@oa-sdk/spec-bundler 0.1.0

package/dist/link-rewriter.js

@@ -0,0 +1,777 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Temporarily masks code blocks and inline code to prevent false-positive link mutations.
+ * Provides character-accurate original line and column mapping.
+ */
+export function maskCodeBlocks(markdown) {
+    const spans = [];
+    function addSpans(regex, type) {
+        let m;
+        while ((m = regex.exec(markdown)) !== null) {
+            const start = m.index;
+            const end = start + m[0].length;
+            const overlaps = spans.some((s) => Math.max(s.start, start) < Math.min(s.end, end));
+            if (!overlaps) {
+                spans.push({ start, end, original: m[0], type });
+            }
+        }
+    }
+    // 1. HTML comments
+    addSpans(/<!--[\s\S]*?-->/g, "code_block");
+    // 2. HTML pre, code, script, and style blocks
+    addSpans(/(?:<pre\b[^>]*>[\s\S]*?<\/pre>|<code\b[^>]*>[\s\S]*?<\/code>|<script\b[^>]*>[\s\S]*?<\/script>|<style\b[^>]*>[\s\S]*?<\/style>)/gi, "code_block");
+    // 3. Fenced code blocks (3+ backticks or tildes, multiline or single line, with optional blockquote prefixes)
+    addSpans(/^[ \t>]*(?:(`{3,}|~{3,}))[^\r\n]*\r?\n[\s\S]*?^[ \t>]*\1[`~]*[ \t]*(?:\r?\n|$)/gm, "code_block");
+    addSpans(/(?:(`{3,}|~{3,})[\s\S]*?\1[`~]*)/g, "code_block");
+    // 4. Inline code (`...` single line, or ``...`` multiline)
+    addSpans(/(?:(`{2,})[\s\S]*?\1|`[^`\r\n]+`)/g, "inline_code");
+    // 5. Escaped brackets (\[ and \])
+    addSpans(/\\[\[\]]/g, "escaped");
+    // Sort spans in document order
+    spans.sort((a, b) => a.start - b.start);
+    const replacements = [];
+    const segments = [];
+    let masked = "";
+    let tokenCounter = 0;
+    let lastEnd = 0;
+    for (const span of spans) {
+        if (span.start > lastEnd) {
+            const origStart = lastEnd;
+            const origEnd = span.start;
+            const maskedStart = masked.length;
+            const text = markdown.slice(origStart, origEnd);
+            masked += text;
+            segments.push({
+                origStart,
+                origEnd,
+                maskedStart,
+                maskedEnd: masked.length,
+                isToken: false,
+            });
+        }
+        let placeholder = "";
+        if (span.type === "escaped") {
+            placeholder = `__META_BUNDLER_ESCAPED_BRACKET_${tokenCounter++}__`;
+        }
+        else if (span.type === "code_block") {
+            placeholder = `__META_BUNDLER_CODE_BLOCK_${tokenCounter++}__`;
+        }
+        else {
+            placeholder = `__META_BUNDLER_INLINE_CODE_${tokenCounter++}__`;
+        }
+        replacements.push({ placeholder, original: span.original });
+        const maskedStart = masked.length;
+        masked += placeholder;
+        segments.push({
+            origStart: span.start,
+            origEnd: span.end,
+            maskedStart,
+            maskedEnd: masked.length,
+            isToken: true,
+        });
+        lastEnd = span.end;
+    }
+    if (lastEnd < markdown.length) {
+        const origStart = lastEnd;
+        const origEnd = markdown.length;
+        const maskedStart = masked.length;
+        const text = markdown.slice(origStart, origEnd);
+        masked += text;
+        segments.push({
+            origStart,
+            origEnd,
+            maskedStart,
+            maskedEnd: masked.length,
+            isToken: false,
+        });
+    }
+    const getOriginalPosition = (maskedOffset) => {
+        let origOffset = maskedOffset;
+        for (const seg of segments) {
+            if (maskedOffset >= seg.maskedStart && maskedOffset < seg.maskedEnd) {
+                if (seg.isToken) {
+                    origOffset = seg.origStart;
+                }
+                else {
+                    origOffset = seg.origStart + (maskedOffset - seg.maskedStart);
+                }
+                break;
+            }
+        }
+        if (maskedOffset >= masked.length) {
+            origOffset = markdown.length;
+        }
+        const slice = markdown.slice(0, origOffset);
+        const line = slice.split("\n").length;
+        const lastNl = slice.lastIndexOf("\n");
+        const column = lastNl === -1 ? origOffset + 1 : origOffset - lastNl;
+        return { line, column, offset: origOffset };
+    };
+    const restore = (text) => {
+        let restored = text;
+        for (let i = replacements.length - 1; i >= 0; i--) {
+            const r = replacements[i];
+            restored = restored.replace(r.placeholder, () => r.original);
+        }
+        return restored;
+    };
+    return { masked, restore, getOriginalPosition };
+}
+/**
+ * Resolves a raw href from markdown to an absolute local filesystem path.
+ */
+export function resolveLocalPath(rawPath, sourceFileAbs, workspaceRoot) {
+    const isWindows = sourceFileAbs.includes("\\") ||
+        /^[a-zA-Z]:/.test(sourceFileAbs) ||
+        workspaceRoot.includes("\\") ||
+        /^[a-zA-Z]:/.test(workspaceRoot);
+    const pathModule = isWindows ? path.win32 : path.posix;
+    const normalized = rawPath.replace(/\\/g, "/");
+    if (normalized.startsWith("file://")) {
+        try {
+            return fileURLToPath(normalized);
+        }
+        catch {
+            // Fallback manual decode if URL parsing fails
+            const stripped = normalized.replace(/^file:\/\//, "");
+            return pathModule.resolve(decodeURIComponent(stripped));
+        }
+    }
+    let decodedPath = normalized;
+    if (normalized.includes("%")) {
+        try {
+            decodedPath = decodeURIComponent(normalized);
+        }
+        catch {
+            // ignore malformed URI
+        }
+    }
+    if (decodedPath.startsWith("/")) {
+        // Root-relative to workspace
+        return pathModule.resolve(workspaceRoot, decodedPath.replace(/^\/+/, ""));
+    }
+    // Relative to current document source directory
+    return pathModule.resolve(pathModule.dirname(sourceFileAbs), decodedPath);
+}
+/**
+ * Common link target rewriting logic shared between inline links and reference definitions.
+ */
+function transformHref(rawHrefWithAngle, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, linkKind = "inline") {
+    const hadAngleBrackets = rawHrefWithAngle.startsWith("<") && rawHrefWithAngle.endsWith(">");
+    let rawHref = hadAngleBrackets ? rawHrefWithAngle.slice(1, -1) : rawHrefWithAngle;
+    // Skip in-page hash anchors
+    if (rawHref.startsWith("#")) {
+        return { newHrefFormatted: rawHrefWithAngle, skipped: true };
+    }
+    // Skip external protocols (any protocol scheme other than file:)
+    if (!rawHref.startsWith("file:") && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(rawHref)) {
+        return { newHrefFormatted: rawHrefWithAngle, skipped: true };
+    }
+    const normalizedRawHref = rawHref.replace(/\\/g, "/");
+    // Split base path and query/hash
+    const hashIndex = normalizedRawHref.indexOf("#");
+    const queryIndex = normalizedRawHref.indexOf("?");
+    let splitIndex = -1;
+    if (hashIndex !== -1 && queryIndex !== -1) {
+        splitIndex = Math.min(hashIndex, queryIndex);
+    }
+    else if (hashIndex !== -1) {
+        splitIndex = hashIndex;
+    }
+    else if (queryIndex !== -1) {
+        splitIndex = queryIndex;
+    }
+    const basePath = splitIndex === -1 ? normalizedRawHref : normalizedRawHref.slice(0, splitIndex);
+    const suffix = splitIndex === -1 ? "" : normalizedRawHref.slice(splitIndex);
+    if (!basePath) {
+        return { newHrefFormatted: rawHrefWithAngle, skipped: true };
+    }
+    const resolvedAbs = resolveLocalPath(basePath, sourceFileAbs, workspaceRoot);
+    if (!resolvedAbs) {
+        return { newHrefFormatted: rawHrefWithAngle, skipped: true };
+    }
+    const normalizedBundleDest = bundleDestPath.replace(/\\/g, "/");
+    const currentBundleDir = path.posix.dirname(normalizedBundleDest);
+    const unbundledPolicy = config.unbundledPolicy ?? "warn";
+    const gitUrl = config.gitRepositoryUrl?.replace(/\/$/, "");
+    let targetBundleDest = sourceAbsToBundleDest.get(resolvedAbs) ??
+        sourceAbsToBundleDest.get(resolvedAbs.replace(/\\/g, "/")) ??
+        sourceAbsToBundleDest.get(resolvedAbs.replace(/\//g, "\\"));
+    // Fallback: if basePath has encoded characters, also try raw path
+    if (!targetBundleDest && basePath.includes("%")) {
+        const rawAbs = path.resolve(path.dirname(sourceFileAbs), basePath);
+        targetBundleDest =
+            sourceAbsToBundleDest.get(rawAbs) ??
+                sourceAbsToBundleDest.get(rawAbs.replace(/\\/g, "/")) ??
+                sourceAbsToBundleDest.get(rawAbs.replace(/\//g, "\\"));
+    }
+    // Fallback: if basePath is workspace-relative (common in TypeSpec @evidence)
+    if (!targetBundleDest) {
+        const fromWorkspace = path.resolve(workspaceRoot, basePath.replace(/^\/+/, ""));
+        targetBundleDest =
+            sourceAbsToBundleDest.get(fromWorkspace) ??
+                sourceAbsToBundleDest.get(fromWorkspace.replace(/\\/g, "/")) ??
+                sourceAbsToBundleDest.get(fromWorkspace.replace(/\//g, "\\"));
+    }
+    let newHref = normalizedRawHref;
+    let diagnostic;
+    const kindLabel = linkKind === "reference-def" ? "reference definition" : "internal link";
+    if (targetBundleDest) {
+        const normalizedTargetBundleDest = targetBundleDest.replace(/\\/g, "/");
+        let relInBundle = path.posix.relative(currentBundleDir, normalizedTargetBundleDest);
+        if (!relInBundle.startsWith(".")) {
+            relInBundle = `./${relInBundle}`;
+        }
+        // Preserve %20 if original link used %20 and didn't use angle brackets
+        if (!hadAngleBrackets && rawHref.includes("%20") && !relInBundle.includes("%20")) {
+            relInBundle = relInBundle.replace(/ /g, "%20");
+        }
+        newHref = `${relInBundle}${suffix}`;
+        diagnostic = {
+            file: normalizedBundleDest,
+            line,
+            column,
+            originalHref: rawHref,
+            rewrittenHref: newHref,
+            targetBundleDest: normalizedTargetBundleDest,
+            severity: "info",
+            linkKind,
+            message: `Rewrote ${kindLabel}: '${rawHref}' -> '${newHref}'`,
+        };
+    }
+    else {
+        // Target is outside the bundle
+        if (unbundledPolicy === "github-fallback") {
+            if (gitUrl) {
+                const relToRoot = path.relative(workspaceRoot, resolvedAbs).replace(/\\/g, "/");
+                newHref = `${gitUrl}/${relToRoot}${suffix}`;
+                diagnostic = {
+                    file: normalizedBundleDest,
+                    line,
+                    column,
+                    originalHref: rawHref,
+                    rewrittenHref: newHref,
+                    severity: "info",
+                    linkKind,
+                    message: `Converted unbundled ${kindLabel} to remote git URL: '${rawHref}' -> '${newHref}'`,
+                };
+            }
+            else {
+                diagnostic = {
+                    file: normalizedBundleDest,
+                    line,
+                    column,
+                    originalHref: rawHref,
+                    severity: "warning",
+                    linkKind,
+                    message: `Unbundled ${kindLabel} target '${rawHref}' cannot be converted to GitHub URL because 'gitRepositoryUrl' is not configured.`,
+                };
+            }
+        }
+        else if (unbundledPolicy === "warn") {
+            if (config.normalizeFileSchemes && rawHref.startsWith("file://")) {
+                const relToRoot = path.relative(workspaceRoot, resolvedAbs).replace(/\\/g, "/");
+                newHref = `./${relToRoot}${suffix}`;
+            }
+            diagnostic = {
+                file: normalizedBundleDest,
+                line,
+                column,
+                originalHref: rawHref,
+                severity: "warning",
+                linkKind,
+                message: `Unbundled ${kindLabel} target '${rawHref}' (${resolvedAbs}) is not part of this bundle.`,
+            };
+        }
+        else if (unbundledPolicy === "error") {
+            diagnostic = {
+                file: normalizedBundleDest,
+                line,
+                column,
+                originalHref: rawHref,
+                severity: "error",
+                linkKind,
+                message: `Unbundled ${kindLabel} target '${rawHref}' is not allowed by policy 'error'.`,
+            };
+        }
+    }
+    const newHrefFormatted = hadAngleBrackets || newHref.includes(" ") ? `<${newHref}>` : newHref;
+    return { newHrefFormatted, diagnostic, skipped: false };
+}
+/**
+ * Rewrites markdown links and reference definitions in a file so that they point to bundle-relative locations.
+ */
+export function rewriteMarkdownContent(content, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config = {}) {
+    if (config.enabled === false) {
+        return { rewritten: content, diagnostics: [] };
+    }
+    const diagnostics = [];
+    const { masked, restore, getOriginalPosition } = maskCodeBlocks(content);
+    // 1. Match and rewrite Markdown inline links: [text](target "optional title") and ![alt](src "title")
+    // Allows nested image in link label: [![alt](src)](target)
+    // Supports balanced parentheses in destinations and titles in "", '', or ()
+    const linkRegex = /(!?\[)((?:!\[[^\]]*\]\([^)]*\)|[^\]])*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+    let transformed = masked.replace(linkRegex, (fullMatch, prefix, label, rawHrefWithAngle, titlePart, offset) => {
+        const { line, column } = getOriginalPosition(offset);
+        let processedLabel = label;
+        if (label.includes("![")) {
+            const innerImgRegex = /(!?\[)([^\]]*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+            processedLabel = label.replace(innerImgRegex, (innerFull, innerPrefix, innerAlt, innerRawHref, innerTitlePart, innerOffset) => {
+                const innerMaskedOffset = offset + prefix.length + innerOffset;
+                const { line: innerLine, column: innerCol } = getOriginalPosition(innerMaskedOffset);
+                const { newHrefFormatted, diagnostic } = transformHref(innerRawHref, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, innerLine, innerCol, "inline");
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+                const innerTitle = innerTitlePart ?? "";
+                return `${innerPrefix}${innerAlt}](${newHrefFormatted}${innerTitle})`;
+            });
+        }
+        const { newHrefFormatted, diagnostic, skipped } = transformHref(rawHrefWithAngle, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, "inline");
+        if (diagnostic) {
+            diagnostics.push(diagnostic);
+        }
+        const title = titlePart ?? "";
+        if (skipped) {
+            return `${prefix}${processedLabel}](${rawHrefWithAngle}${title})`;
+        }
+        return `${prefix}${processedLabel}](${newHrefFormatted}${title})`;
+    });
+    // 2. Match and rewrite CommonMark link reference definitions (supports blockquotes, list markers, and destination on next line):
+    //    ^[ \t>]*(?:(?:[-*+]|\d+[.)])[ \t>]+)?\[label\]:[ \t]*(?:\r?\n[ \t>]+)?(<url>|\S+)(?:[ \t]+(?:"title"|'title'|\(title\)))?[ \t]*$
+    const refDefRegex = /^([ \t>]*(?:(?:[-*+]|\d+[.)])[ \t>]+)?\[)([^\]]+)(\]:[ \t]*(?:\r?\n[ \t>]+)?)(<[^>]+>|\S+)((?:[ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?)[ \t]*$/gm;
+    transformed = transformed.replace(refDefRegex, (fullMatch, prefix, label, colon, rawHrefWithAngle, titlePart, offset) => {
+        const bracketIndex = offset + prefix.indexOf("[");
+        const { line, column } = getOriginalPosition(bracketIndex);
+        const { newHrefFormatted, diagnostic, skipped } = transformHref(rawHrefWithAngle, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, "reference-def");
+        if (diagnostic) {
+            diagnostics.push(diagnostic);
+        }
+        if (skipped) {
+            return fullMatch;
+        }
+        return `${prefix}${label}${colon}${newHrefFormatted}${titlePart}`;
+    });
+    return {
+        rewritten: restore(transformed),
+        diagnostics,
+    };
+}
+/**
+ * Rewrites TypeSpec (@evidence, relative import, and @doc markdown) references in a file
+ * so that they point to bundle-relative locations.
+ */
+export function rewriteTypeSpecContent(content, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config = {}) {
+    if (config.enabled === false) {
+        return { rewritten: content, diagnostics: [] };
+    }
+    const diagnostics = [];
+    const getPosition = (offset) => {
+        const slice = content.slice(0, offset);
+        const line = slice.split("\n").length;
+        const lastNl = slice.lastIndexOf("\n");
+        const column = lastNl === -1 ? offset + 1 : offset - lastNl;
+        return { line, column };
+    };
+    let transformed = content;
+    // 1. Match and rewrite @evidence("path/to/doc.md#anchor", "reason")
+    const evidenceRegex = /(@evidence\s*\(\s*)(["'])([^"']+)\2/g;
+    transformed = transformed.replace(evidenceRegex, (fullMatch, prefix, quote, rawTarget, offset) => {
+        const targetOffset = offset + prefix.length + quote.length;
+        const { line, column } = getPosition(targetOffset);
+        const { newHrefFormatted, diagnostic, skipped } = transformHref(rawTarget, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, "inline");
+        if (diagnostic) {
+            diagnostics.push({
+                ...diagnostic,
+                message: diagnostic.message.replace(/internal link/g, "@evidence citation"),
+            });
+        }
+        if (skipped) {
+            return fullMatch;
+        }
+        const unwrapped = newHrefFormatted.replace(/^<|>$/g, "");
+        return `${prefix}${quote}${unwrapped}${quote}`;
+    });
+    // 2. Match and rewrite relative imports: import "./model.tsp"; or import "../common.tsp";
+    const importRegex = /(\bimport\s+)(["'])(\.[^"']+)\2/g;
+    transformed = transformed.replace(importRegex, (fullMatch, prefix, quote, rawTarget, offset) => {
+        const targetOffset = offset + prefix.length + quote.length;
+        const { line, column } = getPosition(targetOffset);
+        const { newHrefFormatted, diagnostic, skipped } = transformHref(rawTarget, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, "inline");
+        if (diagnostic) {
+            diagnostics.push({
+                ...diagnostic,
+                message: diagnostic.message.replace(/internal link/g, "TypeSpec import"),
+            });
+        }
+        if (skipped) {
+            return fullMatch;
+        }
+        const unwrapped = newHrefFormatted.replace(/^<|>$/g, "");
+        return `${prefix}${quote}${unwrapped}${quote}`;
+    });
+    // 3. Match and rewrite Markdown links inside @doc("... [text](target) ...") or @doc("""...""")
+    const docRegex = /(@doc\s*\(\s*)("""|"|')([\s\S]*?)\2(\s*\))/g;
+    transformed = transformed.replace(docRegex, (fullMatch, prefix, quote, docBody, suffix, offset) => {
+        const mdLinkRegex = /(!?\[)((?:!\[[^\]]*\]\([^)]*\)|[^\]])*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+        const newDocBody = docBody.replace(mdLinkRegex, (linkMatch, lPrefix, lLabel, rawHrefWithAngle, lTitlePart, lOffset) => {
+            const linkTargetOffset = offset + prefix.length + quote.length + lOffset;
+            const { line, column } = getPosition(linkTargetOffset);
+            const { newHrefFormatted, diagnostic, skipped } = transformHref(rawHrefWithAngle, sourceFileAbs, bundleDestPath, sourceAbsToBundleDest, workspaceRoot, config, line, column, "inline");
+            if (diagnostic) {
+                diagnostics.push({
+                    ...diagnostic,
+                    message: diagnostic.message.replace(/internal link/g, "@doc markdown link"),
+                });
+            }
+            const title = lTitlePart ?? "";
+            if (skipped) {
+                return `${lPrefix}${lLabel}](${rawHrefWithAngle}${title})`;
+            }
+            return `${lPrefix}${lLabel}](${newHrefFormatted}${title})`;
+        });
+        return `${prefix}${quote}${newDocBody}${quote}${suffix}`;
+    });
+    return {
+        rewritten: transformed,
+        diagnostics,
+    };
+}
+/**
+ * Normalizes heading text into a GitHub CommonMark-compliant anchor slug.
+ * Supports Unicode (Korean, CJK, etc.) and alphanumeric characters.
+ */
+export function normalizeSlug(text) {
+    return text
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .replace(/\s+/g, "-");
+}
+export function extractDocumentAnchors(content) {
+    const slugs = new Set();
+    const explicit = new Set();
+    const all = new Set();
+    const headingRegex = /^#{1,6}\s+(.+)$/gm;
+    let match;
+    while ((match = headingRegex.exec(content)) !== null) {
+        const rawHeading = match[1].trim();
+        const customMatch = rawHeading.match(/\{#([^}]+)\}/);
+        if (customMatch) {
+            const customId = customMatch[1].trim().toLowerCase();
+            explicit.add(customId);
+            all.add(customId);
+        }
+        const cleanTitle = rawHeading.replace(/\{#([^}]+)\}/, "").trim();
+        const slug = normalizeSlug(cleanTitle);
+        slugs.add(slug);
+        all.add(slug);
+        all.add(slug.replace(/-+/g, "-"));
+    }
+    // Explicit HTML anchors: <a id="..."> or <a name="..."> or any id/name attribute on HTML tags
+    const htmlAnchorRegex = /<[a-zA-Z0-9_-]+\s+[^>]*?(?:id|name)=["']([^"']+)["']/gi;
+    while ((match = htmlAnchorRegex.exec(content)) !== null) {
+        const id = match[1].trim().toLowerCase();
+        explicit.add(id);
+        all.add(id);
+    }
+    return { slugs, explicit, all };
+}
+/**
+ * Finds high-confidence closest candidate anchor in existingAnchors using Levenshtein distance.
+ */
+export function findClosestAnchor(missingAnchor, existingAnchors) {
+    const cleanMissing = missingAnchor.replace(/^#/, "").toLowerCase();
+    let bestCandidate = null;
+    let minDistance = Infinity;
+    for (const candidate of existingAnchors) {
+        const cleanCandidate = candidate.replace(/^#/, "").toLowerCase();
+        const dist = levenshteinDistance(cleanMissing, cleanCandidate);
+        if (dist <= 3 && dist < minDistance) {
+            minDistance = dist;
+            bestCandidate = `#${cleanCandidate}`;
+        }
+    }
+    return bestCandidate;
+}
+/**
+ * Verifies that all relative markdown and TypeSpec links point to files that actually exist within the bundle.
+ */
+export function verifyBundleLinkIntegrity(bundleEntries, options = {}) {
+    const diagnostics = [];
+    const existingFiles = new Set(Array.from(bundleEntries.keys()).map((k) => k.replace(/\\/g, "/")));
+    const severity = options.severity ?? "error";
+    const anchorsCache = new Map();
+    const getDocumentAnchors = (filePath) => {
+        if (anchorsCache.has(filePath))
+            return anchorsCache.get(filePath);
+        let entryContent = bundleEntries.get(filePath);
+        if (entryContent === undefined) {
+            for (const [k, v] of bundleEntries.entries()) {
+                if (k.replace(/\\/g, "/") === filePath) {
+                    entryContent = v;
+                    break;
+                }
+            }
+        }
+        if (entryContent === undefined)
+            return null;
+        const text = typeof entryContent === "string" ? entryContent : entryContent.toString("utf8");
+        const anchors = extractDocumentAnchors(text);
+        anchorsCache.set(filePath, anchors);
+        return anchors;
+    };
+    for (const [rawDestPath, content] of bundleEntries.entries()) {
+        const destPath = rawDestPath.replace(/\\/g, "/");
+        const isMarkdown = destPath.endsWith(".md") || destPath.endsWith(".mdx");
+        const isTypeSpec = destPath.endsWith(".tsp");
+        if (!isMarkdown && !isTypeSpec)
+            continue;
+        const text = typeof content === "string" ? content : content.toString("utf8");
+        const currentDir = path.posix.dirname(destPath);
+        let getOriginalPosition;
+        let masked = text;
+        if (isMarkdown) {
+            const maskResult = maskCodeBlocks(text);
+            masked = maskResult.masked;
+            getOriginalPosition = maskResult.getOriginalPosition;
+        }
+        else {
+            getOriginalPosition = (offset) => {
+                const slice = text.slice(0, offset);
+                const line = slice.split("\n").length;
+                const lastNl = slice.lastIndexOf("\n");
+                const column = lastNl === -1 ? offset + 1 : offset - lastNl;
+                return { line, column, offset };
+            };
+        }
+        const checkHref = (rawWithAngle, offset, linkKind) => {
+            let rawHref = rawWithAngle;
+            if (rawHref.startsWith("<") && rawHref.endsWith(">")) {
+                rawHref = rawHref.slice(1, -1);
+            }
+            // Skip external protocols
+            if (!rawHref.startsWith("file:") && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(rawHref))
+                return;
+            const hashIndex = rawHref.indexOf("#");
+            const hasHash = hashIndex !== -1;
+            const rawAnchor = hasHash ? rawHref.slice(hashIndex + 1) : "";
+            const splitIndex = rawHref.search(/[#?]/);
+            const targetPath = splitIndex === -1 ? rawHref : rawHref.slice(0, splitIndex);
+            // Intra-file hash anchors: [Section](#heading)
+            if (!targetPath && hasHash) {
+                if (!options.checkAnchors || !rawAnchor)
+                    return;
+                const anchors = getDocumentAnchors(destPath);
+                if (anchors) {
+                    const anchorLower = rawAnchor.toLowerCase();
+                    const collapsedAnchor = anchorLower.replace(/-+/g, "-");
+                    if (!anchors.all.has(anchorLower) && !anchors.all.has(collapsedAnchor)) {
+                        const { line, column } = getOriginalPosition(offset);
+                        const suggestion = findClosestAnchor(rawAnchor, anchors.all);
+                        const hint = suggestion ? ` (Did you mean '${suggestion}'?)` : "";
+                        diagnostics.push({
+                            file: destPath,
+                            line,
+                            column,
+                            originalHref: rawHref,
+                            severity,
+                            suggestedTarget: suggestion ?? undefined,
+                            linkKind,
+                            message: `Dead anchor link detected: '${rawHref}' not found in '${destPath}'.${hint}`,
+                        });
+                    }
+                }
+                return;
+            }
+            if (!targetPath)
+                return;
+            const normalizedTargetPath = targetPath.replace(/\\/g, "/");
+            // Calculate destination inside bundle
+            let resolvedDest;
+            if (normalizedTargetPath.startsWith("/")) {
+                resolvedDest = path.posix
+                    .normalize(normalizedTargetPath)
+                    .replace(/^\/+/, "");
+            }
+            else {
+                resolvedDest = path.posix
+                    .normalize(path.posix.join(currentDir, normalizedTargetPath))
+                    .replace(/^\/+/, "");
+            }
+            // Fallback for workspace-relative targets without leading slash
+            if (!existingFiles.has(resolvedDest) && existingFiles.has(normalizedTargetPath.replace(/^\/+/, ""))) {
+                resolvedDest = normalizedTargetPath.replace(/^\/+/, "");
+            }
+            // If policy is preserve and destination escapes bundle, skip
+            if (options.unbundledPolicy === "preserve" &&
+                (resolvedDest.startsWith("..") ||
+                    path.posix.isAbsolute(normalizedTargetPath) ||
+                    normalizedTargetPath.startsWith("../"))) {
+                return;
+            }
+            let decodedDest = resolvedDest;
+            if (resolvedDest.includes("%")) {
+                try {
+                    decodedDest = decodeURIComponent(resolvedDest);
+                }
+                catch {
+                    // ignore malformed URI
+                }
+            }
+            if (!existingFiles.has(resolvedDest) && !existingFiles.has(decodedDest)) {
+                const { line, column } = getOriginalPosition(offset);
+                const suggestion = findClosestFile(resolvedDest, existingFiles) ??
+                    (decodedDest !== resolvedDest ? findClosestFile(decodedDest, existingFiles) : null);
+                let hint = "";
+                let suggestedRelative;
+                if (suggestion) {
+                    let relSuggestion = path.posix.relative(currentDir, suggestion);
+                    if (!relSuggestion.startsWith(".")) {
+                        relSuggestion = `./${relSuggestion}`;
+                    }
+                    suggestedRelative = relSuggestion;
+                    hint = ` (Did you mean '${relSuggestion}'?)`;
+                }
+                diagnostics.push({
+                    file: destPath,
+                    line,
+                    column,
+                    originalHref: rawHref,
+                    severity,
+                    suggestedTarget: suggestedRelative,
+                    linkKind,
+                    message: `Dead link detected: '${rawHref}' resolves to '${resolvedDest}' which does not exist in the bundle.${hint}`,
+                });
+            }
+            else if (options.checkAnchors && hasHash && rawAnchor) {
+                const targetFile = existingFiles.has(resolvedDest) ? resolvedDest : decodedDest;
+                if (targetFile.endsWith(".md") || targetFile.endsWith(".mdx")) {
+                    const anchors = getDocumentAnchors(targetFile);
+                    if (anchors) {
+                        const anchorLower = rawAnchor.toLowerCase();
+                        const collapsedAnchor = anchorLower.replace(/-+/g, "-");
+                        if (!anchors.all.has(anchorLower) && !anchors.all.has(collapsedAnchor)) {
+                            const { line, column } = getOriginalPosition(offset);
+                            const suggestion = findClosestAnchor(rawAnchor, anchors.all);
+                            const targetPrefix = rawHref.slice(0, hashIndex);
+                            const suggestedTarget = suggestion ? `${targetPrefix}${suggestion}` : undefined;
+                            const hint = suggestion ? ` (Did you mean '${suggestedTarget}'?)` : "";
+                            diagnostics.push({
+                                file: destPath,
+                                line,
+                                column,
+                                originalHref: rawHref,
+                                severity,
+                                suggestedTarget,
+                                linkKind,
+                                message: `Dead anchor link detected: '${rawHref}' target anchor '#${rawAnchor}' not found in '${targetFile}'.${hint}`,
+                            });
+                        }
+                    }
+                }
+            }
+        };
+        if (isMarkdown) {
+            // 1. Inline links (including nested images in labels)
+            const linkRegex = /(!?\[)((?:!\[[^\]]*\]\([^)]*\)|[^\]])*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+            let match;
+            while ((match = linkRegex.exec(masked)) !== null) {
+                const prefix = match[1];
+                const label = match[2];
+                const href = match[3];
+                checkHref(href, match.index, "inline");
+                if (label.includes("![")) {
+                    const innerImgRegex = /(!?\[)([^\]]*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+                    let innerMatch;
+                    while ((innerMatch = innerImgRegex.exec(label)) !== null) {
+                        const innerOffset = match.index + prefix.length + innerMatch.index;
+                        checkHref(innerMatch[3], innerOffset, "inline");
+                    }
+                }
+            }
+            // 2. Reference definitions
+            const refDefRegex = /^[ \t>]*(?:(?:[-*+]|\d+[.)])[ \t>]+)?\[([^\]]+)\]:[ \t]*(?:\r?\n[ \t>]+)?(<[^>]+>|\S+)/gm;
+            let refMatch;
+            while ((refMatch = refDefRegex.exec(masked)) !== null) {
+                const bracketIndex = refMatch.index + refMatch[0].indexOf("[");
+                checkHref(refMatch[2], bracketIndex, "reference-def");
+            }
+        }
+        else if (isTypeSpec) {
+            // 1. @evidence citations
+            const evRegex = /@evidence\s*\(\s*["']([^"']+)["']/g;
+            let evMatch;
+            while ((evMatch = evRegex.exec(text)) !== null) {
+                checkHref(evMatch[1], evMatch.index, "inline");
+            }
+            // 2. Relative imports
+            const impRegex = /\bimport\s+["'](\.[^"']+)["']/g;
+            let impMatch;
+            while ((impMatch = impRegex.exec(text)) !== null) {
+                checkHref(impMatch[1], impMatch.index, "inline");
+            }
+            // 3. @doc markdown links
+            const docRegex = /@doc\s*\(\s*(?:"""([\s\S]*?)"""|"((?:\\.|[^"\\])*)")\s*\)/g;
+            let docMatch;
+            while ((docMatch = docRegex.exec(text)) !== null) {
+                const docText = docMatch[1] ?? docMatch[2] ?? "";
+                const mdLinkRegex = /(!?\[)((?:!\[[^\]]*\]\([^)]*\)|[^\]])*)\]\((<[^>]+>|(?:\\.|[^()\s]|\((?:\\.|[^()\s])*\))+)([ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+                let lMatch;
+                while ((lMatch = mdLinkRegex.exec(docText)) !== null) {
+                    checkHref(lMatch[3], docMatch.index + lMatch.index, "inline");
+                }
+            }
+        }
+    }
+    return diagnostics;
+}
+/**
+ * Calculates Levenshtein edit distance between two strings.
+ */
+export function levenshteinDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[m][n];
+}
+/**
+ * Finds high-confidence closest candidate file path in existingFiles for a missing target path.
+ */
+export function findClosestFile(missingPath, existingFiles) {
+    const missingBase = path.posix.basename(missingPath).toLowerCase();
+    let bestCandidate = null;
+    let minDistance = Infinity;
+    for (const candidate of existingFiles) {
+        const candidateBase = path.posix.basename(candidate).toLowerCase();
+        // 1. Exact base filename match (e.g. user specified wrong relative folder)
+        if (candidateBase === missingBase) {
+            return candidate;
+        }
+        // 2. High-confidence basename typo (edit distance <= 2)
+        const baseDist = levenshteinDistance(missingBase, candidateBase);
+        if (baseDist <= 2 && baseDist < minDistance) {
+            minDistance = baseDist;
+            bestCandidate = candidate;
+        }
+        // 3. High-confidence path typo (edit distance <= 3)
+        const fullDist = levenshteinDistance(missingPath.toLowerCase(), candidate.toLowerCase());
+        if (fullDist <= 3 && fullDist < minDistance) {
+            minDistance = fullDist;
+            bestCandidate = candidate;
+        }
+    }
+    return bestCandidate;
+}
+//# sourceMappingURL=link-rewriter.js.map