bejamas 0.2.12 → 0.3.0

package/dist/index.js

@@ -1,21 +1,30 @@
 #!/usr/bin/env node
-import { _ as getWorkspaceConfig, b as highlighter, d as parseJsDocMetadata, g as getConfig, o as extractFrontmatter, p as resolveUiRoot, v as spinner, y as logger } from "./utils-BfJTJvcy.js";
+import { A as renderSemanticIconSvgWithAttributeString, B as normalizeDesignSystemConfig, C as buildUiUrl, D as SEMANTIC_ICON_NAMES, E as ICON_LIBRARY_COLLECTIONS, F as getDocumentLanguage, H as encodePreset, I as getFontPackageName, L as getFontValue, M as RTL_LANGUAGE_VALUES, N as designSystemConfigSchema, O as getSemanticIconNameFromLucideExport, P as getDocumentDirection, R as getHeadingFontValue, S as BASE_COLORS, T as buildRegistryTheme, U as isPresetCode, V as decodePreset, W as fonts, _ as getConfig, b as highlighter, d as parseJsDocMetadata, g as spinner, j as DEFAULT_DESIGN_SYSTEM_CONFIG, k as getSemanticIconNameFromLucidePath, o as extractFrontmatter, p as resolveUiRoot, v as getWorkspaceConfig, w as resolveRegistryUrl, x as BEJAMAS_COMPONENTS_SCHEMA_URL, y as logger, z as getStyleId } from "./utils-BCEkpKMO.js";
 import { Command } from "commander";
 import { createRequire } from "module";
-import path from "path";
+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 { z } from "zod";
-import { bold, cyan, dim, green, magenta, red, white, yellow } from "kleur/colors";
 import { execa } from "execa";
 import prompts from "prompts";
-import fg from "fast-glob";
-import path$1, { extname as extname$1, isAbsolute, join as join$1, relative as relative$1, resolve } from "node:path";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import fs$1 from "node:fs/promises";
+import os$1 from "node:os";
+
+//#region src/registry/context.ts
+let context = { headers: {} };
+function clearRegistryContext() {
+	context.headers = {};
+}
 
+//#endregion
 //#region src/utils/errors.ts
 const MISSING_DIR_OR_EMPTY_PROJECT = "1";
 
@@ -23,7 +32,7 @@ const MISSING_DIR_OR_EMPTY_PROJECT = "1";
 //#region src/preflights/preflight-init.ts
 async function preFlightInit(options) {
 	const errors = {};
-	if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
+	if (!fs.existsSync(options.cwd) || !fs.existsSync(path$1.resolve(options.cwd, "package.json"))) {
 		errors[MISSING_DIR_OR_EMPTY_PROJECT] = true;
 		return {
 			errors,
@@ -37,10 +46,986 @@ async function preFlightInit(options) {
 }
 
 //#endregion
-//#region src/registry/context.ts
-let context = { headers: {} };
-function clearRegistryContext() {
-	context.headers = {};
+//#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 = new Set(["geist", "geist-mono"]);
+const MANAGED_BODY_FONT_CLASSES = new Set(["font-mono", "font-serif"]);
+function compactSource$1(source) {
+	return source.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function upsertImport(source, moduleName, importedName, fallbackNames = []) {
+	const importPattern = /* @__PURE__ */ new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeRegExp$1(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(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) {
+	return `${ASTRO_CONFIG_BLOCK_START}\n/** @type {NonNullable<import("astro/config").AstroUserConfig["fonts"]>} */\nconst ${ASTRO_FONT_CONSTANT} = [${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`}];\n${ASTRO_CONFIG_BLOCK_END}`;
+}
+function buildAstroLayoutFontBlock(fontsToSerialize) {
+	return `${ASTRO_LAYOUT_BLOCK_START}\n${fontsToSerialize.map((font) => `<Font cssVariable="${font.cssVariable}" />`).join("\n")}\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(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 = /* @__PURE__ */ new RegExp(`${escapeRegExp$1(ASTRO_CONFIG_BLOCK_START)}[\\s\\S]*?const\\s+${ASTRO_FONT_CONSTANT}\\s*=\\s*\\[([\\s\\S]*?)\\];[\\s\\S]*?${escapeRegExp$1(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$1(start)}[\\s\\S]*?${escapeRegExp$1(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 = new Set([SHADCN_TAILWIND_IMPORT, BEJAMAS_TAILWIND_IMPORT]);
+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(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(CREATE_BLOCK_START)}[\\s\\S]*?${escapeRegExp(CREATE_BLOCK_END)}\\n*`, "m");
+	const danglingBlockPattern = new RegExp(`\\n*${escapeRegExp(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(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) {
+	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 font = getFontValue(config.font);
+	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));
+	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,
+		tailwind: {
+			...current.tailwind ?? {},
+			baseColor: config.baseColor,
+			cssVariables: true
+		}
+	};
+	await fs.writeJson(filepath, next, { spaces: 2 });
+}
+async function patchCssFileWithTheme(filepath, config, themeVars) {
+	const next = transformDesignSystemCss(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");
+}
+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$1 = transformTemplateLayoutToI18n(current);
+		if (next$1 !== current) await fs.writeFile(filepath, next$1, "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 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)));
+	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 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;
+	return renderSemanticIconSvgWithAttributeString(library, semanticName, attributeString.replace(/\sname=(["'])[^"']+\1/g, "").replace(/\slibrary=(["'])[^"']+\1/g, "").replace(/\sdata-icon-library=(["'])[^"']+\1/g, "").trim());
+}
+
+//#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) {
+	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(/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) {
+	const config = await getConfig(cwd);
+	if (!config) return;
+	const searchRoots = new Set([config.resolvedPaths.components, config.resolvedPaths.ui]);
+	for (const root of Array.from(searchRoots)) {
+		if (!root) continue;
+		const astroFiles = await fg("**/*.astro", {
+			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
@@ -154,7 +1139,39 @@ const TEMPLATES = {
 	"astro-monorepo": "astro-monorepo",
 	"astro-with-component-docs-monorepo": "astro-with-component-docs-monorepo"
 };
-const MONOREPO_TEMPLATE_URL = "https://codeload.github.com/bejamas/ui/tar.gz/main";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path$1.dirname(__filename);
+function resolveLocalTemplatesDir() {
+	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();
+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,
@@ -207,7 +1224,7 @@ async function createProject(options) {
 		logger.break();
 		process.exit(1);
 	}
-	if (fs.existsSync(path.resolve(options.cwd, projectName, "package.json"))) {
+	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.`);
@@ -227,39 +1244,22 @@ async function createProject(options) {
 }
 async function createProjectFromTemplate(projectPath, options) {
 	const createSpinner = spinner(`Creating a new project from template. This may take a few minutes.`).start();
-	const TEMPLATE_TAR_SUBPATH = {
-		astro: "ui-main/templates/astro",
-		"astro-monorepo": "ui-main/templates/monorepo-astro",
-		"astro-with-component-docs-monorepo": "ui-main/templates/monorepo-astro-with-docs"
+	const TEMPLATE_DIRNAME = {
+		astro: "astro",
+		"astro-monorepo": "monorepo-astro",
+		"astro-with-component-docs-monorepo": "monorepo-astro-with-docs"
 	};
 	try {
 		dotenv.config({ quiet: true });
-		const templatePath = path.join(os.tmpdir(), `bejamas-template-${Date.now()}`);
-		await fs.ensureDir(templatePath);
-		const authToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-		const usedAuth = Boolean(authToken);
-		const headers = { "User-Agent": "bejamas-cli" };
-		if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
-		const response = await fetch(MONOREPO_TEMPLATE_URL, { headers });
-		if (!response.ok) {
-			if (response.status === 401 || response.status === 403 || !usedAuth && response.status === 404) throw new Error("Unauthorized to access private template. Set GITHUB_TOKEN or GH_TOKEN (in .env or env) with repo access and try again.");
-			if (response.status === 404) throw new Error("Failed to download template: not found.");
-			throw new Error(`Failed to download template: ${response.status} ${response.statusText}`);
-		}
-		const tarPath = path.resolve(templatePath, "template.tar.gz");
-		await fs.writeFile(tarPath, Buffer.from(await response.arrayBuffer()));
-		const tarSubpath = TEMPLATE_TAR_SUBPATH[options.templateKey];
-		const leafName = tarSubpath.split("/").pop();
-		await execa("tar", [
-			"-xzf",
-			tarPath,
-			"-C",
-			templatePath,
-			"--strip-components=2",
-			tarSubpath
-		]);
-		const extractedPath = path.resolve(templatePath, leafName);
-		await fs.move(extractedPath, projectPath);
+		const templatePath = path$1.join(os.tmpdir(), `bejamas-template-${Date.now()}`);
+		const templateSource = path$1.resolve(LOCAL_TEMPLATES_DIR, TEMPLATE_DIRNAME[options.templateKey]);
+		if (!await fs.pathExists(templateSource)) throw new Error(`Local template not found: ${templateSource}`);
+		await fs.copy(templateSource, projectPath, { filter: (source) => {
+			const basename = path$1.basename(source);
+			return basename !== "node_modules" && basename !== ".astro";
+		} });
+		await removeEmptyTemplateI18nDirs(projectPath);
+		await applyLocalPackageOverrides(projectPath);
 		await fs.remove(templatePath);
 		await execa(options.packageManager, ["install"], { cwd: projectPath });
 		try {
@@ -273,51 +1273,295 @@ async function createProjectFromTemplate(projectPath, options) {
 					"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);
+		} 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 < 2) 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$1 = path.dirname(uiFiles[0].path);
+		const folderName = path.basename(dirname$1);
+		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);
+		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}`);
+	}
+	return result;
+}
+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;
+	for (const componentName of components) try {
+		const registryItem = await fetchRegistryItem(componentName, registryUrl, style);
+		if (!registryItem) {
+			if (verbose) logger.info(`[bejamas-ui] Could not fetch registry for ${componentName}, skipping reorganization`);
+			continue;
+		}
+		if (!shouldReorganizeRegistryUiFiles(registryItem.files, uiDir)) continue;
+		const componentResult = await reorganizeRegistryUiFiles(registryItem.files, uiDir, verbose, overwriteExisting);
+		result.totalMoved += componentResult.totalMoved;
+		result.movedFiles.push(...componentResult.movedFiles);
+		result.skippedFiles.push(...componentResult.skippedFiles);
+		if (componentResult.totalMoved > 0 && verbose) {
+			const subfolder = getSubfolderFromPaths(registryItem.files);
+			logger.info(`[bejamas-ui] Reorganized ${componentName} into ${subfolder}/`);
+		}
+	} catch (err) {
+		if (verbose) logger.warn(`[bejamas-ui] Failed to reorganize ${componentName}: ${err}`);
 	}
+	return result;
 }
 
 //#endregion
 //#region src/utils/shadcn-cli.ts
-const require = createRequire(import.meta.url);
-const PINNED_SHADCN_VERSION = "3.8.5";
+const PINNED_SHADCN_VERSION = "4.1.1";
 const PINNED_SHADCN_PACKAGE = `shadcn@${PINNED_SHADCN_VERSION}`;
-function resolveBundledShadcnEntrypoint() {
-	try {
-		return require.resolve("shadcn");
-	} catch {
-		return null;
-	}
+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 buildPinnedShadcnInvocation(shadcnArgs, bundledEntrypoint = resolveBundledShadcnEntrypoint()) {
-	if (bundledEntrypoint) return {
-		cmd: process.execPath,
-		args: [bundledEntrypoint, ...shadcnArgs],
-		source: "bundled"
-	};
+function getNpmExecutable() {
+	return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function buildPinnedShadcnInvocation(shadcnArgs) {
 	return {
-		cmd: "npx",
+		cmd: getNpmExecutable(),
 		args: [
-			"-y",
-			PINNED_SHADCN_PACKAGE,
+			"exec",
+			"--yes",
+			"--prefix",
+			PINNED_SHADCN_EXEC_PREFIX,
+			`--package=${PINNED_SHADCN_PACKAGE}`,
+			"--",
+			"shadcn",
 			...shadcnArgs
 		],
-		source: "fallback"
+		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
-const DEFAULT_REGISTRY_URL$1 = "https://ui.bejamas.com/r";
-const DEFAULT_COMPONENTS_BASE_COLOR = "neutral";
+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(),
@@ -327,20 +1571,98 @@ const initOptionsSchema = z.object({
 	template: z.string().optional().refine((val) => {
 		if (val) return TEMPLATES[val];
 		return true;
-	}, { message: "Invalid template. Please use 'next' or 'next-monorepo'." }),
-	baseColor: z.string().optional(),
-	baseStyle: z.boolean()
+	}, { 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 buildShadcnInitArgs(baseColor = DEFAULT_COMPONENTS_BASE_COLOR) {
+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 [
-		"init",
-		"--base-color",
-		baseColor
+		...forwardedOptions.slice(0, passthroughIndex),
+		"--reinstall",
+		...forwardedOptions.slice(passthroughIndex)
 	];
 }
-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. (next, next-monorepo)").option("-b, --base-color <base-color>", "the base color to use. (neutral, gray, zinc, stone, slate)", void 0).option("-y, --yes", "skip confirmation prompt.", true).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.").action(async (_components, opts) => {
+function extractOptionsForShadcnInit(rawArgv, cmd) {
+	if (typeof cmd.getOptionValueSource === "function") {
+		const opts = cmd.optsWithGlobals();
+		const forwarded$1 = [];
+		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$1.push(flag);
+			else if (negateFlag) forwarded$1.push(negateFlag);
+		};
+		addBoolean("yes", "--yes");
+		addBoolean("force", "--force");
+		addBoolean("silent", "--silent");
+		addBoolean("reinstall", "--reinstall", "--no-reinstall");
+		const initIndex$1 = rawArgv.findIndex((arg) => arg === "init");
+		if (initIndex$1 !== -1) {
+			const rest$1 = rawArgv.slice(initIndex$1 + 1);
+			const doubleDashIndex = rest$1.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded$1.push(...rest$1.slice(doubleDashIndex));
+		}
+		return forwarded$1;
+	}
+	const initIndex = rawArgv.findIndex((arg) => arg === "init");
+	if (initIndex === -1) return [];
+	const rest = rawArgv.slice(initIndex + 1);
+	const forwarded = [];
+	const filteredFlags = 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);
+		await runInit({
+			...opts,
+			forwardedOptions: extractOptionsForShadcnInit(process.argv.slice(2), cmd)
+		});
 	} catch (error) {
 		logger.break();
 		handleError(error);
@@ -349,6 +1671,7 @@ const init = new Command().name("init").description("initialize your project and
 	}
 });
 async function runInit(options) {
+	const designConfig = resolveDesignSystemConfig(options);
 	let newProjectTemplate;
 	if (!options.skipPreflight) {
 		if ((await preFlightInit(options)).errors[MISSING_DIR_OR_EMPTY_PROJECT]) {
@@ -360,30 +1683,86 @@ async function runInit(options) {
 		}
 	}
 	if (newProjectTemplate) {
-		options.cwd = path.resolve(options.cwd, {
+		const projectPath = {
 			"astro-monorepo": "apps/web",
 			"astro-with-component-docs-monorepo": "apps/web",
 			astro: ""
-		}[newProjectTemplate]);
+		};
+		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 {
 		const env = {
 			...process.env,
-			REGISTRY_URL: process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL$1
+			REGISTRY_URL: resolveRegistryUrl()
 		};
-		const invocation = buildPinnedShadcnInvocation(buildShadcnInitArgs(options.baseColor ?? DEFAULT_COMPONENTS_BASE_COLOR));
-		await execa(invocation.cmd, invocation.args, {
-			stdio: "inherit",
+		const initUrl = buildInitUrl(designConfig, options.themeRef);
+		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
 		});
-	} catch (err) {
+		await syncManagedTailwindCss(options.cwd);
+		const managedFonts = [toManagedAstroFont(designConfig.font), designConfig.fontHeading !== "inherit" ? toManagedAstroFont(`font-heading-${designConfig.fontHeading}`) : null].filter((font) => font !== null);
+		const managedFont = managedFonts.find((font) => font.cssVariable !== "--font-heading");
+		if (managedFonts.length > 0 && managedFont) {
+			await syncAstroFontsInProject(options.cwd, managedFonts, managedFont.cssVariable);
+			await syncAstroManagedFontCss(options.cwd, managedFont.cssVariable);
+			await cleanupAstroFontPackages(options.cwd);
+		}
+		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);
+		}
+	} catch {
 		process.exit(1);
 	}
 }
 
+//#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
 /**
@@ -421,7 +1800,7 @@ function resolveAliasPathUsingTsConfig(inputPath, projectRoot) {
 }
 
 //#endregion
-//#region src/commands/docs.ts
+//#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 {
@@ -460,7 +1839,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) outResolved = mapped;
 						else {
 							const abs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
-							if (abs) outResolved = relative$1(projectRoot, abs);
+							if (abs) outResolved = relative(projectRoot, abs);
 						}
 						if (!outResolved && mapped.startsWith("@/")) outResolved = mapped.replace(/^@\//, "src/");
 						const finalOut = outResolved ?? mapped;
@@ -486,7 +1865,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 					for (let i = 0; i < 6; i += 1) {
 						if (existsSync(resolve(current, "packages/ui/package.json"))) {
 							const abs = resolve(current, "packages/ui");
-							return relative$1(shellCwd, abs) || abs;
+							return relative(shellCwd, abs) || abs;
 						}
 						const parent = resolve(current, "..");
 						if (parent === current) break;
@@ -494,7 +1873,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 					}
 					if (existsSync(resolve(shellCwd, "node_modules/@bejamas/ui/package.json"))) {
 						const abs = resolve(shellCwd, "node_modules/@bejamas/ui");
-						return relative$1(shellCwd, abs) || abs;
+						return relative(shellCwd, abs) || abs;
 					}
 					return "packages/ui";
 				})(),
@@ -533,7 +1912,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 			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-BejBMCLk.js");
+		const mod = await import("./generate-mdx-PPNpe9_J.js");
 		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
 		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
 	} catch (err) {
@@ -541,7 +1920,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 		process.exit(1);
 	}
 }
-const docs = new Command().name("docs:build").alias("docs").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) => {
+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,
@@ -639,19 +2018,19 @@ async function checkDocs({ cwd, json }) {
 			logger.error("Unable to locate @bejamas/ui. Use --cwd to specify the UI package path.");
 			process.exit(1);
 		}
-		const componentsDir = join$1(uiRoot, "src", "components");
+		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$1(e.name).toLowerCase() === ".astro").map((e) => e.name).sort();
+		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$1(componentsDir, file), file);
+			const status = checkComponentDocs(join(componentsDir, file), file);
 			results.push(status);
 		}
 		const complete = results.filter((r) => r.status === "complete");
@@ -718,174 +2097,8 @@ const docsCheck = new Command().name("docs:check").description("check documentat
 	});
 });
 
-//#endregion
-//#region src/utils/astro-imports.ts
-function updateImportAliases(moduleSpecifier, config, isRemote = false) {
-	if (!moduleSpecifier.startsWith("@/") && !isRemote) return moduleSpecifier;
-	let specifier = moduleSpecifier;
-	if (isRemote && specifier.startsWith("@/")) specifier = specifier.replace(/^@\//, "@/registry/new-york/");
-	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(/import\s+["']([^"']+)["']/g, (full, specifier) => {
-		const next = updateImportAliases(specifier, config, false);
-		if (next === specifier) return full;
-		return full.replace(specifier, next);
-	});
-	return updated;
-}
-async function fixAstroImports(cwd, isVerbose) {
-	const config = await getConfig(cwd);
-	if (!config) return;
-	const searchRoots = new Set([config.resolvedPaths.components, config.resolvedPaths.ui]);
-	for (const root of Array.from(searchRoots)) {
-		if (!root) continue;
-		const astroFiles = await fg("**/*.astro", {
-			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$1.relative(cwd, filePath)}`);
-		}
-	}
-}
-
-//#endregion
-//#region src/utils/reorganize-components.ts
-/**
-* Fetches a registry item JSON from the registry URL.
-*/
-async function fetchRegistryItem(componentName, registryUrl) {
-	const url = `${registryUrl}/styles/new-york-v4/${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;
-	}
-}
-/**
-* Extracts the subfolder name from registry file paths.
-* E.g., "components/ui/avatar/Avatar.astro" → "avatar"
-*/
-function getSubfolderFromPaths(files) {
-	const uiFiles = files.filter((f) => f.type === "registry:ui");
-	if (uiFiles.length < 2) 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 firstPath = uiFiles[0].path;
-		const dirname$1 = path$1.dirname(firstPath);
-		const folderName = path$1.basename(dirname$1);
-		if (folderName && folderName !== "ui") return folderName;
-	}
-	return null;
-}
-/**
-* Checks if a path exists.
-*/
-async function pathExists(filePath) {
-	try {
-		await fs$1.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Reorganizes multi-file components into correct subfolders.
-* Only moves files from FLAT location to subfolder.
-* Does NOT touch files already in subfolders.
-* E.g., moves `uiDir/Avatar.astro` to `uiDir/avatar/Avatar.astro`.
-* Returns info about moved files for display purposes.
-*/
-async function reorganizeComponents(components, uiDir, registryUrl, verbose) {
-	const result = {
-		totalMoved: 0,
-		movedFiles: [],
-		skippedFiles: []
-	};
-	if (!uiDir || components.length === 0) return result;
-	for (const componentName of components) try {
-		const registryItem = await fetchRegistryItem(componentName, registryUrl);
-		if (!registryItem) {
-			if (verbose) logger.info(`[bejamas-ui] Could not fetch registry for ${componentName}, skipping reorganization`);
-			continue;
-		}
-		const subfolder = getSubfolderFromPaths(registryItem.files);
-		if (!subfolder) {
-			if (verbose) logger.info(`[bejamas-ui] ${componentName} is single-file or has no subfolder, skipping`);
-			continue;
-		}
-		const uiFiles = registryItem.files.filter((f) => f.type === "registry:ui");
-		const targetDir = path$1.join(uiDir, subfolder);
-		let movedCount = 0;
-		for (const file of uiFiles) {
-			const filename = path$1.basename(file.path);
-			const flatPath = path$1.join(uiDir, filename);
-			const targetPath = path$1.join(targetDir, filename);
-			if (!await pathExists(flatPath)) continue;
-			if (await pathExists(targetPath)) {
-				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);
-			movedCount++;
-			result.totalMoved++;
-			result.movedFiles.push(`${subfolder}/${filename}`);
-			if (verbose) logger.info(`[bejamas-ui] Moved ${filename} → ${subfolder}/${filename}`);
-		}
-		if (movedCount > 0 && verbose) logger.info(`[bejamas-ui] Reorganized ${componentName} into ${subfolder}/`);
-	} catch (err) {
-		if (verbose) logger.warn(`[bejamas-ui] Failed to reorganize ${componentName}: ${err}`);
-	}
-	return result;
-}
-
 //#endregion
 //#region src/commands/add.ts
-const DEFAULT_REGISTRY_URL = "https://ui.bejamas.com/r";
 function extractOptionsForShadcn(rawArgv, cmd) {
 	if (typeof cmd.getOptionValueSource === "function") {
 		const opts = cmd.optsWithGlobals();
@@ -903,13 +2116,25 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 			const value = opts[key];
 			if (typeof value === "string") forwarded$1.push(flag, value);
 		};
+		const addOptionalString = (key, flag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (value === true) {
+				forwarded$1.push(flag);
+				return;
+			}
+			if (typeof value === "string") forwarded$1.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$1 = rawArgv.findIndex((arg) => arg === "add");
 		if (addIndex$1 !== -1) {
 			const rest$1 = rawArgv.slice(addIndex$1 + 1);
@@ -926,13 +2151,15 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 		"-c",
 		"--cwd",
 		"-p",
-		"--path"
+		"--path",
+		"--diff",
+		"--view"
 	]);
 	const filteredFlags = new Set(["-v", "--verbose"]);
-	for (let i = 0; i < rest.length; i += 1) {
-		const token = rest[i];
+	for (let index = 0; index < rest.length; index += 1) {
+		const token = rest[index];
 		if (token === "--") {
-			forwarded.push("--", ...rest.slice(i + 1));
+			forwarded.push("--", ...rest.slice(index + 1));
 			break;
 		}
 		if (!token.startsWith("-")) continue;
@@ -940,36 +2167,38 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 		forwarded.push(token);
 		if (token.includes("=")) continue;
 		if (optionsWithValues.has(token)) {
-			const next = rest[i + 1];
+			const next = rest[index + 1];
 			if (next) {
 				forwarded.push(next);
-				i += 1;
+				index += 1;
 			}
 		}
 	}
 	return forwarded;
 }
-/** Build maps for path rewriting, handling filename collisions */
-async function buildSubfolderMap(components, registryUrl) {
+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)`;
+}
+async function buildSubfolderMap(components, uiDir, registryUrl, style) {
 	const filenameToSubfolders = /* @__PURE__ */ new Map();
-	const componentInfo = /* @__PURE__ */ new Map();
+	let requiresReorganization = false;
 	for (const componentName of components) {
-		const registryItem = await fetchRegistryItem(componentName, registryUrl);
+		const registryItem = await fetchRegistryItem(componentName, registryUrl, style);
 		if (!registryItem) continue;
+		if (shouldReorganizeRegistryUiFiles(registryItem.files, uiDir)) requiresReorganization = true;
 		const subfolder = getSubfolderFromPaths(registryItem.files);
 		if (!subfolder) continue;
-		const files = [];
 		for (const file of registryItem.files) if (file.type === "registry:ui") {
-			const filename = path$1.basename(file.path);
-			files.push(filename);
+			const filename = path.basename(file.path);
 			const subfolders = filenameToSubfolders.get(filename) || [];
 			subfolders.push(subfolder);
 			filenameToSubfolders.set(filename, subfolders);
 		}
-		componentInfo.set(subfolder, {
-			subfolder,
-			files
-		});
 	}
 	const uniqueMap = /* @__PURE__ */ new Map();
 	const sharedFilenames = /* @__PURE__ */ new Set();
@@ -979,35 +2208,29 @@ async function buildSubfolderMap(components, registryUrl) {
 	});
 	return {
 		uniqueMap,
-		componentInfo,
-		sharedFilenames
+		sharedFilenames,
+		requiresReorganization
 	};
 }
-/**
-* Rewrite file paths to include correct subfolders.
-* Handles shared filenames (like index.ts) by tracking current component context.
-*/
 function rewritePaths(paths, mapResult) {
-	const { uniqueMap, componentInfo, sharedFilenames } = mapResult;
+	const { uniqueMap, sharedFilenames } = mapResult;
 	let currentSubfolder = null;
 	return paths.map((filePath) => {
-		const filename = path$1.basename(filePath);
-		const parentDir = path$1.basename(path$1.dirname(filePath));
+		const filename = path.basename(filePath);
+		const parentDir = path.basename(path.dirname(filePath));
 		const uniqueMapping = uniqueMap.get(filename);
 		if (uniqueMapping) {
-			const expectedSubfolder = path$1.dirname(uniqueMapping);
+			const expectedSubfolder = path.dirname(uniqueMapping);
 			currentSubfolder = expectedSubfolder;
-			if (parentDir !== expectedSubfolder) return `${path$1.dirname(filePath)}/${uniqueMapping}`;
+			if (parentDir !== expectedSubfolder) return `${path.dirname(filePath)}/${uniqueMapping}`;
 			return filePath;
 		}
 		if (sharedFilenames.has(filename) && currentSubfolder) {
-			const expectedSubfolder = currentSubfolder;
-			if (parentDir !== expectedSubfolder) return `${path$1.dirname(filePath)}/${expectedSubfolder}/${filename}`;
+			if (parentDir !== currentSubfolder) return `${path.dirname(filePath)}/${currentSubfolder}/${filename}`;
 		}
 		return filePath;
 	});
 }
-/** Fetch available components from the registry */
 async function fetchAvailableComponents(registryUrl) {
 	const indexUrl = `${registryUrl}/index.json`;
 	const response = await fetch(indexUrl);
@@ -1015,14 +2238,13 @@ async function fetchAvailableComponents(registryUrl) {
 	const data = await response.json();
 	return Array.isArray(data) ? data : [];
 }
-/** Prompt user to select components interactively */
 async function promptForComponents(registryUrl) {
 	const checkingSpinner = spinner("Checking registry.").start();
 	let components;
 	try {
 		components = await fetchAvailableComponents(registryUrl);
 		checkingSpinner.succeed();
-	} catch (error) {
+	} catch {
 		checkingSpinner.fail();
 		logger.error("Failed to fetch available components from registry.");
 		return null;
@@ -1035,9 +2257,9 @@ async function promptForComponents(registryUrl) {
 		type: "autocompleteMultiselect",
 		name: "selected",
 		message: "Which components would you like to add?",
-		choices: components.filter((c) => !c.type || c.type === "registry:ui").map((c) => ({
-			title: c.name,
-			value: c.name
+		choices: components.filter((component) => !component.type || component.type === "registry:ui").map((component) => ({
+			title: component.name,
+			value: component.name
 		})),
 		hint: "- Space to select. Return to submit.",
 		instructions: false
@@ -1045,7 +2267,6 @@ async function promptForComponents(registryUrl) {
 	if (!selected) return null;
 	return selected;
 }
-/** Parse shadcn output to extract file lists (stdout has paths, stderr has headers) */
 function parseShadcnOutput(stdout, stderr) {
 	const result = {
 		created: [],
@@ -1072,23 +2293,34 @@ function parseShadcnOutput(stdout, stderr) {
 			if (!allPaths.includes(filePath)) allPaths.push(filePath);
 		}
 	}
-	let idx = 0;
-	for (let i = 0; i < createdCount && idx < allPaths.length; i++) result.created.push(allPaths[idx++]);
-	for (let i = 0; i < updatedCount && idx < allPaths.length; i++) result.updated.push(allPaths[idx++]);
-	for (let i = 0; i < skippedCount && idx < allPaths.length; i++) result.skipped.push(allPaths[idx++]);
+	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(packages, forwardedOptions, isVerbose, isSilent, subfolderMapResult) {
+async function addComponents(cwd, packages, forwardedOptions, isVerbose, isSilent, inspectionMode) {
 	const env = {
 		...process.env,
-		REGISTRY_URL: process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL
+		REGISTRY_URL: resolveRegistryUrl()
 	};
+	await ensurePinnedShadcnExecPrefix();
 	const invocation = buildPinnedShadcnInvocation(buildShadcnAddArgs(packages, forwardedOptions));
 	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",
@@ -1103,13 +2335,21 @@ async function addComponents(packages, forwardedOptions, isVerbose, isSilent, su
 			logger.info(`[bejamas-ui] Raw stdout: ${stdout}`);
 			logger.info(`[bejamas-ui] Raw stderr: ${stderr}`);
 		}
-		const parsed = parseShadcnOutput(stdout, stderr);
+		if (inspectionMode) {
+			if (stdout) process.stdout.write(stdout.endsWith("\n") ? stdout : `${stdout}\n`);
+			if (stderr) process.stderr.write(stderr.endsWith("\n") ? stderr : `${stderr}\n`);
+		}
+		const parsed = inspectionMode ? {
+			created: [],
+			updated: [],
+			skipped: []
+		} : parseShadcnOutput(stdout, stderr);
 		if (result.exitCode !== 0) {
 			if (result.stderr) logger.error(result.stderr);
 			process.exit(result.exitCode);
 		}
 		return parsed;
-	} catch (err) {
+	} catch {
 		registrySpinner.fail();
 		logger.error("Failed to add components");
 		process.exit(1);
@@ -1125,22 +2365,24 @@ function buildShadcnAddArgs(packages, forwardedOptions) {
 		...forwardedOptions
 	];
 }
-const add = new Command().name("add").description("Add components via the pinned 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("--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 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 = process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL;
+	const registryUrl = resolveRegistryUrl();
 	if (wantsAll && componentsToAdd.length === 0) {
 		const fetchingSpinner = spinner("Fetching available components.", { silent: isSilent }).start();
 		try {
-			componentsToAdd = (await fetchAvailableComponents(registryUrl)).filter((c) => !c.type || c.type === "registry:ui").map((c) => c.name);
+			componentsToAdd = (await fetchAvailableComponents(registryUrl)).filter((component) => !component.type || component.type === "registry:ui").map((component) => component.name);
 			fetchingSpinner.succeed();
-		} catch (error) {
+		} catch {
 			fetchingSpinner.fail();
 			logger.error("Failed to fetch available components from registry.");
 			process.exit(1);
@@ -1166,19 +2408,35 @@ const add = new Command().name("add").description("Add components via the pinned
 		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 i = 0; i < componentsToAdd.length; i++) {
-		const component = componentsToAdd[i];
+	for (let index = 0; index < componentsToAdd.length; index += 1) {
+		const component = componentsToAdd[index];
 		if (totalComponents > 1 && !isSilent) {
 			logger.break();
-			logger.info(highlighter.info(`[${i + 1}/${totalComponents}]`) + ` Adding ${highlighter.success(component)}...`);
+			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) {
+					await syncAstroFontsInProject(cwd, mergeManagedAstroFonts(await readManagedAstroFontsFromProject(cwd), nextFont), nextFont.cssVariable);
+					await syncAstroManagedFontCss(cwd, nextFont.cssVariable);
+					await cleanupAstroFontPackages(cwd);
+				}
+			}
 		}
-		const subfolderMapResult = await buildSubfolderMap([component], registryUrl);
-		const parsed = await addComponents([component], forwardedOptions, verbose, isSilent, subfolderMapResult);
 		let skippedCount = 0;
-		if (uiDir) skippedCount = (await reorganizeComponents([component], uiDir, registryUrl, verbose)).skippedFiles.length;
-		if (!isSilent) {
-			uiDir && path$1.relative(cwd, uiDir);
+		if (!inspectionMode && uiDir && subfolderMapResult.requiresReorganization) skippedCount = (await reorganizeComponents([component], uiDir, registryUrl, verbose, activeStyle)).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);
@@ -1193,13 +2451,36 @@ const add = new Command().name("add").description("Add components via the pinned
 			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(`Skipped ${skippedPaths.length} file${skippedPaths.length > 1 ? "s" : ""}: (use --overwrite)`);
+				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.");
 		}
 	}
-	await fixAstroImports(cwd, verbose);
+	if (!inspectionMode) await fixAstroImports(cwd, verbose);
+});
+
+//#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
@@ -1208,7 +2489,9 @@ 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(info);
 program.addCommand(docs);
+program.addCommand(docsBuild);
 program.addCommand(docsCheck);
 program.parse(process.argv);
 var src_default = program;