bejamas 0.0.0-canary.0138fd3

package/dist/generate-mdx-BSRQJPrF.js

@@ -0,0 +1,1205 @@
+import { _ as getConfig, a as extractComponentTagsFromMDX, b as logger, c as extractPropsFromDeclaredProps, d as parseJsDocMetadata, f as resolveOutDir, g as spinner, h as toIdentifier, i as discoverExamples, l as normalizeBlockMDX, m as slugify, n as createSourceFileFromFrontmatter, o as extractFrontmatter, p as resolveUiRoot, r as detectHasImportTopLevel, s as extractPropsFromAstroProps, st as __require, t as RESERVED_COMPONENTS, u as normalizeUsageMDX } from "./utils-Cxc_kZGv.js";
+import { dirname, extname, join, relative } from "path";
+import { existsSync, mkdirSync } from "fs";
+import { readFile, readdir, writeFile } from "fs/promises";
+
+//#region src/docs/generate-mdx/examples.ts
+function createImplicitSection() {
+	return {
+		title: null,
+		intro: [],
+		items: []
+	};
+}
+function normalizeSection(section) {
+	return {
+		title: section.title,
+		introMD: section.intro.join("\n").trim(),
+		items: section.items.map((item) => ({
+			title: item.title,
+			body: item.body.join("\n").trim()
+		}))
+	};
+}
+function pushItem(section, item) {
+	if (!section || !item) return;
+	if (!item.title.trim().length && !item.body.join("\n").trim().length) return;
+	section.items.push(item);
+}
+function pushSection(sections, section) {
+	if (!section) return;
+	const normalized = normalizeSection(section);
+	if (!normalized.title && !normalized.introMD.length && normalized.items.length === 0) return;
+	sections.push(normalized);
+}
+function extractHeading(line, level) {
+	const pattern = level === 2 ? /^##(?!#)\s+(.+)$/ : /^###(?!#)\s+(.+)$/;
+	const match = line.trim().match(pattern);
+	return match ? match[1].trim() : null;
+}
+function splitDescriptionAndSnippetRaw(body) {
+	if (!body || !body.trim().length) return {
+		descriptionMD: "",
+		snippet: ""
+	};
+	const lines = body.split("\n");
+	let snippetStartIdx = -1;
+	for (let i = 0; i < lines.length; i += 1) {
+		const ln = lines[i];
+		if (!ln.trim().length) continue;
+		if (/^\s*[<{]/.test(ln)) {
+			snippetStartIdx = i;
+			break;
+		}
+	}
+	if (snippetStartIdx <= 0) return {
+		descriptionMD: "",
+		snippet: body.trim()
+	};
+	return {
+		descriptionMD: lines.slice(0, snippetStartIdx).join("\n").trim(),
+		snippet: lines.slice(snippetStartIdx).join("\n").trim()
+	};
+}
+function splitAstroFrontmatter(sourceCode) {
+	const match = sourceCode.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return {
+		frontmatter: "",
+		markup: sourceCode.trim()
+	};
+	return {
+		frontmatter: match[1].trim(),
+		markup: match[2].trim()
+	};
+}
+function stripFrontmatterComments(frontmatter) {
+	if (!frontmatter || !frontmatter.length) return "";
+	return frontmatter.replace(/\/\*[\s\S]*?\*\//g, "\n").replace(/^[ \t]*\/\/.*$/gm, "").trim();
+}
+function isImportOnlyFrontmatter(frontmatter) {
+	const cleaned = stripFrontmatterComments(frontmatter);
+	if (!cleaned.length) return true;
+	let remaining = cleaned;
+	remaining = remaining.replace(/(?:^|\n)\s*import\s+(?:type\s+)?[\s\S]*?\s+from\s+['"][^'"]+['"]\s*;?(?=\n|$)/g, "\n").replace(/(?:^|\n)\s*import\s+['"][^'"]+['"]\s*;?(?=\n|$)/g, "\n").replace(/(?:^|\n)\s*export\s+(?:\*\s+from|\{[\s\S]*?\}\s+from)\s+['"][^'"]+['"]\s*;?(?=\n|$)/g, "\n").trim();
+	return remaining.replace(/[;\s]/g, "").length === 0;
+}
+function isAstroFrontmatterPreviewUnsafe(frontmatter) {
+	const cleaned = stripFrontmatterComments(frontmatter);
+	if (!cleaned.length) return false;
+	if (/\b(?:const|let|var|function|class|if|for|while|switch|try|catch|return|throw|await|new)\b|=>|Astro\./.test(cleaned)) return true;
+	return !isImportOnlyFrontmatter(cleaned);
+}
+function parseFenceInfo(infoRaw) {
+	const parts = (infoRaw || "").trim().split(/\s+/).filter((v) => v.length).map((v) => v.toLowerCase());
+	if (!parts.length) return {
+		lang: "",
+		flags: /* @__PURE__ */ new Set()
+	};
+	const [lang, ...flags] = parts;
+	return {
+		lang,
+		flags: new Set(flags)
+	};
+}
+function decodeEscapedScriptTags(source) {
+	if (!source || !source.length) return source;
+	return source.replace(/&lt;script&gt;/gi, "<script>").replace(/&lt;\/script&gt;/gi, "<\/script>");
+}
+const CONSOLE_SCRIPT_FENCE_LANGS = /* @__PURE__ */ new Set([
+	"js",
+	"ts",
+	"javascript",
+	"typescript"
+]);
+function parseFenceBlocks(body) {
+	const lines = body.split("\n");
+	const fences = [];
+	let active = null;
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("```")) {
+			if (active) active.bodyLines.push(line);
+			continue;
+		}
+		if (!active) {
+			const parsed = parseFenceInfo(trimmed.slice(3).trim());
+			active = {
+				startLine: i,
+				openLine: line,
+				lang: parsed.lang,
+				flags: parsed.flags,
+				bodyLines: []
+			};
+			continue;
+		}
+		fences.push({
+			openLine: active.openLine,
+			closeLine: line,
+			lang: active.lang,
+			flags: active.flags,
+			body: active.bodyLines.join("\n"),
+			startLine: active.startLine,
+			endLine: i
+		});
+		active = null;
+	}
+	return {
+		lines,
+		fences
+	};
+}
+function serializeFenceBlock(fence) {
+	const parts = [fence.openLine];
+	if (fence.body.length) parts.push(fence.body);
+	parts.push(fence.closeLine);
+	return parts.join("\n");
+}
+function buildRemainingMarkdown(lines, fences, consumedFenceIndexes) {
+	const skippedLines = /* @__PURE__ */ new Set();
+	for (const [index, fence] of fences.entries()) {
+		if (!consumedFenceIndexes.has(index)) continue;
+		for (let line = fence.startLine; line <= fence.endLine; line += 1) skippedLines.add(line);
+	}
+	return lines.filter((_, index) => !skippedLines.has(index)).join("\n").trim();
+}
+function extractFirstAstroFence(body) {
+	if (!body || !body.trim().length) return null;
+	const { lines, fences } = parseFenceBlocks(body);
+	const astroFenceIndex = fences.findIndex((fence) => fence.lang === "astro");
+	if (astroFenceIndex === -1) return null;
+	const astroFence = fences[astroFenceIndex];
+	const consumedFenceIndexes = /* @__PURE__ */ new Set([astroFenceIndex]);
+	let companionSourceMD = "";
+	let consoleScripts = [];
+	let companionIntroMD = "";
+	let trailingDescriptionMD = "";
+	let mergeCompanionWithSource = false;
+	if (astroFence.flags.has("console")) {
+		const nextFence = fences[astroFenceIndex + 1];
+		if (nextFence && CONSOLE_SCRIPT_FENCE_LANGS.has(nextFence.lang)) {
+			consumedFenceIndexes.add(astroFenceIndex + 1);
+			companionSourceMD = serializeFenceBlock(nextFence);
+			companionIntroMD = lines.slice(astroFence.endLine + 1, nextFence.startLine).join("\n").trim();
+			trailingDescriptionMD = lines.slice(nextFence.endLine + 1).join("\n").trim();
+			mergeCompanionWithSource = companionIntroMD.length === 0;
+			const normalizedScript = nextFence.body.trim();
+			if (normalizedScript.length) consoleScripts = [normalizedScript];
+		}
+	}
+	const descriptionMD = companionSourceMD.length ? lines.slice(0, astroFence.startLine).join("\n").trim() : buildRemainingMarkdown(lines, fences, consumedFenceIndexes);
+	return {
+		sourceCode: decodeEscapedScriptTags(astroFence.body.trim()),
+		descriptionMD,
+		skipPreview: astroFence.flags.has("nopreview"),
+		enableConsolePanel: astroFence.flags.has("console"),
+		consoleScripts,
+		companionSourceMD,
+		companionIntroMD,
+		trailingDescriptionMD,
+		mergeCompanionWithSource
+	};
+}
+function parseExamplesSections(examplesMDX) {
+	if (!examplesMDX || !examplesMDX.trim().length) return [];
+	const sections = [];
+	const lines = examplesMDX.split("\n");
+	let currentSection = null;
+	let currentItem = null;
+	let inFence = false;
+	for (const line of lines) {
+		if (line.trim().startsWith("```")) {
+			inFence = !inFence;
+			if (!currentSection) currentSection = createImplicitSection();
+			if (currentItem) currentItem.body.push(line);
+			else currentSection.intro.push(line);
+			continue;
+		}
+		if (!inFence) {
+			const h2 = extractHeading(line, 2);
+			if (h2) {
+				pushItem(currentSection, currentItem);
+				currentItem = null;
+				pushSection(sections, currentSection);
+				currentSection = {
+					title: h2,
+					intro: [],
+					items: []
+				};
+				continue;
+			}
+			const h3 = extractHeading(line, 3);
+			if (h3) {
+				if (!currentSection) currentSection = createImplicitSection();
+				pushItem(currentSection, currentItem);
+				currentItem = {
+					title: h3,
+					body: []
+				};
+				continue;
+			}
+		}
+		if (!currentSection) currentSection = createImplicitSection();
+		if (currentItem) currentItem.body.push(line);
+		else currentSection.intro.push(line);
+	}
+	pushItem(currentSection, currentItem);
+	pushSection(sections, currentSection);
+	return sections;
+}
+function prepareExampleContent(body) {
+	if (!body || !body.trim().length) return {
+		descriptionMD: "",
+		snippet: "",
+		sourceCode: "",
+		sourceFromFence: false,
+		skipPreview: false,
+		enableConsolePanel: false,
+		consoleScripts: [],
+		companionSourceMD: "",
+		companionIntroMD: "",
+		trailingDescriptionMD: "",
+		mergeCompanionWithSource: false
+	};
+	const fenced = extractFirstAstroFence(body);
+	if (fenced) {
+		const { frontmatter, markup } = splitAstroFrontmatter(fenced.sourceCode);
+		const unsafeFrontmatter = isAstroFrontmatterPreviewUnsafe(frontmatter);
+		return {
+			descriptionMD: fenced.descriptionMD,
+			snippet: markup,
+			sourceCode: fenced.sourceCode,
+			sourceFromFence: true,
+			skipPreview: fenced.skipPreview || unsafeFrontmatter,
+			enableConsolePanel: fenced.enableConsolePanel,
+			consoleScripts: fenced.consoleScripts,
+			companionSourceMD: fenced.companionSourceMD,
+			companionIntroMD: fenced.companionIntroMD,
+			trailingDescriptionMD: fenced.trailingDescriptionMD,
+			mergeCompanionWithSource: fenced.mergeCompanionWithSource
+		};
+	}
+	const split = splitDescriptionAndSnippetRaw(body);
+	return {
+		descriptionMD: split.descriptionMD,
+		snippet: split.snippet,
+		sourceCode: split.snippet,
+		sourceFromFence: false,
+		skipPreview: false,
+		enableConsolePanel: false,
+		consoleScripts: [],
+		companionSourceMD: "",
+		companionIntroMD: "",
+		trailingDescriptionMD: "",
+		mergeCompanionWithSource: false
+	};
+}
+function extractTags(block) {
+	if (!block || !block.length) return [];
+	const found = /* @__PURE__ */ new Set();
+	const tagRegex = /<([A-Z][A-Za-z0-9_]*)\b/g;
+	let match;
+	while ((match = tagRegex.exec(block)) !== null) found.add(match[1]);
+	return Array.from(found);
+}
+function extractComponentTagsFromPreviewMarkdown(block, config = {}) {
+	if (!block || !block.length) return [];
+	const { defaultPreview = true, allowForcedPreview = true } = config;
+	const found = /* @__PURE__ */ new Set();
+	const lines = block.split("\n");
+	let inFence = false;
+	let fenceOpen = "";
+	let currentFenceLang = "";
+	let currentFenceFlags = /* @__PURE__ */ new Set();
+	const fenceBody = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("```")) {
+			if (!inFence) {
+				inFence = true;
+				fenceOpen = line;
+				const parsed = parseFenceInfo(trimmed.slice(3).trim());
+				currentFenceLang = parsed.lang;
+				currentFenceFlags = parsed.flags;
+				fenceBody.length = 0;
+				continue;
+			}
+			if (currentFenceLang === "astro") {
+				const sourceCode = fenceBody.join("\n").trim();
+				const prepared = prepareExampleContent(`${fenceOpen}\n${sourceCode}\n${line}`);
+				const hasForcedPreviewFlag = currentFenceFlags.has("preview") || currentFenceFlags.has("console");
+				if (!prepared.skipPreview && (defaultPreview || allowForcedPreview && hasForcedPreviewFlag)) for (const tag of extractTags(prepared.snippet)) found.add(tag);
+			}
+			inFence = false;
+			fenceOpen = "";
+			currentFenceLang = "";
+			currentFenceFlags = /* @__PURE__ */ new Set();
+			fenceBody.length = 0;
+			continue;
+		}
+		if (inFence) {
+			fenceBody.push(line);
+			continue;
+		}
+		for (const tag of extractTags(line)) found.add(tag);
+	}
+	return Array.from(found);
+}
+function extractComponentTagsFromExamplesSections(sections) {
+	if (!sections?.length) return [];
+	const found = /* @__PURE__ */ new Set();
+	for (const section of sections) {
+		for (const tag of extractComponentTagsFromPreviewMarkdown(section.introMD)) found.add(tag);
+		for (const item of section.items) {
+			const prepared = prepareExampleContent(item.body);
+			if (prepared.skipPreview) continue;
+			for (const tag of extractTags(prepared.snippet)) found.add(tag);
+		}
+	}
+	return Array.from(found);
+}
+
+//#endregion
+//#region src/docs/generate-mdx/mdx-builder.ts
+/**
+* Check if an import path uses the new barrel export pattern (no .astro extension)
+*/
+function isBarrelImport(path) {
+	return !path.endsWith(".astro");
+}
+/**
+* Convert a PascalCase component name to its folder path (kebab-case).
+* Examples:
+*   - "Card" → "card"
+*   - "CardHeader" → "card"
+*   - "InputGroup" → "input-group"
+*   - "InputGroupAddon" → "input-group"
+*   - "StickySurface" → "sticky-surface"
+*   - "RadioGroup" → "radio-group"
+*   - "RadioGroupItem" → "radio-group"
+*/
+function componentToFolder(name) {
+	const sortedFamilies = [
+		"InputGroup",
+		"LinkGroup",
+		"RadioGroup",
+		"ButtonGroup",
+		"StickySurface",
+		"DropdownMenu",
+		"NavigationMenu",
+		"ContextMenu",
+		"HoverCard",
+		"ToggleGroup"
+	].sort((a, b) => b.length - a.length);
+	for (const family of sortedFamilies) if (name === family || name.startsWith(family)) return family.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+	const baseMatch = name.match(/^[A-Z][a-z]*/);
+	return baseMatch ? baseMatch[0].toLowerCase() : name.toLowerCase();
+}
+function resolveComponentFolder(name, componentFolderMap) {
+	if (!componentFolderMap) return componentToFolder(name);
+	const direct = componentFolderMap[name];
+	if (direct && direct.length) return direct;
+	return componentToFolder(name);
+}
+/**
+* Group component names by their folder path
+*/
+function groupComponentsByFolder(components, componentFolderMap) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const comp of components) {
+		const folder = resolveComponentFolder(comp, componentFolderMap);
+		if (!groups.has(folder)) groups.set(folder, []);
+		groups.get(folder).push(comp);
+	}
+	return groups;
+}
+/**
+* Generate import lines for UI components using the barrel import pattern
+*/
+function generateBarrelImports(components, componentsAlias, componentFolderMap) {
+	const groups = groupComponentsByFolder(components, componentFolderMap);
+	const lines = [];
+	const sortedFolders = Array.from(groups.keys()).sort();
+	for (const folder of sortedFolders) {
+		const names = groups.get(folder).sort();
+		if (folder.endsWith(".astro")) {
+			for (const name of names) lines.push(`import ${name} from '${componentsAlias}/${folder}';`);
+			continue;
+		}
+		lines.push(`import { ${names.join(", ")} } from '${componentsAlias}/${folder}';`);
+	}
+	return lines;
+}
+/**
+* Generate import lines for UI components using the old default import pattern
+*/
+function generateDefaultImports(components, componentsAlias) {
+	return components.slice().sort().map((name) => `import ${name} from '${componentsAlias}/${name}.astro';`);
+}
+function buildMdx(params) {
+	const { importName, importPath, title, description, descriptionBodyMDX, usageMDX, hasImport, propsList, propsTable, examples, examplesSections, componentFolderMap, autoImports, lucideIcons, primaryExampleMDX, componentSource, commandName, figmaUrl, componentsAlias, namedExports, apiMDX } = params;
+	const available = params.availableComponents ? new Set(params.availableComponents) : null;
+	const missingFromNames = (names) => names.filter((name) => available && !available.has(name) && !RESERVED_COMPONENTS.has(name) && !/Icon$/.test(name));
+	const missingFromSnippet = (snippet) => missingFromNames([...new Set([...snippet.matchAll(/<([A-Z][A-Za-z0-9_]*)\b/g)].map((match) => match[1]))]);
+	const missingNotice = (names) => {
+		return `> Preview unavailable. Run \`bejamas add ${[...new Set(names.map((name) => resolveComponentFolder(name, componentFolderMap)))].sort().join(" ")}\` to install the required components, then regenerate the docs.`;
+	};
+	const useBarrelPattern = isBarrelImport(importPath);
+	const sortedLucide = (lucideIcons ?? []).slice().sort();
+	const externalTopImports = [`import { Tabs as DocsTabs, TabItem as DocsTabItem } from '@astrojs/starlight/components';`, sortedLucide.length ? `import { ${sortedLucide.join(", ")} } from '@lucide/astro';` : null].filter((v) => v != null).slice().sort((a, b) => String(a).localeCompare(String(b)));
+	const sortedUiAuto = (autoImports ?? []).filter((name) => !available || available.has(name)).slice().sort();
+	const uiAutoLines = useBarrelPattern || componentFolderMap ? generateBarrelImports(sortedUiAuto, componentsAlias, componentFolderMap) : generateDefaultImports(sortedUiAuto, componentsAlias);
+	const exampleLines = (examples ?? []).filter((ex) => !missingFromSnippet(ex.source).length).map((ex) => `import ${ex.importName} from '${ex.importPath}';`).sort((a, b) => a.localeCompare(b));
+	let mainImportLine = null;
+	if (!hasImport) {
+		if (useBarrelPattern) mainImportLine = `import { ${[importName, ...namedExports ?? []].sort().join(", ")} } from '${importPath}';`;
+		else mainImportLine = `import ${importName} from '${importPath}';`;
+	}
+	const internalTopImports = [
+		mainImportLine,
+		...uiAutoLines,
+		...exampleLines
+	].filter((v) => v != null).slice().sort((a, b) => String(a).localeCompare(String(b)));
+	const importLines = [
+		...externalTopImports,
+		externalTopImports.length && internalTopImports.length ? "" : null,
+		...internalTopImports
+	].filter((v) => v !== null && v !== void 0);
+	const extractTags = (snippet) => {
+		const found = /* @__PURE__ */ new Set();
+		const tagRegex = /<([A-Z][A-Za-z0-9_]*)\b/g;
+		let m;
+		while ((m = tagRegex.exec(snippet)) !== null) found.add(m[1]);
+		return found;
+	};
+	const buildSnippetImportLines = (snippet) => {
+		if (!snippet || !snippet.length) return [];
+		const used = extractTags(snippet);
+		const usedIcons = sortedLucide.filter((n) => used.has(n));
+		const usedUi = (autoImports ?? []).filter((n) => used.has(n));
+		const includeMain = !hasImport && used.has(importName);
+		const usedNamedExports = useBarrelPattern && namedExports ? namedExports.filter((n) => used.has(n)) : [];
+		const external = [];
+		if (usedIcons.length) external.push(`import { ${usedIcons.join(", ")} } from '@lucide/astro';`);
+		const internal = [];
+		if (useBarrelPattern) {
+			if (includeMain || usedNamedExports.length > 0) {
+				const mainExports = [...includeMain ? [importName] : [], ...usedNamedExports].sort();
+				internal.push(`import { ${mainExports.join(", ")} } from '${importPath}';`);
+			}
+			if (usedUi.length > 0) internal.push(...generateBarrelImports(usedUi, componentsAlias, componentFolderMap));
+		} else {
+			if (includeMain) internal.push(`import ${importName} from '${importPath}';`);
+			internal.push(...componentFolderMap ? generateBarrelImports(usedUi, componentsAlias, componentFolderMap) : generateDefaultImports(usedUi, componentsAlias));
+		}
+		const externalSorted = external.slice().sort((a, b) => a.localeCompare(b));
+		const internalSorted = internal.slice().sort((a, b) => a.localeCompare(b));
+		return [
+			...externalSorted,
+			externalSorted.length && internalSorted.length ? "" : null,
+			...internalSorted
+		].filter((v) => v !== null && v !== void 0);
+	};
+	let consolePreviewCounter = 0;
+	const wrapTextNodes = (snippet) => {
+		if (!snippet) return snippet;
+		return snippet.replace(/>([^<]+)</g, (match, inner) => {
+			const trimmed = inner.trim();
+			if (!trimmed.length) return match;
+			if (/^\{[\s\S]*\}$/.test(trimmed)) return match;
+			if (/\{[^}]*\}/.test(inner)) return match;
+			return `>{${JSON.stringify(inner)}}<`;
+		});
+	};
+	/**
+	* Normalize whitespace in preview content.
+	* This collapses ALL newlines and multiple spaces into single spaces to prevent
+	* MDX parsing issues. In particular, a '>' at the start of a line is interpreted
+	* as a block quote marker by MDX, which causes "Unexpected lazy line" errors.
+	*/
+	const normalizeInlineWhitespace = (snippet) => {
+		if (!snippet) return snippet;
+		return snippet.replace(/\s+/g, " ").trim();
+	};
+	/**
+	* Convert <p> tags that contain component tags to <span> tags.
+	* This is necessary because components may render as block elements (like <div>),
+	* and HTML doesn't allow block elements inside <p>. The browser would automatically
+	* close the <p> before any block element, breaking the layout.
+	*/
+	const convertParagraphsWithComponents = (snippet) => {
+		if (!snippet) return snippet;
+		return snippet.replace(/<p(\s[^>]*)?>([^]*?)<\/p>/gi, (match, attrs, content) => {
+			if (/<[A-Z][A-Za-z0-9]*/.test(content)) return `<span${attrs || ""} style="display:block">${content}</span>`;
+			return match;
+		});
+	};
+	const extractInlineScripts = (snippet) => {
+		if (!snippet) return {
+			markup: snippet,
+			scripts: []
+		};
+		const scripts = [];
+		return {
+			markup: snippet.replace(/<script\b[^>]*>([\s\S]*?)<\/script>/gi, (_, scriptBody) => {
+				scripts.push((scriptBody || "").trim());
+				return "";
+			}),
+			scripts
+		};
+	};
+	const toMdxPreview = (snippet, options = {}) => {
+		if (!snippet) return {
+			markup: "",
+			scripts: []
+		};
+		const { enableConsolePanel = false, consoleScripts = [] } = options;
+		const extracted = extractInlineScripts(snippet);
+		const resolvedConsoleScripts = enableConsolePanel && consoleScripts.length ? consoleScripts : enableConsolePanel ? extracted.scripts : [];
+		const withoutComments = extracted.markup.replace(/<!--([\s\S]*?)-->/g, "{/*$1*/}");
+		const withConvertedParagraphs = convertParagraphsWithComponents(withoutComments);
+		if (/<p[\s>]/i.test(withConvertedParagraphs)) return {
+			markup: normalizeInlineWhitespace(withConvertedParagraphs),
+			scripts: resolvedConsoleScripts
+		};
+		const normalized = normalizeInlineWhitespace(withConvertedParagraphs);
+		return {
+			markup: wrapTextNodes(normalized),
+			scripts: resolvedConsoleScripts
+		};
+	};
+	const buildConsoleRuntimeSource = (rootId, panelId, userScript) => {
+		return `(function () {
+  var root = document.getElementById(${JSON.stringify(rootId)});
+  var panel = document.getElementById(${JSON.stringify(panelId)});
+  if (!root || !panel) return;
+
+  var placeholder = panel.textContent || "Waiting for logs...";
+  var hasLogs = false;
+
+  var toText = function (value) {
+    if (typeof value === "string") return value;
+    if (value === undefined) return "undefined";
+    if (value === null) return "null";
+    try {
+      return JSON.stringify(value);
+    } catch (_error) {
+      return String(value);
+    }
+  };
+
+  var append = function (level, args) {
+    var stamp = new Date().toLocaleTimeString();
+    var body = Array.prototype.map.call(args, toText).join(" ");
+    var line = "[" + stamp + "] " + String(level).toUpperCase() + ": " + body;
+    var current = panel.textContent || "";
+    if (!hasLogs && current.trim() === placeholder.trim()) {
+      panel.textContent = line;
+    } else {
+      panel.textContent = current ? current + "\\n" + line : line;
+    }
+    hasLogs = true;
+    panel.scrollTop = panel.scrollHeight;
+  };
+
+  var methods = ["log", "info", "warn", "error"];
+  var proxyConsole = Object.create(console);
+  for (var i = 0; i < methods.length; i += 1) {
+    (function (methodName) {
+      var fallback = typeof console.log === "function" ? console.log.bind(console) : function () {};
+      var original =
+        typeof console[methodName] === "function"
+          ? console[methodName].bind(console)
+          : fallback;
+      proxyConsole[methodName] = function () {
+        var args = Array.prototype.slice.call(arguments);
+        original.apply(console, args);
+        append(methodName, args);
+      };
+    })(methods[i]);
+  }
+
+  try {
+    var run = new Function("console", "root", "panel", ${JSON.stringify(userScript)});
+    run(proxyConsole, root, panel);
+  } catch (error) {
+    var fallbackError = typeof console.error === "function" ? console.error.bind(console) : function () {};
+    fallbackError(error);
+    append("error", [error]);
+  }
+})();`;
+	};
+	const renderConsoleScripts = (rootId, panelId, scripts) => {
+		if (!scripts.length) return "";
+		return scripts.filter((script) => script && script.trim().length).map((script) => {
+			const runtimeSource = buildConsoleRuntimeSource(rootId, panelId, script);
+			return `<script type="module" src="data:text/javascript;charset=utf-8,${encodeURIComponent(runtimeSource)}"><\/script>`;
+		}).join("\n");
+	};
+	const renderCompanionSourceMD = (sourceMD) => {
+		if (!sourceMD || !sourceMD.trim().length) return "";
+		const match = sourceMD.trim().match(/^```(\S*)([^\n]*)\n([\s\S]*?)\n```$/);
+		if (!match) return sourceMD;
+		const [, langRaw = "", flagsRaw = "", body = ""] = match;
+		const lang = langRaw.trim().toLowerCase();
+		if (![
+			"js",
+			"ts",
+			"javascript",
+			"typescript"
+		].includes(lang)) return sourceMD;
+		const astroInfo = ["astro", flagsRaw.trim()].filter(Boolean).join(" ");
+		const scriptBody = body.replace(/\s+$/, "");
+		return [
+			`\`\`\`${astroInfo}`,
+			"<script>",
+			scriptBody,
+			"<\/script>",
+			"```"
+		].join("\n");
+	};
+	const extractCompanionScriptBody = (sourceMD) => {
+		if (!sourceMD || !sourceMD.trim().length) return "";
+		const match = sourceMD.trim().match(/^```(\S*)([^\n]*)\n([\s\S]*?)\n```$/);
+		if (!match) return "";
+		const [, langRaw = "", , body = ""] = match;
+		const lang = langRaw.trim().toLowerCase();
+		if (![
+			"js",
+			"ts",
+			"javascript",
+			"typescript"
+		].includes(lang)) return "";
+		return body.replace(/\s+$/, "");
+	};
+	const renderMergedAstroSourceMD = (fenceOpen, sourceBody, companionSourceMD) => {
+		const scriptBody = extractCompanionScriptBody(companionSourceMD);
+		if (!scriptBody.length) return [
+			fenceOpen,
+			sourceBody,
+			"```"
+		].filter(Boolean).join("\n");
+		const normalizedSourceBody = sourceBody.replace(/\s+$/, "");
+		const parts = [fenceOpen];
+		if (normalizedSourceBody.length) parts.push(normalizedSourceBody, "");
+		parts.push("<script>", scriptBody, "<\/script>", "```");
+		return parts.join("\n");
+	};
+	const renderPreviewBlock = (snippet, options = {}) => {
+		const missing = missingFromSnippet(snippet);
+		if (missing.length) return missingNotice(missing);
+		const { enableConsolePanel = false } = options;
+		const preparedPreview = toMdxPreview(snippet, options);
+		if (!preparedPreview.markup || !preparedPreview.markup.length) return "";
+		if (!enableConsolePanel) return `<div class="not-content sl-bejamas-component-preview flex justify-center px-4 md:px-10 py-12 border border-border rounded-t-lg min-h-72 items-center">
+${preparedPreview.markup}
+</div>`;
+		consolePreviewCounter += 1;
+		const rootId = `sl-bejamas-console-preview-${consolePreviewCounter}`;
+		const panelId = `${rootId}-output`;
+		const scriptTags = renderConsoleScripts(rootId, panelId, preparedPreview.scripts);
+		return [
+			`<div id="${rootId}" class="not-content sl-bejamas-component-preview flex justify-center px-4 md:px-10 py-12 border border-border rounded-t-lg min-h-72 items-center">`,
+			preparedPreview.markup,
+			"</div>",
+			`<div class="not-content sl-bejamas-console-log-shell px-4 md:px-10 py-4 border border-border border-t-0">`,
+			`<pre id="${panelId}" data-slot="event-log" class="sl-bejamas-console-log w-full p-3 rounded-md bg-muted text-xs font-mono text-muted-foreground min-h-[80px] max-h-[200px] overflow-y-auto">Waiting for logs...</pre>`,
+			scriptTags && scriptTags.length ? scriptTags : null,
+			"</div>"
+		].filter((part) => part !== null).join("\n");
+	};
+	const renderAstroPreviewsInMarkdown = (block, config = {}) => {
+		if (!block || !block.length) return block;
+		const missingRaw = missingFromNames(extractComponentTagsFromPreviewMarkdown(block, {
+			defaultPreview: false,
+			allowForcedPreview: false
+		}));
+		if (missingRaw.length) return `${missingNotice(missingRaw)}\n\n\`\`\`\`mdx\n${block}\n\`\`\`\``;
+		const { defaultPreview = true, allowForcedPreview = true } = config;
+		const lines = block.split("\n");
+		const out = [];
+		let inFence = false;
+		let fenceOpen = "";
+		let currentFenceLang = "";
+		let currentFenceFlags = /* @__PURE__ */ new Set();
+		const fenceBody = [];
+		const findCompanionConsoleFence = (startIndex) => {
+			let index = startIndex;
+			while (index < lines.length) {
+				const trimmedLine = lines[index].trim();
+				if (!trimmedLine.length || !trimmedLine.startsWith("```")) {
+					index += 1;
+					continue;
+				}
+				const parsed = parseFenceInfo(trimmedLine.slice(3).trim());
+				if (![
+					"js",
+					"ts",
+					"javascript",
+					"typescript"
+				].includes(parsed.lang)) return null;
+				let end = index + 1;
+				while (end < lines.length) {
+					if (lines[end].trim().startsWith("```")) return {
+						start: index,
+						end
+					};
+					end += 1;
+				}
+				return null;
+			}
+			return null;
+		};
+		for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+			const line = lines[lineIndex];
+			const trimmed = line.trim();
+			if (trimmed.startsWith("```")) {
+				if (!inFence) {
+					inFence = true;
+					fenceOpen = line;
+					const parsed = parseFenceInfo(trimmed.slice(3).trim());
+					currentFenceLang = parsed.lang;
+					currentFenceFlags = parsed.flags;
+					fenceBody.length = 0;
+					continue;
+				}
+				if (currentFenceLang === "astro") {
+					const sourceCode = decodeEscapedScriptTags(fenceBody.join("\n").trim());
+					const companionConsoleFence = currentFenceFlags.has("console") ? findCompanionConsoleFence(lineIndex + 1) : null;
+					const companionMarkdown = companionConsoleFence ? lines.slice(lineIndex + 1, companionConsoleFence.end + 1).join("\n") : "";
+					const prepared = prepareExampleContent(companionMarkdown.length ? `${fenceOpen}\n${sourceCode}\n${line}\n${companionMarkdown}` : `${fenceOpen}\n${sourceCode}\n${line}`);
+					const hasForcedPreviewFlag = currentFenceFlags.has("preview") || currentFenceFlags.has("console");
+					const shouldPreview = !prepared.skipPreview && (defaultPreview || allowForcedPreview && hasForcedPreviewFlag);
+					if (prepared.snippet && prepared.snippet.length && shouldPreview) {
+						const previewBlock = renderPreviewBlock(prepared.snippet, {
+							enableConsolePanel: prepared.enableConsolePanel,
+							consoleScripts: prepared.consoleScripts
+						});
+						if (previewBlock.length) out.push(previewBlock);
+						out.push("");
+					}
+				}
+				if (currentFenceLang === "astro") {
+					const normalizedFenceBody = decodeEscapedScriptTags(fenceBody.join("\n"));
+					const companionConsoleFence = currentFenceFlags.has("console") ? findCompanionConsoleFence(lineIndex + 1) : null;
+					const companionMarkdown = companionConsoleFence ? lines.slice(lineIndex + 1, companionConsoleFence.end + 1).join("\n") : "";
+					const prepared = companionMarkdown.length ? prepareExampleContent(`${fenceOpen}\n${normalizedFenceBody}\n${line}\n${companionMarkdown}`) : null;
+					if (prepared?.companionSourceMD && prepared.companionSourceMD.length && prepared.mergeCompanionWithSource) {
+						out.push(renderMergedAstroSourceMD(fenceOpen, normalizedFenceBody, prepared.companionSourceMD));
+						if (companionConsoleFence) lineIndex = companionConsoleFence.end;
+					} else {
+						out.push(fenceOpen);
+						if (normalizedFenceBody.length) out.push(...normalizedFenceBody.split("\n"));
+						out.push(line);
+						if (prepared?.companionSourceMD && prepared.companionSourceMD.length && companionConsoleFence) {
+							const companionIntro = lines.slice(lineIndex + 1, companionConsoleFence.start).join("\n");
+							if (companionIntro.length) out.push(companionIntro);
+							out.push(renderCompanionSourceMD(prepared.companionSourceMD));
+							lineIndex = companionConsoleFence.end;
+						}
+					}
+				} else {
+					out.push(fenceOpen);
+					if (fenceBody.length) out.push(...fenceBody);
+					out.push(line);
+				}
+				inFence = false;
+				fenceOpen = "";
+				currentFenceLang = "";
+				currentFenceFlags = /* @__PURE__ */ new Set();
+				fenceBody.length = 0;
+				continue;
+			}
+			if (inFence) {
+				fenceBody.push(line);
+				continue;
+			}
+			out.push(line);
+		}
+		if (inFence) {
+			out.push(fenceOpen);
+			if (currentFenceLang === "astro") {
+				const normalizedFenceBody = decodeEscapedScriptTags(fenceBody.join("\n"));
+				if (normalizedFenceBody.length) out.push(...normalizedFenceBody.split("\n"));
+			} else if (fenceBody.length) out.push(...fenceBody);
+		}
+		return out.join("\n").trim();
+	};
+	const renderedDescriptionBodyMDX = renderAstroPreviewsInMarkdown(descriptionBodyMDX || "");
+	const renderedUsageMDX = renderAstroPreviewsInMarkdown(usageMDX || "", { defaultPreview: false });
+	const renderedApiMDX = renderAstroPreviewsInMarkdown(apiMDX || "", {
+		defaultPreview: false,
+		allowForcedPreview: false
+	});
+	const primaryExampleSection = primaryExampleMDX && primaryExampleMDX.length ? `${renderPreviewBlock(primaryExampleMDX)}
+
+\`\`\`astro
+${(() => {
+		const lines = buildSnippetImportLines(primaryExampleMDX);
+		return lines.length ? `---\n${lines.join("\n")}\n---\n\n` : "";
+	})()}${primaryExampleMDX}
+\`\`\`` : null;
+	const renderExampleItem = (headingLevel, headingTitle, body) => {
+		const prepared = prepareExampleContent(body);
+		const blocks = [`${headingLevel} ${headingTitle}`];
+		if (prepared.descriptionMD && prepared.descriptionMD.length) blocks.push(renderAstroPreviewsInMarkdown(prepared.descriptionMD));
+		if (prepared.snippet && prepared.snippet.length && prepared.sourceCode && prepared.sourceCode.length && !prepared.skipPreview) blocks.push(renderPreviewBlock(prepared.snippet, {
+			enableConsolePanel: prepared.enableConsolePanel,
+			consoleScripts: prepared.consoleScripts
+		}));
+		if (prepared.sourceCode && prepared.sourceCode.length) {
+			const sourceBlock = prepared.sourceFromFence ? prepared.sourceCode : `${(() => {
+				const lines = buildSnippetImportLines(prepared.sourceCode);
+				return lines.length ? `---\n${lines.join("\n")}\n---\n\n` : "";
+			})()}${prepared.sourceCode}`;
+			if (prepared.companionSourceMD && prepared.companionSourceMD.length && prepared.mergeCompanionWithSource) blocks.push(renderMergedAstroSourceMD("```astro", sourceBlock, prepared.companionSourceMD));
+			else blocks.push(`\`\`\`astro
+${sourceBlock}
+\`\`\``);
+			if (prepared.companionIntroMD && prepared.companionIntroMD.length && !prepared.mergeCompanionWithSource) blocks.push(prepared.companionIntroMD);
+			if (prepared.companionSourceMD && prepared.companionSourceMD.length && !prepared.mergeCompanionWithSource) blocks.push(renderCompanionSourceMD(prepared.companionSourceMD));
+			if (prepared.trailingDescriptionMD && prepared.trailingDescriptionMD.length) blocks.push(renderAstroPreviewsInMarkdown(prepared.trailingDescriptionMD));
+		}
+		return blocks.join("\n\n");
+	};
+	const renderedExampleSections = [];
+	if (examplesSections && examplesSections.length) {
+		let implicitExampleCounter = 1;
+		for (const section of examplesSections) {
+			const sectionParts = [];
+			const hasSectionTitle = !!(section.title && section.title.length);
+			if (hasSectionTitle) sectionParts.push(`### ${section.title}`);
+			if (section.introMD && section.introMD.length) sectionParts.push(renderAstroPreviewsInMarkdown(section.introMD));
+			if (section.items && section.items.length) {
+				const itemHeadingLevel = hasSectionTitle ? "####" : "###";
+				for (const item of section.items) sectionParts.push(renderExampleItem(itemHeadingLevel, item.title, item.body));
+			} else if (!hasSectionTitle && section.introMD && section.introMD.length) {
+				const prepared = prepareExampleContent(section.introMD);
+				if (prepared.snippet && prepared.snippet.length) {
+					sectionParts.length = 0;
+					sectionParts.push(renderExampleItem("###", `Example ${implicitExampleCounter}`, section.introMD));
+					implicitExampleCounter += 1;
+				}
+			}
+			if (sectionParts.length) renderedExampleSections.push(sectionParts.join("\n\n").trim());
+		}
+	}
+	if (examples && examples.length) for (const ex of examples) renderedExampleSections.push(`### ${ex.title}
+
+${missingFromSnippet(ex.source).length ? missingNotice(missingFromSnippet(ex.source)) : `<div class="not-content">
+  <${ex.importName} />
+</div>`}
+
+\`\`\`astro
+${ex.source}
+\`\`\``);
+	const formatDefault = (val) => {
+		if (val == null) return "";
+		let raw = String(val).trim();
+		if (!raw.length) return "";
+		raw = raw.replace(/[\u201C\u201D\u201E\u201F]/g, "\"").replace(/[\u2018\u2019]/g, "'");
+		const isSingleQuoted = /^'[^']*'$/.test(raw);
+		const isDoubleQuoted = /^"[^"]*"$/.test(raw);
+		const isBacktickSimple = /^`[^`]*`$/.test(raw) && raw.indexOf("${") === -1;
+		let content = raw;
+		if (isSingleQuoted || isDoubleQuoted || isBacktickSimple) content = `"${raw.slice(1, -1)}"`;
+		content = content.replace(/\|/g, "\\|");
+		const hasTick = content.includes("`");
+		const hasDoubleTick = content.includes("``");
+		const fence = !hasTick ? "`" : !hasDoubleTick ? "``" : "```";
+		return `${fence}${content}${fence}`;
+	};
+	const installationSection = `## Installation
+
+<DocsTabs syncKey="pkg">
+  <DocsTabItem label="bun">
+  \`\`\`bash
+  bunx bejamas add ${commandName}
+  \`\`\`
+  </DocsTabItem>
+  <DocsTabItem label="npm">
+  \`\`\`bash
+  npx bejamas add ${commandName}
+  \`\`\`
+  </DocsTabItem>
+  <DocsTabItem label="pnpm">
+  \`\`\`bash
+  pnpm dlx bejamas add ${commandName}
+  \`\`\`
+  </DocsTabItem>
+  <DocsTabItem label="yarn">
+  \`\`\`bash
+  yarn dlx bejamas add ${commandName}
+  \`\`\`
+  </DocsTabItem>
+</DocsTabs>`;
+	const serializeFrontmatter = (label, value) => {
+		if (!value || !value.length) return null;
+		return `${label}: ${JSON.stringify(value)}`;
+	};
+	return [
+		"---",
+		serializeFrontmatter("title", title),
+		serializeFrontmatter("description", description),
+		serializeFrontmatter("figmaUrl", figmaUrl),
+		"---",
+		"",
+		...importLines,
+		importLines.length ? "" : null,
+		renderedDescriptionBodyMDX && renderedDescriptionBodyMDX.length ? renderedDescriptionBodyMDX : null,
+		renderedDescriptionBodyMDX && renderedDescriptionBodyMDX.length ? "" : null,
+		primaryExampleSection,
+		primaryExampleSection ? "" : null,
+		installationSection,
+		"",
+		renderedUsageMDX && renderedUsageMDX.length ? `## Usage\n\n${renderedUsageMDX}` : null,
+		"",
+		propsTable && propsTable.length ? `## Props\n\n| Prop | Type | Default |\n|---|---|---|\n${propsTable.map((p) => `| <code>${p.name}</code> | \`${(p.type || "").replace(/\|/g, "\\|")}\` | ${formatDefault(p.defaultValue)} |`).join("\n")}` : propsList ? `## Props\n\n${propsList}` : null,
+		propsTable && propsTable.length || propsList ? "" : null,
+		renderedExampleSections.length ? `## Examples\n\n` + renderedExampleSections.join("\n\n") : null,
+		renderedExampleSections.length ? "" : null,
+		renderedApiMDX && renderedApiMDX.length ? `## API Reference\n\n${renderedApiMDX}` : null
+	].filter((v) => v !== null && v !== void 0).join("\n").trim() + "\n";
+}
+
+//#endregion
+//#region src/docs/generate-mdx/index.ts
+/**
+* Discover components in the components directory.
+* Supports both:
+* - Old pattern: flat .astro files in components/
+* - New pattern: folders with index.ts barrel exports
+*/
+async function discoverComponents(componentsDir) {
+	const entries = [];
+	const dirEntries = (await readdir(componentsDir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+	for (const entry of dirEntries) if (entry.isDirectory()) {
+		const folderPath = join(componentsDir, entry.name);
+		const indexPath = join(folderPath, "index.ts");
+		if (existsSync(indexPath)) {
+			const localExports = parseBarrelExports(await readFile(indexPath, "utf-8")).filter(({ file }) => dirname(join(folderPath, file)) === folderPath && existsSync(join(folderPath, file)));
+			const namedExports = localExports.map(({ name }) => name);
+			const mainComponentName = findMainComponent(namedExports, entry.name);
+			if (mainComponentName) {
+				const mainFilePath = join(folderPath, localExports.find(({ name }) => name === mainComponentName).file);
+				if (existsSync(mainFilePath)) {
+					const subComponents = namedExports.filter((n) => n !== mainComponentName);
+					entries.push({
+						name: mainComponentName,
+						filePath: mainFilePath,
+						folderName: entry.name,
+						isFolder: true,
+						namedExports: subComponents
+					});
+				}
+			}
+		}
+	} else if (entry.isFile() && extname(entry.name).toLowerCase() === ".astro") {
+		const componentName = entry.name.replace(/\.astro$/i, "");
+		entries.push({
+			name: componentName,
+			filePath: join(componentsDir, entry.name),
+			folderName: "",
+			isFolder: false,
+			namedExports: []
+		});
+	}
+	const nestedNames = new Set(entries.filter((entry) => entry.isFolder).map((entry) => entry.name));
+	return entries.filter((entry) => entry.isFolder || !nestedNames.has(entry.name));
+}
+function buildComponentFolderMap(components) {
+	const map = {};
+	for (const component of components) {
+		if (!component.isFolder) {
+			map[component.name] = `${component.name}.astro`;
+			continue;
+		}
+		if (!component.folderName) continue;
+		map[component.name] = component.folderName;
+		for (const sub of component.namedExports) map[sub] = component.folderName;
+	}
+	return map;
+}
+/**
+* Parse a barrel (index.ts) file to extract named exports.
+* Handles patterns like:
+* - export { default as Card } from "./Card.astro";
+* - export { default as CardHeader } from "./CardHeader.astro";
+*/
+function parseBarrelExports(content) {
+	const exports = [];
+	const exportRegex = /export\s*\{\s*default\s+as\s+(\w+)\s*\}\s*from\s*["'](\.\/[^"']+\.astro)["']/g;
+	let match;
+	while ((match = exportRegex.exec(content)) !== null) exports.push({
+		name: match[1],
+		file: match[2]
+	});
+	return exports;
+}
+/**
+* Find the main component from a list of exports.
+* The main component is typically the one that matches the folder name (PascalCase).
+*/
+function findMainComponent(exports, folderName) {
+	if (exports.length === 0) return null;
+	const expectedName = folderName.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+	const exactMatch = exports.find((e) => e === expectedName);
+	if (exactMatch) return exactMatch;
+	return exports[0];
+}
+async function main() {
+	const DEBUG = process.env.BEJAMAS_DEBUG === "1" || process.env.BEJAMAS_DEBUG === "true";
+	const cwd = process.env.BEJAMAS_DOCS_CWD && process.env.BEJAMAS_DOCS_CWD.length ? process.env.BEJAMAS_DOCS_CWD : process.cwd();
+	const config = await getConfig(cwd);
+	const componentsAlias = (config?.aliases?.ui || config?.aliases?.components || "@bejamas/ui/components").replace(/\/$/, "");
+	const componentsDirFromConfig = config?.resolvedPaths?.ui || config?.resolvedPaths?.components;
+	let uiRoot = componentsDirFromConfig ? dirname(dirname(componentsDirFromConfig)) : resolveUiRoot(cwd);
+	let componentsDir = join(uiRoot, "src", "components");
+	if (componentsDirFromConfig) {
+		componentsDir = componentsDirFromConfig;
+		uiRoot = dirname(dirname(componentsDirFromConfig));
+	}
+	if (!existsSync(componentsDir)) componentsDir = join(uiRoot, "src", "components");
+	const outDir = resolveOutDir(cwd);
+	mkdirSync(outDir, { recursive: true });
+	if (DEBUG) {
+		logger.info(`[docs-generator] cwd: ${cwd}`);
+		logger.info(`[docs-generator] uiRoot: ${uiRoot}`);
+		logger.info(`[docs-generator] componentsDir: ${componentsDir}`);
+		logger.info(`[docs-generator] outDir: ${outDir}`);
+	}
+	const components = await discoverComponents(componentsDir);
+	const componentFolderMap = buildComponentFolderMap(components);
+	const availableComponents = Object.keys(componentFolderMap);
+	const rewriteAliases = (source) => source.replace(/@bejamas\/ui\/components(?=[/"'])/g, componentsAlias).replace(/@bejamas\/(?:ui|registry)\/lib\/utils(?=["'])/g, config?.aliases?.utils ?? "@/lib/utils").replace(/@bejamas\/(?:ui|registry)\/lib(?=[/"'])/g, config?.aliases?.lib ?? "@/lib");
+	if (DEBUG) {
+		logger.info(`[docs-generator] components found: ${components.length}`);
+		if (components.length) logger.info(`[docs-generator] first few: ${components.slice(0, 5).map((c) => c.name).join(", ")}`);
+	}
+	let generatedCount = 0;
+	const total = components.length;
+	const spin = spinner(`Generating docs (0/${total})`).start();
+	for (const component of components) {
+		const { name: pascal, filePath, folderName, isFolder, namedExports } = component;
+		const astroFile = await readFile(filePath, "utf-8");
+		const frontmatterCode = extractFrontmatter(astroFile);
+		const sourceFile = createSourceFileFromFrontmatter(frontmatterCode);
+		const meta = parseJsDocMetadata(rewriteAliases(frontmatterCode));
+		const declaredProps = extractPropsFromDeclaredProps(sourceFile);
+		const destructuredProps = extractPropsFromAstroProps(sourceFile);
+		const defaultsMap = /* @__PURE__ */ new Map();
+		for (const p of destructuredProps) if (p.name && p.hasDefault) defaultsMap.set(p.name, p.defaultValue || null);
+		const propsTable = (declaredProps.length ? declaredProps : []).map((p) => ({
+			name: p.name,
+			type: p.type,
+			required: !p.optional,
+			defaultValue: defaultsMap.has(p.name) ? defaultsMap.get(p.name) : null
+		}));
+		const slug = slugify(pascal);
+		const title = meta.title || meta.name || pascal;
+		const description = meta.description || "";
+		const descriptionBodyMDX = meta.descriptionBodyMDX || "";
+		const figmaUrl = meta.figmaUrl || "";
+		const propsList = "";
+		const importName = pascal;
+		const importPath = isFolder ? `${componentsAlias}/${folderName}` : `${componentsAlias}/${pascal}.astro`;
+		const { text: usageMDX, hasImport: hasImportUsage } = normalizeUsageMDX(meta.usageMDX || "", pascal);
+		const primaryExampleMDX = normalizeBlockMDX(meta.primaryExampleMDX || "").trim();
+		const examplesMDX = normalizeBlockMDX(meta.examplesMDX || "").trim();
+		const apiMDX = normalizeBlockMDX(meta.apiMDX || "").trim();
+		const hasImportExamples = detectHasImportTopLevel(examplesMDX, pascal);
+		const hasImportPrimary = detectHasImportTopLevel(primaryExampleMDX, pascal);
+		const hasImport = hasImportUsage || hasImportExamples || hasImportPrimary;
+		let exampleRelPaths = [];
+		let examples = [];
+		const parsedExamplesSections = parseExamplesSections(examplesMDX);
+		if (parsedExamplesSections.length === 0) {
+			exampleRelPaths = await discoverExamples(filePath, componentsDir);
+			examples = (exampleRelPaths || []).map((rel) => {
+				const posixRel = rel.split(__require("path").sep).join(__require("path").posix.sep);
+				const importPathEx = `${componentsAlias}/${posixRel}`;
+				const abs = join(componentsDir, rel);
+				const source = rewriteAliases(__require("fs").readFileSync(abs, "utf-8"));
+				const base = toIdentifier(__require("path").basename(rel, __require("path").extname(rel)));
+				return {
+					importName: `${pascal}${base}`,
+					importPath: importPathEx,
+					title: base,
+					source
+				};
+			});
+		}
+		const usedInUsage = extractComponentTagsFromPreviewMarkdown(usageMDX, { defaultPreview: false }).filter((n) => n !== pascal);
+		const usedInDescription = extractComponentTagsFromPreviewMarkdown(descriptionBodyMDX).filter((n) => n !== pascal);
+		const usedInExamples = extractComponentTagsFromExamplesSections(parsedExamplesSections).filter((n) => n !== pascal);
+		const usedInPrimary = extractComponentTagsFromMDX(primaryExampleMDX).filter((n) => n !== pascal);
+		const usedInApi = extractComponentTagsFromPreviewMarkdown(apiMDX, {
+			defaultPreview: false,
+			allowForcedPreview: false
+		}).filter((n) => n !== pascal);
+		const autoSet = /* @__PURE__ */ new Set([
+			...usedInUsage,
+			...usedInDescription,
+			...usedInExamples,
+			...usedInPrimary,
+			...usedInApi
+		]);
+		const usedNamedExports = isFolder ? namedExports.filter((n) => autoSet.has(n)) : [];
+		if (isFolder) for (const n of namedExports) autoSet.delete(n);
+		const autoImports = Array.from(autoSet).filter((name) => !RESERVED_COMPONENTS.has(name));
+		const lucideIcons = autoImports.filter((n) => /Icon$/.test(n));
+		const uiAutoImports = autoImports.filter((n) => !/Icon$/.test(n));
+		const missingComponents = uiAutoImports.filter((name) => !availableComponents.includes(name));
+		if (missingComponents.length) logger.warn(`${slug}.mdx: previews require ${missingComponents.sort().join(", ")}; keeping their source examples without executing them.`);
+		const mdx = buildMdx({
+			importName,
+			importPath,
+			title,
+			description,
+			usageMDX,
+			hasImport,
+			propsList,
+			propsTable,
+			examples,
+			examplesSections: parsedExamplesSections,
+			componentFolderMap,
+			availableComponents,
+			autoImports: uiAutoImports,
+			lucideIcons,
+			primaryExampleMDX,
+			componentSource: astroFile.trim(),
+			commandName: slug,
+			figmaUrl,
+			descriptionBodyMDX,
+			componentsAlias,
+			namedExports: isFolder ? usedNamedExports : void 0,
+			apiMDX
+		});
+		const outFile = join(outDir, `${slug}.mdx`);
+		mkdirSync(dirname(outFile), { recursive: true });
+		await writeFile(outFile, mdx, "utf-8");
+		generatedCount += 1;
+		spin.text = `Generating docs (${generatedCount}/${total}) - ${title}`;
+		if (DEBUG) logger.info(`Generated ${outFile}`);
+	}
+	spin.succeed(`Created ${generatedCount} file${generatedCount === 1 ? "" : "s"}:`);
+	components.map((c) => {
+		const slug = slugify(c.name);
+		const outFile = join(outDir, `${slug}.mdx`);
+		return relative(cwd, outFile);
+	}).sort((a, b) => a.localeCompare(b)).forEach((p) => {
+		logger.log(`  - ${p}`);
+	});
+	logger.break();
+}
+async function runDocsGenerator() {
+	await main();
+}
+if (process.env.BEJAMAS_SKIP_AUTO_RUN !== "1" && process.env.BEJAMAS_SKIP_AUTO_RUN !== "true") runDocsGenerator().catch((err) => {
+	logger.error(String(err));
+	process.exit(1);
+});
+
+//#endregion
+export { runDocsGenerator };
+//# sourceMappingURL=generate-mdx-BSRQJPrF.js.map