bejamas 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as PRESET_RADII, A as getSemanticIconNameFromLucideExport, B as getHeadingFontValue, C as BASE_COLORS, D as buildRegistryTheme, E as ICON_LIBRARIES, F as designSystemConfigSchema, G as DEFAULT_PRESET_CONFIG, H as getStyleDefaultRadius, I as getDocumentDirection, J as PRESET_FONTS, K as PRESET_BASE_COLORS, L as getDocumentLanguage, M as renderSemanticIconSvgWithAttributeString, N as DEFAULT_DESIGN_SYSTEM_CONFIG, O as ICON_LIBRARY_COLLECTIONS, P as RTL_LANGUAGE_VALUES, Q as PRESET_MENU_COLORS, R as getFontPackageName, S as BEJAMAS_COMPONENTS_SCHEMA_URL, T as resolveRegistryUrl, U as getStyleId, V as getRadiusValue, W as normalizeDesignSystemConfig, X as PRESET_ICON_LIBRARIES, Y as PRESET_FONT_HEADINGS, Z as PRESET_MENU_ACCENTS, _ as getConfig, at as isPresetCode, b as logger, d as parseJsDocMetadata, et as PRESET_STYLES, g as spinner, it as encodePreset, j as getSemanticIconNameFromLucidePath, k as SEMANTIC_ICON_NAMES, nt as V1_CHART_COLOR_MAP, o as extractFrontmatter, ot as fonts, p as resolveUiRoot, q as PRESET_CHART_COLORS, rt as decodePreset, tt as PRESET_THEMES, v as getWorkspaceConfig, w as buildUiUrl, x as highlighter, y as getProjectInfo, z as getFontValue } from "./utils-CyYWo_qS.js";
+import { $ as PRESET_MENU_COLORS, A as SEMANTIC_ICON_NAMES, B as getFontValue, C as BEJAMAS_COMPONENTS_SCHEMA_URL, D as ICON_LIBRARIES, E as resolveRegistryUrl, F as RTL_LANGUAGE_VALUES, G as normalizeDesignSystemConfig, H as getRadiusValue, I as designSystemConfigSchema, J as PRESET_CHART_COLORS, K as DEFAULT_PRESET_CONFIG, L as getDocumentDirection, M as getSemanticIconNameFromLucidePath, N as renderSemanticIconSvgWithAttributeString, O as buildRegistryTheme, P as DEFAULT_DESIGN_SYSTEM_CONFIG, Q as PRESET_MENU_ACCENTS, R as getDocumentLanguage, S as highlighter, T as buildUiUrl, U as getStyleDefaultRadius, V as getHeadingFontValue, W as getStyleId, X as PRESET_FONT_HEADINGS, Y as PRESET_FONTS, Z as PRESET_ICON_LIBRARIES, _ as findCommonRoot, at as encodePreset, b as getProjectInfo, d as parseJsDocMetadata, et as PRESET_RADII, g as spinner, it as decodePreset, j as getSemanticIconNameFromLucideExport, k as ICON_LIBRARY_COLLECTIONS, nt as PRESET_THEMES, o as extractFrontmatter, ot as isPresetCode, p as resolveUiRoot, q as PRESET_BASE_COLORS, rt as V1_CHART_COLOR_MAP, st as fonts, tt as PRESET_STYLES, v as getConfig, w as BASE_COLORS, x as logger, y as getWorkspaceConfig, z as getFontPackageName } from "./utils-Dmd3Tydo.js";
 import { Command } from "commander";
 import { createRequire } from "module";
 import path, { extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -18,6 +18,8 @@ import { execa } from "execa";
 import prompts from "prompts";
 import * as tar from "tar";
 import os$1 from "node:os";
+import { stripVTControlCharacters } from "node:util";
+import { StringDecoder } from "node:string_decoder";
 
 //#region src/registry/context.ts
 let context = { headers: {} };
@@ -25,17 +27,12 @@ function clearRegistryContext() {
 	context.headers = {};
 }
 
-//#endregion
-//#region src/utils/errors.ts
-const MISSING_DIR_OR_EMPTY_PROJECT = "1";
-const MISSING_CONFIG = "3";
-
 //#endregion
 //#region src/preflights/preflight-init.ts
 async function preFlightInit(options) {
 	const errors = {};
 	if (!fs.existsSync(options.cwd) || !fs.existsSync(path$1.resolve(options.cwd, "package.json"))) {
-		errors[MISSING_DIR_OR_EMPTY_PROJECT] = true;
+		errors["1"] = true;
 		return {
 			errors,
 			projectInfo: null
@@ -62,8 +59,17 @@ const ASTRO_CONFIG_CANDIDATES = [
 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"]);
+const ASTRO_FONTSOURCE_FONT_NAMES = /* @__PURE__ */ new Set(["geist", "geist-mono"]);
+const MANAGED_BODY_FONT_CLASSES = /* @__PURE__ */ new Set(["font-mono", "font-serif"]);
+function parseStringArray(source) {
+	if (!source) return void 0;
+	try {
+		const parsed = JSON.parse(source);
+		return Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string") ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
 function compactSource$1(source) {
 	return source.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
 }
@@ -71,23 +77,25 @@ 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$2(moduleName)}["'];?`);
+	const importPattern = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeRegExp$2(moduleName)}["'];?`);
 	if (importPattern.test(source)) return source.replace(importPattern, (_match, importsSource) => {
 		const imports = importsSource.split(",").map((value) => value.trim()).filter(Boolean);
 		if (!imports.includes(importedName)) imports.push(importedName);
 		for (const name of fallbackNames) if (!imports.includes(name)) imports.unshift(name);
 		return `import { ${Array.from(new Set(imports)).join(", ")} } from "${moduleName}";`;
 	});
-	const importLine = `import { ${Array.from(new Set([...fallbackNames, importedName])).join(", ")} } from "${moduleName}";`;
+	const importLine = `import { ${Array.from(/* @__PURE__ */ new Set([...fallbackNames, importedName])).join(", ")} } from "${moduleName}";`;
 	const frontmatterEnd = source.indexOf("---", 3);
 	if (source.startsWith("---") && frontmatterEnd !== -1) return `${source.slice(0, frontmatterEnd).trimEnd()}\n${importLine}\n${source.slice(frontmatterEnd)}`;
 	return `${importLine}\n${source}`;
 }
 function buildAstroConfigFontBlock(fontsToSerialize) {
-	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}`;
+	const body = fontsToSerialize.length === 0 ? "" : `\n${fontsToSerialize.map((font) => `  {\n    provider: fontProviders.${font.provider}(),\n    name: ${JSON.stringify(font.name)},\n    cssVariable: ${JSON.stringify(font.cssVariable)},\n${font.weights ? `    weights: ${JSON.stringify(font.weights)},\n` : ""}    subsets: ${JSON.stringify(font.subsets)},\n  },`).join("\n")}\n`;
+	return `${ASTRO_CONFIG_BLOCK_START}\n/** @type {NonNullable<import("astro").AstroUserConfig["fonts"]>} */\nconst ${ASTRO_FONT_CONSTANT} = [${body}];\n${ASTRO_CONFIG_BLOCK_END}`;
 }
 function buildAstroLayoutFontBlock(fontsToSerialize) {
-	return `${ASTRO_LAYOUT_BLOCK_START}\n${fontsToSerialize.map((font) => `<Font cssVariable="${font.cssVariable}" />`).join("\n")}\n${ASTRO_LAYOUT_BLOCK_END}`;
+	const body = fontsToSerialize.map((font) => `<Font cssVariable="${font.cssVariable}" />`).join("\n");
+	return `${ASTRO_LAYOUT_BLOCK_START}\n${body}\n${ASTRO_LAYOUT_BLOCK_END}`;
 }
 function bodyFontClassFromCssVariable(cssVariable) {
 	if (cssVariable === "--font-mono" || cssVariable === "--font-serif") return fontClassFromCssVariable(cssVariable);
@@ -102,14 +110,14 @@ function upsertManagedBodyFontClass(source, cssVariable) {
 		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;
+		const nextClasses = bodyClass ? Array.from(/* @__PURE__ */ new Set([...existingClasses, bodyClass])) : existingClasses;
 		let nextAttrs = attrs.replace(classPattern, "");
 		if (nextClasses.length > 0) nextAttrs = `${nextAttrs} class=${quote}${nextClasses.join(" ")}${quote}`;
 		return `<body${nextAttrs}${selfClosing}>`;
 	});
 }
 function parseManagedAstroFonts(source) {
-	const markerPattern = /* @__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 markerPattern = new RegExp(`${escapeRegExp$2(ASTRO_CONFIG_BLOCK_START)}[\\s\\S]*?const\\s+${ASTRO_FONT_CONSTANT}\\s*=\\s*\\[([\\s\\S]*?)\\];[\\s\\S]*?${escapeRegExp$2(ASTRO_CONFIG_BLOCK_END)}`);
 	const match = source.match(markerPattern);
 	if (!match) return [];
 	return (match[1].match(/\{[\s\S]*?\}/g) ?? []).map((entry) => {
@@ -117,19 +125,14 @@ function parseManagedAstroFonts(source) {
 		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];
+		const weights = parseStringArray(entry.match(/weights:\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
+			subsets: parseStringArray(subsetsSource) ?? ["latin"],
+			...weights && { weights }
 		};
 	}).filter((value) => value !== null);
 }
@@ -233,7 +236,8 @@ function toManagedAstroFont(fontName) {
 		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)
+		subsets: normalizeManagedAstroFontSubsets(font.font.subsets),
+		...font.font.weight?.length && { weights: [...font.font.weight] }
 	};
 }
 function mergeManagedAstroFonts(currentFonts, nextFont) {
@@ -325,7 +329,7 @@ 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 MANAGED_TAILWIND_IMPORTS = /* @__PURE__ */ new Set([SHADCN_TAILWIND_IMPORT, BEJAMAS_TAILWIND_IMPORT]);
 const MANAGED_ICON_PACKAGES = new Set(ICON_LIBRARIES.map((library) => library.packageName));
 const FALLBACK_ICON_PACKAGE_VERSION = "latest";
 const TEMPLATE_APP_UI_IMPORT = "import { appUi } from \"@/i18n/ui\";";
@@ -677,10 +681,17 @@ function transformStarterPageToI18n(source) {
 	if (!match) return source;
 	return compactSource(match.i18nSource);
 }
-function upsertThemeInlineFont(source, fontVariable) {
+/**
+* Astro's <Font> defines the font variables outside any cascade layer, so it
+* beats Tailwind's theme layer. The body font therefore needs no theme line
+* (without a <Font>, Tailwind's default stack applies), and the heading font
+* falls back to the body font until a heading <Font> defines it.
+*/
+function upsertThemeInlineFont(source, fontVariable = "--font-sans") {
 	const pattern = /@theme inline\s*\{[\s\S]*?\n\}/m;
+	const declarations = `  --font-heading: var(--font-heading, var(${fontVariable}));`;
 	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 block = `@theme inline {\n${declarations}\n}`;
 		const customVariantIndex = source.indexOf("@custom-variant");
 		if (customVariantIndex !== -1) {
 			const nextLineIndex = source.indexOf("\n", customVariantIndex);
@@ -689,9 +700,7 @@ function upsertThemeInlineFont(source, fontVariable) {
 		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`);
+		return 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").replace("@theme inline {\n", `@theme inline {\n${declarations}\n`);
 	});
 }
 function upsertBaseLayerHtmlFont(source, fontClass) {
@@ -707,7 +716,7 @@ function transformDesignSystemCss(source, config, themeVars) {
 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")),
+		...Object.fromEntries(Object.entries(effectiveThemeVars.theme ?? {}).filter(([key]) => key !== "bejamas-font-family" && key !== "font-heading")),
 		...effectiveThemeVars.light ?? {}
 	};
 	const darkVars = { ...effectiveThemeVars.dark ?? {} };
@@ -740,7 +749,7 @@ function transformManagedTailwindImportCss(source) {
 }
 async function patchComponentsJson(filepath, config) {
 	const current = await fs.readJson(filepath);
-	const { rsc: _rsc, tsx: _tsx,...normalizedCurrent } = current;
+	const { rsc: _rsc, tsx: _tsx, ...normalizedCurrent } = current;
 	const next = {
 		...normalizedCurrent,
 		$schema: BEJAMAS_COMPONENTS_SCHEMA_URL,
@@ -865,13 +874,13 @@ async function patchLayoutFile(filepath, config) {
 	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");
+		const next = transformTemplateLayoutToI18n(current);
+		if (next !== current) await fs.writeFile(filepath, next, "utf8");
 		return;
 	}
 	const nextLanguage = getDocumentLanguage(config);
 	const nextDirection = getDocumentDirection(config);
-	let next = current.replace(/<html([^>]*?)lang="[^"]*"([^>]*)>/, "<html$1$2>").replace(/<html([^>]*?)dir="[^"]*"([^>]*)>/, "<html$1$2>");
+	let next = current.replace(/<html([^>]*?)\slang="[^"]*"([^>]*)>/, "<html$1$2>").replace(/<html([^>]*?)\sdir="[^"]*"([^>]*)>/, "<html$1$2>");
 	next = next.replace(/<html([^>]*)>/, `<html$1 lang="${nextLanguage}"${config.rtl ? ` dir="${nextDirection}"` : ""}>`);
 	if (next !== current) await fs.writeFile(filepath, next, "utf8");
 }
@@ -1012,7 +1021,8 @@ function rewriteAstroIcons(content, iconLibrary) {
 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());
+	const normalizedAttributeString = attributeString.replace(/\sname=(["'])[^"']+\1/g, "").replace(/\slibrary=(["'])[^"']+\1/g, "").replace(/\sdata-icon-library=(["'])[^"']+\1/g, "").trim();
+	return renderSemanticIconSvgWithAttributeString(library, semanticName, normalizedAttributeString);
 }
 
 //#endregion
@@ -1064,6 +1074,15 @@ function rewriteAstroMenus(content, menuColor) {
 //#endregion
 //#region src/utils/astro-imports.ts
 function updateImportAliases(moduleSpecifier, config, isRemote = false) {
+	const scope = config.aliases.components.split("/")[0];
+	for (const [segment, alias] of [
+		["lib/utils", config.aliases.utils],
+		["lib", config.aliases.lib],
+		["hooks", config.aliases.hooks]
+	]) {
+		if (!alias) continue;
+		for (const prefix of [`@/${segment}`, `${scope}/${segment}`]) if (moduleSpecifier === prefix || moduleSpecifier.startsWith(`${prefix}/`)) return alias + moduleSpecifier.slice(prefix.length);
+	}
 	if (!moduleSpecifier.startsWith("@/") && !isRemote) return moduleSpecifier;
 	let specifier = moduleSpecifier;
 	if (isRemote && specifier.startsWith("@/")) specifier = specifier.replace(/^@\//, `@/registry/${config.style || "bejamas-juno"}/`);
@@ -1088,6 +1107,7 @@ function rewriteAstroImports(content, config) {
 		if (finalSpec === specifier) return full;
 		return full.replace(specifier, finalSpec);
 	});
+	updated = updated.replace(/(?:export\s+(?:type\s+)?(?:\{[^}]*\}|\*)\s+from\s*|import\s*\(\s*)["']([^"']+)["']/g, (full, specifier) => full.replace(specifier, updateImportAliases(specifier, config)));
 	updated = updated.replace(/import\s+["']([^"']+)["']/g, (full, specifier) => {
 		const next = updateImportAliases(specifier, config, false);
 		if (next === specifier) return full;
@@ -1096,25 +1116,45 @@ function rewriteAstroImports(content, config) {
 	updated = rewriteAstroMenus(updated, config.menuColor);
 	return rewriteAstroIcons(updated, config.iconLibrary);
 }
-async function fixAstroImports(cwd, isVerbose) {
-	const config = await getConfig(cwd);
+function getConfiguredSourceRoots(config) {
+	return Array.from(new Set([
+		config.resolvedPaths.components,
+		config.resolvedPaths.ui,
+		config.resolvedPaths.lib,
+		config.resolvedPaths.hooks
+	].filter((root) => Boolean(root))));
+}
+function isPathWithin(filePath, root) {
+	const relative = path.relative(root, filePath);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+async function fixAstroImports(cwd, isVerbose, targetConfig, scope = { kind: "configured-roots" }) {
+	const config = targetConfig ?? 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)}`);
+	const files = /* @__PURE__ */ new Set();
+	if (scope.kind === "files") for (const filePath of scope.paths) {
+		const absolutePath = path.resolve(cwd, filePath);
+		if (!/\.(?:astro|ts|js)$/.test(absolutePath)) continue;
+		if ((await fs$1.stat(absolutePath).catch(() => null))?.isFile()) files.add(absolutePath);
+	}
+	else {
+		const excluded = new Set((scope.exclude ?? []).map((filePath) => path.resolve(cwd, filePath)));
+		for (const root of getConfiguredSourceRoots(config)) {
+			const matches = await fg("**/*.{astro,ts,js}", {
+				cwd: root,
+				absolute: true,
+				dot: false
+			});
+			for (const filePath of matches) if (!excluded.has(path.resolve(filePath))) files.add(filePath);
 		}
 	}
+	for (const filePath of files) {
+		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
@@ -1235,7 +1275,7 @@ const TEMPLATE_DIRNAME = {
 	"astro-monorepo": "monorepo-astro",
 	"astro-with-component-docs-monorepo": "monorepo-astro-with-docs"
 };
-const TEMPLATE_EXCLUDED_BASENAMES = new Set(["node_modules", ".astro"]);
+const TEMPLATE_EXCLUDED_BASENAMES = /* @__PURE__ */ new Set(["node_modules", ".astro"]);
 const DEFAULT_TEMPLATE_REPOSITORY = "bejamas/ui";
 const DEFAULT_TEMPLATE_REF = "main";
 function resolveLocalTemplatesDir(env = process.env) {
@@ -1333,20 +1373,33 @@ async function copyTemplateFromGitHub(templateDirName, projectPath) {
 		failures.join("\n")
 	].join("\n"));
 }
-async function applyLocalPackageOverrides(projectPath) {
-	const bejamasPackageOverride = process.env.BEJAMAS_PACKAGE_OVERRIDE;
-	if (!bejamasPackageOverride) return;
+/** A valid npm package name derived from the project's folder name. */
+function toPackageName(projectName) {
+	return path$1.basename(projectName).toLowerCase().replace(/[^a-z0-9._~-]+/g, "-").replace(/^[._-]+|-+$/g, "") || "my-app";
+}
+/**
+* Fit the template's manifests to this project: the root package takes the
+* project's name (the template's `astro` shadows the real `astro` package in a
+* workspace), and every `bejamas` dependency points at the running CLI version,
+* or at `BEJAMAS_PACKAGE_OVERRIDE` when testing a local build.
+*/
+async function applyProjectPackageMetadata(projectPath, { projectName, bejamasVersion = BEJAMAS_PACKAGE_METADATA.version, bejamasOverride = process.env.BEJAMAS_PACKAGE_OVERRIDE }) {
+	const bejamasSpec = bejamasOverride ? `file:${bejamasOverride.replace(/\\/g, "/")}` : bejamasVersion && `^${bejamasVersion}`;
+	const rootPackageJson = path$1.resolve(projectPath, "package.json");
 	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}`;
+		if (path$1.resolve(packageJsonPath) === rootPackageJson) {
+			packageJson.name = toPackageName(projectName);
+			changed = true;
+		}
+		for (const field of ["dependencies", "devDependencies"]) if (bejamasSpec && packageJson[field]?.bejamas) {
+			packageJson[field].bejamas = bejamasSpec;
 			changed = true;
 		}
 		if (changed) await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
@@ -1412,6 +1465,7 @@ async function createProject(options) {
 		process.exit(1);
 	}
 	await createProjectFromTemplate(projectPath, {
+		projectName,
 		templateKey: template,
 		packageManager,
 		cwd: options.cwd
@@ -1434,7 +1488,7 @@ async function createProjectFromTemplate(projectPath, options) {
 			await copyTemplateFromGitHub(templateDirName, projectPath);
 		}
 		await removeEmptyTemplateI18nDirs(projectPath);
-		await applyLocalPackageOverrides(projectPath);
+		await applyProjectPackageMetadata(projectPath, { projectName: options.projectName });
 		await execa(options.packageManager, ["install"], { cwd: projectPath });
 		try {
 			const { stdout } = await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectPath });
@@ -1498,12 +1552,32 @@ async function getInstalledUiComponents(cwd) {
 
 //#endregion
 //#region src/utils/reorganize-components.ts
+const BEJAMAS_REGISTRY_NAMESPACE = "@bejamas/";
+/**
+* Resolve the Bejamas item name behind a user-provided specifier. Returns null
+* for URLs and third-party namespaces, which shadcn resolves on its own.
+*/
+function resolveBejamasRegistryItemName(specifier) {
+	const name = specifier.startsWith("@bejamas/") ? specifier.slice(9) : specifier;
+	return /^[a-z0-9][a-z0-9-]*$/.test(name) ? name : null;
+}
+function isRegistryItemUrl(specifier) {
+	return /^https?:\/\//.test(specifier);
+}
 async function fetchRegistryItem(componentName, registryUrl, style = "bejamas-juno") {
-	const url$1 = `${registryUrl}/styles/${style}/${componentName}.json`;
+	if (isRegistryItemUrl(componentName)) try {
+		const response = await fetch(componentName);
+		return response.ok ? await response.json() : null;
+	} catch {
+		return null;
+	}
+	const itemName = resolveBejamasRegistryItemName(componentName);
+	if (!itemName) return null;
+	const url = `${registryUrl}/styles/${style}/${itemName}.json`;
 	try {
-		const response = await fetch(url$1);
+		const response = await fetch(url);
 		if (!response.ok) {
-			const fallbackUrl = `${registryUrl}/${componentName}.json`;
+			const fallbackUrl = `${registryUrl}/${itemName}.json`;
 			const fallbackResponse = await fetch(fallbackUrl);
 			if (!fallbackResponse.ok) return null;
 			return await fallbackResponse.json();
@@ -1516,7 +1590,7 @@ async function fetchRegistryItem(componentName, registryUrl, style = "bejamas-ju
 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;
+	if (uiFiles.length === 0) return null;
 	const subfolders = /* @__PURE__ */ new Set();
 	for (const file of uiFiles) {
 		const parts = file.path.split("/");
@@ -1525,8 +1599,8 @@ function getSubfolderFromPaths(files) {
 	}
 	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);
+		const dirname = path.dirname(uiFiles[0].path);
+		const folderName = path.basename(dirname);
 		if (folderName && folderName !== "ui") return folderName;
 	}
 	return null;
@@ -1556,7 +1630,7 @@ function resolveShadcnUiRelativePath(filePath, uiDir) {
 function shouldReorganizeRegistryUiFiles(files, uiDir) {
 	if (!uiDir) return false;
 	if (!getSubfolderFromPaths(files)) return false;
-	return files.filter((file) => file.type === "registry:ui").some((file) => {
+	return (files ?? []).filter((file) => file.type === "registry:ui").some((file) => {
 		return !resolveShadcnUiRelativePath(file.path, uiDir).includes("/");
 	});
 }
@@ -1577,6 +1651,7 @@ async function reorganizeRegistryUiFiles(files, uiDir, verbose, overwriteExistin
 	const targetDir = path.join(uiDir, subfolder);
 	for (const file of uiFiles) {
 		const filename = path.basename(file.path);
+		if (filename === "index.ts") continue;
 		const flatPath = path.join(uiDir, filename);
 		const targetPath = path.join(targetDir, filename);
 		if (!await pathExists(flatPath)) continue;
@@ -1605,65 +1680,124 @@ async function reorganizeRegistryUiFiles(files, uiDir, verbose, overwriteExistin
 		result.movedFiles.push(`${subfolder}/${filename}`);
 		if (verbose) logger.info(`[bejamas-ui] Moved ${filename} -> ${subfolder}/${filename}`);
 	}
+	if (await pathExists(targetDir)) await repairComponentBarrel(targetDir, files, overwriteExisting);
 	return result;
 }
+async function repairComponentBarrel(targetDir, files, overwriteExisting = false) {
+	const localFiles = (await fs$1.readdir(targetDir)).filter((name) => name.endsWith(".astro")).sort();
+	if (!localFiles.length) return;
+	const indexPath = path.join(targetDir, "index.ts");
+	const existing = await fs$1.readFile(indexPath, "utf8").catch(() => "");
+	const registryBarrel = files.find((file) => path.basename(file.path) === "index.ts")?.content ?? "";
+	const cleaned = (overwriteExisting || !existing ? registryBarrel : existing).replace(/export\s*\{[^}]*\}\s*from\s*["'](\.\/[^"']+\.astro)["'];?/g, (statement, specifier) => localFiles.includes(specifier.slice(2)) ? statement : "").trim();
+	const next = [cleaned, ...localFiles.filter((file) => {
+		const name = path.basename(file, ".astro");
+		return !new RegExp(`default\\s+as\\s+${name}\\b`).test(cleaned);
+	}).map((file) => `export { default as ${path.basename(file, ".astro")} } from "./${file}";`)].filter(Boolean).join("\n") + "\n";
+	if (next !== existing) await fs$1.writeFile(indexPath, next);
+}
+/** Resolve dependencies as well as the requested item before repairing output. */
+async function fetchRegistryTree(components, registryUrl, style = "bejamas-juno") {
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	async function visit(name) {
+		if (seen.has(name)) return;
+		seen.add(name);
+		if (!isRegistryItemUrl(name) && !resolveBejamasRegistryItemName(name)) return;
+		const item = await fetchRegistryItem(name, registryUrl, style);
+		if (!item) throw new Error(`Unable to load registry item ${name} for installation validation.`);
+		for (const dependency of item.registryDependencies ?? []) await visit(dependency);
+		items.push(item);
+	}
+	for (const name of components) await visit(name);
+	return items;
+}
 async function reorganizeComponents(components, uiDir, registryUrl, verbose, style = "bejamas-juno", overwriteExisting = false) {
+	return reorganizeRegistryItems(uiDir && components.length ? await fetchRegistryTree(components, registryUrl, style) : [], uiDir, verbose, overwriteExisting);
+}
+/** Reuse the registry tree already resolved for this installation. */
+async function reorganizeRegistryItems(items, uiDir, verbose, 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);
+	if (!items.some((item) => shouldReorganizeRegistryUiFiles(item.files, uiDir))) return result;
+	for (const item of items) {
+		if (!shouldReorganizeRegistryUiFiles(item.files, uiDir)) continue;
+		const componentResult = await reorganizeRegistryUiFiles(item.files, uiDir, verbose, overwriteExisting);
 		result.totalMoved += componentResult.totalMoved;
 		result.movedFiles.push(...componentResult.movedFiles);
 		result.skippedFiles.push(...componentResult.skippedFiles);
-		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}`);
 	}
+	const flatIndex = path.join(uiDir, "index.ts");
+	const flatContent = await fs$1.readFile(flatIndex, "utf8").catch(() => null);
+	if (flatContent && items.some((item) => item.files?.some((file) => file.type === "registry:ui" && path.basename(file.path) === "index.ts" && file.content.trim() === flatContent.trim()))) await fs$1.unlink(flatIndex);
 	return result;
 }
+/** Update legacy template exports once the installed UI uses nested barrels. */
+async function repairUiPackageExports(uiDir, packageRoot) {
+	const entries = await fs$1.readdir(uiDir, { withFileTypes: true }).catch(() => []);
+	if (!entries.some((entry) => entry.isDirectory()) || entries.some((entry) => entry.name.endsWith(".astro"))) return;
+	const packagePath = path.join(packageRoot, "package.json");
+	const manifest = JSON.parse(await fs$1.readFile(packagePath, "utf8"));
+	if (!manifest.exports || typeof manifest.exports !== "object") return;
+	const relativeUi = path.relative(packageRoot, uiDir).split(path.sep).join("/");
+	if (relativeUi.startsWith("../")) return;
+	const prefix = `./${relativeUi}`;
+	let changed = false;
+	for (const [specifier, target] of Object.entries(manifest.exports)) if (target === `${prefix}/*.astro` || target === `${prefix}/*.ts`) {
+		manifest.exports[specifier] = `${prefix}/*/index.ts`;
+		changed = true;
+	}
+	if (changed) await fs$1.writeFile(packagePath, JSON.stringify(manifest, null, 2) + "\n");
+}
 
 //#endregion
-//#region src/utils/shadcn-cli.ts
-const PINNED_SHADCN_VERSION = "4.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() {
-	await fs$1.mkdir(PINNED_SHADCN_EXEC_PREFIX, { recursive: true });
-	return PINNED_SHADCN_EXEC_PREFIX;
-}
-function getNpmExecutable() {
-	return process.platform === "win32" ? "npm.cmd" : "npm";
-}
-function buildPinnedShadcnInvocation(shadcnArgs) {
+//#region src/utils/pinned-npm-exec.ts
+/**
+* Run a package's bin at an exact version through `npm exec`, in a prefix of
+* its own so the user's project dependencies never interfere.
+*/
+function definePinnedPackage({ name, version, bin, prefixDir }) {
+	const execPrefix = path.join(os$1.tmpdir(), prefixDir, version);
+	const spec = `${name}@${version}`;
 	return {
-		cmd: getNpmExecutable(),
-		args: [
-			"exec",
-			"--yes",
-			"--prefix",
-			PINNED_SHADCN_EXEC_PREFIX,
-			`--package=${PINNED_SHADCN_PACKAGE}`,
-			"--",
-			"shadcn",
-			...shadcnArgs
-		],
-		source: "isolated"
+		version,
+		spec,
+		execPrefix,
+		async ensureExecPrefix() {
+			await fs$1.mkdir(execPrefix, { recursive: true });
+			return execPrefix;
+		},
+		invocation(args) {
+			return {
+				cmd: process.platform === "win32" ? "npm.cmd" : "npm",
+				args: [
+					"exec",
+					"--yes",
+					"--prefix",
+					execPrefix,
+					`--package=${spec}`,
+					"--",
+					bin,
+					...args
+				],
+				source: "isolated"
+			};
+		}
 	};
 }
 
+//#endregion
+//#region src/utils/shadcn-cli.ts
+const PINNED_SHADCN = definePinnedPackage({
+	name: "shadcn",
+	version: "4.21.0",
+	bin: "shadcn",
+	prefixDir: "bejamas-shadcn"
+});
+
 //#endregion
 //#region src/utils/shadcn-command.ts
 function extractPassthroughArgs(rawArgv, commandName) {
@@ -1675,8 +1809,8 @@ function extractPassthroughArgs(rawArgv, commandName) {
 	return rest.slice(doubleDashIndex + 1);
 }
 async function runShadcnCommand({ cwd, args, env }) {
-	await ensurePinnedShadcnExecPrefix();
-	const invocation = buildPinnedShadcnInvocation(args);
+	await PINNED_SHADCN.ensureExecPrefix();
+	const invocation = PINNED_SHADCN.invocation(args);
 	await execa(invocation.cmd, invocation.args, {
 		cwd,
 		env: {
@@ -1701,14 +1835,13 @@ function resolveDesignSystemConfig(options) {
 			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
+		baseColor: options.baseColor ?? DEFAULT_DESIGN_SYSTEM_CONFIG.baseColor,
+		theme: options.baseColor ?? DEFAULT_DESIGN_SYSTEM_CONFIG.theme
 	}));
 }
 function buildInitUrl(config, themeRef, env = process.env) {
@@ -1772,32 +1905,32 @@ function ensureShadcnReinstallFlag(forwardedOptions, shouldReinstall) {
 function extractOptionsForShadcnInit(rawArgv, cmd) {
 	if (typeof cmd.getOptionValueSource === "function") {
 		const opts = cmd.optsWithGlobals();
-		const forwarded$1 = [];
+		const forwarded = [];
 		const getSource = (key) => cmd.getOptionValueSource(key);
 		const addBoolean = (key, flag, negateFlag) => {
 			if (getSource(key) !== "cli") return;
 			const value = opts[key];
 			if (typeof value !== "boolean") return;
-			if (value) forwarded$1.push(flag);
-			else if (negateFlag) forwarded$1.push(negateFlag);
+			if (value) forwarded.push(flag);
+			else if (negateFlag) forwarded.push(negateFlag);
 		};
 		addBoolean("yes", "--yes");
 		addBoolean("force", "--force");
 		addBoolean("silent", "--silent");
 		addBoolean("reinstall", "--reinstall", "--no-reinstall");
-		const initIndex$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));
+		const initIndex = rawArgv.findIndex((arg) => arg === "init");
+		if (initIndex !== -1) {
+			const rest = rawArgv.slice(initIndex + 1);
+			const doubleDashIndex = rest.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded.push(...rest.slice(doubleDashIndex));
 		}
-		return forwarded$1;
+		return forwarded;
 	}
 	const initIndex = rawArgv.findIndex((arg) => arg === "init");
 	if (initIndex === -1) return [];
 	const rest = rawArgv.slice(initIndex + 1);
 	const forwarded = [];
-	const filteredFlags = new Set([
+	const filteredFlags = /* @__PURE__ */ new Set([
 		"-v",
 		"--verbose",
 		"-t",
@@ -1831,7 +1964,7 @@ function extractOptionsForShadcnInit(rawArgv, cmd) {
 	}
 	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) => {
+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. (${BASE_COLORS.map((color) => color.name).join(", ")})`, 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,
@@ -1848,7 +1981,7 @@ async function runInit(options) {
 	const designConfig = resolveDesignSystemConfig(options);
 	let newProjectTemplate;
 	if (!options.skipPreflight) {
-		if ((await preFlightInit(options)).errors[MISSING_DIR_OR_EMPTY_PROJECT]) {
+		if ((await preFlightInit(options)).errors["1"]) {
 			const { projectPath, template } = await createProject(options);
 			if (!projectPath) process.exit(1);
 			options.cwd = projectPath;
@@ -1962,13 +2095,14 @@ function resolveAliasPathUsingTsConfig(inputPath, projectRoot) {
 	const paths = cfg.compilerOptions.paths || {};
 	for (const [key, values] of Object.entries(paths)) {
 		const pattern = key.replace(/\*/g, "(.*)");
-		const re = /* @__PURE__ */ new RegExp(`^${pattern}$`);
+		const re = new RegExp(`^${pattern}$`);
 		const match = inputPath.match(re);
 		if (!match) continue;
 		const wildcard = match[1] || "";
 		const first = Array.isArray(values) ? values[0] : values;
 		if (!first) continue;
-		return resolve(projectRoot, baseUrl, String(first).replace(/\*/g, wildcard));
+		const target = String(first).replace(/\*/g, wildcard);
+		return resolve(projectRoot, baseUrl, target);
 	}
 	return null;
 }
@@ -1979,6 +2113,8 @@ async function generateDocs({ cwd, outDir, verbose }) {
 	const DEBUG = process.env.BEJAMAS_DEBUG === "1" || process.env.BEJAMAS_DEBUG === "true" || verbose;
 	try {
 		const shellCwd = process.cwd();
+		if (cwd && cwd.length) process.env.BEJAMAS_UI_ROOT = resolve(shellCwd, cwd);
+		if (outDir && outDir.length) process.env.BEJAMAS_DOCS_OUT_DIR = outDir;
 		let projectRoot = shellCwd;
 		let probe = shellCwd;
 		for (let i = 0; i < 6 && probe; i += 1) {
@@ -2030,27 +2166,30 @@ async function generateDocs({ cwd, outDir, verbose }) {
 		}
 		if (!process.env.BEJAMAS_DOCS_CWD) process.env.BEJAMAS_DOCS_CWD = shellCwd;
 		if (!process.env.BEJAMAS_UI_ROOT) {
+			const defaultGuess = (() => {
+				let current = shellCwd;
+				for (let i = 0; i < 6; i += 1) {
+					const cand = resolve(current, "packages/ui/package.json");
+					if (existsSync(cand)) {
+						const abs = resolve(current, "packages/ui");
+						return relative(shellCwd, abs) || abs;
+					}
+					const parent = resolve(current, "..");
+					if (parent === current) break;
+					current = parent;
+				}
+				const nm = resolve(shellCwd, "node_modules/@bejamas/ui/package.json");
+				if (existsSync(nm)) {
+					const abs = resolve(shellCwd, "node_modules/@bejamas/ui");
+					return relative(shellCwd, abs) || abs;
+				}
+				return "packages/ui";
+			})();
 			const { uiRoot } = await prompts({
 				type: "text",
 				name: "uiRoot",
 				message: "Path to @bejamas/ui package root:",
-				initial: (() => {
-					let current = shellCwd;
-					for (let i = 0; i < 6; i += 1) {
-						if (existsSync(resolve(current, "packages/ui/package.json"))) {
-							const abs = resolve(current, "packages/ui");
-							return relative(shellCwd, abs) || abs;
-						}
-						const parent = resolve(current, "..");
-						if (parent === current) break;
-						current = parent;
-					}
-					if (existsSync(resolve(shellCwd, "node_modules/@bejamas/ui/package.json"))) {
-						const abs = resolve(shellCwd, "node_modules/@bejamas/ui");
-						return relative(shellCwd, abs) || abs;
-					}
-					return "packages/ui";
-				})(),
+				initial: defaultGuess,
 				validate: (val) => {
 					const p = resolve(shellCwd, val);
 					return existsSync(resolve(p, "package.json")) ? true : `No package.json found in ${p}`;
@@ -2062,8 +2201,6 @@ async function generateDocs({ cwd, outDir, verbose }) {
 			}
 			process.env.BEJAMAS_UI_ROOT = resolve(shellCwd, uiRoot);
 		}
-		if (cwd && cwd.length) process.env.BEJAMAS_UI_ROOT = resolve(cwd);
-		if (outDir && outDir.length) process.env.BEJAMAS_DOCS_OUT_DIR = outDir;
 		if (!process.env.BEJAMAS_DOCS_OUT_DIR) {
 			const { out } = await prompts({
 				type: "text",
@@ -2086,7 +2223,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-Ce7A9Uxe.js");
+		const mod = await import("./generate-mdx-Cb8rPipn.js");
 		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
 		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
 	} catch (err) {
@@ -2123,7 +2260,9 @@ const FIELD_LABELS = {
 	figmaUrl: "@figmaUrl"
 };
 function checkComponentDocs(filePath, fileName) {
-	const meta = parseJsDocMetadata(extractFrontmatter(readFileSync(filePath, "utf-8")));
+	const content = readFileSync(filePath, "utf-8");
+	const frontmatter = extractFrontmatter(content);
+	const meta = parseJsDocMetadata(frontmatter);
 	const componentName = fileName.replace(/\.astro$/i, "");
 	const missingRequired = [];
 	const missingRecommended = [];
@@ -2271,33 +2410,286 @@ const docsCheck = new Command().name("docs:check").description("check documentat
 	});
 });
 
+//#endregion
+//#region ../registry/src/lib/headless-dependencies.ts
+/** Headless behaviors imported by emitted frontmatter, client scripts or helpers. */
+function getHeadlessDependencies(files) {
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const source = (file.content ?? "").replace(/\/\*[\s\S]*?\*\//g, "");
+		for (const match of source.matchAll(/(?:\bfrom\s*|\bimport\s*\(?\s*)["'](@data-slot\/[^/"']+)(?:\/[^"']*)?["']/g)) dependencies.add(match[1]);
+	}
+	return [...dependencies].sort();
+}
+
+//#endregion
+//#region src/utils/registry-dependencies.ts
+function missingRegistryDependencies(manifest, items) {
+	const declared = {
+		...manifest.devDependencies,
+		...manifest.dependencies
+	};
+	const candidates = /* @__PURE__ */ new Map();
+	for (const item of items) for (const specifier of item.dependencies ?? []) {
+		const name = specifier.match(/^(@[^/]+\/[^@/]+|[^@/]+)/)?.[1];
+		if (name && !declared[name]) candidates.set(name, specifier);
+	}
+	for (const item of items) for (const name of getHeadlessDependencies(item.files ?? [])) if (!declared[name] && !candidates.has(name)) candidates.set(name, name);
+	return [...candidates.values()].sort();
+}
+async function ensureRegistryDependencies(cwd, items) {
+	const missing = missingRegistryDependencies(JSON.parse(await fs$1.readFile(path.join(cwd, "package.json"), "utf8")), items);
+	if (!missing.length) return;
+	const manager = await getPackageManager(cwd);
+	await execa(manager, [manager === "npm" ? "install" : "add", ...missing], {
+		cwd,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/utils/registry-install.ts
+/**
+* shadcn reports written files relative to the directory it ran in, except in
+* a workspace where paths are relative to the monorepo root. Resolve each
+* reported path against the candidate bases and keep the ones that exist; the
+* first base with a match wins, so list the one shadcn reports against first.
+*/
+function resolveReportedFiles(files, bases, exists = existsSync) {
+	const resolved = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const match = (path.isAbsolute(file) ? [file] : bases.map((base) => path.resolve(base, file))).find((candidate) => exists(candidate));
+		if (match) resolved.add(match);
+	}
+	return Array.from(resolved);
+}
+/**
+* Bases for `resolveReportedFiles`. In a workspace, shadcn reports paths
+* relative to the monorepo root, so it comes before the app directory.
+*/
+function getReportedFileBases(cwd, config, uiConfig) {
+	const workspaceRoot = config && uiConfig && uiConfig.resolvedPaths.cwd !== config.resolvedPaths.cwd ? findCommonRoot(config.resolvedPaths.cwd, uiConfig.resolvedPaths.cwd) : null;
+	return workspaceRoot ? [workspaceRoot, cwd] : [cwd];
+}
+/** Installed files (relative to cwd or absolute) not covered by config aliases. */
+function filesOutsideConfigRoots(cwd, files, config) {
+	const roots = getConfiguredSourceRoots(config);
+	return files.filter((file) => !roots.some((root) => isPathWithin(path.resolve(cwd, file), root)));
+}
+function buildSubfolderMap(registryItems) {
+	const filenameToSubfolders = /* @__PURE__ */ new Map();
+	for (const registryItem of registryItems) {
+		const subfolder = getSubfolderFromPaths(registryItem.files);
+		if (!subfolder) continue;
+		for (const file of registryItem.files ?? []) if (file.type === "registry:ui") {
+			const filename = path.basename(file.path);
+			const subfolders = filenameToSubfolders.get(filename) || [];
+			subfolders.push(subfolder);
+			filenameToSubfolders.set(filename, subfolders);
+		}
+	}
+	const uniqueMap = /* @__PURE__ */ new Map();
+	const sharedFilenames = /* @__PURE__ */ new Set();
+	filenameToSubfolders.forEach((subfolders, filename) => {
+		if (subfolders.length === 1) uniqueMap.set(filename, `${subfolders[0]}/${filename}`);
+		else sharedFilenames.add(filename);
+	});
+	return {
+		uniqueMap,
+		sharedFilenames
+	};
+}
+/**
+* Repairs the output of several shadcn runs in one command. Work the next run
+* depends on happens per item in `install`; project-wide passes (import scan,
+* package exports, dependency installs) run once in `finish`, which the command
+* also calls before exiting on a failure so completed items stay usable.
+*/
+var RegistryInstallBatch = class {
+	constructor(context) {
+		this.context = context;
+		this.items = [];
+		this.written = /* @__PURE__ */ new Set();
+		this.kept = /* @__PURE__ */ new Set();
+		this.bases = getReportedFileBases(context.cwd, context.config, context.uiConfig);
+	}
+	async install({ items, writtenFiles, skippedFiles }) {
+		const { cwd, uiDir, verbose, overwrite } = this.context;
+		const reorganization = await reorganizeRegistryItems(items, uiDir, verbose, overwrite);
+		this.items.push(...items);
+		for (const file of resolveReportedFiles(writtenFiles, this.bases)) this.written.add(file);
+		for (const file of resolveReportedFiles(skippedFiles, this.bases)) this.kept.add(file);
+		for (const file of reorganization.skippedFiles) this.kept.add(path.resolve(uiDir, file));
+		await syncManagedTailwindCss(cwd);
+		const requestedItem = items.at(-1);
+		if (requestedItem?.type === "registry:font") {
+			const nextFont = toManagedAstroFont(requestedItem.name);
+			if (nextFont) {
+				const currentFonts = await readManagedAstroFontsFromProject(cwd);
+				const nextFonts = mergeManagedAstroFonts(currentFonts, nextFont);
+				await syncAstroFontsInProject(cwd, nextFonts, nextFont.cssVariable);
+				await syncAstroManagedFontCss(cwd, nextFont.cssVariable);
+				await cleanupAstroFontPackages(cwd);
+			}
+		}
+		return reorganization;
+	}
+	async finish() {
+		if (!this.items.length) return;
+		const { cwd, config, uiConfig, uiDir, verbose } = this.context;
+		const items = this.items.splice(0);
+		const written = Array.from(this.written);
+		const kept = Array.from(this.kept).filter((file) => !this.written.has(file));
+		this.written.clear();
+		this.kept.clear();
+		await fixAstroImports(cwd, verbose, uiConfig, {
+			kind: "configured-roots",
+			exclude: kept
+		});
+		if (config) {
+			const appFiles = uiConfig ? filesOutsideConfigRoots(cwd, written, uiConfig) : written;
+			if (appFiles.length) await fixAstroImports(cwd, verbose, config, {
+				kind: "files",
+				paths: appFiles
+			});
+		}
+		if (uiConfig) {
+			await repairUiPackageExports(uiDir, uiConfig.resolvedPaths.cwd);
+			if (!config || config.resolvedPaths.cwd === uiConfig.resolvedPaths.cwd) await ensureRegistryDependencies(uiConfig.resolvedPaths.cwd, items);
+			else {
+				await ensureRegistryDependencies(uiConfig.resolvedPaths.cwd, items.filter((item) => item.type !== "registry:block"));
+				const blockItems = items.filter((item) => item.type === "registry:block");
+				if (blockItems.length) await ensureRegistryDependencies(config.resolvedPaths.cwd, blockItems);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/shadcn-prompts.ts
+const QUESTION_PATTERN = /(?:^|\s)\?\s+([^\r\n]+?)\s+›/g;
+const CONFIRM_PATTERN = /(?:^|\s)\?\s+([^\r\n]+?)\s+›\s*\((?:y\/N|Y\/n)\)/g;
+const SUMMARY_PATTERN = /(?:Created|Updated|Skipped)\s+\d+\s+file|No files updated/i;
+/**
+* Decline every confirm question (overwrites, setup offers), then close stdin
+* when shadcn finishes its file phase. Any other question is reported through
+* `onUnsupportedPrompt` instead of being left to hang.
+*/
+function respondToShadcnPrompts(subprocess, { onUnsupportedPrompt, unsupportedPromptDelayMs = 250 } = {}) {
+	let unsupportedTimer;
+	let waitingOn;
+	let reported = false;
+	function clearUnsupportedTimer() {
+		if (unsupportedTimer) clearTimeout(unsupportedTimer);
+		unsupportedTimer = void 0;
+		waitingOn = void 0;
+	}
+	function inspect(line, answered) {
+		const text = stripVTControlCharacters(line);
+		const stdin = subprocess.stdin;
+		const canAnswer = stdin && !stdin.destroyed && !stdin.writableEnded;
+		if (canAnswer) for (const match of text.matchAll(CONFIRM_PATTERN)) {
+			const message = match[1];
+			if (answered.has(message)) continue;
+			answered.add(message);
+			stdin.write("n\n");
+			if (message === waitingOn) clearUnsupportedTimer();
+		}
+		const message = Array.from(text.matchAll(QUESTION_PATTERN), (match) => match[1]).filter((message) => !answered.has(message)).at(-1);
+		if (message && message !== waitingOn && onUnsupportedPrompt && !reported) {
+			clearUnsupportedTimer();
+			waitingOn = message;
+			unsupportedTimer = setTimeout(() => {
+				reported = true;
+				onUnsupportedPrompt(message);
+			}, unsupportedPromptDelayMs);
+			unsupportedTimer.unref?.();
+		}
+		if (canAnswer && SUMMARY_PATTERN.test(text)) stdin.end();
+	}
+	for (const stream of [subprocess.stdout, subprocess.stderr]) {
+		const decoder = new StringDecoder("utf8");
+		const answered = /* @__PURE__ */ new Set();
+		let pending = "";
+		stream?.on("data", (chunk) => {
+			pending += typeof chunk === "string" ? chunk : decoder.write(chunk);
+			const lines = pending.split("\n");
+			pending = lines.pop();
+			for (const line of lines) {
+				inspect(line, answered);
+				answered.clear();
+			}
+			inspect(pending, answered);
+		});
+		stream?.on("end", clearUnsupportedTimer);
+	}
+}
+
 //#endregion
 //#region src/commands/add.ts
+/** shadcn failed; the output has already been reported. */
+var InstallFailure = class extends Error {
+	constructor(exitCode) {
+		super(`shadcn exited with code ${exitCode}`);
+		this.exitCode = exitCode;
+	}
+};
+function isUiRegistryItem(item) {
+	return !item.type || item.type === "registry:ui";
+}
+function isBlockRegistryItem(item) {
+	return item?.type === "registry:block";
+}
+/** Items a user can pick by name: UI components and blocks. */
+function isAddableRegistryItem(item) {
+	return isUiRegistryItem(item) || isBlockRegistryItem(item);
+}
+/** `--all` is expanded locally, so shadcn must not expand it a second time. */
+function withoutExpandedAllOption(forwardedOptions) {
+	return forwardedOptions.filter((option) => option !== "--all" && option !== "-a");
+}
+/**
+* shadcn output is captured and re-reported by this command, and silent mode
+* would hide the file list needed for post-install repair.
+*/
+function withoutShadcnSilentOption(forwardedOptions) {
+	return forwardedOptions.filter((option) => option !== "--silent" && option !== "-s");
+}
+/**
+* shadcn only knows the registries declared in components.json. The built-in
+* `@bejamas/<item>` namespace is the default registry (REGISTRY_URL), so it is
+* passed to shadcn as the bare item name, which resolves to the styled payload.
+* Bare names, URLs, and third-party namespaces are passed through unchanged.
+*/
+function toShadcnAddArgument(item) {
+	if (!item.startsWith("@bejamas/")) return item;
+	return resolveBejamasRegistryItemName(item) ?? item;
+}
 function extractOptionsForShadcn(rawArgv, cmd) {
 	if (typeof cmd.getOptionValueSource === "function") {
 		const opts = cmd.optsWithGlobals();
-		const forwarded$1 = [];
+		const forwarded = [];
 		const getSource = (key) => cmd.getOptionValueSource(key);
 		const addBoolean = (key, flag, negateFlag) => {
 			if (getSource(key) !== "cli") return;
 			const value = opts[key];
 			if (typeof value !== "boolean") return;
-			if (value) forwarded$1.push(flag);
-			else if (negateFlag) forwarded$1.push(negateFlag);
+			if (value) forwarded.push(flag);
+			else if (negateFlag) forwarded.push(negateFlag);
 		};
 		const addString = (key, flag) => {
 			if (getSource(key) !== "cli") return;
 			const value = opts[key];
-			if (typeof value === "string") forwarded$1.push(flag, value);
+			if (typeof value === "string") forwarded.push(flag, value);
 		};
 		const addOptionalString = (key, flag) => {
 			if (getSource(key) !== "cli") return;
 			const value = opts[key];
 			if (value === true) {
-				forwarded$1.push(flag);
+				forwarded.push(flag);
 				return;
 			}
-			if (typeof value === "string") forwarded$1.push(flag, value);
+			if (typeof value === "string") forwarded.push(flag, value);
 		};
 		addBoolean("yes", "--yes");
 		addBoolean("overwrite", "--overwrite");
@@ -2309,19 +2701,19 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 		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);
-			const doubleDashIndex = rest$1.indexOf("--");
-			if (doubleDashIndex !== -1) forwarded$1.push(...rest$1.slice(doubleDashIndex));
+		const addIndex = rawArgv.findIndex((arg) => arg === "add");
+		if (addIndex !== -1) {
+			const rest = rawArgv.slice(addIndex + 1);
+			const doubleDashIndex = rest.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded.push(...rest.slice(doubleDashIndex));
 		}
-		return forwarded$1;
+		return forwarded;
 	}
 	const addIndex = rawArgv.findIndex((arg) => arg === "add");
 	if (addIndex === -1) return [];
 	const rest = rawArgv.slice(addIndex + 1);
 	const forwarded = [];
-	const optionsWithValues = new Set([
+	const optionsWithValues = /* @__PURE__ */ new Set([
 		"-c",
 		"--cwd",
 		"-p",
@@ -2329,7 +2721,7 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 		"--diff",
 		"--view"
 	]);
-	const filteredFlags = new Set(["-v", "--verbose"]);
+	const filteredFlags = /* @__PURE__ */ new Set(["-v", "--verbose"]);
 	for (let index = 0; index < rest.length; index += 1) {
 		const token = rest[index];
 		if (token === "--") {
@@ -2365,34 +2757,6 @@ function writeCapturedShadcnOutput(stdout, stderr) {
 	if (stdout) process.stdout.write(ensureTrailingNewline(stdout));
 	if (stderr) process.stderr.write(ensureTrailingNewline(stderr));
 }
-async function buildSubfolderMap(components, uiDir, registryUrl, style) {
-	const filenameToSubfolders = /* @__PURE__ */ new Map();
-	let requiresReorganization = false;
-	for (const componentName of components) {
-		const registryItem = await fetchRegistryItem(componentName, registryUrl, style);
-		if (!registryItem) continue;
-		if (shouldReorganizeRegistryUiFiles(registryItem.files, uiDir)) requiresReorganization = true;
-		const subfolder = getSubfolderFromPaths(registryItem.files);
-		if (!subfolder) continue;
-		for (const file of registryItem.files) if (file.type === "registry:ui") {
-			const filename = path.basename(file.path);
-			const subfolders = filenameToSubfolders.get(filename) || [];
-			subfolders.push(subfolder);
-			filenameToSubfolders.set(filename, subfolders);
-		}
-	}
-	const uniqueMap = /* @__PURE__ */ new Map();
-	const sharedFilenames = /* @__PURE__ */ new Set();
-	filenameToSubfolders.forEach((subfolders, filename) => {
-		if (subfolders.length === 1) uniqueMap.set(filename, `${subfolders[0]}/${filename}`);
-		else sharedFilenames.add(filename);
-	});
-	return {
-		uniqueMap,
-		sharedFilenames,
-		requiresReorganization
-	};
-}
 function rewritePaths(paths, mapResult) {
 	const { uniqueMap, sharedFilenames } = mapResult;
 	let currentSubfolder = null;
@@ -2434,14 +2798,16 @@ async function promptForComponents(registryUrl) {
 		logger.warn("No components available in registry.");
 		return null;
 	}
+	const choices = components.filter(isAddableRegistryItem).map((component) => ({
+		title: component.name,
+		value: component.name,
+		description: isBlockRegistryItem(component) ? "block" : void 0
+	}));
 	const { selected } = await prompts({
 		type: "autocompleteMultiselect",
 		name: "selected",
-		message: "Which components would you like to add?",
-		choices: components.filter((component) => !component.type || component.type === "registry:ui").map((component) => ({
-			title: component.name,
-			value: component.name
-		})),
+		message: "Which components or blocks would you like to add?",
+		choices,
 		hint: "- Space to select. Return to submit.",
 		instructions: false
 	});
@@ -2454,11 +2820,12 @@ function parseShadcnOutput(stdout, stderr) {
 		updated: [],
 		skipped: []
 	};
-	const cleanStderr = stderr.replace(/\x1b\[[0-9;]*m/g, "");
-	const cleanStdout = stdout.replace(/\x1b\[[0-9;]*m/g, "");
-	const createdMatch = cleanStderr.match(/Created\s+(\d+)\s+file/i);
-	const updatedMatch = cleanStderr.match(/Updated\s+(\d+)\s+file/i);
-	const skippedMatch = cleanStderr.match(/Skipped\s+(\d+)\s+file/i);
+	const cleanStderr = stripVTControlCharacters(stderr);
+	const cleanStdout = stripVTControlCharacters(stdout);
+	const cleanOutput = `${cleanStdout}\n${cleanStderr}`;
+	const createdMatch = cleanOutput.match(/Created\s+(\d+)\s+file/i);
+	const updatedMatch = cleanOutput.match(/Updated\s+(\d+)\s+file/i);
+	const skippedMatch = cleanOutput.match(/Skipped\s+(\d+)\s+file/i);
 	const createdCount = createdMatch ? parseInt(createdMatch[1], 10) : 0;
 	const updatedCount = updatedMatch ? parseInt(updatedMatch[1], 10) : 0;
 	const skippedCount = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
@@ -2494,20 +2861,33 @@ async function addComponents(cwd, packages, forwardedOptions, isVerbose, isSilen
 		...process.env,
 		REGISTRY_URL: resolveRegistryUrl()
 	};
-	await ensurePinnedShadcnExecPrefix();
-	const invocation = buildPinnedShadcnInvocation(buildShadcnAddArgs(packages, forwardedOptions));
+	await PINNED_SHADCN.ensureExecPrefix();
+	const shadcnArgs = buildShadcnAddArgs(packages, forwardedOptions);
+	const invocation = PINNED_SHADCN.invocation(shadcnArgs);
 	if (isVerbose) logger.info(`[bejamas-ui] ${invocation.cmd} ${invocation.args.join(" ")}`);
 	const registrySpinner = spinner("Checking registry.", { silent: isSilent });
 	registrySpinner.start();
 	try {
-		const result = await execa(invocation.cmd, invocation.args, {
+		const subprocess = execa(invocation.cmd, invocation.args, {
 			cwd,
 			env,
-			input: "n\nn\nn\nn\nn\nn\nn\nn\nn\nn\n",
+			stdin: "pipe",
 			stdout: "pipe",
 			stderr: "pipe",
 			reject: false
 		});
+		let unsupportedPrompt;
+		respondToShadcnPrompts(subprocess, { onUnsupportedPrompt(message) {
+			unsupportedPrompt = message;
+			subprocess.kill();
+		} });
+		const result = await subprocess;
+		if (unsupportedPrompt) {
+			registrySpinner.fail();
+			logger.error(`shadcn asked a question that bejamas add cannot answer: "${unsupportedPrompt}"`);
+			writeCapturedShadcnOutput(result.stdout || "", result.stderr || "");
+			throw new InstallFailure(1);
+		}
 		registrySpinner.succeed();
 		spinner("Installing components.", { silent: isSilent }).succeed();
 		const stdout = result.stdout || "";
@@ -2524,13 +2904,14 @@ async function addComponents(cwd, packages, forwardedOptions, isVerbose, isSilen
 		} : parseShadcnOutput(stdout, stderr);
 		if (result.exitCode !== 0) {
 			if (!inspectionMode) writeCapturedShadcnOutput(stdout, stderr);
-			process.exit(result.exitCode);
+			throw new InstallFailure(result.exitCode ?? 1);
 		}
 		return parsed;
-	} catch {
+	} catch (error) {
+		if (error instanceof InstallFailure) throw error;
 		registrySpinner.fail();
 		logger.error("Failed to add components");
-		process.exit(1);
+		throw new InstallFailure(1);
 	}
 }
 function buildShadcnAddArgs(packages, forwardedOptions) {
@@ -2552,13 +2933,13 @@ const add = new Command().name("add").description("Add components via the Bejama
 	const overwriteUsed = forwardedOptions.includes("--overwrite") || forwardedOptions.includes("-o");
 	const cwd = opts.cwd || process.cwd();
 	let componentsToAdd = packages || [];
-	const wantsAll = Boolean(opts.all);
+	const expandsAll = Boolean(opts.all) && componentsToAdd.length === 0;
 	const isSilent = opts.silent || false;
 	const registryUrl = resolveRegistryUrl();
-	if (wantsAll && componentsToAdd.length === 0) {
+	if (expandsAll) {
 		const fetchingSpinner = spinner("Fetching available components.", { silent: isSilent }).start();
 		try {
-			componentsToAdd = (await fetchAvailableComponents(registryUrl)).filter((component) => !component.type || component.type === "registry:ui").map((component) => component.name);
+			componentsToAdd = (await fetchAvailableComponents(registryUrl)).filter(isUiRegistryItem).map((component) => component.name);
 			fetchingSpinner.succeed();
 		} catch {
 			fetchingSpinner.fail();
@@ -2588,54 +2969,60 @@ const add = new Command().name("add").description("Add components via the Bejama
 	}
 	const activeStyle = uiConfig?.style || config?.style || "bejamas-juno";
 	const totalComponents = componentsToAdd.length;
-	for (let index = 0; index < componentsToAdd.length; index += 1) {
-		const component = componentsToAdd[index];
-		if (totalComponents > 1 && !isSilent) {
-			logger.break();
-			logger.info(highlighter.info(`[${index + 1}/${totalComponents}]`) + ` Adding ${highlighter.success(component)}...`);
-		}
-		const subfolderMapResult = inspectionMode ? {
-			uniqueMap: /* @__PURE__ */ new Map(),
-			sharedFilenames: /* @__PURE__ */ new Set(),
-			requiresReorganization: false
-		} : await buildSubfolderMap([component], uiDir, registryUrl, activeStyle);
-		const parsed = await addComponents(cwd, [component], forwardedOptions, verbose, isSilent, inspectionMode);
-		if (!inspectionMode) {
-			await syncManagedTailwindCss(cwd);
-			const registryItem = await fetchRegistryItem(component, registryUrl, activeStyle);
-			if (registryItem?.type === "registry:font") {
-				const nextFont = toManagedAstroFont(registryItem.name);
-				if (nextFont) {
-					await syncAstroFontsInProject(cwd, mergeManagedAstroFonts(await readManagedAstroFontsFromProject(cwd), nextFont), nextFont.cssVariable);
-					await syncAstroManagedFontCss(cwd, nextFont.cssVariable);
-					await cleanupAstroFontPackages(cwd);
-				}
-			}
-		}
-		let skippedCount = 0;
-		if (!inspectionMode && uiDir && subfolderMapResult.requiresReorganization) skippedCount = (await reorganizeComponents([component], uiDir, registryUrl, verbose, activeStyle)).skippedFiles.length;
-		if (!isSilent && !inspectionMode) {
-			const actuallyCreated = Math.max(0, parsed.created.length - skippedCount);
-			if (actuallyCreated > 0) {
-				const createdPaths = rewritePaths(parsed.created.slice(0, actuallyCreated), subfolderMapResult);
-				logger.success(`Created ${createdPaths.length} file${createdPaths.length > 1 ? "s" : ""}:`);
-				for (const file of createdPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
-			}
-			if (parsed.updated.length > 0) {
-				const updatedPaths = rewritePaths(Array.from(new Set(parsed.updated)), subfolderMapResult);
-				logger.info(`Updated ${updatedPaths.length} file${updatedPaths.length > 1 ? "s" : ""}:`);
-				for (const file of updatedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+	const outputBearingOptions = withoutShadcnSilentOption(forwardedOptions);
+	const addOptions = expandsAll ? withoutExpandedAllOption(outputBearingOptions) : outputBearingOptions;
+	const batch = new RegistryInstallBatch({
+		cwd,
+		config,
+		uiConfig,
+		uiDir,
+		verbose,
+		overwrite: overwriteUsed
+	});
+	try {
+		for (let index = 0; index < componentsToAdd.length; index += 1) {
+			const component = componentsToAdd[index];
+			if (totalComponents > 1 && !isSilent) {
+				logger.break();
+				logger.info(highlighter.info(`[${index + 1}/${totalComponents}]`) + ` Adding ${highlighter.success(component)}...`);
 			}
-			if (skippedCount > 0) logger.info(`Skipped ${skippedCount} file${skippedCount > 1 ? "s" : ""}: (already exists)`);
-			if (parsed.skipped.length > 0) {
-				const skippedPaths = rewritePaths(parsed.skipped, subfolderMapResult);
-				logger.info(formatSkippedFilesHeading(skippedPaths.length, overwriteUsed));
-				for (const file of skippedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			const items = inspectionMode ? [] : await fetchRegistryTree([component], registryUrl, activeStyle);
+			const subfolderMapResult = buildSubfolderMap(items);
+			const parsed = await addComponents(cwd, [toShadcnAddArgument(component)], addOptions, verbose, isSilent, inspectionMode);
+			if (inspectionMode) continue;
+			const { skippedFiles } = await batch.install({
+				items,
+				writtenFiles: [...parsed.created, ...parsed.updated],
+				skippedFiles: parsed.skipped
+			});
+			const skippedCount = skippedFiles.length;
+			if (!isSilent) {
+				const actuallyCreated = Math.max(0, parsed.created.length - skippedCount);
+				if (actuallyCreated > 0) {
+					const createdPaths = rewritePaths(parsed.created.slice(0, actuallyCreated), subfolderMapResult);
+					logger.success(`Created ${createdPaths.length} file${createdPaths.length > 1 ? "s" : ""}:`);
+					for (const file of createdPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+				}
+				if (parsed.updated.length > 0) {
+					const updatedPaths = rewritePaths(Array.from(new Set(parsed.updated)), subfolderMapResult);
+					logger.info(`Updated ${updatedPaths.length} file${updatedPaths.length > 1 ? "s" : ""}:`);
+					for (const file of updatedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+				}
+				if (skippedCount > 0) logger.info(`Skipped ${skippedCount} file${skippedCount > 1 ? "s" : ""}: (already exists)`);
+				if (parsed.skipped.length > 0) {
+					const skippedPaths = rewritePaths(parsed.skipped, subfolderMapResult);
+					logger.info(formatSkippedFilesHeading(skippedPaths.length, overwriteUsed));
+					for (const file of skippedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+				}
+				if (actuallyCreated === 0 && parsed.updated.length === 0 && skippedCount === 0 && parsed.skipped.length === 0) logger.info("Already up to date.");
 			}
-			if (actuallyCreated === 0 && parsed.updated.length === 0 && skippedCount === 0 && parsed.skipped.length === 0) logger.info("Already up to date.");
 		}
+	} catch (error) {
+		await batch.finish();
+		if (error instanceof InstallFailure) process.exit(error.exitCode);
+		throw error;
 	}
-	if (!inspectionMode) await fixAstroImports(cwd, verbose);
+	await batch.finish();
 });
 
 //#endregion
@@ -2802,14 +3189,14 @@ const apply = new Command().name("apply").description("apply a preset to an exis
 			only: explicitOnly
 		});
 		const preflight = await preFlightApply(options);
-		if (preflight.errors[MISSING_DIR_OR_EMPTY_PROJECT]) {
+		if (preflight.errors["1"]) {
 			logger.break();
 			logger.error(`The ${highlighter.info("apply")} command only works in an existing project.`);
 			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
 			logger.break();
 			process.exit(1);
 		}
-		if (preflight.errors[MISSING_CONFIG]) {
+		if (preflight.errors["3"]) {
 			logger.break();
 			logger.error(`No ${highlighter.info("components.json")} found at ${highlighter.info(options.cwd)}.`);
 			logger.error(`Run ${highlighter.info(getInitCommand(rawPreset))} first.`);
@@ -2890,9 +3277,9 @@ function resolveApplyPreset(options) {
 	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 getPresetUrlOnly(preset) {
+	if (!isUrl(preset)) return;
+	return new URL(preset).searchParams.get("only") ?? void 0;
 }
 function resolveApplyOnly(value) {
 	if (value === void 0 || value === false) return;
@@ -2922,27 +3309,27 @@ 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 };
+function resolveApplyPresetSource(preset) {
+	if (isPresetCode(preset)) {
+		validatePresetCode(preset);
+		return { preset };
 	}
-	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.`);
+	if (!isUrl(preset)) throw new ApplyPresetError(`Invalid preset: ${highlighter.info(preset)}. Use a preset code or a Bejamas create/init URL containing a preset code.`);
+	const url = new URL(preset);
+	if (!isSupportedPresetUrl(url)) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset)}. Use a Bejamas create or init URL containing a preset code.`);
+	const code = url.searchParams.get("preset")?.trim();
+	if (!code) throw new ApplyPresetError(`Invalid preset URL: ${highlighter.info(preset)}. Expected a URL containing a preset query parameter.`);
 	validatePresetCode(code);
 	return {
 		preset: code,
-		themeRef: url$1.searchParams.get("themeRef") ?? void 0,
-		only: url$1.searchParams.get("only") ?? void 0
+		themeRef: url.searchParams.get("themeRef") ?? void 0,
+		only: url.searchParams.get("only") ?? void 0
 	};
 }
 async function preFlightApply(options) {
 	const errors = {};
 	if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
-		errors[MISSING_DIR_OR_EMPTY_PROJECT] = true;
+		errors["1"] = true;
 		return {
 			errors,
 			config: null
@@ -2964,7 +3351,7 @@ async function preFlightApply(options) {
 				process.exit(1);
 			}
 		}
-		errors[MISSING_CONFIG] = true;
+		errors["3"] = true;
 		return {
 			errors,
 			config: null
@@ -3015,28 +3402,29 @@ async function confirmApply(options) {
 		process.exit(1);
 	}
 }
-async function runPartialApply(cwd, designConfig, preset$1, only) {
+async function runPartialApply(cwd, designConfig, preset, 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 });
+		const initUrl = buildInitUrl(designConfig, preset.themeRef);
+		const themeVars = preset.themeRef ? await fetchInitThemeVars(initUrl) ?? void 0 : void 0;
+		await applyDesignSystemThemeToProject(cwd, designConfig, { themeVars });
 		await fixAstroImports(cwd, false);
 	}
 	if (only.includes("font")) await applyDesignSystemFontToProject(cwd, designConfig);
 }
-function resolveApplyDesignSystemConfig(preset$1, existingConfig) {
+function resolveApplyDesignSystemConfig(preset, existingConfig) {
 	return resolveDesignSystemConfig({
-		preset: preset$1.preset,
+		preset: preset.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)}.`);
+function validatePresetCode(preset) {
+	if (!isPresetCode(preset) || !decodePreset(preset)) throw new ApplyPresetError(`Invalid preset code: ${highlighter.info(preset)}.`);
 }
 async function getApplyConfigPaths(config) {
-	const configPaths = new Set([path.resolve(config.resolvedPaths.cwd, "components.json")]);
+	const configPaths = /* @__PURE__ */ new Set([path.resolve(config.resolvedPaths.cwd, "components.json")]);
 	const workspaceConfig = await getWorkspaceConfig(config);
 	if (workspaceConfig) for (const linkedConfig of Object.values(workspaceConfig)) configPaths.add(path.resolve(linkedConfig.resolvedPaths.cwd, "components.json"));
 	const existingPaths = [];
@@ -3110,9 +3498,9 @@ async function getApplyWorkspaceConfigs(config) {
 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 getInitCommand(preset) {
+	if (!preset) return "bejamas init";
+	return `bejamas init --preset ${quoteShellArg(preset)}`;
 }
 function isUrl(value) {
 	try {
@@ -3122,8 +3510,8 @@ function isUrl(value) {
 		return false;
 	}
 }
-function isSupportedPresetUrl(url$1) {
-	const pathname = url$1.pathname.replace(/\/+$/, "");
+function isSupportedPresetUrl(url) {
+	const pathname = url.pathname.replace(/\/+$/, "");
 	return pathname === "/create" || pathname === "/init";
 }
 
@@ -3159,13 +3547,14 @@ const PRESET_ICON_LIBRARY_SET = new Set(PRESET_ICON_LIBRARIES);
 const PRESET_MENU_ACCENT_SET = new Set(PRESET_MENU_ACCENTS);
 const PRESET_MENU_COLOR_SET = new Set(PRESET_MENU_COLORS);
 const PRESET_STYLE_SET = new Set(PRESET_STYLES);
+new Set(PRESET_THEMES);
 const ROOT_FONT_VARIABLES = [
 	"--font-sans",
 	"--font-serif",
 	"--font-mono"
 ];
 const ROOT_FONT_VARIABLE_SET = new Set(ROOT_FONT_VARIABLES);
-const FONT_VARIABLE_SET = new Set([...ROOT_FONT_VARIABLES, "--font-heading"]);
+const FONT_VARIABLE_SET = /* @__PURE__ */ new Set([...ROOT_FONT_VARIABLES, "--font-heading"]);
 async function resolveProjectPreset(config) {
 	const style = normalizePresetStyle(config.style);
 	if (!style) return {
@@ -3463,31 +3852,31 @@ function printPresetDecode(result) {
 		values: result.values
 	}, { fallbackNote: "  * Compatibility value for older preset versions." });
 }
-function printPresetInfo(preset$1, options = {}) {
+function printPresetInfo(preset, options = {}) {
 	logger.log(highlighter.info("Preset"));
-	if (!preset$1.code || !preset$1.values) {
+	if (!preset.code || !preset.values) {
 		printEntries({ code: "-" });
 		return;
 	}
-	const fallbacks = preset$1.fallbacks ?? [];
+	const fallbacks = preset.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)
+		code: preset.code,
+		version: preset.code[0],
+		style: preset.values.style,
+		baseColor: formatPresetValue("baseColor", preset.values.baseColor),
+		theme: formatPresetValue("theme", preset.values.theme),
+		chartColor: formatPresetValue("chartColor", preset.values.chartColor),
+		iconLibrary: formatPresetValue("iconLibrary", preset.values.iconLibrary),
+		font: formatPresetValue("font", preset.values.font),
+		fontHeading: formatPresetValue("fontHeading", preset.values.fontHeading),
+		radius: formatPresetValue("radius", preset.values.radius),
+		menuAccent: formatPresetValue("menuAccent", preset.values.menuAccent),
+		menuColor: formatPresetValue("menuColor", preset.values.menuColor),
+		url: getPresetUrl(preset.code)
 	});
 	if (fallbacks.length > 0) {
 		logger.log("");
@@ -3587,10 +3976,32 @@ function handlePresetError(error) {
 	process.exit(1);
 }
 
+//#endregion
+//#region ../bench/package.json
+var version = "0.1.0";
+
+//#endregion
+//#region src/commands/bench.ts
+const PINNED_BENCH = definePinnedPackage({
+	name: "@bejamas/bench",
+	version,
+	bin: "bejamas-bench",
+	prefixDir: "bejamas-bench"
+});
+const bench = new Command().name("bench").description("compare an original site with its ported version (runs @bejamas/bench)").usage("--original <url> --ported <url> [options]").argument("[args...]", "run `bejamas bench --help` for all options").helpOption(false).allowUnknownOption().passThroughOptions().allowExcessArguments().action(async (args) => {
+	await PINNED_BENCH.ensureExecPrefix();
+	const invocation = PINNED_BENCH.invocation(args);
+	const result = await execa(invocation.cmd, invocation.args, {
+		stdio: "inherit",
+		reject: false
+	});
+	process.exit(result.exitCode ?? 2);
+});
+
 //#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");
+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").enablePositionalOptions();
 program.addCommand(init);
 program.addCommand(add);
 program.addCommand(apply);
@@ -3599,9 +4010,9 @@ program.addCommand(info);
 program.addCommand(docs);
 program.addCommand(docsBuild);
 program.addCommand(docsCheck);
+program.addCommand(bench);
 program.parse(process.argv);
-var src_default = program;
 
 //#endregion
-export { src_default as default };
+export { program as default };
 //# sourceMappingURL=index.js.map