@fro.bot/wiki-write-core 0.1.3 → 0.2.0

package/dist/line-scanners.d.ts

@@ -0,0 +1,31 @@
+export interface IndexEntryLine {
+    /** The text between `- [[` and `]]`, not trimmed. */
+    readonly slug: string;
+    /** The whole entry line, from the dash to the end of its text. */
+    readonly line: string;
+}
+/**
+ * Finds the index entry lines `- [[slug]] — description` of an index document, left to right, as
+ * `/^- \[\[([^\]|]+)\]\]\s*—\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/gmu`
+ * does:
+ * - the line starts at the beginning of the text or after a line terminator, with `- [[`;
+ * - the slug is a non-empty run up to the first `]` or `|`, which may cross lines, and `]]` follows it;
+ * - whitespace (newlines included), an em dash, whitespace again;
+ * - then either a non-whitespace character and the rest of its line, or, when only whitespace remains to the end
+ *   of the text, a single non-newline whitespace character that ends its line.
+ *
+ * Each run ends at the first character that cannot continue it, so a run is read once from a table of stop
+ * offsets and each candidate line is decided in constant time. The regex rescans the rest of the text from every
+ * `- [[` line that has no `]]` after it, which is quadratic in the length of the text.
+ */
+export declare function findIndexEntryLines(index: string): IndexEntryLine[];
+/**
+ * The inside of a flow-style `related: [a, b]` line, or `undefined` when the line is not one, as
+ * `/^related:\s*\[(.*)\]\s*(?:#.*)?$/u` does. The inside runs to the last `]` before the line's first terminator
+ * that is followed only by whitespace and an optional `#` comment running to the end of the text.
+ *
+ * The regex tries every `]` from the right and rescans the tail from each, which is quadratic when the tail
+ * stops short of the end of the text (a carriage return inside a `#` comment, say). Here the tail is decided
+ * from two tables of stop offsets in constant time per `]`.
+ */
+export declare function parseRelatedFlow(line: string): string | undefined;

package/dist/line-scanners.js

@@ -0,0 +1,111 @@
+import { buildStopTable, isWhitespaceCode } from "./inline-links.js";
+const NEWLINE = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+const LINE_SEPARATOR = 0x20_28;
+const PARAGRAPH_SEPARATOR = 0x20_29;
+const EM_DASH = 0x20_14;
+const CLOSE_BRACKET = 0x5d;
+const PIPE = 0x7c;
+const HASH = 0x23;
+/** The characters a regex `^`, `$` and `.` treat as line boundaries. */
+function isLineTerminator(code) {
+    return code === NEWLINE || code === CARRIAGE_RETURN || code === LINE_SEPARATOR || code === PARAGRAPH_SEPARATOR;
+}
+/**
+ * The offset just past the last character of `text` that is a whitespace character other than a line terminator
+ * and is followed by a line terminator or the end of the text, or -1 when there is none.
+ */
+function findLastBlankEnd(text) {
+    for (let at = text.length - 1; at >= 0; at -= 1) {
+        const code = text.charCodeAt(at);
+        if (isWhitespaceCode(code) &&
+            !isLineTerminator(code) &&
+            (at + 1 === text.length || isLineTerminator(text.charCodeAt(at + 1)))) {
+            return at + 1;
+        }
+    }
+    return -1;
+}
+/**
+ * Finds the index entry lines `- [[slug]] — description` of an index document, left to right, as
+ * `/^- \[\[([^\]|]+)\]\]\s*—\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/gmu`
+ * does:
+ * - the line starts at the beginning of the text or after a line terminator, with `- [[`;
+ * - the slug is a non-empty run up to the first `]` or `|`, which may cross lines, and `]]` follows it;
+ * - whitespace (newlines included), an em dash, whitespace again;
+ * - then either a non-whitespace character and the rest of its line, or, when only whitespace remains to the end
+ *   of the text, a single non-newline whitespace character that ends its line.
+ *
+ * Each run ends at the first character that cannot continue it, so a run is read once from a table of stop
+ * offsets and each candidate line is decided in constant time. The regex rescans the rest of the text from every
+ * `- [[` line that has no `]]` after it, which is quadratic in the length of the text.
+ */
+export function findIndexEntryLines(index) {
+    const entries = [];
+    const opener = '- [[';
+    if (!index.includes(opener))
+        return entries;
+    const slugStop = buildStopTable(index, code => code === CLOSE_BRACKET || code === PIPE);
+    const nonSpace = buildStopTable(index, code => !isWhitespaceCode(code));
+    const lineEnd = buildStopTable(index, isLineTerminator);
+    let lastBlankEnd;
+    const trailingBlankEnd = () => (lastBlankEnd ??= findLastBlankEnd(index));
+    const entryEndAt = (slugEnd) => {
+        const dash = nonSpace[slugEnd + 2] ?? index.length;
+        if (index.charCodeAt(dash) !== EM_DASH)
+            return -1;
+        const textStart = nonSpace[dash + 1] ?? index.length;
+        if (textStart < index.length)
+            return lineEnd[textStart + 1] ?? index.length;
+        // Only whitespace follows the dash: the entry ends at the last character of the text that is a whitespace
+        // character, not a line terminator, and the last in its line. That character does not depend on the dash,
+        // so it is found once, and an entry exists when it lies after the dash.
+        return trailingBlankEnd() > dash + 1 ? trailingBlankEnd() : -1;
+    };
+    for (let start = index.indexOf(opener); start !== -1;) {
+        const atLineStart = start === 0 || isLineTerminator(index.charCodeAt(start - 1));
+        const slugEnd = slugStop[start + 4] ?? index.length;
+        if (atLineStart && slugEnd > start + 4 && index.startsWith(']]', slugEnd)) {
+            const end = entryEndAt(slugEnd);
+            if (end !== -1) {
+                entries.push({ slug: index.slice(start + 4, slugEnd), line: index.slice(start, end) });
+                start = index.indexOf(opener, end);
+                continue;
+            }
+        }
+        start = index.indexOf(opener, start + 1);
+    }
+    return entries;
+}
+/**
+ * The inside of a flow-style `related: [a, b]` line, or `undefined` when the line is not one, as
+ * `/^related:\s*\[(.*)\]\s*(?:#.*)?$/u` does. The inside runs to the last `]` before the line's first terminator
+ * that is followed only by whitespace and an optional `#` comment running to the end of the text.
+ *
+ * The regex tries every `]` from the right and rescans the tail from each, which is quadratic when the tail
+ * stops short of the end of the text (a carriage return inside a `#` comment, say). Here the tail is decided
+ * from two tables of stop offsets in constant time per `]`.
+ */
+export function parseRelatedFlow(line) {
+    const key = 'related:';
+    if (!line.startsWith(key))
+        return undefined;
+    let bracket = key.length;
+    while (bracket < line.length && isWhitespaceCode(line.charCodeAt(bracket)))
+        bracket += 1;
+    if (line.charAt(bracket) !== '[')
+        return undefined;
+    const lineEnd = buildStopTable(line, isLineTerminator);
+    const nonSpace = buildStopTable(line, code => !isWhitespaceCode(code));
+    const insideStart = bracket + 1;
+    const insideLimit = lineEnd[insideStart] ?? line.length;
+    for (let close = insideLimit - 1; close >= insideStart; close -= 1) {
+        if (line.charCodeAt(close) !== CLOSE_BRACKET)
+            continue;
+        const tail = nonSpace[close + 1] ?? line.length;
+        const tailIsComment = line.charCodeAt(tail) === HASH && (lineEnd[tail + 1] ?? line.length) === line.length;
+        if (tail === line.length || tailIsComment)
+            return line.slice(insideStart, close);
+    }
+    return undefined;
+}

package/dist/link-labels.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One link in `replaceLinkLabels`: the capture groups of a markdown link `[text](target)` or a wiki link
+ * `[[target]]` / `[[target|label]]`. The groups of the branch that did not match are `undefined`.
+ */
+export interface LinkLabelParts {
+    readonly markdownText: string | undefined;
+    readonly wikiTarget: string | undefined;
+    readonly wikiLabel: string | undefined;
+}
+/**
+ * Replaces every markdown link and wiki link in `text` with `render(parts)`, scanning left to right once, as
+ * `text.replaceAll(/!?(?:\[([^\]]*)\]\([^)]*\)|\[\[([^\]|]+)(?:\|([^\]]+))?\]\])/gu, ...)` does. A leading `!`
+ * (an image) is part of the match. The markdown form is tried before the wiki form at each `[`:
+ * - markdown: `[`, any text up to the first `]`, `](`, any run up to the first `)`, and that `)`;
+ * - wiki: `[[`, a non-empty target up to the first `]` or `|`, then either `]]` or `|`, a non-empty label up to
+ *   the first `]`, and `]]`.
+ *
+ * Every run ends at the first character that cannot continue it, so the stop offsets are read from tables built
+ * right to left and each `[` is decided in constant time. The regex form rescans the rest of the text from every
+ * unclosed `[`, which is quadratic in the length of the text.
+ */
+export declare function replaceLinkLabels(text: string, render: (parts: LinkLabelParts) => string): string;

package/dist/link-labels.js

@@ -0,0 +1,71 @@
+import { buildStopTable } from "./inline-links.js";
+const OPEN_BRACKET = '[';
+const CLOSE_BRACKET = ']';
+const OPEN_PAREN = '(';
+const CLOSE_PAREN = ')';
+const PIPE = '|';
+const BANG = '!';
+/**
+ * Replaces every markdown link and wiki link in `text` with `render(parts)`, scanning left to right once, as
+ * `text.replaceAll(/!?(?:\[([^\]]*)\]\([^)]*\)|\[\[([^\]|]+)(?:\|([^\]]+))?\]\])/gu, ...)` does. A leading `!`
+ * (an image) is part of the match. The markdown form is tried before the wiki form at each `[`:
+ * - markdown: `[`, any text up to the first `]`, `](`, any run up to the first `)`, and that `)`;
+ * - wiki: `[[`, a non-empty target up to the first `]` or `|`, then either `]]` or `|`, a non-empty label up to
+ *   the first `]`, and `]]`.
+ *
+ * Every run ends at the first character that cannot continue it, so the stop offsets are read from tables built
+ * right to left and each `[` is decided in constant time. The regex form rescans the rest of the text from every
+ * unclosed `[`, which is quadratic in the length of the text.
+ */
+export function replaceLinkLabels(text, render) {
+    if (!text.includes(OPEN_BRACKET))
+        return text;
+    const closeBracketAt = buildStopTable(text, code => code === 0x5d);
+    const closeParenAt = buildStopTable(text, code => code === 0x29);
+    const closeBracketOrPipeAt = buildStopTable(text, code => code === 0x5d || code === 0x7c);
+    const matchAt = (open) => {
+        const textEnd = closeBracketAt[open + 1] ?? text.length;
+        if (text.charAt(textEnd) === CLOSE_BRACKET && text.charAt(textEnd + 1) === OPEN_PAREN) {
+            const parenEnd = closeParenAt[textEnd + 2] ?? text.length;
+            if (text.charAt(parenEnd) === CLOSE_PAREN) {
+                return {
+                    end: parenEnd + 1,
+                    markdownText: text.slice(open + 1, textEnd),
+                    wikiTarget: undefined,
+                    wikiLabel: undefined,
+                };
+            }
+        }
+        if (text.charAt(open + 1) !== OPEN_BRACKET)
+            return undefined;
+        const targetEnd = closeBracketOrPipeAt[open + 2] ?? text.length;
+        if (targetEnd === open + 2)
+            return undefined;
+        const wikiTarget = text.slice(open + 2, targetEnd);
+        if (text.charAt(targetEnd) === PIPE) {
+            const labelEnd = closeBracketAt[targetEnd + 1] ?? text.length;
+            if (labelEnd > targetEnd + 1 && text.startsWith(']]', labelEnd)) {
+                return { end: labelEnd + 2, markdownText: undefined, wikiTarget, wikiLabel: text.slice(targetEnd + 1, labelEnd) };
+            }
+            return undefined;
+        }
+        return text.startsWith(']]', targetEnd)
+            ? { end: targetEnd + 2, markdownText: undefined, wikiTarget, wikiLabel: undefined }
+            : undefined;
+    };
+    let replaced = '';
+    let copiedTo = 0;
+    for (let open = text.indexOf(OPEN_BRACKET); open !== -1;) {
+        const match = matchAt(open);
+        if (match === undefined) {
+            open = text.indexOf(OPEN_BRACKET, open + 1);
+            continue;
+        }
+        // An image's `!` belongs to the match, unless an earlier match already took it.
+        const start = open > copiedTo && text.charAt(open - 1) === BANG ? open - 1 : open;
+        replaced += text.slice(copiedTo, start) + render(match);
+        copiedTo = match.end;
+        open = text.indexOf(OPEN_BRACKET, match.end);
+    }
+    return replaced + text.slice(copiedTo);
+}

package/dist/markdown-links.js

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join, normalize } from 'node:path';
 import process from 'node:process';
 import { findCodeRegions, findRegionAt } from "./code-regions.js";
-const MARKDOWN_LINK_PATTERN = /\[[^\]\n]+\]\(\s*(<[^>\n]+>|[^)\s]+)(?:\s+(?:"[^"\n]*"|'[^'\n]*'|\([^)\n]*\)))?\s*\)/gu;
+import { createInlineLinkFinder } from "./inline-links.js";
 /** Resolve live relative markdown links and report whether their targets exist. */
 export function resolveMarkdownLinks(content, containingFile, options = {}) {
     const links = [];
@@ -11,12 +11,14 @@ export function resolveMarkdownLinks(content, containingFile, options = {}) {
     for (const [lineIndex, line] of content.split('\n').entries()) {
         const currentLineOffset = lineOffset;
         lineOffset += line.length + 1;
-        // The shared global pattern is stateful; every line restarts it and the loop runs it to exhaustion.
-        MARKDOWN_LINK_PATTERN.lastIndex = 0;
-        for (let match = MARKDOWN_LINK_PATTERN.exec(line); match !== null; match = MARKDOWN_LINK_PATTERN.exec(line)) {
-            const target = match[1];
+        // Each line gets its own finder; the loop asks it for the next link at or after `from`.
+        const findLink = createInlineLinkFinder(line);
+        let from = 0;
+        for (let match = findLink(from); match !== undefined; match = findLink(from)) {
+            const { target } = match;
             const matchIndex = match.index;
-            if (target === undefined || (matchIndex > 0 && line[matchIndex - 1] === '!')) {
+            from = matchIndex + match.length;
+            if (matchIndex > 0 && line[matchIndex - 1] === '!') {
                 continue;
             }
             // Code binds tighter than links, so a match that touches a fence or span is literal text.
@@ -24,14 +26,14 @@ export function resolveMarkdownLinks(content, containingFile, options = {}) {
             // after an unclosed bracket in code. Resume after the region the match opened in, or just
             // past its first character when it only closes inside one.
             const matchStart = currentLineOffset + matchIndex;
-            const matchLast = matchStart + match[0].length - 1;
+            const matchLast = matchStart + match.length - 1;
             const openingRegion = findRegionAt(regions, matchStart);
             if (openingRegion !== undefined) {
-                MARKDOWN_LINK_PATTERN.lastIndex = Math.max(openingRegion.end - currentLineOffset, matchIndex + 1);
+                from = Math.max(openingRegion.end - currentLineOffset, matchIndex + 1);
                 continue;
             }
             if (findRegionAt(regions, matchLast) !== undefined) {
-                MARKDOWN_LINK_PATTERN.lastIndex = matchIndex + 1;
+                from = matchIndex + 1;
                 continue;
             }
             const normalizedTarget = target.startsWith('<') && target.endsWith('>') ? target.slice(1, -1) : target;

package/dist/rendering-policy.js

@@ -1,11 +1,25 @@
-const UNSAFE_TAG_PATTERN = /<\/?\s*(?:script|iframe|object|embed|applet|base|form|input|button|textarea|select|option|meta|link|style|template|svg|math)\b[^>]*>/iu;
-const EVENT_HANDLER_PATTERN = /\s+on[a-z][\w:-]*\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/iu;
-const UNSAFE_URI_PATTERN = /\s+(?:href|src|srcset|action|formaction|xlink:href|poster|background|cite)\s*=\s*(?:"\s*|')?(?:javascript|vbscript|data):/iu;
+// A tag is unsafe when its name opens it and a `>` follows anywhere after the name. The pattern stops at the
+// name and `hasUnsafeTag` looks for the `>`: a `[^>]*>` tail rescans the rest of the text from every opening
+// when there is no `>`, which is quadratic in the length of the text.
+const UNSAFE_TAG_OPENING_PATTERN = /<\/?\s*(?:script|iframe|object|embed|applet|base|form|input|button|textarea|select|option|meta|link|style|template|svg|math)\b/iu;
+// Both attribute patterns start at the first whitespace character of a run: a match that starts inside a run also
+// starts at the run's beginning, and without the lookbehind a long run of whitespace is rescanned from every
+// position in it.
+const EVENT_HANDLER_PATTERN = /(?<!\s)\s+on[a-z][\w:-]*\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/iu;
+const UNSAFE_URI_PATTERN = /(?<!\s)\s+(?:href|src|srcset|action|formaction|xlink:href|poster|background|cite)\s*=\s*(?:"\s*|')?(?:javascript|vbscript|data):/iu;
+/**
+ * True when `text` holds an unsafe tag: an opening `<name` or `</name` from the list, then a `>` after the name.
+ * The first opening ends before any later one, so if it has no `>` after it none does.
+ */
+function hasUnsafeTag(text) {
+    const opening = UNSAFE_TAG_OPENING_PATTERN.exec(text);
+    return opening !== null && text.includes('>', opening.index + opening[0].length);
+}
 /** Return save-side findings for HTML that the render policy will strip. */
 export function validateRenderingPolicy(params) {
     const findings = [];
     const renderableMarkdown = maskCodeContent(params.content);
-    if (UNSAFE_TAG_PATTERN.test(renderableMarkdown) ||
+    if (hasUnsafeTag(renderableMarkdown) ||
         EVENT_HANDLER_PATTERN.test(renderableMarkdown) ||
         UNSAFE_URI_PATTERN.test(renderableMarkdown)) {
         findings.push({

package/dist/repo-page-move.js

@@ -13,7 +13,9 @@
  *   repository URL. The body is never consulted.
  * - `log.md` history and `knowledge/wiki/README.md` are never rewritten.
  */
+import { splitFrontmatterBlock } from "./frontmatter-block.js";
 import { parseFrontmatterDocument, renderFrontmatterDocument } from "./frontmatter.js";
+import { parseRelatedFlow } from "./line-scanners.js";
 import { appendLogEntry, rebuildWikiIndex, validateWikilinks, WikiIngestError } from "./wiki-ingest.js";
 import { buildPrivateNameTokens, computeRepoSlug } from "./wiki-slug.js";
 import { findWikilinkSpans } from "./wiki-utils.js";
@@ -22,7 +24,6 @@ const LOG_PATH = 'knowledge/log.md';
 const REPOS_DIR = 'knowledge/wiki/repos';
 const WIKI_PAGE_PATTERN = /^knowledge\/wiki\/(?:repos|topics|entities|comparisons)\/[^/]+\.md$/u;
 const RELATED_BLOCK_KEY = /^related:\s*(?:#.*)?$/u;
-const RELATED_FLOW = /^related:\s*\[(.*)\]\s*(?:#.*)?$/u;
 /** Apply a change set to a file map, returning a new map. */
 export function applyPageChanges(files, changes) {
     const next = { ...files };
@@ -293,21 +294,21 @@ function repairRelated(content, oldSlug, newSlug) {
 }
 /**
  * Edit only the `related:` lines of the frontmatter text, so the rest of the page keeps its bytes.
- * Returns `undefined` for a layout it does not recognize; the caller then re-renders structurally.
+ * Returns `undefined` for a layout it does not recognize, and for a block with a CRLF line ending anywhere in it,
+ * the closing line included, which the edit would otherwise leave half rewritten; the caller then re-renders structurally.
  */
 function editRelatedText(content, oldSlug, newSlug) {
-    const match = /^---\n([\s\S]+?)\n---\n?/u.exec(content);
-    const frontmatter = match?.[1];
-    if (frontmatter === undefined)
+    const split = splitFrontmatterBlock(content);
+    if (split.kind !== 'block' || hasCrlf(split))
         return undefined;
-    const lines = frontmatter.split('\n');
-    const flowIndex = lines.findIndex(line => RELATED_FLOW.test(line));
+    const lines = split.text.split('\n');
+    const flowIndex = lines.findIndex(line => parseRelatedFlow(line) !== undefined);
     if (flowIndex !== -1) {
-        const inner = RELATED_FLOW.exec(lines[flowIndex] ?? '')?.[1] ?? '';
+        const inner = parseRelatedFlow(lines[flowIndex] ?? '') ?? '';
         const items = inner.split(',').map(item => item.trim());
         const mapped = dedupe(items.map(item => (stripQuotes(item) === oldSlug ? swapQuoted(item, newSlug) : item)));
         lines[flowIndex] = `related: [${mapped.join(', ')}]`;
-        return replaceFrontmatter(content, frontmatter, lines.join('\n'));
+        return rebuild(split, lines.join('\n'));
     }
     const keyIndex = lines.findIndex(line => RELATED_BLOCK_KEY.test(line));
     if (keyIndex === -1)
@@ -327,7 +328,7 @@ function editRelatedText(content, oldSlug, newSlug) {
         kept.push(item.value === oldSlug ? `${item.prefix}${item.quote}${newSlug}${item.quote}${item.suffix}` : line);
     }
     lines.splice(keyIndex + 1, cursor - keyIndex - 1, ...kept);
-    return replaceFrontmatter(content, frontmatter, lines.join('\n'));
+    return rebuild(split, lines.join('\n'));
 }
 /** Parse one `  - value` line of a block sequence without a backtracking regex. */
 function parseBlockItem(line) {
@@ -346,9 +347,16 @@ function parseBlockItem(line) {
     const quoted = raw.length >= 2 && (first === "'" || first === '"') && raw.endsWith(first);
     return { prefix, quote: quoted ? (first ?? '') : '', value: quoted ? raw.slice(1, -1) : raw, suffix };
 }
-function replaceFrontmatter(content, original, next) {
-    const start = '---\n'.length;
-    return `${content.slice(0, start)}${next}${content.slice(start + original.length)}`;
+/** Whether the opening line, the block text, the line before the close or the closing line ends with CRLF. */
+function hasCrlf(block) {
+    return (block.opening.endsWith('\r\n') ||
+        block.textEnding === '\r\n' ||
+        block.text.includes('\r\n') ||
+        block.closing.endsWith('\r\n'));
+}
+/** The page with the block text replaced and every other byte of it kept. */
+function rebuild(block, text) {
+    return block.opening + text + block.textEnding + block.closing + block.body;
 }
 function readRelated(content) {
     try {

package/dist/wiki-ingest.js

@@ -9,6 +9,9 @@ import { assertBranchWritable } from "./branch-safety.js";
 import { verifyCorrectionSurvival } from "./corrections-survival.js";
 import { CorrectionStoreError, readCorrections } from "./corrections.js";
 import { bootstrapDataBranch as defaultBootstrapDataBranch, } from "./data-branch-bootstrap.js";
+import { splitFrontmatterBlock } from "./frontmatter-block.js";
+import { parseFrontmatterDocument } from "./frontmatter.js";
+import { findIndexEntryLines } from "./line-scanners.js";
 import { assertReposFile } from "./schemas.js";
 import { computeRepoSlug } from "./wiki-slug.js";
 import { collectWikilinks } from "./wiki-utils.js";
@@ -630,11 +633,7 @@ function parseIndexEntryLines(index) {
     const entries = new Map();
     // Match the full line: "- [[slug]] — description"
     // Description may contain anything except a newline (we keep the entire trailing text).
-    const pattern = /^- \[\[([^\]|]+)\]\]\s*—\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/gmu;
-    for (const match of index.matchAll(pattern)) {
-        const [line, slug] = match;
-        if (line === undefined || slug === undefined)
-            continue;
+    for (const { slug, line } of findIndexEntryLines(index)) {
         entries.set(slug.trim(), line);
     }
     return entries;
@@ -664,23 +663,16 @@ export function appendLogEntry(existingLog, params) {
     return normalizeText(`${base}\n## [${stamp}] ${logOperation} | ${params.target}\n\n${params.summary}\n\n${sources}\n`);
 }
 function parseFrontmatter(path, content) {
-    const match = /^---\n([\s\S]+?)\n---\n?/u.exec(content);
-    if (match === null) {
+    const split = splitFrontmatterBlock(content);
+    if (split.kind !== 'block') {
         throw new WikiIngestError({
             code: 'INVALID_FRONTMATTER',
             message: `${path} is missing YAML frontmatter`,
             remediation: 'Add frontmatter with type, title, created, and updated fields before ingesting the page.',
         });
     }
-    const frontmatterText = match[1];
-    if (frontmatterText === undefined) {
-        throw new WikiIngestError({
-            code: 'INVALID_FRONTMATTER',
-            message: `${path} frontmatter could not be extracted`,
-            remediation: 'Ensure the page begins with a valid YAML frontmatter block.',
-        });
-    }
-    const parsed = parse(frontmatterText);
+    // Only a block with no lines is an empty mapping. A block of one blank line parses to null, like any blank text.
+    const parsed = split.text === '' && split.textEnding === '' ? {} : parse(split.text);
     if (!isRecord(parsed)) {
         throw new WikiIngestError({
             code: 'INVALID_FRONTMATTER',
@@ -718,6 +710,7 @@ function prepareWikiPage(page, existingFiles, params, deletedPaths, migrations)
     const targetSlug = repoTargetSlug(params.target);
     const trackedNodeId = params.trackedRepoNodeIds?.get(pageSlug);
     const isTargetPage = targetSlug === pageSlug;
+    const stamp = isTargetPage ? buildTargetStamp(params, existingFiles[page.path]) : undefined;
     const identity = resolvePageIdentity({
         trackedNodeId,
         targetNodeId: isTargetPage ? params.targetNodeId : undefined,
@@ -730,7 +723,7 @@ function prepareWikiPage(page, existingFiles, params, deletedPaths, migrations)
             : undefined;
         return {
             path: page.path,
-            content: updateRepoPageFrontmatter(page.content, preserveNodeId),
+            content: updateRepoPageFrontmatter(page.content, preserveNodeId, stamp),
         };
     }
     const nodeMatch = identity.trusted ? findRepoPageByNodeId(existingFiles, identity.nodeId) : undefined;
@@ -750,12 +743,13 @@ function prepareWikiPage(page, existingFiles, params, deletedPaths, migrations)
                 nodeId: identity.nodeId,
                 title: repoTargetTitle(params.target) ?? incomingFrontmatter.title,
                 aliases: [nodeMatch.slug],
+                stamp,
             }),
         };
     }
     return {
         path: page.path,
-        content: updateRepoPageFrontmatter(page.content, identity.nodeId),
+        content: updateRepoPageFrontmatter(page.content, identity.nodeId, stamp),
     };
 }
 function resolvePageIdentity(params) {
@@ -815,17 +809,98 @@ function mergeRepoPageContent(incomingContent, historicalContents, changes) {
             body = body === '' ? historicalBody : `${body}\n\n${historicalBody}`;
         }
     }
+    // The ingest matched the old page to the target by a trusted node ID, so the merged page is the target's.
+    if (changes.stamp !== undefined)
+        addTargetSource(values, changes.stamp);
     return renderFrontmatterDocument(values, body);
 }
-function updateRepoPageFrontmatter(content, nodeId) {
+function updateRepoPageFrontmatter(content, nodeId, stamp) {
     const document = parseFrontmatterDocument(content);
     if (nodeId === undefined)
         delete document.values.node_id;
     else
         document.values.node_id = nodeId;
     delete document.values.database_id;
+    if (stamp !== undefined)
+        stampEmptySources(document.values, stamp);
     return renderFrontmatterDocument(document.values, document.body);
 }
+function buildTargetStamp(params, existingContent) {
+    const parts = repoTargetParts(params.target);
+    // Only a target whose owner and name are plain GitHub names is listed on its page. Anything else is written
+    // without a stamp, as before, and never makes the ingest throw.
+    if (parts === undefined || !isPlainGitHubName(parts.owner) || !isPlainGitHubName(parts.name))
+        return undefined;
+    return {
+        owner: parts.owner,
+        name: parts.name,
+        url: `https://github.com/${parts.owner}/${parts.name}`,
+        accessed: params.timestamp.toISOString().slice(0, 10),
+        existingContent,
+    };
+}
+/** A GitHub owner or repository name: ASCII letters, digits, `.`, `_` and `-`, and not `.` or `..`. */
+function isPlainGitHubName(value) {
+    return value !== '.' && value !== '..' && /^[\w.-]+$/u.test(value);
+}
+/**
+ * Lists the target on its own page when the page lists no sources: no `sources` key, or an empty list. A page that
+ * lists any source is never changed, and neither is a `sources` value that is not a list. When the page on the
+ * branch already lists the target, the whole `sources` list it has is carried over as it is, dates and other
+ * entries included, so a repeat write changes nothing. Otherwise the page gets the one new entry.
+ */
+function stampEmptySources(values, stamp) {
+    const sources = values.sources;
+    if (sources !== undefined && !Array.isArray(sources))
+        return;
+    if (sources !== undefined && sources.length > 0)
+        return;
+    values.sources = findExistingSourcesWithTarget(stamp) ?? [{ url: stamp.url, accessed: stamp.accessed }];
+}
+/** Adds the target to a migrated page's sources when no entry matches it, keeping every other entry. */
+function addTargetSource(values, stamp) {
+    const sources = values.sources;
+    if (sources !== undefined && !Array.isArray(sources))
+        return;
+    const listed = sources ?? [];
+    if (listed.some(entry => sourceMatchesTarget(entry, stamp)))
+        return;
+    values.sources = [...listed, { url: stamp.url, accessed: stamp.accessed }];
+}
+/** The `sources` list of the page on the branch, when it has an entry for the target. */
+function findExistingSourcesWithTarget(stamp) {
+    if (stamp.existingContent === undefined)
+        return undefined;
+    try {
+        const sources = parseFrontmatterDocument(stamp.existingContent).values.sources;
+        return Array.isArray(sources) && sources.some(entry => sourceMatchesTarget(entry, stamp)) ? sources : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sourceMatchesTarget(entry, stamp) {
+    return isRecord(entry) && typeof entry.url === 'string' && sourceUrlMatchesRepo(entry.url, stamp.owner, stamp.name);
+}
+/**
+ * Whether `sourceUrl` refers to the repository `owner`/`name` on github.com by the rule the privacy gate applies to
+ * a page's sources (`sourceUrlMatchesRepo` in `check-wiki-private-presence.ts`): `https`, host `github.com`, no
+ * port, owner and name equal without case, and any path after them. This package cannot import the gate, so the
+ * rule is copied and a test pins the copy against the gate's own cases.
+ */
+function sourceUrlMatchesRepo(sourceUrl, owner, name) {
+    let parsed;
+    try {
+        parsed = new URL(sourceUrl);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== 'https:' || parsed.hostname !== 'github.com' || parsed.port !== '')
+        return false;
+    const segments = parsed.pathname.split('/').filter(segment => segment.length > 0);
+    return segments[0]?.toLowerCase() === owner.toLowerCase() && segments[1]?.toLowerCase() === name.toLowerCase();
+}
 function getExistingRepoNodeId(content, path) {
     if (content === undefined)
         return undefined;
@@ -862,16 +937,6 @@ function mergeFrontmatterArray(records, key) {
     }
     return values;
 }
-function parseFrontmatterDocument(content) {
-    const match = /^---\n([\s\S]+?)\n---\n?/u.exec(content);
-    if (match === null || match[1] === undefined) {
-        throw new Error('validated wiki page is missing frontmatter');
-    }
-    const parsed = parse(match[1]);
-    if (!isRecord(parsed))
-        throw new Error('validated wiki page frontmatter is not an object');
-    return { values: parsed, body: content.slice(match[0].length) };
-}
 function isRepoPagePath(path) {
     return path.startsWith(`${WIKI_ROOT}/repos/`) && path.endsWith('.md');
 }

package/dist/wiki-utils.d.ts

@@ -20,8 +20,8 @@ export interface SplitFrontmatterResult {
 /**
  * Split raw wiki page content into frontmatter and body.
  *
- * Stricter than a naive split: malformed YAML frontmatter is surfaced via `error`
- * rather than silently discarded, so downstream safety/lint logic can observe it.
+ * Stricter than a naive split: malformed YAML frontmatter, and a block that is opened and never closed, are
+ * surfaced via `error` rather than silently discarded, so downstream safety/lint logic can observe them.
  */
 export declare function splitFrontmatter(content: string): SplitFrontmatterResult;
 /** Collect `[[target]]` and `[[target|label]]` wikilink targets from page body content. */