lens-content-processor 0.28.0 → 0.33.0

package/dist/validator/article-structure.js

@@ -0,0 +1,674 @@
+import { toString } from "mdast-util-to-string";
+import remarkDirective from "remark-directive";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import { stripAuthoringMarkupForValidation } from "../authoring-markup.js";
+import { parseFrontmatter } from "../parser/frontmatter.js";
+import { applyNextLineValidatorSuppressions, formatValidatorSuppression, VALIDATOR_SUPPRESSIONS, validatorSuppressionsForCode, } from "./suppressions.js";
+const lowResolutionSuppression = VALIDATOR_SUPPRESSIONS.imageLowResolutionAiSearchExhausted;
+const lowResolutionSuppressionGuidance = validatorSuppressionsForCode(lowResolutionSuppression.code).map((definition) => `${definition.explanation} Use: ${formatValidatorSuppression(definition)}`).join(" ");
+const repeatedBlockSuppressionGuidance = validatorSuppressionsForCode("article.block-repeated-nearby").map((definition) => `${definition.explanation} Use: ${formatValidatorSuppression(definition)}`).join(" ");
+const externalSelfFragmentSuppression = VALIDATOR_SUPPRESSIONS.externalSelfFragmentTargetsSourceOnlyContent;
+function issue(file, bodyStartLine, code, severity, message, line, suggestion) {
+    return {
+        file,
+        line: bodyStartLine + line - 1,
+        code,
+        severity,
+        message,
+        ...(suggestion ? { suggestion } : {}),
+    };
+}
+function renderedHeadingId(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .slice(0, 50);
+}
+function lineAt(source, offset) {
+    return source.slice(0, offset).split("\n").length;
+}
+/** Mask fenced/inline code and math without changing offsets or line numbers. */
+function proseMask(source) {
+    const chars = source.split("");
+    const mask = (start, end) => {
+        for (let i = start; i < end; i += 1)
+            if (chars[i] !== "\n")
+                chars[i] = " ";
+    };
+    const ranges = [];
+    const tree = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkDirective)
+        .use(remarkMath, { singleDollarTextMath: false })
+        .parse(source);
+    visit(tree, (node) => {
+        if (["code", "inlineCode", "math", "inlineMath"].includes(node.type)) {
+            const positioned = node;
+            const start = positioned.position?.start.offset;
+            const end = positioned.position?.end.offset;
+            if (start !== undefined && end !== undefined)
+                ranges.push([start, end]);
+        }
+    });
+    for (const [start, end] of ranges)
+        mask(start, end);
+    // The frontend deliberately recognises conservative single-dollar inline
+    // math after remark-math. Mirror that pass so valid TeX is not examined as
+    // prose while currency remains ordinary text.
+    const inlineMath = /(?<!\$)\$(?!\$)([^\s$](?:[^$\n]*?[^\s$])?)\$(?![\d$])/g;
+    const astMasked = chars.join("");
+    for (const match of astMasked.matchAll(inlineMath)) {
+        const start = match.index ?? 0;
+        mask(start, start + match[0].length);
+    }
+    return chars.join("");
+}
+/** Mask selected AST nodes in an already offset-preserving source string. */
+function maskNodes(source, tree, nodeTypes) {
+    const chars = source.split("");
+    visit(tree, (node) => {
+        if (!nodeTypes.has(node.type))
+            return;
+        const positioned = node;
+        const start = positioned.position?.start.offset;
+        const end = positioned.position?.end.offset;
+        if (start === undefined || end === undefined)
+            return;
+        for (let offset = start; offset < end; offset += 1) {
+            if (chars[offset] !== "\n")
+                chars[offset] = " ";
+        }
+    });
+    return chars.join("");
+}
+function escapedAt(source, index) {
+    let slashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+        slashes += 1;
+    }
+    return slashes % 2 === 1;
+}
+function sameSourceFragment(targetUrl, sourceUrl) {
+    if (typeof sourceUrl !== "string" || !sourceUrl.trim())
+        return undefined;
+    try {
+        const target = new URL(targetUrl);
+        const source = new URL(sourceUrl);
+        const normalizedPath = (url) => url.pathname.replace(/\/+$/, "") || "/";
+        if (target.origin !== source.origin ||
+            normalizedPath(target) !== normalizedPath(source) ||
+            target.search !== source.search ||
+            !target.hash) {
+            return undefined;
+        }
+        const fragment = decodeURIComponent(target.hash.slice(1));
+        return fragment || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Vike page directories plus stable content routes accepted by the SPA. Keep
+// this explicit: treating every root-relative URL as local would hide the
+// source-site-relative import failures this rule exists to catch.
+const PLATFORM_LOCAL_ROUTE = /^\/(?:about|admin|ai-doc|availability|coach|coefficient-giving-proposal|content|courses?|enroll|facilitator|funnel-prototype|if-anyone-builds-it-everyone-dies|lenses?|meetings|modules?|navigate|navigators|onboarding|ops|overview|privacy|progress|promptlab|referrals|reschedule|settings|skill-tree|subscribe|terms|theory-of-change|tts-test|validate)(?:\/|$)/i;
+function isUnsupportedRootRelativeLink(url) {
+    return /^\/(?!\/)/.test(url) && url !== "/" && !PLATFORM_LOCAL_ROUTE.test(url);
+}
+const FLATTENED_MATH_TOKEN = /(?<!\\)\b(?:pi|mu|theta|phi|lambda|gamma|tilde|times|infinity|RR|sum|dot)(?=_|\b)|->/g;
+const TYPED_FOOTNOTE_ID = /^(?:cite|note)-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function hasSuspiciousFlattenedMath(tex, displayMode) {
+    const inspectable = tex.replace(/\\(?:text|textrm|textsf|texttt|mathrm|mathbf|operatorname)\{[^{}]*\}/g, "");
+    // These converter spellings are unambiguous even in short inline math.
+    if (/[_^]\s*\(/.test(inspectable) || /(?<!\\)\bdot\.c\b/.test(inspectable)) {
+        return true;
+    }
+    // Display math is almost never the right place for prose quotes or an
+    // unescaped conditional/probability separator. Keep these checks out of
+    // inline math, where absolute values and short quoted labels are plausible.
+    if (displayMode &&
+        (/["“”][^"“”\n]+["“”]/.test(inspectable) || /\s\|\s/.test(inspectable))) {
+        return true;
+    }
+    const tokens = [...inspectable.matchAll(FLATTENED_MATH_TOKEN)];
+    if (tokens.length >= 2)
+        return true;
+    if (tokens.length === 0)
+        return false;
+    if (displayMode &&
+        /(?<!\\)\b(?:pi|mu|theta|phi|lambda|gamma)\b/.test(inspectable)) {
+        return true;
+    }
+    return /->|\b(?:tilde|times|infinity|RR)\b|\bsum_|\bdot\.|[:=]/.test(inspectable);
+}
+export function collectArticleImages(body, bodyStartLine) {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(body);
+    const definitions = new Map();
+    const images = [];
+    visit(tree, "definition", (node) => { definitions.set(node.identifier.toLowerCase(), node.url); });
+    visit(tree, (node) => {
+        if (node.type === "image")
+            images.push({ url: node.url, line: bodyStartLine + (node.position?.start.line ?? 1) - 1 });
+        if (node.type === "imageReference") {
+            const url = definitions.get(node.identifier.toLowerCase());
+            if (url)
+                images.push({ url, line: bodyStartLine + (node.position?.start.line ?? 1) - 1 });
+        }
+    });
+    return images;
+}
+export function validateWikilinkImages(body, file, bodyStartLine) {
+    const source = proseMask(body);
+    return [...source.matchAll(/!\[\[([^\n\]]+)\]\]/g)].map((match) => issue(file, bodyStartLine, "article.wikilink-image-unsupported", "error", `Wiki-link image not supported: ![[${match[1]}]]`, lineAt(source, match.index ?? 0), "Use standard markdown image syntax: ![alt](url)"));
+}
+function scanFences(body, file, bodyStartLine) {
+    const errors = [];
+    let open;
+    body.split("\n").forEach((line, index) => {
+        const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+        if (!match)
+            return;
+        const char = match[1][0];
+        if (!open) {
+            open = { char, length: match[1].length, line: index + 1 };
+        }
+        else if (open.char === char && match[1].length >= open.length && match[2].trim() === "") {
+            open = undefined;
+        }
+    });
+    if (open) {
+        errors.push(issue(file, bodyStartLine, "article.unclosed-fence", "error", `Unclosed ${open.char === "`" ? "backtick" : "tilde"} code fence`, open.line, "Add a compatible closing fence."));
+    }
+    return errors;
+}
+function splitTableRow(line) {
+    const cells = [];
+    let current = "";
+    let escaped = false;
+    let codeTicks = 0;
+    for (const char of line.trim().replace(/^\|/, "").replace(/\|$/, "")) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === "`")
+            codeTicks ^= 1;
+        if (char === "|" && !codeTicks) {
+            cells.push(current.trim());
+            current = "";
+        }
+        else
+            current += char;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function scanTables(body, file, bodyStartLine) {
+    const errors = [];
+    const lines = body.split("\n");
+    for (let i = 1; i < lines.length; i += 1) {
+        if (!/^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(lines[i]))
+            continue;
+        const expected = splitTableRow(lines[i - 1]).length;
+        if (splitTableRow(lines[i]).length !== expected) {
+            errors.push(issue(file, bodyStartLine, "article.table-malformed", "error", "Table delimiter does not match its header", i + 1));
+            continue;
+        }
+        for (let row = i + 1; row < lines.length && lines[row].includes("|") && lines[row].trim(); row += 1) {
+            if (splitTableRow(lines[row]).length !== expected) {
+                errors.push(issue(file, bodyStartLine, "article.table-malformed", "error", `Table row has ${splitTableRow(lines[row]).length} cells; expected ${expected}`, row + 1, "Add or remove cells so every row matches the header."));
+            }
+        }
+    }
+    return errors;
+}
+function normalizedBlock(node, body) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === undefined || end === undefined)
+        return "";
+    const normalized = body.slice(start, end).replace(/\s+/g, " ").trim();
+    // TeX identifiers are case-sensitive: N_1 and n_1 can denote different
+    // variables in otherwise parallel propositions. Preserve case for math so
+    // the duplicate check still catches exact copies without conflating them.
+    return /^\$\$[\s\S]*\$\$$/.test(normalized) ? normalized : normalized.toLowerCase();
+}
+function isSectionBoilerplate(value) {
+    return /^applicability to different subgoals in our verification framework:$/i.test(value);
+}
+function isEmojiJoiner(source, index) {
+    if (source[index] !== "\u200d")
+        return false;
+    const before = Array.from(source.slice(0, index));
+    // Emoji modifiers and variation selectors extend the preceding pictograph.
+    while (before.length && /^(?:\p{Emoji_Modifier}|[\uFE00-\uFE0F\u{E0100}-\u{E01EF}])$/u.test(before.at(-1) ?? ""))
+        before.pop();
+    const previous = before.at(-1) ?? "";
+    const next = Array.from(source.slice(index + 1))[0] ?? "";
+    return /^\p{Extended_Pictographic}$/u.test(previous) && /^\p{Extended_Pictographic}$/u.test(next);
+}
+function isAttributionParagraph(node) {
+    if (node.type !== "paragraph")
+        return false;
+    const text = toString(node).trim();
+    return (text.length <= 240 &&
+        /^\(?\s*(?:joint work|co-?authored|written) with\b/i.test(text));
+}
+const LEGITIMATE_REPEATED_ANNOTATIONS = new Set([
+    "_note_: included here for completeness. this isn't, strictly speaking, a new cause area since allfed is now working on it.",
+]);
+function isLegitimateRepeatedAnnotation(value) {
+    return LEGITIMATE_REPEATED_ANNOTATIONS.has(value);
+}
+/** Structural validation for a complete article draft. Parsing happens once. */
+export function validateArticleStructure(content, file) {
+    const fm = parseFrontmatter(content.replace(/\r\n?/g, "\n"), file);
+    if (fm.error)
+        return [];
+    const rawBody = fm.body;
+    const body = stripAuthoringMarkupForValidation(fm.body);
+    const bodyStartLine = fm.bodyStartLine;
+    const sourceUrl = fm.frontmatter.source_url;
+    const errors = [...scanFences(body, file, bodyStartLine)];
+    const tree = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkDirective)
+        .use(remarkMath, { singleDollarTextMath: false })
+        .parse(body);
+    const prose = proseMask(body);
+    const inlineMathScanSource = maskNodes(body, tree, new Set(["code", "inlineCode", "math", "image", "imageReference"]));
+    const definitions = new Map();
+    const referencedFootnotes = new Map();
+    const definedFootnotes = new Map();
+    const headingIds = new Set();
+    const imageOccurrences = new Map();
+    const externalSelfFragments = new Set();
+    const blocks = [];
+    // Lens uses ordinary GFM footnotes with semantic identifiers. The prefix
+    // drives distinct citation/note rendering; kebab-case suffixes stay stable
+    // when definitions are reordered or new references are inserted.
+    const invalidFootnoteIds = new Set();
+    for (const match of prose.matchAll(/\[\^([^\]\n]+)\](?::)?/g)) {
+        const id = match[1];
+        if (TYPED_FOOTNOTE_ID.test(id) || invalidFootnoteIds.has(id))
+            continue;
+        invalidFootnoteIds.add(id);
+        errors.push(issue(file, bodyStartLine, "article.footnote-id-invalid", "error", `Footnote identifier '${id}' is not a typed kebab-case identifier`, lineAt(prose, match.index ?? 0), "Use [^note-<id>] for explanatory footnotes and [^cite-<id>] for citations; Lens renders the two differently. <id> may be any unique lowercase kebab-case identifier within this file. Rename every reference and its matching definition together."));
+    }
+    visit(tree, "definition", (node) => {
+        definitions.set(node.identifier.toLowerCase(), node.url);
+    });
+    // ArticleSectionWrapper pre-registers H1-H3 IDs for the table of contents.
+    // Duplicate lower-level headings fall back to their unsuffixed slug unless
+    // their exact text is also registered. Mirror that behavior here rather
+    // than applying GitHub-style suffixes to every heading.
+    const registeredHeadingIds = new Map();
+    const registeredBaseCounts = new Map();
+    visit(tree, "heading", (node) => {
+        if (node.depth > 3)
+            return;
+        const text = toString(node);
+        const base = renderedHeadingId(text);
+        const count = registeredBaseCounts.get(base) ?? 0;
+        const ids = registeredHeadingIds.get(text) ?? [];
+        ids.push(count === 0 ? base : `${base}-${count}`);
+        registeredHeadingIds.set(text, ids);
+        registeredBaseCounts.set(base, count + 1);
+    });
+    const renderedTextCounts = new Map();
+    visit(tree, "heading", (node) => {
+        const text = toString(node);
+        const registered = registeredHeadingIds.get(text);
+        if (!registered?.length) {
+            headingIds.add(renderedHeadingId(text));
+            return;
+        }
+        const count = renderedTextCounts.get(text) ?? 0;
+        headingIds.add(registered[count] ?? registered[registered.length - 1]);
+        renderedTextCounts.set(text, count + 1);
+    });
+    visit(tree, "footnoteReference", (node) => {
+        referencedFootnotes.set(node.identifier.toLowerCase(), node.position?.start.line ?? 1);
+    });
+    visit(tree, "footnoteDefinition", (node) => {
+        const id = node.identifier.toLowerCase();
+        definedFootnotes.set(id, [...(definedFootnotes.get(id) ?? []), node.position?.start.line ?? 1]);
+        if (id.startsWith("cite-") &&
+            /^https?:\/\/\S+$/i.test(toString(node).trim())) {
+            errors.push(issue(file, bodyStartLine, "article.citation-definition-url-only", "warning", `Citation '${id}' contains only a URL`, node.position?.start.line ?? 1, "Include the available author, title, year, or publication details while preserving the source link."));
+        }
+    });
+    visit(tree, (node, index, parent) => {
+        const positioned = node;
+        const line = positioned.position?.start.line ?? 1;
+        // Raw HTML is handled by validateHtmlTags, which shares the renderer's
+        // allow-list for sup/sub/audio/SVG rather than rejecting every html node.
+        if (node.type === "link" || node.type === "image") {
+            const target = node;
+            const isImage = node.type === "image";
+            if (!target.url.trim()) {
+                errors.push(issue(file, bodyStartLine, isImage ? "article.image-destination-empty" : "article.link-destination-empty", "error", `${isImage ? "Image" : "Link"} destination is empty`, line));
+            }
+            if (!isImage && isUnsupportedRootRelativeLink(target.url.trim())) {
+                errors.push(issue(file, bodyStartLine, "article.root-relative-source-link", "error", `Root-relative link '${target.url}' resolves against Lens instead of the source website`, line, "Resolve the destination against source_url and use the resulting absolute URL."));
+            }
+            const linkHasImage = !isImage &&
+                target.children.some((child) => child.type === "image" || child.type === "imageReference");
+            const imageOnlyChild = !isImage &&
+                target.children.length === 1 &&
+                (target.children[0].type === "image" ||
+                    target.children[0].type === "imageReference")
+                ? target.children[0]
+                : undefined;
+            if (imageOnlyChild) {
+                const imageUrl = imageOnlyChild.type === "image"
+                    ? imageOnlyChild.url
+                    : imageOnlyChild.type === "imageReference"
+                        ? definitions.get(imageOnlyChild.identifier.toLowerCase())
+                        : undefined;
+                if (imageUrl && imageUrl.trim() === target.url.trim()) {
+                    errors.push(issue(file, bodyStartLine, "article.image-link-wrapper-redundant", "warning", "Image is wrapped in a redundant link to the same URL", line, "Remove the outer link and keep the standard Markdown image."));
+                }
+                else {
+                    errors.push(issue(file, bodyStartLine, "article.image-link-target-discarded", "error", `Image-only link destination '${target.url}' is discarded by the Lens renderer`, line, "Remove the outer link and add a labeled text link, or use the destination as the image URL when it is the intended full-resolution image."));
+                }
+            }
+            if (!isImage && !linkHasImage && !toString(node).trim()) {
+                errors.push(issue(file, bodyStartLine, "article.link-label-empty", "error", "Link has no visible label", line));
+            }
+            if (!isImage) {
+                const sourceFragment = sameSourceFragment(target.url, sourceUrl);
+                if (sourceFragment &&
+                    !externalSelfFragments.has(sourceFragment)) {
+                    externalSelfFragments.add(sourceFragment);
+                    errors.push(issue(file, bodyStartLine, "article.external-self-fragment", "warning", `Link '#${sourceFragment}' points back to this article's source page`, line, `Use a native Markdown footnote for a note, or a local #fragment link for content imported into this article. If this deliberately targets source-only content that was not imported, place this exemption immediately above the link: ${formatValidatorSuppression(externalSelfFragmentSuppression)}`));
+                }
+            }
+            const start = positioned.position?.start.offset;
+            const end = positioned.position?.end.offset;
+            if (start !== undefined && end !== undefined && !isImage) {
+                const before = body[start - 1] ?? "";
+                const after = body[end] ?? "";
+                const label = toString(node);
+                const siblings = parent && "children" in parent ? parent.children : [];
+                const previous = index === undefined || index === null ? undefined : siblings[index - 1];
+                const next = index === undefined || index === null ? undefined : siblings[index + 1];
+                const adjacentTypes = new Set([
+                    "link",
+                    "linkReference",
+                    "image",
+                    "imageReference",
+                    "footnoteReference",
+                ]);
+                const structuredBefore = previous !== undefined &&
+                    adjacentTypes.has(previous.type) &&
+                    previous.position?.end.offset === start;
+                const structuredAfter = next !== undefined &&
+                    adjacentTypes.has(next.type) &&
+                    next.position?.start.offset === end;
+                const touchesWord = /[\p{L}\p{N}]/u.test(before) || /[\p{L}\p{N}]/u.test(after);
+                const bracketWrapped = before === "[" && after === "]";
+                const touchesUnescapedBracket = !bracketWrapped &&
+                    ((/\[|\]/.test(before) &&
+                        !structuredBefore &&
+                        !escapedAt(body, start - 1)) ||
+                        (/\[|\]/.test(after) &&
+                            !structuredAfter &&
+                            !escapedAt(body, end)));
+                if (touchesUnescapedBracket) {
+                    errors.push(issue(file, bodyStartLine, "article.inline-boundary-malformed", "error", "Markdown link touches a stray bracket", line, "Remove the unmatched bracket or complete the intended bracketed citation."));
+                }
+                else {
+                    const citationLabel = /^\[?(?:\d+(?:[.,–-]\d+)*%?|[†‡*]+)\]?$/u.test(label.trim());
+                    // Preserve source-page citation/backreference badges when an import
+                    // intentionally attaches them to prose. A single-letter label is
+                    // otherwise ambiguous (for example, `[a](url)word`), so only treat
+                    // it as a marker when its destination is a known citation anchor.
+                    const sourceCitationMarker = /#(?:cite_(?:note|ref)-|ftnt\d+)/i.test(target.url) &&
+                        /^\[?(?:[a-z]|[†‡*§¶]+)\]?$/iu.test(label.trim());
+                    const suppliesVisualSpace = /^\s|\s$/u.test(label);
+                    if (touchesWord &&
+                        !citationLabel &&
+                        !sourceCitationMarker &&
+                        !suppliesVisualSpace) {
+                        errors.push(issue(file, bodyStartLine, "article.inline-boundary-malformed", "warning", "Markdown link touches an adjacent word", line, "Check whether the joined text is intentional; otherwise add whitespace or punctuation."));
+                    }
+                }
+            }
+            if (isImage) {
+                const image = target;
+                const alt = image.alt?.trim() ?? "";
+                if (alt && /^(?:image|figure|photo)(?:\s*\d+)?[.:]?$/i.test(alt))
+                    errors.push(issue(file, bodyStartLine, "article.image-alt-generic", "warning", `Image alt text '${alt}' is generic`, line, "Remove the alt text by leaving the image brackets empty: ![](image-url)."));
+                if (/^\/attachments\//i.test(image.url))
+                    errors.push(issue(file, bodyStartLine, "article.attachment-url-unservable", "error", "Image uses the unsupported /attachments/ route", line));
+                if (/(?:-\d{2,3}x\d{2,3}(?=\.[a-z]+(?:\?|$))|(?:^|\/)\d{2,3}x\d{2,3}(?=\/|$)|[?&,/]w[_=]\d{2,3}(?:[&,/]|$))/i.test(image.url)) {
+                    errors.push(issue(file, bodyStartLine, lowResolutionSuppression.code, "error", "Image URL requests a low-resolution derivative", line, `Use the highest-resolution image from the original webpage. If none can be found, place one of these audited exemptions immediately above the image: ${lowResolutionSuppressionGuidance}`));
+                }
+                const seen = imageOccurrences.get(image.url) ?? [];
+                if (seen.some((previous) => line - previous <= 30))
+                    errors.push(issue(file, bodyStartLine, "article.image-repeated-nearby", "warning", "The same image URL is repeated nearby", line));
+                seen.push(line);
+                imageOccurrences.set(image.url, seen);
+            }
+        }
+        if (node.type === "linkReference" || node.type === "imageReference") {
+            const id = node.identifier.toLowerCase();
+            if (!definitions.has(id))
+                errors.push(issue(file, bodyStartLine, node.type === "imageReference" ? "article.image-destination-empty" : "article.reference-target-undefined", "error", `Reference target '${id}' is not defined`, line));
+            const referencedUrl = definitions.get(id);
+            if (node.type === "linkReference" &&
+                referencedUrl !== undefined &&
+                isUnsupportedRootRelativeLink(referencedUrl)) {
+                errors.push(issue(file, bodyStartLine, "article.root-relative-source-link", "error", `Root-relative link '${referencedUrl}' resolves against Lens instead of the source website`, line, "Resolve the destination against source_url and use the resulting absolute URL."));
+            }
+        }
+        const mathStart = positioned.position?.start.offset;
+        const mathEnd = positioned.position?.end.offset;
+        const rawMath = mathStart === undefined || mathEnd === undefined
+            ? ""
+            : body.slice(mathStart, mathEnd);
+        const wellDelimitedDisplay = node.type !== "math" ||
+            (rawMath.split("\n")[0]?.trim() === "$$" &&
+                rawMath.split("\n").at(-1)?.trim() === "$$" &&
+                !rawMath.slice(2, -2).includes("$$") &&
+                !/\n[ \t]*\n/.test(rawMath));
+        if ((node.type === "math" || node.type === "inlineMath") &&
+            wellDelimitedDisplay &&
+            hasSuspiciousFlattenedMath(String(node.value ?? ""), node.type === "math")) {
+            errors.push(issue(file, bodyStartLine, "article.math-token-flattened", "warning", "Math contains tokens that look flattened by a converter", line, "Compare the expression with the source and restore the intended TeX commands."));
+        }
+        // Undefined references degrade to plain text in mdast. Inspect text nodes
+        // rather than the raw source so URL query parameters are never mistaken
+        // for reference-style Markdown.
+        if (node.type === "text") {
+            const baseLine = node.position?.start.line ?? 1;
+            for (const match of node.value.matchAll(/(?<!!)\[([^\]\n]+)\]\[([^\]\n]*)\]/g)) {
+                if (match[1].startsWith("^"))
+                    continue;
+                const id = (match[2] || match[1]).trim().toLowerCase();
+                if (id && !definitions.has(id))
+                    errors.push(issue(file, bodyStartLine, "article.reference-target-undefined", "error", `Reference target '${id}' is not defined`, baseLine + lineAt(node.value, match.index ?? 0) - 1));
+            }
+            for (const match of node.value.matchAll(/!\[([^\]\n]*)\]\[([^\]\n]*)\]/g)) {
+                const id = (match[2] || match[1]).trim().toLowerCase();
+                if (id && !definitions.has(id))
+                    errors.push(issue(file, bodyStartLine, "article.image-destination-empty", "error", `Image reference target '${id}' is not defined`, baseLine + lineAt(node.value, match.index ?? 0) - 1));
+            }
+        }
+        if (["paragraph", "table", "image"].includes(node.type) && parent?.type === "root") {
+            const value = normalizedBlock(positioned, body);
+            if (!/^>/.test(value))
+                blocks.push({
+                    node: positioned,
+                    value,
+                    line,
+                    substantial: value.length >= 80 || node.type === "table" || node.type === "image",
+                    attribution: isAttributionParagraph(positioned),
+                });
+        }
+    });
+    // The renderer's conservative single-dollar pass is intentionally outside
+    // remark-math, so inspect those expressions separately for flattened TeX.
+    for (const match of inlineMathScanSource.matchAll(/(?<!\$)\$(?!\$)([^\s$](?:[^$\n]*?[^\s$])?)\$(?![\d$])/g)) {
+        if (!hasSuspiciousFlattenedMath(match[1], false))
+            continue;
+        errors.push(issue(file, bodyStartLine, "article.math-token-flattened", "warning", "Math contains tokens that look flattened by a converter", lineAt(inlineMathScanSource, match.index ?? 0), "Compare the expression with the source and restore the intended TeX commands."));
+    }
+    for (const [id, line] of referencedFootnotes)
+        if (!definedFootnotes.has(id))
+            errors.push(issue(file, bodyStartLine, "article.footnote-missing-definition", "error", `Footnote '${id}' is referenced but never defined`, line));
+    for (const [id, lines] of definedFootnotes) {
+        if (lines.length > 1)
+            errors.push(issue(file, bodyStartLine, "article.footnote-duplicate-definition", "error", `Footnote '${id}' is defined more than once`, lines[1]));
+        if (!referencedFootnotes.has(id))
+            errors.push(issue(file, bodyStartLine, "article.footnote-unused-definition", "warning", `Footnote '${id}' is defined but never referenced`, lines[0]));
+    }
+    const rawFootnoteDefinitions = new Map();
+    for (const match of prose.matchAll(/^\[\^([^\]]+)\]:/gm)) {
+        const id = match[1].toLowerCase();
+        rawFootnoteDefinitions.set(id, [...(rawFootnoteDefinitions.get(id) ?? []), lineAt(prose, match.index ?? 0)]);
+    }
+    for (const [id, lines] of rawFootnoteDefinitions)
+        if (lines.length > 1 && (definedFootnotes.get(id)?.length ?? 0) < 2)
+            errors.push(issue(file, bodyStartLine, "article.footnote-duplicate-definition", "error", `Footnote '${id}' is defined more than once`, lines[1]));
+    for (const match of prose.matchAll(/\[\^([^\]\n]+)\](?!:)/g)) {
+        const id = match[1].toLowerCase();
+        if (!rawFootnoteDefinitions.has(id))
+            errors.push(issue(file, bodyStartLine, "article.footnote-missing-definition", "error", `Footnote '${id}' is referenced but never defined`, lineAt(prose, match.index ?? 0)));
+    }
+    for (let i = 1; i < blocks.length; i += 1) {
+        if (!blocks[i].substantial || blocks[i].value !== blocks[i - 1].value)
+            continue;
+        errors.push(issue(file, bodyStartLine, "article.adjacent-block-duplicate", "error", "A substantial content block is repeated immediately", blocks[i].line));
+    }
+    for (let i = 0; i < blocks.length; i += 1)
+        for (let j = i + 2; j < Math.min(blocks.length, i + 8); j += 1) {
+            if (blocks[i].substantial &&
+                blocks[i].value === blocks[j].value &&
+                !(blocks[i].attribution && blocks[j].attribution) &&
+                !isLegitimateRepeatedAnnotation(blocks[i].value)) {
+                const repeatedUnderBoilerplate = i > 0 &&
+                    j > 0 &&
+                    blocks[i - 1].value === blocks[j - 1].value &&
+                    isSectionBoilerplate(blocks[i - 1].value);
+                if (repeatedUnderBoilerplate)
+                    continue;
+                errors.push(issue(file, bodyStartLine, "article.block-repeated-nearby", "warning", "A substantial content block is repeated nearby", blocks[j].line, repeatedBlockSuppressionGuidance));
+                break;
+            }
+        }
+    for (let i = 0; i + 1 < blocks.length; i += 1)
+        for (let j = i + 3; j + 1 < Math.min(blocks.length, i + 9); j += 1) {
+            const first = `${blocks[i].value}\n${blocks[i + 1].value}`;
+            const second = `${blocks[j].value}\n${blocks[j + 1].value}`;
+            if (first.length >= 80 && first === second) {
+                if (isSectionBoilerplate(blocks[i].value))
+                    continue;
+                errors.push(issue(file, bodyStartLine, "article.block-repeated-nearby", "warning", "A short sequence of content blocks is repeated nearby", blocks[j].line, repeatedBlockSuppressionGuidance));
+                break;
+            }
+        }
+    // Source checks for constructs CommonMark intentionally degrades to text.
+    for (const match of prose.matchAll(/^[ \t]*(?:optional|hide|feedback|source|from|to)::/gim))
+        errors.push(issue(file, bodyStartLine, "article.body-property-unsupported", "error", `Lens-only property '${match[0].trim()}' is not supported in an article body`, lineAt(prose, match.index ?? 0)));
+    const texProse = maskNodes(prose, tree, new Set(["image", "imageReference"]));
+    for (const match of texProse.matchAll(/(?<!\$)\\(?:frac|dfrac|tfrac|boldsymbol|mathbb|mathrm|mathbf|operatorname|begin|end|alpha|beta|gamma|delta|epsilon|theta|lambda|mu|pi|rho|sigma|tau|phi|psi|omega|approx|sim|leq|geq|neq|to|mapsto|infty|cdot|times|sum|prod)\b/g))
+        errors.push(issue(file, bodyStartLine, "article.tex-outside-math", "error", `TeX command '${match[0]}' appears outside math`, lineAt(texProse, match.index ?? 0), "Wrap the expression in valid math delimiters."));
+    for (const match of prose.matchAll(/\u00ad/g))
+        errors.push(issue(file, bodyStartLine, "article.soft-hyphen", "warning", "Soft hyphen in prose damages search and copy/paste", lineAt(prose, match.index ?? 0)));
+    const pdfLineWrapArtifacts = [
+        ...prose.matchAll(/(?<=\p{L})-[ \t]*\n[ \t]*(?=\p{Ll})/gu),
+    ];
+    if (pdfLineWrapArtifacts.length > 0) {
+        const first = pdfLineWrapArtifacts[0];
+        errors.push(issue(file, bodyStartLine, "article.pdf-line-wrap-artifact", "error", `Article contains ${pdfLineWrapArtifacts.length} PDF-style word break${pdfLineWrapArtifacts.length === 1 ? "" : "s"} across source lines`, lineAt(prose, first.index ?? 0), "Reconstruct the affected paragraphs from the source, joining wrapped lines and preserving a hyphen only when it belongs in the original word."));
+    }
+    for (const match of prose.matchAll(/[\u200b-\u200d\ufeff]/g)) {
+        const index = match.index ?? 0;
+        if (match[0] === "\u200d" && isEmojiJoiner(prose, index))
+            continue;
+        errors.push(issue(file, bodyStartLine, "article.zero-width-character", "warning", "Zero-width character in prose", lineAt(prose, index)));
+    }
+    for (const match of prose.matchAll(/!\[[^\]]*\]\(\s*\)|\[[^\]]+\]\(\s*\)/g)) {
+        const raw = match[0];
+        const code = raw.startsWith("![") ? "article.image-destination-empty" : "article.link-destination-empty";
+        errors.push(issue(file, bodyStartLine, code, "error", "Incomplete Markdown link or image", lineAt(prose, match.index ?? 0)));
+    }
+    for (const match of prose.matchAll(/\]\(#([^\s)]+)\)/g)) {
+        let fragment;
+        try {
+            fragment = decodeURIComponent(match[1]).toLowerCase();
+        }
+        catch {
+            fragment = match[1].toLowerCase();
+        }
+        if (!headingIds.has(fragment))
+            errors.push(issue(file, bodyStartLine, "article.fragment-target-missing", "error", `Fragment target '#${match[1]}' does not resolve to a rendered heading`, lineAt(prose, match.index ?? 0)));
+    }
+    for (const match of prose.matchAll(/^#{1,6}\s+(Image|Figure|Photo)\s*$/gim)) {
+        const line = lineAt(prose, match.index ?? 0);
+        const nearby = body.split("\n").slice(line, line + 4).join("\n");
+        errors.push(issue(file, bodyStartLine, /!\[/.test(nearby) ? "article.placeholder-image-heading" : "article.placeholder-heading", /!\[/.test(nearby) ? "error" : "warning", `Placeholder heading '${match[1]}' lacks descriptive context`, line));
+    }
+    for (const match of prose.matchAll(/(?:Posted in:\s*(?:,\s*)+|Export citation|Download citation|Share\s+Save\s+Follow)/gi))
+        errors.push(issue(file, bodyStartLine, "article.page-chrome-residue", "warning", "Source-page interface residue remains in article text", lineAt(prose, match.index ?? 0)));
+    const converterResiduePatterns = [
+        {
+            re: /^[ \t]*(?:††)?longtable[ \t]*$\n(?:[ \t]*\n)*(?=[ \t]*(?:#{1,6}\s+|Abstract\b))/gim,
+            message: "Standalone LaTeX environment name remains in converted prose",
+        },
+        {
+            re: /_\(button:\s*Give feedback\)_/gi,
+            message: "Serialized source-page button remains in article text",
+        },
+        {
+            re: /^[ \t]*(?:>[ \t]*)*(?:\[\^[^\]\n]+\]:[ \t]+)?(?:[-+*][ \t]+)?\d+\.[ \t]+\d+\.[ \t]+\S/gm,
+            message: "Duplicated numbered-list marker remains after conversion",
+        },
+        {
+            re: /^[ \t]*(?:>[ \t]*)*(?:\[\^[^\]\n]+\]:[ \t]+)?[-+*][ \t]+[•◦▪‣][ \t]+\S/gm,
+            message: "Duplicated bullet marker remains after conversion",
+        },
+        {
+            re: /marginparsep has been altered[\s\S]{0,1200}?The page layout violates the ICML style[\s\S]{0,1200}?(?:remove|avoid)[^.\n]{0,160}(?:package|layout)/gi,
+            message: "Document-submission layout diagnostics remain in article text",
+        },
+    ];
+    for (const { re, message } of converterResiduePatterns) {
+        for (const match of prose.matchAll(re)) {
+            errors.push(issue(file, bodyStartLine, "article.page-chrome-residue", "warning", message, lineAt(prose, match.index ?? 0), "Remove the converter or source-page residue while preserving the article content."));
+        }
+    }
+    for (const match of body.matchAll(/\b([A-Za-z][A-Za-z0-9]*)\s+(?:over|divided by)\s+([A-Za-z][A-Za-z0-9]*).{0,100}?\${1,2}\s*\\frac\{\1\}\{\2\}/gis))
+        errors.push(issue(file, bodyStartLine, "article.math-expression-duplicated", "warning", "Flattened math is followed by an equivalent TeX expression", lineAt(body, match.index ?? 0)));
+    // Only warn when Markdown actually parsed a list-looking line as indented
+    // code. Valid nested lists and footnote continuations are intentional.
+    visit(tree, "code", (node) => {
+        if (!node.position || node.lang)
+            return;
+        const lines = body.split("\n");
+        for (let line = node.position.start.line; line <= node.position.end.line; line += 1) {
+            if (/^ {4,}(?:[-+*]|\d+[.)])\s+\S/.test(lines[line - 1] ?? "")) {
+                errors.push(issue(file, bodyStartLine, "article.list-indentation-suspicious", "warning", "List indentation makes this item render as a code block", line, "Reduce the indentation or attach it to the intended parent list."));
+            }
+        }
+    });
+    errors.push(...scanTables(prose, file, bodyStartLine));
+    return applyNextLineValidatorSuppressions(proseMask(rawBody), bodyStartLine, errors, file);
+}
+//# sourceMappingURL=article-structure.js.map