bejamas 0.0.0-canary.0138fd3

package/dist/index.js

@@ -0,0 +1,3717 @@
+#!/usr/bin/env node
+import { $ as PRESET_RADII, A as getSemanticIconNameFromLucideExport, B as getHeadingFontValue, C as BASE_COLORS, D as buildRegistryTheme, E as ICON_LIBRARIES, F as designSystemConfigSchema, G as DEFAULT_PRESET_CONFIG, H as getStyleDefaultRadius, I as getDocumentDirection, J as PRESET_FONTS, K as PRESET_BASE_COLORS, L as getDocumentLanguage, M as renderSemanticIconSvgWithAttributeString, N as DEFAULT_DESIGN_SYSTEM_CONFIG, O as ICON_LIBRARY_COLLECTIONS, P as RTL_LANGUAGE_VALUES, Q as PRESET_MENU_COLORS, R as getFontPackageName, S as BEJAMAS_COMPONENTS_SCHEMA_URL, T as resolveRegistryUrl, U as getStyleId, V as getRadiusValue, W as normalizeDesignSystemConfig, X as PRESET_ICON_LIBRARIES, Y as PRESET_FONT_HEADINGS, Z as PRESET_MENU_ACCENTS, _ as getConfig, at as isPresetCode, b as logger, d as parseJsDocMetadata, et as PRESET_STYLES, g as spinner, it as encodePreset, j as getSemanticIconNameFromLucidePath, k as SEMANTIC_ICON_NAMES, nt as V1_CHART_COLOR_MAP, o as extractFrontmatter, ot as fonts, p as resolveUiRoot, q as PRESET_CHART_COLORS, rt as decodePreset, tt as PRESET_THEMES, v as getWorkspaceConfig, w as buildUiUrl, x as highlighter, y as getProjectInfo, z as getFontValue } from "./utils-Cxc_kZGv.js";
+import { Command } from "commander";
+import { createRequire } from "module";
+import path, { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { z } from "zod";
+import path$1 from "path";
+import { fileURLToPath } from "url";
+import { existsSync, promises, readFileSync, readdirSync } from "node:fs";
+import fs from "fs-extra";
+import fg from "fast-glob";
+import fs$1 from "node:fs/promises";
+import { bold, cyan, dim, green, magenta, red, white, yellow } from "kleur/colors";
+import os from "os";
+import dotenv from "dotenv";
+import { detect } from "@antfu/ni";
+import { execa } from "execa";
+import prompts from "prompts";
+import * as tar from "tar";
+import os$1 from "node:os";
+
+//#region src/registry/context.ts
+let context = { headers: {} };
+function clearRegistryContext() {
+	context.headers = {};
+}
+
+//#endregion
+//#region src/preflights/preflight-init.ts
+async function preFlightInit(options) {
+	const errors = {};
+	if (!fs.existsSync(options.cwd) || !fs.existsSync(path$1.resolve(options.cwd, "package.json"))) {
+		errors["1"] = true;
+		return {
+			errors,
+			projectInfo: null
+		};
+	}
+	return {
+		errors,
+		projectInfo: null
+	};
+}
+
+//#endregion
+//#region src/utils/astro-fonts.ts
+const ASTRO_CONFIG_BLOCK_START = "// bejamas:astro-fonts:start";
+const ASTRO_CONFIG_BLOCK_END = "// bejamas:astro-fonts:end";
+const ASTRO_LAYOUT_BLOCK_START = "<!-- bejamas:astro-fonts:start -->";
+const ASTRO_LAYOUT_BLOCK_END = "<!-- bejamas:astro-fonts:end -->";
+const ASTRO_FONT_CONSTANT = "BEJAMAS_ASTRO_FONTS";
+const ASTRO_CONFIG_CANDIDATES = [
+	"astro.config.mjs",
+	"apps/web/astro.config.mjs",
+	"apps/docs/astro.config.mjs"
+];
+const ASTRO_LAYOUT_CANDIDATES = ["src/layouts/Layout.astro", "apps/web/src/layouts/Layout.astro"];
+const STARLIGHT_HEAD_RELATIVE_PATH = "apps/docs/src/components/Head.astro";
+const ASTRO_FONT_PROVIDERS = ["fontsource", "google"];
+const ASTRO_FONTSOURCE_FONT_NAMES = /* @__PURE__ */ new Set(["geist", "geist-mono"]);
+const MANAGED_BODY_FONT_CLASSES = /* @__PURE__ */ new Set(["font-mono", "font-serif"]);
+function compactSource$1(source) {
+	return source.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function escapeRegExp$2(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function upsertImport(source, moduleName, importedName, fallbackNames = []) {
+	const importPattern = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeRegExp$2(moduleName)}["'];?`);
+	if (importPattern.test(source)) return source.replace(importPattern, (_match, importsSource) => {
+		const imports = importsSource.split(",").map((value) => value.trim()).filter(Boolean);
+		if (!imports.includes(importedName)) imports.push(importedName);
+		for (const name of fallbackNames) if (!imports.includes(name)) imports.unshift(name);
+		return `import { ${Array.from(new Set(imports)).join(", ")} } from "${moduleName}";`;
+	});
+	const importLine = `import { ${Array.from(/* @__PURE__ */ new Set([...fallbackNames, importedName])).join(", ")} } from "${moduleName}";`;
+	const frontmatterEnd = source.indexOf("---", 3);
+	if (source.startsWith("---") && frontmatterEnd !== -1) return `${source.slice(0, frontmatterEnd).trimEnd()}\n${importLine}\n${source.slice(frontmatterEnd)}`;
+	return `${importLine}\n${source}`;
+}
+function buildAstroConfigFontBlock(fontsToSerialize) {
+	const body = fontsToSerialize.length === 0 ? "" : `\n${fontsToSerialize.map((font) => `  {\n    provider: fontProviders.${font.provider}(),\n    name: ${JSON.stringify(font.name)},\n    cssVariable: ${JSON.stringify(font.cssVariable)},\n    subsets: ${JSON.stringify(font.subsets)},\n  },`).join("\n")}\n`;
+	return `${ASTRO_CONFIG_BLOCK_START}\n/** @type {NonNullable<import("astro").AstroUserConfig["fonts"]>} */\nconst ${ASTRO_FONT_CONSTANT} = [${body}];\n${ASTRO_CONFIG_BLOCK_END}`;
+}
+function buildAstroLayoutFontBlock(fontsToSerialize) {
+	const body = fontsToSerialize.map((font) => `<Font cssVariable="${font.cssVariable}" />`).join("\n");
+	return `${ASTRO_LAYOUT_BLOCK_START}\n${body}\n${ASTRO_LAYOUT_BLOCK_END}`;
+}
+function bodyFontClassFromCssVariable(cssVariable) {
+	if (cssVariable === "--font-mono" || cssVariable === "--font-serif") return fontClassFromCssVariable(cssVariable);
+	return "";
+}
+function upsertManagedBodyFontClass(source, cssVariable) {
+	const bodyClass = bodyFontClassFromCssVariable(cssVariable);
+	const bodyTagPattern = /<body\b([^>]*?)(\/?)>/m;
+	if (!bodyTagPattern.test(source)) return source;
+	return source.replace(bodyTagPattern, (_match, attrs, selfClosing) => {
+		const classPattern = /\sclass=(["'])(.*?)\1/m;
+		const classMatch = attrs.match(classPattern);
+		const quote = classMatch?.[1] ?? "\"";
+		const existingClasses = (classMatch?.[2] ?? "").split(/\s+/).filter(Boolean).filter((className) => !MANAGED_BODY_FONT_CLASSES.has(className));
+		const nextClasses = bodyClass ? Array.from(/* @__PURE__ */ new Set([...existingClasses, bodyClass])) : existingClasses;
+		let nextAttrs = attrs.replace(classPattern, "");
+		if (nextClasses.length > 0) nextAttrs = `${nextAttrs} class=${quote}${nextClasses.join(" ")}${quote}`;
+		return `<body${nextAttrs}${selfClosing}>`;
+	});
+}
+function parseManagedAstroFonts(source) {
+	const markerPattern = new RegExp(`${escapeRegExp$2(ASTRO_CONFIG_BLOCK_START)}[\\s\\S]*?const\\s+${ASTRO_FONT_CONSTANT}\\s*=\\s*\\[([\\s\\S]*?)\\];[\\s\\S]*?${escapeRegExp$2(ASTRO_CONFIG_BLOCK_END)}`);
+	const match = source.match(markerPattern);
+	if (!match) return [];
+	return (match[1].match(/\{[\s\S]*?\}/g) ?? []).map((entry) => {
+		const name = entry.match(/name:\s*"([^"]+)"/)?.[1];
+		const cssVariable = entry.match(/cssVariable:\s*"([^"]+)"/)?.[1];
+		const provider = entry.match(/provider:\s*fontProviders\.([a-z]+)\(\)/)?.[1];
+		const subsetsSource = entry.match(/subsets:\s*(\[[^\]]*\])/s)?.[1];
+		if (!name || !cssVariable || !provider || !ASTRO_FONT_PROVIDERS.includes(provider)) return null;
+		let subsets = ["latin"];
+		if (subsetsSource) try {
+			const parsed = JSON.parse(subsetsSource);
+			if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string")) subsets = parsed;
+		} catch {
+			subsets = ["latin"];
+		}
+		return {
+			name,
+			cssVariable,
+			provider,
+			subsets
+		};
+	}).filter((value) => value !== null);
+}
+function normalizeManagedAstroFontSubsets(subsets) {
+	if (!subsets?.length) return ["latin"];
+	return [subsets[0], ...subsets.slice(1)];
+}
+function replaceManagedBlock(source, nextBlock, start, end) {
+	const blockPattern = new RegExp(`${escapeRegExp$2(start)}[\\s\\S]*?${escapeRegExp$2(end)}`, "m");
+	if (blockPattern.test(source)) return source.replace(blockPattern, nextBlock);
+	return null;
+}
+function stripExperimentalFontsProperty(source) {
+	const experimentalMatch = source.match(/experimental\s*:\s*\{/);
+	if (!experimentalMatch || experimentalMatch.index === void 0) return source;
+	const propertyStart = experimentalMatch.index;
+	const openingBraceIndex = propertyStart + experimentalMatch[0].lastIndexOf("{");
+	let depth = 0;
+	let closingBraceIndex = -1;
+	let quote = null;
+	for (let index = openingBraceIndex; index < source.length; index += 1) {
+		const character = source[index];
+		const previousCharacter = index > 0 ? source[index - 1] : "";
+		if (quote) {
+			if (character === quote && previousCharacter !== "\\") quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") {
+			quote = character;
+			continue;
+		}
+		if (character === "{") {
+			depth += 1;
+			continue;
+		}
+		if (character === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				closingBraceIndex = index;
+				break;
+			}
+		}
+	}
+	if (closingBraceIndex === -1) return source;
+	const nextBlockContent = source.slice(openingBraceIndex + 1, closingBraceIndex).replace(/(^|\n)\s*fonts\s*:\s*BEJAMAS_ASTRO_FONTS\s*,?\s*(?=\n|$)/g, "$1").replace(/\n{3,}/g, "\n\n");
+	let propertyEnd = closingBraceIndex + 1;
+	while (propertyEnd < source.length && /\s/.test(source[propertyEnd])) propertyEnd += 1;
+	if (source[propertyEnd] === ",") propertyEnd += 1;
+	if (nextBlockContent.trim().length === 0) return `${source.slice(0, propertyStart)}${source.slice(propertyEnd)}`;
+	const rebuiltProperty = `experimental: {${nextBlockContent}\n  }`;
+	return `${source.slice(0, propertyStart)}${rebuiltProperty}${source.slice(closingBraceIndex + 1)}`;
+}
+function patchAstroConfigSource(source, fontsToSerialize, options = {}) {
+	let next = upsertImport(source, "astro/config", "fontProviders", ["defineConfig"]);
+	const fontBlock = buildAstroConfigFontBlock(fontsToSerialize);
+	const replacedBlock = replaceManagedBlock(next, fontBlock, ASTRO_CONFIG_BLOCK_START, ASTRO_CONFIG_BLOCK_END);
+	if (replacedBlock) next = replacedBlock;
+	else {
+		const lastImport = Array.from(next.matchAll(/^import .*$/gm)).at(-1);
+		if (lastImport?.index !== void 0) {
+			const insertAt = lastImport.index + lastImport[0].length;
+			next = `${next.slice(0, insertAt)}\n\n${fontBlock}${next.slice(insertAt)}`;
+		} else next = `${fontBlock}\n\n${next}`;
+	}
+	next = stripExperimentalFontsProperty(next);
+	if (!/^\s*fonts:\s*BEJAMAS_ASTRO_FONTS\b/m.test(next)) next = next.replace(/defineConfig\(\s*\{/, `defineConfig({\n  fonts: ${ASTRO_FONT_CONSTANT},`);
+	if (options.starlightHeadOverride) {
+		if (next.includes("Head: \"./src/components/Head.astro\"")) return compactSource$1(next);
+		const starlightComponentsPattern = /starlight\(\{\s*([\s\S]*?)components:\s*\{([\s\S]*?)\}/m;
+		if (starlightComponentsPattern.test(next)) next = next.replace(starlightComponentsPattern, (_match, before, inner) => `starlight({${before}components: {\n        Head: "./src/components/Head.astro",${inner ? `${inner}` : ""}\n      }`);
+		else next = next.replace(/starlight\(\s*\{/, `starlight({\n      components: {\n        Head: "./src/components/Head.astro",\n      },`);
+	}
+	return compactSource$1(next);
+}
+function patchAstroLayoutSource(source, fontsToSerialize, activeFontCssVariable) {
+	let next = upsertImport(source, "astro:assets", "Font");
+	const fontBlock = buildAstroLayoutFontBlock(fontsToSerialize);
+	const replacedBlock = replaceManagedBlock(next, fontBlock, ASTRO_LAYOUT_BLOCK_START, ASTRO_LAYOUT_BLOCK_END);
+	if (replacedBlock) next = replacedBlock;
+	else if (next.includes("<head>")) next = next.replace("<head>", `<head>\n    ${fontBlock.replace(/\n/g, "\n    ")}`);
+	else if (next.includes("</head>")) next = next.replace("</head>", `  ${fontBlock.replace(/\n/g, "\n  ")}\n</head>`);
+	else next = `${next}\n${fontBlock}\n`;
+	next = upsertManagedBodyFontClass(next, activeFontCssVariable);
+	return compactSource$1(next);
+}
+function patchStarlightHeadSource(source, fontsToSerialize) {
+	let next = upsertImport(source, "@astrojs/starlight/components/Head.astro", "DefaultHead");
+	next = upsertImport(next, "astro:assets", "Font");
+	const fontBlock = buildAstroLayoutFontBlock(fontsToSerialize);
+	const replacedBlock = replaceManagedBlock(next, fontBlock, ASTRO_LAYOUT_BLOCK_START, ASTRO_LAYOUT_BLOCK_END);
+	if (replacedBlock) next = replacedBlock;
+	else if (next.includes("<DefaultHead")) next = next.replace(/<DefaultHead[^>]*\/>/, (match) => `${match}\n${fontBlock}`);
+	else next = `${next.trimEnd()}\n\n<DefaultHead />\n${fontBlock}\n`;
+	return compactSource$1(next);
+}
+function toManagedAstroFont(fontName) {
+	const normalized = fontName.replace(/^font-heading-/, "").replace(/^font-/, "");
+	const font = fontName.startsWith("font-heading-") ? getHeadingFontValue(normalized) : getFontValue(normalized);
+	if (!font || font.type !== "registry:font" || !ASTRO_FONT_PROVIDERS.includes(font.font.provider)) return null;
+	return {
+		name: font.title?.replace(/\s+\(Heading\)$/, "") ?? font.font.import.replace(/_/g, " "),
+		cssVariable: font.font.variable,
+		provider: ASTRO_FONTSOURCE_FONT_NAMES.has(normalized) ? "fontsource" : "google",
+		subsets: normalizeManagedAstroFontSubsets(font.font.subsets)
+	};
+}
+function mergeManagedAstroFonts(currentFonts, nextFont) {
+	return [...currentFonts.filter((font) => font.cssVariable !== nextFont.cssVariable), nextFont].sort((left, right) => left.cssVariable.localeCompare(right.cssVariable));
+}
+function fontClassFromCssVariable(cssVariable) {
+	return `font-${cssVariable.replace(/^--font-/, "")}`;
+}
+async function patchFileIfExists(filePath, transformer) {
+	if (!await fs.pathExists(filePath)) return;
+	const current = await fs.readFile(filePath, "utf8");
+	const next = transformer(current);
+	if (next !== current) await fs.writeFile(filePath, next, "utf8");
+}
+async function collectPackageJsonsFromComponents(projectPath) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	const packageJsonFiles = /* @__PURE__ */ new Set();
+	for (const relativePath of componentJsonFiles) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		const cssPath = (await fs.readJson(absolutePath))?.tailwind?.css;
+		if (typeof cssPath !== "string" || cssPath.length === 0) continue;
+		let currentDir = path.dirname(path.resolve(path.dirname(absolutePath), cssPath));
+		while (true) {
+			const packageJsonPath = path.resolve(currentDir, "package.json");
+			if (await fs.pathExists(packageJsonPath)) {
+				packageJsonFiles.add(packageJsonPath);
+				break;
+			}
+			const parentDir = path.dirname(currentDir);
+			if (parentDir === currentDir) break;
+			currentDir = parentDir;
+		}
+	}
+	return packageJsonFiles;
+}
+async function upsertStarlightHeadFile(projectPath, fontsToSerialize) {
+	const headPath = path.resolve(projectPath, STARLIGHT_HEAD_RELATIVE_PATH);
+	const next = patchStarlightHeadSource(await fs.pathExists(headPath) ? await fs.readFile(headPath, "utf8") : "---\nimport DefaultHead from \"@astrojs/starlight/components/Head.astro\";\nimport { Font } from \"astro:assets\";\n---\n\n<DefaultHead />\n", fontsToSerialize);
+	await fs.ensureDir(path.dirname(headPath));
+	await fs.writeFile(headPath, next, "utf8");
+}
+async function readManagedAstroFontsFromProject(projectPath) {
+	for (const relativePath of ASTRO_CONFIG_CANDIDATES) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		if (!await fs.pathExists(absolutePath)) continue;
+		const parsed = parseManagedAstroFonts(await fs.readFile(absolutePath, "utf8"));
+		if (parsed.length > 0) return parsed;
+	}
+	return [];
+}
+async function cleanupAstroFontPackages(projectPath) {
+	const managedPackages = new Set(fonts.filter((font) => font.type === "registry:font").map((font) => getFontPackageName(font.name.replace(/^font-heading-/, "").replace(/^font-/, ""))));
+	const packageJsonFiles = await collectPackageJsonsFromComponents(projectPath);
+	await Promise.all(Array.from(packageJsonFiles).map(async (absolutePath) => {
+		const current = await fs.readJson(absolutePath);
+		let changed = false;
+		for (const bucket of ["dependencies", "devDependencies"]) {
+			const currentBucket = current[bucket];
+			if (!currentBucket || typeof currentBucket !== "object") continue;
+			for (const packageName of managedPackages) if (packageName in currentBucket) {
+				delete currentBucket[packageName];
+				changed = true;
+			}
+			if (Object.keys(currentBucket).length === 0) {
+				delete current[bucket];
+				changed = true;
+			}
+		}
+		if (changed) await fs.writeJson(absolutePath, current, { spaces: 2 });
+	}));
+}
+async function syncAstroFontsInProject(projectPath, fontsToSerialize, activeFontCssVariable) {
+	await Promise.all(ASTRO_CONFIG_CANDIDATES.map((relativePath) => patchFileIfExists(path.resolve(projectPath, relativePath), (source) => patchAstroConfigSource(source, fontsToSerialize, { starlightHeadOverride: relativePath === "apps/docs/astro.config.mjs" }))));
+	await Promise.all(ASTRO_LAYOUT_CANDIDATES.map((relativePath) => patchFileIfExists(path.resolve(projectPath, relativePath), (source) => patchAstroLayoutSource(source, fontsToSerialize, activeFontCssVariable))));
+	const docsConfigPath = path.resolve(projectPath, "apps/docs/astro.config.mjs");
+	if (await fs.pathExists(docsConfigPath)) await upsertStarlightHeadFile(projectPath, fontsToSerialize);
+}
+
+//#endregion
+//#region src/utils/apply-design-system.ts
+const CREATE_BLOCK_START = "/* bejamas:create:start */";
+const CREATE_BLOCK_END = "/* bejamas:create:end */";
+const SHADCN_TAILWIND_IMPORT = "@import \"shadcn/tailwind.css\";";
+const BEJAMAS_TAILWIND_IMPORT = "@import \"bejamas/tailwind.css\";";
+const MANAGED_TAILWIND_IMPORTS = /* @__PURE__ */ new Set([SHADCN_TAILWIND_IMPORT, BEJAMAS_TAILWIND_IMPORT]);
+const MANAGED_ICON_PACKAGES = new Set(ICON_LIBRARIES.map((library) => library.packageName));
+const FALLBACK_ICON_PACKAGE_VERSION = "latest";
+const TEMPLATE_APP_UI_IMPORT = "import { appUi } from \"@/i18n/ui\";";
+const TEMPLATE_I18N_SOURCES = {
+	astro: `const RTL_LANGUAGES = ["ar", "fa", "he"] as const;
+
+export type TemplateLanguage = "en" | (typeof RTL_LANGUAGES)[number];
+
+export const CURRENT_LANGUAGE: TemplateLanguage = "en";
+
+const ui = {
+  en: {
+    metadataTitle: "bejamas/ui Astro project",
+    welcomeMessage: "Welcome to {project} Astro project.",
+    getStartedMessage: "Get started by editing src/pages/index.astro.",
+    readDocs: "Read docs",
+    getCustomDemo: "Get custom demo",
+  },
+  ar: {
+    metadataTitle: "مشروع Astro من bejamas/ui",
+    welcomeMessage: "مرحبًا بك في مشروع Astro الخاص بـ {project}.",
+    getStartedMessage: "ابدأ بتحرير src/pages/index.astro.",
+    readDocs: "اقرأ التوثيق",
+    getCustomDemo: "احصل على عرض توضيحي مخصص",
+  },
+  fa: {
+    metadataTitle: "پروژه Astro با bejamas/ui",
+    welcomeMessage: "به پروژه Astro با {project} خوش آمدید.",
+    getStartedMessage: "برای شروع src/pages/index.astro را ویرایش کنید.",
+    readDocs: "مطالعه مستندات",
+    getCustomDemo: "درخواست دموی سفارشی",
+  },
+  he: {
+    metadataTitle: "פרויקט Astro עם bejamas/ui",
+    welcomeMessage: "ברוכים הבאים לפרויקט Astro של {project}.",
+    getStartedMessage: "התחילו בעריכת src/pages/index.astro.",
+    readDocs: "קריאת התיעוד",
+    getCustomDemo: "קבלת דמו מותאם",
+  },
+} as const satisfies Record<TemplateLanguage, Record<string, string>>;
+
+export const appUi = {
+  lang: CURRENT_LANGUAGE,
+  dir: RTL_LANGUAGES.includes(
+    CURRENT_LANGUAGE as (typeof RTL_LANGUAGES)[number],
+  )
+    ? "rtl"
+    : "ltr",
+  ...ui[CURRENT_LANGUAGE],
+};
+`,
+	monorepo: `const RTL_LANGUAGES = ["ar", "fa", "he"] as const;
+
+export type TemplateLanguage = "en" | (typeof RTL_LANGUAGES)[number];
+
+export const CURRENT_LANGUAGE: TemplateLanguage = "en";
+
+const ui = {
+  en: {
+    metadataTitle: "bejamas/ui Astro project",
+    welcomeMessage: "Welcome to {project} Astro monorepo.",
+    getStartedMessage: "Get started by editing apps/web/src/pages/index.astro.",
+    readDocs: "Read docs",
+    getCustomDemo: "Get custom demo",
+  },
+  ar: {
+    metadataTitle: "مشروع Astro من bejamas/ui",
+    welcomeMessage: "مرحبًا بك في مشروع Astro الأحادي من {project}.",
+    getStartedMessage: "ابدأ بتحرير apps/web/src/pages/index.astro.",
+    readDocs: "اقرأ التوثيق",
+    getCustomDemo: "احصل على عرض توضيحي مخصص",
+  },
+  fa: {
+    metadataTitle: "پروژه Astro با bejamas/ui",
+    welcomeMessage: "به مونوریپوی Astro با {project} خوش آمدید.",
+    getStartedMessage:
+      "برای شروع apps/web/src/pages/index.astro را ویرایش کنید.",
+    readDocs: "مطالعه مستندات",
+    getCustomDemo: "درخواست دموی سفارشی",
+  },
+  he: {
+    metadataTitle: "פרויקט Astro עם bejamas/ui",
+    welcomeMessage: "ברוכים הבאים למונורפו Astro של {project}.",
+    getStartedMessage: "התחילו בעריכת apps/web/src/pages/index.astro.",
+    readDocs: "קריאת התיעוד",
+    getCustomDemo: "קבלת דמו מותאם",
+  },
+} as const satisfies Record<TemplateLanguage, Record<string, string>>;
+
+export const appUi = {
+  lang: CURRENT_LANGUAGE,
+  dir: RTL_LANGUAGES.includes(
+    CURRENT_LANGUAGE as (typeof RTL_LANGUAGES)[number],
+  )
+    ? "rtl"
+    : "ltr",
+  ...ui[CURRENT_LANGUAGE],
+};
+`
+};
+const TEMPLATE_PAGE_VARIANTS = [
+	{
+		matchers: [
+			"import { Button } from \"@/ui/button\";",
+			"Astro project.",
+			"Get started by editing src/pages/index.astro."
+		],
+		i18nSource: `---
+import Layout from "@/layouts/Layout.astro";
+import { appUi } from "@/i18n/ui";
+import { Button } from "@/ui/button";
+
+const [welcomePrefix, welcomeSuffix = ""] =
+  appUi.welcomeMessage.split("{project}");
+---
+
+<Layout>
+  <div
+    class="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20"
+  >
+    <div class="flex flex-col gap-6 row-start-2 items-center sm:items-start">
+      <img src="/bejamas.svg" alt="bejamas/ui" class="w-8 dark:invert" />
+      <div class="space-y-2">
+        <p class="text-sm">
+          {welcomePrefix}<code
+            class="font-bold relative bg-muted rounded p-1"
+            >@bejamas/ui</code
+          >{welcomeSuffix}
+        </p>
+        <p class="text-sm">
+          {appUi.getStartedMessage}
+        </p>
+      </div>
+      <div class="flex gap-2">
+        <Button as="a" href="https://ui.bejamas.com/docs"
+          >{appUi.readDocs}</Button
+        >
+        <Button as="a" href="https://bejamas.com/get-in-touch" variant="outline"
+          >{appUi.getCustomDemo}</Button
+        >
+      </div>
+    </div>
+  </div>
+</Layout>
+`
+	},
+	{
+		matchers: [
+			"import { Button } from \"@repo/ui/components/button\";",
+			"width=\"32\"",
+			"Astro monorepo.",
+			"Get started by editing apps/web/src/pages/index.astro."
+		],
+		i18nSource: `---
+import Layout from "@/layouts/Layout.astro";
+import { appUi } from "@/i18n/ui";
+import { Button } from "@repo/ui/components/button";
+
+const [welcomePrefix, welcomeSuffix = ""] =
+  appUi.welcomeMessage.split("{project}");
+---
+
+<Layout>
+  <div
+    class="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20"
+  >
+    <div class="flex flex-col gap-6 row-start-2 items-center sm:items-start">
+      <img
+        src="/bejamas.svg"
+        alt="bejamas/ui"
+        class="w-8 dark:invert"
+        width="32"
+        height="32"
+        alt="bejamas/ui logo"
+      />
+      <div class="space-y-2">
+        <p class="text-sm">
+          {welcomePrefix}<code
+            class="font-bold relative bg-muted rounded p-1"
+            >@bejamas/ui</code
+          >{welcomeSuffix}
+        </p>
+        <p class="text-sm">
+          {appUi.getStartedMessage}
+        </p>
+      </div>
+      <div class="flex gap-2">
+        <Button as="a" href="https://ui.bejamas.com/docs"
+          >{appUi.readDocs}</Button
+        >
+        <Button as="a" href="https://bejamas.com/get-in-touch" variant="outline"
+          >{appUi.getCustomDemo}</Button
+        >
+      </div>
+    </div>
+  </div>
+</Layout>
+`
+	},
+	{
+		matchers: [
+			"import { Button } from \"@repo/ui/components/button\";",
+			"<img src=\"/bejamas.svg\" alt=\"bejamas/ui\" class=\"w-8 dark:invert\" />",
+			"Astro monorepo.",
+			"Get started by editing apps/web/src/pages/index.astro."
+		],
+		i18nSource: `---
+import Layout from "@/layouts/Layout.astro";
+import { appUi } from "@/i18n/ui";
+import { Button } from "@repo/ui/components/button";
+
+const [welcomePrefix, welcomeSuffix = ""] =
+  appUi.welcomeMessage.split("{project}");
+---
+
+<Layout>
+  <div
+    class="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20"
+  >
+    <div class="flex flex-col gap-6 row-start-2 items-center sm:items-start">
+      <img src="/bejamas.svg" alt="bejamas/ui" class="w-8 dark:invert" />
+      <div class="space-y-2">
+        <p class="text-sm">
+          {welcomePrefix}<code
+            class="font-bold relative bg-muted rounded p-1"
+            >@bejamas/ui</code
+          >{welcomeSuffix}
+        </p>
+        <p class="text-sm">
+          {appUi.getStartedMessage}
+        </p>
+      </div>
+      <div class="flex gap-2">
+        <Button as="a" href="https://ui.bejamas.com/docs"
+          >{appUi.readDocs}</Button
+        >
+        <Button as="a" href="https://bejamas.com/get-in-touch" variant="outline"
+          >{appUi.getCustomDemo}</Button
+        >
+      </div>
+    </div>
+  </div>
+</Layout>
+`
+	}
+];
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compactCss(source) {
+	return source.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function compactSource(source) {
+	return source.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function stripLegacyCreateBlock(source) {
+	const fullBlockPattern = new RegExp(`\\n*${escapeRegExp$1(CREATE_BLOCK_START)}[\\s\\S]*?${escapeRegExp$1(CREATE_BLOCK_END)}\\n*`, "m");
+	const danglingBlockPattern = new RegExp(`\\n*${escapeRegExp$1(CREATE_BLOCK_START)}[\\s\\S]*$`, "m");
+	return compactCss(source.replace(fullBlockPattern, "\n\n").replace(danglingBlockPattern, "\n\n"));
+}
+function buildCssVarBlock(selector, vars) {
+	return [
+		`${selector} {`,
+		...Object.entries(vars).map(([key, value]) => `  --${key}: ${value};`),
+		"}"
+	].join("\n");
+}
+function replaceTopLevelBlock(source, selector, nextBlock) {
+	const pattern = new RegExp(`^${escapeRegExp$1(selector)}\\s*\\{[\\s\\S]*?^\\}`, "m");
+	if (pattern.test(source)) return source.replace(pattern, nextBlock);
+	const layerIndex = source.indexOf("@layer base");
+	if (layerIndex !== -1) return `${source.slice(0, layerIndex).trimEnd()}\n\n${nextBlock}\n\n${source.slice(layerIndex).trimStart()}`;
+	return `${source.trimEnd()}\n\n${nextBlock}\n`;
+}
+function upsertImports(source, imports) {
+	const cleanedLines = source.split("\n").filter((line) => {
+		const trimmed = line.trim();
+		if (MANAGED_TAILWIND_IMPORTS.has(trimmed)) return false;
+		return !trimmed.startsWith("@import \"@fontsource-variable/");
+	});
+	let insertAt = -1;
+	for (let index = 0; index < cleanedLines.length; index += 1) {
+		if (cleanedLines[index].trim().startsWith("@import ")) {
+			insertAt = index;
+			continue;
+		}
+		if (insertAt !== -1 && cleanedLines[index].trim() !== "") break;
+	}
+	const uniqueImports = imports.filter((line, index) => imports.indexOf(line) === index);
+	if (insertAt === -1) return compactCss([
+		...uniqueImports,
+		"",
+		...cleanedLines
+	].join("\n"));
+	cleanedLines.splice(insertAt + 1, 0, ...uniqueImports);
+	return compactCss(cleanedLines.join("\n"));
+}
+function upsertManagedTailwindImport(source) {
+	const nextImport = resolveManagedTailwindImport(source);
+	const cleanedLines = source.split("\n").filter((line) => !MANAGED_TAILWIND_IMPORTS.has(line.trim()));
+	let insertAt = -1;
+	for (let index = 0; index < cleanedLines.length; index += 1) {
+		if (cleanedLines[index].trim().startsWith("@import ")) {
+			insertAt = index;
+			continue;
+		}
+		if (insertAt !== -1 && cleanedLines[index].trim() !== "") break;
+	}
+	if (insertAt === -1) return compactCss([
+		nextImport,
+		"",
+		...cleanedLines
+	].join("\n"));
+	cleanedLines.splice(insertAt + 1, 0, nextImport);
+	return compactCss(cleanedLines.join("\n"));
+}
+function resolveManagedTailwindImport(source) {
+	if (source.includes(SHADCN_TAILWIND_IMPORT)) return SHADCN_TAILWIND_IMPORT;
+	if (source.includes(BEJAMAS_TAILWIND_IMPORT)) return BEJAMAS_TAILWIND_IMPORT;
+	return BEJAMAS_TAILWIND_IMPORT;
+}
+function normalizeSourceForComparison(source) {
+	return source.replace(/\r\n/g, "\n").replace(/\s+/g, " ").trim();
+}
+function upsertFrontmatterImport(source, importLine) {
+	if (source.includes(importLine)) return source;
+	const frontmatterEnd = source.indexOf("\n---", 3);
+	if (source.startsWith("---\n") && frontmatterEnd !== -1) return `${source.slice(0, frontmatterEnd).trimEnd()}\n${importLine}${source.slice(frontmatterEnd)}`;
+	return `${importLine}\n${source}`;
+}
+function getTemplateI18nVariant(filepath) {
+	return filepath.includes(`${path.sep}apps${path.sep}web${path.sep}`) ? "monorepo" : "astro";
+}
+function buildTemplateI18nSource(variant, language) {
+	return compactSource(TEMPLATE_I18N_SOURCES[variant].replace("export const CURRENT_LANGUAGE: TemplateLanguage = \"en\";", `export const CURRENT_LANGUAGE: TemplateLanguage = "${language}";`));
+}
+function transformTemplateLayoutToI18n(source) {
+	if (source.includes(TEMPLATE_APP_UI_IMPORT)) return source;
+	let next = upsertFrontmatterImport(source, TEMPLATE_APP_UI_IMPORT);
+	next = next.replace(/<html([^>]*?)\slang=(\"[^\"]*\"|\{[^}]+\})([^>]*)>/, "<html$1$3>").replace(/<html([^>]*?)\sdir=(\"[^\"]*\"|\{[^}]+\})([^>]*)>/, "<html$1$3>");
+	next = next.replace(/<html([^>]*)>/, "<html$1 lang={appUi.lang} dir={appUi.dir}>");
+	next = next.replace(/<title>[\s\S]*?<\/title>/, "<title>{appUi.metadataTitle}</title>");
+	return compactSource(next);
+}
+function transformStarterPageToI18n(source) {
+	if (source.includes(TEMPLATE_APP_UI_IMPORT)) return source;
+	const normalized = normalizeSourceForComparison(source);
+	const match = TEMPLATE_PAGE_VARIANTS.find((variant) => variant.matchers.every((matcher) => normalized.includes(normalizeSourceForComparison(matcher))));
+	if (!match) return source;
+	return compactSource(match.i18nSource);
+}
+function upsertThemeInlineFont(source, fontVariable) {
+	const pattern = /@theme inline\s*\{[\s\S]*?\n\}/m;
+	if (!pattern.test(source)) {
+		const block = `@theme inline {\n${[fontVariable ? `  ${fontVariable}: var(${fontVariable});` : null, "  --font-heading: var(--font-heading);"].filter(Boolean).join("\n")}\n}`;
+		const customVariantIndex = source.indexOf("@custom-variant");
+		if (customVariantIndex !== -1) {
+			const nextLineIndex = source.indexOf("\n", customVariantIndex);
+			return `${source.slice(0, nextLineIndex + 1).trimEnd()}\n\n${block}\n\n${source.slice(nextLineIndex + 1).trimStart()}`;
+		}
+		return `${block}\n\n${source.trimStart()}`;
+	}
+	return source.replace(pattern, (block) => {
+		const withoutManagedFonts = block.replace(/\n\s*--font-(sans|serif|mono|heading):[^\n]+/g, "").replace(/\n\s*--bejamas-font-family:[^\n]+/g, "").replace(/@theme inline\s*\{\n?/, "@theme inline {\n");
+		const declarations = [fontVariable ? `  ${fontVariable}: var(${fontVariable});` : null, "  --font-heading: var(--font-heading);"].filter(Boolean).join("\n");
+		return withoutManagedFonts.replace("@theme inline {\n", `@theme inline {\n${declarations}\n`);
+	});
+}
+function upsertBaseLayerHtmlFont(source, fontClass) {
+	const pattern = /@layer base\s*\{[\s\S]*?\n\}/m;
+	if (!pattern.test(source)) return `${source.trimEnd()}\n\n@layer base {\n  .cn-font-heading {\n    @apply font-heading;\n  }\n  html {\n    @apply ${fontClass};\n  }\n}\n`;
+	return source.replace(pattern, (block) => {
+		return block.replace(/\n\s*html\s*\{[\s\S]*?\n\s*\}/m, "").replace(/\n\s*\.cn-font-heading\s*\{[\s\S]*?\n\s*\}/m, "").replace(/\n\}$/, `\n  .cn-font-heading {\n    @apply font-heading;\n  }\n  html {\n    @apply ${fontClass};\n  }\n}`);
+	});
+}
+function transformDesignSystemCss(source, config, themeVars) {
+	return transformDesignSystemFontCss(transformDesignSystemThemeCss(source, config, themeVars), config);
+}
+function transformDesignSystemThemeCss(source, config, themeVars) {
+	const effectiveThemeVars = themeVars ?? buildRegistryTheme(config).cssVars;
+	const rootVars = {
+		...Object.fromEntries(Object.entries(effectiveThemeVars.theme ?? {}).filter(([key]) => key !== "bejamas-font-family")),
+		...effectiveThemeVars.light ?? {}
+	};
+	const darkVars = { ...effectiveThemeVars.dark ?? {} };
+	const tailwindImport = resolveManagedTailwindImport(source);
+	let next = stripLegacyCreateBlock(source);
+	next = upsertImports(next, [tailwindImport]);
+	next = replaceTopLevelBlock(next, ":root", buildCssVarBlock(":root", rootVars));
+	next = replaceTopLevelBlock(next, ".dark", buildCssVarBlock(".dark", darkVars));
+	return compactCss(next);
+}
+function transformDesignSystemFontCss(source, config) {
+	const font = getFontValue(config.font);
+	const tailwindImport = resolveManagedTailwindImport(source);
+	let next = stripLegacyCreateBlock(source);
+	next = upsertImports(next, [tailwindImport]);
+	next = upsertThemeInlineFont(next, font?.font.variable);
+	if (font) next = upsertBaseLayerHtmlFont(next, fontClassFromCssVariable(font.font.variable));
+	return compactCss(next);
+}
+function transformAstroManagedFontCss(source, fontVariable) {
+	const tailwindImport = resolveManagedTailwindImport(source);
+	let next = stripLegacyCreateBlock(source);
+	next = upsertImports(next, [tailwindImport]);
+	next = upsertThemeInlineFont(next, fontVariable);
+	if (fontVariable) next = upsertBaseLayerHtmlFont(next, fontClassFromCssVariable(fontVariable));
+	return compactCss(next);
+}
+function transformManagedTailwindImportCss(source) {
+	return upsertManagedTailwindImport(source);
+}
+async function patchComponentsJson(filepath, config) {
+	const current = await fs.readJson(filepath);
+	const { rsc: _rsc, tsx: _tsx, ...normalizedCurrent } = current;
+	const next = {
+		...normalizedCurrent,
+		$schema: BEJAMAS_COMPONENTS_SCHEMA_URL,
+		style: getStyleId(config.style),
+		iconLibrary: config.iconLibrary,
+		rtl: config.rtl,
+		menuColor: config.menuColor,
+		menuAccent: config.menuAccent,
+		tailwind: {
+			...current.tailwind ?? {},
+			baseColor: config.baseColor,
+			cssVariables: true
+		}
+	};
+	await fs.writeJson(filepath, next, { spaces: 2 });
+}
+async function patchComponentsJsonWithTheme(filepath, config) {
+	await patchComponentsJson(filepath, config);
+}
+async function patchCssFileWithTheme(filepath, config, themeVars) {
+	const next = transformDesignSystemCss(await fs.readFile(filepath, "utf8"), config, themeVars);
+	await fs.writeFile(filepath, next, "utf8");
+}
+async function patchCssFileWithThemeOnly(filepath, config, themeVars) {
+	const next = transformDesignSystemThemeCss(await fs.readFile(filepath, "utf8"), config, themeVars);
+	await fs.writeFile(filepath, next, "utf8");
+}
+async function patchCssFileWithAstroFont(filepath, fontVariable) {
+	const next = transformAstroManagedFontCss(await fs.readFile(filepath, "utf8"), fontVariable);
+	await fs.writeFile(filepath, next, "utf8");
+}
+async function patchCssFileManagedTailwindImport(filepath) {
+	const next = transformManagedTailwindImportCss(await fs.readFile(filepath, "utf8"));
+	await fs.writeFile(filepath, next, "utf8");
+}
+function getSelectedIconPackageName(config) {
+	return ICON_LIBRARIES.find((library) => library.name === config.iconLibrary)?.packageName;
+}
+async function patchPackageJsonIconDependency(filepath, config) {
+	const selectedIconPackage = getSelectedIconPackageName(config);
+	if (!selectedIconPackage) return;
+	const packageJson = await fs.readJson(filepath);
+	let targetField = null;
+	let changed = false;
+	for (const field of ["dependencies", "devDependencies"]) {
+		const dependencies = packageJson[field];
+		if (!dependencies) continue;
+		for (const iconPackage of MANAGED_ICON_PACKAGES) {
+			if (!dependencies[iconPackage]) continue;
+			targetField ??= field;
+			if (iconPackage === selectedIconPackage) continue;
+			delete dependencies[iconPackage];
+			changed = true;
+		}
+	}
+	if (!targetField) return;
+	if (!(packageJson.dependencies?.[selectedIconPackage] || packageJson.devDependencies?.[selectedIconPackage])) {
+		packageJson[targetField] ??= {};
+		packageJson[targetField][selectedIconPackage] = FALLBACK_ICON_PACKAGE_VERSION;
+		changed = true;
+	}
+	if (changed) await fs.writeJson(filepath, packageJson, { spaces: 2 });
+}
+async function syncPackageIconDependencies(projectPath, config) {
+	const packageJsonFiles = await fg("**/package.json", {
+		cwd: projectPath,
+		absolute: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	await Promise.all(packageJsonFiles.map((filepath) => patchPackageJsonIconDependency(filepath, config)));
+}
+async function syncManagedTailwindCss(projectPath) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		absolute: true,
+		ignore: ["**/node_modules/**"]
+	});
+	await Promise.all(componentJsonFiles.map(async (componentJsonPath) => {
+		const cssRelativePath = (await fs.readJson(componentJsonPath))?.tailwind?.css;
+		if (typeof cssRelativePath !== "string" || cssRelativePath.length === 0) return;
+		const cssPath = path.resolve(path.dirname(componentJsonPath), cssRelativePath);
+		if (!await fs.pathExists(cssPath)) return;
+		await patchCssFileManagedTailwindImport(cssPath);
+	}));
+}
+async function syncAstroManagedFontCss(projectPath, fontVariable) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	const cssFiles = /* @__PURE__ */ new Set();
+	for (const relativePath of componentJsonFiles) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		const cssPath = (await fs.readJson(absolutePath))?.tailwind?.css;
+		if (typeof cssPath === "string" && cssPath.length > 0) cssFiles.add(path.resolve(path.dirname(absolutePath), cssPath));
+	}
+	await Promise.all(Array.from(cssFiles).map((filepath) => patchCssFileWithAstroFont(filepath, fontVariable)));
+}
+async function patchTemplateI18nFile(filepath, config) {
+	if (!config.rtl) return;
+	const nextLanguage = getDocumentLanguage(config);
+	const nextSource = buildTemplateI18nSource(getTemplateI18nVariant(filepath), nextLanguage);
+	if (!await fs.pathExists(filepath)) {
+		await fs.ensureDir(path.dirname(filepath));
+		await fs.writeFile(filepath, nextSource, "utf8");
+		return;
+	}
+	const current = await fs.readFile(filepath, "utf8");
+	const next = current.includes("export const CURRENT_LANGUAGE") ? current.replace(/export const CURRENT_LANGUAGE: TemplateLanguage = "[^"]+";/, `export const CURRENT_LANGUAGE: TemplateLanguage = "${nextLanguage}";`) : nextSource;
+	if (next !== current) await fs.writeFile(filepath, next, "utf8");
+}
+async function patchLayoutFile(filepath, config) {
+	if (!await fs.pathExists(filepath)) return;
+	const current = await fs.readFile(filepath, "utf8");
+	if (current.includes("from \"@/i18n/ui\"")) return;
+	if (config.rtl) {
+		const next = transformTemplateLayoutToI18n(current);
+		if (next !== current) await fs.writeFile(filepath, next, "utf8");
+		return;
+	}
+	const nextLanguage = getDocumentLanguage(config);
+	const nextDirection = getDocumentDirection(config);
+	let next = current.replace(/<html([^>]*?)lang="[^"]*"([^>]*)>/, "<html$1$2>").replace(/<html([^>]*?)dir="[^"]*"([^>]*)>/, "<html$1$2>");
+	next = next.replace(/<html([^>]*)>/, `<html$1 lang="${nextLanguage}"${config.rtl ? ` dir="${nextDirection}"` : ""}>`);
+	if (next !== current) await fs.writeFile(filepath, next, "utf8");
+}
+async function patchStarterPageFile(filepath, config) {
+	if (!config.rtl || !await fs.pathExists(filepath)) return;
+	const current = await fs.readFile(filepath, "utf8");
+	const next = transformStarterPageToI18n(current);
+	if (next !== current) await fs.writeFile(filepath, next, "utf8");
+}
+async function applyDesignSystemToProject(projectPath, config, options = {}) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	const cssFiles = /* @__PURE__ */ new Set();
+	for (const relativePath of componentJsonFiles) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		await patchComponentsJson(absolutePath, config);
+		const cssPath = (await fs.readJson(absolutePath))?.tailwind?.css;
+		if (typeof cssPath === "string" && cssPath.length > 0) {
+			const absoluteCssPath = path.resolve(path.dirname(absolutePath), cssPath);
+			cssFiles.add(absoluteCssPath);
+		}
+	}
+	await Promise.all(Array.from(cssFiles).map((filepath) => patchCssFileWithTheme(filepath, config, options.themeVars)));
+	await syncPackageIconDependencies(projectPath, config);
+	await Promise.all([path.resolve(projectPath, "src/i18n/ui.ts"), path.resolve(projectPath, "apps/web/src/i18n/ui.ts")].map((filepath) => patchTemplateI18nFile(filepath, config)));
+	await Promise.all([path.resolve(projectPath, "src/layouts/Layout.astro"), path.resolve(projectPath, "apps/web/src/layouts/Layout.astro")].map((filepath) => patchLayoutFile(filepath, config)));
+	await Promise.all([path.resolve(projectPath, "src/pages/index.astro"), path.resolve(projectPath, "apps/web/src/pages/index.astro")].map((filepath) => patchStarterPageFile(filepath, config)));
+	await syncDesignSystemFontsInProject(projectPath, config);
+}
+async function applyDesignSystemThemeToProject(projectPath, config, options = {}) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	const cssFiles = /* @__PURE__ */ new Set();
+	for (const relativePath of componentJsonFiles) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		await patchComponentsJsonWithTheme(absolutePath, config);
+		const cssPath = (await fs.readJson(absolutePath))?.tailwind?.css;
+		if (typeof cssPath === "string" && cssPath.length > 0) cssFiles.add(path.resolve(path.dirname(absolutePath), cssPath));
+	}
+	await Promise.all(Array.from(cssFiles).map((filepath) => patchCssFileWithThemeOnly(filepath, config, options.themeVars)));
+	await syncPackageIconDependencies(projectPath, config);
+}
+async function applyDesignSystemFontToProject(projectPath, config) {
+	await syncDesignSystemFontsInProject(projectPath, config);
+}
+async function syncDesignSystemFontsInProject(projectPath, config) {
+	const managedFonts = [toManagedAstroFont(config.font), config.fontHeading !== "inherit" ? toManagedAstroFont(`font-heading-${config.fontHeading}`) : null].filter((font) => font !== null);
+	const managedFont = managedFonts.find((font) => font.cssVariable !== "--font-heading");
+	if (managedFonts.length > 0 && managedFont) {
+		await syncAstroFontsInProject(projectPath, managedFonts, managedFont.cssVariable);
+		await syncAstroManagedFontCss(projectPath, managedFont.cssVariable);
+		await cleanupAstroFontPackages(projectPath);
+	}
+}
+
+//#endregion
+//#region src/utils/icon-transform.ts
+const FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---/;
+function rewriteAstroIcons(content, iconLibrary) {
+	if (!(iconLibrary in ICON_LIBRARY_COLLECTIONS)) return content;
+	const library = iconLibrary;
+	const shouldRewriteLucideImports = library !== "lucide";
+	const frontmatterMatch = content.match(FRONTMATTER_PATTERN);
+	if (!frontmatterMatch) return content;
+	let frontmatter = frontmatterMatch[1];
+	let body = content.slice(frontmatterMatch[0].length);
+	const iconUsages = [];
+	const semanticIconImports = [];
+	if (shouldRewriteLucideImports) {
+		frontmatter = frontmatter.replace(/^\s*import\s+([A-Za-z0-9_$]+)\s+from\s+["']@lucide\/astro\/icons\/([^"']+)["'];?\s*$/gm, (full, localName, iconPath) => {
+			const semanticName = getSemanticIconNameFromLucidePath(iconPath);
+			if (!semanticName) return full;
+			iconUsages.push({
+				localName,
+				semanticName
+			});
+			return "";
+		});
+		frontmatter = frontmatter.replace(/import\s+\{([^}]*)\}\s+from\s+["']@lucide\/astro["'];?/g, (full, importsBlock) => {
+			const keptImports = [];
+			for (const rawImport of importsBlock.split(",")) {
+				const trimmedImport = rawImport.trim();
+				if (!trimmedImport) continue;
+				const aliasMatch = trimmedImport.match(/^([A-Za-z0-9_$]+)(?:\s+as\s+([A-Za-z0-9_$]+))?$/);
+				if (!aliasMatch) {
+					keptImports.push(trimmedImport);
+					continue;
+				}
+				const [, importedName, localAlias] = aliasMatch;
+				const semanticName = getSemanticIconNameFromLucideExport(importedName);
+				if (!semanticName) {
+					keptImports.push(trimmedImport);
+					continue;
+				}
+				iconUsages.push({
+					localName: localAlias ?? importedName,
+					semanticName
+				});
+			}
+			if (!keptImports.length) return "";
+			return `import { ${keptImports.join(", ")} } from "@lucide/astro";`;
+		});
+	}
+	frontmatter = frontmatter.replace(/^\s*import\s+([A-Za-z0-9_$]+)\s+from\s+["'][^"']*SemanticIcon\.astro["'];?\s*$/gm, (_full, localName) => {
+		semanticIconImports.push(localName);
+		return "";
+	});
+	if (!iconUsages.length && !semanticIconImports.length) return content;
+	for (const { localName, semanticName } of iconUsages.sort((left, right) => right.localName.length - left.localName.length)) {
+		const selfClosingPattern = new RegExp(`<${localName}(\\s[^>]*?)?\\s*/>`, "g");
+		const pairedPattern = new RegExp(`<${localName}(\\s[^>]*?)?>([\\s\\S]*?)<\\/${localName}>`, "g");
+		body = body.replace(selfClosingPattern, (_full, attributeString = "") => renderSemanticIconSvgWithAttributeString(library, semanticName, attributeString));
+		body = body.replace(pairedPattern, (_full, attributeString = "") => renderSemanticIconSvgWithAttributeString(library, semanticName, attributeString));
+	}
+	for (const localName of semanticIconImports.sort((left, right) => right.length - left.length)) {
+		const selfClosingPattern = new RegExp(`<${localName}(\\s[^>]*?)?\\s*/>`, "g");
+		const pairedPattern = new RegExp(`<${localName}(\\s[^>]*?)?>([\\s\\S]*?)<\\/${localName}>`, "g");
+		body = body.replace(selfClosingPattern, (full, attributeString = "") => renderSemanticIconUsage(full, library, attributeString));
+		body = body.replace(pairedPattern, (full, attributeString = "") => renderSemanticIconUsage(full, library, attributeString));
+	}
+	return `---\n${frontmatter.split("\n").filter((line, index, lines) => {
+		if (line.trim().length > 0) return true;
+		return lines[index - 1]?.trim().length > 0;
+	}).join("\n").trim()}\n---${body}`;
+}
+function renderSemanticIconUsage(original, library, attributeString = "") {
+	const semanticName = attributeString.match(/\sname=(["'])([^"']+)\1/)?.[2];
+	if (!semanticName || !SEMANTIC_ICON_NAMES.includes(semanticName)) return original;
+	const normalizedAttributeString = attributeString.replace(/\sname=(["'])[^"']+\1/g, "").replace(/\slibrary=(["'])[^"']+\1/g, "").replace(/\sdata-icon-library=(["'])[^"']+\1/g, "").trim();
+	return renderSemanticIconSvgWithAttributeString(library, semanticName, normalizedAttributeString);
+}
+
+//#endregion
+//#region src/utils/menu-transform.ts
+const TRANSLUCENT_CLASSES = [
+	"animate-none!",
+	"relative",
+	"bg-popover/70",
+	"before:pointer-events-none",
+	"before:absolute",
+	"before:inset-0",
+	"before:-z-1",
+	"before:rounded-[inherit]",
+	"before:backdrop-blur-2xl",
+	"before:backdrop-saturate-150",
+	"**:data-[slot$=-item]:focus:bg-foreground/10",
+	"**:data-[slot$=-item]:data-highlighted:bg-foreground/10",
+	"**:data-[slot$=-separator]:bg-foreground/5",
+	"**:data-[slot$=-trigger]:focus:bg-foreground/10",
+	"**:data-[slot$=-trigger]:aria-expanded:bg-foreground/10!",
+	"**:data-[variant=destructive]:focus:bg-foreground/10!",
+	"**:data-[variant=destructive]:text-accent-foreground!",
+	"**:data-[variant=destructive]:**:text-accent-foreground!"
+];
+function transformMenuTokens(tokens, menuColor) {
+	const transformed = [];
+	for (const token of tokens) {
+		if (token === "cn-menu-target") {
+			if (menuColor === "inverted") transformed.push("dark");
+			else if (menuColor === "default-translucent") transformed.push(...TRANSLUCENT_CLASSES);
+			else if (menuColor === "inverted-translucent") transformed.push("dark", ...TRANSLUCENT_CLASSES);
+			continue;
+		}
+		if (token === "cn-menu-translucent") {
+			if (menuColor === "default-translucent" || menuColor === "inverted-translucent") transformed.push(...TRANSLUCENT_CLASSES);
+			continue;
+		}
+		transformed.push(token);
+	}
+	return Array.from(new Set(transformed));
+}
+function rewriteAstroMenus(content, menuColor) {
+	if (!content.includes("cn-menu-target") && !content.includes("cn-menu-translucent")) return content;
+	return content.replace(/(["'])([^"']*\bcn-menu-(?:target|translucent)\b[^"']*)\1/g, (_match, quote, classes) => {
+		return `${quote}${transformMenuTokens(String(classes).split(/\s+/).filter(Boolean), menuColor).join(" ")}${quote}`;
+	});
+}
+
+//#endregion
+//#region src/utils/astro-imports.ts
+function updateImportAliases(moduleSpecifier, config, isRemote = false) {
+	const scope = config.aliases.components.split("/")[0];
+	for (const [segment, alias] of [
+		["lib/utils", config.aliases.utils],
+		["lib", config.aliases.lib],
+		["hooks", config.aliases.hooks]
+	]) {
+		if (!alias) continue;
+		for (const prefix of [`@/${segment}`, `${scope}/${segment}`]) if (moduleSpecifier === prefix || moduleSpecifier.startsWith(`${prefix}/`)) return alias + moduleSpecifier.slice(prefix.length);
+	}
+	if (!moduleSpecifier.startsWith("@/") && !isRemote) return moduleSpecifier;
+	let specifier = moduleSpecifier;
+	if (isRemote && specifier.startsWith("@/")) specifier = specifier.replace(/^@\//, `@/registry/${config.style || "bejamas-juno"}/`);
+	if (!specifier.startsWith("@/registry/")) {
+		const alias = config.aliases.components.split("/")[0];
+		return specifier.replace(/^@\//, `${alias}/`);
+	}
+	if (specifier.match(/^@\/registry\/(.+)\/ui/)) return specifier.replace(/^@\/registry\/(.+)\/ui/, config.aliases.ui ?? `${config.aliases.components}/ui`);
+	if (config.aliases.components && specifier.match(/^@\/registry\/(.+)\/components/)) return specifier.replace(/^@\/registry\/(.+)\/components/, config.aliases.components);
+	if (config.aliases.lib && specifier.match(/^@\/registry\/(.+)\/lib/)) return specifier.replace(/^@\/registry\/(.+)\/lib/, config.aliases.lib);
+	if (config.aliases.hooks && specifier.match(/^@\/registry\/(.+)\/hooks/)) return specifier.replace(/^@\/registry\/(.+)\/hooks/, config.aliases.hooks);
+	return specifier.replace(/^@\/registry\/[^/]+/, config.aliases.components);
+}
+function rewriteAstroImports(content, config) {
+	let updated = content;
+	const utilsAlias = config.aliases?.utils;
+	const utilsImport = `${typeof utilsAlias === "string" && utilsAlias.includes("/") ? utilsAlias.split("/")[0] : "@"}/lib/utils`;
+	updated = updated.replace(/import\s+([\s\S]*?)\s+from\s+["']([^"']+)["']/g, (full, importsPart, specifier) => {
+		const next = updateImportAliases(specifier, config, false);
+		let finalSpec = next;
+		if (typeof importsPart === "string" && importsPart.split(/[{},\s]/).some((part) => part === "cn") && config.aliases.utils && (next === utilsImport || next === "@/lib/utils")) finalSpec = utilsImport === next ? next.replace(utilsImport, config.aliases.utils) : config.aliases.utils;
+		if (finalSpec === specifier) return full;
+		return full.replace(specifier, finalSpec);
+	});
+	updated = updated.replace(/(?:export\s+(?:type\s+)?(?:\{[^}]*\}|\*)\s+from\s*|import\s*\(\s*)["']([^"']+)["']/g, (full, specifier) => full.replace(specifier, updateImportAliases(specifier, config)));
+	updated = updated.replace(/import\s+["']([^"']+)["']/g, (full, specifier) => {
+		const next = updateImportAliases(specifier, config, false);
+		if (next === specifier) return full;
+		return full.replace(specifier, next);
+	});
+	updated = rewriteAstroMenus(updated, config.menuColor);
+	return rewriteAstroIcons(updated, config.iconLibrary);
+}
+async function fixAstroImports(cwd, isVerbose, targetConfig) {
+	const config = targetConfig ?? await getConfig(cwd);
+	if (!config) return;
+	const searchRoots = /* @__PURE__ */ new Set([
+		config.resolvedPaths.components,
+		config.resolvedPaths.ui,
+		config.resolvedPaths.lib,
+		config.resolvedPaths.hooks
+	]);
+	for (const root of Array.from(searchRoots)) {
+		if (!root) continue;
+		const astroFiles = await fg("**/*.{astro,ts,js}", {
+			cwd: root,
+			absolute: true,
+			dot: false
+		});
+		for (const filePath of astroFiles) {
+			const original = await fs$1.readFile(filePath, "utf8");
+			const rewritten = rewriteAstroImports(original, config);
+			if (rewritten === original) continue;
+			await fs$1.writeFile(filePath, rewritten, "utf8");
+			if (isVerbose) logger.info(`[bejamas-ui] fixed imports in ${path.relative(cwd, filePath)}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/utils/get-package-manager.ts
+async function getPackageManager(targetDir, { withFallback } = { withFallback: false }) {
+	const packageManager = await detect({
+		programmatic: true,
+		cwd: targetDir
+	});
+	if (packageManager === "yarn@berry") return "yarn";
+	if (packageManager === "pnpm@6") return "pnpm";
+	if (packageManager === "bun") return "bun";
+	if (packageManager === "deno") return "deno";
+	if (!withFallback) return packageManager ?? "npm";
+	const userAgent = process.env.npm_config_user_agent || "";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("bun")) return "bun";
+	return "npm";
+}
+
+//#endregion
+//#region src/registry/errors.ts
+const RegistryErrorCode = {
+	NETWORK_ERROR: "NETWORK_ERROR",
+	NOT_FOUND: "NOT_FOUND",
+	UNAUTHORIZED: "UNAUTHORIZED",
+	FORBIDDEN: "FORBIDDEN",
+	FETCH_ERROR: "FETCH_ERROR",
+	NOT_CONFIGURED: "NOT_CONFIGURED",
+	INVALID_CONFIG: "INVALID_CONFIG",
+	MISSING_ENV_VARS: "MISSING_ENV_VARS",
+	LOCAL_FILE_ERROR: "LOCAL_FILE_ERROR",
+	PARSE_ERROR: "PARSE_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var RegistryError = class extends Error {
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "RegistryError";
+		this.code = options.code || RegistryErrorCode.UNKNOWN_ERROR;
+		this.statusCode = options.statusCode;
+		this.cause = options.cause;
+		this.context = options.context;
+		this.suggestion = options.suggestion;
+		this.timestamp = /* @__PURE__ */ new Date();
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			statusCode: this.statusCode,
+			context: this.context,
+			suggestion: this.suggestion,
+			timestamp: this.timestamp,
+			stack: this.stack
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/handle-error.ts
+function handleError(error) {
+	logger.break();
+	logger.error(`Something went wrong. Please check the error below for more details.`);
+	logger.error(`If the problem persists, please open an issue on GitHub: https://github.com/bejamas/ui/issues`);
+	logger.error("");
+	if (typeof error === "string") {
+		logger.error(error);
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof RegistryError) {
+		if (error.message) {
+			logger.error(error.cause ? "Error:" : "Message:");
+			logger.error(error.message);
+		}
+		if (error.cause) {
+			logger.error("\nMessage:");
+			logger.error(error.cause);
+		}
+		if (error.suggestion) {
+			logger.error("\nSuggestion:");
+			logger.error(error.suggestion);
+		}
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof z.ZodError) {
+		logger.error("Validation failed:");
+		for (const [key, value] of Object.entries(error.flatten().fieldErrors)) logger.error(`- ${highlighter.info(key)}: ${value}`);
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof Error) {
+		logger.error(error.message);
+		logger.break();
+		process.exit(1);
+	}
+	logger.break();
+	process.exit(1);
+}
+
+//#endregion
+//#region src/utils/create-project.ts
+const TEMPLATES = {
+	astro: "astro",
+	"astro-monorepo": "astro-monorepo",
+	"astro-with-component-docs-monorepo": "astro-with-component-docs-monorepo"
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path$1.dirname(__filename);
+const TEMPLATE_DIRNAME = {
+	astro: "astro",
+	"astro-monorepo": "monorepo-astro",
+	"astro-with-component-docs-monorepo": "monorepo-astro-with-docs"
+};
+const TEMPLATE_EXCLUDED_BASENAMES = /* @__PURE__ */ new Set(["node_modules", ".astro"]);
+const DEFAULT_TEMPLATE_REPOSITORY = "bejamas/ui";
+const DEFAULT_TEMPLATE_REF = "main";
+function resolveLocalTemplatesDir(env = process.env) {
+	const override = env.BEJAMAS_LOCAL_TEMPLATES_DIR?.trim();
+	if (override) return path$1.resolve(override);
+	for (const relativePath of [
+		"../../../../templates",
+		"../../../templates",
+		"../../templates"
+	]) {
+		const candidate = path$1.resolve(__dirname, relativePath);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return path$1.resolve(__dirname, "../../../../templates");
+}
+const LOCAL_TEMPLATES_DIR = resolveLocalTemplatesDir();
+function resolvePackageMetadataPath() {
+	for (const relativePath of ["../package.json", "../../package.json"]) {
+		const candidate = path$1.resolve(__dirname, relativePath);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return path$1.resolve(__dirname, "../package.json");
+}
+function readPackageMetadata() {
+	try {
+		return fs.readJsonSync(resolvePackageMetadataPath());
+	} catch {
+		return {};
+	}
+}
+const BEJAMAS_PACKAGE_METADATA = readPackageMetadata();
+function shouldCopyTemplateEntry(source) {
+	return !TEMPLATE_EXCLUDED_BASENAMES.has(path$1.basename(source));
+}
+async function copyTemplateIntoProject(templateSource, projectPath) {
+	await fs.copy(templateSource, projectPath, { filter: shouldCopyTemplateEntry });
+}
+function resolveRemoteTemplateRefs(metadata = BEJAMAS_PACKAGE_METADATA, env = process.env) {
+	const refs = [
+		env.BEJAMAS_TEMPLATE_REF?.trim(),
+		metadata.gitHead?.trim(),
+		metadata.version && !metadata.version.includes("-") ? `bejamas@${metadata.version}` : void 0,
+		DEFAULT_TEMPLATE_REF
+	].filter((ref) => Boolean(ref));
+	return [...new Set(refs)];
+}
+function buildTemplateArchiveUrl(ref, repository = DEFAULT_TEMPLATE_REPOSITORY) {
+	return `https://api.github.com/repos/${repository}/tarball/${encodeURIComponent(ref)}`;
+}
+function getGitHubRequestHeaders(env = process.env) {
+	const headers = { "User-Agent": `bejamas/${BEJAMAS_PACKAGE_METADATA.version ?? "dev"}` };
+	const token = env.BEJAMAS_GITHUB_TOKEN?.trim() || env.GITHUB_TOKEN?.trim();
+	if (token) headers.Authorization = `Bearer ${token}`;
+	return headers;
+}
+async function downloadTemplateArchive(ref, targetDir) {
+	const archiveUrl = buildTemplateArchiveUrl(ref);
+	const archivePath = path$1.join(targetDir, "repo.tar.gz");
+	const response = await fetch(archiveUrl, {
+		headers: getGitHubRequestHeaders(),
+		signal: AbortSignal.timeout(3e4)
+	});
+	if (!response.ok) throw new Error(`GitHub returned ${response.status} ${response.statusText} for ${ref}.`);
+	await fs.ensureDir(targetDir);
+	await fs.outputFile(archivePath, Buffer.from(await response.arrayBuffer()));
+	await tar.x({
+		cwd: targetDir,
+		file: archivePath,
+		strict: true
+	});
+	const extractedRoot = (await fs.readdir(targetDir)).filter((entry) => entry !== "repo.tar.gz").find((entry) => fs.statSync(path$1.join(targetDir, entry)).isDirectory());
+	if (!extractedRoot) throw new Error(`Downloaded archive for ${ref} did not extract correctly.`);
+	return path$1.join(targetDir, extractedRoot);
+}
+async function copyTemplateFromGitHub(templateDirName, projectPath) {
+	const refs = resolveRemoteTemplateRefs();
+	const failures = [];
+	for (const ref of refs) {
+		const tempDir = path$1.join(os.tmpdir(), `bejamas-template-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+		try {
+			const extractedRoot = await downloadTemplateArchive(ref, tempDir);
+			const templateSource = path$1.join(extractedRoot, "templates", templateDirName);
+			if (!await fs.pathExists(templateSource)) throw new Error(`Template templates/${templateDirName} was not found.`);
+			await copyTemplateIntoProject(templateSource, projectPath);
+			return ref;
+		} catch (error) {
+			failures.push(`${ref}: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			await fs.remove(tempDir);
+		}
+	}
+	throw new Error([
+		`Unable to download templates/${templateDirName} from GitHub.`,
+		`Tried refs: ${refs.join(", ")}.`,
+		failures.join("\n")
+	].join("\n"));
+}
+async function applyLocalPackageOverrides(projectPath) {
+	const bejamasPackageOverride = process.env.BEJAMAS_PACKAGE_OVERRIDE;
+	if (!bejamasPackageOverride) return;
+	const packageJsonPaths = await fg("**/package.json", {
+		cwd: projectPath,
+		absolute: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const normalizedOverride = bejamasPackageOverride.replace(/\\/g, "/");
+	await Promise.all(packageJsonPaths.map(async (packageJsonPath) => {
+		const packageJson = await fs.readJson(packageJsonPath);
+		let changed = false;
+		for (const field of ["dependencies", "devDependencies"]) if (packageJson[field]?.bejamas) {
+			packageJson[field].bejamas = `file:${normalizedOverride}`;
+			changed = true;
+		}
+		if (changed) await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}));
+}
+async function createProject(options) {
+	options = {
+		srcDir: false,
+		...options
+	};
+	let template = options.template && TEMPLATES[options.template] ? options.template : "astro";
+	let projectName = "my-app";
+	const isRemoteComponent = options.components?.length === 1 && !!options.components[0].match(/\/chat\/b\//);
+	if (!options.force) {
+		const { type, name } = await prompts([{
+			type: options.template || isRemoteComponent ? null : "select",
+			name: "type",
+			message: `The path ${highlighter.info(options.cwd)} does not contain a package.json file.\n  Would you like to start a new project?`,
+			choices: [
+				{
+					title: "Astro",
+					value: "astro"
+				},
+				{
+					title: "Astro (Monorepo)",
+					value: "astro-monorepo"
+				},
+				{
+					title: "Astro with Component Docs (Monorepo)",
+					value: "astro-with-component-docs-monorepo"
+				}
+			],
+			initial: 0
+		}, {
+			type: "text",
+			name: "name",
+			message: "What is your project named?",
+			initial: (_prev, values) => {
+				return (options.template && TEMPLATES[options.template] && options.template || values.type || template)?.endsWith("monorepo") ? "my-monorepo" : "my-app";
+			},
+			format: (value) => value.trim(),
+			validate: (value) => value.length > 128 ? `Name should be less than 128 characters.` : true
+		}]);
+		template = type ?? template;
+		projectName = name;
+	}
+	const packageManager = await getPackageManager(options.cwd, { withFallback: true });
+	const projectPath = `${options.cwd}/${projectName}`;
+	try {
+		await fs.access(options.cwd, fs.constants.W_OK);
+	} catch (error) {
+		logger.break();
+		logger.error(`The path ${highlighter.info(options.cwd)} is not writable.`);
+		logger.error(`It is likely you do not have write permissions for this folder or the path ${highlighter.info(options.cwd)} does not exist.`);
+		logger.break();
+		process.exit(1);
+	}
+	if (fs.existsSync(path$1.resolve(options.cwd, projectName, "package.json"))) {
+		logger.break();
+		logger.error(`A project with the name ${highlighter.info(projectName)} already exists.`);
+		logger.error(`Please choose a different name and try again.`);
+		logger.break();
+		process.exit(1);
+	}
+	await createProjectFromTemplate(projectPath, {
+		templateKey: template,
+		packageManager,
+		cwd: options.cwd
+	});
+	return {
+		projectPath,
+		projectName,
+		template
+	};
+}
+async function createProjectFromTemplate(projectPath, options) {
+	const createSpinner = spinner(`Creating a new project from template. This may take a few minutes.`).start();
+	try {
+		dotenv.config({ quiet: true });
+		const templateDirName = TEMPLATE_DIRNAME[options.templateKey];
+		const templateSource = path$1.resolve(LOCAL_TEMPLATES_DIR, templateDirName);
+		if (await fs.pathExists(templateSource)) await copyTemplateIntoProject(templateSource, projectPath);
+		else {
+			createSpinner.text = `Downloading the ${highlighter.info(options.templateKey)} template from GitHub.`;
+			await copyTemplateFromGitHub(templateDirName, projectPath);
+		}
+		await removeEmptyTemplateI18nDirs(projectPath);
+		await applyLocalPackageOverrides(projectPath);
+		await execa(options.packageManager, ["install"], { cwd: projectPath });
+		try {
+			const { stdout } = await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectPath });
+			if (!(stdout.trim() === "true")) {
+				await execa("git", ["init"], { cwd: projectPath });
+				await execa("git", ["add", "-A"], { cwd: projectPath });
+				await execa("git", [
+					"commit",
+					"-m",
+					"Initial commit"
+				], { cwd: projectPath });
+			}
+		} catch (_) {}
+		createSpinner?.succeed("Creating a new project from template.");
+	} catch (error) {
+		createSpinner?.fail("Something went wrong creating a new project from template.");
+		handleError(error);
+	}
+}
+async function removeEmptyTemplateI18nDirs(projectPath) {
+	const candidates = [path$1.resolve(projectPath, "src/i18n"), path$1.resolve(projectPath, "apps/web/src/i18n")];
+	await Promise.all(candidates.map(async (candidate) => {
+		if (!await fs.pathExists(candidate)) return;
+		if ((await fs.readdir(candidate)).length === 0) await fs.remove(candidate);
+	}));
+}
+
+//#endregion
+//#region src/utils/installed-ui-components.ts
+function toRegistryName(filename) {
+	return filename.replace(/\.[^.]+$/, "").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+async function pathExists$1(filepath) {
+	try {
+		await promises.access(filepath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectInstalledUiComponents(uiDir) {
+	if (!await pathExists$1(uiDir)) return [];
+	const entries = await promises.readdir(uiDir, { withFileTypes: true });
+	const components = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) continue;
+		const entryPath = path.resolve(uiDir, entry.name);
+		if (entry.isDirectory()) {
+			if ((await promises.readdir(entryPath, { withFileTypes: true })).some((child) => child.isFile() && (/\.(astro|tsx|jsx)$/.test(child.name) || /^(index\.(ts|js|tsx|jsx))$/.test(child.name)))) components.add(entry.name);
+			continue;
+		}
+		if (entry.isFile() && /\.(astro|tsx|jsx)$/.test(entry.name) && !entry.name.startsWith("index.")) components.add(toRegistryName(entry.name));
+	}
+	return Array.from(components).sort();
+}
+async function getInstalledUiComponents(cwd) {
+	const config = await getConfig(cwd);
+	if (!config) return [];
+	return detectInstalledUiComponents(config.resolvedPaths.ui);
+}
+
+//#endregion
+//#region src/utils/reorganize-components.ts
+async function fetchRegistryItem(componentName, registryUrl, style = "bejamas-juno") {
+	const url = `${registryUrl}/styles/${style}/${componentName}.json`;
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			const fallbackUrl = `${registryUrl}/${componentName}.json`;
+			const fallbackResponse = await fetch(fallbackUrl);
+			if (!fallbackResponse.ok) return null;
+			return await fallbackResponse.json();
+		}
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+function getSubfolderFromPaths(files) {
+	if (!files || files.length === 0) return null;
+	const uiFiles = files.filter((file) => file.type === "registry:ui");
+	if (uiFiles.length === 0) return null;
+	const subfolders = /* @__PURE__ */ new Set();
+	for (const file of uiFiles) {
+		const parts = file.path.split("/");
+		const uiIndex = parts.indexOf("ui");
+		if (uiIndex !== -1 && parts.length > uiIndex + 2) subfolders.add(parts[uiIndex + 1]);
+	}
+	if (subfolders.size === 1) return Array.from(subfolders)[0];
+	if (uiFiles.length > 0) {
+		const dirname = path.dirname(uiFiles[0].path);
+		const folderName = path.basename(dirname);
+		if (folderName && folderName !== "ui") return folderName;
+	}
+	return null;
+}
+async function pathExists(filePath) {
+	try {
+		await fs$1.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveShadcnUiRelativePath(filePath, uiDir) {
+	const normalizedFilePath = filePath.replace(/^\/|\/$/g, "");
+	const lastTargetSegment = path.basename(uiDir.replace(/^\/|\/$/g, ""));
+	if (!lastTargetSegment) return path.basename(normalizedFilePath);
+	const fileSegments = normalizedFilePath.split("/");
+	const commonDirIndex = fileSegments.findIndex((segment) => segment === lastTargetSegment);
+	if (commonDirIndex === -1) return fileSegments[fileSegments.length - 1];
+	return fileSegments.slice(commonDirIndex + 1).join("/");
+}
+/**
+* Current upstream shadcn workspace installs flatten `ui/foo/Bar.astro` when
+* the resolved ui target ends in a segment like `components` instead of `ui`.
+* We keep reorganization only for that compatibility case.
+*/
+function shouldReorganizeRegistryUiFiles(files, uiDir) {
+	if (!uiDir) return false;
+	if (!getSubfolderFromPaths(files)) return false;
+	return (files ?? []).filter((file) => file.type === "registry:ui").some((file) => {
+		return !resolveShadcnUiRelativePath(file.path, uiDir).includes("/");
+	});
+}
+/**
+* Reorganizes one multi-file registry:ui item from flat output into its
+* expected subfolder. This is the filesystem-level compatibility shim.
+*/
+async function reorganizeRegistryUiFiles(files, uiDir, verbose, overwriteExisting = false) {
+	const result = {
+		totalMoved: 0,
+		movedFiles: [],
+		skippedFiles: []
+	};
+	if (!uiDir || !files || files.length === 0) return result;
+	const subfolder = getSubfolderFromPaths(files);
+	if (!subfolder) return result;
+	const uiFiles = files.filter((file) => file.type === "registry:ui");
+	const targetDir = path.join(uiDir, subfolder);
+	for (const file of uiFiles) {
+		const filename = path.basename(file.path);
+		if (filename === "index.ts") continue;
+		const flatPath = path.join(uiDir, filename);
+		const targetPath = path.join(targetDir, filename);
+		if (!await pathExists(flatPath)) continue;
+		if (await pathExists(targetPath)) {
+			if (overwriteExisting) {
+				await fs$1.mkdir(targetDir, { recursive: true });
+				await fs$1.unlink(targetPath);
+				await fs$1.rename(flatPath, targetPath);
+				result.totalMoved++;
+				result.movedFiles.push(`${subfolder}/${filename}`);
+				if (verbose) logger.info(`[bejamas-ui] Replaced ${subfolder}/${filename} with the reinstalled version`);
+				continue;
+			}
+			try {
+				await fs$1.unlink(flatPath);
+				result.skippedFiles.push(`${subfolder}/${filename}`);
+				if (verbose) logger.info(`[bejamas-ui] Removed flat duplicate: ${filename} (${subfolder}/${filename} exists)`);
+			} catch {
+				result.skippedFiles.push(`${subfolder}/${filename}`);
+			}
+			continue;
+		}
+		await fs$1.mkdir(targetDir, { recursive: true });
+		await fs$1.rename(flatPath, targetPath);
+		result.totalMoved++;
+		result.movedFiles.push(`${subfolder}/${filename}`);
+		if (verbose) logger.info(`[bejamas-ui] Moved ${filename} -> ${subfolder}/${filename}`);
+	}
+	if (await pathExists(targetDir)) await repairComponentBarrel(targetDir, files, overwriteExisting);
+	return result;
+}
+async function repairComponentBarrel(targetDir, files, overwriteExisting = false) {
+	const localFiles = (await fs$1.readdir(targetDir)).filter((name) => name.endsWith(".astro")).sort();
+	if (!localFiles.length) return;
+	const indexPath = path.join(targetDir, "index.ts");
+	const existing = await fs$1.readFile(indexPath, "utf8").catch(() => "");
+	const registryBarrel = files.find((file) => path.basename(file.path) === "index.ts")?.content ?? "";
+	const cleaned = (overwriteExisting || !existing ? registryBarrel : existing).replace(/export\s*\{[^}]*\}\s*from\s*["'](\.\/[^"']+\.astro)["'];?/g, (statement, specifier) => localFiles.includes(specifier.slice(2)) ? statement : "").trim();
+	const next = [cleaned, ...localFiles.filter((file) => {
+		const name = path.basename(file, ".astro");
+		return !new RegExp(`default\\s+as\\s+${name}\\b`).test(cleaned);
+	}).map((file) => `export { default as ${path.basename(file, ".astro")} } from "./${file}";`)].filter(Boolean).join("\n") + "\n";
+	if (next !== existing) await fs$1.writeFile(indexPath, next);
+}
+/** Resolve dependencies as well as the requested item before repairing output. */
+async function fetchRegistryTree(components, registryUrl, style = "bejamas-juno") {
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	async function visit(name) {
+		if (seen.has(name)) return;
+		seen.add(name);
+		if (!/^[a-z0-9-]+$/.test(name)) return;
+		const item = await fetchRegistryItem(name, registryUrl, style);
+		if (!item) throw new Error(`Unable to load registry item ${name} for installation validation.`);
+		for (const dependency of item.registryDependencies ?? []) await visit(dependency);
+		items.push(item);
+	}
+	for (const name of components) await visit(name);
+	return items;
+}
+async function reorganizeComponents(components, uiDir, registryUrl, verbose, style = "bejamas-juno", overwriteExisting = false) {
+	const result = {
+		totalMoved: 0,
+		movedFiles: [],
+		skippedFiles: []
+	};
+	if (!uiDir || components.length === 0) return result;
+	const items = await fetchRegistryTree(components, registryUrl, style);
+	for (const item of items) {
+		if (!shouldReorganizeRegistryUiFiles(item.files, uiDir)) continue;
+		const componentResult = await reorganizeRegistryUiFiles(item.files, uiDir, verbose, overwriteExisting);
+		result.totalMoved += componentResult.totalMoved;
+		result.movedFiles.push(...componentResult.movedFiles);
+		result.skippedFiles.push(...componentResult.skippedFiles);
+	}
+	const flatIndex = path.join(uiDir, "index.ts");
+	const flatContent = await fs$1.readFile(flatIndex, "utf8").catch(() => null);
+	if (flatContent && items.some((item) => item.files?.some((file) => file.type === "registry:ui" && path.basename(file.path) === "index.ts" && file.content.trim() === flatContent.trim()))) await fs$1.unlink(flatIndex);
+	return result;
+}
+/** Update legacy template exports once the installed UI uses nested barrels. */
+async function repairUiPackageExports(uiDir, packageRoot) {
+	const entries = await fs$1.readdir(uiDir, { withFileTypes: true }).catch(() => []);
+	if (!entries.some((entry) => entry.isDirectory()) || entries.some((entry) => entry.name.endsWith(".astro"))) return;
+	const packagePath = path.join(packageRoot, "package.json");
+	const manifest = JSON.parse(await fs$1.readFile(packagePath, "utf8"));
+	if (!manifest.exports || typeof manifest.exports !== "object") return;
+	const relativeUi = path.relative(packageRoot, uiDir).split(path.sep).join("/");
+	if (relativeUi.startsWith("../")) return;
+	const prefix = `./${relativeUi}`;
+	let changed = false;
+	for (const [specifier, target] of Object.entries(manifest.exports)) if (target === `${prefix}/*.astro` || target === `${prefix}/*.ts`) {
+		manifest.exports[specifier] = `${prefix}/*/index.ts`;
+		changed = true;
+	}
+	if (changed) await fs$1.writeFile(packagePath, JSON.stringify(manifest, null, 2) + "\n");
+}
+
+//#endregion
+//#region src/utils/shadcn-cli.ts
+const PINNED_SHADCN_VERSION = "4.21.0";
+const PINNED_SHADCN_PACKAGE = `shadcn@${PINNED_SHADCN_VERSION}`;
+const PINNED_SHADCN_EXEC_PREFIX = path.join(os$1.tmpdir(), "bejamas-shadcn", PINNED_SHADCN_VERSION);
+async function ensurePinnedShadcnExecPrefix() {
+	await fs$1.mkdir(PINNED_SHADCN_EXEC_PREFIX, { recursive: true });
+	return PINNED_SHADCN_EXEC_PREFIX;
+}
+function getNpmExecutable() {
+	return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function buildPinnedShadcnInvocation(shadcnArgs) {
+	return {
+		cmd: getNpmExecutable(),
+		args: [
+			"exec",
+			"--yes",
+			"--prefix",
+			PINNED_SHADCN_EXEC_PREFIX,
+			`--package=${PINNED_SHADCN_PACKAGE}`,
+			"--",
+			"shadcn",
+			...shadcnArgs
+		],
+		source: "isolated"
+	};
+}
+
+//#endregion
+//#region src/utils/shadcn-command.ts
+function extractPassthroughArgs(rawArgv, commandName) {
+	const commandIndex = rawArgv.findIndex((arg) => arg === commandName);
+	if (commandIndex === -1) return [];
+	const rest = rawArgv.slice(commandIndex + 1);
+	const doubleDashIndex = rest.indexOf("--");
+	if (doubleDashIndex === -1) return [];
+	return rest.slice(doubleDashIndex + 1);
+}
+async function runShadcnCommand({ cwd, args, env }) {
+	await ensurePinnedShadcnExecPrefix();
+	const invocation = buildPinnedShadcnInvocation(args);
+	await execa(invocation.cmd, invocation.args, {
+		cwd,
+		env: {
+			...process.env,
+			...env
+		},
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/commands/init.ts
+function resolveDesignSystemConfig(options) {
+	const rtlLanguage = options.rtl && options.lang ? options.lang : DEFAULT_DESIGN_SYSTEM_CONFIG.rtlLanguage;
+	if (options.preset && isPresetCode(options.preset)) {
+		const decoded = decodePreset(options.preset);
+		if (decoded) return normalizeDesignSystemConfig(designSystemConfigSchema.parse({
+			...DEFAULT_DESIGN_SYSTEM_CONFIG,
+			...decoded,
+			template: options.template ?? DEFAULT_DESIGN_SYSTEM_CONFIG.template,
+			rtl: options.rtl ?? false,
+			rtlLanguage
+		}));
+	}
+	const baseColor = options.baseColor ?? DEFAULT_DESIGN_SYSTEM_CONFIG.baseColor;
+	return normalizeDesignSystemConfig(designSystemConfigSchema.parse({
+		...DEFAULT_DESIGN_SYSTEM_CONFIG,
+		template: options.template ?? DEFAULT_DESIGN_SYSTEM_CONFIG.template,
+		rtl: options.rtl ?? false,
+		rtlLanguage,
+		baseColor,
+		theme: baseColor === DEFAULT_DESIGN_SYSTEM_CONFIG.baseColor ? DEFAULT_DESIGN_SYSTEM_CONFIG.theme : baseColor
+	}));
+}
+function buildInitUrl(config, themeRef, env = process.env) {
+	const params = new URLSearchParams({
+		preset: encodePreset(config),
+		template: config.template
+	});
+	if (config.rtl) {
+		params.set("rtl", "true");
+		params.set("lang", config.rtlLanguage);
+	}
+	if (themeRef) params.set("themeRef", themeRef);
+	return `${buildUiUrl("/init", env)}?${params.toString()}`;
+}
+function buildThemeVarsFromRegistryItem(item) {
+	return item?.cssVars ?? null;
+}
+async function fetchInitThemeVars(initUrl) {
+	const response = await fetch(initUrl);
+	if (!response.ok) return null;
+	return buildThemeVarsFromRegistryItem(await response.json());
+}
+const initOptionsSchema = z.object({
+	cwd: z.string(),
+	components: z.array(z.string()).optional(),
+	yes: z.boolean(),
+	reinstall: z.boolean().optional(),
+	defaults: z.boolean(),
+	force: z.boolean(),
+	silent: z.boolean(),
+	isNewProject: z.boolean(),
+	srcDir: z.boolean().optional(),
+	cssVariables: z.boolean(),
+	template: z.string().optional().refine((val) => {
+		if (val) return TEMPLATES[val];
+		return true;
+	}, { message: "Invalid template. Please use 'astro', 'astro-monorepo', or 'astro-with-component-docs-monorepo'." }),
+	preset: z.string().optional(),
+	baseColor: z.string().optional().refine((val) => {
+		if (val) return BASE_COLORS.find((color) => color.name === val);
+		return true;
+	}, { message: `Invalid base color. Please use '${BASE_COLORS.map((color) => color.name).join("', '")}'` }),
+	baseStyle: z.boolean(),
+	rtl: z.boolean().default(false),
+	lang: z.enum(RTL_LANGUAGE_VALUES).optional(),
+	themeRef: z.string().optional()
+});
+function shouldReinstallExistingComponents(options) {
+	return options.reinstall ?? Boolean(options.preset);
+}
+function ensureShadcnReinstallFlag(forwardedOptions, shouldReinstall) {
+	if (!shouldReinstall || forwardedOptions.includes("--reinstall") || forwardedOptions.includes("--no-reinstall")) return forwardedOptions;
+	const passthroughIndex = forwardedOptions.indexOf("--");
+	if (passthroughIndex === -1) return [...forwardedOptions, "--reinstall"];
+	return [
+		...forwardedOptions.slice(0, passthroughIndex),
+		"--reinstall",
+		...forwardedOptions.slice(passthroughIndex)
+	];
+}
+function extractOptionsForShadcnInit(rawArgv, cmd) {
+	if (typeof cmd.getOptionValueSource === "function") {
+		const opts = cmd.optsWithGlobals();
+		const forwarded = [];
+		const getSource = (key) => cmd.getOptionValueSource(key);
+		const addBoolean = (key, flag, negateFlag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (typeof value !== "boolean") return;
+			if (value) forwarded.push(flag);
+			else if (negateFlag) forwarded.push(negateFlag);
+		};
+		addBoolean("yes", "--yes");
+		addBoolean("force", "--force");
+		addBoolean("silent", "--silent");
+		addBoolean("reinstall", "--reinstall", "--no-reinstall");
+		const initIndex = rawArgv.findIndex((arg) => arg === "init");
+		if (initIndex !== -1) {
+			const rest = rawArgv.slice(initIndex + 1);
+			const doubleDashIndex = rest.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded.push(...rest.slice(doubleDashIndex));
+		}
+		return forwarded;
+	}
+	const initIndex = rawArgv.findIndex((arg) => arg === "init");
+	if (initIndex === -1) return [];
+	const rest = rawArgv.slice(initIndex + 1);
+	const forwarded = [];
+	const filteredFlags = /* @__PURE__ */ new Set([
+		"-v",
+		"--verbose",
+		"-t",
+		"--template",
+		"-b",
+		"--base-color",
+		"-p",
+		"--preset",
+		"--theme-ref",
+		"-c",
+		"--cwd",
+		"-d",
+		"--defaults",
+		"--src-dir",
+		"--no-src-dir",
+		"--css-variables",
+		"--no-css-variables",
+		"--no-base-style",
+		"--rtl",
+		"--lang"
+	]);
+	for (let index = 0; index < rest.length; index += 1) {
+		const token = rest[index];
+		if (token === "--") {
+			forwarded.push("--", ...rest.slice(index + 1));
+			break;
+		}
+		if (!token.startsWith("-")) continue;
+		if (filteredFlags.has(token)) continue;
+		forwarded.push(token);
+	}
+	return forwarded;
+}
+const init = new Command().name("init").description("initialize your project and install dependencies").argument("[components...]", "names, url or local path to component").option("-t, --template <template>", "the template to use. (astro, astro-monorepo, astro-with-component-docs-monorepo)").option("-b, --base-color <base-color>", "the base color to use. (neutral, gray, zinc, stone, slate)", void 0).option("-p, --preset <preset>", "the encoded create preset to use").option("--theme-ref <theme-ref>", "the custom theme ref to use").option("-y, --yes", "skip confirmation prompt.", false).option("-d, --defaults", "use default configuration.", false).option("-f, --force", "force overwrite of existing configuration.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-s, --silent", "mute output.", false).option("--src-dir", "use the src directory when creating a new project.", false).option("--no-src-dir", "do not use the src directory when creating a new project.").option("--css-variables", "use css variables for theming.", true).option("--no-css-variables", "do not use css variables for theming.").option("--no-base-style", "do not install the base shadcn style.").option("--rtl", "enable right-to-left output", false).option("--lang <lang>", "set the RTL language. (ar, fa, he)").option("--reinstall", "re-install existing UI components. Enabled by default for preset switching.").option("--no-reinstall", "do not re-install existing UI components during preset switching.").action(async (_components, opts, cmd) => {
+	try {
+		await runInit({
+			...opts,
+			forwardedOptions: extractOptionsForShadcnInit(process.argv.slice(2), cmd)
+		});
+	} catch (error) {
+		logger.break();
+		handleError(error);
+	} finally {
+		clearRegistryContext();
+	}
+});
+async function runInit(options) {
+	const designConfig = resolveDesignSystemConfig(options);
+	let newProjectTemplate;
+	if (!options.skipPreflight) {
+		if ((await preFlightInit(options)).errors["1"]) {
+			const { projectPath, template } = await createProject(options);
+			if (!projectPath) process.exit(1);
+			options.cwd = projectPath;
+			options.isNewProject = true;
+			newProjectTemplate = template;
+		}
+	}
+	if (newProjectTemplate) {
+		const projectPath = {
+			"astro-monorepo": "apps/web",
+			"astro-with-component-docs-monorepo": "apps/web",
+			astro: ""
+		};
+		await applyDesignSystemToProject(options.cwd, {
+			...designConfig,
+			template: newProjectTemplate
+		}, { themeVars: options.themeRef ? await fetchInitThemeVars(buildInitUrl({
+			...designConfig,
+			template: newProjectTemplate
+		}, options.themeRef)) ?? void 0 : void 0 });
+		options.cwd = path.resolve(options.cwd, projectPath[newProjectTemplate]);
+		logger.log(`${highlighter.success("Success!")} Project initialization completed.\nYou may now add components.`);
+		return await getConfig(options.cwd);
+	}
+	try {
+		return await runExistingProjectInit(options, designConfig);
+	} catch {
+		process.exit(1);
+	}
+}
+async function runExistingProjectInit(options, designConfig = resolveDesignSystemConfig(options)) {
+	const env = {
+		...process.env,
+		REGISTRY_URL: resolveRegistryUrl()
+	};
+	const initUrl = buildInitUrl(designConfig, options.themeRef);
+	const themeVars = options.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0;
+	const shouldReinstall = shouldReinstallExistingComponents(options);
+	const reinstallComponents = shouldReinstall ? await getInstalledUiComponents(options.cwd) : [];
+	const forwardedOptions = ensureShadcnReinstallFlag(options.forwardedOptions ?? [], shouldReinstall);
+	await runShadcnCommand({
+		cwd: options.cwd,
+		args: [
+			"init",
+			initUrl,
+			...reinstallComponents,
+			...forwardedOptions
+		],
+		env
+	});
+	await syncManagedTailwindCss(options.cwd);
+	await syncDesignSystemFontsInProject(options.cwd, designConfig);
+	await applyDesignSystemToProject(options.cwd, designConfig, { themeVars });
+	if (reinstallComponents.length > 0) {
+		const config = await getConfig(options.cwd);
+		const uiDir = config?.resolvedPaths.ui ?? "";
+		const activeStyle = config?.style ?? "bejamas-juno";
+		if (uiDir) await reorganizeComponents(reinstallComponents, uiDir, resolveRegistryUrl(), false, activeStyle, true);
+		await fixAstroImports(options.cwd, false);
+	}
+	return await getConfig(options.cwd);
+}
+
+//#endregion
+//#region src/commands/docs.ts
+const docs = new Command().name("docs").description("proxy to shadcn docs").argument("<components...>", "component names").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-b, --base <base>", "the base to use either 'base' or 'radix'. defaults to project base.").option("--json", "output as JSON.", false).action(async (components, opts) => {
+	const cwd = path.resolve(opts.cwd ?? process.cwd());
+	const rawArgv = process.argv.slice(2);
+	const args = [
+		"docs",
+		...components,
+		"--cwd",
+		cwd
+	];
+	if (opts.base) args.push("--base", opts.base);
+	if (opts.json) args.push("--json");
+	const passthroughArgs = extractPassthroughArgs(rawArgv, "docs");
+	if (passthroughArgs.length > 0) args.push(...passthroughArgs);
+	try {
+		await runShadcnCommand({
+			cwd,
+			args
+		});
+	} catch {
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/utils/tsconfig-utils.ts
+/**
+* Read and parse tsconfig.json from the project root
+*/
+function readTsConfig(projectRoot) {
+	try {
+		const tsconfigPath = resolve(projectRoot, "tsconfig.json");
+		if (!existsSync(tsconfigPath)) return null;
+		const raw = readFileSync(tsconfigPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Resolve an alias path (like @/components) using tsconfig.json paths
+*/
+function resolveAliasPathUsingTsConfig(inputPath, projectRoot) {
+	const cfg = readTsConfig(projectRoot);
+	if (!cfg || !cfg.compilerOptions) return null;
+	const baseUrl = cfg.compilerOptions.baseUrl || ".";
+	const paths = cfg.compilerOptions.paths || {};
+	for (const [key, values] of Object.entries(paths)) {
+		const pattern = key.replace(/\*/g, "(.*)");
+		const re = new RegExp(`^${pattern}$`);
+		const match = inputPath.match(re);
+		if (!match) continue;
+		const wildcard = match[1] || "";
+		const first = Array.isArray(values) ? values[0] : values;
+		if (!first) continue;
+		const target = String(first).replace(/\*/g, wildcard);
+		return resolve(projectRoot, baseUrl, target);
+	}
+	return null;
+}
+
+//#endregion
+//#region src/commands/docs-build.ts
+async function generateDocs({ cwd, outDir, verbose }) {
+	const DEBUG = process.env.BEJAMAS_DEBUG === "1" || process.env.BEJAMAS_DEBUG === "true" || verbose;
+	try {
+		const shellCwd = process.cwd();
+		if (cwd && cwd.length) process.env.BEJAMAS_UI_ROOT = resolve(shellCwd, cwd);
+		if (outDir && outDir.length) process.env.BEJAMAS_DOCS_OUT_DIR = outDir;
+		let projectRoot = shellCwd;
+		let probe = shellCwd;
+		for (let i = 0; i < 6 && probe; i += 1) {
+			const candidate = resolve(probe, "components.json");
+			if (existsSync(candidate)) {
+				projectRoot = probe;
+				try {
+					const raw = readFileSync(candidate, "utf-8");
+					const config = JSON.parse(raw);
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.aliases?.ui) {
+						const mapped = String(config.aliases.ui);
+						let uiAbs = null;
+						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) uiAbs = resolve(projectRoot, mapped);
+						else uiAbs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
+						if (!uiAbs && mapped.startsWith("@/")) uiAbs = resolve(projectRoot, "src", mapped.slice(2));
+						if (uiAbs) process.env.BEJAMAS_UI_ROOT = uiAbs;
+					}
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.tailwind?.css) {
+						const cssRaw = String(config.tailwind.css);
+						let cssAbs = null;
+						if (cssRaw.startsWith("./") || cssRaw.startsWith("../") || isAbsolute(cssRaw)) cssAbs = resolve(projectRoot, cssRaw);
+						else cssAbs = resolveAliasPathUsingTsConfig(cssRaw, projectRoot);
+						if (!cssAbs && cssRaw.startsWith("@/")) cssAbs = resolve(projectRoot, "src", cssRaw.slice(2));
+						if (cssAbs) {
+							const uiRootFromCss = resolve(cssAbs, "..", "..", "..");
+							process.env.BEJAMAS_UI_ROOT = uiRootFromCss;
+						}
+					}
+					if (!outDir && config?.aliases?.docs) {
+						const mapped = String(config.aliases.docs);
+						let outResolved = null;
+						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) outResolved = mapped;
+						else {
+							const abs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
+							if (abs) outResolved = relative(projectRoot, abs);
+						}
+						if (!outResolved && mapped.startsWith("@/")) outResolved = mapped.replace(/^@\//, "src/");
+						const finalOut = outResolved ?? mapped;
+						if (finalOut && !process.env.BEJAMAS_DOCS_OUT_DIR) {
+							process.env.BEJAMAS_DOCS_OUT_DIR = finalOut;
+							process.env.BEJAMAS_DOCS_CWD = projectRoot;
+						}
+					}
+				} catch {}
+				break;
+			}
+			const parent = resolve(probe, "..");
+			probe = parent === probe ? null : parent;
+		}
+		if (!process.env.BEJAMAS_DOCS_CWD) process.env.BEJAMAS_DOCS_CWD = shellCwd;
+		if (!process.env.BEJAMAS_UI_ROOT) {
+			const defaultGuess = (() => {
+				let current = shellCwd;
+				for (let i = 0; i < 6; i += 1) {
+					const cand = resolve(current, "packages/ui/package.json");
+					if (existsSync(cand)) {
+						const abs = resolve(current, "packages/ui");
+						return relative(shellCwd, abs) || abs;
+					}
+					const parent = resolve(current, "..");
+					if (parent === current) break;
+					current = parent;
+				}
+				const nm = resolve(shellCwd, "node_modules/@bejamas/ui/package.json");
+				if (existsSync(nm)) {
+					const abs = resolve(shellCwd, "node_modules/@bejamas/ui");
+					return relative(shellCwd, abs) || abs;
+				}
+				return "packages/ui";
+			})();
+			const { uiRoot } = await prompts({
+				type: "text",
+				name: "uiRoot",
+				message: "Path to @bejamas/ui package root:",
+				initial: defaultGuess,
+				validate: (val) => {
+					const p = resolve(shellCwd, val);
+					return existsSync(resolve(p, "package.json")) ? true : `No package.json found in ${p}`;
+				}
+			});
+			if (!uiRoot) {
+				logger.error("@bejamas/ui root is required to generate docs.");
+				process.exit(1);
+			}
+			process.env.BEJAMAS_UI_ROOT = resolve(shellCwd, uiRoot);
+		}
+		if (!process.env.BEJAMAS_DOCS_OUT_DIR) {
+			const { out } = await prompts({
+				type: "text",
+				name: "out",
+				message: "Where should we output docs (relative to project root)?",
+				initial: "src/content/docs/components"
+			});
+			if (!out) {
+				logger.error("An output directory is required to generate docs.");
+				process.exit(1);
+			}
+			process.env.BEJAMAS_DOCS_OUT_DIR = out;
+			process.env.BEJAMAS_DOCS_CWD = process.env.BEJAMAS_DOCS_CWD || shellCwd;
+		}
+		process.env.BEJAMAS_SKIP_AUTO_RUN = "1";
+		logger.info(`Generating docs...`);
+		if (DEBUG) {
+			logger.info(`Generator entry: @/src/docs/generate-mdx/index`);
+			if (process.env.BEJAMAS_UI_ROOT) logger.info(`UI root: ${process.env.BEJAMAS_UI_ROOT}`);
+			if (process.env.BEJAMAS_DOCS_CWD) logger.info(`Docs CWD: ${process.env.BEJAMAS_DOCS_CWD}`);
+			if (process.env.BEJAMAS_DOCS_OUT_DIR) logger.info(`Docs out: ${process.env.BEJAMAS_DOCS_OUT_DIR}`);
+		}
+		const mod = await import("./generate-mdx-BSRQJPrF.js");
+		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
+		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
+	} catch (err) {
+		logger.error(err?.message || String(err));
+		process.exit(1);
+	}
+}
+const docsBuild = new Command().name("docs:build").description("generate docs from @bejamas/ui components").option("-c, --cwd <cwd>", "path to UI working directory").option("-o, --out <outDir>", "output directory for generated MDX files").action(async (opts) => {
+	await generateDocs({
+		cwd: opts.cwd,
+		outDir: opts.out,
+		verbose: Boolean(opts.verbose)
+	});
+});
+
+//#endregion
+//#region src/commands/docs-check.ts
+const REQUIRED_FIELDS = [
+	"name",
+	"title",
+	"description"
+];
+const RECOMMENDED_FIELDS = [
+	"primaryExampleMDX",
+	"usageMDX",
+	"figmaUrl"
+];
+const FIELD_LABELS = {
+	name: "@component",
+	title: "@title",
+	description: "@description",
+	primaryExampleMDX: "@preview",
+	usageMDX: "@usage",
+	figmaUrl: "@figmaUrl"
+};
+function checkComponentDocs(filePath, fileName) {
+	const content = readFileSync(filePath, "utf-8");
+	const frontmatter = extractFrontmatter(content);
+	const meta = parseJsDocMetadata(frontmatter);
+	const componentName = fileName.replace(/\.astro$/i, "");
+	const missingRequired = [];
+	const missingRecommended = [];
+	for (const field of REQUIRED_FIELDS) {
+		const value = meta[field];
+		if (!value || typeof value === "string" && !value.trim()) missingRequired.push(FIELD_LABELS[field] || field);
+	}
+	for (const field of RECOMMENDED_FIELDS) {
+		const value = meta[field];
+		if (!value || typeof value === "string" && !value.trim()) missingRecommended.push(FIELD_LABELS[field] || field);
+	}
+	let status;
+	if (missingRequired.length > 0) status = "missing";
+	else if (missingRecommended.length > 0) status = "incomplete";
+	else status = "complete";
+	return {
+		name: componentName,
+		file: fileName,
+		status,
+		missingRequired,
+		missingRecommended
+	};
+}
+async function checkDocs({ cwd, json }) {
+	try {
+		const shellCwd = process.cwd();
+		let projectRoot = shellCwd;
+		let probe = shellCwd;
+		for (let i = 0; i < 6 && probe; i += 1) {
+			const candidate = resolve(probe, "components.json");
+			if (existsSync(candidate)) {
+				projectRoot = probe;
+				try {
+					const raw = readFileSync(candidate, "utf-8");
+					const config = JSON.parse(raw);
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.aliases?.ui) {
+						const mapped = String(config.aliases.ui);
+						let uiAbs = null;
+						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) uiAbs = resolve(projectRoot, mapped);
+						else uiAbs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
+						if (!uiAbs && mapped.startsWith("@/")) uiAbs = resolve(projectRoot, "src", mapped.slice(2));
+						if (uiAbs) process.env.BEJAMAS_UI_ROOT = uiAbs;
+					}
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.tailwind?.css) {
+						const cssRaw = String(config.tailwind.css);
+						let cssAbs = null;
+						if (cssRaw.startsWith("./") || cssRaw.startsWith("../") || isAbsolute(cssRaw)) cssAbs = resolve(projectRoot, cssRaw);
+						else cssAbs = resolveAliasPathUsingTsConfig(cssRaw, projectRoot);
+						if (!cssAbs && cssRaw.startsWith("@/")) cssAbs = resolve(projectRoot, "src", cssRaw.slice(2));
+						if (cssAbs) {
+							const uiRootFromCss = resolve(cssAbs, "..", "..", "..");
+							process.env.BEJAMAS_UI_ROOT = uiRootFromCss;
+						}
+					}
+				} catch {}
+				break;
+			}
+			const parent = resolve(probe, "..");
+			probe = parent === probe ? null : parent;
+		}
+		if (cwd && cwd.length) process.env.BEJAMAS_UI_ROOT = resolve(cwd);
+		let uiRoot;
+		try {
+			uiRoot = resolveUiRoot(shellCwd);
+		} catch {
+			logger.error("Unable to locate @bejamas/ui. Use --cwd to specify the UI package path.");
+			process.exit(1);
+		}
+		const componentsDir = join(uiRoot, "src", "components");
+		if (!existsSync(componentsDir)) {
+			logger.error(`Components directory not found: ${componentsDir}\n\nExpected structure: <uiRoot>/src/components/*.astro\nUse --cwd to specify a different UI package root.`);
+			process.exit(1);
+		}
+		const files = readdirSync(componentsDir, { withFileTypes: true }).filter((e) => e.isFile() && extname(e.name).toLowerCase() === ".astro").map((e) => e.name).sort();
+		if (files.length === 0) {
+			logger.warn("No .astro component files found.");
+			process.exit(0);
+		}
+		const results = [];
+		for (const file of files) {
+			const status = checkComponentDocs(join(componentsDir, file), file);
+			results.push(status);
+		}
+		const complete = results.filter((r) => r.status === "complete");
+		const incomplete = results.filter((r) => r.status === "incomplete");
+		const missing = results.filter((r) => r.status === "missing");
+		const checkResult = {
+			total: results.length,
+			complete,
+			incomplete,
+			missing
+		};
+		if (json) {
+			console.log(JSON.stringify(checkResult, null, 2));
+			if (missing.length > 0) process.exit(1);
+			return;
+		}
+		const termWidth = Math.min(80, process.stdout.columns || 80);
+		const headerLine = "━".repeat(termWidth);
+		logger.break();
+		console.log(dim("┌" + "─".repeat(termWidth - 2) + "┐"));
+		console.log(dim("│") + bold(cyan("  docs:check")) + dim(" — Component Documentation Status") + " ".repeat(Math.max(0, termWidth - 47)) + dim("│"));
+		console.log(dim("└" + "─".repeat(termWidth - 2) + "┘"));
+		logger.break();
+		const formatTag = (tag) => magenta(tag);
+		const formatComponentName = (name) => bold(white(name));
+		if (complete.length > 0) {
+			console.log(green(`✓ Complete (${complete.length} component${complete.length === 1 ? "" : "s"}):`));
+			const names = complete.map((c) => formatComponentName(c.name)).join(dim(", "));
+			console.log(`  ${names}`);
+			logger.break();
+		}
+		if (incomplete.length > 0) {
+			console.log(yellow(`⚠ Incomplete (${incomplete.length} component${incomplete.length === 1 ? "" : "s"}):`));
+			for (const comp of incomplete) {
+				const missingFields = comp.missingRecommended.map(formatTag).join(dim(", "));
+				console.log(`  ${formatComponentName(comp.name)} ${dim("-")} ${dim("missing:")} ${missingFields}`);
+			}
+			logger.break();
+		}
+		if (missing.length > 0) {
+			console.log(red(`✗ Missing Docs (${missing.length} component${missing.length === 1 ? "" : "s"}):`));
+			for (const comp of missing) {
+				const missingFields = comp.missingRequired.map(formatTag).join(dim(", "));
+				console.log(`  ${formatComponentName(comp.name)} ${dim("-")} ${dim("missing:")} ${missingFields}`);
+			}
+			logger.break();
+		}
+		console.log(dim(headerLine));
+		const completeText = green(`${complete.length}/${results.length} complete`);
+		const incompleteText = incomplete.length > 0 ? yellow(`${incomplete.length} incomplete`) : dim(`${incomplete.length} incomplete`);
+		const missingText = missing.length > 0 ? red(`${missing.length} missing docs`) : dim(`${missing.length} missing docs`);
+		console.log(`${bold("Summary:")} ${completeText} ${dim("|")} ${incompleteText} ${dim("|")} ${missingText}`);
+		logger.break();
+		if (missing.length > 0) process.exit(1);
+	} catch (err) {
+		logger.error(err?.message || String(err));
+		process.exit(1);
+	}
+}
+const docsCheck = new Command().name("docs:check").description("check documentation status for all components").option("-c, --cwd <cwd>", "path to UI working directory").option("--json", "output results as JSON").action(async (opts) => {
+	await checkDocs({
+		cwd: opts.cwd,
+		json: Boolean(opts.json)
+	});
+});
+
+//#endregion
+//#region ../registry/src/lib/headless-dependencies.ts
+/** Headless behaviors imported by emitted frontmatter, client scripts or helpers. */
+function getHeadlessDependencies(files) {
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const source = (file.content ?? "").replace(/\/\*[\s\S]*?\*\//g, "");
+		for (const match of source.matchAll(/(?:\bfrom\s*|\bimport\s*\(?\s*)["'](@data-slot\/[^/"']+)(?:\/[^"']*)?["']/g)) dependencies.add(match[1]);
+	}
+	return [...dependencies].sort();
+}
+
+//#endregion
+//#region src/utils/registry-dependencies.ts
+function missingRegistryDependencies(manifest, items) {
+	const declared = {
+		...manifest.devDependencies,
+		...manifest.dependencies
+	};
+	const candidates = /* @__PURE__ */ new Map();
+	for (const item of items) for (const specifier of item.dependencies ?? []) {
+		const name = specifier.match(/^(@[^/]+\/[^@/]+|[^@/]+)/)?.[1];
+		if (name && !declared[name]) candidates.set(name, specifier);
+	}
+	for (const item of items) for (const name of getHeadlessDependencies(item.files ?? [])) if (!declared[name] && !candidates.has(name)) candidates.set(name, name);
+	return [...candidates.values()].sort();
+}
+async function ensureRegistryDependencies(cwd, items) {
+	const missing = missingRegistryDependencies(JSON.parse(await fs$1.readFile(path.join(cwd, "package.json"), "utf8")), items);
+	if (!missing.length) return;
+	const manager = await getPackageManager(cwd);
+	await execa(manager, [manager === "npm" ? "install" : "add", ...missing], {
+		cwd,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/commands/add.ts
+function extractOptionsForShadcn(rawArgv, cmd) {
+	if (typeof cmd.getOptionValueSource === "function") {
+		const opts = cmd.optsWithGlobals();
+		const forwarded = [];
+		const getSource = (key) => cmd.getOptionValueSource(key);
+		const addBoolean = (key, flag, negateFlag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (typeof value !== "boolean") return;
+			if (value) forwarded.push(flag);
+			else if (negateFlag) forwarded.push(negateFlag);
+		};
+		const addString = (key, flag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (typeof value === "string") forwarded.push(flag, value);
+		};
+		const addOptionalString = (key, flag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (value === true) {
+				forwarded.push(flag);
+				return;
+			}
+			if (typeof value === "string") forwarded.push(flag, value);
+		};
+		addBoolean("yes", "--yes");
+		addBoolean("overwrite", "--overwrite");
+		addBoolean("dryRun", "--dry-run");
+		addString("cwd", "--cwd");
+		addBoolean("all", "--all");
+		addString("path", "--path");
+		addBoolean("silent", "--silent");
+		addBoolean("srcDir", "--src-dir", "--no-src-dir");
+		addOptionalString("diff", "--diff");
+		addOptionalString("view", "--view");
+		const addIndex = rawArgv.findIndex((arg) => arg === "add");
+		if (addIndex !== -1) {
+			const rest = rawArgv.slice(addIndex + 1);
+			const doubleDashIndex = rest.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded.push(...rest.slice(doubleDashIndex));
+		}
+		return forwarded;
+	}
+	const addIndex = rawArgv.findIndex((arg) => arg === "add");
+	if (addIndex === -1) return [];
+	const rest = rawArgv.slice(addIndex + 1);
+	const forwarded = [];
+	const optionsWithValues = /* @__PURE__ */ new Set([
+		"-c",
+		"--cwd",
+		"-p",
+		"--path",
+		"--diff",
+		"--view"
+	]);
+	const filteredFlags = /* @__PURE__ */ new Set(["-v", "--verbose"]);
+	for (let index = 0; index < rest.length; index += 1) {
+		const token = rest[index];
+		if (token === "--") {
+			forwarded.push("--", ...rest.slice(index + 1));
+			break;
+		}
+		if (!token.startsWith("-")) continue;
+		if (filteredFlags.has(token)) continue;
+		forwarded.push(token);
+		if (token.includes("=")) continue;
+		if (optionsWithValues.has(token)) {
+			const next = rest[index + 1];
+			if (next) {
+				forwarded.push(next);
+				index += 1;
+			}
+		}
+	}
+	return forwarded;
+}
+function hasInspectionFlags(forwardedOptions) {
+	return forwardedOptions.includes("--dry-run") || forwardedOptions.includes("--diff") || forwardedOptions.includes("--view");
+}
+function formatSkippedFilesHeading(count, overwriteUsed) {
+	const noun = `file${count === 1 ? "" : "s"}`;
+	if (overwriteUsed) return `Skipped ${count} ${noun}: (files might be identical)`;
+	return `Skipped ${count} ${noun}: (files might be identical, use --overwrite to overwrite)`;
+}
+function ensureTrailingNewline(output) {
+	return output.endsWith("\n") ? output : `${output}\n`;
+}
+function writeCapturedShadcnOutput(stdout, stderr) {
+	if (stdout) process.stdout.write(ensureTrailingNewline(stdout));
+	if (stderr) process.stderr.write(ensureTrailingNewline(stderr));
+}
+async function buildSubfolderMap(components, uiDir, registryUrl, style) {
+	const filenameToSubfolders = /* @__PURE__ */ new Map();
+	let requiresReorganization = false;
+	for (const componentName of components) {
+		const registryItems = await fetchRegistryTree([componentName], registryUrl, style);
+		for (const registryItem of registryItems) {
+			if (shouldReorganizeRegistryUiFiles(registryItem.files, uiDir)) requiresReorganization = true;
+			const subfolder = getSubfolderFromPaths(registryItem.files);
+			if (!subfolder) continue;
+			for (const file of registryItem.files) if (file.type === "registry:ui") {
+				const filename = path.basename(file.path);
+				const subfolders = filenameToSubfolders.get(filename) || [];
+				subfolders.push(subfolder);
+				filenameToSubfolders.set(filename, subfolders);
+			}
+		}
+	}
+	const uniqueMap = /* @__PURE__ */ new Map();
+	const sharedFilenames = /* @__PURE__ */ new Set();
+	filenameToSubfolders.forEach((subfolders, filename) => {
+		if (subfolders.length === 1) uniqueMap.set(filename, `${subfolders[0]}/${filename}`);
+		else sharedFilenames.add(filename);
+	});
+	return {
+		uniqueMap,
+		sharedFilenames,
+		requiresReorganization
+	};
+}
+function rewritePaths(paths, mapResult) {
+	const { uniqueMap, sharedFilenames } = mapResult;
+	let currentSubfolder = null;
+	return paths.map((filePath) => {
+		const filename = path.basename(filePath);
+		const parentDir = path.basename(path.dirname(filePath));
+		const uniqueMapping = uniqueMap.get(filename);
+		if (uniqueMapping) {
+			const expectedSubfolder = path.dirname(uniqueMapping);
+			currentSubfolder = expectedSubfolder;
+			if (parentDir !== expectedSubfolder) return `${path.dirname(filePath)}/${uniqueMapping}`;
+			return filePath;
+		}
+		if (sharedFilenames.has(filename) && currentSubfolder) {
+			if (parentDir !== currentSubfolder) return `${path.dirname(filePath)}/${currentSubfolder}/${filename}`;
+		}
+		return filePath;
+	});
+}
+async function fetchAvailableComponents(registryUrl) {
+	const indexUrl = `${registryUrl}/index.json`;
+	const response = await fetch(indexUrl);
+	if (!response.ok) throw new Error(`Failed to fetch registry index: ${response.statusText}`);
+	const data = await response.json();
+	return Array.isArray(data) ? data : [];
+}
+async function promptForComponents(registryUrl) {
+	const checkingSpinner = spinner("Checking registry.").start();
+	let components;
+	try {
+		components = await fetchAvailableComponents(registryUrl);
+		checkingSpinner.succeed();
+	} catch {
+		checkingSpinner.fail();
+		logger.error("Failed to fetch available components from registry.");
+		return null;
+	}
+	if (components.length === 0) {
+		logger.warn("No components available in registry.");
+		return null;
+	}
+	const choices = components.filter((component) => !component.type || component.type === "registry:ui").map((component) => ({
+		title: component.name,
+		value: component.name
+	}));
+	const { selected } = await prompts({
+		type: "autocompleteMultiselect",
+		name: "selected",
+		message: "Which components would you like to add?",
+		choices,
+		hint: "- Space to select. Return to submit.",
+		instructions: false
+	});
+	if (!selected) return null;
+	return selected;
+}
+function parseShadcnOutput(stdout, stderr) {
+	const result = {
+		created: [],
+		updated: [],
+		skipped: []
+	};
+	const cleanStderr = stderr.replace(/\x1b\[[0-9;]*m/g, "");
+	const cleanStdout = stdout.replace(/\x1b\[[0-9;]*m/g, "");
+	const createdMatch = cleanStderr.match(/Created\s+(\d+)\s+file/i);
+	const updatedMatch = cleanStderr.match(/Updated\s+(\d+)\s+file/i);
+	const skippedMatch = cleanStderr.match(/Skipped\s+(\d+)\s+file/i);
+	const createdCount = createdMatch ? parseInt(createdMatch[1], 10) : 0;
+	const updatedCount = updatedMatch ? parseInt(updatedMatch[1], 10) : 0;
+	const skippedCount = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+	const allPaths = [];
+	for (const line of cleanStdout.split("\n")) {
+		const match = line.match(/^\s+-\s+(.+)$/);
+		if (match) allPaths.push(match[1].trim());
+	}
+	for (const line of cleanStderr.split("\n")) {
+		const match = line.match(/^\s+-\s+(.+)$/);
+		if (match) {
+			const filePath = match[1].trim();
+			if (!allPaths.includes(filePath)) allPaths.push(filePath);
+		}
+	}
+	let index = 0;
+	for (let count = 0; count < createdCount && index < allPaths.length; count += 1) {
+		result.created.push(allPaths[index]);
+		index += 1;
+	}
+	for (let count = 0; count < updatedCount && index < allPaths.length; count += 1) {
+		result.updated.push(allPaths[index]);
+		index += 1;
+	}
+	for (let count = 0; count < skippedCount && index < allPaths.length; count += 1) {
+		result.skipped.push(allPaths[index]);
+		index += 1;
+	}
+	return result;
+}
+async function addComponents(cwd, packages, forwardedOptions, isVerbose, isSilent, inspectionMode) {
+	const env = {
+		...process.env,
+		REGISTRY_URL: resolveRegistryUrl()
+	};
+	await ensurePinnedShadcnExecPrefix();
+	const shadcnArgs = buildShadcnAddArgs(packages, forwardedOptions);
+	const invocation = buildPinnedShadcnInvocation(shadcnArgs);
+	if (isVerbose) logger.info(`[bejamas-ui] ${invocation.cmd} ${invocation.args.join(" ")}`);
+	const registrySpinner = spinner("Checking registry.", { silent: isSilent });
+	registrySpinner.start();
+	try {
+		const result = await execa(invocation.cmd, invocation.args, {
+			cwd,
+			env,
+			input: "n\nn\nn\nn\nn\nn\nn\nn\nn\nn\n",
+			stdout: "pipe",
+			stderr: "pipe",
+			reject: false
+		});
+		registrySpinner.succeed();
+		spinner("Installing components.", { silent: isSilent }).succeed();
+		const stdout = result.stdout || "";
+		const stderr = result.stderr || "";
+		if (isVerbose) {
+			logger.info(`[bejamas-ui] Raw stdout: ${stdout}`);
+			logger.info(`[bejamas-ui] Raw stderr: ${stderr}`);
+		}
+		if (inspectionMode) writeCapturedShadcnOutput(stdout, stderr);
+		const parsed = inspectionMode ? {
+			created: [],
+			updated: [],
+			skipped: []
+		} : parseShadcnOutput(stdout, stderr);
+		if (result.exitCode !== 0) {
+			if (!inspectionMode) writeCapturedShadcnOutput(stdout, stderr);
+			process.exit(result.exitCode);
+		}
+		return parsed;
+	} catch {
+		registrySpinner.fail();
+		logger.error("Failed to add components");
+		process.exit(1);
+	}
+}
+function buildShadcnAddArgs(packages, forwardedOptions) {
+	const autoFlags = [];
+	if (!forwardedOptions.includes("--yes")) autoFlags.push("--yes");
+	return [
+		"add",
+		...packages,
+		...autoFlags,
+		...forwardedOptions
+	];
+}
+const add = new Command().name("add").description("Add components via the Bejamas-managed shadcn registry flow").argument("[components...]", "Component package names to add").option("-y, --yes", "skip confirmation prompt.", false).option("-o, --overwrite", "overwrite existing files.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-a, --all", "add all available components", false).option("-p, --path <path>", "the path to add the component to.").option("-s, --silent", "mute output.", false).option("--dry-run", "preview changes without writing files.", false).option("--diff [path]", "show diff for a file.").option("--view [path]", "show file contents.").option("--src-dir", "use the src directory when creating a new project.", false).option("--no-src-dir", "do not use the src directory when creating a new project.").action(async function action(packages, _opts, cmd) {
+	const root = cmd?.parent;
+	const verbose = Boolean(root?.opts?.().verbose);
+	const forwardedOptions = extractOptionsForShadcn(process.argv.slice(2), cmd);
+	const opts = typeof cmd.optsWithGlobals === "function" ? cmd.optsWithGlobals() : cmd.opts?.() ?? {};
+	const inspectionMode = hasInspectionFlags(forwardedOptions);
+	const overwriteUsed = forwardedOptions.includes("--overwrite") || forwardedOptions.includes("-o");
+	const cwd = opts.cwd || process.cwd();
+	let componentsToAdd = packages || [];
+	const wantsAll = Boolean(opts.all);
+	const isSilent = opts.silent || false;
+	const registryUrl = resolveRegistryUrl();
+	if (wantsAll && componentsToAdd.length === 0) {
+		const fetchingSpinner = spinner("Fetching available components.", { silent: isSilent }).start();
+		try {
+			componentsToAdd = (await fetchAvailableComponents(registryUrl)).filter((component) => !component.type || component.type === "registry:ui").map((component) => component.name);
+			fetchingSpinner.succeed();
+		} catch {
+			fetchingSpinner.fail();
+			logger.error("Failed to fetch available components from registry.");
+			process.exit(1);
+		}
+	}
+	if (componentsToAdd.length === 0) {
+		const selected = await promptForComponents(registryUrl);
+		if (!selected || selected.length === 0) return;
+		componentsToAdd = selected;
+	}
+	const config = await getConfig(cwd);
+	let uiDir = config?.resolvedPaths?.ui || "";
+	let uiConfig = config;
+	if (config) {
+		const workspaceConfig = await getWorkspaceConfig(config);
+		if (workspaceConfig?.ui) {
+			uiConfig = workspaceConfig.ui;
+			uiDir = uiConfig.resolvedPaths?.ui || uiDir;
+		}
+	}
+	if (verbose) {
+		logger.info(`[bejamas-ui] cwd: ${cwd}`);
+		logger.info(`[bejamas-ui] uiDir: ${uiDir}`);
+		logger.info(`[bejamas-ui] aliases.ui: ${uiConfig?.aliases?.ui || "not set"}`);
+	}
+	const activeStyle = uiConfig?.style || config?.style || "bejamas-juno";
+	const totalComponents = componentsToAdd.length;
+	for (let index = 0; index < componentsToAdd.length; index += 1) {
+		const component = componentsToAdd[index];
+		if (totalComponents > 1 && !isSilent) {
+			logger.break();
+			logger.info(highlighter.info(`[${index + 1}/${totalComponents}]`) + ` Adding ${highlighter.success(component)}...`);
+		}
+		const subfolderMapResult = inspectionMode ? {
+			uniqueMap: /* @__PURE__ */ new Map(),
+			sharedFilenames: /* @__PURE__ */ new Set(),
+			requiresReorganization: false
+		} : await buildSubfolderMap([component], uiDir, registryUrl, activeStyle);
+		const parsed = await addComponents(cwd, [component], forwardedOptions, verbose, isSilent, inspectionMode);
+		if (!inspectionMode) {
+			await syncManagedTailwindCss(cwd);
+			const registryItem = await fetchRegistryItem(component, registryUrl, activeStyle);
+			if (registryItem?.type === "registry:font") {
+				const nextFont = toManagedAstroFont(registryItem.name);
+				if (nextFont) {
+					const currentFonts = await readManagedAstroFontsFromProject(cwd);
+					const nextFonts = mergeManagedAstroFonts(currentFonts, nextFont);
+					await syncAstroFontsInProject(cwd, nextFonts, nextFont.cssVariable);
+					await syncAstroManagedFontCss(cwd, nextFont.cssVariable);
+					await cleanupAstroFontPackages(cwd);
+				}
+			}
+		}
+		let skippedCount = 0;
+		if (!inspectionMode && uiDir && subfolderMapResult.requiresReorganization) skippedCount = (await reorganizeComponents([component], uiDir, registryUrl, verbose, activeStyle, overwriteUsed)).skippedFiles.length;
+		if (!isSilent && !inspectionMode) {
+			const actuallyCreated = Math.max(0, parsed.created.length - skippedCount);
+			if (actuallyCreated > 0) {
+				const createdPaths = rewritePaths(parsed.created.slice(0, actuallyCreated), subfolderMapResult);
+				logger.success(`Created ${createdPaths.length} file${createdPaths.length > 1 ? "s" : ""}:`);
+				for (const file of createdPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (parsed.updated.length > 0) {
+				const updatedPaths = rewritePaths(Array.from(new Set(parsed.updated)), subfolderMapResult);
+				logger.info(`Updated ${updatedPaths.length} file${updatedPaths.length > 1 ? "s" : ""}:`);
+				for (const file of updatedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (skippedCount > 0) logger.info(`Skipped ${skippedCount} file${skippedCount > 1 ? "s" : ""}: (already exists)`);
+			if (parsed.skipped.length > 0) {
+				const skippedPaths = rewritePaths(parsed.skipped, subfolderMapResult);
+				logger.info(formatSkippedFilesHeading(skippedPaths.length, overwriteUsed));
+				for (const file of skippedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (actuallyCreated === 0 && parsed.updated.length === 0 && skippedCount === 0 && parsed.skipped.length === 0) logger.info("Already up to date.");
+		}
+	}
+	if (!inspectionMode) {
+		await fixAstroImports(cwd, verbose, uiConfig);
+		if (uiConfig) {
+			await repairUiPackageExports(uiDir, uiConfig.resolvedPaths.cwd);
+			const items = await fetchRegistryTree(componentsToAdd, registryUrl, activeStyle);
+			await ensureRegistryDependencies(uiConfig.resolvedPaths.cwd, items);
+		}
+	}
+});
+
+//#endregion
+//#region src/utils/file-helper.ts
+const FILE_BACKUP_SUFFIX = ".bak";
+var FileBackupError = class extends Error {
+	constructor(filePath) {
+		super(`Could not back up ${filePath}.`);
+		this.name = "FileBackupError";
+		this.filePath = filePath;
+	}
+};
+function createFileBackup(filePath) {
+	if (!fs.existsSync(filePath)) return null;
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (fs.existsSync(backupPath)) return null;
+	try {
+		fs.copyFileSync(filePath, backupPath);
+		return backupPath;
+	} catch {
+		return null;
+	}
+}
+function restoreFileBackup(filePath) {
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (!fs.existsSync(backupPath)) return false;
+	try {
+		fs.copyFileSync(backupPath, filePath);
+		fs.unlinkSync(backupPath);
+		return true;
+	} catch (error) {
+		console.error(`Warning: Could not restore backup file ${backupPath}: ${error}`);
+		return false;
+	}
+}
+function deleteFileBackup(filePath) {
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (!fs.existsSync(backupPath)) return false;
+	try {
+		fs.unlinkSync(backupPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/get-monorepo-info.ts
+const FRAMEWORK_CONFIG_FILES = [
+	"next.config.*",
+	"vite.config.*",
+	"astro.config.*",
+	"remix.config.*",
+	"nuxt.config.*",
+	"svelte.config.*",
+	"gatsby-config.*",
+	"angular.json"
+];
+async function isMonorepoRoot(cwd) {
+	if (fs.existsSync(path.resolve(cwd, "pnpm-workspace.yaml"))) return true;
+	const packageJsonPath = path.resolve(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		if ((await fs.readJson(packageJsonPath)).workspaces) return true;
+	} catch {
+		return false;
+	}
+	if (fs.existsSync(path.resolve(cwd, "lerna.json"))) return true;
+	if (fs.existsSync(path.resolve(cwd, "nx.json"))) return true;
+	return false;
+}
+async function getMonorepoTargets(cwd) {
+	const patterns = await getWorkspacePatterns(cwd);
+	if (!patterns.length) return [];
+	const dirs = await fg(patterns, {
+		cwd,
+		onlyDirectories: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const targets = [];
+	for (const dir of dirs) {
+		const fullPath = path.resolve(cwd, dir);
+		if (!fs.existsSync(path.resolve(fullPath, "package.json"))) continue;
+		const hasComponentsJson = fs.existsSync(path.resolve(fullPath, "components.json"));
+		const hasFrameworkConfig = FRAMEWORK_CONFIG_FILES.some((pattern) => fg.sync(pattern, {
+			cwd: fullPath,
+			dot: true
+		}).length > 0);
+		if (hasComponentsJson || hasFrameworkConfig) targets.push({
+			name: dir,
+			hasConfig: hasComponentsJson
+		});
+	}
+	return targets;
+}
+function formatMonorepoMessage(command, targets, options = {}) {
+	const binary = options.binary ?? "bejamas";
+	const cwdFlag = options.cwdFlag ?? "-c";
+	logger.break();
+	logger.log(`It looks like you are running ${highlighter.info(command)} from a monorepo root.`);
+	logger.log(`To use ${binary} in a specific workspace, use the ${highlighter.info(cwdFlag)} flag:`);
+	logger.break();
+	for (const target of targets) logger.log(`  ${binary} ${command} ${cwdFlag} ${target.name}`);
+	logger.break();
+}
+async function getWorkspacePatterns(cwd) {
+	const patterns = [];
+	const pnpmWorkspacePath = path.resolve(cwd, "pnpm-workspace.yaml");
+	if (fs.existsSync(pnpmWorkspacePath)) {
+		const content = await fs.readFile(pnpmWorkspacePath, "utf8");
+		const matches = Array.from(content.matchAll(/^\s*-\s*["']?([^"'\n#]+)["']?\s*$/gm));
+		for (const match of matches) patterns.push(match[1].trim());
+	}
+	const packageJsonPath = path.resolve(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		const packageJson = await fs.readJson(packageJsonPath);
+		const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces?.packages;
+		if (Array.isArray(workspaces)) patterns.push(...workspaces.filter((pattern) => !pattern.startsWith("!")));
+	} catch {
+		return Array.from(new Set(patterns));
+	}
+	return Array.from(new Set(patterns));
+}
+
+//#endregion
+//#region src/commands/apply.ts
+const applyOptionsSchema = z.object({
+	cwd: z.string(),
+	positionalPreset: z.string().optional(),
+	preset: z.string().optional(),
+	only: z.union([z.boolean(), z.string()]).optional(),
+	yes: z.boolean(),
+	silent: z.boolean()
+});
+const APPLY_ONLY_VALUES = ["theme", "font"];
+var ApplyOnlyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyOnlyError";
+	}
+};
+var ApplyPresetError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyPresetError";
+	}
+};
+var ApplyWorkspaceSyncError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyWorkspaceSyncError";
+	}
+};
+const apply = new Command().name("apply").description("apply a preset to an existing project").argument("[preset]", "the preset to apply").option("--preset <preset>", "preset configuration to apply").option("--only [parts]", "apply only parts of a preset: theme, font").option("-y, --yes", "skip confirmation prompt.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-s, --silent", "mute output.", false).action(async (positionalPreset, opts) => {
+	try {
+		const options = applyOptionsSchema.parse({
+			...opts,
+			cwd: path.resolve(opts.cwd),
+			positionalPreset
+		});
+		const rawPreset = resolveApplyPreset(options);
+		const explicitOnly = resolveApplyOnly(options.only);
+		validateApplyOnlyPreset({
+			preset: rawPreset,
+			only: explicitOnly
+		});
+		const preflight = await preFlightApply(options);
+		if (preflight.errors["1"]) {
+			logger.break();
+			logger.error(`The ${highlighter.info("apply")} command only works in an existing project.`);
+			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
+			logger.break();
+			process.exit(1);
+		}
+		if (preflight.errors["3"]) {
+			logger.break();
+			logger.error(`No ${highlighter.info("components.json")} found at ${highlighter.info(options.cwd)}.`);
+			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
+			logger.break();
+			process.exit(1);
+		}
+		const existingConfig = preflight.config;
+		if (!existingConfig) process.exit(1);
+		if (!rawPreset) {
+			await printPresetBuilderGuidance(options);
+			process.exit(0);
+		}
+		const resolvedPreset = resolveApplyPresetSource(rawPreset);
+		const only = explicitOnly ?? resolveApplyOnly(resolvedPreset.only ?? getPresetUrlOnly(rawPreset));
+		const designConfig = resolveApplyDesignSystemConfig(resolvedPreset, existingConfig);
+		await confirmApply({
+			cwd: options.cwd,
+			only,
+			silent: options.silent,
+			yes: options.yes
+		});
+		await withFileBackups(await getApplyConfigPaths(existingConfig), async () => {
+			if (only) await runPartialApply(options.cwd, designConfig, resolvedPreset, only);
+			else await runExistingProjectInit({
+				cwd: options.cwd,
+				components: void 0,
+				yes: true,
+				reinstall: true,
+				defaults: false,
+				force: false,
+				silent: options.silent,
+				isNewProject: false,
+				srcDir: false,
+				cssVariables: true,
+				template: "astro",
+				preset: resolvedPreset.preset,
+				baseColor: void 0,
+				baseStyle: true,
+				rtl: existingConfig.rtl ?? false,
+				lang: void 0,
+				themeRef: resolvedPreset.themeRef,
+				forwardedOptions: ["--yes", "--force"]
+			}, designConfig);
+			const config = await getConfig(options.cwd);
+			if (!config) throw new Error("Could not read components.json after applying preset.");
+			await syncApplyWorkspaceConfigs(config, { only });
+		});
+		if (!options.silent) {
+			logger.break();
+			logger.log("Preset applied successfully.");
+			logger.break();
+		}
+	} catch (error) {
+		if (error instanceof ApplyOnlyError || error instanceof ApplyPresetError) {
+			for (const line of error.message.split("\n")) logger.error(line);
+			logger.break();
+			process.exit(1);
+		}
+		if (error instanceof FileBackupError) {
+			logger.error(`Could not back up ${highlighter.info("components.json")}. Aborting.`);
+			logger.break();
+			process.exit(1);
+		}
+		if (error instanceof ApplyWorkspaceSyncError) {
+			logger.error(error.message);
+			logger.break();
+			process.exit(1);
+		}
+		logger.break();
+		handleError(error);
+	} finally {
+		clearRegistryContext();
+	}
+});
+function resolveApplyPreset(options) {
+	const positionalPreset = options.positionalPreset?.trim();
+	const flagPreset = options.preset?.trim();
+	if (positionalPreset && flagPreset && positionalPreset !== flagPreset) throw new ApplyPresetError(`Received two different preset values. Use either the positional preset or ${highlighter.info("--preset")}, or pass the same value to both.`);
+	return flagPreset ?? positionalPreset;
+}
+function getPresetUrlOnly(preset) {
+	if (!isUrl(preset)) return;
+	return new URL(preset).searchParams.get("only") ?? void 0;
+}
+function resolveApplyOnly(value) {
+	if (value === void 0 || value === false) return;
+	if (value === true) throw new ApplyOnlyError([
+		"Missing value for --only.",
+		`Use one or more of: ${APPLY_ONLY_VALUES.join(", ")}.`,
+		"Example: bejamas apply <preset> --only theme,font."
+	].join("\n"));
+	return parseApplyOnlyParts(value);
+}
+function parseApplyOnlyParts(value) {
+	const aliases = {
+		theme: "theme",
+		font: "font",
+		fonts: "font"
+	};
+	const parts = value.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+	const invalid = parts.filter((part) => !aliases[part]);
+	if (!parts.length || invalid.length) throw new ApplyOnlyError([
+		`Invalid value for --only: ${value}.`,
+		`Use one or more of: ${APPLY_ONLY_VALUES.join(", ")}.`,
+		"Example: bejamas apply <preset> --only theme,font."
+	].join("\n"));
+	return Array.from(new Set(parts.map((part) => aliases[part])));
+}
+function validateApplyOnlyPreset(options) {
+	if (!options.only || options.preset) return;
+	throw new ApplyOnlyError(["Missing preset for --only.", "Use: bejamas apply <preset> --only theme,font."].join("\n"));
+}
+function resolveApplyPresetSource(preset) {
+	if (isPresetCode(preset)) {
+		validatePresetCode(preset);
+		return { preset };
+	}
+	if (!isUrl(preset)) throw new ApplyPresetError(`Invalid preset: ${highlighter.info(preset)}. Use a preset code or a Bejamas create/init URL containing a preset code.`);
+	const url = new URL(preset);
+	if (!isSupportedPresetUrl(url)) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset)}. Use a Bejamas create or init URL containing a preset code.`);
+	const code = url.searchParams.get("preset")?.trim();
+	if (!code) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset)}. Expected a URL containing a preset query parameter.`);
+	validatePresetCode(code);
+	return {
+		preset: code,
+		themeRef: url.searchParams.get("themeRef") ?? void 0,
+		only: url.searchParams.get("only") ?? void 0
+	};
+}
+async function preFlightApply(options) {
+	const errors = {};
+	if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
+		errors["1"] = true;
+		return {
+			errors,
+			config: null
+		};
+	}
+	if (!fs.existsSync(path.resolve(options.cwd, "components.json"))) {
+		if (await isMonorepoRoot(options.cwd)) {
+			const targets = await getMonorepoTargets(options.cwd);
+			const applyTargets = [];
+			for (const target of targets) {
+				const projectInfo = await getProjectInfo(path.resolve(options.cwd, target.name));
+				if (target.hasConfig || projectInfo?.isAstro) applyTargets.push(target);
+			}
+			if (applyTargets.length > 0) {
+				formatMonorepoMessage("apply --preset <preset>", applyTargets, {
+					binary: "bejamas",
+					cwdFlag: "-c"
+				});
+				process.exit(1);
+			}
+		}
+		errors["3"] = true;
+		return {
+			errors,
+			config: null
+		};
+	}
+	try {
+		return {
+			errors,
+			config: await getConfig(options.cwd)
+		};
+	} catch {
+		logger.break();
+		logger.error(`An invalid ${highlighter.info("components.json")} file was found at ${highlighter.info(options.cwd)}.\nBefore you can apply a preset, you must create a valid ${highlighter.info("components.json")} file by running the ${highlighter.info("init")} command.`);
+		logger.break();
+		process.exit(1);
+	}
+}
+async function printPresetBuilderGuidance(options) {
+	if (options.silent) return;
+	const createUrl = buildUiUrl("/create");
+	logger.break();
+	logger.log(`Build your custom preset on ${highlighter.info(createUrl)}.`);
+	logger.log(`Then run ${highlighter.info("bejamas apply --preset <preset>")} with the preset code or preset URL from ui.bejamas.com.`);
+	logger.break();
+}
+async function confirmApply(options) {
+	if (options.yes) return;
+	logger.break();
+	if (!options.only) logger.warn(highlighter.warn("Applying a new preset will overwrite existing UI components, fonts, and CSS variables."));
+	else logger.warn(highlighter.warn("Applying the selected preset parts will update your project configuration and styles."));
+	logger.warn("Commit or stash your changes before continuing so you can easily go back.");
+	if (!options.only) {
+		const reinstallComponents = await getInstalledUiComponents(options.cwd);
+		logger.break();
+		logger.log("  The following components will be re-installed:");
+		if (reinstallComponents.length) for (let index = 0; index < reinstallComponents.length; index += 8) logger.log(`  - ${reinstallComponents.slice(index, index + 8).join(", ")}`);
+		else logger.log("  - No installed UI components were detected.");
+	}
+	logger.break();
+	const { proceed } = await prompts({
+		type: "confirm",
+		name: "proceed",
+		message: "Would you like to continue?",
+		initial: false
+	});
+	if (!proceed) {
+		logger.break();
+		process.exit(1);
+	}
+}
+async function runPartialApply(cwd, designConfig, preset, only) {
+	if (only.includes("theme")) {
+		const initUrl = buildInitUrl(designConfig, preset.themeRef);
+		const themeVars = preset.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0;
+		await applyDesignSystemThemeToProject(cwd, designConfig, { themeVars });
+		await fixAstroImports(cwd, false);
+	}
+	if (only.includes("font")) await applyDesignSystemFontToProject(cwd, designConfig);
+}
+function resolveApplyDesignSystemConfig(preset, existingConfig) {
+	return resolveDesignSystemConfig({
+		preset: preset.preset,
+		template: "astro",
+		rtl: existingConfig.rtl ?? false,
+		baseColor: void 0,
+		lang: void 0
+	});
+}
+function validatePresetCode(preset) {
+	if (!isPresetCode(preset) || !decodePreset(preset)) throw new ApplyPresetError(`Invalid preset code: ${highlighter.info(preset)}.`);
+}
+async function getApplyConfigPaths(config) {
+	const configPaths = /* @__PURE__ */ new Set([path.resolve(config.resolvedPaths.cwd, "components.json")]);
+	const workspaceConfig = await getWorkspaceConfig(config);
+	if (workspaceConfig) for (const linkedConfig of Object.values(workspaceConfig)) configPaths.add(path.resolve(linkedConfig.resolvedPaths.cwd, "components.json"));
+	const existingPaths = [];
+	for (const configPath of configPaths) if (await fs.pathExists(configPath)) existingPaths.push(configPath);
+	return existingPaths.sort();
+}
+async function withFileBackups(filePaths, task) {
+	const backedUpPaths = [];
+	const restoreBackupOnExit = () => {
+		for (const filePath of [...backedUpPaths].reverse()) restoreFileBackup(filePath);
+	};
+	try {
+		for (const filePath of filePaths) {
+			if (!createFileBackup(filePath)) throw new FileBackupError(filePath);
+			backedUpPaths.push(filePath);
+		}
+		process.on("exit", restoreBackupOnExit);
+		const result = await task();
+		process.removeListener("exit", restoreBackupOnExit);
+		for (const filePath of backedUpPaths) deleteFileBackup(filePath);
+		return result;
+	} catch (error) {
+		process.removeListener("exit", restoreBackupOnExit);
+		for (const filePath of [...backedUpPaths].reverse()) restoreFileBackup(filePath);
+		throw error;
+	}
+}
+async function syncApplyWorkspaceConfigs(config, options) {
+	if (options.only && !options.only.includes("theme")) return;
+	const linkedConfigs = await getApplyWorkspaceConfigs(config);
+	if (!linkedConfigs.length) return;
+	const patch = {
+		style: config.style,
+		tailwind: {
+			baseColor: config.tailwind.baseColor,
+			cssVariables: config.tailwind.cssVariables
+		},
+		...config.iconLibrary ? { iconLibrary: config.iconLibrary } : {},
+		...config.rtl !== void 0 ? { rtl: config.rtl } : {},
+		...config.menuColor ? { menuColor: config.menuColor } : {},
+		...config.menuAccent ? { menuAccent: config.menuAccent } : {}
+	};
+	try {
+		for (const linkedConfig of linkedConfigs) {
+			const configPath = path.resolve(linkedConfig.resolvedPaths.cwd, "components.json");
+			if (!await fs.pathExists(configPath)) continue;
+			const existingConfig = await fs.readJson(configPath);
+			await fs.writeJson(configPath, {
+				...existingConfig,
+				...patch,
+				tailwind: {
+					...existingConfig.tailwind,
+					...patch.tailwind
+				}
+			}, { spaces: 2 });
+		}
+	} catch (error) {
+		throw new ApplyWorkspaceSyncError(`Failed to sync linked workspace configs.${error instanceof Error ? ` ${error.message}` : ""}`);
+	}
+}
+async function getApplyWorkspaceConfigs(config) {
+	const workspaceConfig = await getWorkspaceConfig(config);
+	if (!workspaceConfig) return [];
+	const linkedConfigs = /* @__PURE__ */ new Map();
+	for (const linkedConfig of Object.values(workspaceConfig)) {
+		if (linkedConfig.resolvedPaths.cwd === config.resolvedPaths.cwd) continue;
+		linkedConfigs.set(linkedConfig.resolvedPaths.cwd, linkedConfig);
+	}
+	return Array.from(linkedConfigs.values()).sort((a, b) => a.resolvedPaths.cwd.localeCompare(b.resolvedPaths.cwd));
+}
+function quoteShellArg(value) {
+	return /[^A-Za-z0-9_./:-]/.test(value) ? JSON.stringify(value) : value;
+}
+function getInitCommand(preset) {
+	if (!preset) return "bejamas init";
+	return `bejamas init --preset ${quoteShellArg(preset)}`;
+}
+function isUrl(value) {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isSupportedPresetUrl(url) {
+	const pathname = url.pathname.replace(/\/+$/, "");
+	return pathname === "/create" || pathname === "/init";
+}
+
+//#endregion
+//#region src/commands/info.ts
+const info = new Command().name("info").description("proxy to shadcn info").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--json", "output as JSON.", false).action(async (opts) => {
+	const cwd = path.resolve(opts.cwd ?? process.cwd());
+	const rawArgv = process.argv.slice(2);
+	const args = [
+		"info",
+		"--cwd",
+		cwd
+	];
+	if (opts.json) args.push("--json");
+	const passthroughArgs = extractPassthroughArgs(rawArgv, "info");
+	if (passthroughArgs.length > 0) args.push(...passthroughArgs);
+	try {
+		await runShadcnCommand({
+			cwd,
+			args
+		});
+	} catch {
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/utils/preset-resolve.ts
+const PRESET_BASE_COLOR_SET = new Set(PRESET_BASE_COLORS);
+const PRESET_FONT_SET = new Set(PRESET_FONTS);
+const PRESET_FONT_HEADING_SET = new Set(PRESET_FONT_HEADINGS);
+const PRESET_ICON_LIBRARY_SET = new Set(PRESET_ICON_LIBRARIES);
+const PRESET_MENU_ACCENT_SET = new Set(PRESET_MENU_ACCENTS);
+const PRESET_MENU_COLOR_SET = new Set(PRESET_MENU_COLORS);
+const PRESET_STYLE_SET = new Set(PRESET_STYLES);
+new Set(PRESET_THEMES);
+const ROOT_FONT_VARIABLES = [
+	"--font-sans",
+	"--font-serif",
+	"--font-mono"
+];
+const ROOT_FONT_VARIABLE_SET = new Set(ROOT_FONT_VARIABLES);
+const FONT_VARIABLE_SET = /* @__PURE__ */ new Set([...ROOT_FONT_VARIABLES, "--font-heading"]);
+async function resolveProjectPreset(config) {
+	const style = normalizePresetStyle(config.style);
+	if (!style) return {
+		code: null,
+		fallbacks: [],
+		values: null
+	};
+	const cssState = await readCssState(config.resolvedPaths.tailwindCss);
+	const baseColor = asPresetValue(PRESET_BASE_COLOR_SET, config.tailwind.baseColor) ?? DEFAULT_PRESET_CONFIG.baseColor;
+	const iconLibrary = asPresetValue(PRESET_ICON_LIBRARY_SET, config.iconLibrary) ?? DEFAULT_PRESET_CONFIG.iconLibrary;
+	const menuAccent = asPresetValue(PRESET_MENU_ACCENT_SET, config.menuAccent) ?? DEFAULT_PRESET_CONFIG.menuAccent;
+	const menuColor = asPresetValue(PRESET_MENU_COLOR_SET, config.menuColor) ?? DEFAULT_PRESET_CONFIG.menuColor;
+	const resolvedTheme = matchTheme(cssState, {
+		baseColor,
+		menuAccent,
+		menuColor,
+		style
+	});
+	const theme = resolvedTheme ?? getFallbackTheme(baseColor);
+	const resolvedRadius = matchRadius(cssState.rootVars["--radius"], style);
+	const radius = resolvedRadius ?? DEFAULT_PRESET_CONFIG.radius;
+	const resolvedFont = await resolveBodyFont(config, cssState);
+	const font = resolvedFont ?? DEFAULT_PRESET_CONFIG.font;
+	const resolvedFontHeading = await resolveHeadingFont(config, cssState, font);
+	const values = {
+		style,
+		baseColor,
+		theme,
+		iconLibrary,
+		font,
+		fontHeading: normalizeFontHeading(resolvedFontHeading ?? DEFAULT_PRESET_CONFIG.fontHeading, font),
+		radius,
+		menuAccent,
+		menuColor
+	};
+	const fallbacks = [
+		!asPresetValue(PRESET_BASE_COLOR_SET, config.tailwind.baseColor) && "baseColor",
+		!resolvedTheme && "theme",
+		!asPresetValue(PRESET_ICON_LIBRARY_SET, config.iconLibrary) && "iconLibrary",
+		!resolvedFont && "font",
+		!resolvedFontHeading && "fontHeading",
+		!resolvedRadius && "radius",
+		!asPresetValue(PRESET_MENU_ACCENT_SET, config.menuAccent) && "menuAccent",
+		!asPresetValue(PRESET_MENU_COLOR_SET, config.menuColor) && "menuColor"
+	].filter(Boolean);
+	return {
+		code: encodePreset(values),
+		fallbacks,
+		values
+	};
+}
+async function readCssState(tailwindCssPath) {
+	const fallback = {
+		darkVars: {},
+		imports: [],
+		rootVars: {},
+		source: "",
+		themeVars: {}
+	};
+	if (!tailwindCssPath || !await fs.pathExists(tailwindCssPath)) return fallback;
+	try {
+		const source = await fs.readFile(tailwindCssPath, "utf8");
+		return {
+			darkVars: collectBlockDeclarations(source, ".dark"),
+			imports: collectImports(source),
+			rootVars: collectBlockDeclarations(source, ":root"),
+			source,
+			themeVars: collectAtRuleDeclarations(source, "@theme inline")
+		};
+	} catch {
+		return fallback;
+	}
+}
+function collectImports(source) {
+	const imports = [];
+	const pattern = /@import\s+(?:url\((['"]?)(.+?)\1\)|(['"])(.+?)\3)\s*;/g;
+	let match;
+	while (match = pattern.exec(source)) {
+		const value = match[2] ?? match[4];
+		if (value) imports.push(value);
+	}
+	return imports;
+}
+function collectBlockDeclarations(source, selector) {
+	const pattern = new RegExp(`${escapeRegExp(selector)}\\s*\\{([\\s\\S]*?)\\}`, "m");
+	const match = source.match(pattern);
+	return match ? collectDeclarations(match[1]) : {};
+}
+function collectAtRuleDeclarations(source, atRule) {
+	const pattern = new RegExp(`${escapeRegExp(atRule)}\\s*\\{([\\s\\S]*?)\\}`, "m");
+	const match = source.match(pattern);
+	return match ? collectDeclarations(match[1]) : {};
+}
+function collectDeclarations(source) {
+	const declarations = {};
+	const pattern = /(--[a-z0-9-]+)\s*:\s*([^;]+);/gi;
+	let match;
+	while (match = pattern.exec(source)) declarations[match[1]] = match[2].trim();
+	return declarations;
+}
+function matchTheme(state, options) {
+	const lightPrimary = state.rootVars["--primary"];
+	if (!lightPrimary) return null;
+	for (const theme of PRESET_THEMES) {
+		let registryTheme;
+		try {
+			registryTheme = buildRegistryTheme({
+				...DEFAULT_DESIGN_SYSTEM_FOR_MATCHING,
+				...options,
+				theme
+			}).cssVars;
+		} catch {
+			continue;
+		}
+		const expectedLight = registryTheme.light?.primary;
+		const expectedDark = registryTheme.dark?.primary;
+		if (!valuesMatch(lightPrimary, expectedLight)) continue;
+		const darkPrimary = state.darkVars["--primary"];
+		if (darkPrimary && expectedDark && !valuesMatch(darkPrimary, expectedDark)) continue;
+		return theme;
+	}
+	return null;
+}
+function getFallbackTheme(baseColor) {
+	return baseColor === DEFAULT_PRESET_CONFIG.baseColor ? DEFAULT_PRESET_CONFIG.theme : baseColor;
+}
+function matchRadius(value, style) {
+	if (!value) return null;
+	const normalizedValue = normalizeCssValue(value);
+	const styleDefaultRadius = getStyleDefaultRadius(style);
+	if (styleDefaultRadius && normalizedValue === normalizeCssValue(getRadiusValue(styleDefaultRadius))) return "default";
+	for (const radius of PRESET_RADII) if (normalizedValue === normalizeCssValue(getRadiusValue(radius))) return radius === "default" ? "medium" : radius;
+	return null;
+}
+async function resolveBodyFont(config, state) {
+	const activeVariable = resolveActiveBodyFontVariable(state);
+	const managedFonts = await readManagedAstroFontsFromProject(config.resolvedPaths.cwd);
+	const matchedManagedFont = matchManagedFont(activeVariable ? managedFonts.find((font) => font.cssVariable === activeVariable) : managedFonts.find((font) => ROOT_FONT_VARIABLE_SET.has(font.cssVariable)), "body");
+	if (matchedManagedFont) return matchedManagedFont;
+	const matchedImport = activeVariable ? matchFontByImports(state.imports, activeVariable) : null;
+	if (matchedImport) return matchedImport;
+	for (const variable of ROOT_FONT_VARIABLES) {
+		const matched = matchFontFromVariable(state, variable);
+		if (matched) return matched;
+	}
+	return null;
+}
+async function resolveHeadingFont(config, state, bodyFont) {
+	const managedHeadingFont = matchManagedFont((await readManagedAstroFontsFromProject(config.resolvedPaths.cwd)).find((font) => font.cssVariable === "--font-heading"), "heading");
+	if (managedHeadingFont) return managedHeadingFont === bodyFont ? "inherit" : managedHeadingFont;
+	const resolved = resolveFontValue(state, "--font-heading");
+	const matched = resolved ? parseFontFromFamily(resolved) : null;
+	if (matched) return matched === bodyFont ? "inherit" : matched;
+	const value = getCssVariableValue(state, "--font-heading");
+	const reference = value ? getVarReference(value) : null;
+	if (reference && ROOT_FONT_VARIABLE_SET.has(reference)) {
+		const matchedRootFont = matchFontFromVariable(state, reference);
+		if (!matchedRootFont || matchedRootFont === bodyFont) return "inherit";
+		return matchedRootFont;
+	}
+	return "inherit";
+}
+function normalizePresetStyle(style) {
+	if (!style) return null;
+	const normalized = style.replace(/^(bejamas|base|radix)-/, "");
+	if (!PRESET_STYLE_SET.has(normalized)) return null;
+	return normalized;
+}
+function normalizeFontHeading(fontHeading, bodyFont) {
+	const normalized = fontHeading === bodyFont ? "inherit" : fontHeading;
+	return PRESET_FONT_HEADING_SET.has(normalized) ? normalized : DEFAULT_PRESET_CONFIG.fontHeading;
+}
+function resolveActiveBodyFontVariable(state) {
+	const htmlOrBodyFont = state.source.match(/(?:html|body)\s*\{[\s\S]*?@apply[^;]*\bfont-(sans|serif|mono)\b[\s\S]*?\}/m)?.[1];
+	if (htmlOrBodyFont) return `--font-${htmlOrBodyFont}`;
+	for (const variable of ROOT_FONT_VARIABLES) if (state.themeVars[variable]) return variable;
+	return null;
+}
+function matchManagedFont(managedFont, slot) {
+	if (!managedFont) return null;
+	for (const font of PRESET_FONTS) {
+		const expected = slot === "heading" ? toManagedAstroFont(`font-heading-${font}`) : toManagedAstroFont(font);
+		if (expected && expected.cssVariable === managedFont.cssVariable && normalizeFontName(expected.name) === normalizeFontName(managedFont.name)) return font;
+	}
+	return null;
+}
+function matchFontByImports(imports, variable) {
+	const matches = imports.flatMap((input) => {
+		const font = parseFontFromDependency(input);
+		const fontValue = font ? getFontValue(font) : null;
+		return font && fontValue?.font.variable === variable ? [font] : [];
+	});
+	return matches.length === 1 ? matches[0] : null;
+}
+function matchFontFromVariable(state, variable) {
+	const resolved = resolveFontValue(state, variable);
+	return resolved ? parseFontFromFamily(resolved) : null;
+}
+function resolveFontValue(state, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return null;
+	seen.add(variable);
+	const value = getCssVariableValue(state, variable);
+	if (!value) return null;
+	const reference = getVarReference(value);
+	if (!reference) return value;
+	if (FONT_VARIABLE_SET.has(reference)) return resolveFontValue(state, reference, seen);
+	return null;
+}
+function getCssVariableValue(state, variable) {
+	const themeValue = state.themeVars[variable];
+	if (themeValue && getVarReference(themeValue) !== variable) return themeValue;
+	return state.rootVars[variable] ?? themeValue ?? null;
+}
+function getVarReference(value) {
+	return normalizeCssValue(value).match(/^var\((--[a-z0-9-]+)\)$/)?.[1] ?? null;
+}
+function parseFontFromDependency(value) {
+	if (!value) return null;
+	const prefix = "@fontsource-variable/";
+	const normalized = normalizeCssValue(value);
+	return normalized.startsWith(prefix) ? toPresetFont(normalized.slice(21)) : null;
+}
+function parseFontFromFamily(value) {
+	if (!value) return null;
+	const primaryFamily = normalizeFontName(value.split(",")[0] ?? "");
+	for (const font of PRESET_FONTS) {
+		const bodyFont = getFontValue(font);
+		const headingFont = getHeadingFontValue(font);
+		if ([
+			font,
+			bodyFont?.title,
+			bodyFont?.font.family.split(",")[0],
+			bodyFont?.font.import,
+			headingFont?.title?.replace(/\s+\(Heading\)$/, ""),
+			headingFont?.font.family.split(",")[0],
+			headingFont?.font.import
+		].some((candidate) => candidate && normalizeFontName(candidate) === primaryFamily)) return font;
+	}
+	return null;
+}
+function toPresetFont(value) {
+	const normalized = normalizeCssValue(value);
+	return PRESET_FONT_SET.has(normalized) ? normalized : null;
+}
+function normalizeFontName(value) {
+	return value.trim().replace(/^['"]|['"]$/g, "").replace(/\s+variable$/i, "").replace(/_/g, "-").replace(/\s+/g, "-").toLowerCase();
+}
+function normalizeCssValue(value) {
+	if (!value) return "";
+	return value.trim().replace(/-?\d*\.\d+/g, (match) => String(Number(match))).replace(/\s+/g, " ").replace(/\s*,\s*/g, ",").replace(/\s*\/\s*/g, "/").replace(/"/g, "'").toLowerCase();
+}
+function valuesMatch(actual, expected) {
+	return normalizeCssValue(actual) === normalizeCssValue(expected);
+}
+function asPresetValue(set, value) {
+	return value && set.has(value) ? value : null;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const DEFAULT_DESIGN_SYSTEM_FOR_MATCHING = {
+	...DEFAULT_PRESET_CONFIG,
+	template: "astro",
+	rtl: false,
+	rtlLanguage: "ar"
+};
+
+//#endregion
+//#region src/commands/preset.ts
+const PRESET_CHART_COLOR_SET = new Set(PRESET_CHART_COLORS);
+function getPresetUrl(code) {
+	return buildUiUrl(`/create?preset=${code}`);
+}
+function decodePresetCode(code) {
+	const decoded = decodePreset(code);
+	if (!decoded) throw new Error(`Invalid preset code: ${code}`);
+	const derived = [];
+	const chartColor = resolveDecodedChartColor(decoded);
+	if (!decoded.chartColor && chartColor) derived.push("chartColor");
+	return {
+		code,
+		derived,
+		url: getPresetUrl(code),
+		values: {
+			...decoded,
+			...chartColor ? { chartColor } : {}
+		},
+		version: code[0]
+	};
+}
+function printPresetDecode(result) {
+	printPresetInfo({
+		code: result.code,
+		fallbacks: result.derived,
+		values: result.values
+	}, { fallbackNote: "  * Compatibility value for older preset versions." });
+}
+function printPresetInfo(preset, options = {}) {
+	logger.log(highlighter.info("Preset"));
+	if (!preset.code || !preset.values) {
+		printEntries({ code: "-" });
+		return;
+	}
+	const fallbacks = preset.fallbacks ?? [];
+	const formatPresetValue = (key, value) => {
+		const suffix = fallbacks.includes(key) ? "*" : "";
+		return `${value ?? "-"}${suffix}`;
+	};
+	printEntries({
+		code: preset.code,
+		version: preset.code[0],
+		style: preset.values.style,
+		baseColor: formatPresetValue("baseColor", preset.values.baseColor),
+		theme: formatPresetValue("theme", preset.values.theme),
+		chartColor: formatPresetValue("chartColor", preset.values.chartColor),
+		iconLibrary: formatPresetValue("iconLibrary", preset.values.iconLibrary),
+		font: formatPresetValue("font", preset.values.font),
+		fontHeading: formatPresetValue("fontHeading", preset.values.fontHeading),
+		radius: formatPresetValue("radius", preset.values.radius),
+		menuAccent: formatPresetValue("menuAccent", preset.values.menuAccent),
+		menuColor: formatPresetValue("menuColor", preset.values.menuColor),
+		url: getPresetUrl(preset.code)
+	});
+	if (fallbacks.length > 0) {
+		logger.log("");
+		logger.log(options.fallbackNote ?? "  * Uses preset defaults for values that could not be inferred from the project.");
+	}
+}
+const decode = new Command().name("decode").description("decode a preset code").argument("<code>", "the preset code to decode").option("--json", "output as JSON.", false).action((code, opts) => {
+	try {
+		const result = decodePresetCode(code);
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		printPresetDecode(result);
+	} catch (error) {
+		handlePresetError(error);
+	}
+});
+const url = new Command().name("url").description("get the create URL for a preset code").argument("<code>", "the preset code").action((code) => {
+	try {
+		logger.log(decodePresetCode(code).url);
+	} catch (error) {
+		handlePresetError(error);
+	}
+});
+const openCommand = new Command().name("open").description("open a preset code in the browser").argument("<code>", "the preset code").action(async (code) => {
+	let presetUrl;
+	try {
+		presetUrl = decodePresetCode(code).url;
+	} catch (error) {
+		handlePresetError(error);
+		return;
+	}
+	logger.break();
+	logger.log(`  Opening ${presetUrl} in your browser.`);
+	logger.break();
+	try {
+		const { default: open } = await import("open");
+		await open(presetUrl);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		handlePresetError(/* @__PURE__ */ new Error(`Failed to open preset URL: ${message}`));
+	}
+});
+const resolve$1 = new Command().name("resolve").alias("info").description("resolve a preset from your project").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--json", "output as JSON.", false).action(async (opts) => {
+	try {
+		const cwd = path.resolve(opts.cwd);
+		if (!existsSync(path.resolve(cwd, "components.json")) && await isMonorepoRoot(cwd)) {
+			const targets = await getMonorepoTargets(cwd);
+			if (targets.length > 0) {
+				if (opts.json) console.log(JSON.stringify({
+					error: "monorepo_root",
+					message: "You are running preset resolve from a monorepo root. Use the -c flag to specify a workspace.",
+					targets: targets.map((target) => target.name)
+				}, null, 2));
+				else formatMonorepoMessage("preset resolve", targets, {
+					binary: "bejamas",
+					cwdFlag: "-c"
+				});
+				process.exit(1);
+			}
+		}
+		const config = await getConfig(cwd);
+		if (!config) {
+			if (opts.json) {
+				console.log(JSON.stringify(null, null, 2));
+				return;
+			}
+			logger.log("No components.json found.");
+			return;
+		}
+		const resolvedPreset = await resolveProjectPreset(config);
+		if (opts.json) {
+			console.log(JSON.stringify(resolvedPreset.code ? resolvedPreset : null, null, 2));
+			return;
+		}
+		printPresetInfo(resolvedPreset);
+	} catch (error) {
+		handleError(error);
+	}
+});
+const preset = new Command().name("preset").description("manage presets").addCommand(decode).addCommand(resolve$1).addCommand(url).addCommand(openCommand).action(() => {
+	preset.outputHelp();
+});
+function resolveDecodedChartColor(decoded) {
+	if (decoded.chartColor) return decoded.chartColor;
+	const legacyChartColor = V1_CHART_COLOR_MAP[decoded.theme];
+	if (legacyChartColor) return legacyChartColor;
+	if (PRESET_CHART_COLOR_SET.has(decoded.theme)) return decoded.theme;
+}
+function printEntries(entries) {
+	const maxKeyLength = Math.max(...Object.keys(entries).map((key) => key.length));
+	for (const [key, value] of Object.entries(entries)) logger.log(`  ${key.padEnd(maxKeyLength + 2)}${value}`);
+}
+function handlePresetError(error) {
+	if (error instanceof Error) logger.error(error.message);
+	process.exit(1);
+}
+
+//#endregion
+//#region src/index.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const program = new Command().name("bejamas").description("bejamas/ui cli").configureHelp({ helpWidth: Math.min(100, process.stdout.columns || 100) }).version(pkg.version, "-v, --version", "output the version number");
+program.addCommand(init);
+program.addCommand(add);
+program.addCommand(apply);
+program.addCommand(preset);
+program.addCommand(info);
+program.addCommand(docs);
+program.addCommand(docsBuild);
+program.addCommand(docsCheck);
+program.parse(process.argv);
+
+//#endregion
+export { program as default };
+//# sourceMappingURL=index.js.map