@dogsbay/format-mdx 0.2.0-beta.15 → 0.2.0-beta.151

package/dist/extract.js

@@ -0,0 +1,151 @@
+/**
+ * Layer C `extract` — map a component whose DATA lives in a separate
+ * TS/TSX file (`<Features />` backed by `const grid = […]`;
+ * `<CommunityAdaptersTable />` backed by `export const communityAdapters
+ * = […]` in lib/) onto real content nodes.
+ *
+ * Static parsing only (the same balanced scanner as the sidebar
+ * extractor) — nothing is executed. Anything that doesn't scan preserves
+ * the component raw + ledgered (never guess).
+ *
+ * Config shape (per-docset `mdx.components`):
+ *
+ *   Features:
+ *     extract: { file: ../../components/docs/features.tsx, export: grid, as: cards }
+ *     selfClosing: true
+ */
+import { readFileSync } from "node:fs";
+import { captureConstLiteral, displayJsValue } from "./js-scan.js";
+import { parseJsArrayElements, parseJsObjectEntries } from "./fumadocs.js";
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function field(obj, ...keys) {
+    for (const key of keys) {
+        if (obj[key] !== undefined)
+            return displayJsValue(obj[key]);
+    }
+    return undefined;
+}
+/** Display form for a table cell; nested objects prefer name/title/url. */
+function cellValue(raw) {
+    const t = raw.trim();
+    if (t.startsWith("{")) {
+        const entries = parseJsObjectEntries(t);
+        if (entries) {
+            const o = Object.fromEntries(entries);
+            return field(o, "name", "title", "label", "url") ?? "";
+        }
+        return "";
+    }
+    if (t.startsWith("[")) {
+        const elements = parseJsArrayElements(t);
+        return elements ? elements.map(cellValue).join(", ") : "";
+    }
+    return displayJsValue(t);
+}
+function dataToCards(elements) {
+    const cards = [];
+    for (const element of elements) {
+        const entries = parseJsObjectEntries(element);
+        if (!entries)
+            return null;
+        const o = Object.fromEntries(entries);
+        const title = field(o, "title", "name", "label");
+        if (!title)
+            return null;
+        const props = { title };
+        const description = field(o, "description");
+        const href = field(o, "href", "url", "link");
+        if (description)
+            props.description = description;
+        if (href)
+            props.href = href;
+        cards.push({ type: "card", props });
+    }
+    return cards.length > 0 ? { type: "cards", children: cards } : null;
+}
+function dataToTable(elements) {
+    const rows = [];
+    for (const element of elements) {
+        const entries = parseJsObjectEntries(element);
+        if (!entries)
+            return null;
+        rows.push(Object.fromEntries(entries));
+    }
+    if (rows.length === 0)
+        return null;
+    // Columns: first row's key order; skip columns whose every value is
+    // empty after display conversion (avatars, icon components, …).
+    const candidates = Object.keys(rows[0]);
+    const columns = candidates.filter((c) => rows.some((r) => r[c] !== undefined && cellValue(r[c]) !== ""));
+    if (columns.length === 0)
+        return null;
+    const cell = (html, header = false) => ({
+        type: header ? "th" : "td",
+        children: [{ type: "prose", html }],
+    });
+    const humanize = (k) => k.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+    return {
+        type: "table",
+        children: [
+            {
+                type: "thead",
+                children: [{
+                        type: "tr",
+                        children: columns.map((c) => cell(escapeHtml(humanize(c)), true)),
+                    }],
+            },
+            {
+                type: "tbody",
+                children: rows.map((r) => ({
+                    type: "tr",
+                    children: columns.map((c) => {
+                        const value = r[c] !== undefined ? cellValue(r[c]) : "";
+                        // Linkify when a sibling `<col>Url` field exists (name/nameUrl)
+                        const urlSibling = r[`${c}Url`] ?? r[`${c}_url`];
+                        const text = escapeHtml(value);
+                        const html = urlSibling && value
+                            ? `<a href="${escapeHtml(displayJsValue(urlSibling))}">${text}</a>`
+                            : value.match(/^https?:\/\//)
+                                ? `<a href="${text}">${text}</a>`
+                                : text;
+                        return cell(html);
+                    }),
+                })),
+            },
+        ],
+    };
+}
+/**
+ * Build a ComponentMapping for an extract entry. `resolveFile` turns the
+ * spec's file into a readable path (source-relative or pre-rebased
+ * absolute). The data file is read lazily on first use and cached.
+ */
+export function makeExtractMapping(spec, resolveFile) {
+    let cached;
+    return {
+        type: spec.as,
+        container: false,
+        toNode: () => {
+            if (cached === undefined) {
+                cached = null;
+                try {
+                    const source = readFileSync(resolveFile(spec.file), "utf-8");
+                    const literal = captureConstLiteral(source, spec.export);
+                    const elements = literal ? parseJsArrayElements(literal) : null;
+                    if (elements) {
+                        cached = spec.as === "cards" ? dataToCards(elements) : dataToTable(elements);
+                    }
+                }
+                catch {
+                    cached = null;
+                }
+            }
+            if (!cached)
+                return "preserve";
+            // Fresh copy per use — consumers may mutate trees in post-processing.
+            return JSON.parse(JSON.stringify(cached));
+        },
+    };
+}

package/dist/fumadocs.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Fumadocs adapter — component mappings for the Fumadocs UI vocabulary
+ * (fumadocs.dev), plus built-in named handlers for common per-docset
+ * components layered on top of Fumadocs (e.g. better-auth's <APIMethod>).
+ *
+ * Generic builtins already cover Callout/Tabs/Steps/Cards/Accordion-style
+ * tags; this adapter adds the Fumadocs-specific pieces: TypeTable,
+ * Files/File/Folder trees, Accordions, <Link> unwrapping, Banner,
+ * ImageZoom.
+ *
+ * Everything here is static structural mapping — no JSX execution, ever.
+ */
+import type { ComponentMapping, MdxAdapter } from "./adapter.js";
+export declare const apiMethodMapping: ComponentMapping;
+/**
+ * Map a `<DatabaseTable name fields={…}>` schema table onto a real table.
+ * `fields` is an array of `{name, type, description, isPrimaryKey?,
+ * isForeignKey?, isOptional?, isUnique?, references?: {model, field}}` —
+ * either inline or (the common shape) a same-file `export const`
+ * identifier resolved via ctx.moduleData. Static parsing only; anything
+ * that doesn't scan is preserved raw + ledgered.
+ */
+export declare const databaseTableMapping: ComponentMapping;
+/**
+ * Map a component carrying an inline array of link resources
+ * (`resources={[{title, description, href, tags}]}` — better-auth's
+ * `<Resource>`) onto a cards grid. The array may also be a same-file
+ * `export const` identifier (resolved via ctx.moduleData).
+ */
+export declare const resourceCardsMapping: ComponentMapping;
+/** Built-in named handlers resolvable from declarative per-docset config. */
+export declare const MDX_BUILTIN_HANDLERS: Record<string, ComponentMapping>;
+/**
+ * Parse the entries of a JS object literal WITHOUT executing it: returns
+ * [key, rawValue] pairs at one nesting level. Values are raw source spans
+ * (balanced braces/brackets/parens, quote-aware with JSX-text tolerance —
+ * see js-scan.ts). Returns null on anything that doesn't scan as
+ * `key: value, …`.
+ */
+export declare function parseJsObjectEntries(src: string): [string, string][] | null;
+/**
+ * Split a JS array literal into top-level element spans (quote/bracket
+ * aware with JSX-text tolerance — see js-scan.ts; no execution).
+ * Returns null when the text doesn't scan.
+ */
+export declare function parseJsArrayElements(src: string): string[] | null;
+export declare const fumadocsAdapter: MdxAdapter;

package/dist/fumadocs.js

@@ -0,0 +1,471 @@
+/**
+ * Fumadocs adapter — component mappings for the Fumadocs UI vocabulary
+ * (fumadocs.dev), plus built-in named handlers for common per-docset
+ * components layered on top of Fumadocs (e.g. better-auth's <APIMethod>).
+ *
+ * Generic builtins already cover Callout/Tabs/Steps/Cards/Accordion-style
+ * tags; this adapter adds the Fumadocs-specific pieces: TypeTable,
+ * Files/File/Folder trees, Accordions, <Link> unwrapping, Banner,
+ * ImageZoom.
+ *
+ * Everything here is static structural mapping — no JSX execution, ever.
+ */
+import { inlineToDogsbayMd } from "@dogsbay/format-dogsbay-md";
+import { parseTsTypeBlock } from "./ts-type-block.js";
+import { splitTopLevel } from "./js-scan.js";
+// ── <APIMethod> → endpoint (built-in named handler) ──────
+/**
+ * Map an `<APIMethod path method …>` block onto dogsbay's `endpoint`
+ * vocabulary (the format-openapi node rendered by EndpointCard /
+ * ParameterTable / ApiLayout and serialized agent-readably by
+ * format-dogsbay-md's renderEndpoint).
+ *
+ * The TS type block inside the fence is parsed with parseTsTypeBlock —
+ * the same deterministic line-based grammar better-auth's own component
+ * applies client-side. The declared type name becomes `clientMethod`
+ * (the authClient call name); parsed properties become parameters /
+ * request-body rows. The original fence rides along as a code sample,
+ * so nothing is lost even when a nuance doesn't parse. Parse failure →
+ * "preserve" (mdx-raw + ledger) — never guess.
+ */
+/** "/two-factor/enable" → "twoFactor.enable" (kebab segments → camelCase). */
+function pathToDotNotation(path) {
+    return path
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => segment
+        .split("-")
+        .map((word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1))
+        .join(""))
+        .join(".");
+}
+/**
+ * Generate the client call-site example the same way better-auth's own
+ * component does at runtime:
+ *
+ *   const { data, error } = await authClient.twoFactor.enable({
+ *       password: "secure-password", // required
+ *   });
+ *
+ * Server-only props are skipped; GET-style calls wrap the props in a
+ * `query` object; nested object props open/close by path depth.
+ */
+function buildClientCallSample(path, props, opts) {
+    const indent = (n) => "    ".repeat(n);
+    const base = opts.asQuery ? 2 : 1;
+    let body = "";
+    const visible = props.filter((p) => !p.serverOnly);
+    for (let i = 0; i < visible.length; i++) {
+        const p = visible[i];
+        const comment = p.optional ? "" : " // required";
+        if (p.type === "Object") {
+            body += `${indent(p.path.length + base)}${p.name}: {${comment}\n`;
+        }
+        else {
+            const value = p.example ? `: ${p.example}` : "";
+            body += `${indent(p.path.length + base)}${p.name}${value},${comment}\n`;
+        }
+        // Close nested objects when depth decreases
+        const nextDepth = visible[i + 1]?.path.length ?? 0;
+        for (let d = p.path.length + (p.type === "Object" ? 1 : 0); d > nextDepth; d--) {
+            body += `${indent(d - 1 + base)}},\n`;
+        }
+    }
+    const args = body
+        ? opts.asQuery
+            ? `{\n${indent(1)}query: {\n${body}${indent(1)}},\n}`
+            : `{\n${body}}`
+        : "";
+    const assign = opts.noResult ? "" : `const ${opts.resultVariable} = `;
+    return `${assign}await authClient.${pathToDotNotation(path)}(${args});`;
+}
+export const apiMethodMapping = {
+    type: "endpoint",
+    container: true,
+    toNode: (attrs, innerSource) => {
+        const fence = innerSource.match(/```[^\n]*\n([\s\S]*?)\n[ \t]*```/);
+        if (!fence)
+            return "preserve";
+        const code = fence[1];
+        const parsed = parseTsTypeBlock(code);
+        if (!parsed)
+            return "preserve";
+        const method = (attrs.method || "GET").toUpperCase();
+        const path = attrs.path || "";
+        const notes = [];
+        if (attrs.note)
+            notes.push(attrs.note);
+        if (attrs.requireSession === "true")
+            notes.push("Requires an active session.");
+        if (attrs.requireBearerToken === "true")
+            notes.push("Requires a Bearer token.");
+        if (attrs.requireHeaders === "true") {
+            notes.push(attrs.headersComment || "Requires request headers to be passed.");
+        }
+        if (attrs.isServerOnly === "true")
+            notes.push("Server-side API only.");
+        if (attrs.isClientOnly === "true")
+            notes.push("Client SDK only.");
+        const asQuery = attrs.forceAsQuery === "true" ||
+            attrs.forceAsParam === "true" ||
+            (method === "GET" && attrs.forceAsBody !== "true");
+        const rows = parsed.props.map((p) => {
+            const flags = [];
+            if (p.serverOnly)
+                flags.push("server-only");
+            if (p.clientOnly)
+                flags.push("client-only");
+            const description = [p.description, flags.length ? `(${flags.join(", ")})` : ""]
+                .filter(Boolean)
+                .join(" ");
+            return {
+                name: [...p.path, p.name].join("."),
+                type: p.type,
+                required: !p.optional,
+                nullable: p.nullable || undefined,
+                description: description || undefined,
+                // Display form: `"secure-password"` (source text) → secure-password
+                example: p.example !== undefined ? displayValue(p.example) : undefined,
+            };
+        });
+        const props = {
+            method,
+            path,
+            clientMethod: parsed.name,
+        };
+        if (notes.length > 0)
+            props.description = notes.join(" ");
+        if (rows.length > 0) {
+            if (asQuery) {
+                props.parameters = rows.map((r) => ({
+                    name: r.name,
+                    in: "query",
+                    type: r.type,
+                    required: r.required,
+                    description: r.description,
+                }));
+            }
+            else {
+                props.requestBody = rows;
+            }
+        }
+        // Generated call-site example — the same snippet better-auth's own
+        // component builds at runtime (client SDK method from the path,
+        // example values, // required comments, query wrap for GET).
+        // Server-only endpoints have no client call; they keep just the
+        // type block.
+        const samples = [];
+        if (attrs.isServerOnly !== "true") {
+            samples.push({
+                language: "ts",
+                label: "Client example",
+                code: buildClientCallSample(path, parsed.props, {
+                    asQuery,
+                    resultVariable: attrs.resultVariable || "{ data, error }",
+                    noResult: attrs.noResult === "true",
+                }),
+            });
+        }
+        // Full-fidelity fallback channel: the original TS block rides along.
+        samples.push({ language: "ts", label: "Types", code });
+        props.codeSamples = samples;
+        return { type: "endpoint", props };
+    },
+};
+// ── <DatabaseTable> → table (built-in named handler) ─────
+/**
+ * Map a `<DatabaseTable name fields={…}>` schema table onto a real table.
+ * `fields` is an array of `{name, type, description, isPrimaryKey?,
+ * isForeignKey?, isOptional?, isUnique?, references?: {model, field}}` —
+ * either inline or (the common shape) a same-file `export const`
+ * identifier resolved via ctx.moduleData. Static parsing only; anything
+ * that doesn't scan is preserved raw + ledgered.
+ */
+export const databaseTableMapping = {
+    type: "table",
+    container: false,
+    toNode: (attrs, _inner, ctx) => {
+        const fieldsExpr = resolveAttrExpr(attrs.fields, ctx.moduleData);
+        if (!fieldsExpr)
+            return "preserve";
+        const elements = parseJsArrayElements(fieldsExpr);
+        if (!elements || elements.length === 0)
+            return "preserve";
+        const rows = [];
+        for (const element of elements) {
+            const entries = parseJsObjectEntries(element);
+            if (!entries)
+                return "preserve";
+            const f = Object.fromEntries(entries);
+            const name = f.name ? displayValue(f.name) : "";
+            const type = f.type ? displayValue(f.type) : "";
+            const description = f.description ? displayValue(f.description) : "";
+            const marks = [];
+            if (f.isPrimaryKey === "true")
+                marks.push("PK");
+            if (f.isForeignKey === "true")
+                marks.push("FK");
+            if (f.isUnique === "true")
+                marks.push("unique");
+            if (f.isOptional === "true")
+                marks.push("optional");
+            if (f.references) {
+                const ref = parseJsObjectEntries(f.references);
+                if (ref) {
+                    const r = Object.fromEntries(ref);
+                    if (r.model && r.field) {
+                        marks.push(`→ ${displayValue(r.model)}.${displayValue(r.field)}`);
+                    }
+                }
+            }
+            rows.push({
+                type: "tr",
+                children: [
+                    cell(`<code>${escapeHtml(name)}</code>`),
+                    cell(type ? `<code>${escapeHtml(type)}</code>` : ""),
+                    cell(escapeHtml(marks.join(", "))),
+                    cell(escapeHtml(description)),
+                ],
+            });
+        }
+        const node = {
+            type: "table",
+            children: [
+                {
+                    type: "thead",
+                    children: [{
+                            type: "tr",
+                            children: [cell("Field", true), cell("Type", true), cell("Key", true), cell("Description", true)],
+                        }],
+                },
+                { type: "tbody", children: rows },
+            ],
+        };
+        // A caption is inline Markdown; the type table's name is plain text
+        if (attrs.name)
+            node.props = { caption: inlineToDogsbayMd([{ type: "text", text: String(attrs.name) }]) };
+        return node;
+    },
+};
+// ── <Resource resources={[…]}> → cards (built-in named handler) ──
+/**
+ * Map a component carrying an inline array of link resources
+ * (`resources={[{title, description, href, tags}]}` — better-auth's
+ * `<Resource>`) onto a cards grid. The array may also be a same-file
+ * `export const` identifier (resolved via ctx.moduleData).
+ */
+export const resourceCardsMapping = {
+    type: "cards",
+    container: false,
+    toNode: (attrs, _inner, ctx) => {
+        const raw = resolveAttrExpr(attrs.resources, ctx.moduleData) ??
+            resolveAttrExpr(attrs.items, ctx.moduleData) ??
+            resolveAttrExpr(attrs.data, ctx.moduleData);
+        if (!raw)
+            return "preserve";
+        const elements = parseJsArrayElements(raw);
+        if (!elements || elements.length === 0)
+            return "preserve";
+        const cards = [];
+        for (const element of elements) {
+            const entries = parseJsObjectEntries(element);
+            if (!entries)
+                return "preserve";
+            const o = Object.fromEntries(entries);
+            const title = o.title ?? o.name;
+            if (!title)
+                return "preserve";
+            const props = { title: displayValue(title) };
+            if (o.description)
+                props.description = displayValue(o.description);
+            const href = o.href ?? o.url ?? o.link;
+            if (href)
+                props.href = displayValue(href);
+            cards.push({ type: "card", props });
+        }
+        return { type: "cards", children: cards };
+    },
+};
+/** Built-in named handlers resolvable from declarative per-docset config. */
+export const MDX_BUILTIN_HANDLERS = {
+    "api-method": apiMethodMapping,
+    "database-table": databaseTableMapping,
+    "resource-cards": resourceCardsMapping,
+};
+// ── <TypeTable> → table ──────────────────────────────────
+function cell(html, header = false) {
+    return { type: header ? "th" : "td", children: [{ type: "prose", html }] };
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+ * Parse the entries of a JS object literal WITHOUT executing it: returns
+ * [key, rawValue] pairs at one nesting level. Values are raw source spans
+ * (balanced braces/brackets/parens, quote-aware with JSX-text tolerance —
+ * see js-scan.ts). Returns null on anything that doesn't scan as
+ * `key: value, …`.
+ */
+export function parseJsObjectEntries(src) {
+    let s = src.trim();
+    if (s.startsWith("{") && s.endsWith("}"))
+        s = s.slice(1, -1);
+    const pieces = splitTopLevel(s);
+    if (!pieces)
+        return null;
+    const entries = [];
+    for (const piece of pieces) {
+        // key: identifier, "quoted", or 'quoted' — then `: value`
+        const m = /^\s*(?:([\w$-]+)|"([^"]*)"|'([^']*)')\s*:\s*([\s\S]*)$/.exec(piece);
+        if (!m)
+            return null;
+        const key = m[1] ?? m[2] ?? m[3];
+        entries.push([key, m[4].trim()]);
+    }
+    return entries;
+}
+/**
+ * Split a JS array literal into top-level element spans (quote/bracket
+ * aware with JSX-text tolerance — see js-scan.ts; no execution).
+ * Returns null when the text doesn't scan.
+ */
+export function parseJsArrayElements(src) {
+    const s = src.trim();
+    if (!s.startsWith("[") || !s.endsWith("]"))
+        return null;
+    return splitTopLevel(s.slice(1, -1));
+}
+/** Unquote a raw JS value for display; non-literals pass through as source. */
+function displayValue(raw) {
+    const t = raw.trim();
+    const m = t.match(/^(["'`])([\s\S]*)\1$/);
+    return m ? m[2] : t;
+}
+/**
+ * Resolve an attribute expression: a literal passes through; a bare
+ * identifier resolves against the file's `export const` capture
+ * (ctx.moduleData). Returns null when unresolvable.
+ */
+function resolveAttrExpr(expr, moduleData) {
+    if (!expr)
+        return null;
+    const t = expr.trim();
+    if (/^[\w$]+$/.test(t))
+        return moduleData[t] ?? null;
+    return t;
+}
+const typeTableMapping = {
+    type: "table",
+    container: false,
+    toNode: (attrs, _inner, ctx) => {
+        const obj = resolveAttrExpr(attrs.type, ctx.moduleData);
+        if (!obj)
+            return "preserve";
+        const entries = parseJsObjectEntries(obj);
+        if (!entries || entries.length === 0)
+            return "preserve";
+        const rows = [];
+        for (const [prop, rawValue] of entries) {
+            const fields = parseJsObjectEntries(rawValue);
+            if (!fields)
+                return "preserve";
+            const byKey = Object.fromEntries(fields);
+            const typeText = byKey.type ? displayValue(byKey.type) : "";
+            const descText = byKey.description ? displayValue(byKey.description) : "";
+            const defaultText = byKey.default ? displayValue(byKey.default) : "";
+            rows.push({
+                type: "tr",
+                children: [
+                    cell(`<code>${escapeHtml(prop)}</code>`),
+                    cell(typeText ? `<code>${escapeHtml(typeText)}</code>` : ""),
+                    cell(escapeHtml(descText)),
+                    cell(defaultText ? `<code>${escapeHtml(defaultText)}</code>` : ""),
+                ],
+            });
+        }
+        return {
+            type: "table",
+            children: [
+                {
+                    type: "thead",
+                    children: [{
+                            type: "tr",
+                            children: [cell("Prop", true), cell("Type", true), cell("Description", true), cell("Default", true)],
+                        }],
+                },
+                { type: "tbody", children: rows },
+            ],
+        };
+    },
+};
+// ── <Files>/<Folder>/<File> → nested list ────────────────
+const filesMapping = {
+    type: "unordered-list",
+    container: true,
+    toNode: (_attrs, innerSource, ctx) => {
+        const items = ctx.parseBlocks(innerSource).filter((n) => n.type === "list-item");
+        if (items.length === 0)
+            return "preserve";
+        return { type: "unordered-list", children: items };
+    },
+};
+const folderMapping = {
+    type: "list-item",
+    container: true,
+    toNode: (attrs, innerSource, ctx) => {
+        const name = attrs.name || attrs.title || "";
+        const items = ctx.parseBlocks(innerSource).filter((n) => n.type === "list-item");
+        const children = [
+            { type: "prose", html: `<strong>${escapeHtml(name)}/</strong>` },
+        ];
+        if (items.length > 0)
+            children.push({ type: "unordered-list", children: items });
+        return { type: "list-item", children };
+    },
+};
+const fileMapping = {
+    type: "list-item",
+    container: false,
+    toNode: (attrs) => ({
+        type: "list-item",
+        children: [{ type: "prose", html: `<code>${escapeHtml(attrs.name || attrs.title || "")}</code>` }],
+    }),
+};
+// ── The adapter ──────────────────────────────────────────
+export const fumadocsAdapter = {
+    name: "fumadocs",
+    components: {
+        // Fumadocs cards container is <Cards>, not <CardGroup>
+        Cards: { type: "cards", container: true },
+        // Fumadocs accordions — dogsbay has first-class accordion nodes
+        Accordions: { type: "accordion", container: true },
+        Accordion: {
+            type: "accordion-item",
+            container: true,
+            propsFromAttrs: (attrs) => ({ title: attrs.title || "", id: attrs.id }),
+        },
+        Banner: {
+            type: "callout",
+            container: true,
+            propsFromAttrs: (attrs) => ({
+                variant: attrs.variant === "rainbow" ? "info" : attrs.variant || "info",
+            }),
+        },
+        TypeTable: typeTableMapping,
+        Files: filesMapping,
+        Folder: folderMapping,
+        File: fileMapping,
+        ImageZoom: {
+            type: "image",
+            container: false,
+            propsFromAttrs: (attrs) => ({ src: attrs.src, alt: attrs.alt }),
+        },
+        // Auto-generated from source/OpenAPI at build time — nothing static to keep
+        AutoTypeTable: { type: "", container: false, strip: true },
+    },
+    selfClosingTags: ["TypeTable", "File", "ImageZoom", "AutoTypeTable"],
+    inlineTransforms: [
+        // <Link href="/x">text</Link> → [text](/x) — next/link passthrough
+        [/<Link\s+[^>]*?href=\{?["']([^"'}]+)["']\}?[^>]*?>([\s\S]*?)<\/Link>/g, "[$2]($1)"],
+    ],
+};

package/dist/index.d.ts

@@ -1,3 +1,12 @@
-export { mdxToTree, extractHeadings } from "./parse.js";
+export { mdxToTree, parseMdx, parseAttrs, extractHeadings, type MdxParseOptions, type MdxParseResult, } from "./parse.js";
+export { compileComponentConfig, type ComponentMapping, type ComponentHandlerContext, type ChildrenPolicy, type MdxAdapter, type MdxLedgerEntry, type MdxComponentConfig, type MdxPreprocessContext, } from "./adapter.js";
+export { fumadocsAdapter, apiMethodMapping, databaseTableMapping, resourceCardsMapping, MDX_BUILTIN_HANDLERS, parseJsObjectEntries, parseJsArrayElements, } from "./fumadocs.js";
+export { mintlifyAdapter } from "./mintlify.js";
+export { makeExtractMapping, type ExtractSpec } from "./extract.js";
+export { parseTsTypeBlock, type TsTypeBlock, type TsTypeProp, } from "./ts-type-block.js";
+export { buildFumadocsNav, detectFumadocsDir, type FumadocsNavOptions, } from "./meta-nav.js";
+export { buildMintlifyNav, detectMintlifyDir, type MintlifyNavOptions, mintlifyRedirects, } from "./mintlify-nav.js";
+export { mintlifyOpenApiSpecRef, buildMintlifyEndpointMap, openApiPageKey, } from "./mintlify-openapi.js";
+export { extractNavFromTsx, extractNavFromTsxFile, type NavExtractOptions, } from "./nav-extract.js";
+export { scanBalancedLiteral, splitTopLevel, isQuoteStart, captureConstLiteral, displayJsValue, } from "./js-scan.js";
 export type { TreeNode, InlineNode, ExportPage, NavItem } from "@dogsbay/types";
-//# sourceMappingURL=index.d.ts.map