bejamas 0.3.3 → 0.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { A as getSemanticIconNameFromLucidePath, B as getStyleId, C as buildUiUrl, D as ICON_LIBRARY_COLLECTIONS, E as buildRegistryTheme, F as getDocumentDirection, G as fonts, H as decodePreset, I as getDocumentLanguage, L as getFontPackageName, M as DEFAULT_DESIGN_SYSTEM_CONFIG, N as RTL_LANGUAGE_VALUES, O as SEMANTIC_ICON_NAMES, P as designSystemConfigSchema, R as getFontValue, S as BASE_COLORS, T as ICON_LIBRARIES, U as encodePreset, V as normalizeDesignSystemConfig, W as isPresetCode, _ as getConfig, b as highlighter, d as parseJsDocMetadata, g as spinner, j as renderSemanticIconSvgWithAttributeString, k as getSemanticIconNameFromLucideExport, o as extractFrontmatter, p as resolveUiRoot, v as getWorkspaceConfig, w as resolveRegistryUrl, x as BEJAMAS_COMPONENTS_SCHEMA_URL, y as logger, z as getHeadingFontValue } from "./utils-B0HWwl6F.js";
+import { $ as PRESET_RADII, A as getSemanticIconNameFromLucideExport, B as getHeadingFontValue, C as BASE_COLORS, D as buildRegistryTheme, E as ICON_LIBRARIES, F as designSystemConfigSchema, G as DEFAULT_PRESET_CONFIG, H as getStyleDefaultRadius, I as getDocumentDirection, J as PRESET_FONTS, K as PRESET_BASE_COLORS, L as getDocumentLanguage, M as renderSemanticIconSvgWithAttributeString, N as DEFAULT_DESIGN_SYSTEM_CONFIG, O as ICON_LIBRARY_COLLECTIONS, P as RTL_LANGUAGE_VALUES, Q as PRESET_MENU_COLORS, R as getFontPackageName, S as BEJAMAS_COMPONENTS_SCHEMA_URL, T as resolveRegistryUrl, U as getStyleId, V as getRadiusValue, W as normalizeDesignSystemConfig, X as PRESET_ICON_LIBRARIES, Y as PRESET_FONT_HEADINGS, Z as PRESET_MENU_ACCENTS, _ as getConfig, at as isPresetCode, b as logger, d as parseJsDocMetadata, et as PRESET_STYLES, g as spinner, it as encodePreset, j as getSemanticIconNameFromLucidePath, k as SEMANTIC_ICON_NAMES, nt as V1_CHART_COLOR_MAP, o as extractFrontmatter, ot as fonts, p as resolveUiRoot, q as PRESET_CHART_COLORS, rt as decodePreset, tt as PRESET_THEMES, v as getWorkspaceConfig, w as buildUiUrl, x as highlighter, y as getProjectInfo, z as getFontValue } from "./utils-otwzm7kH.js";
 import { Command } from "commander";
 import { createRequire } from "module";
 import path, { extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -28,6 +28,7 @@ function clearRegistryContext() {
 //#endregion
 //#region src/utils/errors.ts
 const MISSING_DIR_OR_EMPTY_PROJECT = "1";
+const MISSING_CONFIG = "3";
 
 //#endregion
 //#region src/preflights/preflight-init.ts
@@ -66,11 +67,11 @@ 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) {
+function escapeRegExp$2(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function upsertImport(source, moduleName, importedName, fallbackNames = []) {
-	const importPattern = /* @__PURE__ */ new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeRegExp$1(moduleName)}["'];?`);
+	const importPattern = /* @__PURE__ */ new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeRegExp$2(moduleName)}["'];?`);
 	if (importPattern.test(source)) return source.replace(importPattern, (_match, importsSource) => {
 		const imports = importsSource.split(",").map((value) => value.trim()).filter(Boolean);
 		if (!imports.includes(importedName)) imports.push(importedName);
@@ -108,7 +109,7 @@ function upsertManagedBodyFontClass(source, cssVariable) {
 	});
 }
 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 markerPattern = /* @__PURE__ */ new RegExp(`${escapeRegExp$2(ASTRO_CONFIG_BLOCK_START)}[\\s\\S]*?const\\s+${ASTRO_FONT_CONSTANT}\\s*=\\s*\\[([\\s\\S]*?)\\];[\\s\\S]*?${escapeRegExp$2(ASTRO_CONFIG_BLOCK_END)}`);
 	const match = source.match(markerPattern);
 	if (!match) return [];
 	return (match[1].match(/\{[\s\S]*?\}/g) ?? []).map((entry) => {
@@ -137,7 +138,7 @@ function normalizeManagedAstroFontSubsets(subsets) {
 	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");
+	const blockPattern = new RegExp(`${escapeRegExp$2(start)}[\\s\\S]*?${escapeRegExp$2(end)}`, "m");
 	if (blockPattern.test(source)) return source.replace(blockPattern, nextBlock);
 	return null;
 }
@@ -571,7 +572,7 @@ const [welcomePrefix, welcomeSuffix = ""] =
 `
 	}
 ];
-function escapeRegExp(value) {
+function escapeRegExp$1(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function compactCss(source) {
@@ -581,8 +582,8 @@ 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");
+	const fullBlockPattern = new RegExp(`\\n*${escapeRegExp$1(CREATE_BLOCK_START)}[\\s\\S]*?${escapeRegExp$1(CREATE_BLOCK_END)}\\n*`, "m");
+	const danglingBlockPattern = new RegExp(`\\n*${escapeRegExp$1(CREATE_BLOCK_START)}[\\s\\S]*$`, "m");
 	return compactCss(source.replace(fullBlockPattern, "\n\n").replace(danglingBlockPattern, "\n\n"));
 }
 function buildCssVarBlock(selector, vars) {
@@ -593,7 +594,7 @@ function buildCssVarBlock(selector, vars) {
 	].join("\n");
 }
 function replaceTopLevelBlock(source, selector, nextBlock) {
-	const pattern = new RegExp(`^${escapeRegExp(selector)}\\s*\\{[\\s\\S]*?^\\}`, "m");
+	const pattern = new RegExp(`^${escapeRegExp$1(selector)}\\s*\\{[\\s\\S]*?^\\}`, "m");
 	if (pattern.test(source)) return source.replace(pattern, nextBlock);
 	const layerIndex = source.indexOf("@layer base");
 	if (layerIndex !== -1) return `${source.slice(0, layerIndex).trimEnd()}\n\n${nextBlock}\n\n${source.slice(layerIndex).trimStart()}`;
@@ -701,18 +702,27 @@ function upsertBaseLayerHtmlFont(source, fontClass) {
 	});
 }
 function transformDesignSystemCss(source, config, themeVars) {
+	return transformDesignSystemFontCss(transformDesignSystemThemeCss(source, config, themeVars), config);
+}
+function transformDesignSystemThemeCss(source, config, themeVars) {
 	const effectiveThemeVars = themeVars ?? buildRegistryTheme(config).cssVars;
 	const rootVars = {
 		...Object.fromEntries(Object.entries(effectiveThemeVars.theme ?? {}).filter(([key]) => key !== "bejamas-font-family")),
 		...effectiveThemeVars.light ?? {}
 	};
 	const darkVars = { ...effectiveThemeVars.dark ?? {} };
-	const 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));
+	return compactCss(next);
+}
+function transformDesignSystemFontCss(source, config) {
+	const font = getFontValue(config.font);
+	const tailwindImport = resolveManagedTailwindImport(source);
+	let next = stripLegacyCreateBlock(source);
+	next = upsertImports(next, [tailwindImport]);
 	next = upsertThemeInlineFont(next, font?.font.variable);
 	if (font) next = upsertBaseLayerHtmlFont(next, fontClassFromCssVariable(font.font.variable));
 	return compactCss(next);
@@ -737,6 +747,8 @@ async function patchComponentsJson(filepath, config) {
 		style: getStyleId(config.style),
 		iconLibrary: config.iconLibrary,
 		rtl: config.rtl,
+		menuColor: config.menuColor,
+		menuAccent: config.menuAccent,
 		tailwind: {
 			...current.tailwind ?? {},
 			baseColor: config.baseColor,
@@ -745,10 +757,17 @@ async function patchComponentsJson(filepath, config) {
 	};
 	await fs.writeJson(filepath, next, { spaces: 2 });
 }
+async function patchComponentsJsonWithTheme(filepath, config) {
+	await patchComponentsJson(filepath, config);
+}
 async function patchCssFileWithTheme(filepath, config, themeVars) {
 	const next = transformDesignSystemCss(await fs.readFile(filepath, "utf8"), config, themeVars);
 	await fs.writeFile(filepath, next, "utf8");
 }
+async function patchCssFileWithThemeOnly(filepath, config, themeVars) {
+	const next = transformDesignSystemThemeCss(await fs.readFile(filepath, "utf8"), config, themeVars);
+	await fs.writeFile(filepath, next, "utf8");
+}
 async function patchCssFileWithAstroFont(filepath, fontVariable) {
 	const next = transformAstroManagedFontCss(await fs.readFile(filepath, "utf8"), fontVariable);
 	await fs.writeFile(filepath, next, "utf8");
@@ -886,10 +905,36 @@ async function applyDesignSystemToProject(projectPath, config, options = {}) {
 	await Promise.all([path.resolve(projectPath, "src/i18n/ui.ts"), path.resolve(projectPath, "apps/web/src/i18n/ui.ts")].map((filepath) => patchTemplateI18nFile(filepath, config)));
 	await Promise.all([path.resolve(projectPath, "src/layouts/Layout.astro"), path.resolve(projectPath, "apps/web/src/layouts/Layout.astro")].map((filepath) => patchLayoutFile(filepath, config)));
 	await Promise.all([path.resolve(projectPath, "src/pages/index.astro"), path.resolve(projectPath, "apps/web/src/pages/index.astro")].map((filepath) => patchStarterPageFile(filepath, config)));
+	await syncDesignSystemFontsInProject(projectPath, config);
+}
+async function applyDesignSystemThemeToProject(projectPath, config, options = {}) {
+	const componentJsonFiles = await fg("**/components.json", {
+		cwd: projectPath,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.astro/**"
+		]
+	});
+	const cssFiles = /* @__PURE__ */ new Set();
+	for (const relativePath of componentJsonFiles) {
+		const absolutePath = path.resolve(projectPath, relativePath);
+		await patchComponentsJsonWithTheme(absolutePath, config);
+		const cssPath = (await fs.readJson(absolutePath))?.tailwind?.css;
+		if (typeof cssPath === "string" && cssPath.length > 0) cssFiles.add(path.resolve(path.dirname(absolutePath), cssPath));
+	}
+	await Promise.all(Array.from(cssFiles).map((filepath) => patchCssFileWithThemeOnly(filepath, config, options.themeVars)));
+	await syncPackageIconDependencies(projectPath, config);
+}
+async function applyDesignSystemFontToProject(projectPath, config) {
+	await syncDesignSystemFontsInProject(projectPath, config);
+}
+async function syncDesignSystemFontsInProject(projectPath, config) {
 	const managedFonts = [toManagedAstroFont(config.font), config.fontHeading !== "inherit" ? toManagedAstroFont(`font-heading-${config.fontHeading}`) : null].filter((font) => font !== null);
 	const managedFont = managedFonts.find((font) => font.cssVariable !== "--font-heading");
 	if (managedFonts.length > 0 && managedFont) {
 		await syncAstroFontsInProject(projectPath, managedFonts, managedFont.cssVariable);
+		await syncAstroManagedFontCss(projectPath, managedFont.cssVariable);
 		await cleanupAstroFontPackages(projectPath);
 	}
 }
@@ -1454,9 +1499,9 @@ async function getInstalledUiComponents(cwd) {
 //#endregion
 //#region src/utils/reorganize-components.ts
 async function fetchRegistryItem(componentName, registryUrl, style = "bejamas-juno") {
-	const url = `${registryUrl}/styles/${style}/${componentName}.json`;
+	const url$1 = `${registryUrl}/styles/${style}/${componentName}.json`;
 	try {
-		const response = await fetch(url);
+		const response = await fetch(url$1);
 		if (!response.ok) {
 			const fallbackUrl = `${registryUrl}/${componentName}.json`;
 			const fallbackResponse = await fetch(fallbackUrl);
@@ -1592,7 +1637,7 @@ async function reorganizeComponents(components, uiDir, registryUrl, verbose, sty
 
 //#endregion
 //#region src/utils/shadcn-cli.ts
-const PINNED_SHADCN_VERSION = "4.1.1";
+const PINNED_SHADCN_VERSION = "4.6.0";
 const PINNED_SHADCN_PACKAGE = `shadcn@${PINNED_SHADCN_VERSION}`;
 const PINNED_SHADCN_EXEC_PREFIX = path.join(os$1.tmpdir(), "bejamas-shadcn", PINNED_SHADCN_VERSION);
 async function ensurePinnedShadcnExecPrefix() {
@@ -1829,45 +1874,43 @@ async function runInit(options) {
 		return await getConfig(options.cwd);
 	}
 	try {
-		const env = {
-			...process.env,
-			REGISTRY_URL: resolveRegistryUrl()
-		};
-		const initUrl = buildInitUrl(designConfig, options.themeRef);
-		const themeVars = options.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0;
-		const shouldReinstall = shouldReinstallExistingComponents(options);
-		const reinstallComponents = shouldReinstall ? await getInstalledUiComponents(options.cwd) : [];
-		const forwardedOptions = ensureShadcnReinstallFlag(options.forwardedOptions ?? [], shouldReinstall);
-		await runShadcnCommand({
-			cwd: options.cwd,
-			args: [
-				"init",
-				initUrl,
-				...reinstallComponents,
-				...forwardedOptions
-			],
-			env
-		});
-		await syncManagedTailwindCss(options.cwd);
-		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);
-		}
-		await applyDesignSystemToProject(options.cwd, designConfig, { themeVars });
-		if (reinstallComponents.length > 0) {
-			const config = await getConfig(options.cwd);
-			const uiDir = config?.resolvedPaths.ui ?? "";
-			const activeStyle = config?.style ?? "bejamas-juno";
-			if (uiDir) await reorganizeComponents(reinstallComponents, uiDir, resolveRegistryUrl(), false, activeStyle, true);
-			await fixAstroImports(options.cwd, false);
-		}
+		return await runExistingProjectInit(options, designConfig);
 	} catch {
 		process.exit(1);
 	}
 }
+async function runExistingProjectInit(options, designConfig = resolveDesignSystemConfig(options)) {
+	const env = {
+		...process.env,
+		REGISTRY_URL: resolveRegistryUrl()
+	};
+	const initUrl = buildInitUrl(designConfig, options.themeRef);
+	const themeVars = options.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0;
+	const shouldReinstall = shouldReinstallExistingComponents(options);
+	const reinstallComponents = shouldReinstall ? await getInstalledUiComponents(options.cwd) : [];
+	const forwardedOptions = ensureShadcnReinstallFlag(options.forwardedOptions ?? [], shouldReinstall);
+	await runShadcnCommand({
+		cwd: options.cwd,
+		args: [
+			"init",
+			initUrl,
+			...reinstallComponents,
+			...forwardedOptions
+		],
+		env
+	});
+	await syncManagedTailwindCss(options.cwd);
+	await syncDesignSystemFontsInProject(options.cwd, designConfig);
+	await applyDesignSystemToProject(options.cwd, designConfig, { themeVars });
+	if (reinstallComponents.length > 0) {
+		const config = await getConfig(options.cwd);
+		const uiDir = config?.resolvedPaths.ui ?? "";
+		const activeStyle = config?.style ?? "bejamas-juno";
+		if (uiDir) await reorganizeComponents(reinstallComponents, uiDir, resolveRegistryUrl(), false, activeStyle, true);
+		await fixAstroImports(options.cwd, false);
+	}
+	return await getConfig(options.cwd);
+}
 
 //#endregion
 //#region src/commands/docs.ts
@@ -2043,7 +2086,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-_F9W0nYJ.js");
+		const mod = await import("./generate-mdx-oWy6Hzgd.js");
 		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
 		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
 	} catch (err) {
@@ -2595,6 +2638,495 @@ const add = new Command().name("add").description("Add components via the Bejama
 	if (!inspectionMode) await fixAstroImports(cwd, verbose);
 });
 
+//#endregion
+//#region src/utils/file-helper.ts
+const FILE_BACKUP_SUFFIX = ".bak";
+var FileBackupError = class extends Error {
+	constructor(filePath) {
+		super(`Could not back up ${filePath}.`);
+		this.name = "FileBackupError";
+		this.filePath = filePath;
+	}
+};
+function createFileBackup(filePath) {
+	if (!fs.existsSync(filePath)) return null;
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (fs.existsSync(backupPath)) return null;
+	try {
+		fs.copyFileSync(filePath, backupPath);
+		return backupPath;
+	} catch {
+		return null;
+	}
+}
+function restoreFileBackup(filePath) {
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (!fs.existsSync(backupPath)) return false;
+	try {
+		fs.copyFileSync(backupPath, filePath);
+		fs.unlinkSync(backupPath);
+		return true;
+	} catch (error) {
+		console.error(`Warning: Could not restore backup file ${backupPath}: ${error}`);
+		return false;
+	}
+}
+function deleteFileBackup(filePath) {
+	const backupPath = `${filePath}${FILE_BACKUP_SUFFIX}`;
+	if (!fs.existsSync(backupPath)) return false;
+	try {
+		fs.unlinkSync(backupPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/get-monorepo-info.ts
+const FRAMEWORK_CONFIG_FILES = [
+	"next.config.*",
+	"vite.config.*",
+	"astro.config.*",
+	"remix.config.*",
+	"nuxt.config.*",
+	"svelte.config.*",
+	"gatsby-config.*",
+	"angular.json"
+];
+async function isMonorepoRoot(cwd) {
+	if (fs.existsSync(path.resolve(cwd, "pnpm-workspace.yaml"))) return true;
+	const packageJsonPath = path.resolve(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		if ((await fs.readJson(packageJsonPath)).workspaces) return true;
+	} catch {
+		return false;
+	}
+	if (fs.existsSync(path.resolve(cwd, "lerna.json"))) return true;
+	if (fs.existsSync(path.resolve(cwd, "nx.json"))) return true;
+	return false;
+}
+async function getMonorepoTargets(cwd) {
+	const patterns = await getWorkspacePatterns(cwd);
+	if (!patterns.length) return [];
+	const dirs = await fg(patterns, {
+		cwd,
+		onlyDirectories: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const targets = [];
+	for (const dir of dirs) {
+		const fullPath = path.resolve(cwd, dir);
+		if (!fs.existsSync(path.resolve(fullPath, "package.json"))) continue;
+		const hasComponentsJson = fs.existsSync(path.resolve(fullPath, "components.json"));
+		const hasFrameworkConfig = FRAMEWORK_CONFIG_FILES.some((pattern) => fg.sync(pattern, {
+			cwd: fullPath,
+			dot: true
+		}).length > 0);
+		if (hasComponentsJson || hasFrameworkConfig) targets.push({
+			name: dir,
+			hasConfig: hasComponentsJson
+		});
+	}
+	return targets;
+}
+function formatMonorepoMessage(command, targets, options = {}) {
+	const binary = options.binary ?? "bejamas";
+	const cwdFlag = options.cwdFlag ?? "-c";
+	logger.break();
+	logger.log(`It looks like you are running ${highlighter.info(command)} from a monorepo root.`);
+	logger.log(`To use ${binary} in a specific workspace, use the ${highlighter.info(cwdFlag)} flag:`);
+	logger.break();
+	for (const target of targets) logger.log(`  ${binary} ${command} ${cwdFlag} ${target.name}`);
+	logger.break();
+}
+async function getWorkspacePatterns(cwd) {
+	const patterns = [];
+	const pnpmWorkspacePath = path.resolve(cwd, "pnpm-workspace.yaml");
+	if (fs.existsSync(pnpmWorkspacePath)) {
+		const content = await fs.readFile(pnpmWorkspacePath, "utf8");
+		const matches = Array.from(content.matchAll(/^\s*-\s*["']?([^"'\n#]+)["']?\s*$/gm));
+		for (const match of matches) patterns.push(match[1].trim());
+	}
+	const packageJsonPath = path.resolve(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		const packageJson = await fs.readJson(packageJsonPath);
+		const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces?.packages;
+		if (Array.isArray(workspaces)) patterns.push(...workspaces.filter((pattern) => !pattern.startsWith("!")));
+	} catch {
+		return Array.from(new Set(patterns));
+	}
+	return Array.from(new Set(patterns));
+}
+
+//#endregion
+//#region src/commands/apply.ts
+const applyOptionsSchema = z.object({
+	cwd: z.string(),
+	positionalPreset: z.string().optional(),
+	preset: z.string().optional(),
+	only: z.union([z.boolean(), z.string()]).optional(),
+	yes: z.boolean(),
+	silent: z.boolean()
+});
+const APPLY_ONLY_VALUES = ["theme", "font"];
+var ApplyOnlyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyOnlyError";
+	}
+};
+var ApplyPresetError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyPresetError";
+	}
+};
+var ApplyWorkspaceSyncError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApplyWorkspaceSyncError";
+	}
+};
+const apply = new Command().name("apply").description("apply a preset to an existing project").argument("[preset]", "the preset to apply").option("--preset <preset>", "preset configuration to apply").option("--only [parts]", "apply only parts of a preset: theme, font").option("-y, --yes", "skip confirmation prompt.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-s, --silent", "mute output.", false).action(async (positionalPreset, opts) => {
+	try {
+		const options = applyOptionsSchema.parse({
+			...opts,
+			cwd: path.resolve(opts.cwd),
+			positionalPreset
+		});
+		const rawPreset = resolveApplyPreset(options);
+		const explicitOnly = resolveApplyOnly(options.only);
+		validateApplyOnlyPreset({
+			preset: rawPreset,
+			only: explicitOnly
+		});
+		const preflight = await preFlightApply(options);
+		if (preflight.errors[MISSING_DIR_OR_EMPTY_PROJECT]) {
+			logger.break();
+			logger.error(`The ${highlighter.info("apply")} command only works in an existing project.`);
+			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
+			logger.break();
+			process.exit(1);
+		}
+		if (preflight.errors[MISSING_CONFIG]) {
+			logger.break();
+			logger.error(`No ${highlighter.info("components.json")} found at ${highlighter.info(options.cwd)}.`);
+			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
+			logger.break();
+			process.exit(1);
+		}
+		const existingConfig = preflight.config;
+		if (!existingConfig) process.exit(1);
+		if (!rawPreset) {
+			await printPresetBuilderGuidance(options);
+			process.exit(0);
+		}
+		const resolvedPreset = resolveApplyPresetSource(rawPreset);
+		const only = explicitOnly ?? resolveApplyOnly(resolvedPreset.only ?? getPresetUrlOnly(rawPreset));
+		const designConfig = resolveApplyDesignSystemConfig(resolvedPreset, existingConfig);
+		await confirmApply({
+			cwd: options.cwd,
+			only,
+			silent: options.silent,
+			yes: options.yes
+		});
+		await withFileBackups(await getApplyConfigPaths(existingConfig), async () => {
+			if (only) await runPartialApply(options.cwd, designConfig, resolvedPreset, only);
+			else await runExistingProjectInit({
+				cwd: options.cwd,
+				components: void 0,
+				yes: true,
+				reinstall: true,
+				defaults: false,
+				force: false,
+				silent: options.silent,
+				isNewProject: false,
+				srcDir: false,
+				cssVariables: true,
+				template: "astro",
+				preset: resolvedPreset.preset,
+				baseColor: void 0,
+				baseStyle: true,
+				rtl: existingConfig.rtl ?? false,
+				lang: void 0,
+				themeRef: resolvedPreset.themeRef,
+				forwardedOptions: ["--yes", "--force"]
+			}, designConfig);
+			const config = await getConfig(options.cwd);
+			if (!config) throw new Error("Could not read components.json after applying preset.");
+			await syncApplyWorkspaceConfigs(config, { only });
+		});
+		if (!options.silent) {
+			logger.break();
+			logger.log("Preset applied successfully.");
+			logger.break();
+		}
+	} catch (error) {
+		if (error instanceof ApplyOnlyError || error instanceof ApplyPresetError) {
+			for (const line of error.message.split("\n")) logger.error(line);
+			logger.break();
+			process.exit(1);
+		}
+		if (error instanceof FileBackupError) {
+			logger.error(`Could not back up ${highlighter.info("components.json")}. Aborting.`);
+			logger.break();
+			process.exit(1);
+		}
+		if (error instanceof ApplyWorkspaceSyncError) {
+			logger.error(error.message);
+			logger.break();
+			process.exit(1);
+		}
+		logger.break();
+		handleError(error);
+	} finally {
+		clearRegistryContext();
+	}
+});
+function resolveApplyPreset(options) {
+	const positionalPreset = options.positionalPreset?.trim();
+	const flagPreset = options.preset?.trim();
+	if (positionalPreset && flagPreset && positionalPreset !== flagPreset) throw new ApplyPresetError(`Received two different preset values. Use either the positional preset or ${highlighter.info("--preset")}, or pass the same value to both.`);
+	return flagPreset ?? positionalPreset;
+}
+function getPresetUrlOnly(preset$1) {
+	if (!isUrl(preset$1)) return;
+	return new URL(preset$1).searchParams.get("only") ?? void 0;
+}
+function resolveApplyOnly(value) {
+	if (value === void 0 || value === false) return;
+	if (value === true) throw new ApplyOnlyError([
+		"Missing value for --only.",
+		`Use one or more of: ${APPLY_ONLY_VALUES.join(", ")}.`,
+		"Example: bejamas apply <preset> --only theme,font."
+	].join("\n"));
+	return parseApplyOnlyParts(value);
+}
+function parseApplyOnlyParts(value) {
+	const aliases = {
+		theme: "theme",
+		font: "font",
+		fonts: "font"
+	};
+	const parts = value.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+	const invalid = parts.filter((part) => !aliases[part]);
+	if (!parts.length || invalid.length) throw new ApplyOnlyError([
+		`Invalid value for --only: ${value}.`,
+		`Use one or more of: ${APPLY_ONLY_VALUES.join(", ")}.`,
+		"Example: bejamas apply <preset> --only theme,font."
+	].join("\n"));
+	return Array.from(new Set(parts.map((part) => aliases[part])));
+}
+function validateApplyOnlyPreset(options) {
+	if (!options.only || options.preset) return;
+	throw new ApplyOnlyError(["Missing preset for --only.", "Use: bejamas apply <preset> --only theme,font."].join("\n"));
+}
+function resolveApplyPresetSource(preset$1) {
+	if (isPresetCode(preset$1)) {
+		validatePresetCode(preset$1);
+		return { preset: preset$1 };
+	}
+	if (!isUrl(preset$1)) throw new ApplyPresetError(`Invalid preset: ${highlighter.info(preset$1)}. Use a preset code or a Bejamas create/init URL containing a preset code.`);
+	const url$1 = new URL(preset$1);
+	if (!isSupportedPresetUrl(url$1)) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset$1)}. Use a Bejamas create or init URL containing a preset code.`);
+	const code = url$1.searchParams.get("preset")?.trim();
+	if (!code) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset$1)}. Expected a URL containing a preset query parameter.`);
+	validatePresetCode(code);
+	return {
+		preset: code,
+		themeRef: url$1.searchParams.get("themeRef") ?? void 0,
+		only: url$1.searchParams.get("only") ?? void 0
+	};
+}
+async function preFlightApply(options) {
+	const errors = {};
+	if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
+		errors[MISSING_DIR_OR_EMPTY_PROJECT] = true;
+		return {
+			errors,
+			config: null
+		};
+	}
+	if (!fs.existsSync(path.resolve(options.cwd, "components.json"))) {
+		if (await isMonorepoRoot(options.cwd)) {
+			const targets = await getMonorepoTargets(options.cwd);
+			const applyTargets = [];
+			for (const target of targets) {
+				const projectInfo = await getProjectInfo(path.resolve(options.cwd, target.name));
+				if (target.hasConfig || projectInfo?.isAstro) applyTargets.push(target);
+			}
+			if (applyTargets.length > 0) {
+				formatMonorepoMessage("apply --preset <preset>", applyTargets, {
+					binary: "bejamas",
+					cwdFlag: "-c"
+				});
+				process.exit(1);
+			}
+		}
+		errors[MISSING_CONFIG] = true;
+		return {
+			errors,
+			config: null
+		};
+	}
+	try {
+		return {
+			errors,
+			config: await getConfig(options.cwd)
+		};
+	} catch {
+		logger.break();
+		logger.error(`An invalid ${highlighter.info("components.json")} file was found at ${highlighter.info(options.cwd)}.\nBefore you can apply a preset, you must create a valid ${highlighter.info("components.json")} file by running the ${highlighter.info("init")} command.`);
+		logger.break();
+		process.exit(1);
+	}
+}
+async function printPresetBuilderGuidance(options) {
+	if (options.silent) return;
+	const createUrl = buildUiUrl("/create");
+	logger.break();
+	logger.log(`Build your custom preset on ${highlighter.info(createUrl)}.`);
+	logger.log(`Then run ${highlighter.info("bejamas apply --preset <preset>")} with the preset code or preset URL from ui.bejamas.com.`);
+	logger.break();
+}
+async function confirmApply(options) {
+	if (options.yes) return;
+	logger.break();
+	if (!options.only) logger.warn(highlighter.warn("Applying a new preset will overwrite existing UI components, fonts, and CSS variables."));
+	else logger.warn(highlighter.warn("Applying the selected preset parts will update your project configuration and styles."));
+	logger.warn("Commit or stash your changes before continuing so you can easily go back.");
+	if (!options.only) {
+		const reinstallComponents = await getInstalledUiComponents(options.cwd);
+		logger.break();
+		logger.log("  The following components will be re-installed:");
+		if (reinstallComponents.length) for (let index = 0; index < reinstallComponents.length; index += 8) logger.log(`  - ${reinstallComponents.slice(index, index + 8).join(", ")}`);
+		else logger.log("  - No installed UI components were detected.");
+	}
+	logger.break();
+	const { proceed } = await prompts({
+		type: "confirm",
+		name: "proceed",
+		message: "Would you like to continue?",
+		initial: false
+	});
+	if (!proceed) {
+		logger.break();
+		process.exit(1);
+	}
+}
+async function runPartialApply(cwd, designConfig, preset$1, only) {
+	if (only.includes("theme")) {
+		const initUrl = buildInitUrl(designConfig, preset$1.themeRef);
+		await applyDesignSystemThemeToProject(cwd, designConfig, { themeVars: preset$1.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0 });
+		await fixAstroImports(cwd, false);
+	}
+	if (only.includes("font")) await applyDesignSystemFontToProject(cwd, designConfig);
+}
+function resolveApplyDesignSystemConfig(preset$1, existingConfig) {
+	return resolveDesignSystemConfig({
+		preset: preset$1.preset,
+		template: "astro",
+		rtl: existingConfig.rtl ?? false,
+		baseColor: void 0,
+		lang: void 0
+	});
+}
+function validatePresetCode(preset$1) {
+	if (!isPresetCode(preset$1) || !decodePreset(preset$1)) throw new ApplyPresetError(`Invalid preset code: ${highlighter.info(preset$1)}.`);
+}
+async function getApplyConfigPaths(config) {
+	const configPaths = new Set([path.resolve(config.resolvedPaths.cwd, "components.json")]);
+	const workspaceConfig = await getWorkspaceConfig(config);
+	if (workspaceConfig) for (const linkedConfig of Object.values(workspaceConfig)) configPaths.add(path.resolve(linkedConfig.resolvedPaths.cwd, "components.json"));
+	const existingPaths = [];
+	for (const configPath of configPaths) if (await fs.pathExists(configPath)) existingPaths.push(configPath);
+	return existingPaths.sort();
+}
+async function withFileBackups(filePaths, task) {
+	const backedUpPaths = [];
+	const restoreBackupOnExit = () => {
+		for (const filePath of [...backedUpPaths].reverse()) restoreFileBackup(filePath);
+	};
+	try {
+		for (const filePath of filePaths) {
+			if (!createFileBackup(filePath)) throw new FileBackupError(filePath);
+			backedUpPaths.push(filePath);
+		}
+		process.on("exit", restoreBackupOnExit);
+		const result = await task();
+		process.removeListener("exit", restoreBackupOnExit);
+		for (const filePath of backedUpPaths) deleteFileBackup(filePath);
+		return result;
+	} catch (error) {
+		process.removeListener("exit", restoreBackupOnExit);
+		for (const filePath of [...backedUpPaths].reverse()) restoreFileBackup(filePath);
+		throw error;
+	}
+}
+async function syncApplyWorkspaceConfigs(config, options) {
+	if (options.only && !options.only.includes("theme")) return;
+	const linkedConfigs = await getApplyWorkspaceConfigs(config);
+	if (!linkedConfigs.length) return;
+	const patch = {
+		style: config.style,
+		tailwind: {
+			baseColor: config.tailwind.baseColor,
+			cssVariables: config.tailwind.cssVariables
+		},
+		...config.iconLibrary ? { iconLibrary: config.iconLibrary } : {},
+		...config.rtl !== void 0 ? { rtl: config.rtl } : {},
+		...config.menuColor ? { menuColor: config.menuColor } : {},
+		...config.menuAccent ? { menuAccent: config.menuAccent } : {}
+	};
+	try {
+		for (const linkedConfig of linkedConfigs) {
+			const configPath = path.resolve(linkedConfig.resolvedPaths.cwd, "components.json");
+			if (!await fs.pathExists(configPath)) continue;
+			const existingConfig = await fs.readJson(configPath);
+			await fs.writeJson(configPath, {
+				...existingConfig,
+				...patch,
+				tailwind: {
+					...existingConfig.tailwind,
+					...patch.tailwind
+				}
+			}, { spaces: 2 });
+		}
+	} catch (error) {
+		throw new ApplyWorkspaceSyncError(`Failed to sync linked workspace configs.${error instanceof Error ? ` ${error.message}` : ""}`);
+	}
+}
+async function getApplyWorkspaceConfigs(config) {
+	const workspaceConfig = await getWorkspaceConfig(config);
+	if (!workspaceConfig) return [];
+	const linkedConfigs = /* @__PURE__ */ new Map();
+	for (const linkedConfig of Object.values(workspaceConfig)) {
+		if (linkedConfig.resolvedPaths.cwd === config.resolvedPaths.cwd) continue;
+		linkedConfigs.set(linkedConfig.resolvedPaths.cwd, linkedConfig);
+	}
+	return Array.from(linkedConfigs.values()).sort((a, b) => a.resolvedPaths.cwd.localeCompare(b.resolvedPaths.cwd));
+}
+function quoteShellArg(value) {
+	return /[^A-Za-z0-9_./:-]/.test(value) ? JSON.stringify(value) : value;
+}
+function getInitCommand(preset$1) {
+	if (!preset$1) return "bejamas init";
+	return `bejamas init --preset ${quoteShellArg(preset$1)}`;
+}
+function isUrl(value) {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isSupportedPresetUrl(url$1) {
+	const pathname = url$1.pathname.replace(/\/+$/, "");
+	return pathname === "/create" || pathname === "/init";
+}
+
 //#endregion
 //#region src/commands/info.ts
 const info = new Command().name("info").description("proxy to shadcn info").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--json", "output as JSON.", false).action(async (opts) => {
@@ -2618,12 +3150,451 @@ const info = new Command().name("info").description("proxy to shadcn info").opti
 	}
 });
 
+//#endregion
+//#region src/utils/preset-resolve.ts
+const PRESET_BASE_COLOR_SET = new Set(PRESET_BASE_COLORS);
+const PRESET_FONT_SET = new Set(PRESET_FONTS);
+const PRESET_FONT_HEADING_SET = new Set(PRESET_FONT_HEADINGS);
+const PRESET_ICON_LIBRARY_SET = new Set(PRESET_ICON_LIBRARIES);
+const PRESET_MENU_ACCENT_SET = new Set(PRESET_MENU_ACCENTS);
+const PRESET_MENU_COLOR_SET = new Set(PRESET_MENU_COLORS);
+const PRESET_STYLE_SET = new Set(PRESET_STYLES);
+const ROOT_FONT_VARIABLES = [
+	"--font-sans",
+	"--font-serif",
+	"--font-mono"
+];
+const ROOT_FONT_VARIABLE_SET = new Set(ROOT_FONT_VARIABLES);
+const FONT_VARIABLE_SET = new Set([...ROOT_FONT_VARIABLES, "--font-heading"]);
+async function resolveProjectPreset(config) {
+	const style = normalizePresetStyle(config.style);
+	if (!style) return {
+		code: null,
+		fallbacks: [],
+		values: null
+	};
+	const cssState = await readCssState(config.resolvedPaths.tailwindCss);
+	const baseColor = asPresetValue(PRESET_BASE_COLOR_SET, config.tailwind.baseColor) ?? DEFAULT_PRESET_CONFIG.baseColor;
+	const iconLibrary = asPresetValue(PRESET_ICON_LIBRARY_SET, config.iconLibrary) ?? DEFAULT_PRESET_CONFIG.iconLibrary;
+	const menuAccent = asPresetValue(PRESET_MENU_ACCENT_SET, config.menuAccent) ?? DEFAULT_PRESET_CONFIG.menuAccent;
+	const menuColor = asPresetValue(PRESET_MENU_COLOR_SET, config.menuColor) ?? DEFAULT_PRESET_CONFIG.menuColor;
+	const resolvedTheme = matchTheme(cssState, {
+		baseColor,
+		menuAccent,
+		menuColor,
+		style
+	});
+	const theme = resolvedTheme ?? getFallbackTheme(baseColor);
+	const resolvedRadius = matchRadius(cssState.rootVars["--radius"], style);
+	const radius = resolvedRadius ?? DEFAULT_PRESET_CONFIG.radius;
+	const resolvedFont = await resolveBodyFont(config, cssState);
+	const font = resolvedFont ?? DEFAULT_PRESET_CONFIG.font;
+	const resolvedFontHeading = await resolveHeadingFont(config, cssState, font);
+	const values = {
+		style,
+		baseColor,
+		theme,
+		iconLibrary,
+		font,
+		fontHeading: normalizeFontHeading(resolvedFontHeading ?? DEFAULT_PRESET_CONFIG.fontHeading, font),
+		radius,
+		menuAccent,
+		menuColor
+	};
+	const fallbacks = [
+		!asPresetValue(PRESET_BASE_COLOR_SET, config.tailwind.baseColor) && "baseColor",
+		!resolvedTheme && "theme",
+		!asPresetValue(PRESET_ICON_LIBRARY_SET, config.iconLibrary) && "iconLibrary",
+		!resolvedFont && "font",
+		!resolvedFontHeading && "fontHeading",
+		!resolvedRadius && "radius",
+		!asPresetValue(PRESET_MENU_ACCENT_SET, config.menuAccent) && "menuAccent",
+		!asPresetValue(PRESET_MENU_COLOR_SET, config.menuColor) && "menuColor"
+	].filter(Boolean);
+	return {
+		code: encodePreset(values),
+		fallbacks,
+		values
+	};
+}
+async function readCssState(tailwindCssPath) {
+	const fallback = {
+		darkVars: {},
+		imports: [],
+		rootVars: {},
+		source: "",
+		themeVars: {}
+	};
+	if (!tailwindCssPath || !await fs.pathExists(tailwindCssPath)) return fallback;
+	try {
+		const source = await fs.readFile(tailwindCssPath, "utf8");
+		return {
+			darkVars: collectBlockDeclarations(source, ".dark"),
+			imports: collectImports(source),
+			rootVars: collectBlockDeclarations(source, ":root"),
+			source,
+			themeVars: collectAtRuleDeclarations(source, "@theme inline")
+		};
+	} catch {
+		return fallback;
+	}
+}
+function collectImports(source) {
+	const imports = [];
+	const pattern = /@import\s+(?:url\((['"]?)(.+?)\1\)|(['"])(.+?)\3)\s*;/g;
+	let match;
+	while (match = pattern.exec(source)) {
+		const value = match[2] ?? match[4];
+		if (value) imports.push(value);
+	}
+	return imports;
+}
+function collectBlockDeclarations(source, selector) {
+	const pattern = new RegExp(`${escapeRegExp(selector)}\\s*\\{([\\s\\S]*?)\\}`, "m");
+	const match = source.match(pattern);
+	return match ? collectDeclarations(match[1]) : {};
+}
+function collectAtRuleDeclarations(source, atRule) {
+	const pattern = new RegExp(`${escapeRegExp(atRule)}\\s*\\{([\\s\\S]*?)\\}`, "m");
+	const match = source.match(pattern);
+	return match ? collectDeclarations(match[1]) : {};
+}
+function collectDeclarations(source) {
+	const declarations = {};
+	const pattern = /(--[a-z0-9-]+)\s*:\s*([^;]+);/gi;
+	let match;
+	while (match = pattern.exec(source)) declarations[match[1]] = match[2].trim();
+	return declarations;
+}
+function matchTheme(state, options) {
+	const lightPrimary = state.rootVars["--primary"];
+	if (!lightPrimary) return null;
+	for (const theme of PRESET_THEMES) {
+		let registryTheme;
+		try {
+			registryTheme = buildRegistryTheme({
+				...DEFAULT_DESIGN_SYSTEM_FOR_MATCHING,
+				...options,
+				theme
+			}).cssVars;
+		} catch {
+			continue;
+		}
+		const expectedLight = registryTheme.light?.primary;
+		const expectedDark = registryTheme.dark?.primary;
+		if (!valuesMatch(lightPrimary, expectedLight)) continue;
+		const darkPrimary = state.darkVars["--primary"];
+		if (darkPrimary && expectedDark && !valuesMatch(darkPrimary, expectedDark)) continue;
+		return theme;
+	}
+	return null;
+}
+function getFallbackTheme(baseColor) {
+	return baseColor === DEFAULT_PRESET_CONFIG.baseColor ? DEFAULT_PRESET_CONFIG.theme : baseColor;
+}
+function matchRadius(value, style) {
+	if (!value) return null;
+	const normalizedValue = normalizeCssValue(value);
+	const styleDefaultRadius = getStyleDefaultRadius(style);
+	if (styleDefaultRadius && normalizedValue === normalizeCssValue(getRadiusValue(styleDefaultRadius))) return "default";
+	for (const radius of PRESET_RADII) if (normalizedValue === normalizeCssValue(getRadiusValue(radius))) return radius === "default" ? "medium" : radius;
+	return null;
+}
+async function resolveBodyFont(config, state) {
+	const activeVariable = resolveActiveBodyFontVariable(state);
+	const managedFonts = await readManagedAstroFontsFromProject(config.resolvedPaths.cwd);
+	const matchedManagedFont = matchManagedFont(activeVariable ? managedFonts.find((font) => font.cssVariable === activeVariable) : managedFonts.find((font) => ROOT_FONT_VARIABLE_SET.has(font.cssVariable)), "body");
+	if (matchedManagedFont) return matchedManagedFont;
+	const matchedImport = activeVariable ? matchFontByImports(state.imports, activeVariable) : null;
+	if (matchedImport) return matchedImport;
+	for (const variable of ROOT_FONT_VARIABLES) {
+		const matched = matchFontFromVariable(state, variable);
+		if (matched) return matched;
+	}
+	return null;
+}
+async function resolveHeadingFont(config, state, bodyFont) {
+	const managedHeadingFont = matchManagedFont((await readManagedAstroFontsFromProject(config.resolvedPaths.cwd)).find((font) => font.cssVariable === "--font-heading"), "heading");
+	if (managedHeadingFont) return managedHeadingFont === bodyFont ? "inherit" : managedHeadingFont;
+	const resolved = resolveFontValue(state, "--font-heading");
+	const matched = resolved ? parseFontFromFamily(resolved) : null;
+	if (matched) return matched === bodyFont ? "inherit" : matched;
+	const value = getCssVariableValue(state, "--font-heading");
+	const reference = value ? getVarReference(value) : null;
+	if (reference && ROOT_FONT_VARIABLE_SET.has(reference)) {
+		const matchedRootFont = matchFontFromVariable(state, reference);
+		if (!matchedRootFont || matchedRootFont === bodyFont) return "inherit";
+		return matchedRootFont;
+	}
+	return "inherit";
+}
+function normalizePresetStyle(style) {
+	if (!style) return null;
+	const normalized = style.replace(/^(bejamas|base|radix)-/, "");
+	if (!PRESET_STYLE_SET.has(normalized)) return null;
+	return normalized;
+}
+function normalizeFontHeading(fontHeading, bodyFont) {
+	const normalized = fontHeading === bodyFont ? "inherit" : fontHeading;
+	return PRESET_FONT_HEADING_SET.has(normalized) ? normalized : DEFAULT_PRESET_CONFIG.fontHeading;
+}
+function resolveActiveBodyFontVariable(state) {
+	const htmlOrBodyFont = state.source.match(/(?:html|body)\s*\{[\s\S]*?@apply[^;]*\bfont-(sans|serif|mono)\b[\s\S]*?\}/m)?.[1];
+	if (htmlOrBodyFont) return `--font-${htmlOrBodyFont}`;
+	for (const variable of ROOT_FONT_VARIABLES) if (state.themeVars[variable]) return variable;
+	return null;
+}
+function matchManagedFont(managedFont, slot) {
+	if (!managedFont) return null;
+	for (const font of PRESET_FONTS) {
+		const expected = slot === "heading" ? toManagedAstroFont(`font-heading-${font}`) : toManagedAstroFont(font);
+		if (expected && expected.cssVariable === managedFont.cssVariable && normalizeFontName(expected.name) === normalizeFontName(managedFont.name)) return font;
+	}
+	return null;
+}
+function matchFontByImports(imports, variable) {
+	const matches = imports.flatMap((input) => {
+		const font = parseFontFromDependency(input);
+		const fontValue = font ? getFontValue(font) : null;
+		return font && fontValue?.font.variable === variable ? [font] : [];
+	});
+	return matches.length === 1 ? matches[0] : null;
+}
+function matchFontFromVariable(state, variable) {
+	const resolved = resolveFontValue(state, variable);
+	return resolved ? parseFontFromFamily(resolved) : null;
+}
+function resolveFontValue(state, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return null;
+	seen.add(variable);
+	const value = getCssVariableValue(state, variable);
+	if (!value) return null;
+	const reference = getVarReference(value);
+	if (!reference) return value;
+	if (FONT_VARIABLE_SET.has(reference)) return resolveFontValue(state, reference, seen);
+	return null;
+}
+function getCssVariableValue(state, variable) {
+	const themeValue = state.themeVars[variable];
+	if (themeValue && getVarReference(themeValue) !== variable) return themeValue;
+	return state.rootVars[variable] ?? themeValue ?? null;
+}
+function getVarReference(value) {
+	return normalizeCssValue(value).match(/^var\((--[a-z0-9-]+)\)$/)?.[1] ?? null;
+}
+function parseFontFromDependency(value) {
+	if (!value) return null;
+	const prefix = "@fontsource-variable/";
+	const normalized = normalizeCssValue(value);
+	return normalized.startsWith(prefix) ? toPresetFont(normalized.slice(21)) : null;
+}
+function parseFontFromFamily(value) {
+	if (!value) return null;
+	const primaryFamily = normalizeFontName(value.split(",")[0] ?? "");
+	for (const font of PRESET_FONTS) {
+		const bodyFont = getFontValue(font);
+		const headingFont = getHeadingFontValue(font);
+		if ([
+			font,
+			bodyFont?.title,
+			bodyFont?.font.family.split(",")[0],
+			bodyFont?.font.import,
+			headingFont?.title?.replace(/\s+\(Heading\)$/, ""),
+			headingFont?.font.family.split(",")[0],
+			headingFont?.font.import
+		].some((candidate) => candidate && normalizeFontName(candidate) === primaryFamily)) return font;
+	}
+	return null;
+}
+function toPresetFont(value) {
+	const normalized = normalizeCssValue(value);
+	return PRESET_FONT_SET.has(normalized) ? normalized : null;
+}
+function normalizeFontName(value) {
+	return value.trim().replace(/^['"]|['"]$/g, "").replace(/\s+variable$/i, "").replace(/_/g, "-").replace(/\s+/g, "-").toLowerCase();
+}
+function normalizeCssValue(value) {
+	if (!value) return "";
+	return value.trim().replace(/-?\d*\.\d+/g, (match) => String(Number(match))).replace(/\s+/g, " ").replace(/\s*,\s*/g, ",").replace(/\s*\/\s*/g, "/").replace(/"/g, "'").toLowerCase();
+}
+function valuesMatch(actual, expected) {
+	return normalizeCssValue(actual) === normalizeCssValue(expected);
+}
+function asPresetValue(set, value) {
+	return value && set.has(value) ? value : null;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const DEFAULT_DESIGN_SYSTEM_FOR_MATCHING = {
+	...DEFAULT_PRESET_CONFIG,
+	template: "astro",
+	rtl: false,
+	rtlLanguage: "ar"
+};
+
+//#endregion
+//#region src/commands/preset.ts
+const PRESET_CHART_COLOR_SET = new Set(PRESET_CHART_COLORS);
+function getPresetUrl(code) {
+	return buildUiUrl(`/create?preset=${code}`);
+}
+function decodePresetCode(code) {
+	const decoded = decodePreset(code);
+	if (!decoded) throw new Error(`Invalid preset code: ${code}`);
+	const derived = [];
+	const chartColor = resolveDecodedChartColor(decoded);
+	if (!decoded.chartColor && chartColor) derived.push("chartColor");
+	return {
+		code,
+		derived,
+		url: getPresetUrl(code),
+		values: {
+			...decoded,
+			...chartColor ? { chartColor } : {}
+		},
+		version: code[0]
+	};
+}
+function printPresetDecode(result) {
+	printPresetInfo({
+		code: result.code,
+		fallbacks: result.derived,
+		values: result.values
+	}, { fallbackNote: "  * Compatibility value for older preset versions." });
+}
+function printPresetInfo(preset$1, options = {}) {
+	logger.log(highlighter.info("Preset"));
+	if (!preset$1.code || !preset$1.values) {
+		printEntries({ code: "-" });
+		return;
+	}
+	const fallbacks = preset$1.fallbacks ?? [];
+	const formatPresetValue = (key, value) => {
+		const suffix = fallbacks.includes(key) ? "*" : "";
+		return `${value ?? "-"}${suffix}`;
+	};
+	printEntries({
+		code: preset$1.code,
+		version: preset$1.code[0],
+		style: preset$1.values.style,
+		baseColor: formatPresetValue("baseColor", preset$1.values.baseColor),
+		theme: formatPresetValue("theme", preset$1.values.theme),
+		chartColor: formatPresetValue("chartColor", preset$1.values.chartColor),
+		iconLibrary: formatPresetValue("iconLibrary", preset$1.values.iconLibrary),
+		font: formatPresetValue("font", preset$1.values.font),
+		fontHeading: formatPresetValue("fontHeading", preset$1.values.fontHeading),
+		radius: formatPresetValue("radius", preset$1.values.radius),
+		menuAccent: formatPresetValue("menuAccent", preset$1.values.menuAccent),
+		menuColor: formatPresetValue("menuColor", preset$1.values.menuColor),
+		url: getPresetUrl(preset$1.code)
+	});
+	if (fallbacks.length > 0) {
+		logger.log("");
+		logger.log(options.fallbackNote ?? "  * Uses preset defaults for values that could not be inferred from the project.");
+	}
+}
+const decode = new Command().name("decode").description("decode a preset code").argument("<code>", "the preset code to decode").option("--json", "output as JSON.", false).action((code, opts) => {
+	try {
+		const result = decodePresetCode(code);
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		printPresetDecode(result);
+	} catch (error) {
+		handlePresetError(error);
+	}
+});
+const url = new Command().name("url").description("get the create URL for a preset code").argument("<code>", "the preset code").action((code) => {
+	try {
+		logger.log(decodePresetCode(code).url);
+	} catch (error) {
+		handlePresetError(error);
+	}
+});
+const openCommand = new Command().name("open").description("open a preset code in the browser").argument("<code>", "the preset code").action(async (code) => {
+	let presetUrl;
+	try {
+		presetUrl = decodePresetCode(code).url;
+	} catch (error) {
+		handlePresetError(error);
+		return;
+	}
+	logger.break();
+	logger.log(`  Opening ${presetUrl} in your browser.`);
+	logger.break();
+	try {
+		const { default: open } = await import("open");
+		await open(presetUrl);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		handlePresetError(/* @__PURE__ */ new Error(`Failed to open preset URL: ${message}`));
+	}
+});
+const resolve$1 = new Command().name("resolve").alias("info").description("resolve a preset from your project").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--json", "output as JSON.", false).action(async (opts) => {
+	try {
+		const cwd = path.resolve(opts.cwd);
+		if (!existsSync(path.resolve(cwd, "components.json")) && await isMonorepoRoot(cwd)) {
+			const targets = await getMonorepoTargets(cwd);
+			if (targets.length > 0) {
+				if (opts.json) console.log(JSON.stringify({
+					error: "monorepo_root",
+					message: "You are running preset resolve from a monorepo root. Use the -c flag to specify a workspace.",
+					targets: targets.map((target) => target.name)
+				}, null, 2));
+				else formatMonorepoMessage("preset resolve", targets, {
+					binary: "bejamas",
+					cwdFlag: "-c"
+				});
+				process.exit(1);
+			}
+		}
+		const config = await getConfig(cwd);
+		if (!config) {
+			if (opts.json) {
+				console.log(JSON.stringify(null, null, 2));
+				return;
+			}
+			logger.log("No components.json found.");
+			return;
+		}
+		const resolvedPreset = await resolveProjectPreset(config);
+		if (opts.json) {
+			console.log(JSON.stringify(resolvedPreset.code ? resolvedPreset : null, null, 2));
+			return;
+		}
+		printPresetInfo(resolvedPreset);
+	} catch (error) {
+		handleError(error);
+	}
+});
+const preset = new Command().name("preset").description("manage presets").addCommand(decode).addCommand(resolve$1).addCommand(url).addCommand(openCommand).action(() => {
+	preset.outputHelp();
+});
+function resolveDecodedChartColor(decoded) {
+	if (decoded.chartColor) return decoded.chartColor;
+	const legacyChartColor = V1_CHART_COLOR_MAP[decoded.theme];
+	if (legacyChartColor) return legacyChartColor;
+	if (PRESET_CHART_COLOR_SET.has(decoded.theme)) return decoded.theme;
+}
+function printEntries(entries) {
+	const maxKeyLength = Math.max(...Object.keys(entries).map((key) => key.length));
+	for (const [key, value] of Object.entries(entries)) logger.log(`  ${key.padEnd(maxKeyLength + 2)}${value}`);
+}
+function handlePresetError(error) {
+	if (error instanceof Error) logger.error(error.message);
+	process.exit(1);
+}
+
 //#endregion
 //#region src/index.ts
 const pkg = createRequire(import.meta.url)("../package.json");
 const program = new Command().name("bejamas").description("bejamas/ui cli").configureHelp({ helpWidth: Math.min(100, process.stdout.columns || 100) }).version(pkg.version, "-v, --version", "output the version number");
 program.addCommand(init);
 program.addCommand(add);
+program.addCommand(apply);
+program.addCommand(preset);
 program.addCommand(info);
 program.addCommand(docs);
 program.addCommand(docsBuild);