cascivo 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1438 @@
+#!/usr/bin/env node
+import { argv, stdin, stdout } from "node:process";
+import { pathToFileURL } from "node:url";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
+import { buildRegistry, parseLegacyRegistry, validateIndex } from "@cascivo/registry";
+//#region src/utils/config.ts
+const DEFAULT_CONFIG = {
+	registry: "https://raw.githubusercontent.com/urbanisierung/cascivo/main/registry.json",
+	outputDir: "src/components/ui",
+	theme: "light"
+};
+const CONFIG_FILES = [
+	"cascivo.config.ts",
+	"cascivo.config.js",
+	"cascivo.config.mjs"
+];
+/** Apply defaults over a (possibly partial) user config object. */
+function resolveConfig(partial) {
+	return {
+		...DEFAULT_CONFIG,
+		...partial
+	};
+}
+/** Let env vars override config — used by the MCP server to pass `outputDir`. */
+function applyEnvOverrides(config, env = process.env) {
+	return {
+		...config,
+		...env.CASCIVO_REGISTRY ? { registry: env.CASCIVO_REGISTRY } : {},
+		...env.CASCIVO_OUTPUT_DIR ? { outputDir: env.CASCIVO_OUTPUT_DIR } : {}
+	};
+}
+/**
+* Locate and load `cascivo.config.{ts,js,mjs}` from `cwd`. Falls back to the
+* default config when no file is found or the file cannot be loaded. Env vars
+* (`CASCIVO_REGISTRY`, `CASCIVO_OUTPUT_DIR`) take precedence.
+*/
+async function loadConfig(cwd = process.cwd()) {
+	for (const file of CONFIG_FILES) {
+		const path = join(cwd, file);
+		if (!existsSync(path)) continue;
+		try {
+			const mod = await import(pathToFileURL(path).href);
+			return applyEnvOverrides(resolveConfig(mod.default ?? mod));
+		} catch {
+			return applyEnvOverrides(resolveConfig(null));
+		}
+	}
+	return applyEnvOverrides(resolveConfig(null));
+}
+/** Detect the package manager in use from lock files, defaulting to npm. */
+function detectPackageManager(cwd = process.cwd()) {
+	if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+	if (existsSync(join(cwd, "bun.lockb"))) return "bun";
+	return "npm";
+}
+/** The install subcommand each package manager uses to add dependencies. */
+function installCommand(pm, packages) {
+	return [pm, [pm === "npm" ? "install" : "add", ...packages]];
+}
+//#endregion
+//#region src/utils/exec.ts
+/**
+* Install npm packages using the detected package manager, inheriting stdio so
+* the user sees install progress. Returns false if the install failed.
+*/
+function installPackages(packages, cwd = process.cwd()) {
+	if (packages.length === 0) return true;
+	const [cmd, args] = installCommand(detectPackageManager(cwd), packages);
+	console.log(`Installing ${packages.join(", ")} with ${cmd}…`);
+	if (spawnSync(cmd, args, {
+		cwd,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	}).status !== 0) {
+		console.error(`Failed to install: ${packages.join(", ")}`);
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/utils/fs.ts
+/** Resolve where a component file should be written. */
+function resolveOutputPath(outputDir, component, file, cwd = process.cwd()) {
+	return join(resolve(cwd, outputDir), component, file);
+}
+/** Write a file, creating parent directories as needed. */
+async function writeFileSafe(path, content) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content, "utf8");
+}
+/** Read a file, returning null if it does not exist. */
+async function readFileSafe(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/utils/registry.ts
+function asStringArray(value) {
+	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/** Validate and normalize raw JSON into a typed Registry. Throws on bad shape. */
+function parseRegistry(raw) {
+	if (typeof raw !== "object" || raw === null) throw new Error("Invalid registry: expected an object");
+	const obj = raw;
+	if (!Array.isArray(obj.components)) throw new Error("Invalid registry: \"components\" must be an array");
+	const components = obj.components.map((entry, i) => {
+		if (typeof entry !== "object" || entry === null) throw new Error(`Invalid registry: component at index ${i} is not an object`);
+		const c = entry;
+		if (typeof c.name !== "string") throw new Error(`Invalid registry: component at index ${i} is missing "name"`);
+		const rawType = c.type;
+		const type = rawType === "component" || rawType === "layout" || rawType === "block" || rawType === "chart" ? rawType : void 0;
+		const rawMeta = c.meta;
+		const metaName = typeof rawMeta === "object" && rawMeta !== null && typeof rawMeta.name === "string" ? rawMeta.name : c.name;
+		const result = {
+			name: c.name,
+			description: typeof c.description === "string" ? c.description : "",
+			category: typeof c.category === "string" ? c.category : "",
+			version: typeof c.version === "string" ? c.version : "0.0.0",
+			files: asStringArray(c.files),
+			dependencies: asStringArray(c.dependencies),
+			tags: asStringArray(c.tags),
+			meta: { name: metaName }
+		};
+		if (type !== void 0) result.type = type;
+		if (typeof c.install === "string") result.install = c.install;
+		return result;
+	});
+	const blocks = Array.isArray(obj.blocks) ? obj.blocks.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const b = entry;
+		if (typeof b.name !== "string") return [];
+		const rawScreenshot = typeof b.screenshot === "object" && b.screenshot !== null ? b.screenshot : {};
+		return [{
+			name: b.name,
+			type: "block",
+			displayName: typeof b.displayName === "string" ? b.displayName : b.name,
+			description: typeof b.description === "string" ? b.description : "",
+			category: typeof b.category === "string" ? b.category : "",
+			version: typeof b.version === "string" ? b.version : "0.0.0",
+			files: asStringArray(b.files),
+			dependencies: asStringArray(b.dependencies),
+			tags: asStringArray(b.tags),
+			screenshot: {
+				light: typeof rawScreenshot.light === "string" ? rawScreenshot.light : "",
+				dark: typeof rawScreenshot.dark === "string" ? rawScreenshot.dark : ""
+			}
+		}];
+	}) : [];
+	return {
+		version: typeof obj.version === "string" ? obj.version : "0.0.0",
+		generatedAt: typeof obj.generatedAt === "string" ? obj.generatedAt : "",
+		components,
+		blocks
+	};
+}
+/** Fetch and parse the registry from a URL. */
+async function fetchRegistry(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`Failed to fetch registry from ${url}: ${res.status} ${res.statusText}`);
+	return parseRegistry(await res.json());
+}
+/**
+* Find a component by name (case-insensitive, full name or unambiguous suffix).
+*
+* Examples:
+*   "layout/app-shell" → exact match on full name
+*   "app-shell"        → suffix match if exactly one entry ends with "/app-shell"
+*   "button"           → exact match (no slash, no suffix ambiguity)
+*/
+function findComponent(registry, name) {
+	const target = name.toLowerCase();
+	if (target.startsWith("block/")) {
+		const blockName = target.slice(6);
+		const block = (registry.blocks ?? []).find((b) => b.name.toLowerCase() === blockName);
+		if (!block) throw new Error(`Block "${blockName}" not found in registry.`);
+		return block;
+	}
+	const exact = registry.components.find((c) => c.name.toLowerCase() === target);
+	if (exact) return exact;
+	const suffix = `/${target}`;
+	const matches = registry.components.filter((c) => c.name.toLowerCase().endsWith(suffix));
+	if (matches.length === 1) return matches[0];
+}
+/** Extract the file name from a registry file URL. */
+function fileName(url) {
+	const stripped = url.split(/[?#]/)[0] ?? url;
+	return stripped.split("/").pop() || stripped;
+}
+//#endregion
+//#region src/utils/lock.ts
+function sha256(content) {
+	return `sha256-${createHash("sha256").update(content).digest("hex")}`;
+}
+const LOCK_FILENAME = "cascade.lock";
+async function readLock(cwd = process.cwd()) {
+	const path = join(cwd, LOCK_FILENAME);
+	if (!existsSync(path)) return null;
+	try {
+		const raw = JSON.parse(await readFile(path, "utf8"));
+		if (typeof raw !== "object" || raw === null) return null;
+		return raw;
+	} catch {
+		return null;
+	}
+}
+async function writeLock(lock, cwd = process.cwd()) {
+	await writeFile(join(cwd, LOCK_FILENAME), `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+}
+function createLock() {
+	return {
+		lockVersion: 1,
+		items: {}
+	};
+}
+function updateLockEntry(lock, name, entry) {
+	return {
+		...lock,
+		items: {
+			...lock.items,
+			[name]: entry
+		}
+	};
+}
+//#endregion
+//#region src/utils/http.ts
+const CACHE_DIR = join(homedir(), ".cascade", "cache");
+const MAX_SIZE = 10 * 1024 * 1024;
+const TIMEOUT_MS = 15e3;
+const MAX_RETRIES = 4;
+let _fetchFn = globalThis.fetch;
+function cacheKey(url) {
+	return createHash("sha256").update(url).digest("hex");
+}
+async function getCached(url) {
+	try {
+		const data = await readFile(join(CACHE_DIR, cacheKey(url)), "utf8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+async function setCached(url, data) {
+	try {
+		await mkdir(CACHE_DIR, { recursive: true });
+		await writeFile(join(CACHE_DIR, cacheKey(url)), JSON.stringify(data));
+	} catch {}
+}
+async function fetchJson(url, opts = {}) {
+	const fullUrl = opts.params ? `${url}?${new URLSearchParams(opts.params).toString()}` : url;
+	if (opts.cache !== false) {
+		const cached = await getCached(fullUrl);
+		if (cached !== null) return cached;
+	}
+	let lastError;
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+		if (attempt > 0) await new Promise((r) => setTimeout(r, 1e3 * 2 ** (attempt - 1)));
+		try {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+			let res;
+			try {
+				res = await _fetchFn(fullUrl, {
+					headers: {
+						Accept: "application/json",
+						...opts.headers
+					},
+					signal: controller.signal
+				});
+			} finally {
+				clearTimeout(timer);
+			}
+			if (res.status === 401 || res.status === 403 || res.status === 429) {
+				let msg = `HTTP ${res.status}`;
+				try {
+					const body = await res.json();
+					if (typeof body["message"] === "string") msg += `: ${body["message"]}`;
+				} catch {}
+				throw new Error(msg);
+			}
+			if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${fullUrl}`);
+			const len = Number(res.headers.get("content-length") ?? 0);
+			if (len > MAX_SIZE) throw new Error(`Response too large (${len} bytes) from ${fullUrl}`);
+			const text = await res.text();
+			if (text.length > MAX_SIZE) throw new Error(`Response too large from ${fullUrl}`);
+			const json = JSON.parse(text);
+			if (opts.cache !== false) await setCached(fullUrl, json);
+			return json;
+		} catch (e) {
+			lastError = e;
+			if (e instanceof Error && /HTTP 4\d\d/.test(e.message)) break;
+		}
+	}
+	const msg = lastError instanceof Error ? lastError.message : String(lastError);
+	throw new Error(`Network error fetching ${fullUrl}: ${msg}\n(Check your internet connection or registry URL)`);
+}
+//#endregion
+//#region src/utils/resolve.ts
+const GITHUB_RE = /^([^/]+)\/([^/]+)\/([^#]+)(?:#(.+))?$/;
+function expandEnv(str, env = process.env) {
+	return str.replace(/\$\{([^}]+)\}/g, (_, key) => {
+		const val = env[key];
+		if (val === void 0) throw new Error(`Environment variable ${key} is not set`);
+		return val;
+	});
+}
+function parseAddress(spec, env = process.env) {
+	if (spec.startsWith("http://") || spec.startsWith("https://") || spec.startsWith("./") || spec.startsWith("/")) return {
+		kind: "url",
+		name: spec,
+		raw: spec
+	};
+	if (spec.startsWith("@")) {
+		const slash = spec.indexOf("/", 1);
+		if (slash === -1) throw new Error(`Invalid namespace address: ${spec} (expected @ns/name)`);
+		return {
+			kind: "namespace",
+			namespace: spec.slice(0, slash),
+			name: spec.slice(slash + 1),
+			raw: spec
+		};
+	}
+	const specWithoutRef = spec.includes("#") ? spec.slice(0, spec.indexOf("#")) : spec;
+	const githubMatch = GITHUB_RE.exec(spec);
+	if (githubMatch && !specWithoutRef.includes(".") && specWithoutRef.split("/").length >= 3) {
+		const [, owner, repo, item, ref] = githubMatch;
+		return {
+			kind: "github",
+			name: `${owner}/${repo}/${item}`,
+			ref: ref ?? "main",
+			raw: spec
+		};
+	}
+	return {
+		kind: "bare",
+		name: spec,
+		raw: spec
+	};
+}
+function resolveNamespaceUrl(ns, name, nsCfg, env) {
+	const template = typeof nsCfg === "string" ? nsCfg : nsCfg.url;
+	if (!template.includes("{name}")) throw new Error(`Registry namespace "${ns}" URL template must contain {name}: ${template}`);
+	return expandEnv(template.replace("{name}", name), env);
+}
+async function resolveItemUrl(addr, config, env = process.env, resolveNamespaceHook) {
+	switch (addr.kind) {
+		case "url": return { url: addr.name };
+		case "bare": return { url: `${config.registry.replace(/\/registry\.json$/, "").replace(/\/r$/, "")}/r/${addr.name}.json` };
+		case "github": {
+			const parts = addr.name.split("/");
+			const owner = parts[0];
+			const repo = parts[1];
+			const item = parts.slice(2).join("/");
+			return { url: `https://raw.githubusercontent.com/${owner}/${repo}/${addr.ref ?? "main"}/r/${item}.json` };
+		}
+		case "namespace": {
+			const ns = addr.namespace;
+			const name = addr.name;
+			if (config.registries?.[ns]) {
+				const nsCfg = config.registries[ns];
+				const url = resolveNamespaceUrl(ns, name, nsCfg, env);
+				const headers = typeof nsCfg !== "string" ? nsCfg.headers : void 0;
+				const params = typeof nsCfg !== "string" ? nsCfg.params : void 0;
+				const expandedHeaders = headers ? Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, expandEnv(v, env)])) : void 0;
+				const expandedParams = params ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, expandEnv(v, env)])) : void 0;
+				const result = { url };
+				if (expandedHeaders) result.headers = expandedHeaders;
+				if (expandedParams) result.params = expandedParams;
+				return result;
+			}
+			if (resolveNamespaceHook) {
+				const hookResult = await resolveNamespaceHook(ns);
+				if (hookResult) return { url: resolveNamespaceUrl(ns, name, hookResult, env) };
+			}
+			if (ns === "@cascade") return { url: `https://cascivo.com/r/${name}.json` };
+			throw new Error(`Unknown namespace "${ns}". Add it to registries in cascivo.config.ts or check the directory at cascivo.com`);
+		}
+	}
+}
+async function resolveClosure(specs, config, env = process.env, resolveNamespaceHook) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [...specs];
+	const plan = [];
+	while (queue.length > 0) {
+		const spec = queue.shift();
+		const addr = parseAddress(spec, env);
+		const identity = addr.raw;
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		const { url, headers, params } = await resolveItemUrl(addr, config, env, resolveNamespaceHook);
+		const fetchOpts = {};
+		if (headers) fetchOpts.headers = headers;
+		if (params) fetchOpts.params = params;
+		const item = await fetchJson(url, fetchOpts);
+		const entry = {
+			spec,
+			addr,
+			itemUrl: url,
+			item,
+			registryBase: url.replace(/\/[^/]+\.json$/, "")
+		};
+		if (headers) entry.headers = headers;
+		if (params) entry.params = params;
+		plan.push(entry);
+		for (const dep of item.registryDependencies ?? []) queue.push(dep);
+	}
+	return { items: plan };
+}
+//#endregion
+//#region src/utils/directory.ts
+const DIRECTORY_URL = "https://cascivo.com/r/registries.json";
+async function resolveFromDirectory(ns, fetchFn) {
+	try {
+		let data;
+		if (fetchFn) {
+			const res = await fetchFn(DIRECTORY_URL, { headers: { Accept: "application/json" } });
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			data = await res.json();
+		} else data = await fetchJson(DIRECTORY_URL);
+		const entry = data.registries?.find((r) => r.namespace === ns);
+		if (!entry) return null;
+		return entry.registryUrl;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		console.warn(`Could not reach cascivo.com directory: ${msg}`);
+		return null;
+	}
+}
+//#endregion
+//#region src/commands/add.ts
+/** Dependencies always present in a cascade project — never auto-installed. */
+const ASSUMED_DEPS = new Set(["react", "react-dom"]);
+async function fetchText$1(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+	return res.text();
+}
+function isMultiRegistrySpec(name) {
+	return name.startsWith("@") || name.startsWith("http://") || name.startsWith("https://") || name.startsWith("./") || name.startsWith("/") || name.split("/").length >= 3;
+}
+async function add(names, config, opts = {}) {
+	if (names.length === 0) {
+		console.error("Usage: cascivo add <component...>");
+		return;
+	}
+	const multiSpecs = names.filter(isMultiRegistrySpec);
+	const bareSpecs = names.filter((n) => !isMultiRegistrySpec(n));
+	let lock = await readLock() ?? createLock();
+	if (multiSpecs.length > 0) {
+		const plan = await resolveClosure(multiSpecs, config, process.env, resolveFromDirectory);
+		if (opts.dryRun) {
+			console.log("Dry run — would install:");
+			for (const item of plan.items) {
+				console.log(`  ${item.spec} (${item.item.name}@${item.item.version}) from ${item.itemUrl}`);
+				for (const f of item.item.files) console.log(`    ${f.url}`);
+			}
+			return;
+		}
+		const isThirdParty = (itemUrl) => !itemUrl.includes("cascivo.com");
+		for (const { item, itemUrl, registryBase } of plan.items) {
+			if (isThirdParty(itemUrl)) console.log(`\nReview before use — files from non-directory registry: ${registryBase}\n` + (item.files ?? []).map((f) => `  ${f.url}`).join("\n"));
+			await installItem(item, config, lock, registryBase);
+			lock = updateLockEntry(lock, item.name, {
+				registry: registryBase,
+				version: item.version,
+				installedAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+				files: {}
+			});
+		}
+		await writeLock(lock);
+		return;
+	}
+	const registry = await fetchRegistry(config.registry);
+	const missingDeps = /* @__PURE__ */ new Set();
+	for (const name of bareSpecs) {
+		const entry = findComponent(registry, name);
+		if (!entry) {
+			console.error(`Component "${name}" not found in registry. Run "cascivo list".`);
+			continue;
+		}
+		if (entry.type === "chart") {
+			const pkg = entry.install ?? "@cascivo/charts";
+			console.log(`Chart "${entry.name}" is distributed as an npm package.`);
+			console.log(`Install it with: npm install ${pkg}`);
+			console.log(`Then import: import { ${entry.meta.name} } from '${pkg}'`);
+			continue;
+		}
+		const outputName = entry.name.includes("/") ? entry.name.split("/").pop() : entry.name;
+		const fileHashes = {};
+		for (const url of entry.files) {
+			const content = await fetchText$1(url);
+			const dest = resolveOutputPath(config.outputDir, outputName, fileName(url));
+			await writeFileSafe(dest, content);
+			fileHashes[dest] = sha256(content);
+		}
+		for (const dep of entry.dependencies) if (!ASSUMED_DEPS.has(dep)) missingDeps.add(dep);
+		const registryBase = config.registry.replace(/\/registry\.json$/, "").replace(/\/r$/, "");
+		lock = updateLockEntry(lock, entry.name, {
+			registry: registryBase,
+			version: entry.version,
+			installedAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+			files: fileHashes
+		});
+		console.log(`Added ${entry.name} to ${config.outputDir}/${outputName}/`);
+	}
+	if (missingDeps.size > 0) installPackages([...missingDeps]);
+	await writeLock(lock);
+}
+async function installItem(item, config, _lock, _registryBase) {
+	const outputName = item.name.includes("/") ? item.name.split("/").pop() : item.name;
+	const missingDeps = /* @__PURE__ */ new Set();
+	for (const file of item.files ?? []) try {
+		const content = await fetchText$1(file.url);
+		await writeFileSafe(resolveOutputPath(config.outputDir, outputName, fileName(file.url)), content);
+	} catch {
+		console.warn(`  Could not fetch ${file.url}`);
+	}
+	for (const dep of item.dependencies ?? []) if (!ASSUMED_DEPS.has(dep)) missingDeps.add(dep);
+	if (missingDeps.size > 0) installPackages([...missingDeps]);
+	console.log(`Added ${item.name} to ${config.outputDir}/${outputName}/`);
+}
+//#endregion
+//#region src/commands/doctor.ts
+const BANNED_HOOKS = [
+	"useState",
+	"useEffect",
+	"useLayoutEffect",
+	"useContext",
+	"useReducer"
+];
+async function runDoctor(root) {
+	const violations = [];
+	const componentsDir = join(root, "packages", "components", "src");
+	if (!existsSync(componentsDir)) return {
+		violations: [],
+		passed: true
+	};
+	const components = readdirSync(componentsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+	const reactIndex = join(root, "packages", "react", "src", "index.ts");
+	const indexContent = existsSync(reactIndex) ? readFileSync(reactIndex, "utf8") : "";
+	for (const name of components) {
+		const tsxPath = join(componentsDir, name, `${name}.tsx`);
+		if (!existsSync(tsxPath)) continue;
+		const content = readFileSync(tsxPath, "utf8");
+		for (const hook of BANNED_HOOKS) if (new RegExp(`\\b${hook}\\b`).test(content)) violations.push({
+			file: tsxPath,
+			rule: "no-react-hooks",
+			detail: `Banned hook '${hook}' in ${name}.tsx`
+		});
+		if (/aria-label="[A-Z]/.test(content)) violations.push({
+			file: tsxPath,
+			rule: "no-hardcoded-strings",
+			detail: `Hardcoded aria-label in ${name}.tsx — use t(builtin.*)`
+		});
+		if (!new RegExp(`from.*components/src/${name}`).test(indexContent)) violations.push({
+			file: tsxPath,
+			rule: "missing-react-export",
+			detail: `${name} not exported from @cascivo/react`
+		});
+	}
+	return {
+		violations,
+		passed: violations.length === 0
+	};
+}
+//#endregion
+//#region src/commands/generate.ts
+function isTranslationRef(v) {
+	return typeof v === "object" && v !== null && "$t" in v;
+}
+function serializeProp(value) {
+	if (typeof value === "string") return `"${value.replace(/"/g, "\\\"")}"`;
+	if (typeof value === "number" || typeof value === "boolean") return `{${value}}`;
+	if (value === null) return `{null}`;
+	if (isTranslationRef(value)) return `{"${value.$t}"} {/* i18n: ${value.$t} */}`;
+	return `{${JSON.stringify(value)}}`;
+}
+function renderChildren(children, indent, componentPropNames, knownComponents) {
+	if (children === void 0) return "";
+	if (typeof children === "string") return children;
+	if (isTranslationRef(children)) return `{/* i18n: ${children.$t} */}`;
+	if (Array.isArray(children)) return children.map((child) => renderNode(child, indent + "  ", componentPropNames, knownComponents)).join("\n");
+	return "";
+}
+function renderNode(node, indent, _parentPropNames, knownComponents) {
+	const compName = node.component;
+	knownComponents.add(compName);
+	const propParts = [];
+	if (node.props) for (const [k, v] of Object.entries(node.props)) propParts.push(`${k}=${serializeProp(v)}`);
+	if (node.bind) for (const [k, ref] of Object.entries(node.bind)) {
+		const path = ref.replace(/^\$data\./, "").replace(/\./g, ".");
+		propParts.push(`${k}={data.${path}}`);
+	}
+	if (node.events) for (const [k, ref] of Object.entries(node.events)) {
+		const actionName = ref.replace(/^\$actions\./, "");
+		propParts.push(`${k}={actions.${actionName}}`);
+	}
+	const propsStr = propParts.length > 0 ? " " + propParts.join(" ") : "";
+	const childrenStr = node.children !== void 0 ? renderChildren(node.children, indent, [], knownComponents) : void 0;
+	if (childrenStr !== void 0 && childrenStr !== "") return `${indent}<${compName}${propsStr}>\n${indent}  ${childrenStr}\n${indent}</${compName}>`;
+	return `${indent}<${compName}${propsStr} />`;
+}
+function collectBindAndEvents(nodes) {
+	const boundProps = [];
+	const actionProps = [];
+	function walk(node) {
+		if (node.bind) for (const ref of Object.values(node.bind)) {
+			const path = ref.replace(/^\$data\./, "");
+			if (!boundProps.includes(path)) boundProps.push(path);
+		}
+		if (node.events) for (const ref of Object.values(node.events)) {
+			const name = ref.replace(/^\$actions\./, "");
+			if (!actionProps.includes(name)) actionProps.push(name);
+		}
+		if (Array.isArray(node.children)) node.children.forEach(walk);
+	}
+	nodes.forEach(walk);
+	return {
+		boundProps,
+		actionProps
+	};
+}
+function generateTsx(config, _propMetas, componentsPath) {
+	const knownComponents = /* @__PURE__ */ new Set();
+	const { boundProps, actionProps } = collectBindAndEvents(Object.values(config.view.regions).flat());
+	const regionBlocks = Object.entries(config.view.regions).map(([regionName, nodes]) => {
+		return `    <div className="region-${regionName}">\n${nodes.map((n) => renderNode(n, "      ", [], knownComponents)).join("\n")}\n    </div>`;
+	}).join("\n");
+	const importLines = [...knownComponents].sort().map((c) => `import { ${c} } from '${componentsPath}/${c.toLowerCase()}/${c.toLowerCase()}'`).join("\n");
+	const hasData = boundProps.length > 0;
+	const hasActions = actionProps.length > 0;
+	const params = [hasData ? `data: {\n${boundProps.map((p) => `    ${p.replace(/\./g, "_")}: unknown // TODO: type your data`).join("\n")}\n  }` : "", hasActions ? `actions: {\n${actionProps.map((a) => `    ${a}: (...args: unknown[]) => unknown`).join("\n")}\n  }` : ""].filter(Boolean).join(",\n  ");
+	return `import React from 'react'
+${importLines}
+
+interface PageProps ${params ? `{\n  ${params}\n}` : "{}"}
+
+export function GeneratedPage({ ${hasData ? "data, " : ""}${hasActions ? "actions" : ""} }: PageProps) {
+  return (
+    <div className="cascade-view">
+${regionBlocks}
+    </div>
+  )
+}
+`;
+}
+async function generate(args, config) {
+	const outArg = args.find((_, i) => args[i - 1] === "--out");
+	const inputArg = args.find((a) => !a.startsWith("--"));
+	const componentsDirArg = args.find((_, i) => args[i - 1] === "--components-dir");
+	if (!inputArg) {
+		console.error("Usage: cascivo generate <config.json> [--out output.tsx] [--components-dir ./src/components/ui]");
+		process.exitCode = 1;
+		return;
+	}
+	const { readFileSync } = await import("node:fs");
+	const configJson = readFileSync(inputArg, "utf-8");
+	const viewConfig = JSON.parse(configJson);
+	await fetchRegistry(config.registry);
+	const tsx = generateTsx(viewConfig, /* @__PURE__ */ new Map(), componentsDirArg ?? config.outputDir ?? "./src/components/ui");
+	const outPath = outArg ?? join(dirname(inputArg), `${basename(inputArg, ".json")}.tsx`);
+	writeFileSync(outPath, tsx, "utf-8");
+	console.log(`Generated ${outPath}`);
+	try {
+		const { spawnSync } = await import("node:child_process");
+		if (spawnSync("pnpm", [
+			"exec",
+			"vp",
+			"fmt",
+			outPath
+		], {
+			encoding: "utf8",
+			stdio: "inherit"
+		}).status !== 0) {
+			if (spawnSync("npx", [
+				"--yes",
+				"prettier",
+				"--write",
+				outPath
+			], {
+				encoding: "utf8",
+				stdio: "inherit"
+			}).status !== 0) console.log("(Note: formatter not found — output may need manual formatting)");
+		}
+	} catch {}
+}
+//#endregion
+//#region src/commands/init.ts
+const THEMES$1 = [
+	"light",
+	"dark",
+	"warm"
+];
+async function promptTheme() {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		const answer = (await rl.question("Theme? (light/dark/warm) [light]: ")).trim().toLowerCase();
+		return THEMES$1.includes(answer) ? answer : "light";
+	} finally {
+		rl.close();
+	}
+}
+function configFileContents(theme) {
+	return `import type { CascadeConfig } from 'cascivo'
+
+const config: CascadeConfig = {
+  registry: '${DEFAULT_CONFIG.registry}',
+  outputDir: '${DEFAULT_CONFIG.outputDir}',
+  theme: '${theme}',
+}
+
+export default config
+`;
+}
+async function init(cwd = process.cwd()) {
+	installPackages(["@cascivo/core", "@cascivo/tokens"], cwd);
+	const theme = await promptTheme();
+	await writeFileSafe(join(cwd, "cascivo.config.ts"), configFileContents(theme));
+	console.log(`\nCreated cascivo.config.ts (theme: ${theme})`);
+	console.log("Import the theme in your root CSS or entry file:");
+	console.log(`  import '@cascivo/themes/${theme}.css'`);
+	console.log(`Then set the theme on your root element:`);
+	console.log(`  <html data-theme="${theme}">`);
+	console.log("\nAdd components with: cascivo add <name>");
+}
+//#endregion
+//#region src/commands/list.ts
+const TYPE_LABELS = {
+	component: "Components",
+	layout: "Layouts",
+	block: "Blocks",
+	section: "Sections"
+};
+/** Render a group of entries as an aligned text table (no section header). */
+function formatGroup(entries) {
+	const rows = entries.map((c) => [
+		c.name,
+		c.category,
+		c.description
+	]);
+	const headers = [
+		"Name",
+		"Category",
+		"Description"
+	];
+	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+	const line = (cells) => cells.map((cell, i) => cell.padEnd(widths[i] ?? cell.length)).join("  ").trimEnd();
+	const sep = widths.map((w) => "-".repeat(w)).join("  ");
+	return [
+		line(headers),
+		sep,
+		...rows.map(line)
+	].join("\n");
+}
+/** Render the component list as an aligned text table, grouped by type. */
+function formatList(components) {
+	if (components.length === 0) return "No components found.";
+	if (!components.some((c) => c.type !== void 0)) return formatGroup(components);
+	const groups = /* @__PURE__ */ new Map();
+	for (const c of components) {
+		const key = c.type ?? "component";
+		if (!groups.has(key)) groups.set(key, []);
+		groups.get(key).push(c);
+	}
+	const sections = [];
+	for (const [key, entries] of groups) {
+		const label = TYPE_LABELS[key] ?? key;
+		sections.push(`${label}\n${formatGroup(entries)}`);
+	}
+	return sections.join("\n\n");
+}
+async function list(config, options = {}) {
+	let components = (await fetchRegistry(config.registry)).components;
+	if (options.installed) components = components.filter((c) => {
+		const outputName = c.name.includes("/") ? c.name.split("/").pop() : c.name;
+		return existsSync(join(process.cwd(), config.outputDir, outputName));
+	});
+	console.log(formatList(components));
+}
+//#endregion
+//#region src/commands/registry.ts
+async function registryBuild(args) {
+	let inFile = "cascade-registry.json";
+	let outDir = "public/r";
+	for (let i = 0; i < args.length; i++) if (args[i] === "--in" && args[i + 1]) {
+		inFile = args[i + 1];
+		i++;
+	} else if (args[i] === "--out" && args[i + 1]) {
+		outDir = args[i + 1];
+		i++;
+	}
+	const inPath = resolve(inFile);
+	if (!existsSync(inPath)) {
+		console.error(`cascade registry build: file not found: ${inPath}`);
+		process.exitCode = 1;
+		return;
+	}
+	const raw = JSON.parse(await readFile(inPath, "utf8"));
+	dirname(inPath);
+	let index = (() => {
+		if (typeof raw === "object" && raw !== null && raw["schemaVersion"] === 2) return raw;
+		return parseLegacyRegistry(raw);
+	})();
+	const result = validateIndex(index);
+	if (result.warnings.length > 0) for (const w of result.warnings) console.warn(`warn: ${w}`);
+	if (!result.ok) {
+		for (const e of result.errors) console.error(`error: ${e}`);
+		process.exitCode = 1;
+		return;
+	}
+	const outPath = resolve(outDir);
+	await buildRegistry(index, outPath);
+	console.log(`cascade registry build: wrote static output to ${outPath}`);
+}
+//#endregion
+//#region src/commands/search.ts
+function matchesQuery(item, query) {
+	const q = query.toLowerCase();
+	return item.name.toLowerCase().includes(q) || item.description.toLowerCase().includes(q) || item.tags.some((t) => t.toLowerCase().includes(q));
+}
+async function search(args, config) {
+	const nsFlag = args.indexOf("--registry");
+	const registryFilter = nsFlag !== -1 ? args[nsFlag + 1] : void 0;
+	const query = args.filter((a, i) => a !== "--registry" && args[i - 1] !== "--registry").join(" ").trim();
+	if (!query) {
+		console.error("Usage: cascade search <query> [--registry @ns]");
+		return;
+	}
+	const results = [];
+	if (!registryFilter) {
+		const registry = await fetchRegistry(config.registry);
+		for (const c of registry.components) if (matchesQuery(c, query)) results.push({
+			name: c.name,
+			version: c.version,
+			description: c.description
+		});
+	}
+	const registries = config.registries ?? {};
+	for (const [ns, nsCfg] of Object.entries(registries)) {
+		if (registryFilter && ns !== registryFilter) continue;
+		try {
+			const raw = await fetchJson((typeof nsCfg === "string" ? nsCfg : nsCfg.url).replace(/{name}[^$]*$/, "").replace(/\/$/, "") + "/registry.json");
+			for (const item of raw.items ?? []) if (matchesQuery(item, query)) results.push({
+				name: `${ns}/${item.name}`,
+				version: item.version,
+				description: item.description,
+				registry: ns
+			});
+		} catch {
+			console.warn(`  [warn] Could not search ${ns} registry`);
+		}
+	}
+	if (results.length === 0) {
+		console.log("No results found.");
+		return;
+	}
+	for (const r of results) {
+		const reg = r.registry ? ` (${r.registry})` : "";
+		console.log(`${r.name}@${r.version}${reg} — ${r.description}`);
+	}
+}
+//#endregion
+//#region src/commands/theme.ts
+const THEMES = [
+	"light",
+	"dark",
+	"warm",
+	"flat",
+	"minimal",
+	"midnight",
+	"pastel",
+	"brutalist",
+	"corporate",
+	"terminal"
+];
+async function theme(args) {
+	const [sub, name] = args;
+	if (sub !== "add" || !name) {
+		console.error(`Usage: cascade theme add <${THEMES.join("|")}>`);
+		return;
+	}
+	if (!THEMES.includes(name)) {
+		console.error(`Unknown theme "${name}". Available: ${THEMES.join(", ")}`);
+		return;
+	}
+	installPackages(["@cascivo/themes"]);
+	console.log(`\nImport the theme in your root CSS or entry file:`);
+	console.log(`  import '@cascivo/themes/${name}.css'`);
+	console.log(`Then set it on a container:`);
+	console.log(`  <div data-theme="${name}">…</div>`);
+}
+//#endregion
+//#region src/utils/diff.ts
+/**
+* Minimal line-based diff (LCS) rendered in a unified-ish format. Zero deps —
+* good enough to preview what `cascade update` will change.
+*/
+function diffLines(oldStr, newStr) {
+	const a = oldStr.split("\n");
+	const b = newStr.split("\n");
+	const n = a.length;
+	const m = b.length;
+	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }, () => 0));
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < n && j < m) if (a[i] === b[j]) {
+		out.push(`  ${a[i]}`);
+		i++;
+		j++;
+	} else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+		out.push(`- ${a[i]}`);
+		i++;
+	} else {
+		out.push(`+ ${b[j]}`);
+		j++;
+	}
+	while (i < n) out.push(`- ${a[i++]}`);
+	while (j < m) out.push(`+ ${b[j++]}`);
+	return out;
+}
+/** True when the two strings differ. */
+function hasChanges(oldStr, newStr) {
+	return oldStr !== newStr;
+}
+//#endregion
+//#region src/utils/merge.ts
+function lcs(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+	return dp;
+}
+function diff(base, changed) {
+	const dp = lcs(base, changed);
+	const chunks = [];
+	let i = base.length;
+	let j = changed.length;
+	const leftOnly = [];
+	const rightOnly = [];
+	const common = [];
+	function flush() {
+		if (leftOnly.length > 0 || rightOnly.length > 0) {
+			if (common.length > 0) {
+				chunks.unshift({
+					type: "common",
+					lines: [...common]
+				});
+				common.length = 0;
+			}
+			chunks.unshift({
+				type: leftOnly.length > 0 ? "left" : "right",
+				lines: leftOnly.length > 0 ? [...leftOnly] : [...rightOnly]
+			});
+			leftOnly.length = 0;
+			rightOnly.length = 0;
+		} else if (common.length > 0) {
+			chunks.unshift({
+				type: "common",
+				lines: [...common]
+			});
+			common.length = 0;
+		}
+	}
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && base[i - 1] === changed[j - 1]) {
+		if (leftOnly.length > 0 || rightOnly.length > 0) flush();
+		common.unshift(base[i - 1]);
+		i--;
+		j--;
+	} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+		flush();
+		rightOnly.unshift(changed[j - 1]);
+		j--;
+	} else {
+		flush();
+		leftOnly.unshift(base[i - 1]);
+		i--;
+	}
+	flush();
+	return chunks;
+}
+function merge(base, local, upstream) {
+	const baseLines = base.split("\n");
+	const localLines = local.split("\n");
+	const upstreamLines = upstream.split("\n");
+	const localChunks = diff(baseLines, localLines);
+	diff(baseLines, upstreamLines);
+	const localMap = /* @__PURE__ */ new Map();
+	let li = 0;
+	for (const c of localChunks) if (c.type === "left") localMap.set(`del:${li}`, c.lines);
+	else if (c.type === "right") {
+		localMap.set(`ins:${li}`, c.lines);
+		li += c.lines.length;
+	} else li += c.lines.length;
+	const result = [];
+	let conflicts = 0;
+	baseLines.length;
+	localLines.length;
+	upstreamLines.length;
+	if (local === base) return {
+		text: upstream,
+		conflicts: 0
+	};
+	if (upstream === base) return {
+		text: local,
+		conflicts: 0
+	};
+	const localDiffs = diff(baseLines, localLines);
+	const upstreamDiffs = diff(baseLines, upstreamLines);
+	let basePos = 0;
+	let lPos = 0;
+	let uPos = 0;
+	const localOut = [];
+	const upstreamOut = [];
+	for (const c of localDiffs) if (c.type === "common") {
+		lPos += c.lines.length;
+		basePos += c.lines.length;
+	} else if (c.type === "right") {
+		localOut.push({
+			baseStart: basePos,
+			baseEnd: basePos,
+			lines: c.lines
+		});
+		lPos += c.lines.length;
+	} else {
+		localOut.push({
+			baseStart: basePos,
+			baseEnd: basePos + c.lines.length,
+			lines: []
+		});
+		basePos += c.lines.length;
+	}
+	basePos = 0;
+	for (const c of upstreamDiffs) if (c.type === "common") {
+		uPos += c.lines.length;
+		basePos += c.lines.length;
+	} else if (c.type === "right") {
+		upstreamOut.push({
+			baseStart: basePos,
+			baseEnd: basePos,
+			lines: c.lines
+		});
+		uPos += c.lines.length;
+	} else {
+		upstreamOut.push({
+			baseStart: basePos,
+			baseEnd: basePos + c.lines.length,
+			lines: []
+		});
+		basePos += c.lines.length;
+	}
+	const localByBase = /* @__PURE__ */ new Map();
+	for (const e of localOut) localByBase.set(e.baseStart, {
+		end: e.baseEnd,
+		lines: e.lines
+	});
+	const upstreamByBase = /* @__PURE__ */ new Map();
+	for (const e of upstreamOut) upstreamByBase.set(e.baseStart, {
+		end: e.baseEnd,
+		lines: e.lines
+	});
+	let b = 0;
+	while (b <= baseLines.length) {
+		const lEdit = localByBase.get(b);
+		const uEdit = upstreamByBase.get(b);
+		if (lEdit && uEdit) {
+			const lEnd = Math.max(lEdit.end, b);
+			const uEnd = Math.max(uEdit.end, b);
+			const lLines = lEdit.lines;
+			const uLines = uEdit.lines;
+			if (JSON.stringify(lLines) === JSON.stringify(uLines)) result.push(...lLines);
+			else {
+				result.push("<<<<<<< local");
+				result.push(...lLines);
+				result.push("=======");
+				result.push(...uLines);
+				result.push(">>>>>>> upstream");
+				conflicts++;
+			}
+			b = Math.max(lEnd, uEnd, b + 1);
+		} else if (lEdit) {
+			result.push(...lEdit.lines);
+			b = Math.max(lEdit.end, b + 1);
+		} else if (uEdit) {
+			result.push(...uEdit.lines);
+			b = Math.max(uEdit.end, b + 1);
+		} else {
+			if (b < baseLines.length) result.push(baseLines[b]);
+			b++;
+		}
+	}
+	return {
+		text: result.join("\n"),
+		conflicts
+	};
+}
+//#endregion
+//#region src/commands/update.ts
+async function confirm(question) {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		const answer = (await rl.question(`${question} (y/N): `)).trim().toLowerCase();
+		return answer === "y" || answer === "yes";
+	} finally {
+		rl.close();
+	}
+}
+async function fetchText(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
+	return res.text();
+}
+async function update(name, config, opts = {}) {
+	if (opts.check) return updateCheck(config);
+	if (!name) {
+		console.error("Usage: cascivo update <component>");
+		return;
+	}
+	const lockEntry = (await readLock())?.items[name];
+	const entry = findComponent(await fetchRegistry(config.registry), name);
+	if (!entry) {
+		console.error(`Component "${name}" not found in registry. Run "cascivo list".`);
+		return;
+	}
+	if (lockEntry) {
+		const lockedVersion = lockEntry.version;
+		const baseItemUrl = `${lockEntry.registry}/r/${name}@${lockedVersion}.json`;
+		let baseItem = null;
+		try {
+			baseItem = await fetchJson(baseItemUrl);
+		} catch {
+			console.warn(`Warning: could not fetch base version ${lockedVersion} from ${baseItemUrl}. Falling back to two-way diff.`);
+		}
+		if (baseItem) await threeWayUpdate(name, entry, baseItem, config, opts);
+		else await twoWayUpdate(name, entry, config, opts);
+	} else {
+		console.warn(`Warning: "${name}" has no lock entry. Falling back to two-way diff update (pre-v11 install).`);
+		await twoWayUpdate(name, entry, config, opts);
+	}
+}
+async function threeWayUpdate(name, upstreamEntry, baseItem, config, opts) {
+	if (!upstreamEntry) return;
+	const outputName = name.includes("/") ? name.split("/").pop() : name;
+	const summaries = [];
+	const pending = [];
+	for (const url of upstreamEntry.files) {
+		const fname = fileName(url);
+		const baseFile = baseItem.files.find((f) => fileName(f.url) === fname);
+		const dest = resolveOutputPath(config.outputDir, outputName, fname);
+		const upstream = await fetchText(url);
+		const local = existsSync(dest) ? await readFile(dest, "utf8") : "";
+		const base = baseFile ? await fetchText(baseFile.url) : "";
+		if (base === "" && local === "") {
+			summaries.push({
+				file: fname,
+				result: "clean"
+			});
+			pending.push({
+				dest,
+				content: upstream,
+				conflicts: 0
+			});
+			continue;
+		}
+		const { text, conflicts } = merge(base, local, upstream);
+		if (conflicts > 0) summaries.push({
+			file: fname,
+			result: "conflict"
+		});
+		else if (text === local) {
+			summaries.push({
+				file: fname,
+				result: "unchanged"
+			});
+			continue;
+		} else summaries.push({
+			file: fname,
+			result: "clean"
+		});
+		pending.push({
+			dest,
+			content: text,
+			conflicts
+		});
+	}
+	if (pending.length === 0) {
+		console.log(`${name} is already up to date.`);
+		return;
+	}
+	for (const s of summaries) {
+		const icon = s.result === "conflict" ? "⚠" : s.result === "clean" ? "✓" : "·";
+		console.log(`  ${icon} ${s.file} (${s.result})`);
+	}
+	const conflicted = pending.filter((p) => p.conflicts > 0);
+	if ((opts.yes ? conflicted.length === 0 : await confirm(`\nApply ${pending.length} change(s) to ${name}?`)) || opts.yes) {
+		const lock = await readLock();
+		let updatedLock = lock;
+		for (const { dest, content, conflicts } of pending) {
+			if (opts.yes && conflicts > 0) {
+				console.log(`  skipped (conflicts): ${dest}`);
+				continue;
+			}
+			await writeFileSafe(dest, content);
+		}
+		if (lock && updatedLock) {
+			const hasConflicts = conflicted.length > 0;
+			updatedLock = updateLockEntry(updatedLock, name, {
+				...lock.items[name],
+				version: upstreamEntry.version,
+				...hasConflicts ? { conflicted: true } : {}
+			});
+			await writeLock(updatedLock);
+		}
+		console.log(`Updated ${name}.`);
+		if (conflicted.length > 0) console.log(`${conflicted.length} file(s) have conflict markers — resolve them manually.`);
+	} else console.log("Aborted. No files changed.");
+}
+async function twoWayUpdate(name, entry, config, opts) {
+	if (!entry) return;
+	const pending = [];
+	for (const url of entry.files) {
+		const res = await fetch(url);
+		if (!res.ok) {
+			console.error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+			return;
+		}
+		const latest = await res.text();
+		const dest = resolveOutputPath(config.outputDir, entry.name, fileName(url));
+		const current = await readFileSafe(dest);
+		if (current === null) {
+			console.log(`New file: ${dest}`);
+			pending.push({
+				path: dest,
+				content: latest
+			});
+		} else if (hasChanges(current, latest)) {
+			console.log(`\n--- ${dest}`);
+			console.log(diffLines(current, latest).join("\n"));
+			pending.push({
+				path: dest,
+				content: latest
+			});
+		}
+	}
+	if (pending.length === 0) {
+		console.log(`${name} is already up to date.`);
+		return;
+	}
+	if (opts.yes || await confirm(`\nApply ${pending.length} change(s) to ${name}?`)) {
+		for (const { path, content } of pending) await writeFileSafe(path, content);
+		console.log(`Updated ${name}.`);
+	} else console.log("Aborted. No files changed.");
+}
+async function updateCheck(config) {
+	const lock = await readLock();
+	if (!lock || Object.keys(lock.items).length === 0) {
+		console.log("No installed components found in cascivo.lock.");
+		return;
+	}
+	const registry = await fetchRegistry(config.registry);
+	let outdated = 0;
+	for (const [name, entry] of Object.entries(lock.items)) {
+		const current = findComponent(registry, name);
+		if (!current) continue;
+		if (current.version !== entry.version) {
+			console.log(`${name}: ${entry.version} → ${current.version}`);
+			outdated++;
+		}
+	}
+	if (outdated > 0) {
+		console.log(`${outdated} component(s) outdated.`);
+		process.exitCode = 1;
+	} else console.log("All components up to date.");
+}
+//#endregion
+//#region src/commands/view.ts
+async function view(args, config) {
+	const spec = args[0];
+	if (!spec) {
+		console.error("Usage: cascade view <component-spec>");
+		return;
+	}
+	const { url, headers, params } = await resolveItemUrl(parseAddress(spec), config);
+	const fetchOpts = {};
+	if (headers) fetchOpts.headers = headers;
+	if (params) fetchOpts.params = params;
+	const item = await fetchJson(url, fetchOpts);
+	console.log(`\n${item.name}  v${item.version}`);
+	console.log(`Type: ${item.type}${item.category ? ` / ${item.category}` : ""}`);
+	console.log(`${item.description}`);
+	if (item.author) console.log(`Author: ${item.author}`);
+	if (item.license) console.log(`License: ${item.license}`);
+	if (item.homepage) console.log(`Homepage: ${item.homepage}`);
+	if (item.changelog?.length) {
+		console.log("\nChangelog:");
+		for (const c of item.changelog.slice(0, 5)) console.log(`  ${c.version}: ${c.note}`);
+	}
+	if (item.files?.length) {
+		console.log("\nFiles:");
+		for (const f of item.files) {
+			const target = f.target ? ` → ${f.target}` : "";
+			console.log(`  ${f.url}${target}`);
+		}
+	}
+	if (item.dependencies?.length) console.log(`\nDependencies: ${item.dependencies.join(", ")}`);
+	if (item.registryDependencies?.length) console.log(`Registry dependencies: ${item.registryDependencies.join(", ")}`);
+}
+//#endregion
+//#region src/index.ts
+const VERSION = "0.0.0";
+const HELP = `cascivo ${VERSION} — the CSS-native, signal-driven, AI-first design system
+
+Usage: cascivo <command> [options]
+
+Commands:
+  init                     Set up cascivo in the current project
+  add <component...>       Add one or more components to your project
+  list [--installed]       List available components
+  update [component]       Update installed components (--check: list outdated)
+  search <query>           Search components across registries
+  view <spec>              View a component before installing
+  theme add <name>         Install a theme (light | dark | warm)
+  generate <config.json>   Generate TSX from a ViewConfig JSON file
+  doctor [--ci]            Check components for rule violations
+  audit --ai <paths...>    Audit AI-generated code against the cascivo contract
+  registry build           Build a static registry from a cascivo-registry.json file
+
+Run "cascivo <command> --help" for details.`;
+async function run(args) {
+	const [command, ...rest] = args;
+	switch (command) {
+		case "init":
+			await init();
+			break;
+		case "add":
+			await add(rest, await loadConfig(), {
+				dryRun: rest.includes("--dry-run"),
+				yes: rest.includes("--yes")
+			});
+			break;
+		case "list":
+			await list(await loadConfig(), { installed: rest.includes("--installed") });
+			break;
+		case "update":
+			await update(rest.filter((r) => !r.startsWith("--"))[0], await loadConfig(), {
+				check: rest.includes("--check"),
+				yes: rest.includes("--yes")
+			});
+			break;
+		case "search":
+			await search(rest, await loadConfig());
+			break;
+		case "view":
+			await view(rest, await loadConfig());
+			break;
+		case "theme":
+			await theme(rest);
+			break;
+		case "generate":
+			await generate(rest, await loadConfig());
+			break;
+		case "registry":
+			if (rest[0] === "build") await registryBuild(rest.slice(1));
+			else {
+				console.error(`Unknown registry subcommand: ${rest[0]}`);
+				process.exitCode = 1;
+			}
+			break;
+		case "doctor": {
+			const ci = rest.includes("--ci");
+			if (rest.includes("--drift")) {
+				const { runDoctorDrift } = await import("./drift-D7JFzpP_.mjs");
+				await runDoctorDrift(rest);
+			} else {
+				const result = await runDoctor(process.cwd());
+				if (result.passed) console.log("No violations found.");
+				else {
+					for (const v of result.violations) console.error(`[${v.rule}] ${v.detail}\n  ${v.file}`);
+					if (ci) process.exitCode = 1;
+				}
+			}
+			break;
+		}
+		case "audit": {
+			const { audit } = await import("./audit-AHr4MDMK.mjs");
+			await audit(rest, await loadConfig());
+			break;
+		}
+		case "tokens":
+			if (rest[0] === "import") {
+				const { tokensImport } = await import("./tokens-CO1xRiYC.mjs");
+				await tokensImport(rest.slice(1));
+			} else {
+				console.error(`Unknown tokens subcommand: ${rest[0]}`);
+				process.exitCode = 1;
+			}
+			break;
+		case void 0:
+		case "--help":
+		case "-h":
+		case "help":
+			console.log(HELP);
+			break;
+		case "--version":
+		case "-v":
+			console.log(VERSION);
+			break;
+		default:
+			console.error(`Unknown command: ${command}\n`);
+			console.log(HELP);
+			process.exitCode = 1;
+	}
+}
+if (argv[1] !== void 0 && import.meta.url === pathToFileURL(argv[1]).href) run(argv.slice(2)).catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export { VERSION, run };
+
+//# sourceMappingURL=index.mjs.map