@thallylabs/migrate 0.2.41 → 0.2.43

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/repository.ts
 import { compileSync as compileSync2 } from "@mdx-js/mdx";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { spawn } from "child_process";
 import {
   closeSync,
@@ -801,9 +801,9 @@ import { basename, dirname, extname as extname2, posix as posix2, relative as re
 import postcss from "postcss";
 import selectorParser from "postcss-selector-parser";
 import remarkMdx2 from "remark-mdx";
-import remarkParse2 from "remark-parse";
+import remarkParse3 from "remark-parse";
 import ts2 from "typescript";
-import { unified as unified2 } from "unified";
+import { unified as unified3 } from "unified";
 
 // src/frontmatter.ts
 import { parse as parseYaml } from "yaml";
@@ -856,8 +856,8 @@ import { compileSync } from "@mdx-js/mdx";
 import { nameToEmoji } from "gemoji";
 import remarkGfm from "remark-gfm";
 import remarkMdx from "remark-mdx";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
+import remarkParse2 from "remark-parse";
+import { unified as unified2 } from "unified";
 
 // src/mintlify-extras.ts
 import { extname } from "path";
@@ -885,8 +885,8 @@ function slugifySegment(value, preserveCase = false) {
   } catch {
   }
   const normalized = preserveCase ? decoded : decoded.toLowerCase();
-  const slug2 = normalized.replace(/\.(?:html?|mdx?)$/i, "").replace(SAFE_SEGMENT, "-").replace(/(^-|-$)/g, "");
-  return slug2 === "." || slug2 === ".." ? "" : slug2;
+  const slug3 = normalized.replace(/\.(?:html?|mdx?)$/i, "").replace(SAFE_SEGMENT, "-").replace(/(^-|-$)/g, "");
+  return slug3 === "." || slug3 === ".." ? "" : slug3;
 }
 function pageIdFromReference(value, preserveCase = false) {
   const withoutQuery = value.split(/[?#]/, 1)[0].replace(/\\/g, "/").replace(/^\/+/, "");
@@ -1125,13 +1125,103 @@ function playgroundDisplay(value, where, warn) {
   return void 0;
 }
 
+// src/fence-meta.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function delimitedEnd(meta, start) {
+  const opening = meta[start];
+  if (opening === '"' || opening === "'") {
+    let close = start + 1;
+    while (close < meta.length && meta[close] !== opening) close += meta[close] === "\\" && meta[close + 1] === opening ? 2 : 1;
+    return close < meta.length ? close + 1 : close;
+  }
+  if (opening !== "{") return void 0;
+  let depth = 0;
+  let quote = "";
+  for (let index = start; index < meta.length; index++) {
+    const char = meta[index];
+    if (quote) {
+      if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === "{") depth++;
+    else if (char === "}" && --depth === 0) return index + 1;
+  }
+  return meta.length;
+}
+function tokens(meta) {
+  const result = [];
+  let index = 0;
+  while (index < meta.length) {
+    if (/\s/.test(meta[index])) {
+      index++;
+      continue;
+    }
+    const start = index;
+    const delimited = delimitedEnd(meta, index);
+    if (delimited !== void 0) {
+      result.push({ start, end: delimited, value: meta.slice(start, delimited), quoted: meta[start] !== "{", group: meta[start] === "{" });
+      index = delimited;
+      continue;
+    }
+    const key = /^([A-Za-z][\w-]*)=/.exec(meta.slice(index));
+    if (key) {
+      index += key[0].length;
+      const groupEnd = delimitedEnd(meta, index);
+      if (groupEnd !== void 0) index = groupEnd;
+      else while (index < meta.length && !/\s/.test(meta[index])) index++;
+      result.push({ start, end: index, key: key[1], value: meta.slice(start, index) });
+      continue;
+    }
+    while (index < meta.length && !/\s/.test(meta[index])) {
+      if (index > start && meta[index] === "{" && /^\{[\d,\s-]*\}/.test(meta.slice(index))) break;
+      index++;
+    }
+    result.push({ start, end: index, value: meta.slice(start, index) });
+  }
+  return result;
+}
+function normalizeMintlifyCodeFences(body, warn) {
+  const tree = unified().use(remarkParse).parse(body);
+  const edits = [];
+  const removed = /* @__PURE__ */ new Set();
+  const unknown = /* @__PURE__ */ new Set();
+  const supported = /* @__PURE__ */ new Set(["title", "filename", "framework", "tag", "icon", "highlight", "focus", "wrap", "lines", "expandable", "nocopy"]);
+  function visit(node) {
+    if (node.type === "code" && node.position?.start.offset !== void 0) {
+      const start = node.position.start.offset;
+      const lineEnd = body.indexOf("\n", start);
+      const end = lineEnd < 0 ? body.length : lineEnd;
+      const line = body.slice(start, end);
+      const opening = /^([`~]{3,}[^\s]*)([ \t]+)(.*?)(\r?)$/.exec(line);
+      if (opening) {
+        const meta = opening[3];
+        const kept = tokens(meta).filter((token) => {
+          if (token.key === "theme" || !token.key && !token.quoted && !token.group && token.value === "twoslash") {
+            removed.add(token.key ?? token.value);
+            return false;
+          }
+          if (token.key && !supported.has(token.key)) unknown.add(token.key);
+          return true;
+        });
+        const normalized = kept.map((token) => meta.slice(token.start, token.end)).join(" ");
+        if (normalized !== meta && kept.length !== tokens(meta).length) edits.push({ start, end, value: `${opening[1]}${normalized ? ` ${normalized}` : ""}${opening[4]}` });
+      }
+    }
+    for (const child of node.children ?? []) visit(child);
+  }
+  visit(tree);
+  if (removed.size) warn?.(`Removed unsupported Mintlify code-fence options: ${[...removed].join(", ")}. Code examples and supported display options were preserved.`);
+  if (unknown.size) warn?.(`Unsupported Mintlify code-fence options are ignored: ${[...unknown].join(", ")}. Review these renderer-specific options.`);
+  return edits.sort((a, b) => b.start - a.start).reduce((text3, edit) => text3.slice(0, edit.start) + edit.value + text3.slice(edit.end), body);
+}
+
 // src/mdx.ts
 function titleFromId(id) {
   const value = id.split("/").at(-1) ?? id;
   if (value === "introduction") return "Introduction";
   return value.split(/[-_]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-var descriptionParser = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+var descriptionParser = unified2().use(remarkParse2).use(remarkGfm).use(remarkMdx);
 function plainText(node) {
   if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
   if (node.type === "image") return node.alt ?? "";
@@ -2648,13 +2738,41 @@ function externalPageUrl(value) {
 }
 function parseMarkdownPage(input) {
   const parsed = parseFrontmatter(input.raw);
+  if (input.platform === "mintlify") {
+    const supported = /* @__PURE__ */ new Set([
+      "title",
+      "description",
+      "sidebarTitle",
+      "navTitle",
+      "icon",
+      "iconType",
+      "tag",
+      "badge",
+      "keywords",
+      "mode",
+      "hidden",
+      "noindex",
+      "url",
+      "openapi",
+      "api",
+      "authMethod",
+      "playground",
+      // Access settings are enforced by the repository classifier, never lost here.
+      "groups",
+      "public",
+      ...PAGE_META_FIELDS.map(([field]) => field)
+    ]);
+    const dropped = Object.keys(parsed.data).filter((key) => !supported.has(key));
+    if (dropped.length) input.warn?.(`Unsupported Mintlify frontmatter fields were omitted: ${dropped.join(", ")}. Review their behavior before publishing.`);
+  }
   const fallbackIdentity = {
     id: input.id,
     navigationId: input.navigationId ?? input.id,
     ...input.locale ? { locale: input.locale } : {}
   };
   const identity = input.resolveIdentity?.(parsed.data, fallbackIdentity) ?? fallbackIdentity;
-  const body = removeUndefinedExpressions(injectReactHookImports(normalizeMdx(parsed.content, input.platform)), input.warn).trim();
+  const normalized = normalizeMdx(parsed.content, input.platform);
+  const body = removeUndefinedExpressions(injectReactHookImports(input.platform === "mintlify" ? normalizeMintlifyCodeFences(normalized, input.warn) : normalized), input.warn).trim();
   const keywords = Array.isArray(parsed.data.keywords) ? parsed.data.keywords.filter((value) => typeof value === "string") : [];
   const heading = leadingPageHeading(body);
   const title = typeof parsed.data.title === "string" && parsed.data.title.trim() ? parsed.data.title.trim() : heading?.title ?? titleFromId(identity.navigationId);
@@ -2817,7 +2935,7 @@ function youtubeEmbedVideoId(node, specifier) {
   }
   return void 0;
 }
-var parser = unified2().use(remarkParse2).use(remarkMdx2);
+var parser = unified3().use(remarkParse3).use(remarkMdx2);
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs"]);
 var DATA_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".css", ".svg", ".png", ".jpg", ".jpeg", ".webp", ".gif", ".avif", ".woff", ".woff2"]);
 var RESCUABLE_ASSET_EXTENSIONS = /* @__PURE__ */ new Set([".svg", ".png", ".jpg", ".jpeg", ".webp", ".gif", ".avif", ".ico", ".docx", ".pdf"]);
@@ -4495,8 +4613,8 @@ function localReference(value) {
 }
 function jsonPointer(root, pointer) {
   if (!pointer || pointer === "#") return root;
-  const tokens = pointer.replace(/^#\/?/, "").split("/").filter(Boolean);
-  return tokens.reduce((current, token) => {
+  const tokens2 = pointer.replace(/^#\/?/, "").split("/").filter(Boolean);
+  return tokens2.reduce((current, token) => {
     if (Array.isArray(current)) {
       const index = Number(token);
       return Number.isSafeInteger(index) && index >= 0 ? current[index] : void 0;
@@ -6416,8 +6534,8 @@ function docusaurusSlugifySegment(value) {
     decoded = decodeURIComponent(value);
   } catch {
   }
-  const slug2 = decoded.replace(/\.(?:html?|mdx?)$/i, "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/(^-|-$)/g, "");
-  return slug2 === "." || slug2 === ".." ? "" : slug2;
+  const slug3 = decoded.replace(/\.(?:html?|mdx?)$/i, "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/(^-|-$)/g, "");
+  return slug3 === "." || slug3 === ".." ? "" : slug3;
 }
 function docusaurusRouteId(value) {
   const segments = normalizeDocId(value).split("/").map(docusaurusSlugifySegment).filter(Boolean);
@@ -6435,11 +6553,11 @@ function storageIdForRoute(routeId) {
 function titleCase3(value) {
   return stripNumberPrefix(value).replace(/sidebar$/i, "").split(/[-_]/).filter(Boolean).map((word) => ["api", "cli", "sdk", "ui"].includes(word.toLowerCase()) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-function routeFromSlug(slug2, fallback, sourceDirectory) {
-  if (slug2 === "/") return "introduction";
-  if (slug2.startsWith("/")) return docusaurusRouteId(slug2);
+function routeFromSlug(slug3, fallback, sourceDirectory) {
+  if (slug3 === "/") return "introduction";
+  if (slug3.startsWith("/")) return docusaurusRouteId(slug3);
   const fallbackDirectory = sourceDirectory ?? (fallback === "introduction" ? "" : posix3.dirname(fallback));
-  const resolved = posix3.normalize(posix3.join(fallbackDirectory, slug2));
+  const resolved = posix3.normalize(posix3.join(fallbackDirectory, slug3));
   if (resolved === ".." || resolved.startsWith("../")) return null;
   return docusaurusRouteId(resolved);
 }
@@ -6560,9 +6678,9 @@ function expandDocusaurusDocCardLists(pages, config, sourceRoutes) {
         const target2 = pageByRoute.get(item);
         return [{ title: target2?.title ?? item.split("/").at(-1) ?? item, route: item }];
       }
-      const slug2 = slugifySegment(item.group);
+      const slug3 = slugifySegment(item.group);
       const routes = [...item.pages].flatMap((child) => typeof child === "string" ? [child] : []);
-      const route = routes.find((candidate) => candidate === slug2 || candidate.endsWith(`/${slug2}`)) ?? firstRoute(item.pages);
+      const route = routes.find((candidate) => candidate === slug3 || candidate.endsWith(`/${slug3}`)) ?? firstRoute(item.pages);
       return route ? [{ title: item.group, route }] : [];
     });
     const markup = cards.length ? `<CardGroup>
@@ -7395,7 +7513,7 @@ function readDocusaurusPresentation(repositoryRoot) {
     }
     return styles.join(";");
   };
-  let tokens = "";
+  let tokens2 = "";
   const prismStart = propertyStart(config, "prism");
   const prism = prismStart < 0 ? null : matchingObjectLiteral(config, prismStart);
   const themeStart = prism ? propertyStart(prism, "theme") : -1;
@@ -7421,7 +7539,7 @@ function readDocusaurusPresentation(repositoryRoot) {
         const hex = typeof style.style?.color === "string" ? cssColorToHex(style.style.color) : void 0;
         if (tokenNames[type] && hex) colors.set(`--shiki-token-${tokenNames[type]}`, hex);
       }
-      tokens = [...colors].map(([name, hex]) => `${name}:${hex}`).join(";");
+      tokens2 = [...colors].map(([name, hex]) => `${name}:${hex}`).join(";");
     }
   } catch {
   }
@@ -7449,7 +7567,7 @@ body{font-family:${safeBodyFont}}
 .thally-docs-prose{line-height:1.5;color:var(--docs-ink)}
 .thally-docs-prose p{margin-block:0 1rem}
 .thally-docs-prose a{color:var(--docs-accent)}
-.thally-docs-code{${tokens};background:var(--docs-code-bg)}
+.thally-docs-code{${tokens2};background:var(--docs-code-bg)}
 @media(min-width:1024px){
 .thally-docs-shell{max-width:none;padding-inline:0}
 .thally-docs-sidebar,.thally-docs-sidebar>div{width:300px}
@@ -7471,10 +7589,45 @@ function unquote(value) {
 }
 function splitOpenApiRef(raw) {
   const value = unquote(raw);
-  const match = /^(?:(.+?)\s+)?((?:webhook\s+[^\s/]\S*)|(?:[A-Za-z]+\s+\/.*))$/i.exec(value);
-  if (!match) return null;
-  const specRef = match[1] ? unquote(match[1]) : void 0;
-  return { ...specRef ? { specRef } : {}, operation: match[2] };
+  let firstLineBreak = -1;
+  let lastLineBreak = -1;
+  let lastWhitespace = -1;
+  for (let index = 0; index < value.length; index++) {
+    const character = value[index];
+    if (/\s/.test(character)) lastWhitespace = index;
+    if (character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029") {
+      if (firstLineBreak < 0) firstLineBreak = index;
+      lastLineBreak = index;
+    }
+  }
+  let bare = null;
+  let previousEnd = 0;
+  let start = 0;
+  while (start < value.length) {
+    let end = start;
+    let letters = true;
+    while (end < value.length && !/\s/.test(value[end])) {
+      const code = value.charCodeAt(end);
+      if (!(code >= 65 && code <= 90) && !(code >= 97 && code <= 122)) letters = false;
+      end++;
+    }
+    let argument = end;
+    while (argument < value.length && /\s/.test(value[argument])) argument++;
+    const hasArgument = argument > end && argument < value.length;
+    const method = letters && value[argument] === "/" && lastLineBreak < argument;
+    const webhook = end - start === 7 && value.slice(start, end).toLowerCase() === "webhook" && value[argument] !== "/" && lastWhitespace < argument;
+    if (hasArgument && (method || webhook)) {
+      if (start === 0) bare = { operation: value };
+      else {
+        const specRef = unquote(value.slice(0, previousEnd));
+        return { ...specRef ? { specRef } : {}, operation: value.slice(start) };
+      }
+    }
+    previousEnd = end;
+    if (firstLineBreak >= 0 && firstLineBreak < previousEnd) break;
+    start = argument;
+  }
+  return bare;
 }
 function canonicalSpecRef(specRef) {
   return specRef.trim().split(/[?#]/, 1)[0].replace(/\\/g, "/").replace(/^(?:\.?\/+)+/, "");
@@ -7628,11 +7781,246 @@ import { isAbsolute as isAbsolute2, join, relative as relative5, resolve as reso
 // src/url.ts
 import { load as load4 } from "cheerio";
 import remarkMdx4 from "remark-mdx";
-import remarkParse4 from "remark-parse";
+import remarkParse5 from "remark-parse";
 import TurndownService from "turndown";
-import { unified as unified4 } from "unified";
+import { unified as unified5 } from "unified";
 import { parse as parseYaml5, stringify as stringifyYaml2 } from "yaml";
 
+// src/url-openapi.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/remote-spec.ts
+import { lookup } from "dns/promises";
+import { request } from "https";
+import { isIP } from "net";
+var isWithheld = (node) => [node["x-hidden"], node["x-excluded"]].some((value) => value === true || value === "true");
+var MAX_SPEC_BYTES = 25e6;
+var MAX_REDIRECTS = 3;
+function isPublicAddress(address, family) {
+  if (family === 4) {
+    const parts = address.split(".").map(Number);
+    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+    const [a, b] = parts;
+    return !(a === 0 || a === 10 || a === 127 || a >= 224 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 0 || b === 168) || a === 198 && (b === 18 || b === 19) || a === 203 && b === 0 || a === 198 && b === 51);
+  }
+  return family === 6 && /^[23][0-9a-f]{0,3}:/i.test(address) && !/^2001:db8:/i.test(address);
+}
+function validatedSpecUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.username || url.password || isIP(url.hostname)) {
+    throw new Error("Remote OpenAPI references must use an HTTPS domain without credentials or an IP literal.");
+  }
+  url.hash = "";
+  return url;
+}
+async function getPinnedAddress(url) {
+  const addresses = await lookup(url.hostname, { all: true });
+  if (addresses.length === 0 || addresses.some((candidate) => !isPublicAddress(candidate.address, candidate.family))) {
+    throw new Error("The OpenAPI host did not resolve exclusively to public addresses.");
+  }
+  return addresses[0];
+}
+async function requestPinnedSpec(url) {
+  const pinned = await getPinnedAddress(url);
+  return new Promise((resolve5, reject) => {
+    const req = request(url, {
+      headers: { Accept: "application/json, application/yaml, text/yaml, */*", "User-Agent": "Thally-Migrate/1.0 (+https://thally.io)" },
+      signal: AbortSignal.timeout(3e4),
+      // Node's dual-stack connector asks lookup for `all: true`; that
+      // callback must receive address records, not a single address string.
+      lookup: (_hostname, options, callback) => {
+        if (typeof options === "object" && options.all) callback(null, [pinned]);
+        else callback(null, pinned.address, pinned.family);
+      }
+    }, (response) => {
+      const status = response.statusCode ?? 0;
+      if (status >= 300 && status < 400) {
+        response.resume();
+        resolve5({ status, location: response.headers.location, body: Buffer.alloc(0) });
+        return;
+      }
+      if (status < 200 || status >= 300) {
+        response.resume();
+        reject(new Error(`OpenAPI server returned ${status}.`));
+        return;
+      }
+      const statedBytes = Number(response.headers["content-length"] ?? 0);
+      if (statedBytes > MAX_SPEC_BYTES) {
+        response.destroy();
+        reject(new Error("Remote OpenAPI spec exceeds the 25 MB import limit."));
+        return;
+      }
+      const chunks = [];
+      let bytes = 0;
+      response.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > MAX_SPEC_BYTES) {
+          response.destroy(new Error("Remote OpenAPI spec exceeds the 25 MB import limit."));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => resolve5({ status, body: Buffer.concat(chunks) }));
+      response.on("error", reject);
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+async function downloadSpec(value, fetcher) {
+  let url = validatedSpecUrl(value);
+  if (fetcher) {
+    const response = await fetcher(url, { accept: "application/json, application/yaml, text/yaml" });
+    validatedSpecUrl(response.finalUrl.toString());
+    const body = Buffer.from(response.body);
+    if (body.length > MAX_SPEC_BYTES) throw new Error("Remote OpenAPI spec exceeds the 25 MB import limit.");
+    return body;
+  }
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const response = await requestPinnedSpec(url);
+    if (response.status >= 300 && response.status < 400) {
+      if (!response.location || hop === MAX_REDIRECTS) throw new Error("Remote OpenAPI spec redirected too many times.");
+      url = validatedSpecUrl(new URL(response.location, url).toString());
+      continue;
+    }
+    return response.body;
+  }
+  throw new Error("Remote OpenAPI spec redirected too many times.");
+}
+function parseOpenApi(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("OpenAPI spec is not an object.");
+  const document = parsed;
+  if (typeof document.openapi !== "string" || !/^3\./.test(document.openapi)) {
+    throw new Error("Remote specification is not OpenAPI 3.x.");
+  }
+  if (!document.paths || typeof document.paths !== "object" || Array.isArray(document.paths)) {
+    throw new Error("Remote OpenAPI spec has no paths object.");
+  }
+  const paths = Object.entries(document.paths);
+  if (paths.length > 5e3) throw new Error("Remote OpenAPI spec has too many paths to import.");
+  const operations = [];
+  for (const [path, value] of paths) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || isWithheld(value)) continue;
+    for (const [method, raw] of Object.entries(value)) {
+      if (!/^(get|post|put|patch|delete|head|options|trace)$/i.test(method) || !raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      const operation = raw;
+      if (isWithheld(operation)) continue;
+      const tags = Array.isArray(operation.tags) ? operation.tags : [];
+      operations.push({
+        method: method.toLowerCase(),
+        path,
+        tag: typeof tags[0] === "string" ? tags[0] : "API Reference",
+        summary: typeof operation.summary === "string" ? operation.summary : String(operation.operationId ?? "")
+      });
+    }
+  }
+  return operations;
+}
+
+// src/url-openapi.ts
+var slug = (value) => value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+async function hydrateUrlOpenApi(bundle, specUrl, fetcher) {
+  try {
+    const content = withoutByteOrderMark(await downloadSpec(specUrl, fetcher));
+    const { document, format } = parseSpecDocument(content.toString("utf8"));
+    const operations = parseOpenApi(document);
+    const path = `openapi/openapi-${createHash2("sha256").update(specUrl).digest("hex").slice(0, 12)}.${format}`;
+    const byRoute = /* @__PURE__ */ new Map();
+    for (const operation of operations) {
+      const key = `${slug(operation.tag)}/${slug(operation.summary)}`;
+      if (!slug(operation.summary)) continue;
+      byRoute.set(key, byRoute.has(key) ? null : operation);
+    }
+    const represented = /* @__PURE__ */ new Set();
+    const visible = new Set(operations.map((operation) => operationKey2(`${operation.method} ${operation.path}`)));
+    const assets = bundle.assets.filter((asset) => /\.(?:json|ya?ml)$/i.test(asset.path)).map((asset) => ({ ...asset, sourcePath: canonicalSpecRef(asset.path), filename: specRefBaseName(asset.path) }));
+    const published = /* @__PURE__ */ new Map();
+    const defaultSource = [...bundle.docsConfig.tabs.filter((tab) => !tab.hidden), ...bundle.docsConfig.tabs.filter((tab) => tab.hidden)].find((tab) => tab.api)?.api?.source;
+    const isExistingBinding = (raw) => {
+      const ref = splitOpenApiRef(raw);
+      if (!ref) return void 0;
+      const key = operationKey2(ref.operation);
+      if (!visible.has(key)) return void 0;
+      const source = ref.specRef ?? defaultSource;
+      if (!source) return void 0;
+      const resolved = resolveSpecRef(source, assets, false);
+      if (resolved.kind !== "match") return void 0;
+      const asset = resolved.spec;
+      if (!published.has(asset.path)) {
+        try {
+          const original = parseSpecDocument(Buffer.from(asset.content).toString("utf8")).document;
+          published.set(asset.path, new Set(parseOpenApi(original).map((operation) => operationKey2(`${operation.method} ${operation.path}`))));
+        } catch {
+          published.set(asset.path, /* @__PURE__ */ new Set());
+        }
+      }
+      return published.get(asset.path).has(key) ? { operation: ref.operation, source: asset.path } : void 0;
+    };
+    const reboundSources = /* @__PURE__ */ new Set();
+    const withheld = /* @__PURE__ */ new Set();
+    const kept = /* @__PURE__ */ new Set();
+    const bind = (page, reference) => {
+      const key = operationKey2(reference);
+      represented.add(key);
+      if (page.public === false || page.groups?.length) withheld.add(key);
+      else kept.add(key);
+      return { ...page, openapi: `${path} ${reference}` };
+    };
+    const pages = bundle.pages.map((page) => {
+      if (bundle.sourceKind !== "url") return page;
+      if (page.openapi) {
+        const selected = splitOpenApiRef(page.openapi);
+        if (selected && (selected.specRef === specUrl || selected.specRef === path && assets.some((asset) => asset.path === path)) && visible.has(operationKey2(selected.operation))) {
+          return bind(page, selected.operation);
+        }
+        const bound = isExistingBinding(page.openapi);
+        if (bound) {
+          reboundSources.add(bound.source);
+          return bind(page, bound.operation);
+        }
+        return page;
+      }
+      const operation = byRoute.get(page.navigationId.split("/").slice(-2).join("/").toLowerCase());
+      if (!operation) return page;
+      const reference = `${operation.method.toUpperCase()} ${operation.path}`;
+      return bind(page, reference);
+    });
+    const remaining = operations.map((operation) => `${operation.method.toUpperCase()} ${operation.path}`).filter((reference) => !represented.has(operationKey2(reference)));
+    const pruned = markExcluded(content, [...withheld].filter((key) => !kept.has(key)), [...kept]);
+    const warning = pruned.excluded.length ? { code: "gated-page", source: path, message: sharedSpecMessage(path, pruned.excluded) } : void 0;
+    const api = { source: path, ...represented.size ? remaining.length ? { groups: [{ group: "Endpoints", pages: remaining }] } : { navigation: false } : {} };
+    const stillReferenced = new Set(pages.flatMap((page) => {
+      const source = page.openapi ? splitOpenApiRef(page.openapi)?.specRef ?? defaultSource : void 0;
+      if (!source) return [];
+      const resolved = resolveSpecRef(source, assets, false);
+      return resolved.kind === "match" ? [resolved.spec.path] : [];
+    }));
+    const tabs = bundle.docsConfig.tabs.filter((tab) => {
+      if (!tab.hidden || tab.api?.navigation !== false || tab.pages?.length || tab.groups?.length || tab.href) return true;
+      const source = resolveSpecRef(tab.api.source, assets, false);
+      return source.kind !== "match" || !reboundSources.has(source.spec.path) || stillReferenced.has(source.spec.path);
+    }).map((tab) => ({ ...tab }));
+    const target2 = tabs.find((tab) => tab.api && [path, specUrl].includes(tab.api.source)) ?? tabs.find((tab) => !tab.api && tab.tab.toLowerCase().includes("api"));
+    if (target2) target2.api = api;
+    else {
+      const taken = new Set(tabs.map((tab) => slug(tab.tab)));
+      let label = "API Reference";
+      let suffix = 2;
+      while (taken.has(slug(label))) label = `API Reference ${suffix++}`;
+      tabs.push({ tab: label, api });
+    }
+    return {
+      ...bundle,
+      pages,
+      assets: [...bundle.assets.filter((asset) => asset.path !== path), { path, content: pruned.content, projectRelative: true }],
+      docsConfig: { ...bundle.docsConfig, tabs },
+      warnings: warning && !bundle.warnings.some((item) => item.code === warning.code && item.source === warning.source && item.message === warning.message) ? [...bundle.warnings, warning] : bundle.warnings
+    };
+  } catch (error) {
+    return { ...bundle, warnings: [...bundle.warnings, { code: "fetch-failed", source: specUrl, message: `OpenAPI spec could not be imported: ${error instanceof Error ? error.message : String(error)}` }] };
+  }
+}
+
 // src/analytics.ts
 var GA4_ID = /^G-[A-Z0-9]{4,20}$/;
 var GTM_ID = /^GTM-[A-Z0-9]{4,12}$/;
@@ -7860,7 +8248,10 @@ var VIDEO_ATTRIBUTES = /* @__PURE__ */ new Set([
   "width",
   "height",
   "preload",
-  "aria-label"
+  "aria-label",
+  // Publisher asset provenance does not change playback and is never emitted.
+  // Keep this explicit: arbitrary data attributes may drive custom controls.
+  "data-path"
 ]);
 var YOUTUBE_ATTRIBUTES = /* @__PURE__ */ new Set([
   "src",
@@ -7925,7 +8316,7 @@ function projectMigrationMedia(html, base) {
 }
 
 // src/url-static-content.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { load as load3 } from "cheerio";
 
 // src/svg-policy.ts
@@ -8247,7 +8638,7 @@ function projectMigrationSvg(html) {
   if (svg.attr("xmlns") === void 0) svg.attr("xmlns", "http://www.w3.org/2000/svg");
   const content = Buffer.from($.xml(svg));
   if (!isPassiveSvg(content)) return null;
-  const sha256 = createHash2("sha256").update(content).digest("hex");
+  const sha256 = createHash3("sha256").update(content).digest("hex");
   const labelled = (svg.attr("aria-labelledby") ?? "").split(/\s+/).filter(Boolean).map((id) => svg.find("[id]").filter((_index, node) => $(node).attr("id") === id).text().trim()).filter(Boolean);
   const alternative = svg.attr("aria-label")?.trim() || labelled.join(" ") || svg.children("title").text().trim() || svg.children("desc").text().trim() || svg.find("text").text().trim();
   return { asset: { path: `migration-assets/${sha256}.svg`, content }, alternative };
@@ -8361,12 +8752,12 @@ function projectCapturedTabs($, root) {
 }
 
 // src/url-flight-content.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import remarkMdx3 from "remark-mdx";
-import remarkParse3 from "remark-parse";
+import remarkParse4 from "remark-parse";
 import remarkGfm2 from "remark-gfm";
-import { unified as unified3 } from "unified";
-var parser2 = unified3().use(remarkParse3).use(remarkGfm2).use(remarkMdx3);
+import { unified as unified4 } from "unified";
+var parser2 = unified4().use(remarkParse4).use(remarkGfm2).use(remarkMdx3);
 var MAX_SOURCE_BYTES = 8e6;
 var sourceTrees = /* @__PURE__ */ new Map();
 var cachedSourceBytes = 0;
@@ -8538,7 +8929,7 @@ function sourceText(node) {
   return node.value ?? (node.children ?? []).map(sourceText).join("");
 }
 function sourceNodes(source) {
-  const key = createHash3("sha256").update(source).digest("hex");
+  const key = createHash4("sha256").update(source).digest("hex");
   const cached = sourceTrees.get(key);
   if (cached) {
     sourceTrees.delete(key);
@@ -8887,7 +9278,7 @@ function recoverFlightDisclosures($, root, document, article, projectionBudget)
     if (!id || !target2 || title === null || labelText(title) !== labelText(button.text()) || panel.length !== 1 || panel.attr("role") !== "region" || panel.attr("aria-labelledby") !== id || root.find("[id]").filter((_index, node) => $(node).attr("id") === id).length !== 1 || panel.is('[aria-busy="true"]') || panel.find('[aria-busy="true"],[role="progressbar"]').length) continue;
     let html;
     if (!panel.text().trim() && !panel.children().length) {
-      const prefix = `thally-flight-${createHash3("sha256").update(target2).digest("hex").slice(0, 16)}`;
+      const prefix = `thally-flight-${createHash4("sha256").update(target2).digest("hex").slice(0, 16)}`;
       const rendered = flightStaticHtml(document, source.props.children, prefix, projectionBudget);
       if (rendered === null || !rendered.trim()) continue;
       html = rendered;
@@ -9126,8 +9517,13 @@ function recoverFlightArticleCode($, root) {
 
 // src/redirects.ts
 var LISTED = 10;
+function trimTrailingSlashes2(route) {
+  let end = route.length;
+  while (end > 0 && route[end - 1] === "/") end--;
+  return route.slice(0, end);
+}
 function exactRoute(route) {
-  return route.startsWith("/") && !/[?:*#()[\]{}]/.test(route) ? route.replace(/\/+$/, "") || "/" : null;
+  return route.startsWith("/") && !/[?:*#()[\]{}]/.test(route) ? trimTrailingSlashes2(route) || "/" : null;
 }
 function literalRoute(route) {
   return exactRoute(route)?.toLowerCase() ?? null;
@@ -9390,8 +9786,8 @@ var MINTLIFY_ARTICLE_LABELS = [
   { baseUrl: "Select base URL", permalink: "Navigate to header" },
   { baseUrl: "\u9009\u62E9\u57FA\u7840URL", permalink: "\u5BFC\u822A\u5230\u6807\u9898" }
 ];
-var remoteMarkdownParser = unified4().use(remarkParse4).use(remarkMdx4);
-var embeddedOpenApiParser = unified4().use(remarkParse4);
+var remoteMarkdownParser = unified5().use(remarkParse5).use(remarkMdx4);
+var embeddedOpenApiParser = unified5().use(remarkParse5);
 function validateMigrationUrl(value) {
   let url;
   try {
@@ -10007,9 +10403,13 @@ function migratedHref(href, currentUrl, source, scopePath, importedIds, sourceHo
       return `/${target2.search}${target2.hash}`;
     }
     let path = target2.pathname;
+    const isMarkdown = path.endsWith(".md");
+    const machinePath = path.replace(/\/+$/, "");
+    if (["/llms.txt", "/llms-full.txt", "/openapi.json", "/openapi.yaml", "/robots.txt", "/sitemap.xml"].includes(machinePath)) return `${machinePath}${target2.search}${target2.hash}`;
     if (scopePath !== "/" && (path === scopePath || path.startsWith(`${scopePath}/`))) {
       path = path.slice(scopePath.length);
     }
+    if (["/llms.txt", "/llms-full.txt", "/openapi.json", "/openapi.yaml", "/robots.txt", "/sitemap.xml"].includes(path)) return `${path}${target2.search}${target2.hash}`;
     const id = pageIdFromReference(path.replace(/^\/+/, "") || "introduction");
     const localizedId = id ? canonicalLocalizedPageId(id) : id;
     const destinationId = localizedId === sourceHomePageId ? "introduction" : localizedId;
@@ -10019,7 +10419,7 @@ function migratedHref(href, currentUrl, source, scopePath, importedIds, sourceHo
     }
     if (importedDestinationId) {
       const destination = importedDestinationId === "introduction" ? "/" : `/${importedDestinationId}`;
-      return `${destination}${target2.search}${target2.hash}`;
+      return `${destination === "/" && isMarkdown ? "/introduction" : destination}${isMarkdown ? ".md" : ""}${target2.search}${target2.hash}`;
     }
     return target2.toString();
   } catch {
@@ -11194,9 +11594,9 @@ async function migrateUrl(options) {
       ]
     };
   }
-  if (platform === "mintlify") docsConfig = addMintlifyDirectoryRedirects(docsConfig, pages);
+  if (platform === "mintlify") docsConfig = { ...addMintlifyDirectoryRedirects(docsConfig, pages), markdown: { enabled: true } };
   docsConfig = dropConflictingRedirects(dropUnroutableRedirects(docsConfig, warnings), pages, warnings);
-  return {
+  const bundle = {
     sourceUrl: source.toString(),
     sourceKind: "url",
     platform,
@@ -11216,6 +11616,20 @@ async function migrateUrl(options) {
       skipped: Math.max(0, visited.size - pages.length)
     }
   };
+  const sourceHtml = scopedHtmlProbe ? load4(scopedHtmlProbe.body) : void 0;
+  const linkedSpecs = sourceHtml && scopedHtmlProbe && /html/i.test(scopedHtmlProbe.contentType) ? [...new Set(sourceHtml('link[rel="service-desc"][href], a[href]').map((_index, element) => {
+    const href = sourceHtml(element).attr("href");
+    if (!href) return null;
+    try {
+      const url = new URL(href, scopedHtmlProbe.finalUrl);
+      return url.protocol === "https:" && /\/(?:openapi|swagger)\.(?:json|ya?ml)$/i.test(url.pathname) ? url.toString() : null;
+    } catch {
+      return null;
+    }
+  }).get())] : [];
+  const specUrl = options.openapiUrl ?? (!openApiAsset && linkedSpecs.length === 1 ? linkedSpecs[0] : void 0);
+  if (!options.openapiUrl && linkedSpecs.length > 1) bundle.warnings.push({ code: "unsupported-config", message: "Multiple OpenAPI specifications were linked by the source. Select one explicitly with --openapi <https-url>." });
+  return specUrl ? hydrateUrlOpenApi(bundle, specUrl, options.fetcher) : bundle;
 }
 
 // src/source-refs.ts
@@ -12367,12 +12781,12 @@ function classifyApiSpec(path) {
   return /asyncapi/i.test(topLevel) ? "asyncapi" : "openapi";
 }
 var SPEC_DIRECTORY = "openapi";
-var MAX_SPEC_BYTES = 5e7;
+var MAX_SPEC_BYTES2 = 5e7;
 function readSpecFile(absolutePath, relativePath, warnings) {
-  if (lstatSync6(absolutePath).size > MAX_SPEC_BYTES) {
+  if (lstatSync6(absolutePath).size > MAX_SPEC_BYTES2) {
     warnings.push({
       code: "skipped-file",
-      message: `The OpenAPI spec "${relativePath}" is larger than ${MAX_SPEC_BYTES / 1e6} MB and was not migrated; split it or reduce its size.`,
+      message: `The OpenAPI spec "${relativePath}" is larger than ${MAX_SPEC_BYTES2 / 1e6} MB and was not migrated; split it or reduce its size.`,
       source: relativePath
     });
     return void 0;
@@ -12598,7 +13012,7 @@ function apiTabSpecIds(tabs) {
   return tabs.filter((tab) => !tab.hidden && tab.api).map((tab, index) => ({ tab, specId: index === 0 ? "default" : slugifyApiSpecId(tab.tab) }));
 }
 var flagged = (value) => value === true || value === "true";
-var isWithheld = (node) => flagged(node["x-hidden"]) || flagged(node["x-excluded"]);
+var isWithheld2 = (node) => flagged(node["x-hidden"]) || flagged(node["x-excluded"]);
 var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 function resolveLocalSpecRef(document, ref) {
   if (ref !== "#" && !ref.startsWith("#/")) return void 0;
@@ -12625,7 +13039,7 @@ function viewSpecPathItem(document, entry) {
   }
   const item = Object.assign({}, ...[...chain].reverse());
   delete item.$ref;
-  return { item, withheld: chain.some(isWithheld) };
+  return { item, withheld: chain.some(isWithheld2) };
 }
 function parseOpenApiOperationsForLinking(content) {
   const document = readSpecDocument(content);
@@ -12649,7 +13063,7 @@ function visibleOperations(document, entries) {
       const operation = item[method];
       if (!operation || typeof operation !== "object") continue;
       const op = operation;
-      if (isWithheld(op)) continue;
+      if (isWithheld2(op)) continue;
       const tags = Array.isArray(op.tags) ? op.tags.filter((tag) => typeof tag === "string") : [];
       operations.push({
         method,
@@ -12663,6 +13077,28 @@ function visibleOperations(document, entries) {
   }
   return operations;
 }
+function migrationApiRoutes(bundle) {
+  const routes = /* @__PURE__ */ new Set();
+  for (const { tab, specId } of apiTabSpecIds(bundle.docsConfig.tabs)) {
+    const source = tab.api.source.replace(/^\//, "");
+    const asset = bundle.assets.find((entry) => entry.path.replace(/^\//, "") === source);
+    if (!asset) continue;
+    const document = readSpecDocument(Buffer.from(asset.content));
+    if (!isRecord2(document)) continue;
+    const operations = visibleOperations(document, document.paths);
+    const webhooks = visibleOperations(document, document.webhooks);
+    if (specId === "default" && (operations.length || webhooks.length)) routes.add("/api");
+    for (const operation of operations) {
+      routes.add(`/api/${specId}/${thallyOperationSlugSegments(operation.path, operation.method).join("/")}`);
+    }
+    for (const operation of webhooks) {
+      const segments = thallyOperationSlugSegments(operation.path, operation.method);
+      if (segments[0] !== "webhooks") segments.unshift("webhooks");
+      routes.add(`/api/${specId}/${segments.join("/")}`);
+    }
+  }
+  return [...routes];
+}
 function servedOperations(source, parsed) {
   let operations = parsed.get(source.filename);
   if (!operations) {
@@ -13376,10 +13812,13 @@ function rewriteMintlifyMountedLinks(body, pageIds) {
     if (!pathname.startsWith("/") || pathname.startsWith("//") || pathname.includes("\\")) return target2;
     const segments = pathname.slice(1).split("/");
     if (segments.some((segment) => !segment || segment === "." || segment === "..")) return target2;
-    if (pageIds.has(segments.join("/"))) return target2;
+    const markdown = pathname.endsWith(".md");
+    const sourceMdx = pathname.endsWith(".mdx");
+    const routeSegments = markdown || sourceMdx ? [...segments.slice(0, -1), segments.at(-1).replace(/\.mdx?$/, "")] : segments;
+    if (pageIds.has(routeSegments.join("/"))) return sourceMdx ? `/${routeSegments.join("/")}${suffix}` : target2;
     for (let count = 1; count < segments.length && count <= 3; count++) {
-      const candidate = segments.slice(count).join("/");
-      if (pageIds.has(candidate)) return `/${candidate}${suffix}`;
+      const candidate = routeSegments.slice(count).join("/");
+      if (pageIds.has(candidate)) return `/${candidate}${markdown ? ".md" : ""}${suffix}`;
     }
     return target2;
   };
@@ -13459,11 +13898,11 @@ function preserveLinkedAnchors(pages) {
     const headingSlugs = /* @__PURE__ */ new Map();
     const slugCounts = /* @__PURE__ */ new Map();
     for (const heading of headings) {
-      const slug2 = heading.text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
-      existing.add(slug2);
-      const seen = slugCounts.get(slug2) ?? 0;
-      slugCounts.set(slug2, seen + 1);
-      if (slug2) headingSlugs.set(seen === 0 ? slug2 : `${slug2}-${seen}`, heading.index);
+      const slug3 = heading.text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      existing.add(slug3);
+      const seen = slugCounts.get(slug3) ?? 0;
+      slugCounts.set(slug3, seen + 1);
+      if (slug3) headingSlugs.set(seen === 0 ? slug3 : `${slug3}-${seen}`, heading.index);
     }
     const headingAliases = /* @__PURE__ */ new Map();
     const tableAliases = /* @__PURE__ */ new Map();
@@ -13528,9 +13967,9 @@ function addDatedHeadingAliases(body, date) {
     if (open) return [line];
     const heading = line.match(/^#{2,6}\s+(.+?)\s*#*\s*$/);
     if (!heading) return [line];
-    const slug2 = heading[1].replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[`*_]/g, "").normalize("NFKD").toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, "").trim().replace(/\s+/g, "-");
-    const id = `${date}-${slug2}`;
-    if (!slug2 || existingIds.has(id)) return [line];
+    const slug3 = heading[1].replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[`*_]/g, "").normalize("NFKD").toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, "").trim().replace(/\s+/g, "-");
+    const id = `${date}-${slug3}`;
+    if (!slug3 || existingIds.has(id)) return [line];
     existingIds.add(id);
     return [`<a id="${id}" />`, "", line];
   }).join("\n");
@@ -14748,9 +15187,9 @@ ${warnings.map((warning) => `- ${warning.message}`).join("\n")}`);
       // hierarchy (never just its own segment) and wins over a docs.yml slug.
       ...platform === "fern" ? {
         resolveIdentity: (frontmatter, fallback) => {
-          const slug2 = typeof frontmatter.slug === "string" ? frontmatter.slug.trim() : "";
-          if (!slug2) return fallback;
-          const overridden = pageIdFromReference(slug2, true);
+          const slug3 = typeof frontmatter.slug === "string" ? frontmatter.slug.trim() : "";
+          if (!slug3) return fallback;
+          const overridden = pageIdFromReference(slug3, true);
           if (!overridden) return fallback;
           fernIdRenames.set(fallback.navigationId, overridden);
           return { ...fallback, id: overridden, navigationId: overridden };
@@ -15132,7 +15571,7 @@ ${warnings.map((warning) => `- ${warning.message}`).join("\n")}`);
         message: `Skipped ${rootStyleProjection.omittedSelectors} stylesheet selector${rootStyleProjection.omittedSelectors === 1 ? "" : "s"} that target platform-owned or unreferenced markup. Recreate any intentional shell customization with Thally configuration.`
       });
       if (rootStyleProjection.css.trim()) {
-        const identity = createHash4("sha256").update(componentSourceIdentity(options.sourceUrl, repositoryDir, mintlifyProjectRoot)).digest("hex").slice(0, 12);
+        const identity = createHash5("sha256").update(componentSourceIdentity(options.sourceUrl, repositoryDir, mintlifyProjectRoot)).digest("hex").slice(0, 12);
         const assetPath = `migrated/${identity}/style.css`;
         const content = Buffer.from(rootStyleProjection.css);
         assets.push({ path: assetPath, content });
@@ -16019,6 +16458,32 @@ function renderPage(bundle, page) {
 function isIntegrationsObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function mergeRedirects(existing = [], incoming = []) {
+  const redirects = [...existing];
+  const key = (source) => literalRoute(source) ?? trimTrailingSlashes2(source).toLowerCase();
+  const destinationKey = (destination) => literalRoute(destinationRoute(destination) ?? "");
+  const sources = new Set(existing.map((redirect) => key(redirect.source)));
+  for (const redirect of incoming) {
+    const source = key(redirect.source);
+    if (sources.has(source)) continue;
+    const visited = /* @__PURE__ */ new Set([source]);
+    let destination = destinationKey(redirect.destination);
+    let cycle = false;
+    while (destination) {
+      if (visited.has(destination)) {
+        cycle = true;
+        break;
+      }
+      visited.add(destination);
+      const next = redirects.find((candidate) => literalRoute(candidate.source) === destination);
+      destination = next ? destinationKey(next.destination) : null;
+    }
+    if (cycle) continue;
+    redirects.push(redirect);
+    sources.add(source);
+  }
+  return redirects;
+}
 function mergeMigrationConfig(existing, incoming) {
   const tabs = existing.tabs.filter((tab) => tab.tab.toLowerCase() !== "changelog");
   const names = new Set(tabs.map((tab) => tab.tab.toLowerCase()));
@@ -16086,6 +16551,10 @@ function mergeMigrationConfig(existing, incoming) {
     ...incoming,
     ...existing,
     tabs,
+    ...existing.redirects || incoming.redirects ? { redirects: mergeRedirects(existing.redirects, incoming.redirects) } : {},
+    // A starter's primary action must not discard a newly imported logo.
+    // Owner-authored fields, including an explicit null logo, remain authoritative.
+    ...incoming.navbar || existing.navbar ? { navbar: { ...incoming.navbar, ...existing.navbar } } : {},
     // Collection presentation belongs to the imported information
     // architecture; starter defaults must not coerce source dropdowns to tabs.
     navigation: incoming.navigation ?? existing.navigation,
@@ -16117,11 +16586,12 @@ function renderMigrationFiles(bundle, options = {}) {
 }
 
 // src/url-run.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { load as load8 } from "cheerio";
-import remarkParse5 from "remark-parse";
+import { parse as parse2, postprocess, preprocess } from "micromark";
+import remarkParse6 from "remark-parse";
 import remarkMdx5 from "remark-mdx";
-import { unified as unified5 } from "unified";
+import { unified as unified6 } from "unified";
 
 // src/url-asset-cache.ts
 function createMigrationAssetCache() {
@@ -16652,7 +17122,7 @@ function mergeSourceNavigation(existing, incoming) {
 }
 
 // src/url-identity.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { load as load7 } from "cheerio";
 var directory = (path) => path.replace(/\/index\/?$/i, "").replace(/\/$/, "") || "/";
 function migrationSectionQueryCandidate(source, anchors) {
@@ -16713,7 +17183,7 @@ function observedMigrationArticleIdentity(document) {
   canonical2.pathname = canonical2.pathname.replace(/\/+$/, "") || "/";
   const removed = [...source.searchParams].filter(([key, value]) => !canonical2.searchParams.getAll(key).includes(value));
   const sectionAnchor = removed.length === 1 && anchors.includes(removed[0][1]) ? removed[0][1] : void 0;
-  return { canonicalUrl: canonical2.href, articleSha256: createHash5("sha256").update(payload).digest("hex"), ...sectionAnchor ? { sectionAnchor } : {} };
+  return { canonicalUrl: canonical2.href, articleSha256: createHash6("sha256").update(payload).digest("hex"), ...sectionAnchor ? { sectionAnchor } : {} };
 }
 
 // src/url-api-schema-controls.ts
@@ -17040,8 +17510,8 @@ function apiOperationCodeControls(body, specification, operation) {
     const metadata = object2(resolveValue(value));
     const declaration = resolveValue(metadata?.openapi);
     if (typeof declaration !== "string") return false;
-    const tokens = declaration.trim().split(/\s+/);
-    return tokens.at(-2)?.toLowerCase() === operation.method.toLowerCase() && tokens.at(-1) === operation.path;
+    const tokens2 = declaration.trim().split(/\s+/);
+    return tokens2.at(-2)?.toLowerCase() === operation.method.toLowerCase() && tokens2.at(-1) === operation.path;
   };
   const active = /* @__PURE__ */ new Set();
   const visit = (input, provider, group, depth, owners = []) => {
@@ -17087,9 +17557,9 @@ function apiOperationCodeControls(body, specification, operation) {
             const hint = object2(resolveValue(scope?.pageMetadata)), metadata = object2(resolveValue(props.pageMetadata));
             const declaration = resolveValue(hint?.openapi);
             if (typeof declaration !== "string" || typeof hint?.href !== "string" || !hint.href || hint.href !== metadata?.href) return false;
-            const tokens = declaration.trim().split(/\s+/);
+            const tokens2 = declaration.trim().split(/\s+/);
             const template = (path) => path.split("/").map((segment) => /^\{[^{}\/]+\}$/.test(segment) ? "{}" : segment).join("/");
-            return tokens.at(-2)?.toLowerCase() === operation.method.toLowerCase() && template(tokens.at(-1) ?? "") === template(operation.path);
+            return tokens2.at(-2)?.toLowerCase() === operation.method.toLowerCase() && template(tokens2.at(-1) ?? "") === template(operation.path);
           })()) generatedControllers += 1;
         }
         let local = group;
@@ -17197,15 +17667,15 @@ function apiOperationCodeControls(body, specification, operation) {
 }
 
 // src/url-run.ts
-var CONVERTER_VERSION = "url-evidence-v6";
-var parser3 = unified5().use(remarkParse5).use(remarkMdx5);
-var ACCEPT = "text/markdown,text/html,application/xhtml+xml;q=0.9";
+var CONVERTER_VERSION = "url-evidence-v7";
+var parser3 = unified6().use(remarkParse6).use(remarkMdx5);
+var ACCEPT = "text/html,application/xhtml+xml";
 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 createHash6("sha256").update(value).digest("hex");
+  return createHash7("sha256").update(value).digest("hex");
 }
 function canonicalJson(value) {
   const canonical2 = (value2) => Array.isArray(value2) ? value2.map(canonical2) : value2 !== null && typeof value2 === "object" ? Object.fromEntries(Object.entries(value2).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, field]) => [key, canonical2(field)])) : value2;
@@ -17229,6 +17699,11 @@ function canonical(value, base) {
     return null;
   }
 }
+function sameRouteMarkdownRepresentation(alternate, primary) {
+  const target2 = new URL(alternate), source = new URL(primary);
+  const directory2 = (path) => path.replace(/\.mdx?$/i, "").replace(/\/index\/?$/i, "").replace(/\/$/, "");
+  return target2.origin === source.origin && target2.search === source.search && directory2(target2.pathname) === directory2(source.pathname) && /\.mdx?$/i.test(target2.pathname);
+}
 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) || /\.(?:json|ya?ml)$/i.test(document.finalUrl.pathname) || /(?:xml|json)/i.test(document.contentType)) return "index";
@@ -17479,7 +17954,7 @@ function resolveMigrationRecord(records, record) {
   }
   return record;
 }
-function navigationConfig(checkpoint, records) {
+function navigationConfig(checkpoint, records, occurrencePages = /* @__PURE__ */ new Map()) {
   const navigation = checkpoint.navigation;
   const shortcuts = [];
   const collectShortcuts = (nodes) => {
@@ -17504,7 +17979,7 @@ function navigationConfig(checkpoint, records) {
   const project2 = (nodes) => nodes.flatMap((node) => {
     const record = node.url ? records.get(canonical(node.url, node.url) ?? "") : void 0;
     const target2 = resolveMigrationRecord(records, record);
-    const page = target2?.page;
+    const page = occurrencePages.get(node) ?? target2?.page;
     const children = project2(node.children ?? []);
     if (children.length) {
       const contains = (entries) => entries.some((entry) => typeof entry === "string" ? entry === (page && projection.navigationId(page)) : contains(entry.pages));
@@ -17804,8 +18279,19 @@ async function runUrlMigration(options) {
     if (!record.evidence) continue;
     const final = canonical(record.evidence.finalUrl, sourceUrl);
     if (!final) continue;
-    if (record.outcome === "imported") enqueueArticleLinks(record.evidence.links, final, record.url);
-    else if (record.outcome === "excluded") {
+    if (record.outcome === "imported") {
+      enqueueArticleLinks(record.evidence.links, final, record.url);
+      for (const reference of record.evidence.markdownRepresentations ?? []) {
+        const alternate = canonical(reference, final);
+        if (!alternate || !sameRouteMarkdownRepresentation(alternate, final)) continue;
+        enqueue(alternate, final, "declared-markdown-representation");
+        const sibling = records.get(alternate);
+        if (sibling && sibling.representationOf !== record.url) {
+          sibling.representationOf = record.url;
+          changed.push(sibling);
+        }
+      }
+    } else if (record.outcome === "excluded") {
       if (classifyMigrationResponse({ finalUrl: new URL(final), contentType: record.evidence.contentType, body: "" }) === "index") {
         for (const link of record.evidence.links) enqueue(link, final, record.url);
       }
@@ -17888,6 +18374,7 @@ async function runUrlMigration(options) {
     let claimedId;
     let claimedFinal;
     let markdownRepresentation;
+    const markdownRepresentations = [];
     let exactKey;
     try {
       delete record.reason;
@@ -17980,13 +18467,13 @@ async function runUrlMigration(options) {
         $('link[rel="alternate"][type="text/markdown"][href]').each((_index, node) => {
           const alternate = canonical($(node).attr("href"), final);
           if (!alternate) return;
-          const target2 = new URL(alternate), primary = new URL(final);
-          const directory2 = (path) => path.replace(/\.mdx?$/i, "").replace(/\/index\/?$/i, "").replace(/\/$/, "");
-          if (target2.origin !== primary.origin || target2.search !== primary.search || directory2(target2.pathname) !== directory2(primary.pathname) || !/\.mdx?$/i.test(target2.pathname)) return;
+          if (!sameRouteMarkdownRepresentation(alternate, final)) return;
           enqueue(alternate, final, "declared-markdown-representation");
           const sibling = records.get(alternate);
+          if (!sibling) return;
           sibling.representationOf = record.url;
           markdownRepresentation ??= alternate;
+          markdownRepresentations.push(alternate);
           changed.push(sibling);
         });
       }
@@ -17999,7 +18486,8 @@ async function runUrlMigration(options) {
         }
         enqueueNavigation(observedNavigation, final);
       }
-      if (imported >= maxPages) {
+      const replacesRepresentation = imported >= maxPages && markdownRepresentations.some((url) => records.get(url)?.page);
+      if (imported >= maxPages && !replacesRepresentation) {
         record.outcome = "excluded";
         record.reason = "A discovery endpoint resolved to an article after the selected page limit.";
         return;
@@ -18018,14 +18506,17 @@ async function runUrlMigration(options) {
       const locale = language.locale;
       const navigationId = locale ? id.split("/").filter((segment) => segment.toLowerCase() !== locale.toLowerCase()).join("/") || "introduction" : id;
       const identityId = locale ? `${locale}/${navigationId}` : id;
-      if (usedIds.has(identityId) && usedIds.get(identityId) !== record.url) {
+      const owner = records.get(usedIds.get(identityId) ?? "");
+      const sharesDeclaredRepresentation = owner && (owner.representationOf === record.url || record.representationOf === owner.url);
+      if (owner && owner !== record && !sharesDeclaredRepresentation) {
         record.outcome = "failed";
         record.reason = `Destination collision for ${identityId}.`;
         return;
       }
-      usedIds.set(identityId, record.url);
+      if (!owner || owner === record || owner.representationOf === record.url) usedIds.set(identityId, record.url);
       claimedId = identityId;
       const evidence = evidenceOf(document);
+      if (markdownRepresentations.length) evidence.markdownRepresentations = markdownRepresentations;
       const page = convert(document, id);
       if (!page) {
         record.outcome = "failed";
@@ -18236,6 +18727,7 @@ ${difference}`;
       if (!primary || primary === record) continue;
       const winner = primary.outcome === "imported" ? primary : record.outcome === "imported" && primary.outcome === "failed" ? record : void 0;
       if (!winner) continue;
+      if (winner.page) usedIds.set(winner.page.id, winner.url);
       const alternate = winner === primary ? record : primary;
       if (alternate.outcome === "alias" && alternate.aliasOf === winner.url) continue;
       if (alternate.outcome === "imported") {
@@ -18257,7 +18749,17 @@ ${difference}`;
   settleArticleIdentities();
   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));
+      const index = pending.findIndex((record, position) => {
+        if (position < cursor || record.outcome !== "pending") return false;
+        const url = new URL(record.url);
+        if (isDiscoveryIndex(url, source)) return true;
+        if (/\.mdx?$/i.test(url.pathname)) return false;
+        return [".md", ".mdx", "/index.md", "/index.mdx"].some((extension) => {
+          const alternate = new URL(url);
+          alternate.pathname = alternate.pathname.replace(/\/index$/i, "") + extension;
+          return records.get(alternate.href)?.outcome === "imported";
+        });
+      });
       if (index < 0) break;
       pending.splice(cursor, 0, pending.splice(index, 1)[0]);
     }
@@ -18281,19 +18783,60 @@ ${difference}`;
   }
   const navigationLabels = /* @__PURE__ */ new Map();
   const navigationIssues = [];
+  const navigationOccurrences = /* @__PURE__ */ new Map();
   const labelPages = (nodes) => {
     for (const node of nodes) {
       const entry = node.url ? records.get(canonical(node.url, sourceUrl) ?? "") : void 0;
       const target2 = resolveMigrationRecord(records, entry);
-      if (target2?.page && node.label && !node.children?.length && !entry?.aliasAnchor) {
-        const previous = navigationLabels.get(target2.url);
-        if (previous && previous !== node.label) navigationIssues.push({ code: "unsupported-component", source: target2.url, message: `This page has multiple source navigation labels (${previous}, ${node.label}); review the shared sidebar title.` });
-        else navigationLabels.set(target2.url, node.label);
+      if (entry && target2?.page && node.label && !node.children?.length && !entry.aliasAnchor) {
+        const occurrences = navigationOccurrences.get(target2) ?? [];
+        occurrences.push({ node, entry });
+        navigationOccurrences.set(target2, occurrences);
       }
       labelPages(node.children ?? []);
     }
   };
   labelPages(checkpoint.navigation);
+  const occurrencePages = /* @__PURE__ */ new Map();
+  const navigationAliases = /* @__PURE__ */ new Map();
+  const occupiedPageIds = new Set(checkpoint.records.flatMap((record) => record.page ? [projection.pageId(record.page)] : []));
+  const navigationRedirects = [];
+  for (const [target2, occurrences] of navigationOccurrences) {
+    const final = target2.evidence && canonical(target2.evidence.finalUrl, sourceUrl);
+    const primary = occurrences.find(({ entry }) => entry.url === final) ?? occurrences.find(({ entry }) => entry === target2) ?? occurrences[0];
+    navigationLabels.set(target2.url, primary.node.label);
+    for (const { node, entry } of occurrences) {
+      if (node.label === primary.node.label) continue;
+      const existing = navigationAliases.get(entry.url);
+      if (existing?.page.navTitle === node.label && existing.target === target2) {
+        occurrencePages.set(node, existing.page);
+        continue;
+      }
+      const sourceRoute = new URL(entry.url);
+      const id = inScope(sourceRoute, source, scopePath) ? idForUrl(sourceRoute, scopePath) : null;
+      const locale = projection.canonicalLocale(target2.page);
+      let navigationId = id && (locale ? id.split("/").filter((segment) => segment.toLowerCase() !== locale.toLowerCase()).join("/") || "introduction" : id);
+      const legacyPrefix = locale && `${locale.toLowerCase()}-`;
+      if (navigationId && legacyPrefix && projection.navigationId(target2.page) !== target2.page.navigationId && navigationId.toLowerCase().startsWith(legacyPrefix)) navigationId = navigationId.slice(legacyPrefix.length);
+      const page = navigationId ? {
+        ...target2.page,
+        id: locale ? `${locale}/${navigationId}` : navigationId,
+        navigationId,
+        ...locale ? { locale } : {},
+        navTitle: node.label,
+        source: entry.url,
+        noindex: true
+      } : void 0;
+      if (!page || existing || occupiedPageIds.has(projection.pageId(page))) {
+        navigationIssues.push({ code: "unsupported-component", source: target2.url, message: `This page has multiple source navigation labels (${primary.node.label}, ${node.label}); their source routes cannot retain distinct sidebar titles safely.` });
+        continue;
+      }
+      occupiedPageIds.add(projection.pageId(page));
+      navigationAliases.set(entry.url, { page, target: target2 });
+      occurrencePages.set(node, page);
+      navigationRedirects.push({ source: projection.route(page), destination: projection.route(target2.page), permanent: true });
+    }
+  }
   const pages = checkpoint.records.flatMap((record) => record.page ? [{ ...record.page, id: projection.pageId(record.page), navigationId: projection.navigationId(record.page), ...projection.canonicalLocale(record.page) ? { locale: projection.canonicalLocale(record.page) } : {}, ...navigationLabels.has(record.url) ? { navTitle: navigationLabels.get(record.url) } : {}, body: rewriteMarkdownDestinations(record.page.body, (value) => {
     let url;
     try {
@@ -18314,6 +18857,10 @@ ${difference}`;
     const hasBrokenSourceAnchor = Boolean(url.hash && destination?.outcome === "imported" && destination.evidence && !destination.evidence.anchors.includes(anchor));
     return `${route}${hasBrokenSourceAnchor ? "" : effectiveHash}`;
   }) }] : []);
+  const projectedPages = new Map(pages.map((page) => [page.id, page]));
+  for (const { page, target: target2 } of navigationAliases.values()) {
+    pages.push({ ...page, id: projection.pageId(page), body: projectedPages.get(projection.pageId(target2.page)).body });
+  }
   const validation = validateUrlMigration(checkpoint, Boolean(options.signal?.aborted));
   validation.issues.push(...navigationIssues);
   if (navigationIssues.length && validation.status === "passed") validation.status = "partial";
@@ -18334,12 +18881,12 @@ ${difference}`;
     platform: options.platform ?? "generic",
     pages,
     assets: [...assets.values()],
-    docsConfig: navigationConfig(checkpoint, records) ?? buildNavigationFromPages(pages),
+    docsConfig: navigationConfig(checkpoint, records, occurrencePages) ?? buildNavigationFromPages(pages),
     warnings: [...validation.issues, ...validation.warnings ?? []].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.redirects.length) bundle.docsConfig.redirects = projection.redirects;
+  if (projection.redirects.length || navigationRedirects.length) bundle.docsConfig.redirects = [...projection.redirects, ...navigationRedirects];
   if (projection.locales.length) {
     const locales = [.../* @__PURE__ */ new Set([projection.defaultLocale, ...projection.locales])];
     bundle.docsConfig.i18n = { ...bundle.docsConfig.i18n, defaultLocale: projection.defaultLocale, locales: locales.map((code) => ({ code, label: code === "en" ? "English" : code })) };
@@ -18357,9 +18904,11 @@ function rewriteMarkdownDestinations(body, rewrite) {
     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 };
+    const destinations = postprocess(parse2().document().write(preprocess()(original, void 0, true))).filter(([event, token]) => event === "enter" && ["resourceDestinationString", "definitionDestinationString", "autolinkProtocol", "autolinkEmail"].includes(token.type));
+    const destination = destinations.at(-1)?.[1];
+    if (!destination) return null;
+    const escaped = replacement.replace(/[\\&()<>]/g, "\\$&").replace(/[\t\n\r ]/g, (character) => encodeURIComponent(character));
+    return { start: start + destination.start.offset, end: start + destination.end.offset, replacement: escaped };
   }).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", "poster", "href", "srcSet", "srcset", "img", "primaryHref", "secondaryHref"].includes(attribute.name) || !attribute.position) continue;
@@ -18391,133 +18940,8 @@ function rewriteMarkdownDestinations(body, rewrite) {
 }
 
 // src/remote-api.ts
-import { createHash as createHash7 } from "crypto";
-import { lookup } from "dns/promises";
-import { request } from "https";
-import { isIP } from "net";
-var MAX_SPEC_BYTES2 = 25e6;
-var MAX_REDIRECTS = 3;
-function isPublicAddress(address, family) {
-  if (family === 4) {
-    const parts = address.split(".").map(Number);
-    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
-    const [a, b] = parts;
-    return !(a === 0 || a === 10 || a === 127 || a >= 224 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 0 || b === 168) || a === 198 && (b === 18 || b === 19) || a === 203 && b === 0 || a === 198 && b === 51);
-  }
-  return family === 6 && /^[23][0-9a-f]{0,3}:/i.test(address) && !/^2001:db8:/i.test(address);
-}
-function validatedSpecUrl(value) {
-  const url = new URL(value);
-  if (url.protocol !== "https:" || url.username || url.password || isIP(url.hostname)) {
-    throw new Error("Remote OpenAPI references must use an HTTPS domain without credentials or an IP literal.");
-  }
-  url.hash = "";
-  return url;
-}
-async function getPinnedAddress(url) {
-  const addresses = await lookup(url.hostname, { all: true });
-  if (addresses.length === 0 || addresses.some((candidate) => !isPublicAddress(candidate.address, candidate.family))) {
-    throw new Error("The OpenAPI host did not resolve exclusively to public addresses.");
-  }
-  return addresses[0];
-}
-async function requestPinnedSpec(url) {
-  const pinned = await getPinnedAddress(url);
-  return new Promise((resolve5, reject) => {
-    const req = request(url, {
-      headers: { Accept: "application/json, application/yaml, text/yaml, */*", "User-Agent": "Thally-Migrate/1.0 (+https://thally.io)" },
-      signal: AbortSignal.timeout(3e4),
-      // Node's dual-stack connector asks lookup for `all: true`; that
-      // callback must receive address records, not a single address string.
-      lookup: (_hostname, options, callback) => {
-        if (typeof options === "object" && options.all) callback(null, [pinned]);
-        else callback(null, pinned.address, pinned.family);
-      }
-    }, (response) => {
-      const status = response.statusCode ?? 0;
-      if (status >= 300 && status < 400) {
-        response.resume();
-        resolve5({ status, location: response.headers.location, body: Buffer.alloc(0) });
-        return;
-      }
-      if (status < 200 || status >= 300) {
-        response.resume();
-        reject(new Error(`OpenAPI server returned ${status}.`));
-        return;
-      }
-      const statedBytes = Number(response.headers["content-length"] ?? 0);
-      if (statedBytes > MAX_SPEC_BYTES2) {
-        response.destroy();
-        reject(new Error("Remote OpenAPI spec exceeds the 25 MB import limit."));
-        return;
-      }
-      const chunks = [];
-      let bytes = 0;
-      response.on("data", (chunk) => {
-        bytes += chunk.length;
-        if (bytes > MAX_SPEC_BYTES2) {
-          response.destroy(new Error("Remote OpenAPI spec exceeds the 25 MB import limit."));
-          return;
-        }
-        chunks.push(chunk);
-      });
-      response.on("end", () => resolve5({ status, body: Buffer.concat(chunks) }));
-      response.on("error", reject);
-    });
-    req.on("error", reject);
-    req.end();
-  });
-}
-async function downloadSpec(value, fetcher) {
-  let url = validatedSpecUrl(value);
-  if (fetcher) {
-    const response = await fetcher(url, { accept: "application/json, application/yaml, text/yaml" });
-    validatedSpecUrl(response.finalUrl.toString());
-    const body = Buffer.from(response.body);
-    if (body.length > MAX_SPEC_BYTES2) throw new Error("Remote OpenAPI spec exceeds the 25 MB import limit.");
-    return body;
-  }
-  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
-    const response = await requestPinnedSpec(url);
-    if (response.status >= 300 && response.status < 400) {
-      if (!response.location || hop === MAX_REDIRECTS) throw new Error("Remote OpenAPI spec redirected too many times.");
-      url = validatedSpecUrl(new URL(response.location, url).toString());
-      continue;
-    }
-    return response.body;
-  }
-  throw new Error("Remote OpenAPI spec redirected too many times.");
-}
-function parseOpenApi(parsed) {
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("OpenAPI spec is not an object.");
-  const document = parsed;
-  if (typeof document.openapi !== "string" || !/^3\./.test(document.openapi)) {
-    throw new Error("Remote specification is not OpenAPI 3.x.");
-  }
-  if (!document.paths || typeof document.paths !== "object" || Array.isArray(document.paths)) {
-    throw new Error("Remote OpenAPI spec has no paths object.");
-  }
-  const paths = Object.entries(document.paths);
-  if (paths.length > 5e3) throw new Error("Remote OpenAPI spec has too many paths to import.");
-  const operations = [];
-  for (const [path, value] of paths) {
-    if (!value || typeof value !== "object" || Array.isArray(value) || isWithheld(value)) continue;
-    for (const [method, raw] of Object.entries(value)) {
-      if (!/^(get|post|put|patch|delete|head|options|trace)$/i.test(method) || !raw || typeof raw !== "object" || Array.isArray(raw)) continue;
-      const operation = raw;
-      if (isWithheld(operation)) continue;
-      const tags = Array.isArray(operation.tags) ? operation.tags : [];
-      operations.push({
-        method: method.toLowerCase(),
-        path,
-        tag: typeof tags[0] === "string" ? tags[0] : "API Reference",
-        summary: typeof operation.summary === "string" ? operation.summary : String(operation.operationId ?? "")
-      });
-    }
-  }
-  return operations;
-}
-function slug(value) {
+import { createHash as createHash8 } from "crypto";
+function slug2(value) {
   return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function operationTarget(specId, operation) {
@@ -18566,7 +18990,7 @@ async function hydrateRemoteApiSpecs(bundle, fetcher) {
       }
       const { format: extension, document } = parseSpecDocument(body.toString("utf8"));
       const operations = parseOpenApi(document);
-      const filename = `openapi-${createHash7("sha256").update(reference.url).digest("hex").slice(0, 12)}.${extension}`;
+      const filename = `openapi-${createHash8("sha256").update(reference.url).digest("hex").slice(0, 12)}.${extension}`;
       if (!assets.some((asset) => asset.path === `openapi/${filename}`)) assets.push({ path: `openapi/${filename}`, content: body, projectRelative: true });
       for (const page of pages) {
         const ref = page.openapi ? splitOpenApiRef(page.openapi) : null;
@@ -18651,7 +19075,7 @@ async function hydrateRemoteApiSpecs(bundle, fetcher) {
     const listed = reference.directories?.length && reference.directories.every((directory2) => directory2.operations) ? new Set(reference.directories.flatMap((directory2) => directory2.operations ?? []).map((name) => name.trim().split(/\s+/)).map(([method, ...path]) => `${method.toLowerCase()} ${path.join(" ")}`)) : null;
     for (const operation of operations) {
       if (listed && !listed.has(`${operation.method} ${operation.path}`)) continue;
-      const key = `${slug(operation.tag)}/${slug(operation.summary)}`;
+      const key = `${slug2(operation.tag)}/${slug2(operation.summary)}`;
       guesses.set(key, guesses.has(key) || !specId ? null : operationTarget(specId, operation));
     }
   }
@@ -18694,12 +19118,16 @@ export {
   detectRepositoryPlatform,
   gitmodulePaths,
   hydrateRemoteApiSpecs,
+  hydrateUrlOpenApi,
   importSourceRef,
   isPassiveSvg,
+  literalRoute,
   mergeMigrationConfig,
   migrateRepository,
   migrateUrl,
+  migrationApiRoutes,
   normalizeMdx,
+  pageEntryRoutes,
   parseGitHubRepositoryUrl,
   parseMarkdownPage,
   parseSourceRefFlags,