@dogsbay/format-dogsbay-md 0.2.0-beta.0

package/dist/serialize.js

@@ -0,0 +1,712 @@
+import { inlineToDogsbayMd } from "./inline.js";
+import { renderAttrs, splitProps } from "./attributes.js";
+import { pickCodeFence, pickDirectiveFence, normalizeTrailingWhitespace, } from "./escape.js";
+import { resolveOptions } from "./types.js";
+import { renderBlockDirective } from "./directives.js";
+import { renderFrontmatter } from "./yaml.js";
+/**
+ * Serialize a tree of nodes to Dogsbay Markdown.
+ */
+export function treeToDogsbayMd(nodes, options) {
+    const ctx = resolveOptions(options);
+    const parts = nodes.map((node) => renderNode(node, ctx));
+    const body = normalizeTrailingWhitespace(parts.filter(Boolean).join("\n\n"));
+    if (options?.frontmatter && Object.keys(options.frontmatter).length > 0) {
+        return `${renderFrontmatter(options.frontmatter)}\n\n${body}`;
+    }
+    return body;
+}
+/**
+ * Serialize a single node (no trailing normalization).
+ * Exposed for chunker to emit one node per file.
+ */
+export function nodeToDogsbayMd(node, options) {
+    return renderNode(node, resolveOptions(options));
+}
+function renderNode(node, ctx) {
+    switch (node.type) {
+        case "heading":
+            return renderHeading(node);
+        case "paragraph":
+        case "prose":
+            return renderParagraph(node, ctx);
+        case "code":
+            return renderCode(node);
+        case "hr":
+        case "thematic-break":
+        case "separator":
+            return "---";
+        case "blockquote":
+            return renderBlockquote(node, ctx);
+        case "html":
+        case "html-container":
+            return node.html ?? "";
+        case "unordered-list":
+            return renderList(node, ctx, false);
+        case "ordered-list":
+            return renderList(node, ctx, true);
+        case "list-item":
+            // Standalone list item (rare; usually rendered via list container)
+            return renderInlineOrChildren(node, ctx);
+        case "callout":
+            return renderCallout(node, ctx);
+        case "details":
+            return renderDetails(node, ctx);
+        case "table":
+            return renderTable(node, ctx);
+        case "figure":
+            return renderFigure(node, ctx);
+        case "math-block":
+            return renderMathBlock(node);
+        case "image":
+            return renderBlockImage(node);
+        case "tabs":
+            return renderTabs(node, ctx);
+        case "steps":
+        case "substeps":
+            return renderSteps(node, ctx);
+        case "cards":
+            return renderCards(node, ctx);
+        case "grid":
+            return renderGrid(node, ctx);
+        case "grid-item":
+            return renderGridItem(node, ctx);
+        case "card":
+            return renderCard(node, ctx);
+        case "link-button":
+        case "button":
+            return renderButton(node, ctx);
+        case "deflist":
+            return renderDeflist(node, ctx);
+        case "accordion":
+            return renderAccordion(node, ctx);
+        case "accordion-item":
+            return renderAccordionItem(node, ctx);
+        case "link-card":
+            return renderLinkCard(node, ctx);
+        case "avatar":
+            return renderAvatar(node);
+        case "footnote-list":
+            return renderFootnoteList(node, ctx);
+        case "footnote-def":
+            return renderFootnoteDef(node);
+        case "endpoint":
+            return renderEndpoint(node);
+        default:
+            return renderUnknown(node, ctx);
+    }
+}
+/**
+ * Serialize an OpenAPI `endpoint` TreeNode (produced by
+ * @dogsbay/format-openapi) as agent-readable markdown. The HTML
+ * version uses ApiLayout + EndpointCard + friends; the markdown
+ * mirror collapses the same data into headings, tables, and code
+ * blocks so an agent fetching the `.md` URL still gets the full
+ * operation reference.
+ */
+function renderEndpoint(node) {
+    const props = (node.props ?? {});
+    const method = String(props.method ?? "get").toUpperCase();
+    const path = String(props.path ?? "");
+    const baseUrl = String(props.baseUrl ?? "");
+    const summary = props.summary;
+    const description = props.description;
+    const deprecated = props.deprecated === true;
+    const parameters = props.parameters ?? [];
+    const requestBody = props.requestBody ?? [];
+    const responses = props.responses ?? [];
+    const codeSamples = props.codeSamples ?? [];
+    const out = [];
+    out.push(`## ${method} ${path}`);
+    out.push("");
+    if (deprecated) {
+        out.push("> [!WARNING]");
+        out.push("> This endpoint is deprecated.");
+        out.push("");
+    }
+    if (baseUrl) {
+        out.push(`**Base URL**: \`${baseUrl}\``);
+        out.push("");
+    }
+    if (summary) {
+        out.push(summary);
+        out.push("");
+    }
+    if (description && description !== summary) {
+        out.push(description);
+        out.push("");
+    }
+    if (parameters.length > 0) {
+        out.push("### Parameters");
+        out.push("");
+        out.push("| Name | In | Type | Required | Description |");
+        out.push("| --- | --- | --- | --- | --- |");
+        for (const p of parameters) {
+            const desc = String(p.description ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+            out.push(`| \`${p.name}\` | ${p.in} | \`${p.type}\` | ${p.required ? "yes" : "no"} | ${desc} |`);
+        }
+        out.push("");
+    }
+    if (requestBody.length > 0) {
+        out.push("### Request body");
+        out.push("");
+        for (const p of requestBody) {
+            out.push(`- \`${p.name}\` (\`${p.type}\`)${p.required ? " — required" : ""}${p.description ? ` — ${p.description}` : ""}`);
+        }
+        out.push("");
+    }
+    if (responses.length > 0) {
+        out.push("### Responses");
+        out.push("");
+        for (const r of responses) {
+            const status = String(r.status ?? "");
+            const desc = String(r.description ?? "");
+            out.push(`- **${status}** — ${desc}`);
+        }
+        out.push("");
+    }
+    if (codeSamples.length > 0) {
+        out.push("### Code samples");
+        out.push("");
+        for (const s of codeSamples) {
+            const lang = String(s.language ?? "");
+            const label = s.label ? ` (${s.label})` : "";
+            out.push(`#### ${lang}${label}`);
+            out.push("");
+            out.push("```" + lang);
+            out.push(String(s.code ?? ""));
+            out.push("```");
+            out.push("");
+        }
+    }
+    return out.join("\n").trimEnd();
+}
+// ── Node renderers ──────────────────────────────────────────────────────
+function renderHeading(node) {
+    const level = Math.min(6, Math.max(1, Number(node.props?.level) || 1));
+    const hashes = "#".repeat(level);
+    const text = inlineToDogsbayMd(node.inline) || (node.html ?? "");
+    const attrs = splitProps(node.props, ["level", "slug"]);
+    // Include slug as id if provided and not auto-generated
+    const slug = node.props?.slug;
+    if (slug && !attrs.id) {
+        attrs.id = slug;
+    }
+    const attrStr = renderAttrs(attrs);
+    return attrStr ? `${hashes} ${text} ${attrStr}` : `${hashes} ${text}`;
+}
+function renderParagraph(node, ctx) {
+    if (node.inline && node.inline.length > 0) {
+        return inlineToDogsbayMd(node.inline);
+    }
+    // Nested children (e.g. Starlight produces paragraph > prose structure)
+    if (node.children && node.children.length > 0 && ctx) {
+        return node.children
+            .map((c) => renderNode(c, ctx))
+            .filter(Boolean)
+            .join("");
+    }
+    if (node.html) {
+        return node.html;
+    }
+    return "";
+}
+function renderCode(node) {
+    const content = (node.html ?? node.props?.code ?? "");
+    const lang = (node.props?.language ?? node.props?.lang ?? "");
+    const fence = pickCodeFence(content);
+    // Code-block attribute set: title + Expressive-Code-style decorations
+    // (highlights, ins, del, mark, collapse, lineNumbers, frame) plus standard
+    // passthrough (id, class). Emitted via {attrs} after the language so the
+    // parser reads them via markdown-it-attrs.
+    const attrKeys = [
+        "title", "highlights", "lineNumbers",
+        "ins", "del", "mark", "collapse", "frame",
+    ];
+    const attrParts = [];
+    if (node.props?.id)
+        attrParts.push(`#${node.props.id}`);
+    if (node.props?.class) {
+        const classes = String(node.props.class).split(/\s+/).filter(Boolean);
+        for (const c of classes)
+            attrParts.push(`.${c}`);
+    }
+    for (const key of attrKeys) {
+        const v = node.props?.[key];
+        if (v === undefined || v === null || v === false)
+            continue;
+        if (v === true) {
+            attrParts.push(key);
+            continue;
+        }
+        const s = String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        attrParts.push(`${key}="${s}"`);
+    }
+    let infoLine = lang;
+    if (attrParts.length > 0) {
+        infoLine = `${infoLine}${infoLine ? " " : ""}{${attrParts.join(" ")}}`;
+    }
+    return `${fence}${infoLine}\n${content.replace(/\n$/, "")}\n${fence}`;
+}
+function renderBlockquote(node, ctx) {
+    const inner = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    return inner
+        .split("\n")
+        .map((line) => (line ? `> ${line}` : ">"))
+        .join("\n");
+}
+function renderList(node, ctx, ordered) {
+    const items = node.children ?? [];
+    const start = ordered
+        ? (Number(node.props?.start) || 1)
+        : 0;
+    return items
+        .map((item, idx) => {
+        const marker = ordered ? `${start + idx}.` : "-";
+        const body = renderListItem(item, ctx);
+        const [first, ...rest] = body.split("\n");
+        const pad = " ".repeat(marker.length + 1);
+        const continuation = rest.map((l) => (l ? pad + l : l)).join("\n");
+        return `${marker} ${first}${continuation ? "\n" + continuation : ""}`;
+    })
+        .join("\n");
+}
+function renderListItem(node, ctx) {
+    // A list item may have inline content AND/OR block children.
+    // Inline content first (the "primary" text), then nested blocks.
+    const inline = inlineToDogsbayMd(node.inline);
+    const children = (node.children ?? []).map((c) => renderNode(c, ctx)).filter(Boolean);
+    if (inline && children.length === 0)
+        return inline;
+    if (!inline && children.length > 0)
+        return children.join("\n\n");
+    return [inline, ...children].filter(Boolean).join("\n\n");
+}
+function renderInlineOrChildren(node, ctx) {
+    const inline = inlineToDogsbayMd(node.inline);
+    const children = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    return [inline, children].filter(Boolean).join("\n\n");
+}
+// ── Callouts ─────────────────────────────────────────────────────────────
+const GITHUB_CALLOUT_TYPES = new Set([
+    "note",
+    "tip",
+    "important",
+    "warning",
+    "caution",
+]);
+function renderCallout(node, ctx) {
+    const type = String(node.props?.type ?? "note").toLowerCase();
+    const title = node.props?.title;
+    const body = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    // Use GitHub blockquote form for simple standard callouts (no custom title)
+    if (ctx.githubCallouts && !title && GITHUB_CALLOUT_TYPES.has(type)) {
+        const tag = `[!${type.toUpperCase()}]`;
+        return [tag, body]
+            .join("\n")
+            .split("\n")
+            .map((l) => (l ? `> ${l}` : ">"))
+            .join("\n");
+    }
+    // Directive form
+    return renderBlockDirective({
+        name: type,
+        props: node.props,
+        excludeProps: ["type"],
+        body,
+    }, ctx);
+}
+// ── Details / Collapsible ────────────────────────────────────────────────
+function renderDetails(node, ctx) {
+    const body = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    const props = { ...(node.props ?? {}) };
+    // Normalize summary→title
+    if (props.summary && !props.title) {
+        props.title = props.summary;
+        delete props.summary;
+    }
+    return renderBlockDirective({
+        name: "details",
+        props,
+        excludeProps: ["summary"],
+        body,
+    }, ctx);
+}
+// ── Tables ───────────────────────────────────────────────────────────────
+function renderTable(node, ctx) {
+    const children = node.children ?? [];
+    // Find thead/tbody/tr children. Table structure in TreeNode is either
+    // direct tr children or thead+tbody wrappers.
+    let headerRow;
+    const bodyRows = [];
+    for (const child of children) {
+        if (child.type === "thead") {
+            const rows = child.children ?? [];
+            if (rows.length > 0)
+                headerRow = rows[0];
+        }
+        else if (child.type === "tbody") {
+            bodyRows.push(...(child.children ?? []));
+        }
+        else if (child.type === "tr") {
+            if (!headerRow) {
+                headerRow = child;
+            }
+            else {
+                bodyRows.push(child);
+            }
+        }
+    }
+    if (!headerRow && bodyRows.length === 0)
+        return "";
+    const firstRow = headerRow ?? bodyRows.shift();
+    if (!firstRow)
+        return "";
+    const headerCells = (firstRow.children ?? []).map((c) => renderTableCell(c));
+    const separator = headerCells.map(() => "---");
+    const lines = [
+        "| " + headerCells.join(" | ") + " |",
+        "| " + separator.join(" | ") + " |",
+    ];
+    for (const row of bodyRows) {
+        const cells = (row.children ?? []).map((c) => renderTableCell(c));
+        lines.push("| " + cells.join(" | ") + " |");
+    }
+    return lines.join("\n");
+}
+function renderTableCell(node) {
+    // Table cells can carry inline directly (dogsbay-md shape) or via nested
+    // paragraph/prose children (Starlight shape). Collapse whatever we find to
+    // a single line — GFM tables don't allow block content in cells.
+    let text = inlineToDogsbayMd(node.inline);
+    if (!text && node.children) {
+        const parts = [];
+        for (const child of node.children) {
+            if (child.inline && child.inline.length > 0) {
+                parts.push(inlineToDogsbayMd(child.inline));
+            }
+            else if (child.html) {
+                parts.push(child.html);
+            }
+            else if (child.children) {
+                // Dive one more level (paragraph > prose > inline)
+                for (const grand of child.children) {
+                    if (grand.inline)
+                        parts.push(inlineToDogsbayMd(grand.inline));
+                    else if (grand.html)
+                        parts.push(grand.html);
+                }
+            }
+        }
+        text = parts.join(" ");
+    }
+    if (!text && node.html)
+        text = node.html;
+    return text.replace(/\|/g, "\\|").replace(/\n/g, " ").trim();
+}
+// ── Other blocks ─────────────────────────────────────────────────────────
+function renderFigure(node, ctx) {
+    const caption = node.props?.caption;
+    const body = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    if (!caption)
+        return body;
+    const fence = pickDirectiveFence(body);
+    return `${fence}figure${renderAttrs({ props: { caption } })}\n${body}\n${fence}`;
+}
+function renderMathBlock(node) {
+    const content = (node.html ?? node.props?.latex ?? "");
+    return `$$\n${content.replace(/\n$/, "")}\n$$`;
+}
+function renderBlockImage(node) {
+    const src = String(node.props?.src ?? "");
+    const alt = String(node.props?.alt ?? "");
+    const title = node.props?.title;
+    const titleStr = title ? ` "${title.replace(/"/g, '\\"')}"` : "";
+    const attrs = splitProps(node.props, ["src", "alt", "title"]);
+    const attrStr = renderAttrs(attrs);
+    const base = `![${alt}](${src}${titleStr})`;
+    return attrStr ? `${base}${attrStr}` : base;
+}
+// ── Tabs ─────────────────────────────────────────────────────────────────
+function renderTabs(node, ctx) {
+    const children = node.children ?? [];
+    // Two shapes: tab children (tab flavour) OR raw child nodes representing panels
+    const tabs = children.filter((c) => c.type === "tab");
+    if (tabs.length === 0) {
+        // No explicit tab children — fall back to wrapping whatever's inside
+        const body = children.map((c) => renderNode(c, ctx)).join("\n\n");
+        return renderBlockDirective({ name: "tabs", props: node.props, body }, ctx);
+    }
+    // Definition list form (canonical)
+    const items = tabs.map((tab) => renderTabItem(tab, ctx));
+    const body = items.join("\n\n");
+    return renderBlockDirective({ name: "tabs", props: node.props, body }, ctx);
+}
+function renderTabItem(node, ctx) {
+    const label = String(node.props?.label ?? node.props?.title ?? "Tab");
+    const content = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    // Definition list: term on one line, `:   body` with continuation indented
+    const [first, ...rest] = content.split("\n");
+    const pad = "    "; // 4 spaces to continue dd content
+    const restLines = rest.map((l) => (l ? pad + l : l)).join("\n");
+    return `${label}\n:   ${first}${restLines ? "\n" + restLines : ""}`;
+}
+// ── Steps ────────────────────────────────────────────────────────────────
+function renderSteps(node, ctx) {
+    const children = node.children ?? [];
+    const stepChildren = children.filter((c) => c.type === "step");
+    // Wrap steps in an ordered list. If children are already list-items, use as-is.
+    let list;
+    if (stepChildren.length > 0) {
+        list = {
+            type: "ordered-list",
+            children: stepChildren.map((step) => ({
+                type: "list-item",
+                inline: step.inline,
+                children: step.children,
+            })),
+        };
+    }
+    else {
+        // Fall back: direct children get wrapped as ordered list items
+        list = { type: "ordered-list", children };
+    }
+    const body = renderList(list, ctx, true);
+    return renderBlockDirective({ name: "steps", props: node.props, body }, ctx);
+}
+// ── Cards (grid of card nodes) ───────────────────────────────────────────
+function renderCards(node, ctx) {
+    const children = node.children ?? [];
+    const allCards = children.length > 0 && children.every((c) => c.type === "card");
+    if (!allCards) {
+        // Mixed content inside :::cards is probably a mis-tagged :::grid — warn
+        // via unknown-node heuristic: pass through children but with grid semantics.
+        // We keep the :::cards name since that's what the source said.
+        const body = children.map((c) => renderNode(c, ctx)).filter(Boolean).join("\n\n");
+        return renderBlockDirective({ name: "cards", props: node.props, body }, ctx);
+    }
+    // List form — each card as a bulleted list item with a bold link
+    const items = children.map((card) => renderCardListItem(card));
+    const body = items.join("\n\n");
+    return renderBlockDirective({ name: "cards", props: node.props, body }, ctx);
+}
+function renderCardListItem(node) {
+    const title = String(node.props?.title ?? "");
+    const href = node.props?.href;
+    // Description may live on props.description (our convention) or in the
+    // card's children (Starlight convention puts it as a paragraph child).
+    const description = node.props?.description
+        ?? extractCardDescriptionText(node);
+    const titleText = href ? `**[${title}](${href})**` : `**${title}**`;
+    const attrs = splitProps(node.props, ["title", "href", "description"]);
+    const attrStr = renderAttrs(attrs);
+    const header = attrStr ? `${titleText}${attrStr}` : titleText;
+    if (description) {
+        // Description may itself contain newlines; collapse to single paragraph
+        const cleaned = description.replace(/\s+/g, " ").trim();
+        return `- ${header}\n  ${cleaned}`;
+    }
+    return `- ${header}`;
+}
+/**
+ * Walk a card's children to find a description paragraph. Handles both
+ * direct `paragraph.inline` (our parser) and nested `paragraph > prose > inline`
+ * (Starlight importer) shapes.
+ */
+function extractCardDescriptionText(node) {
+    for (const child of node.children ?? []) {
+        if (child.type !== "paragraph")
+            continue;
+        if (child.inline && child.inline.length > 0) {
+            return inlineToDogsbayMd(child.inline);
+        }
+        if (child.children) {
+            for (const grand of child.children) {
+                if (grand.inline && grand.inline.length > 0) {
+                    return inlineToDogsbayMd(grand.inline);
+                }
+            }
+        }
+    }
+    return undefined;
+}
+// ── Grid (generic layout wrapper) ────────────────────────────────────────
+/**
+ * Generic CSS-grid container. Unlike :::cards, grid has no requirement that
+ * children be cards — any components can live inside. The grid directive just
+ * provides layout semantics (cols, rows, gap).
+ */
+function renderGrid(node, ctx) {
+    const body = (node.children ?? [])
+        .map((c) => renderNode(c, ctx))
+        .filter(Boolean)
+        .join("\n\n");
+    return renderBlockDirective({ name: "grid", props: node.props, body }, ctx);
+}
+/**
+ * Per-cell wrapper for column/row spanning inside a :::grid.
+ * Round-trips the span/rowSpan/start props.
+ *
+ * When the cell has no body content (only attrs), emits the leaf directive
+ * form `::grid-item{attrs}` — saves the writer from colons-scaling pain
+ * and reads more cleanly. Otherwise emits the container form
+ * `:::grid-item{attrs}\nbody\n:::`.
+ */
+function renderGridItem(node, ctx) {
+    const body = (node.children ?? [])
+        .map((c) => renderNode(c, ctx))
+        .filter(Boolean)
+        .join("\n\n");
+    if (!body) {
+        // Leaf form
+        const attrs = splitProps(node.props, []);
+        const attrStr = renderAttrs(attrs);
+        return `::grid-item${attrStr}`;
+    }
+    return renderBlockDirective({ name: "grid-item", props: node.props, body }, ctx);
+}
+// ── Single card ──────────────────────────────────────────────────────────
+function renderCard(node, ctx) {
+    // Single card may have an inline body or children
+    const inline = inlineToDogsbayMd(node.inline);
+    const childBody = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    const body = [inline, childBody].filter(Boolean).join("\n\n");
+    return renderBlockDirective({ name: "card", props: node.props, body }, ctx);
+}
+// ── Button ──────────────────────────────────────────────────────────────
+function renderButton(node, ctx) {
+    const label = inlineToDogsbayMd(node.inline);
+    const childBody = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    const body = label || childBody || String(node.props?.label ?? "");
+    return renderBlockDirective({ name: "button", props: node.props, body, excludeProps: ["label"] }, ctx);
+}
+// ── Definition list ──────────────────────────────────────────────────────
+function renderDeflist(node, ctx) {
+    const children = node.children ?? [];
+    const parts = [];
+    let currentTerm = null;
+    for (const child of children) {
+        if (child.type === "dt") {
+            currentTerm = inlineToDogsbayMd(child.inline) || (child.html ?? "");
+        }
+        else if (child.type === "dd" && currentTerm !== null) {
+            const def = (child.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+            const inline = inlineToDogsbayMd(child.inline);
+            const defBody = [inline, def].filter(Boolean).join("\n\n");
+            const [first, ...rest] = defBody.split("\n");
+            const pad = "    ";
+            const restIndented = rest.map((l) => (l ? pad + l : l)).join("\n");
+            parts.push(`${currentTerm}\n:   ${first}${restIndented ? "\n" + restIndented : ""}`);
+        }
+    }
+    return parts.join("\n\n");
+}
+// ── Accordion ────────────────────────────────────────────────────────────
+function renderAccordion(node, ctx) {
+    const items = (node.children ?? []).filter((c) => c.type === "accordion-item");
+    // Definition list form (canonical) — mirrors `:::tabs` layout.
+    if (items.length > 0) {
+        const blocks = items.map((item) => renderAccordionDefItem(item, ctx));
+        const body = blocks.join("\n\n");
+        return renderBlockDirective({ name: "accordion", props: node.props, body }, ctx);
+    }
+    // Fallback — children that aren't accordion-items get rendered through.
+    const body = (node.children ?? [])
+        .map((c) => renderNode(c, ctx))
+        .filter(Boolean)
+        .join("\n\n");
+    return renderBlockDirective({ name: "accordion", props: node.props, body }, ctx);
+}
+function renderAccordionDefItem(node, ctx) {
+    const label = String(node.props?.label ?? node.props?.title ?? "Item");
+    const content = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    const [first, ...rest] = content.split("\n");
+    const pad = "    ";
+    const restLines = rest.map((l) => (l ? pad + l : l)).join("\n");
+    return `${label}\n:   ${first}${restLines ? "\n" + restLines : ""}`;
+}
+function renderAccordionItem(node, ctx) {
+    // Standalone `:::accordion-item` form (rare — most accordion items live
+    // inside `:::accordion`). Round-trips via the directive shell.
+    const body = (node.children ?? []).map((c) => renderNode(c, ctx)).join("\n\n");
+    return renderBlockDirective({ name: "accordion-item", props: node.props, body }, ctx);
+}
+// ── Link card ────────────────────────────────────────────────────────────
+function renderLinkCard(node, ctx) {
+    // Description prop becomes the body when no rich children are present.
+    // Round-trips with the parser's `linkCardFromChildren` heuristic.
+    const description = node.props?.description;
+    const childBody = (node.children ?? [])
+        .map((c) => renderNode(c, ctx))
+        .filter(Boolean)
+        .join("\n\n");
+    const body = childBody || (description ?? "");
+    return renderBlockDirective({
+        name: "link-card",
+        props: node.props,
+        excludeProps: childBody ? [] : ["description"],
+        body,
+    }, ctx);
+}
+// ── Avatar ───────────────────────────────────────────────────────────────
+function renderAvatar(node) {
+    // Leaf form — `::avatar{src=... alt=... fallback=...}`.
+    const attrs = splitProps(node.props, []);
+    const attrStr = renderAttrs(attrs);
+    return `::avatar${attrStr}`;
+}
+// ── Footnote block ────────────────────────────────────────────────────────
+/**
+ * Render a footnote block — emit each child def as a `[^label]: …`
+ * line, separated by blank lines. The list itself has no syntax;
+ * its children carry the source-level constructs.
+ *
+ * The per-def `inline` content rendered via `inlineToDogsbayMd` may
+ * include `\n` line breaks (multi-paragraph defs, see parser). For
+ * the canonical single-line form, we collapse line breaks into
+ * indented continuation per CommonMark's link-reference-definition
+ * convention.
+ */
+function renderFootnoteList(node, ctx) {
+    const defs = (node.children ?? []).filter((c) => c.type === "footnote-def");
+    return defs.map((def) => renderFootnoteDef(def)).join("\n\n");
+}
+function renderFootnoteDef(node) {
+    // Prefer the explicit `label` prop emitted by the parser; fall
+    // back to deriving it from the `id` field (`fn-{label}`) for
+    // round-tripping TreeNodes constructed by hand or by other
+    // importers that don't set the label prop.
+    let label = node.props?.label;
+    if (!label) {
+        const id = node.props?.id ?? "";
+        label = id.startsWith("fn-") ? id.slice(3) : id;
+    }
+    const content = inlineToDogsbayMd(node.inline) || "";
+    // Multi-paragraph defs (line breaks in inline) get continuation
+    // lines indented by 4 spaces, matching CommonMark's continuation
+    // rule for link reference definitions / footnote bodies.
+    const [first, ...rest] = content.split("\n");
+    if (rest.length === 0) {
+        return `[^${label}]: ${first}`;
+    }
+    const indented = rest.map((l) => (l ? `    ${l}` : "")).join("\n");
+    return `[^${label}]: ${first}\n${indented}`;
+}
+function renderUnknown(node, ctx) {
+    switch (ctx.unknownNodes) {
+        case "skip":
+            return "";
+        case "comment":
+            return `<!-- unsupported: ${node.type} -->`;
+        case "html":
+        default:
+            if (node.html)
+                return node.html;
+            // Render children if we have any — better than nothing
+            if (node.children) {
+                return node.children.map((c) => renderNode(c, ctx)).join("\n\n");
+            }
+            return `<!-- unsupported: ${node.type} -->`;
+    }
+}
+//# sourceMappingURL=serialize.js.map