blodemd 0.0.13 → 0.0.15

package/packages/@repo/previewing/dist/markdown/agent-markdown.d.ts

@@ -0,0 +1,3 @@
+export declare const toAgentMarkdown: (source: string) => string;
+export declare const prepareLlmsFullContent: (source: string, origin: string, basePath: string) => string;
+//# sourceMappingURL=agent-markdown.d.ts.map

package/packages/@repo/previewing/dist/markdown/agent-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-markdown.d.ts","sourceRoot":"","sources":["../../src/markdown/agent-markdown.ts"],"names":[],"mappings":"AA4OA,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,MAMhD,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,UAAU,MAAM,WAMf,CAAC"}

package/packages/@repo/previewing/dist/markdown/agent-markdown.js

@@ -0,0 +1,176 @@
+import { NEWLINE_REGEX } from "../constants.js";
+import { absolutiseInternalLinks, sanitizePlaceholderUrls } from "./links.js";
+const FENCED_CODE_BLOCK_REGEX = /(^|\n)(`{3,}|~{3,})[^\n]*\n[\s\S]*?\n\2(?=\n|$)/g;
+const TYPE_TABLE_REGEX = /<TypeTable\s+type=\{\{([\s\S]*?)\}\}\s*\/>/g;
+const TYPE_TABLE_ROW_HEADER_REGEX = /^\s*(["']?[\w$./<>|{}\-\s]+["']?)\s*:\s*\{\s*$/;
+const STRING_FIELD_REGEX = (field) => new RegExp(`${field}:\\s*(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`, "s");
+const BOOLEAN_FIELD_REGEX = (field) => new RegExp(`${field}:\\s*(true|false)`, "s");
+const getStringProp = (attributes, name) => {
+    const match = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|\\{\\s*"([^"]*)"\\s*\\}|\\{\\s*'([^']*)'\\s*\\})`).exec(attributes);
+    return match?.slice(1).find((value) => typeof value === "string");
+};
+const protectFencedCodeBlocks = (source) => {
+    const blocks = [];
+    const text = source.replace(FENCED_CODE_BLOCK_REGEX, (match) => {
+        const placeholder = `\n@@BLODEMD_CODE_BLOCK_${blocks.length}@@\n`;
+        blocks.push(match.trim());
+        return placeholder;
+    });
+    return { blocks, text };
+};
+const restoreFencedCodeBlocks = (source, blocks) => {
+    let restored = source;
+    for (const [index, block] of blocks.entries()) {
+        // Function replacer: code may contain `$&`, `$1`, `` $` `` etc. which a
+        // string replacement would interpret as substitution patterns.
+        restored = restored.replace(`@@BLODEMD_CODE_BLOCK_${index}@@`, () => block);
+    }
+    return restored;
+};
+const INLINE_CODE_REGEX = /(?<![\\`])`([^`\n]+)`(?!`)/g;
+const protectInlineCode = (source) => {
+    const spans = [];
+    const text = source.replace(INLINE_CODE_REGEX, (match) => {
+        const placeholder = `@@BLODEMD_INLINE_CODE_${spans.length}@@`;
+        spans.push(match);
+        return placeholder;
+    });
+    return { spans, text };
+};
+const restoreInlineCode = (source, spans) => {
+    let restored = source;
+    for (const [index, span] of spans.entries()) {
+        restored = restored.replace(`@@BLODEMD_INLINE_CODE_${index}@@`, () => span);
+    }
+    return restored;
+};
+const compactMarkdown = (source) => source
+    .replaceAll(/[ \t]+\n/g, "\n")
+    .replaceAll(/\n{3,}/g, "\n\n")
+    .trim();
+const getFieldStringValue = (block, field) => {
+    const match = STRING_FIELD_REGEX(field).exec(block);
+    return match?.slice(1).find((value) => typeof value === "string");
+};
+const getFieldBooleanValue = (block, field) => {
+    const match = BOOLEAN_FIELD_REGEX(field).exec(block);
+    return match?.[1];
+};
+const renderTypeTable = (_match, body) => {
+    const rows = [];
+    const lines = body.split(NEWLINE_REGEX);
+    for (let index = 0; index < lines.length; index += 1) {
+        const header = TYPE_TABLE_ROW_HEADER_REGEX.exec(lines[index] ?? "");
+        if (!header) {
+            continue;
+        }
+        const name = (header[1] ?? "").replaceAll(/^["']|["']$/g, "").trim();
+        const blockLines = [];
+        index += 1;
+        while (index < lines.length) {
+            const line = lines[index] ?? "";
+            if (/^\s*\},?\s*$/.test(line)) {
+                break;
+            }
+            blockLines.push(line);
+            index += 1;
+        }
+        const block = blockLines.join("\n");
+        const type = getFieldStringValue(block, "type") ?? "";
+        const description = getFieldStringValue(block, "description") ?? "";
+        const required = getFieldBooleanValue(block, "required") ?? "";
+        const defaultValue = getFieldStringValue(block, "default") ?? "";
+        const meta = [
+            type ? `type: ${type}` : null,
+            required ? `required: ${required}` : null,
+            defaultValue ? `default: ${defaultValue}` : null,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        rows.push(`- \`${name}\`${meta ? ` (${meta})` : ""}: ${description}`);
+    }
+    return rows.length ? rows.join("\n") : "";
+};
+const transformMdxComponents = (source) => {
+    let output = source;
+    output = output.replaceAll(TYPE_TABLE_REGEX, renderTypeTable);
+    output = output.replaceAll(/<Installer\s+([^>]*)\/>/g, (_match, attributes) => {
+        const command = getStringProp(attributes, "command");
+        return command ? `\`\`\`bash\n${command}\n\`\`\`` : "";
+    });
+    output = output.replaceAll(/<Tree\.Folder\s+([^>]*)>/g, (_match, attributes) => {
+        const name = getStringProp(attributes, "name") ?? "folder";
+        return `- ${name}/`;
+    });
+    output = output.replaceAll(/<Tree\.File\s+([^>]*)\/>/g, (_match, attributes) => {
+        const name = getStringProp(attributes, "name") ?? "file";
+        return `- ${name}`;
+    });
+    output = output.replaceAll("</Tree.Folder>", "");
+    output = output.replaceAll(/<\/?Tree[^>]*>/g, "");
+    output = output.replaceAll(/<Frame(?=[\s>])\s*([^>]*)>([\s\S]*?)<\/Frame>/g, (_match, attributes, children) => {
+        const caption = getStringProp(attributes, "caption");
+        const hint = getStringProp(attributes, "hint");
+        return compactMarkdown([hint, children.trim(), caption ? `Caption: ${caption}` : null]
+            .filter(Boolean)
+            .join("\n\n"));
+    });
+    output = output.replaceAll(/<Callout(?=[\s>])\s*([^>]*)>([\s\S]*?)<\/Callout>/g, (_match, attributes, children) => {
+        const type = (getStringProp(attributes, "type") ?? "note").toUpperCase();
+        return `> [!${type}]\n${children
+            .trim()
+            .split(NEWLINE_REGEX)
+            .map((line) => `> ${line}`)
+            .join("\n")}`;
+    });
+    for (const [tag, type] of [
+        ["Note", "NOTE"],
+        ["Warning", "WARNING"],
+        ["Info", "INFO"],
+        ["Tip", "TIP"],
+        ["Check", "CHECK"],
+        ["Danger", "DANGER"],
+    ]) {
+        output = output.replaceAll(new RegExp(`<${tag}(?=[\\s>])\\s*[^>]*>([\\s\\S]*?)</${tag}>`, "g"), (_match, children) => `> [!${type}]\n${children
+            .trim()
+            .split(NEWLINE_REGEX)
+            .map((line) => `> ${line}`)
+            .join("\n")}`);
+    }
+    output = output.replaceAll(/<Accordion(?=[\s>])\s*([^>]*)>([\s\S]*?)<\/Accordion>/g, (_match, attributes, children) => {
+        const title = getStringProp(attributes, "title") ?? "Details";
+        return `### ${title}\n\n${children.trim()}`;
+    });
+    output = output.replaceAll(/<Tab\s+([^>]*)>([\s\S]*?)<\/Tab>/g, (_match, attributes, children) => {
+        const title = getStringProp(attributes, "title") ??
+            getStringProp(attributes, "label") ??
+            "Tab";
+        return `### ${title}\n\n${children.trim()}`;
+    });
+    output = output.replaceAll(/<Step\s+([^>]*)>([\s\S]*?)<\/Step>/g, (_match, attributes, children) => {
+        const title = getStringProp(attributes, "title") ?? "Step";
+        return `1. **${title}**\n\n${children.trim()}`;
+    });
+    output = output.replaceAll(/<Expandable(?=[\s>])\s*([^>]*)>([\s\S]*?)<\/Expandable>/g, (_match, attributes, children) => {
+        const title = getStringProp(attributes, "title") ?? "Details";
+        return `### ${title}\n\n${children.trim()}`;
+    });
+    output = output.replaceAll(/<Card(?=[\s>])\s*([^>]*)>([\s\S]*?)<\/Card>/g, (_match, attributes, children) => {
+        const title = getStringProp(attributes, "title");
+        const href = getStringProp(attributes, "href");
+        const heading = title
+            ? `### ${href ? `[${title}](${href})` : title}`
+            : "";
+        return compactMarkdown([heading, children.trim()].filter(Boolean).join("\n\n"));
+    });
+    output = output.replaceAll(/<\/?(?:Columns|Column|CodeGroup|Tabs|Steps|AccordionGroup|CardGroup)[^>]*>/g, "");
+    return compactMarkdown(output);
+};
+export const toAgentMarkdown = (source) => {
+    const { blocks, text: codeProtected } = protectFencedCodeBlocks(source);
+    const { spans, text: inlineProtected } = protectInlineCode(codeProtected);
+    const transformed = transformMdxComponents(inlineProtected);
+    const inlineRestored = restoreInlineCode(transformed, spans);
+    return compactMarkdown(restoreFencedCodeBlocks(inlineRestored, blocks));
+};
+export const prepareLlmsFullContent = (source, origin, basePath) => absolutiseInternalLinks(sanitizePlaceholderUrls(toAgentMarkdown(source)), origin, basePath);

package/packages/@repo/previewing/dist/markdown/format.d.ts

@@ -0,0 +1,8 @@
+export declare const parseFrontmatter: (source: string) => {
+    body: string;
+    frontmatter: any;
+};
+export declare const stripFrontmatter: (source: string) => string;
+export declare const formatMarkdownPage: (title: string, source: string, description?: string) => string;
+export declare const formatMarkdownPageSection: (title: string, url: string, source: string, description?: string) => string;
+//# sourceMappingURL=format.d.ts.map

package/packages/@repo/previewing/dist/markdown/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/markdown/format.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM;;;CAS9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,WACT,CAAC;AAiBvC,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,cAAc,MAAM,WASrB,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,OAAO,MAAM,EACb,KAAK,MAAM,EACX,QAAQ,MAAM,EACd,cAAc,MAAM,WASrB,CAAC"}

package/packages/@repo/previewing/dist/markdown/format.js

@@ -0,0 +1,43 @@
+import { slugify } from "@repo/common";
+import YAML from "yaml";
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+const LEADING_H1_REGEX = /^#\s+([^\r\n]+)(?:\r?\n(?:\r?\n)?)?/;
+export const parseFrontmatter = (source) => {
+    const match = FRONTMATTER_REGEX.exec(source);
+    if (!match) {
+        return { body: source, frontmatter: {} };
+    }
+    const raw = match[1] ?? "";
+    const data = YAML.parse(raw) ?? {};
+    const body = source.slice(match[0].length);
+    return { body, frontmatter: data };
+};
+export const stripFrontmatter = (source) => parseFrontmatter(source).body.trim();
+const stripMatchingLeadingH1 = (source, title) => {
+    const trimmed = source.trimStart();
+    const match = LEADING_H1_REGEX.exec(trimmed);
+    if (!match) {
+        return trimmed.trim();
+    }
+    const [headingLine = "", headingTitle = ""] = match;
+    if (slugify(headingTitle) !== slugify(title)) {
+        return trimmed.trim();
+    }
+    return trimmed.slice(headingLine.length).trim();
+};
+export const formatMarkdownPage = (title, source, description) => {
+    const content = stripMatchingLeadingH1(source, title);
+    const descriptionBlock = description ? `\n\n${description}` : "";
+    if (!content) {
+        return `# ${title}${descriptionBlock}`;
+    }
+    return `# ${title}${descriptionBlock}\n\n${content}`;
+};
+export const formatMarkdownPageSection = (title, url, source, description) => {
+    const content = stripMatchingLeadingH1(source, title);
+    const descriptionBlock = description ? `\n\n${description}` : "";
+    if (!content) {
+        return `# ${title} (${url})${descriptionBlock}`;
+    }
+    return `# ${title} (${url})${descriptionBlock}\n\n${content}`;
+};

package/packages/@repo/previewing/dist/markdown/links.d.ts

@@ -0,0 +1,3 @@
+export declare const sanitizePlaceholderUrls: (text: string) => string;
+export declare const absolutiseInternalLinks: (source: string, origin: string, basePath: string) => string;
+//# sourceMappingURL=links.d.ts.map

package/packages/@repo/previewing/dist/markdown/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/markdown/links.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,MAGe,CAAC;AAEvE,eAAO,MAAM,uBAAuB,GAClC,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,UAAU,MAAM,KACf,MAiBF,CAAC"}

package/packages/@repo/previewing/dist/markdown/links.js

@@ -0,0 +1,31 @@
+const PLACEHOLDER_URL_PATTERN = [
+    "https?://(?:[a-z0-9-]+\\.)*example\\.(?:com|org|net)\\b[^\\s)\\]\"'<>]*",
+    "https?://discord\\.gg/example\\b[^\\s)\\]\"'<>]*",
+    "https?://(?:[a-z0-9-]+\\.)+(?:test|invalid)(?:[/?#:][^\\s)\\]\"'<>]*)?",
+    "https?://localhost(?::\\d+)?[^\\s)\\]\"'<>]*",
+    "https?://(?:[a-z0-9-]+\\.)*your[-_]?domain\\.[a-z]+\\b[^\\s)\\]\"'<>]*",
+    "https?://acme\\.blode\\.md\\b[^\\s)\\]\"'<>]*",
+    "https?://github\\.com/example/[^\\s)\\]\"'<>]*",
+    "https?://(?:us|eu)\\.i\\.posthog\\.com\\b[^\\s)\\]\"'<>]*",
+].join("|");
+const PLACEHOLDER_URL_RE = new RegExp(PLACEHOLDER_URL_PATTERN, "gi");
+const PLACEHOLDER_MARKDOWN_LINK_RE = new RegExp(`\\[([^\\]]+)\\]\\((?:${PLACEHOLDER_URL_PATTERN})\\)`, "gi");
+const INTERNAL_MARKDOWN_LINK_RE = /(!?\[[^\]]+\])\((\/[^)\s]*)\)/g;
+const defangUrl = (value) => value.replace(/^https?:\/\//i, "");
+export const sanitizePlaceholderUrls = (text) => text
+    .replace(PLACEHOLDER_MARKDOWN_LINK_RE, "$1")
+    .replace(PLACEHOLDER_URL_RE, (match) => `\`${defangUrl(match)}\``);
+export const absolutiseInternalLinks = (source, origin, basePath) => {
+    const normalizedBase = basePath
+        ? `/${basePath}`.replaceAll(/\/+/g, "/").replace(/\/$/, "")
+        : "";
+    return source.replaceAll(INTERNAL_MARKDOWN_LINK_RE, (_match, label, linkPath) => {
+        const alreadyPrefixed = normalizedBase &&
+            (linkPath === normalizedBase ||
+                linkPath.startsWith(`${normalizedBase}/`));
+        const absolutePath = alreadyPrefixed
+            ? linkPath
+            : `${normalizedBase}${linkPath}`.replaceAll(/\/+/g, "/");
+        return `${label}(${origin}${absolutePath})`;
+    });
+};

package/packages/@repo/previewing/dist/openapi-pages.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionConfig, SiteConfig } from "@repo/models";
+import type { OpenApiOperation } from "@repo/prebuild";
+import type { ContentSource } from "./content-source.js";
+import type { UtilityPage } from "./types.js";
+export declare const formatOpenApiPageContent: (operation: OpenApiOperation) => string;
+export declare const buildUtilityOpenApiPages: (config: SiteConfig, collection: CollectionConfig | undefined, source: ContentSource) => Promise<UtilityPage[]>;
+//# sourceMappingURL=openapi-pages.d.ts.map

package/packages/@repo/previewing/dist/openapi-pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-pages.d.ts","sourceRoot":"","sources":["../src/openapi-pages.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAEhB,UAAU,EACX,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAwH9C,eAAO,MAAM,wBAAwB,GACnC,WAAW,gBAAgB,KAC1B,MA0BF,CAAC;AA6EF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,UAAU,EAClB,YAAY,gBAAgB,GAAG,SAAS,EACxC,QAAQ,aAAa,2BA0EtB,CAAC"}

package/packages/@repo/previewing/dist/openapi-pages.js

@@ -0,0 +1,200 @@
+import { ensureArray, normalizePath } from "@repo/common";
+import { extractOpenApiOperations, openApiIdentifier, openApiSlug, parseOpenApiSpec, } from "@repo/prebuild";
+import { getDocsNavigation } from "./config-loader.js";
+const getOpenApiSourceKey = (source) => `${source.source}::${source.directory ?? ""}::${(source.include ?? []).join("|")}`;
+const toOpenApiSourceObject = (value) => {
+    if (typeof value === "string") {
+        return { source: value };
+    }
+    return value;
+};
+const collectOpenApiSources = (collection) => {
+    const sources = [];
+    for (const item of ensureArray(collection?.openapi)) {
+        if (!item) {
+            continue;
+        }
+        sources.push(toOpenApiSourceObject(item));
+    }
+    const groups = collection?.navigation?.groups ?? [];
+    for (const group of groups) {
+        if (!group.openapi) {
+            continue;
+        }
+        sources.push(toOpenApiSourceObject(group.openapi));
+    }
+    const seen = new Set();
+    return sources.filter((source) => {
+        const key = getOpenApiSourceKey(source);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+};
+const getSchemaTypeLabel = (schema) => {
+    if (!schema || typeof schema !== "object") {
+        return "any";
+    }
+    const record = schema;
+    if (typeof record.$ref === "string") {
+        const last = record.$ref.split("/").pop();
+        return last ?? "object";
+    }
+    if (typeof record.type === "string") {
+        if (record.type === "array" && record.items) {
+            return `${getSchemaTypeLabel(record.items)}[]`;
+        }
+        return record.type;
+    }
+    if (Array.isArray(record.oneOf) || Array.isArray(record.anyOf)) {
+        const variants = (record.oneOf ?? record.anyOf);
+        return variants.map(getSchemaTypeLabel).join(" | ");
+    }
+    return "object";
+};
+const formatParameterLine = (parameter) => {
+    const name = String(parameter.name ?? "");
+    const location = parameter.in ? ` (${parameter.in})` : "";
+    const required = parameter.required ? "required" : "optional";
+    const type = getSchemaTypeLabel(parameter.schema);
+    const description = typeof parameter.description === "string" && parameter.description
+        ? ` - ${parameter.description.split("\n")[0]}`
+        : "";
+    return `- \`${name}\`${location}: ${type}, ${required}${description}`;
+};
+const formatRequestBody = (body) => {
+    const required = body.required ? "required" : "optional";
+    const content = body.content ?? {};
+    const mediaTypes = Object.keys(content);
+    if (mediaTypes.length === 0) {
+        return `${required} body`;
+    }
+    return mediaTypes
+        .map((mediaType) => {
+        const mediaEntry = content[mediaType];
+        const schemaLabel = getSchemaTypeLabel(mediaEntry?.schema);
+        return `- ${mediaType} (${required}): ${schemaLabel}`;
+    })
+        .join("\n");
+};
+const formatResponses = (responses) => Object.entries(responses)
+    .map(([status, value]) => {
+    const response = value ?? {};
+    const description = typeof response.description === "string" && response.description
+        ? response.description.split("\n")[0]
+        : "";
+    const content = response.content ?? {};
+    const mediaTypes = Object.keys(content);
+    const mediaSuffix = mediaTypes.length
+        ? ` [${mediaTypes.join(", ")}]`
+        : "";
+    return `- ${status}${mediaSuffix}${description ? ` - ${description}` : ""}`;
+})
+    .join("\n");
+export const formatOpenApiPageContent = (operation) => {
+    const parts = [`Method: ${operation.method}`, `Path: ${operation.path}`];
+    if (operation.description) {
+        parts.push(operation.description);
+    }
+    if (operation.tags.length) {
+        parts.push(`Tags: ${operation.tags.join(", ")}`);
+    }
+    if (operation.parameters.length) {
+        parts.push(`## Parameters\n\n${operation.parameters
+            .map(formatParameterLine)
+            .join("\n")}`);
+    }
+    if (operation.requestBody) {
+        parts.push(`## Request body\n\n${formatRequestBody(operation.requestBody)}`);
+    }
+    if (operation.responses) {
+        parts.push(`## Responses\n\n${formatResponses(operation.responses)}`);
+    }
+    return parts.join("\n\n");
+};
+const getGroupedOpenApiSourceKey = (source) => getOpenApiSourceKey(toOpenApiSourceObject(source));
+const collectUtilityOpenApiPages = (pagesByIdentifier, pagesBySource, operations, directory, openApiSource, slugPrefix) => {
+    const sourceKey = getOpenApiSourceKey(openApiSource);
+    const includeIdentifiers = openApiSource.include?.length
+        ? new Set(openApiSource.include)
+        : null;
+    for (const operation of operations) {
+        const identifier = openApiIdentifier(operation.method, operation.path);
+        if (includeIdentifiers && !includeIdentifiers.has(identifier)) {
+            continue;
+        }
+        const baseSlug = normalizePath(openApiSlug(operation.method, operation.path, directory));
+        const slug = slugPrefix
+            ? normalizePath(`${slugPrefix}/${baseSlug}`)
+            : baseSlug;
+        const page = {
+            content: formatOpenApiPageContent(operation),
+            description: operation.description,
+            identifier,
+            slug,
+            sourceKey,
+            title: operation.summary ?? identifier,
+        };
+        pagesByIdentifier.set(identifier, page);
+        if (!pagesBySource.has(sourceKey)) {
+            pagesBySource.set(sourceKey, []);
+        }
+        pagesBySource.get(sourceKey)?.push(page);
+    }
+};
+const addUtilityPagesFromSourceKey = (pages, pagesBySource, sourceKey) => {
+    for (const page of pagesBySource.get(sourceKey) ?? []) {
+        pages.set(page.slug, page);
+    }
+};
+const addReferencedUtilityPages = (pages, pagesByIdentifier, pageReferences, hiddenPages, groupHidden = false) => {
+    for (const pageReference of pageReferences ?? []) {
+        if (groupHidden || hiddenPages.has(pageReference)) {
+            continue;
+        }
+        const page = pagesByIdentifier.get(pageReference);
+        if (page) {
+            pages.set(page.slug, page);
+        }
+    }
+};
+export const buildUtilityOpenApiPages = async (config, collection, source) => {
+    if (!collection || collection.type !== "docs") {
+        return [];
+    }
+    const docsNavigation = getDocsNavigation(config);
+    const hiddenPages = new Set(docsNavigation?.hidden);
+    const slugPrefix = normalizePath(collection.slugPrefix ?? "");
+    const byIdentifier = new Map();
+    const bySource = new Map();
+    const pages = new Map();
+    const sources = collectOpenApiSources(collection);
+    const resolved = await Promise.all(sources.map(async (item) => {
+        const rawSpec = await source.readFile(item.source);
+        const spec = parseOpenApiSpec(rawSpec, item.source);
+        const directory = item.directory ?? "api";
+        const { operations } = extractOpenApiOperations(spec, directory);
+        return { directory, operations, source: item };
+    }));
+    for (const { directory, operations, source: openApiSource } of resolved) {
+        collectUtilityOpenApiPages(byIdentifier, bySource, operations, directory, openApiSource, slugPrefix);
+    }
+    for (const openApiSource of ensureArray(collection.openapi)) {
+        if (!openApiSource) {
+            continue;
+        }
+        addUtilityPagesFromSourceKey(pages, bySource, getGroupedOpenApiSourceKey(openApiSource));
+    }
+    for (const group of docsNavigation?.groups ?? []) {
+        const groupHidden = group.hidden === true;
+        addReferencedUtilityPages(pages, byIdentifier, group.pages, hiddenPages, groupHidden);
+        if (groupHidden || !group.openapi) {
+            continue;
+        }
+        addUtilityPagesFromSourceKey(pages, bySource, getGroupedOpenApiSourceKey(group.openapi));
+    }
+    addReferencedUtilityPages(pages, byIdentifier, docsNavigation?.pages, hiddenPages);
+    return [...pages.values()];
+};

package/packages/@repo/previewing/dist/search-index.d.ts

@@ -0,0 +1,4 @@
+import type { SiteConfig } from "@repo/models";
+import type { ContentIndex, SearchIndexItem, UtilityIndex } from "./types.js";
+export declare const buildSearchIndex: (index: ContentIndex, config: SiteConfig, utilityIndex?: UtilityIndex) => SearchIndexItem[];
+//# sourceMappingURL=search-index.d.ts.map

package/packages/@repo/previewing/dist/search-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-index.d.ts","sourceRoot":"","sources":["../src/search-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM/C,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE9E,eAAO,MAAM,gBAAgB,GAC3B,OAAO,YAAY,EACnB,QAAQ,UAAU,EAClB,eAAe,YAAY,KAC1B,eAAe,EAyBjB,CAAC"}

package/packages/@repo/previewing/dist/search-index.js

@@ -0,0 +1,23 @@
+import { buildPageMetadataMap, shouldIncludeSearchEntry, } from "./content-index.js";
+export const buildSearchIndex = (index, config, utilityIndex) => {
+    const pageMetadataMap = buildPageMetadataMap(index);
+    const items = new Map();
+    for (const page of utilityIndex?.pages ?? []) {
+        items.set(page.slug, {
+            path: page.slug,
+            title: page.title,
+        });
+    }
+    for (const entry of index.entries) {
+        if (!shouldIncludeSearchEntry(entry, pageMetadataMap, config)) {
+            continue;
+        }
+        const pageMeta = pageMetadataMap.get(entry.slug);
+        items.set(entry.slug, {
+            href: pageMeta?.url,
+            path: entry.slug,
+            title: pageMeta?.sidebarTitle ?? entry.title,
+        });
+    }
+    return [...items.values()];
+};

package/packages/@repo/previewing/dist/serialization.d.ts

@@ -0,0 +1,13 @@
+import type { ContentSource } from "./content-source.js";
+import type { ContentIndex, PrebuiltOpenApiEntry, SearchIndexItem, TocItem, UtilityIndex } from "./types.js";
+export declare const serializeContentIndex: (index: ContentIndex) => string;
+export declare const serializeOpenApiIndex: (entries: PrebuiltOpenApiEntry[]) => string;
+export declare const loadPrebuiltContentIndex: (source: ContentSource) => Promise<ContentIndex | null>;
+export declare const loadPrebuiltOpenApiIndex: (source: ContentSource) => Promise<PrebuiltOpenApiEntry[] | null>;
+export declare const serializeSearchIndex: (items: SearchIndexItem[]) => string;
+export declare const loadPrebuiltSearchIndex: (source: ContentSource) => Promise<SearchIndexItem[] | null>;
+export declare const serializeTocIndex: (itemsBySlug: Map<string, TocItem[]>) => string;
+export declare const loadPrebuiltTocIndex: (source: ContentSource) => Promise<Map<string, TocItem[]> | null>;
+export declare const serializeUtilityIndex: (index: UtilityIndex) => string;
+export declare const loadPrebuiltUtilityIndex: (source: ContentSource) => Promise<UtilityIndex | null>;
+//# sourceMappingURL=serialization.d.ts.map

package/packages/@repo/previewing/dist/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAEV,YAAY,EACZ,oBAAoB,EACpB,eAAe,EACf,OAAO,EACP,YAAY,EAGb,MAAM,YAAY,CAAC;AAgCpB,eAAO,MAAM,qBAAqB,GAAI,OAAO,YAAY,KAAG,MAKvB,CAAC;AAEtC,eAAO,MAAM,qBAAqB,GAChC,SAAS,oBAAoB,EAAE,KAC9B,MAIkC,CAAC;AAEtC,eAAO,MAAM,wBAAwB,GACnC,QAAQ,aAAa,KACpB,OAAO,CAAC,YAAY,GAAG,IAAI,CA8B7B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,aAAa,KACpB,OAAO,CAAC,oBAAoB,EAAE,GAAG,IAAI,CAYvC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,eAAe,EAAE,KAAG,MAI5B,CAAC;AAErC,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,OAAO,CAAC,eAAe,EAAE,GAAG,IAAI,CAYlC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,aAAa,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,KAClC,MAI8B,CAAC;AAElC,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,aAAa,KACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAYvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,YAAY,KAAG,MAIvB,CAAC;AAEtC,eAAO,MAAM,wBAAwB,GACnC,QAAQ,aAAa,KACpB,OAAO,CAAC,YAAY,GAAG,IAAI,CAsB7B,CAAC"}

package/packages/@repo/previewing/dist/serialization.js

@@ -0,0 +1,108 @@
+import { PREBUILT_INDEX_PATH, PREBUILT_OPENAPI_INDEX_PATH, PREBUILT_SEARCH_INDEX_PATH, PREBUILT_TOC_INDEX_PATH, PREBUILT_UTILITY_INDEX_PATH, } from "./constants.js";
+export const serializeContentIndex = (index) => JSON.stringify({
+    collections: Object.fromEntries(index.byCollection),
+    entries: index.entries,
+    version: 1,
+});
+export const serializeOpenApiIndex = (entries) => JSON.stringify({
+    entries,
+    version: 1,
+});
+export const loadPrebuiltContentIndex = async (source) => {
+    try {
+        const raw = await source.readFile(PREBUILT_INDEX_PATH);
+        const data = JSON.parse(raw);
+        if (data.version !== 1 || !Array.isArray(data.entries)) {
+            return null;
+        }
+        const bySlug = new Map();
+        const byCollection = new Map();
+        for (const entry of data.entries) {
+            bySlug.set(entry.slug, entry);
+        }
+        for (const [collectionId, entries] of Object.entries(data.collections ?? {})) {
+            byCollection.set(collectionId, entries);
+        }
+        return {
+            byCollection,
+            bySlug,
+            entries: data.entries,
+            errors: [],
+        };
+    }
+    catch {
+        return null;
+    }
+};
+export const loadPrebuiltOpenApiIndex = async (source) => {
+    try {
+        const raw = await source.readFile(PREBUILT_OPENAPI_INDEX_PATH);
+        const data = JSON.parse(raw);
+        if (data.version !== 1 || !Array.isArray(data.entries)) {
+            return null;
+        }
+        return data.entries;
+    }
+    catch {
+        return null;
+    }
+};
+export const serializeSearchIndex = (items) => JSON.stringify({
+    items,
+    version: 1,
+});
+export const loadPrebuiltSearchIndex = async (source) => {
+    try {
+        const raw = await source.readFile(PREBUILT_SEARCH_INDEX_PATH);
+        const data = JSON.parse(raw);
+        if (data.version !== 1 || !Array.isArray(data.items)) {
+            return null;
+        }
+        return data.items;
+    }
+    catch {
+        return null;
+    }
+};
+export const serializeTocIndex = (itemsBySlug) => JSON.stringify({
+    itemsBySlug: Object.fromEntries(itemsBySlug),
+    version: 1,
+});
+export const loadPrebuiltTocIndex = async (source) => {
+    try {
+        const raw = await source.readFile(PREBUILT_TOC_INDEX_PATH);
+        const data = JSON.parse(raw);
+        if (data.version !== 1 || typeof data.itemsBySlug !== "object") {
+            return null;
+        }
+        return new Map(Object.entries(data.itemsBySlug ?? {}));
+    }
+    catch {
+        return null;
+    }
+};
+export const serializeUtilityIndex = (index) => JSON.stringify({
+    ...index,
+    version: 1,
+});
+export const loadPrebuiltUtilityIndex = async (source) => {
+    try {
+        const raw = await source.readFile(PREBUILT_UTILITY_INDEX_PATH);
+        const data = JSON.parse(raw);
+        if (data.version !== 1 ||
+            typeof data.name !== "string" ||
+            !Array.isArray(data.pages)) {
+            return null;
+        }
+        return {
+            description: data.description,
+            name: data.name,
+            pages: data.pages,
+            segments: Array.isArray(data.segments) ? data.segments : undefined,
+            slug: data.slug,
+        };
+    }
+    catch {
+        return null;
+    }
+};

package/packages/@repo/previewing/dist/toc-index.d.ts

@@ -0,0 +1,5 @@
+import type { ContentSource } from "./content-source.js";
+import type { ContentIndex, TocItem } from "./types.js";
+export declare const extractToc: (source: string) => TocItem[];
+export declare const buildTocIndex: (index: ContentIndex, source: ContentSource) => Promise<Map<string, TocItem[]>>;
+//# sourceMappingURL=toc-index.d.ts.map