@thallylabs/migrate 0.2.27 → 0.2.29

package/dist/index.js

@@ -5382,14 +5382,14 @@ function buildNavigationFromPages(pages, options = {}) {
   const ids = pages.filter((page) => !page.locale || page.locale === "en").map((page) => page.navigationId);
   const ordered = [...new Set(ids)];
   if (options.topLevelTabs) {
-    const sourceNavigation = (options.topLevelNavigation ?? []).flatMap((entry) => {
+    const sourceNavigation2 = (options.topLevelNavigation ?? []).flatMap((entry) => {
       const sectionPages = ordered.filter((id) => id === entry.section || id.startsWith(`${entry.section}/`));
       const pageId = ordered.includes(entry.pageId) ? entry.pageId : preferredLandingPage(entry.section, sectionPages) ?? sectionPages[0];
       return pageId ? [{ ...entry, pageId }] : [];
     });
-    if (sourceNavigation.length > 1) {
+    if (sourceNavigation2.length > 1) {
       const claimedIds = /* @__PURE__ */ new Set();
-      const tabs = sourceNavigation.map((entry) => {
+      const tabs = sourceNavigation2.map((entry) => {
         const pageIds = ordered.filter((id) => {
           const matches = id === entry.pageId || id === entry.section || id.startsWith(`${entry.section}/`);
           if (matches) claimedIds.add(id);
@@ -7431,10 +7431,48 @@ function validateIntegrations(integrations) {
   return messages;
 }
 
+// src/url-images.ts
+function migrationImageUrl(value, base) {
+  const url = new URL(value, base);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Responsive image URL is not a credential-free HTTP(S) URL.");
+  return url.toString();
+}
+function migrationImageCandidates(value, base, resolve4 = true) {
+  if (value.length > 64e3) throw new Error("Responsive image candidate list exceeds its safety bound.");
+  const result = [];
+  let index = 0;
+  while (index < value.length) {
+    while (index < value.length && /[\t\n\f\r ,]/.test(value[index])) index++;
+    if (index === value.length) break;
+    const start = index;
+    while (index < value.length && !/[\t\n\f\r ]/.test(value[index])) index++;
+    let url = value.slice(start, index);
+    const hasTerminatingComma = url.endsWith(",");
+    if (hasTerminatingComma) url = url.replace(/,+$/, "");
+    const descriptorStart = index;
+    if (!hasTerminatingComma) while (index < value.length && value[index] !== ",") index++;
+    const descriptor = hasTerminatingComma ? "" : value.slice(descriptorStart, index).trim();
+    if (descriptor && !/^(?:[1-9]\d*w|(?:\d+(?:\.\d+)?|\.\d+)x)$/.test(descriptor)) throw new Error("Responsive image has an unsupported descriptor.");
+    if (descriptor.endsWith("x") && Number(descriptor.slice(0, -1)) <= 0) throw new Error("Responsive image density must be positive.");
+    const resolved = migrationImageUrl(url, base);
+    result.push({ url: resolve4 ? resolved : url, descriptor });
+    if (result.length > 128) throw new Error("Responsive image has too many candidates.");
+    if (value[index] === ",") index++;
+  }
+  if (!result.length) throw new Error("Responsive image has no candidates.");
+  return result;
+}
+function renderMigrationSrcset(candidates) {
+  return candidates.map((candidate) => `${candidate.url}${candidate.descriptor ? ` ${candidate.descriptor}` : ""}`).join(", ");
+}
+function migrationImageAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\{/g, "&#123;").replace(/\}/g, "&#125;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;");
+}
+
 // src/url.ts
 var DEFAULT_MAX_PAGES = 1e3;
 var DEFAULT_MAX_TOTAL_BYTES = 1e8;
-var MAX_DISCOVERED_URLS = 5e3;
+var MAX_DISCOVERED_URLS = 1e5;
 var MAX_LOCAL_RESPONSE_BYTES = 2e6;
 var MAX_SITEMAP_DOCUMENTS = 25;
 var PORTABLE_MDX_COMPONENTS = /* @__PURE__ */ new Set([
@@ -7502,7 +7540,9 @@ var PORTABLE_MDX_COMPONENTS = /* @__PURE__ */ new Set([
   "View",
   "Visibility",
   "Warning",
-  "YouTube"
+  "YouTube",
+  "picture",
+  "source"
 ]);
 var LOCALE_CODES = /* @__PURE__ */ new Set([
   "ar",
@@ -7944,6 +7984,20 @@ function sanitizeMarkdownUrls(value) {
           hasUnsafeMdxSyntax = true;
           return;
         }
+        if (node.name === "source" || node.name === "picture") {
+          const allowed = node.name === "picture" ? [] : ["src", "srcSet", "srcset", "sizes", "media", "type", "width", "height", "id"];
+          if (!allowed.includes(attribute.name) || typeof attribute.value !== "string") {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+          try {
+            if (/^srcset$/i.test(attribute.name)) migrationImageCandidates(decodeHtmlAttribute(attribute.value), new URL("https://migration.invalid"));
+            if (attribute.name === "src") migrationImageUrl(decodeHtmlAttribute(attribute.value), new URL("https://migration.invalid"));
+          } catch {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+        }
       }
     }
     for (const child of node.children ?? []) validateMdxSyntax(child);
@@ -8272,15 +8326,28 @@ function mergeEmbeddedOpenApi(fragments) {
   if (tags.size > 0) combined.tags = [...tags.values()];
   return new TextEncoder().encode(stringifyYaml2(combined));
 }
-function htmlPage(document, id) {
+function htmlPage(document, id, options = {}) {
   const $ = load2(document.body);
   const links = $('nav a[href], main a[href], article a[href], [role="main"] a[href]').map((_index, element) => $(element).attr("href") ?? "").get().filter(Boolean);
-  const title = $("main h1, article h1, h1").first().text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || $("title").text().split("|")[0].trim();
+  const scopedTitle = options.omitDocumentHeading ? $('main article, article, main, [role="main"]').first().find("h1").first().text().trim() : "";
+  const title = scopedTitle || $("main h1, article h1, h1").first().text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || $("title").text().split("|")[0].trim();
   const description = $('meta[name="description"]').attr("content")?.trim() || $('meta[property="og:description"]').attr("content")?.trim();
   const content = $('main article, article, main, [role="main"]').first();
   const root = content.length ? content : $("body");
-  root.find("script,style,noscript,nav,header,footer,aside,form,button,svg,iframe,object,embed,link,meta").remove();
+  let documentHeadingAnchor = "";
+  const excludedElements = options.omitDocumentHeading ? "script,style,noscript,nav,footer,aside,form,button,svg,iframe,object,embed,link,meta" : "script,style,noscript,nav,header,footer,aside,form,button,svg,iframe,object,embed,link,meta";
+  root.find(excludedElements).remove();
   root.find(".theme-doc-version-badge,.theme-doc-breadcrumbs,.theme-doc-toc-mobile,.table-of-contents,.hash-link").remove();
+  if (options.omitDocumentHeading) {
+    const heading = root.find("h1").first();
+    if (heading.length && heading.text().trim() === title) {
+      const anchorId = heading.attr("id");
+      if (anchorId) documentHeadingAnchor = `<a id="${migrationImageAttribute(anchorId)}" />
+
+`;
+      heading.remove();
+    }
+  }
   root.find("a[href]").each((_index, element) => {
     const href = $(element).attr("href");
     if (!href) return;
@@ -8311,6 +8378,53 @@ function htmlPage(document, id) {
   });
   const turndown = new TurndownService({ codeBlockStyle: "fenced", emDelimiter: "_", headingStyle: "atx" });
   turndown.remove(["script", "style", "noscript"]);
+  const anchor = (element) => {
+    const value = element.getAttribute("id");
+    return options.preserveAnchors && value ? `<a id="${value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\{/g, "&#123;")}" />
+
+` : "";
+  };
+  if (options.preserveAnchors) turndown.addRule("migration-source-anchor", {
+    filter: (node) => node.hasAttribute("id") && node.nodeName !== "PRE",
+    replacement: (content2, node) => {
+      const element = node;
+      const heading = element.nodeName.match(/^H([1-6])$/);
+      return `
+
+${anchor(element)}${heading ? `${"#".repeat(Number(heading[1]))} ` : ""}${content2}
+
+`;
+    }
+  });
+  if (options.preserveResponsiveImages) {
+    const image = (element) => {
+      const tag = element.nodeName.toLowerCase();
+      const attributes = [];
+      for (const name of ["src", "srcset", "sizes", "alt", "title", "media", "type", "width", "height", "id"]) {
+        let value = element.getAttribute(name);
+        if (value === null) continue;
+        if (name === "src") value = migrationImageUrl(value, document.finalUrl);
+        if (name === "srcset") value = renderMigrationSrcset(migrationImageCandidates(value, document.finalUrl));
+        const prop = name === "srcset" ? "srcSet" : name;
+        attributes.push(`${prop}="${migrationImageAttribute(value)}"`);
+      }
+      return `<${tag}${attributes.length ? ` ${attributes.join(" ")}` : ""} />`;
+    };
+    turndown.addRule("migration-responsive-image", {
+      filter: (node) => ["IMG", "SOURCE"].includes(node.nodeName),
+      replacement: (_content, node) => image(node)
+    });
+    turndown.addRule("migration-responsive-picture", {
+      filter: "picture",
+      replacement: (content2) => `
+
+<picture>
+${content2.trim()}
+</picture>
+
+`
+    });
+  }
   turndown.addRule("docusaurus-admonition", {
     filter: (node) => node.nodeName === "DIV" && node.classList.contains("theme-admonition"),
     replacement: (_content, node) => {
@@ -8325,8 +8439,8 @@ function htmlPage(document, id) {
       const markdown = turndown.turndown(clone.html() ?? "").trim();
       return `
 
-<${tag}>
-${titleText ? `**${titleText}**
+${anchor(element)}<${tag}>
+${titleText ? `**${escapeMarkdownText(titleText)}**
 
 ` : ""}${markdown}
 </${tag}>
@@ -8341,17 +8455,22 @@ ${titleText ? `**${titleText}**
       const fragment = load2(element.outerHTML);
       const container = fragment(".tabs-container").first();
       const labels = container.children("ul.tabs").children("li").toArray().map((item) => fragment(item).text().trim() || "Tab");
-      const panels = container.children('div[role="tabpanel"]').toArray();
+      const panels = container.find('[role="tabpanel"]').toArray().filter((panel) => fragment(panel).closest(".tabs-container")[0] === container[0]);
       if (panels.length === 0) return _content;
       const tabs = panels.map((panel, index) => {
-        const title2 = (labels[index] ?? `Tab ${index + 1}`).replace(/"/g, "&quot;");
+        const panelId = fragment(panel).attr("id");
+        const tab = panelId ? container.find('[role="tab"]').toArray().find((item) => fragment(item).attr("aria-controls") === panelId) : void 0;
+        const title2 = migrationImageAttribute((tab ? fragment(tab).text().trim() : labels[index]) || `Tab ${index + 1}`);
+        const panelAnchor = options.preserveAnchors && panelId ? `<a id="${migrationImageAttribute(panelId)}" />
+
+` : "";
         return `<Tab title="${title2}">
-${turndown.turndown(fragment(panel).html() ?? "").trim()}
+${panelAnchor}${turndown.turndown(fragment(panel).html() ?? "").trim()}
 </Tab>`;
       });
       return `
 
-<Tabs>
+${anchor(element)}<Tabs>
 ${tabs.join("\n\n")}
 </Tabs>
 
@@ -8390,7 +8509,7 @@ ${normalized.slice(1).map((row) => `| ${row.join(" | ")} |`).join("\n")}
       const fence = "`".repeat(Math.max(3, longestFence + 1));
       return `
 
-${fence}${language}
+${anchor(element)}${fence}${language}
 ${code}
 ${fence}
 
@@ -8398,8 +8517,8 @@ ${fence}
     }
   });
   const escape = turndown.escape.bind(turndown);
-  turndown.escape = (text2) => escape(text2).replace(/[<{]/g, (match) => `\\${match}`);
-  const body = turndown.turndown(root.html() ?? "").trim();
+  turndown.escape = (text2) => escape(text2).replace(/[<{}]/g, (match) => `\\${match}`);
+  const body = `${documentHeadingAnchor}${turndown.turndown(root.html() ?? "").trim()}`;
   if (!title || body.length < 40 && $("article").length === 0) return { page: null, links };
   return {
     page: {
@@ -8556,13 +8675,13 @@ function docusaurusNavigationFromSnapshots(snapshots, pages, scopePath) {
   });
   mergedSnapshots.sort((left, right) => pageIdsFor(right).length - pageIdsFor(left).length);
   const tabs = mergedSnapshots.flatMap((snapshot, snapshotIndex) => {
-    function convert(items) {
+    function convert2(items) {
       const converted2 = [];
       for (const item of items) {
         const routeId = item.href ? docusaurusRouteIdForUrl(new URL(item.href), scopePath) : null;
         const page = routeId && imported.has(routeId) && !claimed.has(routeId) ? routeId : null;
         if (page) claimed.add(page);
-        const children = item.items ? convert(item.items) : [];
+        const children = item.items ? convert2(item.items) : [];
         if (children.length > 0 || item.isCategory) {
           converted2.push({ group: item.label, pages: page ? [page, ...children] : children });
           continue;
@@ -8571,7 +8690,7 @@ function docusaurusNavigationFromSnapshots(snapshots, pages, scopePath) {
       }
       return converted2;
     }
-    const converted = convert(snapshot.items);
+    const converted = convert2(snapshot.items);
     const loosePages = converted.filter((item) => typeof item === "string");
     const groups = converted.filter((item) => typeof item !== "string");
     if (loosePages.length > 0) groups.unshift({ group: "Overview", pages: loosePages });
@@ -8676,7 +8795,7 @@ async function safeFetch(fetcher, url, accept) {
 async function migrateUrl(options) {
   const source = validateMigrationUrl(options.sourceUrl);
   const fetcher = options.fetcher ?? defaultMigrationFetcher;
-  const maxPages = Math.max(1, Math.min(options.maxPages ?? DEFAULT_MAX_PAGES, 1e3));
+  const maxPages = Math.max(1, Math.min(options.maxPages ?? DEFAULT_MAX_PAGES, 1e4));
   const concurrency = Math.max(1, Math.min(options.concurrency ?? 5, 10));
   const maxTotalBytes = Math.max(1e6, Math.min(options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES, 5e8));
   const submittedScopePath = docsScopePath(source);
@@ -8835,12 +8954,15 @@ async function migrateUrl(options) {
       if (!isInScope(document.finalUrl, source, scopePath)) {
         return { candidate, page: null, links: [], failure: false };
       }
+      if (/\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$/i.test(document.finalUrl.pathname) || /(?:xml|json)/i.test(document.contentType)) {
+        return { candidate, page: null, links: markdownLinks(document.body), base: document.finalUrl, failure: false };
+      }
       const isMarkdown = /(?:markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname);
       if (!isMarkdown && !/\.mdx?$/i.test(candidate.pathname)) {
         const markdownUrl = new URL(candidate);
         markdownUrl.pathname = `${markdownUrl.pathname.replace(/\/$/, "")}.md`;
         const markdownDocument = await safeFetch(fetcher, markdownUrl, "text/markdown,text/plain");
-        if (markdownDocument && isInScope(markdownDocument.finalUrl, source, scopePath) && /(?:markdown|text\/plain)/i.test(markdownDocument.contentType)) {
+        if (markdownDocument && isInScope(markdownDocument.finalUrl, source, scopePath) && !/\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$/i.test(markdownDocument.finalUrl.pathname) && /(?:markdown|text\/plain)/i.test(markdownDocument.contentType)) {
           document = markdownDocument;
         }
       }
@@ -10340,12 +10462,12 @@ function apiOperationLinkMap(sources, docsConfig) {
       const tagSegment = mintlifyOperationSlugSegment(operation.tag ?? "default");
       const mintlifyTag = mintlifyUrlSlug(operation.tag ?? "default");
       const mintlifyLeaf = mintlifyUrlSlug(operation.summary?.trim() || operation.operationId?.trim() || `${operation.method} ${operation.path}`);
-      const canonical = `${source.prefix}/${mintlifyTag}/${mintlifyLeaf}`.replace(/^\/+|\/+$/g, "");
+      const canonical2 = `${source.prefix}/${mintlifyTag}/${mintlifyLeaf}`.replace(/^\/+|\/+$/g, "");
       if (mintlifyTag && mintlifyLeaf) {
-        if (!mintlifyPages.has(canonical)) mintlifyPages.set(canonical, thallyHref);
-        else if (mintlifyPages.get(canonical) !== thallyHref && !duplicatePages.includes(canonical)) duplicatePages.push(canonical);
+        if (!mintlifyPages.has(canonical2)) mintlifyPages.set(canonical2, thallyHref);
+        else if (mintlifyPages.get(canonical2) !== thallyHref && !duplicatePages.includes(canonical2)) duplicatePages.push(canonical2);
       }
-      if (mintlifyTag && mintlifyLeaf && !map.has(canonical.toLowerCase())) map.set(canonical.toLowerCase(), thallyHref);
+      if (mintlifyTag && mintlifyLeaf && !map.has(canonical2.toLowerCase())) map.set(canonical2.toLowerCase(), thallyHref);
       const tagRoot = `${source.prefix}/${mintlifyTag}`.replace(/^\/+|\/+$/g, "");
       if (mintlifyTag && !mintlifyPages.has(tagRoot)) mintlifyPages.set(tagRoot, thallyHref);
       if (mintlifyTag && !map.has(tagRoot.toLowerCase())) map.set(tagRoot.toLowerCase(), thallyHref);
@@ -10820,16 +10942,16 @@ function preserveLinkedAnchors(pages) {
   const requested = /* @__PURE__ */ new Map();
   const crossPageRequests = /* @__PURE__ */ new Set();
   const addTarget = (target, currentId) => {
-    const hash2 = target.indexOf("#");
-    if (hash2 < 0) return;
+    const hash3 = target.indexOf("#");
+    if (hash3 < 0) return;
     let fragment;
     try {
-      fragment = decodeURIComponent(target.slice(hash2 + 1));
+      fragment = decodeURIComponent(target.slice(hash3 + 1));
     } catch {
       return;
     }
     if (!/^[\p{L}\p{N}_.:$-]{1,120}$/u.test(fragment)) return;
-    const path = target.slice(0, hash2).split("?")[0];
+    const path = target.slice(0, hash3).split("?")[0];
     const id = target.startsWith("#") ? currentId : path.startsWith("/") && !path.startsWith("//") ? path.replace(/^\//, "").replace(/\/$/, "") || "introduction" : "";
     if (!pageById.has(id)) return;
     if (!requested.has(id)) requested.set(id, /* @__PURE__ */ new Set());
@@ -13442,8 +13564,1137 @@ function renderMigrationFiles(bundle, options = {}) {
   ];
 }
 
-// src/remote-api.ts
+// src/url-run.ts
 import { createHash as createHash3 } from "crypto";
+import { load as load3 } from "cheerio";
+import remarkParse4 from "remark-parse";
+import remarkMdx4 from "remark-mdx";
+import { unified as unified4 } from "unified";
+
+// src/svg-policy.ts
+import { Parser } from "htmlparser2";
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+var ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "title",
+  "desc",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "textpath",
+  "lineargradient",
+  "radialgradient",
+  "stop",
+  "clippath",
+  "mask",
+  "pattern",
+  "marker",
+  "filter",
+  "feblend",
+  "fecolormatrix",
+  "fecomponenttransfer",
+  "fecomposite",
+  "feconvolvematrix",
+  "fediffuselighting",
+  "fedisplacementmap",
+  "fedistantlight",
+  "fedropshadow",
+  "feflood",
+  "fefunca",
+  "fefuncb",
+  "fefuncg",
+  "fefuncr",
+  "fegaussianblur",
+  "femerge",
+  "femergenode",
+  "femorphology",
+  "feoffset",
+  "fepointlight",
+  "fespecularlighting",
+  "fespotlight",
+  "fetile",
+  "feturbulence"
+]);
+var ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "xmlns",
+  "xmlns:xlink",
+  "xml:space",
+  "version",
+  "baseprofile",
+  "id",
+  "class",
+  "viewbox",
+  "preserveaspectratio",
+  "width",
+  "height",
+  "x",
+  "y",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "d",
+  "points",
+  "pathlength",
+  "transform",
+  "transform-origin",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-opacity",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "opacity",
+  "color",
+  "display",
+  "visibility",
+  "overflow",
+  "clip-path",
+  "clip-rule",
+  "clippathunits",
+  "mask",
+  "maskunits",
+  "maskcontentunits",
+  "filter",
+  "filterunits",
+  "primitiveunits",
+  "marker-start",
+  "marker-mid",
+  "marker-end",
+  "markerwidth",
+  "markerheight",
+  "markerunits",
+  "refx",
+  "refy",
+  "orient",
+  "patternunits",
+  "patterncontentunits",
+  "patterntransform",
+  "gradientunits",
+  "gradienttransform",
+  "spreadmethod",
+  "fx",
+  "fy",
+  "fr",
+  "offset",
+  "stop-color",
+  "stop-opacity",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "font-style",
+  "font-variant",
+  "letter-spacing",
+  "word-spacing",
+  "text-anchor",
+  "dominant-baseline",
+  "alignment-baseline",
+  "baseline-shift",
+  "text-decoration",
+  "dx",
+  "dy",
+  "rotate",
+  "textlength",
+  "lengthadjust",
+  "startoffset",
+  "writing-mode",
+  "direction",
+  "unicode-bidi",
+  "shape-rendering",
+  "text-rendering",
+  "image-rendering",
+  "color-interpolation",
+  "color-interpolation-filters",
+  "vector-effect",
+  "paint-order",
+  "mix-blend-mode",
+  "isolation",
+  "in",
+  "in2",
+  "result",
+  "stddeviation",
+  "mode",
+  "type",
+  "values",
+  "tablevalues",
+  "slope",
+  "intercept",
+  "amplitude",
+  "exponent",
+  "operator",
+  "k1",
+  "k2",
+  "k3",
+  "k4",
+  "radius",
+  "scale",
+  "xchannelselector",
+  "ychannelselector",
+  "basefrequency",
+  "numoctaves",
+  "seed",
+  "stitchtiles",
+  "flood-color",
+  "flood-opacity",
+  "lighting-color",
+  "surfacescale",
+  "diffuseconstant",
+  "specularconstant",
+  "specularexponent",
+  "kernelmatrix",
+  "kernelunitlength",
+  "order",
+  "divisor",
+  "bias",
+  "targetx",
+  "targety",
+  "edgemode",
+  "preservealpha",
+  "azimuth",
+  "elevation",
+  "z",
+  "pointsatx",
+  "pointsaty",
+  "pointsatz",
+  "limitingconeangle",
+  "aria-hidden",
+  "aria-label",
+  "role",
+  "focusable",
+  // Validated below: only in-document fragment references.
+  "href",
+  "xlink:href"
+]);
+function hasExternalReference(value) {
+  if (value.includes("\\")) return true;
+  const compact = value.replace(/[\u0000- ]/gu, "").toLowerCase();
+  if (/(?:java|vb)script:|data:|expression\(|@import|<|>/u.test(compact)) {
+    return true;
+  }
+  for (const match of compact.matchAll(/url\(([^)]*)\)/gu)) {
+    if (!/^["']?#[a-z0-9_.:-]+["']?$/u.test(match[1])) return true;
+  }
+  return compact.replace(/url\(([^)]*)\)/gu, "").includes("url(");
+}
+function utf8SvgText(content) {
+  const hasUtf8Bom = content[0] === 239 && content[1] === 187 && content[2] === 191;
+  const body = hasUtf8Bom ? content.subarray(3) : content;
+  if (body[0] === 254 && body[1] === 255 || body[0] === 255 && body[1] === 254 || body[0] === 0 && body[1] === 0 || body.includes(0)) {
+    return null;
+  }
+  const text2 = body.toString("utf8");
+  if (text2.includes("\uFFFD")) return null;
+  const declaration = /^<\?xml\b[^>]*\?>/iu.exec(text2);
+  if (declaration) {
+    const encoding = /\bencoding\s*=\s*["']([^"']*)["']/iu.exec(declaration[0]);
+    if (encoding && !/^utf-?8$/iu.test(encoding[1].trim())) return null;
+  } else if (/<\?xml\b/iu.test(text2)) {
+    return null;
+  }
+  return text2;
+}
+function isPassiveSvg(content) {
+  const text2 = utf8SvgText(Buffer.from(content.buffer, content.byteOffset, content.byteLength));
+  if (text2 === null) return false;
+  let isPassive = true;
+  let depth = 0;
+  let sawRoot = false;
+  const openStarts = [];
+  const fail = () => {
+    isPassive = false;
+  };
+  const parser3 = new Parser(
+    {
+      onopentag(name, attributes) {
+        const element = name.toLowerCase();
+        if (depth === 0) {
+          if (sawRoot || element !== "svg") fail();
+          sawRoot = true;
+        }
+        depth += 1;
+        openStarts.push(parser3.startIndex);
+        if (element.includes(":") || !ALLOWED_ELEMENTS.has(element)) fail();
+        for (const [rawName, value] of Object.entries(attributes)) {
+          const attribute = rawName.toLowerCase();
+          if (!ALLOWED_ATTRIBUTES.has(attribute)) {
+            fail();
+            continue;
+          }
+          if (attribute === "xmlns" && value !== SVG_NAMESPACE) fail();
+          if (attribute === "xmlns:xlink" && value !== XLINK_NAMESPACE) fail();
+          if ((attribute === "href" || attribute === "xlink:href") && !/^#[A-Za-z0-9_.:-]+$/u.test(value.trim())) {
+            fail();
+          }
+          if (hasExternalReference(value)) fail();
+        }
+      },
+      onclosetag(_name, isImplied) {
+        depth -= 1;
+        const start = openStarts.pop();
+        if (isImplied && start !== parser3.startIndex) fail();
+      },
+      // DOCTYPE (and with it custom entities) or any other declaration other
+      // than the XML prolog.
+      onprocessinginstruction(name) {
+        if (name.toLowerCase() !== "?xml") fail();
+      },
+      oncdatastart: fail,
+      ontext(value) {
+        if (depth === 0 && value.trim()) fail();
+      },
+      onerror: fail
+    },
+    { xmlMode: true, decodeEntities: true, recognizeSelfClosing: true }
+  );
+  try {
+    parser3.write(text2);
+    parser3.end();
+  } catch {
+    return false;
+  }
+  return isPassive && sawRoot && depth === 0;
+}
+
+// src/url-asset-cache.ts
+function createMigrationAssetCache() {
+  const settled = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const remember = (url, asset) => {
+    settled.delete(url);
+    settled.set(url, asset);
+    if (settled.size > 480) settled.delete(settled.keys().next().value);
+    return asset;
+  };
+  const get = (url) => {
+    const asset = settled.get(url);
+    if (asset) return Promise.resolve(remember(url, asset));
+    return pending.get(url);
+  };
+  return {
+    remember,
+    get,
+    has(url) {
+      return settled.has(url) || pending.has(url);
+    },
+    get size() {
+      return settled.size + pending.size;
+    },
+    load(url, acquire) {
+      const existing = get(url);
+      if (existing) return existing;
+      const request2 = Promise.resolve().then(acquire).then((asset) => {
+        pending.delete(url);
+        return remember(url, asset);
+      }, (error) => {
+        pending.delete(url);
+        throw error;
+      });
+      pending.set(url, request2);
+      return request2;
+    },
+    delete(url) {
+      settled.delete(url);
+    }
+  };
+}
+
+// src/url-journal-clone.ts
+function cloneUrlMigrationCheckpoint(checkpoint) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const clone = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+    if (typeof value === "number") return Number.isFinite(value) ? value === 0 ? 0 : value : null;
+    if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") return void 0;
+    if (typeof value !== "object") throw new TypeError("Checkpoint must contain JSON-safe values.");
+    if (ancestors.has(value)) throw new TypeError("Checkpoint must not contain circular references.");
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("Checkpoint must contain plain JSON containers.");
+    ancestors.add(value);
+    try {
+      if (Array.isArray(value)) return Array.from(value, (entry) => clone(entry) ?? null);
+      return Object.fromEntries(Object.entries(value).flatMap(([key, entry]) => {
+        const copied = clone(entry);
+        return copied === void 0 ? [] : [[key, copied]];
+      }));
+    } finally {
+      ancestors.delete(value);
+    }
+  };
+  return clone(checkpoint);
+}
+
+// src/url-run.ts
+var CONVERTER_VERSION = "url-evidence-v2";
+var parser2 = unified4().use(remarkParse4).use(remarkMdx4);
+var ACCEPT = "text/markdown,text/html,application/xhtml+xml;q=0.9";
+var MAX_RESPONSE_BYTES = 8e6;
+var MAX_ASSET_BYTES2 = 1e7;
+var MAX_RECORDS = 1e5;
+var LOCALES = /* @__PURE__ */ new Set(["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hi", "hu", "id", "it", "ja", "ko", "ms", "nl", "no", "pl", "pt", "pt-br", "ro", "ru", "sk", "sv", "th", "tr", "uk", "vi", "zh", "zh-cn", "zh-hans", "zh-hant"]);
+function hash2(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function pageHash(page) {
+  const canonical2 = (value) => Array.isArray(value) ? value.map(canonical2) : value !== null && typeof value === "object" ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, field]) => [key, canonical2(field)])) : value;
+  return hash2(JSON.stringify(canonical2(page)));
+}
+function inScope(url, source, scope) {
+  return url.origin === source.origin && !url.username && !url.password && (scope === "/" || url.pathname === scope || url.pathname.startsWith(`${scope}/`));
+}
+function isDiscoveryIndex(url, source) {
+  return url.origin === source.origin && /\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$/i.test(url.pathname);
+}
+function canonical(value, base) {
+  try {
+    const url = validateMigrationUrl(new URL(value, base).toString());
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function classifyMigrationResponse(document) {
+  if (document.status && document.status >= 400) return "unsupported";
+  if (/\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$|\/search(?:\.html)?$/i.test(document.finalUrl.pathname) || /(?:xml|json)/i.test(document.contentType)) return "index";
+  if (/^(?:image|audio|video)\//i.test(document.contentType) || /\.(?:pdf|zip|png|jpe?g|webp|gif|svg|ico|mp4|webm)$/i.test(document.finalUrl.pathname)) return "asset";
+  return /(?:html|markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname) ? "page" : "unsupported";
+}
+function markdownNodes(body) {
+  const nodes = [];
+  const visit = (node) => {
+    nodes.push(node);
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(parser2.parse(body));
+  return nodes;
+}
+function markdownCode(body) {
+  return markdownNodes(body).filter((node) => node.type === "code").map((node) => node.value ?? "");
+}
+function alternativeBlocks(body, baseline) {
+  const blocks = (value) => (parser2.parse(value).children ?? []).map((node) => value.slice(node.position.start.offset, node.position.end.offset));
+  const originals = new Set(blocks(baseline));
+  return blocks(body).filter((block) => !originals.has(block)).join("\n\n");
+}
+function linksOf(document) {
+  if (/html/i.test(document.contentType)) {
+    const $ = load3(document.body);
+    const root = $('main article,article,main,[role="main"]').first();
+    root.find("nav,footer,aside").remove();
+    return [...root.find("a[href]").toArray(), ...$('link[rel="sitemap"][href],link[rel="alternate"][href]').toArray()].map((node) => $(node).attr("href")).filter(Boolean);
+  }
+  if (/xml/i.test(document.contentType) || /<urlset|<sitemapindex/i.test(document.body)) {
+    const $ = load3(document.body, { xmlMode: true });
+    return $("loc").toArray().map((node) => $(node).text().trim());
+  }
+  return [
+    ...markdownNodes(document.body).flatMap((node) => node.url ? [node.url] : []),
+    ...[...document.body.matchAll(/^Sitemap:\s*(\S+)/gmi)].map((match) => match[1])
+  ];
+}
+function htmlEvidence(document) {
+  const $ = load3(document.body);
+  const root = $('main article,article,main,[role="main"]').first();
+  const article = root.length ? root : $("body");
+  article.find("nav,footer,aside,form,script,style").remove();
+  return {
+    anchors: article.find("[id]").toArray().map((node) => $(node).attr("id")).filter(Boolean),
+    code: article.find("pre").toArray().map((node) => {
+      const lines = $(node).find(".token-line");
+      return lines.length ? lines.toArray().map((line) => $(line).text()).join("\n") : $(node).text();
+    })
+  };
+}
+function evidenceOf(capture) {
+  const technical = /html/i.test(capture.contentType) ? htmlEvidence(capture) : { code: markdownCode(capture.body), anchors: markdownHeadingAnchors(capture.body) };
+  return {
+    sha256: hash2(capture.body),
+    byteLength: Buffer.byteLength(capture.body),
+    finalUrl: capture.finalUrl.toString(),
+    contentType: capture.contentType,
+    ...capture.artifactRef ? { artifactRef: capture.artifactRef } : {},
+    states: (capture.states ?? []).map((state) => ({ id: state.id, label: state.label, sha256: hash2(state.response.body) })),
+    ...technical,
+    links: linksOf(capture)
+  };
+}
+function markdownHeadingAnchors(body) {
+  const seen = /* @__PURE__ */ new Map();
+  return markdownNodes(body).filter((node) => node.type === "heading").map((node) => {
+    const text2 = (value) => value.value ?? (value.children ?? []).map(text2).join("");
+    const base = text2(node).toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-");
+    const occurrence = seen.get(base) ?? 0;
+    seen.set(base, occurrence + 1);
+    return occurrence ? `${base}-${occurrence}` : base;
+  });
+}
+function sourceNavigation(capture) {
+  if (capture.navigation) {
+    const resolve4 = (nodes, depth = 0) => {
+      if (depth > 32 || nodes.length > 1e4) throw new Error("Source navigation exceeds its depth or width safety bound.");
+      return nodes.map((node) => ({ label: node.label, ...node.url ? { url: new URL(node.url, capture.finalUrl).toString() } : {}, ...node.children ? { children: resolve4(node.children, depth + 1) } : {} }));
+    };
+    return resolve4(capture.navigation);
+  }
+  if (!/html/i.test(capture.contentType)) return [];
+  const $ = load3(capture.body);
+  const candidates = ['.theme-doc-sidebar-menu,[aria-label*="sidebar" i]', "aside", '[role="navigation"],nav'];
+  const root = candidates.map((selector) => $(selector).filter((_index, node) => $(node).find("a[href]").length > 0 && $(node).closest("header").length === 0).first()).find((candidate) => candidate.length) ?? $("aside").first();
+  if (!root.length) return [];
+  const walk2 = (element, excluded) => {
+    const result = [];
+    $(element).children().each((_index, node) => {
+      if (node === excluded) return;
+      const item = $(node);
+      if (item.is("a[href]")) {
+        result.push({ label: item.text().replace(/\s+/g, " ").trim(), url: new URL(item.attr("href"), capture.finalUrl).toString() });
+      } else if (item.is("li,details") || item.attr("data-migration-group") !== void 0 || item.children("h2,h3,h4,h5,h6").length > 0) {
+        const directLink = item.children("a[href]").first();
+        const direct = directLink.length ? directLink : item.children("div").children("a[href]").first();
+        const label = direct.text().trim() || item.children("summary,button,span,h2,h3,h4,h5,h6").first().text().trim();
+        const children = walk2(node, direct[0]);
+        if (label) result.push({ label, ...direct.length ? { url: new URL(direct.attr("href"), capture.finalUrl).toString() } : {}, ...children.length ? { children } : {} });
+        else result.push(...children);
+      } else result.push(...walk2(node, excluded));
+    });
+    return result;
+  };
+  try {
+    return walk2(root);
+  } catch {
+    return [];
+  }
+}
+function idForUrl(url, scope) {
+  const relative7 = scope === "/" ? url.pathname.slice(1) : url.pathname.slice(scope.length).replace(/^\//, "");
+  const id = pageIdFromReference(relative7 || "introduction", true);
+  return id && `${id}${url.search ? `--${hash2(url.search).slice(0, 12)}` : ""}`;
+}
+function convert(document, id) {
+  if (/html/i.test(document.contentType)) {
+    const technical = htmlEvidence(document);
+    const page = htmlPage(document, id, { preserveAnchors: true, preserveResponsiveImages: true, omitDocumentHeading: true }).page;
+    if (!page) return null;
+    page.descriptionPlacement = "body";
+    const nodes = markdownNodes(page.body).filter((node) => node.type === "code");
+    if (nodes.length === technical.code.length) {
+      for (let index = nodes.length - 1; index >= 0; index--) {
+        const node = nodes[index];
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        if (start === void 0 || end === void 0) continue;
+        const original = page.body.slice(start, end);
+        const info = original.split("\n", 1)[0].replace(/^`+|^~+/, "");
+        const code = technical.code[index];
+        const fence = "`".repeat(Math.max(3, ...[...code.matchAll(/`+/g)].map((match) => match[0].length + 1)));
+        page.body = `${page.body.slice(0, start)}${fence}${info}
+${code}
+${fence}${page.body.slice(end)}`;
+      }
+    }
+    return page;
+  }
+  const safe = sanitizeRemoteMarkdown(document.body);
+  return safe === null ? null : markdownPage({ ...document, body: safe }, id, "generic").page;
+}
+function assetReferences(capture) {
+  if (!/html/i.test(capture.contentType)) {
+    return markdownNodes(capture.body).filter((node) => node.type === "image").flatMap((node) => node.url ? [node.url] : []);
+  }
+  const $ = load3(capture.body);
+  const root = $('main article,article,main,[role="main"]').first();
+  return [
+    ...root.find("img[src],video[poster],a[download][href]").toArray().map((node) => $(node).attr("src") ?? $(node).attr("poster") ?? $(node).attr("href")),
+    ...root.find("[srcset]").toArray().flatMap((node) => migrationImageCandidates($(node).attr("srcset") ?? "", capture.finalUrl).map((candidate) => candidate.url))
+  ].filter(Boolean);
+}
+function unresolvedStaticControls(body) {
+  const $ = load3(body);
+  const root = $('main article,article,main,[role="main"]').first();
+  const tabs = root.find('[role="tab"]').toArray();
+  for (const tab of tabs) {
+    const controls = $(tab).attr("aria-controls");
+    const panels = controls ? root.find("[id]").filter((_index, node) => $(node).attr("id") === controls) : root.find('[role="tabpanel"]').eq(tabs.indexOf(tab));
+    if (panels.length !== 1 || !panels.text().trim() && !panels.find("pre,img,table,svg").length || panels.find('[aria-busy="true"],[role="progressbar"]').length) return true;
+  }
+  return root.find("details:not([open])").toArray().some((node) => {
+    const clone = $(node).clone();
+    clone.children("summary").remove();
+    return !clone.text().trim() && !clone.find("pre,img,table,svg").length;
+  });
+}
+async function defaultAssetFetcher(url, signal) {
+  const response = await fetch(url, { signal: signal ?? AbortSignal.timeout(15e3) });
+  if (!response.ok) throw new Error(`Asset returned ${response.status}.`);
+  if (Number(response.headers.get("content-length")) > MAX_ASSET_BYTES2) throw new Error("Asset exceeds size limit.");
+  const reader = response.body?.getReader();
+  const chunks = [];
+  let size = 0;
+  if (reader) while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    size += next.value.length;
+    if (size > MAX_ASSET_BYTES2) {
+      await reader.cancel();
+      throw new Error("Asset exceeds size limit.");
+    }
+    chunks.push(next.value);
+  }
+  return { url: response.url || url.toString(), contentType: response.headers.get("content-type") ?? "", content: Buffer.concat(chunks) };
+}
+function acceptedAsset(asset) {
+  if (asset.content.byteLength > MAX_ASSET_BYTES2) return null;
+  const mime = asset.contentType.split(";", 1)[0].toLowerCase().trim();
+  if (mime === "image/svg+xml") return isPassiveSvg(asset.content) ? "svg" : null;
+  const signature = Buffer.from(asset.content.slice(0, 16));
+  const extensions = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp", "application/pdf": "pdf", "image/avif": "avif" };
+  const extension = extensions[mime];
+  if (!extension) return null;
+  const isSignatureValid = extension === "png" ? signature.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) : extension === "jpg" ? signature[0] === 255 && signature[1] === 216 : extension === "gif" ? /^GIF8[79]a/.test(signature.toString()) : extension === "webp" ? signature.toString("ascii", 0, 4) === "RIFF" && signature.toString("ascii", 8, 12) === "WEBP" : extension === "pdf" ? signature.toString("ascii", 0, 5) === "%PDF-" : signature.toString("ascii", 4, 8) === "ftyp" && /avif|avis/.test(signature.toString("ascii", 8));
+  return isSignatureValid ? extension : null;
+}
+function validRecord(record) {
+  if (record.outcome !== "imported") return true;
+  return Boolean(record.page && record.pageSha256 === pageHash(record.page) && record.evidence && pageIdFromReference(record.page.id, true) === record.page.id && pageIdFromReference(record.page.navigationId, true) === record.page.navigationId && sanitizeRemoteMarkdown(record.page.body.replace(/^<a id="[^"<]*" \/>$/gm, "")) !== null && /^[a-f0-9]{64}$/.test(record.evidence.sha256) && record.assets?.every((asset) => /^migration-assets\/[a-f0-9]{64}\.[a-z0-9]+$/.test(asset.path) && hash2(Buffer.from(asset.base64, "base64")) === asset.sha256));
+}
+function navigationConfig(navigation, records) {
+  const project2 = (nodes) => nodes.flatMap((node) => {
+    const record = node.url ? records.get(canonical(node.url, node.url) ?? "") : void 0;
+    const target = record?.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+    const page = target?.page;
+    const children = project2(node.children ?? []);
+    if (children.length) {
+      const contains = (entries) => entries.some((entry) => typeof entry === "string" ? entry === page?.navigationId : contains(entry.pages));
+      return [{ group: node.label || "Documentation", pages: [...page && !contains(children) ? [page.navigationId] : [], ...children] }];
+    }
+    return page ? [page.navigationId] : [];
+  });
+  const pages = project2(navigation);
+  return pages.length ? { tabs: [{ tab: "Documentation", pages }] } : null;
+}
+function observedLocale(document, id, scopePath) {
+  const issues = [];
+  const canonicalLanguage = (value) => {
+    if (!/^[a-z]{2,3}(?:-[a-z0-9]{2,8}){0,4}$/i.test(value)) return void 0;
+    try {
+      return Intl.getCanonicalLocales(value)[0];
+    } catch {
+      return void 0;
+    }
+  };
+  const candidates = [];
+  if (document.locale) {
+    const locale = canonicalLanguage(document.locale);
+    if (!locale) throw new Error("Capture locale is not a portable language code.");
+    candidates.push({ source: "capture", value: locale });
+  }
+  const urlLocale = [id.split("/", 1)[0], ...scopePath.split("/"), document.finalUrl.pathname.split("/").filter(Boolean)[0]].find((segment) => segment && LOCALES.has(segment.toLowerCase()));
+  if (urlLocale) candidates.push({ source: "URL", value: canonicalLanguage(urlLocale) });
+  const declared = /html/i.test(document.contentType) ? load3(document.body)("html").attr("lang")?.trim() : void 0;
+  if (declared) {
+    const locale = canonicalLanguage(declared);
+    if (locale) candidates.push({ source: "html lang", value: locale });
+    else issues.push({ code: "unsupported-component", source: document.finalUrl.href, message: "The source declares an unsupported HTML language; review its locale configuration." });
+  }
+  if (new Set(candidates.map((candidate) => candidate.value)).size > 1) {
+    issues.push({ code: "unsupported-component", source: document.finalUrl.href, message: `Observed locale metadata disagrees (${candidates.map((candidate) => `${candidate.source}: ${candidate.value}`).join(", ")}); review the source language.` });
+  }
+  return { locale: candidates[0]?.value, issues };
+}
+function localeProjection(checkpoint) {
+  const pages = checkpoint.records.flatMap((record) => record.page ? [record.page] : []);
+  const canonicalLocale = (page) => {
+    try {
+      return page.locale ? Intl.getCanonicalLocales(page.locale)[0] : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const locales = [...new Set(pages.map(canonicalLocale).filter((locale) => Boolean(locale)))];
+  const defaultLocale = pages.some((page) => !page.locale) || locales.includes("en") ? "en" : locales[0] ?? "en";
+  const pageId = (page) => {
+    const locale = canonicalLocale(page);
+    return locale ? `${locale === defaultLocale ? "" : `${locale}/`}${page.navigationId}` : page.id;
+  };
+  const route = (page) => {
+    const locale = canonicalLocale(page);
+    const prefix = locale && locale !== defaultLocale ? `/${locale}` : "";
+    return `${prefix}${page.navigationId === "introduction" ? "/" : `/${page.navigationId}`}`;
+  };
+  return { canonicalLocale, locales, defaultLocale, pageId, route };
+}
+function validateUrlMigration(checkpoint, cancelled = false) {
+  const issues = [];
+  const counts = { pending: 0, imported: 0, excluded: 0, failed: 0, alias: 0 };
+  const records = new Map(checkpoint.records.map((record) => [record.url, record]));
+  const source = new URL(checkpoint.sourceUrl);
+  const projection = localeProjection(checkpoint);
+  const primaryIds = new Set(checkpoint.records.flatMap((record) => record.page && (!record.page.locale || projection.canonicalLocale(record.page) === projection.defaultLocale) ? [record.page.navigationId] : []));
+  const outputIds = /* @__PURE__ */ new Set();
+  const resolve4 = (url) => {
+    const record = records.get(canonical(url, checkpoint.sourceUrl) ?? "");
+    return record?.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+  };
+  for (const record of checkpoint.records) {
+    counts[record.outcome]++;
+    issues.push(...record.issues ?? []);
+    if (record.outcome === "pending" || record.outcome === "failed") issues.push({ code: "missing-page", source: record.url, message: record.reason ?? `Inventory entry is ${record.outcome}.` });
+    if (!record.page || !record.evidence) continue;
+    const outputId = projection.pageId(record.page);
+    if (outputIds.has(outputId)) issues.push({ code: "collision", source: record.url, message: `Multiple source pages map to runtime path ${outputId}.` });
+    outputIds.add(outputId);
+    if (record.page.locale && projection.canonicalLocale(record.page) !== projection.defaultLocale && !primaryIds.has(record.page.navigationId)) {
+      issues.push({ code: "missing-page", source: record.url, message: `Secondary locale ${record.page.locale} requires a primary ${projection.defaultLocale} page at ${record.page.navigationId}; the runtime cannot serve an orphan translation.` });
+    }
+    const actual = markdownCode(record.page.body);
+    if (JSON.stringify(actual) !== JSON.stringify(record.evidence.code)) issues.push({ code: "code-mismatch", source: record.url, message: "Source code payloads differ from converted code payloads." });
+    for (const value of record.evidence.links) {
+      let link;
+      try {
+        link = new URL(value, record.evidence.finalUrl);
+      } catch {
+        continue;
+      }
+      if (!inScope(link, source, checkpoint.scopePath)) continue;
+      if (/\.(?:png|jpe?g|gif|svg|webp|avif|pdf|zip|mp4|webm|css|js|json|ya?ml)$/i.test(link.pathname)) continue;
+      const destination = resolve4(link.toString());
+      if (!destination || !["imported", "excluded"].includes(destination.outcome)) {
+        issues.push({ code: "missing-page", source: record.url, message: `Unresolved internal destination: ${link}` });
+      } else if (link.hash && destination.outcome === "imported") {
+        let anchor = link.hash.slice(1);
+        try {
+          anchor = decodeURIComponent(anchor);
+        } catch {
+        }
+        if (!destination.evidence?.anchors.includes(anchor)) issues.push({ code: "missing-anchor", source: record.url, message: `Missing source anchor: ${link}` });
+      }
+    }
+  }
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (node.url) {
+        const url = new URL(node.url, source);
+        if (inScope(url, source, checkpoint.scopePath) && !resolve4(url.toString())?.page) issues.push({ code: "navigation-missing", source: node.url, message: `Source navigation target ${node.label} was not imported.` });
+      }
+      visit(node.children ?? []);
+    }
+  };
+  visit(checkpoint.navigation);
+  if (!counts.imported) issues.push({ code: "missing-page", source: checkpoint.sourceUrl, message: "No readable article pages were imported." });
+  return { status: cancelled ? "cancelled" : issues.length ? "partial" : "passed", issues, counts };
+}
+async function runUrlMigration(options) {
+  const source = validateMigrationUrl(options.sourceUrl);
+  const sourceUrl = canonical(source.toString(), source.toString());
+  const requestedScope = options.scopePath ?? (source.pathname.endsWith("/") ? source.pathname : source.pathname.slice(0, source.pathname.lastIndexOf("/")) || "/");
+  let scopeEnd = requestedScope.length;
+  while (scopeEnd > 0 && requestedScope.charCodeAt(scopeEnd - 1) === 47) scopeEnd--;
+  const scopePath = requestedScope.slice(0, scopeEnd) || "/";
+  if (!scopePath.startsWith("/") || scopePath.includes("?") || scopePath.includes("#") || !inScope(source, source, scopePath)) throw new Error("The selected documentation scope must contain the source URL.");
+  const maxPages = options.maxPages ?? 1e3;
+  if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > 1e4) throw new Error("maxPages must be between 1 and 10000.");
+  const concurrency = Math.max(1, Math.min(32, Math.floor(options.concurrency ?? 5)));
+  const batchSize = Math.max(1, Math.min(500, Math.floor(options.batchSize ?? 50)));
+  if (!Number.isFinite(concurrency) || !Number.isFinite(batchSize) || options.maxCaptures !== void 0 && (!Number.isInteger(options.maxCaptures) || options.maxCaptures < 1) || options.maxTotalBytes !== void 0 && (!Number.isFinite(options.maxTotalBytes) || options.maxTotalBytes < 1)) throw new Error("Migration batch, concurrency and byte limits must be positive finite numbers.");
+  const captureVersion = options.captureVersion ?? "fetch-v1";
+  if (options.checkpoint && options.checkpoint.records.length > MAX_RECORDS) throw new Error("Checkpoint inventory exceeds its bound.");
+  const checkpoint = options.checkpoint ? cloneUrlMigrationCheckpoint(options.checkpoint) : { schemaVersion: 1, converterVersion: CONVERTER_VERSION, sourceUrl, scopePath, captureVersion, records: [], navigation: [] };
+  if (checkpoint.schemaVersion !== 1 || checkpoint.converterVersion !== CONVERTER_VERSION || checkpoint.sourceUrl !== sourceUrl || checkpoint.scopePath !== scopePath || checkpoint.captureVersion !== captureVersion) throw new Error("Checkpoint does not match this source, scope or capture/converter version.");
+  if (checkpoint.records.length > MAX_RECORDS) throw new Error("Checkpoint inventory exceeds its bound.");
+  const records = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) {
+    if (canonical(record.url, sourceUrl) !== record.url || !inScope(new URL(record.url), source, scopePath) && !isDiscoveryIndex(new URL(record.url), source)) throw new Error("Checkpoint contains an unsafe inventory URL.");
+    if (records.has(record.url)) throw new Error("Checkpoint contains a duplicate inventory URL.");
+    if (!validRecord(record) || record.outcome === "failed" && options.retryFailed !== false || record.outcome !== "pending" && options.reconcile && !await options.reconcile(record)) {
+      record.outcome = "pending";
+      delete record.page;
+      delete record.pageSha256;
+      delete record.evidence;
+      delete record.assets;
+    }
+    if (record.page && pageIdFromReference(record.page.id, true) !== record.page.id) throw new Error("Checkpoint contains an unsafe page path.");
+    records.set(record.url, record);
+  }
+  const pending = [...records.values()].filter((record) => record.outcome === "pending");
+  let changed = [];
+  let navigationChanged = false;
+  const enqueue = (value, base, discoveredBy) => {
+    const url = canonical(value, base);
+    if (!url || !inScope(new URL(url), source, scopePath) && !isDiscoveryIndex(new URL(url), source)) return;
+    const existing = records.get(url);
+    if (existing) {
+      if (!existing.discoveredBy.includes(discoveredBy)) {
+        existing.discoveredBy.push(discoveredBy);
+        changed.push(existing);
+      }
+      return;
+    }
+    if (records.size >= MAX_RECORDS) throw new Error("Discovered URL inventory exceeded the 100000 URL safety bound.");
+    const record = { url, discoveredBy: [discoveredBy], outcome: "pending" };
+    records.set(url, record);
+    checkpoint.records.push(record);
+    pending.push(record);
+    changed.push(record);
+  };
+  enqueue(sourceUrl, sourceUrl, "submitted");
+  for (const path of ["llms.txt", "sitemap.xml", "robots.txt"]) enqueue(`${scopePath === "/" ? "" : scopePath}/${path}`, sourceUrl, "discovery-index");
+  if (scopePath !== "/") for (const path of ["llms.txt", "sitemap.xml", "robots.txt"]) enqueue(`/${path}`, sourceUrl, "discovery-index");
+  const fetcher = options.fetcher ?? defaultMigrationFetcher;
+  const capture = options.captureProvider?.capture.bind(options.captureProvider) ?? (async ({ url }) => fetcher(url, { accept: ACCEPT }));
+  const assetFetcher = options.assetFetcher ?? (!options.fetcher && !options.captureProvider ? defaultAssetFetcher : void 0);
+  const usedIds = new Map([...records.values()].filter((record) => record.page).map((record) => [record.page.id, record.url]));
+  const finalUrls = new Map([...records.values()].filter((record) => record.evidence && record.page).map((record) => [canonical(record.evidence.finalUrl, sourceUrl), record.url]));
+  let imported = usedIds.size;
+  const assetPayloads = new Map(checkpoint.records.flatMap((record) => (record.assets ?? []).map((asset) => [asset.sha256, asset])));
+  const assetBytes = /* @__PURE__ */ new Map();
+  const retainAsset = (asset) => {
+    if (!acceptedAsset(asset)) throw new Error("Asset MIME/signature is unsupported or unsafe to serve.");
+    const sha256 = hash2(asset.content);
+    const content = assetBytes.get(sha256) ?? Buffer.from(asset.content);
+    assetBytes.set(sha256, content);
+    return { ...asset, content };
+  };
+  const assetRequests = createMigrationAssetCache();
+  for (const record of checkpoint.records) for (const asset of record.assets ?? []) {
+    if (!assetRequests.has(asset.url)) {
+      const content = assetBytes.get(asset.sha256) ?? Buffer.from(asset.base64, "base64");
+      assetBytes.set(asset.sha256, content);
+      assetRequests.remember(asset.url, { url: asset.url, contentType: asset.contentType, content });
+    }
+  }
+  let totalBytes = checkpoint.records.reduce((sum, record) => sum + (record.evidence?.byteLength ?? 0), 0) + [...assetPayloads.values()].reduce((sum, asset) => sum + Buffer.byteLength(asset.base64, "base64"), 0);
+  let budgetExhausted = false;
+  let cursor = 0;
+  const flush = async () => {
+    const distinct = [...new Map(changed.map((record) => [record.url, record])).values()];
+    if (options.onCheckpoint) for (let index = 0; index < distinct.length || index === 0 && navigationChanged; index += batchSize) {
+      await options.onCheckpoint({ schemaVersion: 1, converterVersion: CONVERTER_VERSION, scopePath, captureVersion, sourceUrl, records: distinct.slice(index, index + batchSize), ...navigationChanged && index === 0 ? { navigation: checkpoint.navigation } : {} });
+    }
+    changed = [];
+    navigationChanged = false;
+  };
+  const process2 = async (record) => {
+    if (options.signal?.aborted) return;
+    try {
+      delete record.reason;
+      const document = await capture({ url: new URL(record.url), signal: options.signal });
+      if (options.signal?.aborted) return;
+      if (Buffer.byteLength(document.body) > MAX_RESPONSE_BYTES) throw new Error("Captured response exceeds the 8 MB safety bound.");
+      const final = canonical(document.finalUrl.toString(), sourceUrl);
+      const role = classifyMigrationResponse(document);
+      if (!inScope(document.finalUrl, source, scopePath) && !(role === "index" && isDiscoveryIndex(document.finalUrl, source))) {
+        record.outcome = "excluded";
+        record.reason = "Redirected outside the selected origin/path.";
+        return;
+      }
+      if (document.status && document.status >= 400) throw new Error(`Source page returned HTTP ${document.status}.`);
+      if (role !== "page") {
+        totalBytes += Buffer.byteLength(document.body);
+        if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+          budgetExhausted = true;
+          throw new Error("Migration exceeded its content byte budget.");
+        }
+        record.outcome = "excluded";
+        record.reason = `Final response role: ${role}.`;
+        const links = role === "index" ? linksOf(document) : [];
+        record.evidence = { sha256: hash2(document.body), byteLength: Buffer.byteLength(document.body), finalUrl: final, contentType: document.contentType, ...document.artifactRef ? { artifactRef: document.artifactRef } : {}, states: [], code: [], anchors: [], links };
+        for (const link of links) enqueue(link, final, record.url);
+        return;
+      }
+      if (imported >= maxPages) {
+        record.outcome = "excluded";
+        record.reason = "A discovery endpoint resolved to an article after the selected page limit.";
+        return;
+      }
+      const already = finalUrls.get(final);
+      if (already && already !== record.url) {
+        record.outcome = "alias";
+        record.aliasOf = already;
+        return;
+      }
+      finalUrls.set(final, record.url);
+      const id = idForUrl(document.finalUrl, scopePath);
+      if (!id) throw new Error("Source URL has no safe destination path.");
+      if (usedIds.has(id) && usedIds.get(id) !== record.url) {
+        record.outcome = "failed";
+        record.reason = `Destination collision for ${id}.`;
+        return;
+      }
+      usedIds.set(id, record.url);
+      const evidence = evidenceOf(document);
+      const page = convert(document, id);
+      if (!page) {
+        record.outcome = "failed";
+        record.reason = "Content could not be represented as safe inert MDX.";
+        return;
+      }
+      const states = document.states ?? [];
+      if (states.length > 64) throw new Error("Capture contains too many alternative states.");
+      for (const state of states) {
+        if (Buffer.byteLength(state.response.body) > MAX_RESPONSE_BYTES) throw new Error("Alternative state exceeds the 8 MB safety bound.");
+        if (!inScope(state.response.finalUrl, source, scopePath) || classifyMigrationResponse(state.response) !== "page") throw new Error("Capture state escaped its selected scope or article role.");
+        const alternative = convert(state.response, id);
+        if (!alternative) throw new Error(`Alternative state ${state.id} is not inert content.`);
+        const stateCode = /html/i.test(state.response.contentType) ? htmlEvidence(state.response).code : markdownCode(state.response.body);
+        evidence.states.find((entry) => entry.id === state.id).code = stateCode;
+        const difference = alternativeBlocks(alternative.body, page.body);
+        evidence.code.push(...markdownCode(difference));
+        evidence.links.push(...linksOf(state.response));
+        evidence.anchors.push(.../html/i.test(state.response.contentType) ? htmlEvidence(state.response).anchors : markdownHeadingAnchors(state.response.body));
+        if (difference) page.body += `
+
+### ${state.label.replace(/[<>{}#\n\r]/g, "")}
+
+${difference}`;
+      }
+      totalBytes += Buffer.byteLength(document.body) + states.reduce((sum, state) => sum + Buffer.byteLength(state.response.body), 0);
+      evidence.byteLength = Buffer.byteLength(document.body) + states.reduce((sum, state) => sum + Buffer.byteLength(state.response.body), 0);
+      if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+        budgetExhausted = true;
+        throw new Error("Migration exceeded its content byte budget.");
+      }
+      record.assets = [];
+      record.issues = [];
+      if (/html/i.test(document.contentType)) {
+        const $ = load3(document.body);
+        const root = $('main article,article,main,[role="main"]').first();
+        root.find("nav,footer,aside,.theme-doc-breadcrumbs,.theme-doc-toc-mobile,.table-of-contents,.hash-link").remove();
+        root.find('button svg,a.hash-link svg,[aria-hidden="true"] svg,svg[aria-hidden="true"],svg[data-lucide],svg[data-icon]').remove();
+        if (root.find("h1").length > 1) record.issues.push({ code: "unsupported-component", source: record.url, message: "The article contains multiple level-one headings; review their hierarchy." });
+        const unsupported = [...new Set(root.find("iframe,object,embed,canvas,svg,form,input,textarea,select,math,video,audio").toArray().map((node) => node.tagName))];
+        if (unsupported.length) record.issues.push({ code: "unsupported-component", source: record.url, message: `Rendered content requires explicit review for: ${unsupported.join(", ")}.` });
+        if (!states.length && unresolvedStaticControls(document.body)) record.issues.push({ code: "unsupported-component", source: record.url, message: "An interactive alternative has no complete captured panel or disclosure content." });
+      }
+      const suppliedAssets = new Map((document.assets ?? []).map((asset) => [canonical(asset.url, final), asset]));
+      const assetUrls = [...new Set([...assetReferences(document), ...states.flatMap((state) => assetReferences(state.response))].map((url) => canonical(url, final)).filter((url) => Boolean(url)))];
+      if (assetUrls.length > 256 || (document.assets?.length ?? 0) > 256) throw new Error("Capture exceeds the 256 assets per page safety bound.");
+      for (const url of assetUrls) {
+        try {
+          let assetRequest = assetRequests.get(url);
+          if (!suppliedAssets.has(url) && !assetRequest && assetFetcher) {
+            assetRequest = assetRequests.load(url, () => assetFetcher(new URL(url), options.signal).then(retainAsset));
+          }
+          const supplied = suppliedAssets.get(url);
+          const asset = supplied ? retainAsset(supplied) : assetRequest ? await assetRequest : null;
+          if (!asset) throw new Error("Capture host did not supply asset bytes or a binary fetch boundary.");
+          const extension = acceptedAsset(asset);
+          if (!extension) throw new Error("Asset MIME/signature is unsupported or unsafe to serve.");
+          const sha256 = hash2(asset.content);
+          const existing = assetPayloads.get(sha256);
+          if (!existing) {
+            totalBytes += asset.content.byteLength;
+            if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+              budgetExhausted = true;
+              throw new Error("Migration exceeded its content and asset byte budget.");
+            }
+          }
+          const path = `migration-assets/${sha256}.${extension}`;
+          const receipt = { url, path, sha256, contentType: asset.contentType, base64: existing?.base64 ?? Buffer.from(asset.content).toString("base64") };
+          record.assets.push(receipt);
+          if (!existing) assetPayloads.set(sha256, receipt);
+          if (!assetRequests.has(url)) assetRequests.remember(url, asset);
+          page.body = rewriteMarkdownDestinations(page.body, (destination) => canonical(destination, final) === url ? `/${path}${new URL(destination, final).hash}` : destination);
+        } catch (error) {
+          assetRequests.delete(url);
+          record.issues.push({ code: "asset-failed", source: record.url, message: `${url}: ${error instanceof Error ? error.message : String(error)}` });
+        }
+      }
+      if (options.signal?.aborted) return;
+      if (sanitizeRemoteMarkdown(page.body.replace(/^<a id="[^"<]*" \/>$/gm, "")) === null) throw new Error("Converted content did not pass inert MDX validation.");
+      record.evidence = evidence;
+      record.page = page;
+      const language = observedLocale(document, page.id, scopePath);
+      record.issues.push(...language.issues);
+      const canonicalLocale = language.locale;
+      if (canonicalLocale) {
+        page.locale = canonicalLocale;
+        const segments = page.id.split("/");
+        const localeIndex = segments.findIndex((segment) => segment.toLowerCase() === canonicalLocale.toLowerCase());
+        page.navigationId = segments.filter((_segment, index) => index !== localeIndex).join("/") || "introduction";
+        page.id = `${canonicalLocale}/${page.navigationId}`;
+        if (usedIds.has(page.id) && usedIds.get(page.id) !== record.url) throw new Error(`Destination collision for locale page ${page.id}.`);
+        usedIds.delete(id);
+        usedIds.set(page.id, record.url);
+      }
+      record.version = document.version ?? [...page.id.split("/"), ...document.finalUrl.pathname.split("/")].find((segment) => /^v\d+(?:\.\d+)*$/i.test(segment));
+      record.pageSha256 = pageHash(page);
+      record.outcome = "imported";
+      imported++;
+      const navigation = checkpoint.navigation.length ? [] : sourceNavigation(document);
+      if (!checkpoint.navigation.length && navigation.length) {
+        checkpoint.navigation = navigation;
+        navigationChanged = true;
+      }
+      for (const link of evidence.links) {
+        try {
+          const url = new URL(link, final);
+          if (!/\.(?:png|jpe?g|gif|svg|webp|avif|pdf|zip|mp4|webm|css|js)$/i.test(url.pathname)) enqueue(link, final, record.url);
+        } catch {
+        }
+      }
+      const visit = (nodes) => {
+        for (const node of nodes) {
+          if (node.url) enqueue(node.url, final, "source-navigation");
+          visit(node.children ?? []);
+        }
+      };
+      visit(navigation);
+    } catch (error) {
+      if (options.signal?.aborted) return;
+      const wasImported = record.outcome === "imported";
+      record.outcome = record.discoveredBy.every((origin) => origin === "discovery-index") ? "excluded" : "failed";
+      record.reason = error instanceof Error ? error.message : String(error);
+      if (record.page) {
+        if (wasImported) imported--;
+        usedIds.delete(record.page.id);
+      }
+      delete record.page;
+      delete record.pageSha256;
+      delete record.assets;
+    } finally {
+      if (record.outcome !== "pending") {
+        if (options.onRecord) await options.onRecord(record);
+        changed.push(record);
+      }
+    }
+  };
+  while (cursor < pending.length && !options.signal?.aborted && !budgetExhausted && cursor < (options.maxCaptures ?? Infinity)) {
+    if (imported >= maxPages) {
+      const index = pending.findIndex((record, position) => position >= cursor && isDiscoveryIndex(new URL(record.url), source));
+      if (index < 0) break;
+      pending.splice(cursor, 0, pending.splice(index, 1)[0]);
+    }
+    const batch = pending.slice(cursor, cursor + Math.min(concurrency, imported >= maxPages ? 1 : maxPages - imported, (options.maxCaptures ?? Infinity) - cursor));
+    cursor += batch.length;
+    await Promise.all(batch.map(process2));
+    if (changed.length >= batchSize) await flush();
+  }
+  await flush();
+  const projection = localeProjection(checkpoint);
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) {
+    const target = record.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+    if (target?.page) {
+      const route = projection.route(target.page);
+      routeMap.set(record.url, route);
+      if (target.evidence) routeMap.set(canonical(target.evidence.finalUrl, sourceUrl), route);
+    }
+  }
+  const navigationLabels = /* @__PURE__ */ new Map();
+  const navigationIssues = [];
+  const labelPages = (nodes) => {
+    for (const node of nodes) {
+      const entry = node.url ? records.get(canonical(node.url, sourceUrl) ?? "") : void 0;
+      const target = entry?.outcome === "alias" ? records.get(entry.aliasOf ?? "") : entry;
+      if (target?.page && node.label && !node.children?.length) {
+        const previous = navigationLabels.get(target.url);
+        if (previous && previous !== node.label) navigationIssues.push({ code: "unsupported-component", source: target.url, message: `This page has multiple source navigation labels (${previous}, ${node.label}); review the shared sidebar title.` });
+        else navigationLabels.set(target.url, node.label);
+      }
+      labelPages(node.children ?? []);
+    }
+  };
+  labelPages(checkpoint.navigation);
+  const pages = checkpoint.records.flatMap((record) => record.page ? [{ ...record.page, id: projection.pageId(record.page), ...record.page.locale ? { locale: projection.canonicalLocale(record.page) } : {}, ...navigationLabels.has(record.url) ? { navTitle: navigationLabels.get(record.url) } : {}, body: rewriteMarkdownDestinations(record.page.body, (value) => {
+    let url;
+    try {
+      url = new URL(value, record.evidence.finalUrl);
+    } catch {
+      return value;
+    }
+    const route = routeMap.get(canonical(url.toString(), sourceUrl));
+    return route ? `${route}${url.hash}` : value;
+  }) }] : []);
+  const validation = validateUrlMigration(checkpoint, Boolean(options.signal?.aborted));
+  validation.issues.push(...navigationIssues);
+  if (navigationIssues.length && validation.status === "passed") validation.status = "partial";
+  const assets = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) for (const asset of record.assets ?? []) {
+    if (!assets.has(asset.path)) {
+      const content = assetBytes.get(asset.sha256) ?? Buffer.from(asset.base64, "base64");
+      assets.set(asset.path, { path: asset.path, content: Buffer.from(content.buffer, content.byteOffset, content.byteLength) });
+    }
+  }
+  const bundle = {
+    sourceUrl,
+    sourceKind: "url",
+    platform: options.platform ?? "generic",
+    pages,
+    assets: [...assets.values()],
+    docsConfig: navigationConfig(checkpoint.navigation, records) ?? buildNavigationFromPages(pages),
+    warnings: validation.issues.map((issue) => ({ code: issue.code === "missing-page" ? "missing-page" : "unsupported-config", message: issue.message, source: issue.source })),
+    urlMigrationValidation: validation,
+    stats: { discovered: records.size, imported: pages.length, skipped: records.size - pages.length }
+  };
+  if (projection.locales.length) {
+    const locales = [.../* @__PURE__ */ new Set([projection.defaultLocale, ...projection.locales])];
+    bundle.docsConfig.i18n = { defaultLocale: projection.defaultLocale, locales: locales.map((code) => ({ code, label: code === "en" ? "English" : code })) };
+  }
+  const stopReason = options.signal?.aborted ? "cancelled" : budgetExhausted ? "byte-limit" : cursor < pending.length && cursor >= (options.maxCaptures ?? Infinity) ? "capture-limit" : imported >= maxPages && cursor < pending.length ? "page-limit" : cursor < pending.length ? "capture-limit" : "complete";
+  return { bundle, checkpoint, validation, stopReason };
+}
+function rewriteMarkdownDestinations(body, rewrite) {
+  const edits = markdownNodes(body).filter((node) => node.url && node.position).map((node) => {
+    const start = node.position.start.offset;
+    const end = node.position.end.offset;
+    const original = body.slice(start, end);
+    const replacement = rewrite(node.url);
+    if (replacement === node.url) return null;
+    const index = original.lastIndexOf(node.url);
+    if (index < 0) return null;
+    return { start: start + index, end: start + index + node.url.length, replacement };
+  }).filter((edit) => edit !== null).sort((a, b) => b.start - a.start);
+  for (const node of markdownNodes(body)) for (const attribute of node.attributes ?? []) {
+    if (!attribute.name || !["src", "href", "srcSet", "srcset", "img", "primaryHref", "secondaryHref"].includes(attribute.name) || !attribute.position) continue;
+    let value = attribute.value;
+    if (typeof value !== "string") {
+      try {
+        value = JSON.parse(value?.value ?? "");
+      } catch {
+        continue;
+      }
+    }
+    if (typeof value !== "string") continue;
+    let replacement;
+    if (/^srcset$/i.test(attribute.name)) {
+      const candidates = migrationImageCandidates(value, new URL("https://migration.invalid"), false);
+      replacement = renderMigrationSrcset(candidates.map((candidate) => ({ ...candidate, url: rewrite(candidate.url) })));
+      if (replacement === renderMigrationSrcset(candidates)) continue;
+    } else {
+      replacement = rewrite(value);
+      if (replacement === value) continue;
+    }
+    const start = attribute.position.start.offset, end = attribute.position.end.offset;
+    if (start === void 0 || end === void 0) continue;
+    edits.push({ start, end, replacement: `${attribute.name}="${migrationImageAttribute(replacement)}"` });
+  }
+  edits.sort((a, b) => b.start - a.start);
+  for (const edit of edits) body = body.slice(0, edit.start) + edit.replacement + body.slice(edit.end);
+  return body;
+}
+
+// src/remote-api.ts
+import { createHash as createHash4 } from "crypto";
 import { lookup } from "dns/promises";
 import { request } from "https";
 import { isIP } from "net";
@@ -13606,7 +14857,7 @@ async function hydrateRemoteApiSpecs(bundle, fetcher) {
       const body = pruned.content;
       if (reference.withheldOperations?.length) warnings.push({ code: "gated-page", message: sharedSpecMessage(reference.url, pruned.excluded), source: reference.url });
       const operations = parseOpenApi(body, extension);
-      const filename = `openapi-${createHash3("sha256").update(reference.url).digest("hex").slice(0, 12)}.${extension}`;
+      const filename = `openapi-${createHash4("sha256").update(reference.url).digest("hex").slice(0, 12)}.${extension}`;
       assets.push({ path: `openapi/${filename}`, content: body, projectRelative: true });
       for (const page of pages) {
         const ref = page.openapi ? splitOpenApiRef(page.openapi) : null;
@@ -13652,6 +14903,7 @@ export {
   SOURCE_REF_MAX_REPOSITORY_KB,
   addMintlifyDirectoryRedirects,
   buildNavigationFromPages,
+  classifyMigrationResponse,
   cloneGitHubRepository,
   defaultMigrationFetcher,
   detectRepositoryDocsDir,
@@ -13659,6 +14911,7 @@ export {
   gitmodulePaths,
   hydrateRemoteApiSpecs,
   importSourceRef,
+  isPassiveSvg,
   mergeMigrationConfig,
   migrateRepository,
   migrateUrl,
@@ -13673,8 +14926,10 @@ export {
   readFernConfig,
   readMintlifyConfig,
   renderMigrationFiles,
+  runUrlMigration,
   sourceRefOversizeReason,
   validateIntegrations,
-  validateMigrationUrl
+  validateMigrationUrl,
+  validateUrlMigration
 };
 //# sourceMappingURL=index.js.map