@doxbrix/doxloop 0.1.5 → 0.2.0

package/vendor/doxbrix-import/dist/importer.js

@@ -0,0 +1,1567 @@
+import { materializeMintlifyOpenApiPages, materializeOpenApiNavigationDocument } from './mintlify-openapi.js';
+const PAGE_EXTENSIONS = ['.md', '.mdx', '.markdown'];
+const CONFIG_NAMES = ['mint.json', 'docs.json'];
+const NON_PAGE_DIRS = new Set([
+    'snippets', '_snippets', 'includes', '_includes', 'partials', '_partials',
+    'node_modules', '.git', '.github', '.doxbrix', '.agents', '.claude', '.gemini', '.idea', '.vscode',
+]);
+const ROOT_REPOSITORY_FILES = new Set(['readme', 'contributing', 'agents', 'code_of_conduct', 'code-of-conduct', 'security', 'license']);
+function normalizePath(path) {
+    const out = [];
+    for (const part of path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '').split('/')) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..')
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out.join('/');
+}
+function dirname(path) {
+    const normalized = normalizePath(path);
+    const index = normalized.lastIndexOf('/');
+    return index < 0 ? '' : normalized.slice(0, index);
+}
+function basename(path) {
+    const normalized = normalizePath(path);
+    return normalized.slice(normalized.lastIndexOf('/') + 1);
+}
+function joinPath(base, path) {
+    return normalizePath(base ? `${base}/${path}` : path);
+}
+function isPageFile(path) {
+    const lower = path.toLowerCase();
+    return PAGE_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function stripPageExtension(path) {
+    for (const ext of PAGE_EXTENSIONS)
+        if (path.toLowerCase().endsWith(ext))
+            return path.slice(0, -ext.length);
+    return path;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function normalizeHex(value) {
+    const raw = asString(value);
+    if (!raw || !/^#[0-9a-f]{3}(?:[0-9a-f]{3})?$/i.test(raw))
+        return undefined;
+    if (raw.length === 7)
+        return raw;
+    return `#${raw.slice(1).split('').map((char) => `${char}${char}`).join('')}`;
+}
+function slug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'docs';
+}
+function mergeObjects(base, override) {
+    if (!base || typeof base !== 'object' || Array.isArray(base))
+        return override;
+    if (!override || typeof override !== 'object' || Array.isArray(override))
+        return override;
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (key === '$ref')
+            continue;
+        out[key] = key in out ? mergeObjects(out[key], value) : value;
+    }
+    return out;
+}
+/** Resolve Mintlify's JSON `$ref` files without executing code or leaving the source tree. */
+function resolveJsonRefs(value, currentPath, files, stack = new Set()) {
+    if (Array.isArray(value))
+        return value.map((item) => resolveJsonRefs(item, currentPath, files, stack));
+    if (!value || typeof value !== 'object')
+        return value;
+    const record = value;
+    let resolved = record;
+    const ref = asString(record.$ref);
+    if (ref && !ref.startsWith('#')) {
+        const refPath = joinPath(dirname(currentPath), ref.split('#')[0]);
+        if (!stack.has(refPath)) {
+            const source = files.get(refPath);
+            if (source) {
+                try {
+                    const nextStack = new Set(stack).add(refPath);
+                    resolved = mergeObjects(resolveJsonRefs(JSON.parse(source), refPath, files, nextStack), record);
+                }
+                catch {
+                    // Keep the sibling configuration when the referenced JSON is invalid.
+                }
+            }
+        }
+    }
+    const out = {};
+    for (const [key, child] of Object.entries(asRecord(resolved))) {
+        if (key !== '$ref')
+            out[key] = resolveJsonRefs(child, currentPath, files, stack);
+    }
+    return out;
+}
+function pageNode(entry) {
+    if (typeof entry === 'string')
+        return [{ type: 'page', file: stripPageExtension(normalizePath(entry)) }];
+    const obj = asRecord(entry);
+    const page = asString(obj.page);
+    if (page) {
+        return [{
+                type: 'page',
+                file: stripPageExtension(normalizePath(page)),
+                ...(asString(obj.title) ? { title: asString(obj.title) } : {}),
+                ...(asString(obj.icon) ? { icon: asString(obj.icon) } : {}),
+                ...(obj.hidden === true ? { hidden: true } : {}),
+            }];
+    }
+    const href = asString(obj.href ?? obj.url);
+    const linkLabel = asString(obj.label ?? obj.anchor ?? obj.name);
+    if (href && linkLabel && !Array.isArray(obj.pages) && !Array.isArray(obj.groups)) {
+        return [{ type: 'link', title: linkLabel, href, ...(asString(obj.icon) ? { icon: asString(obj.icon) } : {}) }];
+    }
+    const root = asString(obj.root);
+    const children = [
+        ...(root ? pageNode(root) : []),
+        ...(Array.isArray(obj.pages) ? obj.pages.flatMap(pageNode) : []),
+        ...apiNode(obj),
+    ];
+    const group = asString(obj.group);
+    if (Object.hasOwn(obj, 'group')) {
+        if (!group)
+            return children;
+        return [{ type: 'group', label: group, ...(asString(obj.icon) ? { icon: asString(obj.icon) } : {}), items: children }];
+    }
+    return children;
+}
+function normalizeSpecSource(source) {
+    return /^https?:\/\//i.test(source) ? source : normalizePath(source);
+}
+function openApiSource(value) {
+    return asString(value) ?? asString(asRecord(value).source);
+}
+function apiNode(container) {
+    const openapi = openApiSource(container.openapi);
+    return openapi
+        ? [{
+                type: 'api',
+                title: asString(container.apiTitle ?? container.api_title) ?? 'API Reference',
+                spec: normalizeSpecSource(openapi),
+                ...(asString(container.icon) ? { icon: asString(container.icon) } : {}),
+            }]
+        : [];
+}
+function directNav(container) {
+    const groups = Array.isArray(container.groups) ? container.groups.flatMap(pageNode) : [];
+    const pages = Array.isArray(container.pages) ? container.pages.flatMap(pageNode) : [];
+    return [...groups, ...pages, ...apiNode(container)];
+}
+function childContainers(value) {
+    return Array.isArray(value) ? value.map(asRecord).filter((entry) => Object.keys(entry).length > 0) : [];
+}
+/** Preserve every language/version/product/tab instead of silently selecting the first branch. */
+function collectSpaces(navigation, initialName) {
+    const spaces = [];
+    const importVersions = [];
+    const globalLinks = [];
+    const visit = (raw, ctx, depth) => {
+        if (depth > 12)
+            return;
+        if (Array.isArray(raw))
+            raw = { groups: raw };
+        const nav = asRecord(raw);
+        if (!Object.keys(nav).length)
+            return;
+        const global = asRecord(nav.global);
+        for (const entry of [...childContainers(global.anchors), ...childContainers(global.links)]) {
+            globalLinks.push(...pageNode(entry));
+        }
+        const languages = childContainers(nav.languages);
+        if (languages.length) {
+            for (const language of languages) {
+                const locale = asString(language.language ?? language.locale);
+                visit(language, { ...ctx, locale: locale ?? ctx.locale, suffixes: locale ? [...ctx.suffixes, locale.toUpperCase()] : ctx.suffixes }, depth + 1);
+            }
+            return;
+        }
+        // Versions become first-class ProjectVersion entries, NOT name-suffixed
+        // sibling spaces: each branch's spaces carry ctx.version and the catalog
+        // records label/tag/default (first entry is default unless one opts in).
+        const versions = childContainers(nav.versions);
+        if (versions.length) {
+            for (const version of versions) {
+                const label = asString(version.version ?? version.name ?? version.label);
+                if (!label) {
+                    visit(version, ctx, depth + 1);
+                    continue;
+                }
+                const key = slug(label);
+                if (!importVersions.some((entry) => entry.version === key)) {
+                    const tag = asString(version.tag);
+                    importVersions.push({
+                        version: key,
+                        label,
+                        ...(tag ? { tag } : {}),
+                        ...(version.default === true ? { isDefault: true } : {}),
+                    });
+                }
+                visit(version, { ...ctx, version: key }, depth + 1);
+            }
+            return;
+        }
+        const structured = [
+            ...childContainers(nav.products).map((entry) => ({ entry, label: asString(entry.product ?? entry.name ?? entry.label) })),
+            ...childContainers(nav.tabs).map((entry) => ({ entry, label: asString(entry.tab ?? entry.name ?? entry.label) })),
+            ...childContainers(nav.dropdowns).map((entry) => ({ entry, label: asString(entry.dropdown ?? entry.name ?? entry.label) })),
+        ];
+        if (structured.length) {
+            for (const { entry, label } of structured) {
+                visit(entry, {
+                    ...ctx,
+                    name: label ?? ctx.name,
+                    suffixes: ctx.suffixes,
+                    icon: asString(entry.icon) ?? ctx.icon,
+                    tag: asString(entry.tag) ?? ctx.tag,
+                    groupAnchors: true,
+                }, depth + 1);
+            }
+        }
+        const anchorLinks = [];
+        for (const anchor of childContainers(nav.anchors)) {
+            const nested = directNav(anchor).length > 0 || ['groups', 'pages', 'tabs', 'products', 'dropdowns'].some((key) => Array.isArray(anchor[key]));
+            if (nested) {
+                const label = asString(anchor.anchor ?? anchor.name) ?? ctx.name;
+                if (ctx.groupAnchors) {
+                    const items = directNav(anchor);
+                    if (items.length) {
+                        anchorLinks.push({
+                            type: 'group',
+                            label,
+                            ...(asString(anchor.icon) ? { icon: asString(anchor.icon) } : {}),
+                            items,
+                        });
+                    }
+                }
+                else {
+                    visit(anchor, { ...ctx, name: label }, depth + 1);
+                }
+            }
+            else {
+                anchorLinks.push(...pageNode(anchor));
+            }
+        }
+        const own = directNav(nav);
+        if (own.length || anchorLinks.length) {
+            const suffix = ctx.suffixes.length ? ` ${ctx.suffixes.join(' · ')}` : '';
+            const name = `${ctx.name}${suffix}`;
+            spaces.push({
+                name,
+                slug: slug(name),
+                ...(ctx.locale ? { locale: ctx.locale } : {}),
+                ...(ctx.version ? { version: ctx.version } : {}),
+                ...(ctx.icon ? { icon: ctx.icon } : {}),
+                ...(ctx.tag ? { tag: ctx.tag } : {}),
+                nav: [...own, ...anchorLinks],
+            });
+        }
+    };
+    visit(navigation, { name: initialName, suffixes: [] }, 0);
+    if (globalLinks.length) {
+        for (const space of spaces)
+            space.nav.push(...globalLinks);
+    }
+    if (importVersions.length > 0 && !importVersions.some((entry) => entry.isDefault)) {
+        importVersions[0].isDefault = true;
+    }
+    return { spaces: dedupeSpaces(spaces), versions: importVersions };
+}
+function dedupeSpaces(spaces) {
+    const seen = new Map();
+    return spaces.map((space) => {
+        // v1 and v2 both legitimately contain a "Getting Started" space, so the
+        // dedupe key spans (locale, version, slug).
+        const key = `${space.locale ?? ''}:${space.version ?? ''}:${space.slug ?? slug(space.name)}`;
+        const count = seen.get(key) ?? 0;
+        seen.set(key, count + 1);
+        return count === 0 ? space : { ...space, slug: `${space.slug ?? slug(space.name)}-${count + 1}` };
+    });
+}
+function fontConfig(value) {
+    if (typeof value === 'string')
+        return { family: value };
+    const record = asRecord(value);
+    return {
+        family: asString(record.family),
+        source: asString(record.source),
+        format: asString(record.format),
+        weight: asNumber(record.weight),
+    };
+}
+function mintlifyLayout(preset) {
+    // Mintlify themes differ mainly in shell density. These tokens keep the same
+    // proportions in Doxbrix while remaining responsive at the renderer layer.
+    switch (preset) {
+        // Mint's current max-w-8xl canvas is 92rem (1472px). With the reader's
+        // 32px inline padding this produces the 1408px body used by the source.
+        case 'mint': return { headerHeight: 64, tabsHeight: 48, shellMaxWidth: 1472, sidebarWidth: 288, tocWidth: 264, contentMaxWidth: 920, contentPadding: 32, navPadding: 32 };
+        case 'willow': return { headerHeight: 64, tabsHeight: 48, shellMaxWidth: 1400, sidebarWidth: 272, tocWidth: 248, contentMaxWidth: 760, contentPadding: 40, navPadding: 22 };
+        case 'linden': return { headerHeight: 64, sidebarWidth: 288, tocWidth: 256, contentMaxWidth: 820, contentPadding: 42, navPadding: 24 };
+        case 'maple':
+        case 'almond': return { headerHeight: 68, sidebarWidth: 304, tocWidth: 272, contentMaxWidth: 880, contentPadding: 48, navPadding: 26 };
+        case 'palm':
+        case 'aspen':
+        case 'sequoia': return { headerHeight: 68, sidebarWidth: 320, tocWidth: 288, contentMaxWidth: 920, contentPadding: 48, navPadding: 28 };
+        default: return { headerHeight: 64, sidebarWidth: 288, tocWidth: 272, contentMaxWidth: 840, contentPadding: 44, navPadding: 24 };
+    }
+}
+function mintlifyTypography(preset) {
+    if (preset !== 'mint')
+        return {};
+    // Mintlify does not serialize its platform typography defaults into docs.json.
+    // Materialize them during conversion so Doxbrix does not accidentally fall
+    // back to the host application's heavier title and lower-contrast prose.
+    return {
+        font: 'Inter',
+        headingFont: 'Inter',
+        typography: {
+            titleWeight: 600,
+            titleSize: 36,
+            titleSizeMobile: 30,
+            titleLineHeight: 1.11111,
+            titleLineHeightMobile: 1.2,
+            descriptionSize: 18,
+            descriptionLineHeight: 1.55556,
+            bodyWeight: 400,
+            bodySize: 16,
+            bodyLineHeight: 1.75,
+            fontFeatures: ['cv02', 'cv03', 'cv04', 'cv11'],
+            fontVariationSettings: 'normal',
+            fontSmoothing: 'antialiased',
+            headingWeight: 600,
+            h2Size: 24,
+            h2LineHeight: 1.33333,
+            h2MarginTop: 48,
+            h2MarginBottom: 16,
+            h3Size: 20,
+            h3LineHeight: 1.4,
+            h3MarginTop: 48,
+            h3MarginBottom: 12,
+            h4Size: 18,
+            h4LineHeight: 1.5,
+            h4MarginTop: 36,
+            h4MarginBottom: 9,
+            strongWeight: 600,
+            apiFieldWeight: 600,
+        },
+        textColors: {
+            // Mint's current neutral scale: gray-900/700/600 in light mode and
+            // gray-200/300/400 in dark mode.
+            light: { heading: '#171717', body: '#3f3f3f', muted: '#505050' },
+            dark: { heading: '#dfdfdf', body: '#cecece', muted: '#9f9f9f' },
+        },
+    };
+}
+function parseTheme(config) {
+    const colors = asRecord(config.colors);
+    const logo = config.logo;
+    const logoRecord = asRecord(logo);
+    const favicon = config.favicon;
+    const faviconRecord = asRecord(favicon);
+    const appearance = asRecord(config.appearance);
+    const fonts = asRecord(config.fonts);
+    const baseFont = fontConfig(config.fonts);
+    const bodyFont = fontConfig(fonts.body);
+    const headingFont = fontConfig(fonts.heading);
+    const codeFont = fontConfig(fonts.code);
+    const background = asRecord(config.background);
+    const bgColor = background.color;
+    const bgRecord = asRecord(bgColor);
+    const styling = asRecord(config.styling);
+    const codeblocks = styling.codeblocks;
+    const codeblockConfig = asRecord(codeblocks);
+    const codeblockTheme = codeblockConfig.theme;
+    const codeblockModes = asRecord(codeblockTheme);
+    const preset = asString(config.theme);
+    const presetTypography = mintlifyTypography(preset);
+    const fontSources = [];
+    for (const [role, font] of [['body', Object.keys(bodyFont).length ? bodyFont : baseFont], ['heading', headingFont], ['code', codeFont]]) {
+        if (font.family && font.source)
+            fontSources.push({ family: font.family, source: font.source, ...(font.format ? { format: font.format } : {}), ...(font.weight ? { weight: font.weight } : {}), role });
+    }
+    const mode = appearance.default === 'light' || appearance.default === 'dark' ? appearance.default : 'system';
+    return {
+        source: 'doxbrix-import',
+        ...(preset ? { preset } : {}),
+        ...(normalizeHex(colors.primary) ? { primaryColor: normalizeHex(colors.primary) } : {}),
+        ...(normalizeHex(colors.light) ? { lightColor: normalizeHex(colors.light) } : {}),
+        ...(normalizeHex(colors.dark) ? { darkColor: normalizeHex(colors.dark) } : {}),
+        mode,
+        strictMode: appearance.strict === true,
+        ...presetTypography,
+        ...(bodyFont.family ?? baseFont.family ? { font: bodyFont.family ?? baseFont.family } : {}),
+        ...(headingFont.family ?? bodyFont.family ?? baseFont.family ? { headingFont: headingFont.family ?? bodyFont.family ?? baseFont.family } : {}),
+        ...(codeFont.family ? { codeFont: codeFont.family } : {}),
+        ...(fontSources.length ? { fontSources } : {}),
+        ...(typeof logo === 'string' ? { logoLight: logo, logoDark: logo } : {}),
+        ...(asString(logoRecord.light) ? { logoLight: asString(logoRecord.light) } : {}),
+        ...(asString(logoRecord.dark) ? { logoDark: asString(logoRecord.dark) } : {}),
+        ...(asString(logoRecord.href) ? { logoHref: asString(logoRecord.href) } : {}),
+        ...(typeof favicon === 'string' ? { favicon } : {}),
+        ...(asString(faviconRecord.light) ? { faviconLight: asString(faviconRecord.light) } : {}),
+        ...(asString(faviconRecord.dark) ? { faviconDark: asString(faviconRecord.dark) } : {}),
+        ...(normalizeHex(bgRecord.light ?? bgColor) ? { backgroundColorLight: normalizeHex(bgRecord.light ?? bgColor) } : {}),
+        ...(normalizeHex(bgRecord.dark) ? { backgroundColorDark: normalizeHex(bgRecord.dark) } : {}),
+        ...(asString(background.image) ? { backgroundImage: asString(background.image) } : {}),
+        ...(asString(background.decoration) ? { backgroundDecoration: asString(background.decoration) } : {}),
+        ...(asString(codeblocks) ? { codeTheme: asString(codeblocks) } : {}),
+        ...(asString(codeblockTheme) ? { codeTheme: asString(codeblockTheme) } : {}),
+        ...(asString(codeblockModes.light) ? { codeThemeLight: asString(codeblockModes.light) } : {}),
+        ...(asString(codeblockModes.dark) ? { codeThemeDark: asString(codeblockModes.dark) } : {}),
+        ...(asString(styling.eyebrows) ? { eyebrow: asString(styling.eyebrows) } : {}),
+        layout: mintlifyLayout(preset),
+    };
+}
+function parseSiteChrome(config) {
+    const navbar = asRecord(config.navbar);
+    const links = Array.isArray(navbar.links) ? navbar.links.map(asRecord).map((link) => ({
+        label: asString(link.label ?? link.type) ?? 'Link',
+        href: asString(link.href) ?? '',
+        ...(asString(link.icon) ? { icon: asString(link.icon) } : {}),
+    })).filter((link) => link.href) : [];
+    const primaryRaw = asRecord(navbar.primary);
+    const primaryHref = asString(primaryRaw.href);
+    const primary = primaryHref ? { label: asString(primaryRaw.label ?? primaryRaw.type) ?? 'Open', href: primaryHref, ...(asString(primaryRaw.type) ? { type: asString(primaryRaw.type) } : {}) } : undefined;
+    const footer = asRecord(config.footer);
+    const groups = Array.isArray(footer.links) ? footer.links.map(asRecord).map((group) => ({
+        title: asString(group.header ?? group.title) ?? 'Links',
+        links: (Array.isArray(group.items) ? group.items : []).map(asRecord).map((link) => ({ label: asString(link.label) ?? 'Link', url: asString(link.href ?? link.url) ?? '' })).filter((link) => link.url),
+    })).filter((group) => group.links.length) : [];
+    const socials = Object.entries(asRecord(footer.socials)).map(([platform, url]) => ({ platform, label: platform.replace(/(^|-)(\w)/g, (_m, _p, c) => ` ${c.toUpperCase()}`).trim(), url: asString(url) ?? '' })).filter((entry) => entry.url);
+    const bannerRaw = asRecord(config.banner);
+    const bannerContent = asString(bannerRaw.content);
+    const bannerColor = bannerRaw.color;
+    const bannerColors = asRecord(bannerColor);
+    const bannerType = bannerRaw.type === 'warning' || bannerRaw.type === 'critical' ? bannerRaw.type : 'info';
+    const banner = bannerContent ? {
+        content: bannerContent,
+        dismissible: bannerRaw.dismissible === true,
+        type: bannerType,
+        ...(normalizeHex(bannerColors.light ?? bannerColor) ? { colorLight: normalizeHex(bannerColors.light ?? bannerColor) } : {}),
+        ...(normalizeHex(bannerColors.dark) ? { colorDark: normalizeHex(bannerColors.dark) } : {}),
+    } : undefined;
+    if (!links.length && !primary && !groups.length && !socials.length && !banner)
+        return undefined;
+    return {
+        ...((links.length || primary) ? { navbar: { links, ...(primary ? { primary } : {}) } } : {}),
+        ...((groups.length || socials.length) ? { footer: { groups, socials } } : {}),
+        ...(banner ? { banner } : {}),
+    };
+}
+function parseRedirects(value) {
+    return Array.isArray(value) ? value.map(asRecord).map((redirect) => ({ from: asString(redirect.source ?? redirect.from) ?? '', to: asString(redirect.destination ?? redirect.to) ?? '' })).filter((redirect) => redirect.from && redirect.to) : [];
+}
+/** Mintlify accepts one or many OpenAPI documents in `api.openapi`. Object
+ * entries use `source`; strings can be repository paths or public URLs. */
+function parseOpenApiSources(config) {
+    const raw = asRecord(config.api).openapi;
+    const values = Array.isArray(raw) ? raw : raw === undefined ? [] : [raw];
+    const sources = values
+        .map((value) => asString(value) ?? asString(asRecord(value).source))
+        .filter((value) => Boolean(value));
+    return [...new Set(sources)];
+}
+function navigationOpenApiSources(value, sources = []) {
+    if (Array.isArray(value)) {
+        for (const child of value)
+            navigationOpenApiSources(child, sources);
+        return sources;
+    }
+    const node = asRecord(value);
+    if (!Object.keys(node).length)
+        return sources;
+    const source = openApiSource(node.openapi);
+    if (source)
+        sources.push(normalizeSpecSource(source));
+    for (const key of ['languages', 'versions', 'products', 'tabs', 'dropdowns', 'anchors', 'groups', 'pages']) {
+        navigationOpenApiSources(node[key], sources);
+    }
+    return sources;
+}
+function parseApiBaseUrl(config) {
+    const server = asRecord(asRecord(config.api).mdx).server;
+    if (Array.isArray(server))
+        return server.map(asString).find(Boolean);
+    return asString(server);
+}
+function collectManifestPages(manifest) {
+    const files = new Set();
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === 'page')
+                files.add(stripPageExtension(normalizePath(node.file)));
+            else if (node.type === 'group')
+                walk(node.items);
+        }
+    };
+    for (const space of manifest.spaces)
+        walk(space.nav);
+    return files;
+}
+function likelyPage(path) {
+    const parts = normalizePath(path).split('/');
+    if (parts.some((part) => NON_PAGE_DIRS.has(part.toLowerCase())))
+        return false;
+    return parts.length !== 1 || !ROOT_REPOSITORY_FILES.has(stripPageExtension(parts[0]).toLowerCase());
+}
+function preserveUnlistedPages(manifest, pagePaths) {
+    const listed = collectManifestPages(manifest);
+    const missing = pagePaths.map(stripPageExtension).filter((file) => likelyPage(file) && !listed.has(file));
+    if (!missing.length)
+        return;
+    if (!manifest.spaces[0])
+        manifest.spaces.push({ name: manifest.name ?? 'Documentation', slug: 'docs', nav: [] });
+    manifest.spaces[0].nav.push({
+        type: 'group',
+        label: 'Imported pages',
+        hidden: true,
+        items: missing.sort().map((file) => ({ type: 'page', file, hidden: true })),
+    });
+}
+function splitFrontmatter(markdown) {
+    if (!/^---\s*\r?\n/.test(markdown))
+        return { head: '', body: markdown };
+    const match = /^---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n?/.exec(markdown);
+    return match ? { head: match[0], body: markdown.slice(match[0].length) } : { head: '', body: markdown };
+}
+function attr(raw, name) {
+    const match = new RegExp(`\\b${name}\\s*=\\s*(?:["']([^"']*)["']|\\{([^{}]*)\\}|([^\\s/>]+))`, 'i').exec(raw);
+    return match?.[1] ?? match?.[2] ?? match?.[3];
+}
+function stringAttr(raw, name) {
+    const value = attr(raw, name)?.trim();
+    if (!value)
+        return undefined;
+    const quoted = /^(['"])([\s\S]*)\1$/.exec(value);
+    return quoted ? quoted[2] : value;
+}
+function decodeMdxEntities(value) {
+    return value
+        .replace(/&#x([0-9a-f]+);/gi, (_match, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_match, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10)))
+        .replace(/&quot;/gi, '"')
+        .replace(/&apos;|&#39;/gi, "'")
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&amp;/gi, '&');
+}
+function mintlifyFieldInline(rawAttrs) {
+    const name = decodeMdxEntities(attr(rawAttrs, 'name') ?? 'field').replace(/`/g, '\\`').replace(/\|/g, '\\|');
+    const type = decodeMdxEntities(attr(rawAttrs, 'type') ?? '').replace(/`/g, '\\`').replace(/\|/g, '\\|');
+    const required = /(?:^|\s)required(?:\s|=|$)/i.test(rawAttrs);
+    const recommended = /(?:^|\s)recommended(?:\s|=|$)/i.test(rawAttrs);
+    return [`\`${name}\``, required ? '*' : recommended ? '●' : '', type ? `\`(${type})\`` : '']
+        .filter(Boolean)
+        .join(' ');
+}
+function exportedSnippetBody(source, exportedName) {
+    const content = splitFrontmatter(source).body.trim();
+    if (!exportedName)
+        return content;
+    const declaration = new RegExp(`export\\s+const\\s+${exportedName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).exec(content);
+    if (!declaration)
+        return content;
+    const arrow = content.indexOf('=>', declaration.index);
+    if (arrow < 0)
+        return content;
+    const returned = content.indexOf('return', arrow);
+    const open = content.indexOf('(', returned >= 0 ? returned : arrow + 2);
+    const close = content.lastIndexOf(');');
+    if (open < 0 || close <= open)
+        return content;
+    return content.slice(open + 1, close).trim().replace(/^<>\s*/, '').replace(/\s*<\/>$/, '');
+}
+function expandSnippetInvocation(output, name, snippet) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const invocation = new RegExp(`<${escaped}\\b((?:"[^"]*"|'[^']*'|\\{[^{}]*\\}|[^>])*)(?:\\/\\s*>|>([\\s\\S]*?)<\\/${escaped}>)`, 'g');
+    return output.replace(invocation, (_match, rawAttrs, children) => {
+        let expanded = snippet;
+        for (const attribute of rawAttrs.matchAll(/\b([A-Za-z_$][\w$-]*)\s*=\s*(?:["']([^"']*)["']|\{\s*(["'])([\s\S]*?)\3\s*\}|\{([^{}]*)\})/g)) {
+            const key = attribute[1];
+            const value = attribute[2] ?? attribute[4] ?? attribute[5] ?? '';
+            expanded = expanded.replace(new RegExp(`\\{\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*}`, 'g'), JSON.stringify(value.trim()));
+        }
+        return children?.trim() ? `${expanded}\n${children.trim()}` : expanded;
+    });
+}
+function inlineMdxSnippets(body, pagePath, files, stack = new Set()) {
+    const imports = new Map();
+    let output = body.replace(/^\s*import\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+["']([^"']+\.(?:md|mdx))["']\s*;?\s*$/gm, (_match, name, source) => {
+        const target = normalizePath(source.startsWith('/') ? source : joinPath(dirname(pagePath), source));
+        const snippet = files.get(target);
+        if (snippet !== undefined && !stack.has(target)) {
+            imports.set(name, inlineMdxSnippets(exportedSnippetBody(snippet), target, files, new Set(stack).add(target)));
+        }
+        return '';
+    });
+    output = output.replace(/^\s*import\s*\{([^}]+)}\s*from\s*["']([^"']+\.(?:md|mdx|js|jsx|ts|tsx))["']\s*;?\s*$/gm, (_match, bindings, source) => {
+        const target = normalizePath(source.startsWith('/') ? source : joinPath(dirname(pagePath), source));
+        const snippet = files.get(target);
+        if (snippet !== undefined) {
+            const isCodeModule = /\.(?:js|jsx|ts|tsx)$/i.test(target);
+            for (const binding of bindings.split(',')) {
+                const [exported, local = exported] = binding.trim().split(/\s+as\s+/);
+                if (exported && local && local !== 'IntegrationTile' && !stack.has(target)) {
+                    const exportedBody = exportedSnippetBody(snippet, exported);
+                    // Mintlify repositories commonly keep brand icons as tiny React
+                    // components. Inline only modules whose selected export is a single
+                    // SVG tree; arbitrary JavaScript components must never be executed or
+                    // copied into the destination MDX.
+                    if (!isCodeModule || /^<svg\b[\s\S]*<\/svg\s*>$/i.test(exportedBody.trim())) {
+                        imports.set(local, isCodeModule
+                            ? exportedBody
+                            : inlineMdxSnippets(exportedBody, target, files, new Set(stack).add(target)));
+                    }
+                }
+            }
+        }
+        return '';
+    });
+    // Mintlify also permits reusable snippets to be globally available. Resolve
+    // simple PascalCase filename components so pages do not lose content merely
+    // because an explicit import is absent.
+    for (const [path, source] of files) {
+        if (!/(?:^|\/)snippets\/[^/]+\.(?:md|mdx)$/i.test(path))
+            continue;
+        const base = path.split('/').at(-1).replace(/\.(?:md|mdx)$/i, '');
+        const name = base.split(/[-_]+/).map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`).join('');
+        if (name && name !== 'IntegrationTile' && output.includes(`<${name}`) && !imports.has(name) && !stack.has(path)) {
+            imports.set(name, inlineMdxSnippets(exportedSnippetBody(source), path, files, new Set(stack).add(path)));
+        }
+    }
+    for (const [name, snippet] of imports) {
+        output = expandSnippetInvocation(output, name, snippet);
+    }
+    return output;
+}
+function replaceBalancedTag(body, tag, map) {
+    const re = new RegExp(`<${tag}\\b([^>]*)>([\\s\\S]*?)</${tag}>`, 'gi');
+    let prior = '';
+    let next = body;
+    while (next !== prior) {
+        prior = next;
+        next = next.replace(re, (_match, attrs, inner) => map(attrs, inner));
+    }
+    return next;
+}
+function normalizeFileTreeInner(inner) {
+    return inner
+        .replace(/<Tree\.Folder\b/gi, '<Folder')
+        .replace(/<\/Tree\.Folder>/gi, '</Folder>')
+        .replace(/<Tree\.File\b/gi, '<FileNode')
+        .replace(/<\/Tree\.File>/gi, '</FileNode>');
+}
+function mintlifyImageTheme(rawAttrs) {
+    const className = stringAttr(rawAttrs, 'className') ?? stringAttr(rawAttrs, 'class') ?? '';
+    if (/(?:^|\s)dark:hidden(?:\s|$)/i.test(className))
+        return 'light';
+    if (/(?:^|\s)dark:block(?:\s|$)/i.test(className) && /(?:^|\s)hidden(?:\s|$)/i.test(className))
+        return 'dark';
+    return undefined;
+}
+/**
+ * Mintlify commonly authors one light-theme image followed by one dark-theme
+ * image and controls visibility with Tailwind classes. Preserve that pair as a
+ * single portable Image block so stripping source CSS does not show both.
+ */
+function normalizeMintlifyThemeImagePairs(segment) {
+    return segment.replace(/<img\b([^>]*)\/?\s*>\s*<img\b([^>]*)\/?\s*>/gi, (match, firstAttrs, secondAttrs) => {
+        const firstTheme = mintlifyImageTheme(firstAttrs);
+        const secondTheme = mintlifyImageTheme(secondAttrs);
+        if (!firstTheme || !secondTheme || firstTheme === secondTheme)
+            return match;
+        const lightAttrs = firstTheme === 'light' ? firstAttrs : secondAttrs;
+        const darkAttrs = firstTheme === 'dark' ? firstAttrs : secondAttrs;
+        const lightSrc = stringAttr(lightAttrs, 'src');
+        const darkSrc = stringAttr(darkAttrs, 'src');
+        if (!lightSrc || !darkSrc)
+            return match;
+        const alt = stringAttr(lightAttrs, 'alt') ?? stringAttr(darkAttrs, 'alt') ?? '';
+        return `\n<Image src=${JSON.stringify(lightSrc)} darkSrc=${JSON.stringify(darkSrc)} alt=${JSON.stringify(alt)} />\n`;
+    });
+}
+const SAFE_SVG_PRESENTATION_PROPERTIES = new Set([
+    'fill',
+    'fill-opacity',
+    'opacity',
+    'stroke',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-opacity',
+    'stroke-width',
+]);
+function svgStyleText(value) {
+    const expression = /^\s*\{\s*("(?:\\.|[^"\\])*")\s*}\s*$/.exec(value)?.[1];
+    if (!expression)
+        return value;
+    try {
+        return JSON.parse(expression);
+    }
+    catch {
+        return '';
+    }
+}
+/** Convert safe class-based SVG presentation rules to attributes before style
+ * elements are removed. This preserves icons generated by design tools without
+ * allowing their CSS to escape the SVG or affect the surrounding docs page. */
+function inlineSafeSvgClassStyles(svg) {
+    const classRules = new Map();
+    const withoutStyles = svg.replace(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi, (_match, raw) => {
+        const css = svgStyleText(raw);
+        for (const rule of css.matchAll(/\.([A-Za-z_][\w-]*)\s*\{([^{}]*)}/g)) {
+            const declarations = new Map();
+            for (const declaration of (rule[2] ?? '').split(';')) {
+                const separator = declaration.indexOf(':');
+                if (separator < 1)
+                    continue;
+                const property = declaration.slice(0, separator).trim().toLowerCase();
+                const value = declaration.slice(separator + 1).trim();
+                if (SAFE_SVG_PRESENTATION_PROPERTIES.has(property)
+                    && /^(?:currentColor|none|transparent|#[0-9a-f]{3,8}|-?(?:\d+(?:\.\d+)?|\.\d+)(?:px|%)?|url\(#[A-Za-z_][\w:.-]*\))$/i.test(value))
+                    declarations.set(property, value);
+            }
+            if (declarations.size)
+                classRules.set(rule[1], declarations);
+        }
+        return '';
+    });
+    if (!classRules.size)
+        return withoutStyles;
+    return withoutStyles.replace(/<([A-Za-z][\w:.-]*)\b([^>]*)>/g, (match, tag, attrs) => {
+        const classes = /\b(?:class|className)\s*=\s*(["'])(.*?)\1/i.exec(attrs)?.[2]?.split(/\s+/) ?? [];
+        const additions = new Map();
+        for (const className of classes) {
+            for (const [property, value] of classRules.get(className) ?? [])
+                additions.set(property, value);
+        }
+        let nextAttrs = attrs;
+        for (const [property, value] of additions) {
+            if (!new RegExp(`\\b${property.replace('-', '[-A-Z]')}\\s*=`, 'i').test(nextAttrs)) {
+                nextAttrs += ` ${property}="${value}"`;
+            }
+        }
+        return `<${tag}${nextAttrs}>`;
+    });
+}
+function sanitizeInlineSvg(svg) {
+    return inlineSafeSvgClassStyles(svg)
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>/gi, '')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style\s*>/gi, '')
+        .replace(/<foreignObject\b[^>]*>[\s\S]*?<\/foreignObject\s*>/gi, '')
+        .replace(/<(?:animate|animateMotion|animateTransform|set)\b[^>]*>[\s\S]*?<\/(?:animate|animateMotion|animateTransform|set)\s*>/gi, '')
+        .replace(/<(?:animate|animateMotion|animateTransform|set)\b[^>]*\/\s*>/gi, '')
+        .replace(/\s+style\s*=\s*\{\{[\s\S]*?}}/gi, '')
+        .replace(/\s+\{\.\.\.[^}]+}/g, '')
+        .replace(/\s+on[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|\{[^}]*\}|[^\s>]+)/gi, '')
+        .replace(/\s+(?:href|xlink:href)\s*=\s*(["'])\s*javascript:[\s\S]*?\1/gi, '')
+        .replace(/=\{\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*}/g, '="$1"')
+        .replace(/=\{\s*(["'])([\s\S]*?)\1\s*}/g, '="$2"')
+        .replace(/\bclassName=/g, 'class=')
+        .replace(/\bfillRule=/g, 'fill-rule=')
+        .replace(/\bclipRule=/g, 'clip-rule=')
+        .replace(/\bclipPath=/g, 'clip-path=')
+        .replace(/\bfillOpacity=/g, 'fill-opacity=')
+        .replace(/\bstrokeWidth=/g, 'stroke-width=')
+        .replace(/\bstrokeLinecap=/g, 'stroke-linecap=')
+        .replace(/\bstrokeLinejoin=/g, 'stroke-linejoin=')
+        .replace(/\bstrokeMiterlimit=/g, 'stroke-miterlimit=')
+        .replace(/\bstrokeOpacity=/g, 'stroke-opacity=')
+        .replace(/\bstopColor=/g, 'stop-color=')
+        .replace(/\bstopOpacity=/g, 'stop-opacity=')
+        .replace(/\bxmlSpace=/g, 'xml:space=')
+        .replace(/\bxlinkHref=/g, 'xlink:href=')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function markForcedCurrentColorCardIcons(input) {
+    return input.replace(/\bicon\s*=\s*\{\s*(<svg\b)/gi, 'icon={$1 data-doxbrix-force-current-color="true"');
+}
+function sourceForcesCurrentColorCardIcons(files) {
+    return [...files].some(([path, content]) => (/\.css$/i.test(path)
+        && /\[data-component-part=["']card-icon["']]\s+svg\s+(?:path|g|circle|rect)/i.test(content)
+        && /fill\s*:\s*#18171a\s*!important/i.test(content)
+        && /html\.dark[\s\S]*?fill\s*:\s*#(?:fff|ffffff)\s*!important/i.test(content)));
+}
+/**
+ * Decode an SVG icon produced by the importer for safe inline rendering.
+ *
+ * SVGs that use `currentColor` must remain in the document tree to inherit the
+ * card or navigation color. Rendering the same data URL through `<img>` creates
+ * an isolated document and silently turns those icons black. Only the encoded
+ * SVG form emitted by this importer is accepted, and it is sanitized again at
+ * the rendering boundary before callers use it as markup.
+ */
+export function decodeImportedSvgIconDataUrl(value) {
+    const prefix = 'data:image/svg+xml,';
+    if (!value.toLowerCase().startsWith(prefix))
+        return null;
+    try {
+        const decoded = decodeURIComponent(value.slice(prefix.length));
+        const sanitized = sanitizeInlineSvg(decoded);
+        return /^<svg\b[^>]*>[\s\S]*<\/svg\s*>$/i.test(sanitized) ? sanitized : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Preserve JSX `icon={<svg>...</svg>}` values without retaining executable JSX. */
+function normalizeMintlifyInlineSvgIcons(segment) {
+    return segment.replace(/\bicon\s*=\s*\{\s*(<svg\b[\s\S]*?<\/svg\s*>)\s*\}/gi, (_match, svg) => {
+        const sanitized = sanitizeInlineSvg(svg);
+        if (!sanitized)
+            return '';
+        return `icon=${JSON.stringify(`data:image/svg+xml,${encodeURIComponent(sanitized)}`)}`;
+    });
+}
+/**
+ * Degrade ordinary HTML/JSX used inside Mintlify MDX to the portable component
+ * vocabulary understood by the block importer. Documentation platforms permit
+ * raw HTML and JSX, so otherwise tags such as `<div>` and `<li>` survive as
+ * reader-visible text.
+ *
+ * This is intentionally a small, non-executing tokenizer rather than an HTML
+ * parser: it handles the common authoring tags while leaving unknown tags alone.
+ * Flex wrappers become native Columns; their direct child divs become Column items.
+ */
+function transformPortableHtmlSegment(segment) {
+    const inlineCode = [];
+    // Raw HTML-like text inside Markdown code spans is documentation content,
+    // not a live construct. Protect it before the HTML/JSX tokenizer runs. Work
+    // line-by-line because CommonMark code spans authored this way do not need a
+    // cross-line placeholder for the Mintlify content we import.
+    const protectedSegment = segment.split('\n').map((line) => line.replace(/(`+)([^`]*?)\1/g, (value) => {
+        const index = inlineCode.push(value) - 1;
+        return `DOCSINLINECODE${index}END`;
+    })).join('\n');
+    // Media embeds are commonly authored as paired, multiline HTML. Collapse the
+    // whole element first so its closing tag cannot leak into a separate block.
+    // `url` is used for Video because that is the portable block vocabulary;
+    // Embed keeps `src` for iframe-compatible content.
+    const normalized = normalizeMintlifyThemeImagePairs(normalizeMintlifyInlineSvgIcons(protectedSegment))
+        .replace(/<iframe\b([^>]*)>[\s\S]*?<\/iframe\s*>/gi, (_match, attrs) => {
+        const src = attr(attrs, 'src');
+        return src ? `\n<Embed src=${JSON.stringify(src)} />\n` : '';
+    })
+        .replace(/<video\b([^>]*)>([\s\S]*?)<\/video\s*>/gi, (_match, attrs, inner) => {
+        const sourceAttrs = /<source\b([^>]*)\/?\s*>/i.exec(inner)?.[1] ?? '';
+        const src = attr(attrs, 'src') ?? attr(sourceAttrs, 'src');
+        return src ? `\n<Video url=${JSON.stringify(src)} />\n` : inner;
+    });
+    const divStack = [];
+    const listStack = [];
+    const linkStack = [];
+    const token = /\{\/\*[\s\S]*?\*\/\}|\{\s*(['"])\s*\1\s*\}|<([a-z][a-z0-9]*)\b([^>]*?)(\/?)>|<\/([a-z][a-z0-9]*)\s*>/gi;
+    const transformed = normalized.replace(token, (match, _spaceQuote, openName, rawAttrs, _selfClose, closeName) => {
+        if (match.startsWith('{/*'))
+            return '';
+        if (match.startsWith('{'))
+            return ' ';
+        if (openName) {
+            // Portable MDX components are capitalized. They already belong to the
+            // destination vocabulary and must not be mistaken for lowercase HTML.
+            if (/^[A-Z]/.test(openName))
+                return match;
+            const name = openName.toLowerCase();
+            const attrs = rawAttrs ?? '';
+            if (/^h[1-6]$/.test(name))
+                return `\n${'#'.repeat(Number(name[1]))} `;
+            switch (name) {
+                case 'div': {
+                    const parent = divStack.at(-1);
+                    const isFlex = /\bdisplay\s*:\s*['"]?flex\b/i.test(attrs);
+                    const kind = isFlex ? 'columns' : parent === 'columns' ? 'column' : 'strip';
+                    divStack.push(kind);
+                    if (kind === 'columns')
+                        return '\n<Columns>\n';
+                    if (kind === 'column')
+                        return '\n<Column>\n';
+                    return '\n';
+                }
+                case 'p':
+                    return '\n';
+                case 'ul':
+                case 'ol':
+                    listStack.push({ tag: name, next: 1, items: 0 });
+                    return '\n';
+                case 'li': {
+                    const list = listStack.at(-1);
+                    const prefix = list && list.items++ > 0 ? '\n' : '';
+                    if (!list || list.tag === 'ul')
+                        return `${prefix}- `;
+                    return `${prefix}${list.next++}. `;
+                }
+                case 'a': {
+                    const href = attr(attrs, 'href') ?? '#';
+                    linkStack.push(href);
+                    return '[';
+                }
+                case 'img': {
+                    const cleanAttrs = attrs
+                        .replace(/\bclassName=(['"])[\s\S]*?\1/gi, '')
+                        .replace(/\s*\/$/, '')
+                        .trim();
+                    return `\n<Image${cleanAttrs ? ` ${cleanAttrs}` : ''} />\n`;
+                }
+                case 'iframe': {
+                    const src = attr(attrs, 'src');
+                    return src ? `\n<Embed src=${JSON.stringify(src)} />\n` : '';
+                }
+                case 'source': {
+                    const src = attr(attrs, 'src');
+                    return src ? `\n<Video url=${JSON.stringify(src)} />\n` : '';
+                }
+                case 'video': {
+                    const src = attr(attrs, 'src');
+                    return src ? `\n<Video url=${JSON.stringify(src)} />\n` : '\n';
+                }
+                case 'br':
+                    return '\n';
+                case 'hr':
+                    return '\n---\n';
+                case 'strong':
+                case 'b':
+                    return '**';
+                case 'em':
+                case 'i':
+                    return '*';
+                case 'span':
+                case 'button':
+                    return '';
+                case 'section':
+                case 'article':
+                case 'main':
+                case 'header':
+                case 'footer':
+                case 'figure':
+                case 'figcaption':
+                    return '\n';
+                default:
+                    return match;
+            }
+        }
+        if (closeName) {
+            if (/^[A-Z]/.test(closeName))
+                return match;
+            const name = closeName.toLowerCase();
+            if (/^h[1-6]$/.test(name))
+                return '\n\n';
+            switch (name) {
+                case 'div': {
+                    const kind = divStack.pop();
+                    if (kind === 'columns')
+                        return '\n</Columns>\n';
+                    if (kind === 'column')
+                        return '\n</Column>\n';
+                    return '\n';
+                }
+                case 'p':
+                    return '\n\n';
+                case 'ul':
+                case 'ol':
+                    listStack.pop();
+                    return '\n';
+                case 'li':
+                    return '';
+                case 'a':
+                    return `](${linkStack.pop() ?? '#'})`;
+                case 'strong':
+                case 'b':
+                    return '**';
+                case 'em':
+                case 'i':
+                    return '*';
+                case 'span':
+                case 'button':
+                    return '';
+                case 'iframe':
+                case 'source':
+                case 'video':
+                case 'section':
+                case 'article':
+                case 'main':
+                case 'header':
+                case 'footer':
+                case 'figure':
+                case 'figcaption':
+                    return '\n';
+                default:
+                    return match;
+            }
+        }
+        return match;
+    });
+    // JSX commonly puts each <li> on its own indented line. The replacement plus
+    // source whitespace can otherwise insert blank lines and split one list into
+    // several one-item blocks.
+    return transformed
+        // An image used as the sole content of an HTML heading is media, not an
+        // empty Markdown heading followed by media.
+        .replace(/^\s*#{1,6}\s*(?=<Image\b)/gm, '')
+        .replace(/^([ \t]*(?:[-*+]|\d+\.)[ \t]+.*)\n(?:[ \t]*\n)+(?=[ \t]*(?:[-*+]|\d+\.)[ \t])/gm, '$1\n')
+        .replace(/DOCSINLINECODE(\d+)END/g, (_match, index) => inlineCode[Number(index)] ?? '');
+}
+/** Apply raw-HTML normalization only outside fenced code examples. */
+function transformPortableHtml(body) {
+    const lines = body.split('\n');
+    const out = [];
+    let pending = [];
+    let inFence = false;
+    const flush = () => {
+        if (!pending.length)
+            return;
+        out.push(transformPortableHtmlSegment(pending.join('\n')));
+        pending = [];
+    };
+    for (const line of lines) {
+        if (/^\s*(```|~~~)/.test(line)) {
+            if (!inFence)
+                flush();
+            out.push(line);
+            inFence = !inFence;
+        }
+        else if (inFence) {
+            out.push(line);
+        }
+        else {
+            pending.push(line);
+        }
+    }
+    flush();
+    return out.join('\n');
+}
+function protectFencedCodeBlocks(body) {
+    const blocks = [];
+    const output = [];
+    let current;
+    let fenceCharacter = '';
+    let fenceLength = 0;
+    for (const line of body.split('\n')) {
+        if (!current) {
+            const opening = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+            if (!opening) {
+                output.push(line);
+                continue;
+            }
+            current = [line];
+            fenceCharacter = opening[0];
+            fenceLength = opening.length;
+            continue;
+        }
+        current.push(line);
+        const closing = new RegExp(`^\\s*${fenceCharacter === '`' ? '`' : '~'}{${fenceLength},}\\s*$`);
+        if (!closing.test(line))
+            continue;
+        const index = blocks.push(current.join('\n')) - 1;
+        output.push(`DOCSFENCEDCODE${index}END`);
+        current = undefined;
+    }
+    // Preserve an incomplete fence as authored. Validation can report the
+    // unbalanced fence without transformations corrupting its contents.
+    if (current)
+        output.push(current.join('\n'));
+    return {
+        body: output.join('\n'),
+        restore: (value) => value.replace(/DOCSFENCEDCODE(\d+)END/g, (_match, index) => blocks[Number(index)] ?? ''),
+    };
+}
+/** Normalize current Mintlify components into Doxbrix's supported MDX vocabulary. */
+export function transformMintlifyMdx(input) {
+    let body = input;
+    const importedComponents = new Set();
+    for (const line of body.split('\n')) {
+        for (const statement of line.matchAll(/\bimport\s+(.+?)\s+from\s+["'][^"']+["']/g)) {
+            const bindings = statement[1] ?? '';
+            const defaultName = /^([A-Z][A-Za-z0-9_$]*)/.exec(bindings)?.[1];
+            if (defaultName)
+                importedComponents.add(defaultName);
+            const named = /\{([^}]+)}/.exec(bindings)?.[1];
+            for (const binding of named?.split(',') ?? []) {
+                const local = binding.trim().split(/\s+as\s+/).at(-1);
+                if (local && /^[A-Z][A-Za-z0-9_$]*$/.test(local))
+                    importedComponents.add(local);
+            }
+        }
+    }
+    let inFence = false;
+    body = body.split('\n').map((line) => {
+        if (/^\s*(```|~~~)/.test(line))
+            inFence = !inFence;
+        if (inFence || !/^\s*(?:import|export)\b/.test(line))
+            return line;
+        return '';
+    }).join('\n');
+    const fencedCode = protectFencedCodeBlocks(body);
+    body = fencedCode.body;
+    body = transformPortableHtml(body);
+    // Imported presentation components are normally removed because their code
+    // cannot execute in a portable docs project. Field is semantic content,
+    // though: dropping it erases whole table cells. Flatten it to Markdown that
+    // both the cloud reader and CLI preview can render.
+    body = body.replace(/<Field\b((?:"[^"]*"|'[^']*'|[^>])*)\/\s*>/gi, (_match, attrs) => mintlifyFieldInline(attrs));
+    // The destination reader already builds a page TOC. Avoid retaining an
+    // imported client-only TOC placeholder or an empty Panel/Info around it.
+    body = body.replace(/<TableOfContents\b((?:"[^"]*"|'[^']*'|[^>])*)\/\s*>/gi, '');
+    body = body.replace(/<Tab\b([^>]*?)\btitle=(['"])(.*?)\2/gi, '<Tab$1label=$2$3$2');
+    body = body.replace(/<Video\b([^>]*?)\bsrc=(['"])(.*?)\2/gi, '<Video$1url=$2$3$2');
+    body = body.replace(/<Embed\b([^>]*?)\burl=(['"])(.*?)\2/gi, '<Embed$1src=$2$3$2');
+    body = body.replace(/<File\b([^>]*?)\bsrc=(['"])(.*?)\2/gi, '<File$1url=$2$3$2');
+    body = replaceBalancedTag(body, 'Panel', (attrs, inner) => inner.trim() ? `<SidePanel${attrs}>\n${inner.trim()}\n</SidePanel>` : '');
+    body = replaceBalancedTag(body, 'Prompt', (attrs, inner) => `<PromptCard${attrs}>\n${inner.trim()}\n</PromptCard>`);
+    // Tile is already the Doxbrix-native name. Tiles becomes a Columns layout so
+    // every child remains an independently editable Tile block.
+    body = replaceBalancedTag(body, 'Tiles', (attrs, inner) => `<Columns${attrs}>\n${inner.trim()}\n</Columns>`);
+    body = replaceBalancedTag(body, 'View', (attrs, inner) => `<ViewPane${attrs}>\n${inner.trim()}\n</ViewPane>`);
+    // Adjacent Mintlify Views are one selector; keep the grouping explicit.
+    body = body.replace(/(?:\s*<ViewPane\b[^>]*>[\s\S]*?<\/ViewPane>\s*)+/gi, (run) => `<ViewSwitcher>\n${run.trim()}\n</ViewSwitcher>`);
+    body = replaceBalancedTag(body, 'Visibility', (attrs, inner) => `<Audience${attrs}>\n${inner.trim()}\n</Audience>`);
+    body = replaceBalancedTag(body, 'Banner', (attrs, inner) => {
+        const type = attr(attrs, 'type');
+        const tag = type === 'warning' || type === 'critical' ? 'Warning' : 'Info';
+        return `<${tag}>\n${inner.trim()}\n</${tag}>`;
+    });
+    body = replaceBalancedTag(body, 'Tree', (_attrs, inner) => `<FileTree>\n${normalizeFileTreeInner(inner).trim()}\n</FileTree>`);
+    body = replaceBalancedTag(body, 'FileTree', (_attrs, inner) => `<FileTree>\n${normalizeFileTreeInner(inner).trim()}\n</FileTree>`);
+    body = replaceBalancedTag(body, 'Color', (attrs, inner) => {
+        const normalized = inner
+            .replace(/<Color\.Row\b/gi, '<ColorGroup')
+            .replace(/<\/Color\.Row>/gi, '</ColorGroup>')
+            .replace(/<Color\.Item\b/gi, '<ColorSwatch')
+            .replace(/<\/Color\.Item>/gi, '</ColorSwatch>');
+        // Mintlify permits Color.Item directly inside Color; give those swatches a
+        // canonical group so the destination schema never needs two shapes.
+        const grouped = /<ColorGroup\b/i.test(normalized) ? normalized : `<ColorGroup>\n${normalized.trim()}\n</ColorGroup>`;
+        return `<ColorPalette${attrs}>\n${grouped.trim()}\n</ColorPalette>`;
+    });
+    // Imported JSX components that are simple image/CTA cards degrade to portable Markdown.
+    body = body.replace(/<([A-Z][A-Za-z0-9_$]*)\b([^>]*?)\/>/g, (match, name, attrs) => {
+        // These are already portable media blocks. In particular, treating an
+        // iframe-derived Embed's `src` as an image would silently change its type.
+        if (['Embed', 'Excalidraw', 'File', 'PDF', 'Video', 'Tile', 'Icon', 'ColorSwatch', 'FileNode'].includes(name))
+            return match;
+        // A paired light/dark source must remain one theme-aware image block.
+        // Ordinary Image components still degrade to portable Markdown below.
+        if (name === 'Image' && stringAttr(attrs, 'darkSrc'))
+            return match;
+        const image = stringAttr(attrs, 'logo') ?? stringAttr(attrs, 'img') ?? stringAttr(attrs, 'image') ?? stringAttr(attrs, 'src');
+        const alt = stringAttr(attrs, 'alt') ?? stringAttr(attrs, 'title') ?? name;
+        const href = stringAttr(attrs, 'link') ?? stringAttr(attrs, 'ctaHref') ?? stringAttr(attrs, 'href');
+        const label = stringAttr(attrs, 'ctaText') ?? stringAttr(attrs, 'title');
+        if (href && label && name === 'IntegrationTile') {
+            return `<Tile title=${JSON.stringify(label)} href=${JSON.stringify(href)}${image ? ` image=${JSON.stringify(image)}` : ''} />`;
+        }
+        if (image && href)
+            return `[![${alt}](${image})](${href})${label ? `\n\n[${label}](${href})` : ''}`;
+        if (image)
+            return `![${alt}](${image})`;
+        if (importedComponents.has(name))
+            return '';
+        return match;
+    });
+    return fencedCode.restore(body.replace(/\n{3,}/g, '\n\n'));
+}
+function unmappedConstructs(body) {
+    const known = new Set(['Note', 'Tip', 'Warning', 'Info', 'Check', 'Danger', 'Callout', 'Steps', 'Step', 'Tabs', 'Tab', 'Accordion', 'AccordionItem', 'AccordionGroup', 'CodeGroup', 'CodeTab', 'Card', 'CardGroup', 'Frame', 'Image', 'Video', 'Embed', 'File', 'Columns', 'Column', 'Expandable', 'Mermaid', 'Math', 'Terminal', 'Badge', 'Icon', 'Update', 'ApiEndpoint', 'ParameterTable', 'Param', 'ParamField', 'Response', 'ResponseExample', 'ResponseField', 'RequestExample', 'Excalidraw', 'ColorPalette', 'ColorGroup', 'ColorSwatch', 'SidePanel', 'PromptCard', 'Tile', 'Tooltip', 'FileTree', 'Folder', 'FileNode', 'ViewSwitcher', 'ViewPane', 'Audience']);
+    const found = new Set();
+    // Component-like strings inside code examples (TypeScript generics, shell
+    // placeholders, JSX tutorials) are examples, not unmapped page components.
+    let inFence = false;
+    const visible = body.split('\n').map((line) => {
+        if (/^\s*(```|~~~)/.test(line)) {
+            inFence = !inFence;
+            return '';
+        }
+        // Inline-code spans cannot cross a Markdown line. Removing them before
+        // joining prevents an unmatched backtick from swallowing multiple lines
+        // and exposing JSX or generic types from otherwise fenced examples.
+        return inFence ? '' : line.replace(/`+[^`]*`+/g, '');
+    }).join('\n')
+        .replace(/<!--[^]*?-->/g, '');
+    for (const match of visible.matchAll(/(?<!\\)<([A-Z][A-Za-z0-9_.]+)/g))
+        if (!known.has(match[1]))
+            found.add(`<${match[1]}>`);
+    // Lowercase tags are HTML, SVG, or presentation-layer custom elements. They
+    // may degrade visually, but their presence must never stop an otherwise safe
+    // repository transformation. Capitalized MDX components remain blocking in
+    // strict mode because a self-closing component can carry all semantic content
+    // in its props and silently dropping it would lose documentation.
+    for (const match of visible.matchAll(/\{%\s*([a-z-]+)/gi))
+        found.add(`{% ${match[1]} %}`);
+    return [...found];
+}
+function replaceVariables(body, variables) {
+    return body.replace(/\{([A-Za-z_][A-Za-z0-9_.-]*)}/g, (match, key) => {
+        const value = key.split('.').reduce((current, part) => asRecord(current)[part], variables);
+        return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? String(value) : match;
+    });
+}
+function frontmatterValue(head, key) {
+    const match = new RegExp(`^${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:\\s*(.*?)\\s*$`, 'm').exec(head);
+    return match?.[1]?.trim();
+}
+function inferredDescription(body) {
+    const prose = body
+        .replace(/```[\s\S]*?```|~~~[\s\S]*?~~~/g, '')
+        .replace(/<!--[^]*?-->/g, '')
+        .replace(/!\[[^\]]*]\([^)]*\)/g, '')
+        .replace(/\[([^\]]+)]\([^)]*\)/g, '$1')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/[*_`]/g, '');
+    const paragraph = prose
+        .split(/\n\s*\n/)
+        .map((value) => value.replace(/^\s*(?:[-+] |\d+\. )/gm, '').replace(/\s+/g, ' ').trim())
+        .find((value) => value.length >= 20 && !value.startsWith('|'));
+    if (!paragraph)
+        return undefined;
+    if (paragraph.length <= 200)
+        return paragraph;
+    const shortened = paragraph.slice(0, 197).replace(/\s+\S*$/, '').trimEnd();
+    return `${shortened}…`;
+}
+function normalizeMintlifyPage(head, body) {
+    let normalizedBody = body
+        // Mintlify treats its root `images/` directory as site-absolute even when
+        // an authored Markdown image omits the slash.
+        .replace(/(!\[[^\]]*]\()images\//g, '$1/images/');
+    if (frontmatterValue(head, 'title')) {
+        // The Doxbrix reader renders the frontmatter title as the one page H1.
+        normalizedBody = normalizedBody.replace(/^#\s+/gm, '## ');
+    }
+    if (!head || frontmatterValue(head, 'description'))
+        return { head, body: normalizedBody };
+    const description = inferredDescription(normalizedBody);
+    if (!description)
+        return { head, body: normalizedBody };
+    const closing = head.lastIndexOf('---');
+    return closing < 3
+        ? { head, body: normalizedBody }
+        : { head: `${head.slice(0, closing)}description: ${JSON.stringify(description)}\n${head.slice(closing)}`, body: normalizedBody };
+}
+function inferManifest(paths, name = 'Documentation') {
+    const root = [];
+    const groups = new Map();
+    for (const path of paths.filter(likelyPage).sort()) {
+        const file = stripPageExtension(path);
+        const [top] = file.split('/');
+        if (!top || !file.includes('/'))
+            root.push({ type: 'page', file });
+        else {
+            if (!groups.has(top))
+                groups.set(top, []);
+            groups.get(top).push({ type: 'page', file });
+        }
+    }
+    for (const [folder, items] of groups)
+        root.push({ type: 'group', label: folder.replace(/[-_]+/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()), items });
+    return { version: 1, name, spaces: [{ name, slug: 'docs', nav: root }] };
+}
+function parseGitbookSummary(summary) {
+    const nav = [];
+    const stack = [{ indent: -1, items: nav }];
+    for (const raw of summary.split('\n')) {
+        const heading = /^#{1,6}\s+(.+)$/.exec(raw.trim());
+        if (heading) {
+            nav.push({ type: 'label', text: heading[1].trim() });
+            continue;
+        }
+        const bullet = /^(\s*)[-*+]\s+\[([^\]]+)]\(([^)]+)\)/.exec(raw);
+        if (!bullet)
+            continue;
+        const indent = bullet[1].replace(/\t/g, '  ').length;
+        while (stack.length > 1 && stack.at(-1).indent >= indent)
+            stack.pop();
+        const node = { type: 'page', file: stripPageExtension(normalizePath(bullet[3])), title: bullet[2].trim() };
+        stack.at(-1).items.push(node);
+    }
+    return { version: 1, name: 'Documentation', spaces: [{ name: 'Documentation', slug: 'docs', nav }] };
+}
+function transformGitbook(body) {
+    return body
+        .replace(/\{%\s*hint\s+style=["']?(warning|danger|info|success)["']?\s*%}([\s\S]*?)\{%\s*endhint\s*%}/gi, (_m, style, inner) => `<${style === 'danger' ? 'Danger' : style === 'warning' ? 'Warning' : style === 'success' ? 'Check' : 'Info'}>\n${inner.trim()}\n</${style === 'danger' ? 'Danger' : style === 'warning' ? 'Warning' : style === 'success' ? 'Check' : 'Info'}>`)
+        .replace(/<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi, (_m, title, inner) => `<Expandable title="${title.trim()}">\n${inner.trim()}\n</Expandable>`);
+}
+export function convertSourceTree(inputFiles) {
+    const files = new Map(inputFiles.map((file) => [normalizePath(file.path), file.content]));
+    const paths = [...files.keys()];
+    const pagePaths = paths.filter(isPageFile);
+    // Prefer the repository-root config. A prior local migration may have left a
+    // nested Doxbrix docs.json; choosing that would incorrectly detect the source
+    // as native on the next import.
+    const configPath = paths
+        .filter((path) => CONFIG_NAMES.includes(basename(path).toLowerCase()))
+        .sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b))[0];
+    let dialect = 'generic';
+    let manifest;
+    let redirects = [];
+    let transform = (body) => body;
+    let variables = {};
+    if (configPath) {
+        let raw = {};
+        try {
+            raw = asRecord(resolveJsonRefs(JSON.parse(files.get(configPath)), configPath, files));
+        }
+        catch {
+            raw = {};
+        }
+        if (raw.navigation && !Array.isArray(raw.spaces)) {
+            dialect = 'mintlify';
+            const name = asString(raw.name) ?? 'Documentation';
+            const openapiSources = [...new Set([
+                    ...parseOpenApiSources(raw),
+                    ...navigationOpenApiSources(raw.navigation),
+                ])];
+            const apiBaseUrl = parseApiBaseUrl(raw);
+            const collected = collectSpaces(raw.navigation, name);
+            manifest = {
+                version: 1,
+                name,
+                ...(asString(raw.description) ? { description: asString(raw.description) } : {}),
+                ...(openapiSources.length ? { openapiSources } : {}),
+                ...(apiBaseUrl ? { apiBaseUrl } : {}),
+                spaces: collected.spaces,
+                ...(collected.versions.length ? { versions: collected.versions } : {}),
+                theme: parseTheme(raw),
+                ...(parseSiteChrome(raw) ? { site: parseSiteChrome(raw) } : {}),
+            };
+            redirects = parseRedirects(raw.redirects);
+            variables = asRecord(raw.variables);
+            transform = transformMintlifyMdx;
+            preserveUnlistedPages(manifest, pagePaths);
+        }
+        else if (Array.isArray(raw.spaces)) {
+            dialect = 'native';
+            manifest = raw;
+        }
+        else {
+            manifest = inferManifest(pagePaths);
+        }
+    }
+    else {
+        const summaryPath = paths.find((path) => basename(path).toLowerCase() === 'summary.md');
+        if (summaryPath) {
+            dialect = 'gitbook';
+            manifest = parseGitbookSummary(files.get(summaryPath));
+            transform = transformGitbook;
+            preserveUnlistedPages(manifest, pagePaths.filter((path) => path !== summaryPath));
+        }
+        else {
+            manifest = inferManifest(pagePaths);
+        }
+    }
+    const unmapped = new Set();
+    const forceCurrentColorCardIcons = dialect === 'mintlify' && sourceForcesCurrentColorCardIcons(files);
+    let pages = pagePaths
+        .filter((path) => basename(path).toLowerCase() !== 'summary.md')
+        .filter(likelyPage)
+        .map((path) => {
+        const { head, body } = splitFrontmatter(files.get(path));
+        const expanded = dialect === 'mintlify' ? inlineMdxSnippets(body, path, files) : body;
+        const prepared = forceCurrentColorCardIcons ? markForcedCurrentColorCardIcons(expanded) : expanded;
+        const dialectTransformed = transform(replaceVariables(prepared, variables));
+        // Raw HTML and JSX are supported by several documentation systems, not
+        // only Mintlify. Normalize their safe structural subset for every source
+        // dialect so presentational elements such as <button> cannot block a
+        // strict import or leak into the destination as reader-visible markup.
+        // The normalizer protects fenced and inline code before touching tags.
+        const transformed = dialect === 'mintlify'
+            ? dialectTransformed
+            : transformPortableHtml(dialectTransformed);
+        const normalized = dialect === 'mintlify' ? normalizeMintlifyPage(head, transformed) : { head, body: transformed };
+        const markdown = `${normalized.head}${normalized.body}`;
+        for (const item of unmappedConstructs(markdown))
+            unmapped.add(item);
+        return { path, markdown };
+    });
+    if (dialect === 'mintlify') {
+        pages = materializeMintlifyOpenApiPages({
+            pages,
+            files: inputFiles,
+            configuredSources: manifest.openapiSources,
+            fallbackBaseUrl: manifest.apiBaseUrl,
+        });
+    }
+    return { dialect, manifest, pages, redirects, unmapped: [...unmapped].sort() };
+}
+/** Materialize navigation-level OpenAPI markers into generated endpoint pages.
+ * Local documents are read from the source tree; callers may provide a guarded
+ * loader for public URL sources. Unavailable specs remain as API markers and
+ * are reported without dropping their navigation entry. */
+export async function materializeMintlifyOpenApiNavigation(params) {
+    if (params.result.dialect !== 'mintlify')
+        return { result: params.result, warnings: [] };
+    const files = new Map(params.files.map((file) => [normalizePath(file.path), file.content]));
+    const pages = [...params.result.pages];
+    const usedFiles = new Set(pages.map((page) => stripPageExtension(normalizePath(page.path))));
+    const addedPages = new Set(usedFiles);
+    const warnings = [];
+    const loaded = new Map();
+    const materializedSpecs = new Map();
+    const load = (source) => {
+        const cached = loaded.get(source);
+        if (cached)
+            return cached;
+        const pending = /^https?:\/\//i.test(source)
+            ? params.loadRemote?.(source) ?? Promise.resolve(null)
+            : Promise.resolve(files.get(normalizePath(source)) ?? null);
+        loaded.set(source, pending);
+        return pending;
+    };
+    const operationRef = (value) => {
+        const match = /^(?:(\S+)\s+)?(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/\S*)$/i.exec(value.trim());
+        if (!match)
+            return null;
+        return {
+            ...(match[1] ? { source: normalizeSpecSource(match[1]) } : {}),
+            operation: `${match[2].toUpperCase()} ${match[3]}`,
+        };
+    };
+    const containsOperationRef = (nodes) => nodes.some((node) => (node.type === 'page' && Boolean(operationRef(node.file)))
+        || (node.type === 'group' && containsOperationRef(node.items)));
+    const materialize = (node) => {
+        const key = `${node.spec}\0${node.title}`;
+        const cached = materializedSpecs.get(key);
+        if (cached)
+            return cached;
+        const pending = (async () => {
+            let sourceText = null;
+            try {
+                sourceText = await load(node.spec);
+            }
+            catch (error) {
+                warnings.push(`Could not load OpenAPI spec ${node.spec}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (!sourceText) {
+                if (!warnings.some((warning) => warning.includes(node.spec)))
+                    warnings.push(`Could not load OpenAPI spec ${node.spec}.`);
+                return null;
+            }
+            const result = materializeOpenApiNavigationDocument({
+                text: sourceText,
+                title: node.title,
+                usedFiles,
+                fallbackBaseUrl: params.result.manifest.apiBaseUrl,
+            });
+            if (!result)
+                warnings.push(`OpenAPI spec ${node.spec} did not contain any importable operations.`);
+            return result;
+        })();
+        materializedSpecs.set(key, pending);
+        return pending;
+    };
+    const expand = async (nodes) => {
+        // Mintlify permits an OpenAPI source beside authored navigation groups whose
+        // page strings are operation selectors (for example, "GET /v1/apps"). Those
+        // selectors are not file paths. Resolve them against the sibling document
+        // while preserving the source's grouping and order.
+        const localApis = nodes.filter((node) => node.type === 'api');
+        if (localApis.length === 1 && containsOperationRef(nodes)) {
+            const api = localApis[0];
+            const document = await materialize(api);
+            const itemsByOperation = new Map(document?.groups.flatMap((group) => group.items).map((item) => [item.operation, item]) ?? []);
+            const pagesByFile = new Map(document?.pages.map((page) => [stripPageExtension(normalizePath(page.path)), page]) ?? []);
+            const missing = new Set();
+            const rewrite = async (entries) => {
+                const rewritten = [];
+                for (const entry of entries) {
+                    if (entry.type === 'group') {
+                        rewritten.push({ ...entry, items: await rewrite(entry.items) });
+                        continue;
+                    }
+                    if (entry === api) {
+                        // The marker supplied the document for the explicit operation list;
+                        // retaining it would append a duplicate, fully generated API tree.
+                        if (!document)
+                            rewritten.push(entry);
+                        continue;
+                    }
+                    if (entry.type === 'page') {
+                        const ref = operationRef(entry.file);
+                        if (ref) {
+                            const belongsToApi = !ref.source || ref.source === api.spec;
+                            const item = belongsToApi ? itemsByOperation.get(ref.operation) : undefined;
+                            const generatedPage = item ? pagesByFile.get(item.file) : undefined;
+                            if (item && generatedPage) {
+                                if (!addedPages.has(item.file)) {
+                                    pages.push(generatedPage);
+                                    addedPages.add(item.file);
+                                }
+                                rewritten.push({ ...entry, file: item.file, title: entry.title ?? item.title });
+                            }
+                            else {
+                                missing.add(entry.file);
+                                // Never serialize an HTTP operation selector as a page path. In
+                                // non-strict imports this label plus the unresolved API marker is
+                                // a safe, lintable fallback; strict imports stop on the warning.
+                                rewritten.push({ type: 'label', text: entry.title ?? ref.operation });
+                            }
+                            continue;
+                        }
+                    }
+                    if (entry.type === 'api')
+                        rewritten.push(...await expand([entry]));
+                    else
+                        rewritten.push(entry);
+                }
+                return rewritten;
+            };
+            const rewritten = await rewrite(nodes);
+            if (document && missing.size) {
+                warnings.push(`OpenAPI spec ${api.spec} did not contain ${missing.size} referenced operation(s): ${[...missing].slice(0, 5).join(', ')}${missing.size > 5 ? '…' : ''}`);
+            }
+            return rewritten;
+        }
+        const out = [];
+        for (const node of nodes) {
+            if (node.type === 'group') {
+                out.push({ ...node, items: await expand(node.items) });
+                continue;
+            }
+            if (node.type !== 'api') {
+                out.push(node);
+                continue;
+            }
+            const materialized = await materialize(node);
+            if (!materialized) {
+                out.push(node);
+                continue;
+            }
+            for (const page of materialized.pages) {
+                const file = stripPageExtension(normalizePath(page.path));
+                if (!addedPages.has(file)) {
+                    pages.push(page);
+                    addedPages.add(file);
+                }
+            }
+            out.push(...materialized.groups.map((group) => ({
+                type: 'group',
+                label: group.label,
+                items: group.items.map((item) => ({ type: 'page', file: item.file, title: item.title })),
+            })));
+        }
+        return out;
+    };
+    const spaces = [];
+    for (const space of params.result.manifest.spaces) {
+        spaces.push({ ...space, nav: await expand(space.nav) });
+    }
+    return {
+        result: {
+            ...params.result,
+            manifest: { ...params.result.manifest, spaces },
+            pages,
+        },
+        warnings,
+    };
+}