wensity 0.1.12 → 0.1.13

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/commands.ts
-import { mkdir as mkdir6, readFile as readFile6, stat, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7, join as join7 } from "path";
+import { randomBytes } from "crypto";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir7, readFile as readFile8, stat, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join11, relative as relative8 } from "path";
 
-// src/constants.ts
-var CLI_NAME = "wensity";
-var CLI_VERSION = "0.1.12";
+// ../install-core/src/constants.ts
 var CONFIG_FILE_NAME = "wensity.json";
 var DEFAULT_API_ORIGIN = "https://ui.wensity.com";
 var DEFAULT_REGISTRY_PATH = "/api/registry";
@@ -14,6 +14,10 @@ var DEFAULT_COMPONENTS_DIR = "src/components/wensity";
 var DEFAULT_UTILS_PATH = "src/lib/utils";
 var DEFAULT_COMPONENTS_ALIAS = "@/components/wensity";
 var DEFAULT_UTILS_ALIAS = "@/lib/utils";
+
+// src/constants.ts
+var CLI_NAME = "wensity";
+var CLI_VERSION = "0.1.13";
 var INIT_PRIMITIVE_CSS_SLUG = "button";
 var HELP_TEXT = `Wensity CLI ${CLI_VERSION}
 
@@ -68,85 +72,950 @@ Preset notes:
   Invalid/expired/unsupported codes exit non-zero with an actionable message
 `;
 
-// src/errors.ts
-var CliError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.name = "CliError";
-    this.exitCode = exitCode;
+// ../install-core/src/errors.ts
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "rate_limited",
+  "network_error",
+  "server_error",
+  "source_unavailable",
+  "source_integrity_failed",
+  "plan_in_progress",
+  "write_failed",
+  "dependency_install_failed"
+]);
+var WensityError = class extends Error {
+  code;
+  retryable;
+  upstream;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "WensityError";
+    this.code = code;
+    this.retryable = RETRYABLE_CODES.has(code);
+    if (options.upstream) this.upstream = options.upstream;
+    if (options.details) this.details = options.details;
   }
 };
+function isWensityError(error) {
+  return error instanceof WensityError;
+}
 function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 
-// src/args.ts
-function parseArgs(argv) {
-  const positionals = [];
-  const options = /* @__PURE__ */ new Map();
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (!token.startsWith("--")) {
-      positionals.push(token);
-      continue;
+// ../install-core/src/http.ts
+var DEFAULT_RETRY_POLICY = { maxAttempts: 3, baseDelayMs: 500, maxRetryAfterMs: 2e3 };
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var CircuitBreakers = class {
+  #options;
+  #state = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.#options = { threshold: 5, cooldownMs: 3e4, now: Date.now, ...options };
+  }
+  /** Milliseconds until `origin` may be tried again, or 0 when it may be tried now. */
+  remainingMs(origin) {
+    const state = this.#state.get(origin);
+    return state ? Math.max(0, state.openUntil - this.#options.now()) : 0;
+  }
+  recordFailure(origin) {
+    const state = this.#state.get(origin) ?? { failures: 0, openUntil: 0 };
+    state.failures += 1;
+    if (state.failures >= this.#options.threshold) state.openUntil = this.#options.now() + this.#options.cooldownMs;
+    this.#state.set(origin, state);
+  }
+  recordSuccess(origin) {
+    this.#state.delete(origin);
+  }
+  reset() {
+    this.#state.clear();
+  }
+};
+var sharedCircuitBreakers = new CircuitBreakers();
+async function requestJson(url, options = {}) {
+  const {
+    token,
+    userAgent,
+    timeoutMs,
+    fetch: fetchImpl = fetch,
+    retry,
+    breakers = sharedCircuitBreakers,
+    sleep = defaultSleep,
+    random = Math.random,
+    ...init
+  } = options;
+  const headers = new Headers(init.headers);
+  headers.set("accept", "application/json");
+  if (userAgent) headers.set("user-agent", userAgent);
+  if (init.body && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  if (token) {
+    headers.set("authorization", `Bearer ${token}`);
+  }
+  const policy = { ...DEFAULT_RETRY_POLICY, ...retry || {} };
+  const method = (init.method ?? "GET").toUpperCase();
+  const idempotent = (method === "GET" || method === "HEAD") && !init.body;
+  const maxAttempts = retry === false || !idempotent ? 1 : Math.max(1, Math.floor(policy.maxAttempts));
+  const origin = originOf(url);
+  let last;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const waitMs = breakers && origin ? breakers.remainingMs(origin) : 0;
+    if (waitMs > 0) {
+      throw last ?? circuitOpen(url, origin, waitMs);
+    }
+    const outcome = await attemptOnce(url, { ...init, headers }, fetchImpl, timeoutMs);
+    if (breakers && origin) {
+      if (outcome.kind === "failed" && outcome.countsAsFailure) breakers.recordFailure(origin);
+      else breakers.recordSuccess(origin);
+    }
+    if (outcome.kind === "ok") return outcome.value;
+    last = outcome.error;
+    if (!outcome.retryable || attempt === maxAttempts) break;
+    if (outcome.retryAfterMs !== void 0 && outcome.retryAfterMs > policy.maxRetryAfterMs) break;
+    const backoff = random() * policy.baseDelayMs * 2 ** (attempt - 1);
+    await sleep(outcome.retryAfterMs ?? backoff);
+  }
+  throw last;
+}
+async function attemptOnce(url, init, fetchImpl, timeoutMs) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error(`timed out after ${timeoutMs} ms`));
+  }, timeoutMs);
+  const callerSignal = init.signal;
+  const forwardAbort = () => controller.abort(callerSignal?.reason);
+  if (callerSignal?.aborted) forwardAbort();
+  else callerSignal?.addEventListener("abort", forwardAbort, { once: true });
+  const transportFailure = (prefix, error) => {
+    const message = timedOut ? `timed out after ${timeoutMs} ms` : error instanceof Error ? error.message : "Unknown network error";
+    const cancelled = Boolean(callerSignal?.aborted) && !timedOut;
+    return {
+      kind: "failed",
+      error: new WensityError("network_error", `${prefix} ${url}: ${message}`, { cause: error }),
+      // A timeout already used the whole budget, and a caller's cancel is not the origin's fault.
+      retryable: !timedOut && !cancelled,
+      countsAsFailure: !cancelled
+    };
+  };
+  try {
+    let response;
+    try {
+      response = await fetchImpl(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      return transportFailure("Could not reach", error);
     }
-    if (token === "--") {
-      positionals.push(...argv.slice(index + 1));
-      break;
+    let text;
+    try {
+      text = await response.text();
+    } catch (error) {
+      return transportFailure("Could not read the response from", error);
     }
-    const inlineValueIndex = token.indexOf("=");
-    const rawName = inlineValueIndex > -1 ? token.slice(2, inlineValueIndex) : token.slice(2);
-    const name = normalizeOptionName(rawName);
-    if (!name) {
-      throw new CliError(`Invalid option: ${token}`);
+    if (!response.ok) {
+      const upstream = readUpstreamError(response, parseJsonOrNull(text));
+      const message = upstream.message ?? upstream.error ?? response.statusText;
+      return {
+        kind: "failed",
+        error: new WensityError(errorCodeFor(upstream), `${response.status} ${message}`, { upstream }),
+        retryable: RETRYABLE_STATUSES.has(response.status),
+        countsAsFailure: response.status === 429 || response.status >= 500,
+        ...upstream.retryAfterSeconds !== void 0 ? { retryAfterMs: upstream.retryAfterSeconds * 1e3 } : {}
+      };
     }
-    if (inlineValueIndex > -1) {
-      options.set(name, token.slice(inlineValueIndex + 1));
-      continue;
+    return { kind: "ok", value: parseJson(text) };
+  } finally {
+    if (timer) clearTimeout(timer);
+    callerSignal?.removeEventListener("abort", forwardAbort);
+  }
+}
+function circuitOpen(url, origin, waitMs) {
+  const seconds = Math.ceil(waitMs / 1e3);
+  return new WensityError(
+    "network_error",
+    `Could not reach ${url}: requests to ${origin} kept failing, so they are paused for ${seconds} s.`,
+    { details: { circuit: "open", retryAfterSeconds: seconds } }
+  );
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return void 0;
+  }
+}
+function defaultSleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function parseJsonOrNull(text) {
+  try {
+    return parseJson(text);
+  } catch {
+    return null;
+  }
+}
+function parseJson(text) {
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new WensityError("source_integrity_failed", "Registry returned invalid JSON.");
+  }
+}
+function readUpstreamError(response, payload) {
+  const upstream = { status: response.status };
+  const record = payload && typeof payload === "object" ? payload : {};
+  if (typeof record.error === "string") upstream.error = record.error;
+  if (typeof record.message === "string") upstream.message = record.message;
+  if (record.plan && typeof record.plan === "object") upstream.plan = record.plan;
+  const retryAfter = readRetryAfter(response, record);
+  if (retryAfter !== void 0) upstream.retryAfterSeconds = retryAfter;
+  return upstream;
+}
+function readRetryAfter(response, record) {
+  const rateLimit = record.rateLimit;
+  if (rateLimit && typeof rateLimit.retryAfterSeconds === "number") return rateLimit.retryAfterSeconds;
+  const header = Number(response.headers.get("retry-after"));
+  return Number.isFinite(header) && header > 0 ? header : void 0;
+}
+var UPSTREAM_ERROR_CODES = {
+  missing_token: "auth_invalid",
+  invalid_token: "auth_invalid",
+  token_revoked: "auth_revoked",
+  token_user_missing: "auth_user_missing",
+  pro_license_required: "entitlement_required",
+  component_not_found: "item_not_found",
+  block_not_found: "item_not_found",
+  invalid_component_slug: "invalid_slug",
+  invalid_block_slug: "invalid_slug",
+  rate_limit_exceeded: "rate_limited",
+  component_source_unreadable: "source_unavailable",
+  block_source_unreadable: "source_unavailable",
+  component_source_graph_unreadable: "source_unavailable",
+  cli_auth_failed: "server_error"
+};
+function errorCodeFor(upstream) {
+  const known = upstream.error ? UPSTREAM_ERROR_CODES[upstream.error] : void 0;
+  if (known) return known;
+  switch (upstream.status) {
+    case 401:
+      return "auth_invalid";
+    // A 403 without `pro_license_required` is not a licensing answer, so it
+    // falls through to server_error rather than guessing at entitlement.
+    case 404:
+      return "item_not_found";
+    case 429:
+      return "rate_limited";
+    default:
+      return "server_error";
+  }
+}
+
+// ../install-core/src/paths.ts
+import { lstatSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function normalizeUrlOrigin(input) {
+  const trimmed = input.trim().replace(/\/+$/, "");
+  const withProtocol = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  const url = new URL(withProtocol);
+  if (url.protocol !== "https:" && !isLocalHttpUrl(url)) {
+    throw new WensityError("config_invalid", "API URL must use HTTPS, except for localhost development URLs.");
+  }
+  return url.origin;
+}
+function isLocalHttpUrl(url) {
+  if (url.protocol !== "http:") return false;
+  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+}
+function joinUrl(originOrUrl, path) {
+  const base = originOrUrl.endsWith("/") ? originOrUrl : `${originOrUrl}/`;
+  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+  return new URL(normalizedPath, base).toString();
+}
+function resolveInside(root, candidate) {
+  if (isAbsolute(candidate)) {
+    throw new WensityError("path_unsafe", `Path must be project-relative: ${candidate}`);
+  }
+  const absolutePath = resolve(root, candidate);
+  if (escapes(relative(root, absolutePath))) {
+    throw new WensityError("path_unsafe", `Path escapes the project: ${candidate}`);
+  }
+  return absolutePath;
+}
+function escapes(relativePath) {
+  return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath);
+}
+var MAX_TARGET_PATH_LENGTH = 240;
+var SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/;
+function assertTargetPathLength(relativePath) {
+  if (relativePath.length > MAX_TARGET_PATH_LENGTH) {
+    throw new WensityError(
+      "path_unsafe",
+      `Path is longer than ${MAX_TARGET_PATH_LENGTH} characters: ${relativePath.slice(0, 60)}\u2026`
+    );
+  }
+}
+function toPosixPath(input) {
+  return input.split(sep).join("/");
+}
+function parentDirectory(input) {
+  return dirname(input);
+}
+function stripKnownComponentPrefix(path) {
+  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "");
+  const prefixes = ["components/wensity/", "src/components/wensity/"];
+  const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+  return prefix ? normalized.slice(prefix.length) : normalized;
+}
+function sanitizePayloadPath(path, fallbackFileName) {
+  const unsafe3 = () => new WensityError("path_unsafe", `Unsafe registry file path: ${path}`);
+  if (/^[\\/]/.test(path) || /^[A-Za-z]:/.test(path)) throw unsafe3();
+  const normalized = stripKnownComponentPrefix(path);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0) return fallbackFileName;
+  for (const part of parts) {
+    if (part === "." || part === ".." || !SAFE_SEGMENT.test(part)) throw unsafe3();
+  }
+  if (normalized.length > MAX_TARGET_PATH_LENGTH) throw unsafe3();
+  const last = parts.at(-1) ?? fallbackFileName;
+  if (!/\.(tsx|ts|jsx|js)$/.test(last)) {
+    parts[parts.length - 1] = fallbackFileName;
+  }
+  return parts.join("/");
+}
+function componentFileName(slug) {
+  return `${slugToPascalCase(slug)}.tsx`;
+}
+function slugToPascalCase(slug) {
+  return slug.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function extensionlessPath(path) {
+  return path.replace(/\.(tsx|ts|jsx|js)$/, "");
+}
+function assertNoSymlinkEscape(projectRoot, absolutePath) {
+  const root = resolve(projectRoot);
+  const relativePath = relative(root, resolve(absolutePath));
+  if (escapes(relativePath)) {
+    throw new WensityError("path_unsafe", `Path escapes the project: ${toPosixPath(relativePath)}`);
+  }
+  let realRoot;
+  try {
+    realRoot = realpathSync(root);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return;
+    throw error;
+  }
+  let current = root;
+  for (const segment of relativePath.split(sep).filter(Boolean)) {
+    current = join(current, segment);
+    let isSymlink;
+    try {
+      isSymlink = lstatSync(current).isSymbolicLink();
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return;
+      throw error;
     }
-    const nextToken = argv[index + 1];
-    if (nextToken && !nextToken.startsWith("--") && expectsValue(name)) {
-      options.set(name, nextToken);
-      index += 1;
-      continue;
+    if (!isSymlink) continue;
+    let target;
+    try {
+      target = realpathSync(current);
+    } catch {
+      throw new WensityError("path_unsafe", `Path passes through a broken symlink: ${toPosixPath(relative(root, current))}`);
+    }
+    const fromRoot = relative(realRoot, target);
+    if (escapes(fromRoot)) {
+      throw new WensityError(
+        "path_unsafe",
+        `Path escapes the project through a symlink: ${toPosixPath(relative(root, current))}`
+      );
     }
-    options.set(name, true);
   }
-  return { positionals, options };
 }
-function getStringOption(args, name) {
-  const value = args.options.get(name);
-  if (value === void 0) return void 0;
-  if (typeof value === "boolean") {
-    throw new CliError(`--${name} expects a value.`);
+
+// ../install-core/src/client.ts
+function createWensityClient(options) {
+  const origin = options.origin;
+  const registryUrl = options.registryUrl ?? joinUrl(origin, "/api/registry");
+  const blocksRegistryUrl = options.blocksRegistryUrl ?? joinUrl(registryOrigin(registryUrl), "/api/blocks");
+  const apiBaseUrl = options.apiBaseUrl ?? origin;
+  const tokenOrigin = new URL(apiBaseUrl).origin;
+  const { token } = options;
+  const download = (task) => task();
+  function get(url, withToken = false) {
+    const request = {
+      userAgent: options.userAgent,
+      ...options.headers ? { headers: withoutAuthorization(options.headers) } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+      ...options.fetch ? { fetch: options.fetch } : {},
+      ...options.retry !== void 0 ? { retry: options.retry } : {},
+      ...options.breakers !== void 0 ? { breakers: options.breakers } : {},
+      ...options.sleep ? { sleep: options.sleep } : {}
+    };
+    if (withToken && token) {
+      assertTokenDestination(url, tokenOrigin);
+      request.token = token;
+    }
+    return requestJson(url, request);
   }
-  return value;
+  function indexUrl(kind) {
+    return kind === "block" ? blocksRegistryUrl : registryUrl;
+  }
+  async function fetchItemMetadata(slug, kind) {
+    return get(registryMetadataUrl(indexUrl(kind), slug));
+  }
+  async function fetchComponentSource(slug, opts) {
+    const metadata = opts.metadata ?? await fetchItemMetadata(slug, "component");
+    const wrap = opts.download ?? download;
+    if (token) {
+      const cliEndpoint = metadata.endpoints?.cli ?? `/api/cli/${slug}`;
+      const endpoint2 = cliEndpoint.startsWith("http") ? cliEndpoint : joinUrl(apiBaseUrl, cliEndpoint);
+      try {
+        return await wrap(() => get(endpoint2, true));
+      } catch (error) {
+        if (metadata.access === "pro" || !isAuthFailure(error)) throw error;
+        opts.onCredentialsRejected?.(error);
+      }
+    }
+    if (metadata.access === "pro") {
+      throw proRequired(slug, metadata.name, "component");
+    }
+    const publicSourceEndpoint = metadata.endpoints?.registry ?? registrySlugUrl(registryUrl, slug);
+    const endpoint = publicSourceEndpoint.startsWith("http") ? publicSourceEndpoint : joinUrl(registryOrigin(registryUrl), publicSourceEndpoint);
+    return wrap(() => get(endpoint));
+  }
+  async function fetchBlockSource(slug, opts) {
+    const metadata = opts.metadata ?? await fetchItemMetadata(slug, "block");
+    if (!token) {
+      throw proRequired(slug, metadata.name, "block");
+    }
+    const cliEndpoint = metadata.endpoints?.cli ?? `/api/cli/blocks/${slug}`;
+    const endpoint = cliEndpoint.startsWith("http") ? cliEndpoint : joinUrl(apiBaseUrl, cliEndpoint);
+    return (opts.download ?? download)(() => get(endpoint, true));
+  }
+  return {
+    fetchComponentIndex: () => get(registryUrl),
+    fetchBlockIndex: () => get(blocksRegistryUrl),
+    fetchItemMetadata,
+    async fetchSourcePayload(slug, kind, opts = {}) {
+      if (kind === "block") {
+        return await fetchBlockSource(slug, opts);
+      }
+      return await fetchComponentSource(slug, opts);
+    },
+    async whoami() {
+      if (!token) {
+        throw new WensityError("auth_required", "No Wensity API token is configured.");
+      }
+      return get(joinUrl(apiBaseUrl, "/api/cli/whoami"), true);
+    }
+  };
 }
-function hasFlag(args, name) {
-  return args.options.get(name) === true;
+function withoutAuthorization(headers) {
+  return Object.fromEntries(Object.entries(headers).filter(([name]) => name.toLowerCase() !== "authorization"));
 }
-function expectsValue(name) {
+function isAuthFailure(error) {
+  const status = isWensityError(error) ? error.upstream?.status : void 0;
+  return status === 401 || status === 403;
+}
+function proRequired(slug, name, kind) {
+  return new WensityError("auth_required", `${name} is a Pro ${kind}.`, {
+    details: { slug, name, kind }
+  });
+}
+function assertTokenDestination(url, tokenOrigin) {
+  const destination = new URL(url).origin;
+  if (destination !== tokenOrigin) {
+    throw new WensityError(
+      "source_integrity_failed",
+      `Refusing to send the saved API token to ${destination}; it belongs to ${tokenOrigin}.`
+    );
+  }
+}
+function registryMetadataUrl(registry, slug) {
+  const url = new URL(registry);
+  url.searchParams.set("slug", slug);
+  return url.toString();
+}
+function registrySlugUrl(registry, slug) {
+  return joinUrl(registry.endsWith("/") ? registry : `${registry}/`, slug);
+}
+function registryOrigin(registry) {
+  const url = new URL(registry);
+  return `${url.protocol}//${url.host}`;
+}
+
+// ../install-core/src/apply.ts
+import { createHash } from "crypto";
+import {
+  closeSync,
+  constants as fsConstants,
+  fchmodSync,
+  fstatSync,
+  fsyncSync,
+  ftruncateSync,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync2,
+  openSync,
+  renameSync,
+  rmdirSync as rmdirSync2,
+  unlinkSync,
+  writeSync
+} from "fs";
+import { chmod, copyFile, mkdir, open, readFile, rename, rm } from "fs/promises";
+import { dirname as dirname2, join as join3, relative as relative3 } from "path";
+
+// ../install-core/src/workdir.ts
+import { lstatSync as lstatSync2, mkdirSync, readdirSync, readFileSync, realpathSync as realpathSync2, rmdirSync } from "fs";
+import { isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "path";
+var WORK_DIR_NAME = ".wensity-tmp";
+var JOURNAL_FILE = "journal.json";
+var LOCK_FILE = "install.lock";
+function unsafe(message) {
+  return new WensityError("path_unsafe", message);
+}
+function lstatOrUndefined(path) {
+  try {
+    return lstatSync2(path);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function assertRealDirectoryInside(projectRoot, path) {
+  const stat2 = lstatOrUndefined(path);
+  if (!stat2) throw unsafe(`${WORK_DIR_NAME} disappeared while it was in use.`);
+  if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+    throw unsafe(`${toPosixPath(relative2(projectRoot, path))} is not a real directory (a symlink, junction, or file). Remove it and retry.`);
+  }
+  const fromRoot = relative2(realpathSync2(projectRoot), realpathSync2(path));
+  if (fromRoot === ".." || fromRoot.startsWith("../") || fromRoot.startsWith("..\\") || isAbsolute2(fromRoot)) {
+    throw unsafe(`${WORK_DIR_NAME} resolves outside the project.`);
+  }
+}
+function ensureWorkDir(projectRoot) {
+  const dir = join2(projectRoot, WORK_DIR_NAME);
+  if (!lstatOrUndefined(dir)) {
+    try {
+      mkdirSync(dir, { mode: 448 });
+    } catch (error) {
+      if (!(isNodeError(error) && error.code === "EEXIST")) throw error;
+    }
+  }
+  assertRealDirectoryInside(projectRoot, dir);
+  return dir;
+}
+function removeWorkDirIfEmpty(projectRoot) {
+  const dir = join2(projectRoot, WORK_DIR_NAME);
+  const stat2 = lstatOrUndefined(dir);
+  if (!stat2 || stat2.isSymbolicLink() || !stat2.isDirectory()) return;
+  try {
+    rmdirSync(dir);
+  } catch {
+  }
+}
+function findIncompleteJournals(projectRoot) {
+  const dir = join2(projectRoot, WORK_DIR_NAME);
+  if (!lstatOrUndefined(dir)) return [];
+  assertRealDirectoryInside(projectRoot, dir);
+  const lock = lstatOrUndefined(join2(dir, LOCK_FILE));
+  if (lock && (lock.isSymbolicLink() || !lock.isFile())) {
+    throw unsafe(`${WORK_DIR_NAME}/${LOCK_FILE} is not a regular file. It was not followed or removed; delete it yourself.`);
+  }
+  const found = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const journalPath = `${WORK_DIR_NAME}/${entry.name}`;
+    const file = join2(dir, entry.name, JOURNAL_FILE);
+    const stat2 = lstatOrUndefined(file);
+    let journal;
+    if (stat2?.isFile()) {
+      try {
+        journal = JSON.parse(readFileSync(file, "utf8"));
+      } catch {
+        journal = void 0;
+      }
+    }
+    const status = typeof journal?.status === "string" ? journal.status : "unknown";
+    if (status === "committed" || status === "rolled_back") continue;
+    const entries = Array.isArray(journal?.entries) ? journal.entries : [];
+    found.push({
+      journalPath,
+      status,
+      affectedPaths: entries.map((item) => item.relativePath),
+      backupsAvailable: entries.filter((item) => item.existed && item.backup && lstatOrUndefined(join2(dir, entry.name, item.backup))?.isFile()).map((item) => item.relativePath),
+      backupsMissing: entries.filter((item) => !item.existed).map((item) => item.relativePath)
+    });
+  }
+  return found.sort((a, b) => a.journalPath.localeCompare(b.journalPath));
+}
+function recoveryRequired(journal) {
+  return new WensityError(
+    "recovery_required",
+    "A previous Wensity installation did not finish. Recover it before installing again.",
+    {
+      details: {
+        journalPath: journal.journalPath,
+        status: journal.status,
+        affectedPaths: journal.affectedPaths,
+        backupsAvailable: journal.backupsAvailable,
+        backupsMissing: journal.backupsMissing,
+        steps: RECOVERY_STEPS(journal.journalPath)
+      }
+    }
+  );
+}
+function RECOVERY_STEPS(journalPath) {
   return [
-    "api-url",
-    "registry",
-    "token",
-    "type",
-    "preset",
-    "preset-file",
-    "template",
-    "package-manager"
-  ].includes(name);
+    `Inspect ${journalPath}/${JOURNAL_FILE} (if it is missing, no project file was changed by that run)`,
+    "For each entry with existed:true, restore the file from its backup/<n> copy",
+    "For each entry with existed:false that now exists, delete it only if you did not create it yourself",
+    `Verify with git diff, then delete the ${journalPath} directory yourself`,
+    "Re-run the installation"
+  ];
 }
-function normalizeOptionName(name) {
-  if (name === "dry") return "dry-run";
-  return name;
+function assertNoIncompleteJournal(projectRoot) {
+  const [first] = findIncompleteJournals(projectRoot);
+  if (first) throw recoveryRequired(first);
 }
 
-// src/config.ts
-import { existsSync } from "fs";
-import { access, mkdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join2, relative as relative2 } from "path";
+// ../install-core/src/apply.ts
+var WINDOWS_RETRY_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+var WINDOWS_PLACEMENT_ATTEMPTS = 5;
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+async function apply(options) {
+  const { projectRoot, planId, files } = options;
+  const hooks = options.testHooks ?? {};
+  const platform = options.platform ?? process.platform;
+  const emit = (event) => hooks.onEvent?.(event);
+  const fault = (at, index = 0) => {
+    if (hooks.fault && hooks.fault.at === at && (hooks.fault.file ?? 0) === index) {
+      throw new WensityError("write_failed", `Injected fault at ${at}.`);
+    }
+  };
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(planId)) throw new WensityError("path_unsafe", `Invalid journal name: ${planId}`);
+  assertNoIncompleteJournal(projectRoot);
+  const targets = files.map((file) => {
+    assertTargetPathLength(file.relativePath);
+    const absolutePath = resolveInside(projectRoot, file.relativePath);
+    assertNoSymlinkEscape(projectRoot, absolutePath);
+    if (file.content.includes("\0")) {
+      throw new WensityError("source_integrity_failed", `${file.relativePath} contains a NUL byte; Wensity only installs text source.`);
+    }
+    const stat2 = lstatOrUndefined2(absolutePath);
+    if (stat2 && (stat2.isSymbolicLink() || !stat2.isFile())) {
+      throw new WensityError("path_unsafe", `${file.relativePath} exists but is not a regular file (a symlink or directory). Nothing was written.`);
+    }
+    if (file.action === "create" && stat2) {
+      throw new WensityError("plan_stale", `${file.relativePath} appeared after planning.`, {
+        details: { reason: "precondition_mismatch", path: file.relativePath, expected: "absent", found: "present" }
+      });
+    }
+    if (file.action !== "create" && !stat2) {
+      throw new WensityError("plan_stale", `${file.relativePath} was removed after planning.`, {
+        details: { reason: "precondition_mismatch", path: file.relativePath, expected: "present", found: "absent" }
+      });
+    }
+    return { ...file, absolutePath, existed: Boolean(stat2), mode: stat2 ? stat2.mode & 511 : void 0 };
+  });
+  const workDir = ensureWorkDir(projectRoot);
+  const journalDir = join3(workDir, planId);
+  try {
+    mkdirSync2(journalDir, { mode: 448 });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "EEXIST") {
+      throw new WensityError("path_unsafe", `${WORK_DIR_NAME}/${planId} already exists; it was not reused.`);
+    }
+    throw error;
+  }
+  const journalPath = toPosixPath(relative3(projectRoot, journalDir));
+  const journalFile = join3(journalDir, JOURNAL_FILE);
+  const entries = targets.map((target) => ({
+    relativePath: target.relativePath,
+    existed: target.existed,
+    expectedSha256: sha256(target.content),
+    action: target.action
+  }));
+  const writeJournal = async (status, step) => {
+    await writeSynced(journalFile, `${JSON.stringify({ version: 1, planId, status, step, entries }, null, 2)}
+`, 384, true);
+    await syncDirectory(journalDir);
+    emit({ type: "journal", status, step });
+  };
+  const attempted = targets.map(() => false);
+  const placed = targets.map(() => void 0);
+  const createdDirs = [];
+  let failedPath;
+  try {
+    await mkdir(join3(journalDir, "backup"), { mode: 448 });
+    await mkdir(join3(journalDir, "staged"), { mode: 448 });
+    for (const [index, target] of targets.entries()) {
+      failedPath = target.relativePath;
+      if (target.existed) {
+        const backup = `backup/${index}`;
+        await copyFile(target.absolutePath, join3(journalDir, backup), fsConstants.COPYFILE_EXCL);
+        entries[index].backup = backup;
+        entries[index].sha256Before = sha256(await readFile(join3(journalDir, backup)));
+        entries[index].mode = target.mode;
+        emit({ type: "backup", path: target.relativePath });
+      }
+      fault("backup", index);
+    }
+    failedPath = void 0;
+    await writeJournal("in_progress", "backed_up");
+    fault("journal");
+    await writeJournal("in_progress", "staging");
+    for (const [index, target] of targets.entries()) {
+      failedPath = target.relativePath;
+      await writeSynced(join3(journalDir, "staged", String(index)), target.content, target.mode ?? 420);
+      emit({ type: "stage", path: target.relativePath });
+      fault("stage", index);
+    }
+    await writeJournal("in_progress", "placing");
+    for (const [index, target] of targets.entries()) {
+      failedPath = target.relativePath;
+      await makeParents(projectRoot, dirname2(target.absolutePath), createdDirs);
+      attempted[index] = true;
+      placed[index] = await place(join3(journalDir, "staged", String(index)), target, platform, hooks, emit, projectRoot);
+      assertPlaced(projectRoot, target, placed[index]);
+      fault("place", index);
+      const onDisk = sha256(await readFile(target.absolutePath));
+      emit({ type: "verify", path: target.relativePath });
+      if (onDisk !== entries[index].expectedSha256) {
+        throw new WensityError("source_integrity_failed", `${target.relativePath} did not verify after writing (hash mismatch).`, {
+          details: { reason: "post_write_hash_mismatch", path: target.relativePath }
+        });
+      }
+      fault("verify", index);
+    }
+  } catch (cause) {
+    const error = isWensityError(cause) ? cause : new WensityError("write_failed", `Writing ${failedPath ?? "the project files"} failed: ${cause.message}`, { cause });
+    return rollback({ projectRoot, journalDir, journalPath, targets, entries, attempted, placed, createdDirs, writeJournal, error, failedPath, emit });
+  }
+  try {
+    fault("commit");
+    await writeJournal("committed", "done");
+  } catch (cause) {
+    const error = isWensityError(cause) ? cause : new WensityError("write_failed", `Recording the commit failed: ${cause.message}`, { cause });
+    return rollback({ projectRoot, journalDir, journalPath, targets, entries, attempted, placed, createdDirs, writeJournal, error, failedPath: void 0, emit });
+  }
+  let cleanupWarning;
+  try {
+    await rm(journalDir, { recursive: true, force: true });
+    removeWorkDirIfEmpty(projectRoot);
+  } catch (error) {
+    cleanupWarning = `The install committed, but ${journalPath} could not be removed (${error.message}). It is marked committed and can be deleted.`;
+  }
+  return {
+    status: "committed",
+    ...cleanupWarning ? { cleanupWarning } : {},
+    changes: targets.map((target, index) => ({
+      path: target.relativePath,
+      action: target.action === "create" ? "created" : target.action === "modify" ? "modified" : "overwritten",
+      bytes: Buffer.byteLength(target.content),
+      sha256: entries[index].expectedSha256
+    }))
+  };
+}
+async function rollback(input) {
+  const { journalDir, targets, entries, attempted, placed } = input;
+  const restored = [];
+  const removed = [];
+  const unrecovered = [];
+  for (let index = targets.length - 1; index >= 0; index -= 1) {
+    if (!attempted[index]) continue;
+    const target = targets[index];
+    const entry = entries[index];
+    try {
+      const backupBytes = entry.existed ? await readFile(join3(journalDir, entry.backup)) : void 0;
+      input.emit({ type: "rollback", path: target.relativePath });
+      const outcome = rollbackOneSync(input.projectRoot, target, entry, placed[index], backupBytes);
+      if (outcome === "restored") restored.push(target.relativePath);
+      else removed.push(target.relativePath);
+    } catch (error) {
+      unrecovered.push({
+        path: target.relativePath,
+        recovery: entry.existed ? `Copy ${input.journalPath}/${entry.backup} back to ${target.relativePath} (${error.message})` : `Delete ${target.relativePath} if you did not create it yourself (${error.message})`
+      });
+    }
+  }
+  for (const dir of [...input.createdDirs].reverse()) {
+    try {
+      assertNoSymlinkEscape(input.projectRoot, dir);
+      const stat2 = lstatSync3(dir);
+      if (stat2.isDirectory() && !stat2.isSymbolicLink()) rmdirSync2(dir);
+    } catch {
+    }
+  }
+  if (unrecovered.length > 0) {
+    await input.writeJournal("rollback_failed", "rollback").catch(() => void 0);
+    return {
+      status: "rollback_failed",
+      ...input.failedPath ? { failedPath: input.failedPath } : {},
+      journalPath: input.journalPath,
+      restored,
+      removed,
+      unrecovered,
+      error: input.error
+    };
+  }
+  let cleanupWarning;
+  try {
+    await input.writeJournal("rolled_back", "done");
+  } catch (error) {
+    cleanupWarning = `Every file was restored, but ${input.journalPath} could not be marked rolled back (${error.message}).`;
+  }
+  try {
+    await rm(journalDir, { recursive: true, force: true });
+    removeWorkDirIfEmpty(input.projectRoot);
+  } catch (error) {
+    cleanupWarning = `Every file was restored, but ${input.journalPath} could not be removed (${error.message}); it may block the next install until you delete it.`;
+  }
+  return {
+    status: "rolled_back",
+    ...input.failedPath ? { failedPath: input.failedPath } : {},
+    restored,
+    removed,
+    error: input.error,
+    ...cleanupWarning ? { cleanupWarning } : {}
+  };
+}
+function identityOf(stat2) {
+  return { dev: stat2.dev, ino: stat2.ino };
+}
+function sameFile(a, b) {
+  return a.dev === b.dev && a.ino === b.ino;
+}
+function unsafe2(relativePath, why) {
+  return new WensityError("path_unsafe", `${relativePath} ${why}; it was not touched.`);
+}
+function rollbackOneSync(projectRoot, target, entry, placedFile, backupBytes) {
+  const { relativePath, absolutePath } = target;
+  if (!placedFile) return entry.existed ? "restored" : "removed";
+  assertNoSymlinkEscape(projectRoot, absolutePath);
+  const current = lstatOrUndefinedBig(absolutePath);
+  if (current && (current.isSymbolicLink() || !current.isFile())) throw unsafe2(relativePath, "was replaced by a symlink or non-file");
+  if (!current) throw unsafe2(relativePath, "was deleted after it was written");
+  if (!sameFile(identityOf(current), placedFile)) throw unsafe2(relativePath, "was replaced by another file after it was written");
+  if (!entry.existed) {
+    unlinkSync(absolutePath);
+    return "removed";
+  }
+  if (sha256(backupBytes) !== entry.sha256Before) throw new Error("the backup no longer matches its recorded hash; it was not written back");
+  const fd = openSync(absolutePath, fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = identityOf(fstatSync(fd, { bigint: true }));
+    assertNoSymlinkEscape(projectRoot, absolutePath);
+    const again = lstatOrUndefinedBig(absolutePath);
+    if (!sameFile(opened, placedFile) || !again || !sameFile(identityOf(again), placedFile)) {
+      throw unsafe2(relativePath, "moved while it was being restored");
+    }
+    ftruncateSync(fd, 0);
+    let offset = 0;
+    while (offset < backupBytes.length) offset += writeSync(fd, backupBytes, offset, backupBytes.length - offset, offset);
+    fsyncSync(fd);
+    if (entry.mode !== void 0) fchmodSync(fd, entry.mode);
+  } finally {
+    closeSync(fd);
+  }
+  return "restored";
+}
+function lstatOrUndefinedBig(path) {
+  try {
+    return lstatSync3(path, { bigint: true });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function place(staged, target, platform, hooks, emit, projectRoot) {
+  const stagedFile = identityOf(lstatSync3(staged, { bigint: true }));
+  const attempts = platform === "win32" && target.existed ? WINDOWS_PLACEMENT_ATTEMPTS : 1;
+  for (let attempt = 1; ; attempt += 1) {
+    emit({ type: "place", path: target.relativePath, attempt });
+    try {
+      if (hooks.rename) {
+        assertNoSymlinkEscape(projectRoot, target.absolutePath);
+        await hooks.rename(staged, target.absolutePath);
+      } else {
+        assertNoSymlinkEscape(projectRoot, target.absolutePath);
+        renameSync(staged, target.absolutePath);
+      }
+      break;
+    } catch (error) {
+      const retryable = isNodeError(error) && WINDOWS_RETRY_CODES.has(error.code ?? "");
+      if (!retryable || attempt >= attempts) throw error;
+      await new Promise((resolve3) => setTimeout(resolve3, 25 * 2 ** (attempt - 1)));
+    }
+  }
+  return stagedFile;
+}
+function assertPlaced(projectRoot, target, placedFile) {
+  assertNoSymlinkEscape(projectRoot, target.absolutePath);
+  const now = lstatOrUndefinedBig(target.absolutePath);
+  if (!now || now.isSymbolicLink() || !sameFile(identityOf(now), placedFile)) {
+    throw new WensityError("path_unsafe", `${target.relativePath} is not the file that was just written; the install is being rolled back.`);
+  }
+}
+async function makeParents(projectRoot, dir, created) {
+  const missing = [];
+  for (let current = dir; current !== projectRoot && !lstatOrUndefined2(current); current = dirname2(current)) {
+    missing.unshift(current);
+  }
+  for (const path of missing) {
+    await mkdir(path);
+    created.push(path);
+  }
+}
+async function writeSynced(path, data, mode, replace = false) {
+  if (replace) {
+    const temp = `${path}.next`;
+    await writeSynced(temp, data, mode);
+    await rename(temp, path);
+    return;
+  }
+  const handle = await open(path, "wx", mode);
+  try {
+    await handle.writeFile(data, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await chmod(path, mode);
+}
+async function syncDirectory(dir) {
+  try {
+    const handle = await open(dir, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch {
+  }
+}
+function lstatOrUndefined2(path) {
+  try {
+    return lstatSync3(path);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+
+// ../install-core/src/project.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, lstatSync as lstatSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join7, relative as relative6 } from "path";
+
+// ../install-core/src/config.ts
+import { existsSync as existsSync2, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
+import { access, mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, join as join5, posix as posix2, relative as relative5, resolve as resolve2 } from "path";
 
 // ../wensity-preset/src/constants.ts
 var ICON_LIBRARIES = ["tabler", "lucide"];
@@ -1498,6 +2367,7 @@ var TABLER_TO_LUCIDE = {
   IconChevronsRight: "ChevronsRight",
   IconCircleX: "CircleX",
   IconClock: "Clock",
+  IconColorPicker: "Pipette",
   IconCornerDownLeft: "CornerDownLeft",
   IconDots: "Ellipsis",
   IconDownload: "Download",
@@ -2593,99 +3463,31 @@ var BASE_SEMANTIC_THEME_UTILITIES = {
   "--color-surface-muted": "var(--surface-muted)",
   "--color-muted": "var(--muted)",
   "--color-muted-foreground": "var(--muted-foreground)",
-  "--color-border": "var(--border)",
-  "--color-border-strong": "var(--border-strong)"
-};
-var BASE_CSS_START = "/* \u2500\u2500 Wensity Base Tokens \u2014 generated by the Wensity CLI.\n      Edit these values to retheme your app; re-running `wensity init --preset`\n      replaces this block. \u2500\u2500 */";
-var BASE_CSS_END = "/* \u2500\u2500 End Wensity Base Tokens \u2500\u2500 */";
-function formatBaseDeclarations(entries, indent = "  ") {
-  return Object.entries(entries).map(([name, value]) => `${indent}${name}: ${value};`).join("\n");
-}
-function buildBaseCssBlock(baseColor = "inherit") {
-  return [
-    BASE_CSS_START,
-    "@theme inline {",
-    formatBaseDeclarations(BASE_SEMANTIC_THEME_UTILITIES),
-    "}",
-    ":root {",
-    formatBaseDeclarations(exportedBaseSemanticCssVars(baseColor, "light")),
-    "}",
-    ".dark {",
-    formatBaseDeclarations(exportedBaseSemanticCssVars(baseColor, "dark")),
-    "}",
-    BASE_CSS_END
-  ].join("\n");
-}
-
-// src/paths.ts
-import { dirname, isAbsolute, relative, resolve, sep } from "path";
-function normalizeUrlOrigin(input) {
-  const trimmed = input.trim().replace(/\/+$/, "");
-  const withProtocol = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
-  const url = new URL(withProtocol);
-  if (url.protocol !== "https:" && !isLocalHttpUrl(url)) {
-    throw new CliError("API URL must use HTTPS, except for localhost development URLs.");
-  }
-  return url.origin;
-}
-function isLocalHttpUrl(url) {
-  if (url.protocol !== "http:") return false;
-  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
-}
-function joinUrl(originOrUrl, path) {
-  const base = originOrUrl.endsWith("/") ? originOrUrl : `${originOrUrl}/`;
-  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-  return new URL(normalizedPath, base).toString();
-}
-function resolveInside(root, candidate) {
-  if (isAbsolute(candidate)) {
-    throw new Error(`Path must be project-relative: ${candidate}`);
-  }
-  const absolutePath = resolve(root, candidate);
-  const relativePath = relative(root, absolutePath);
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    throw new Error(`Path escapes the project: ${candidate}`);
-  }
-  return absolutePath;
-}
-function toPosixPath(input) {
-  return input.split(sep).join("/");
-}
-function parentDirectory(input) {
-  return dirname(input);
-}
-function stripKnownComponentPrefix(path) {
-  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "");
-  const prefixes = ["components/wensity/", "src/components/wensity/"];
-  const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
-  return prefix ? normalized.slice(prefix.length) : normalized;
-}
-function sanitizePayloadPath(path, fallbackFileName) {
-  const normalized = stripKnownComponentPrefix(path);
-  const parts = normalized.split("/").filter(Boolean);
-  if (parts.length === 0) return fallbackFileName;
-  for (const part of parts) {
-    if (part === "." || part === ".." || part.includes("\0")) {
-      throw new Error(`Unsafe registry file path: ${path}`);
-    }
-  }
-  const last = parts.at(-1) ?? fallbackFileName;
-  if (!/\.(tsx|ts|jsx|js)$/.test(last)) {
-    parts[parts.length - 1] = fallbackFileName;
-  }
-  return parts.join("/");
-}
-function componentFileName(slug) {
-  return `${slugToPascalCase(slug)}.tsx`;
-}
-function slugToPascalCase(slug) {
-  return slug.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+  "--color-border": "var(--border)",
+  "--color-border-strong": "var(--border-strong)"
+};
+var BASE_CSS_START = "/* \u2500\u2500 Wensity Base Tokens \u2014 generated by the Wensity CLI.\n      Edit these values to retheme your app; re-running `wensity init --preset`\n      replaces this block. \u2500\u2500 */";
+var BASE_CSS_END = "/* \u2500\u2500 End Wensity Base Tokens \u2500\u2500 */";
+function formatBaseDeclarations(entries, indent = "  ") {
+  return Object.entries(entries).map(([name, value]) => `${indent}${name}: ${value};`).join("\n");
 }
-function extensionlessPath(path) {
-  return path.replace(/\.(tsx|ts|jsx|js)$/, "");
+function buildBaseCssBlock(baseColor = "inherit") {
+  return [
+    BASE_CSS_START,
+    "@theme inline {",
+    formatBaseDeclarations(BASE_SEMANTIC_THEME_UTILITIES),
+    "}",
+    ":root {",
+    formatBaseDeclarations(exportedBaseSemanticCssVars(baseColor, "light")),
+    "}",
+    ".dark {",
+    formatBaseDeclarations(exportedBaseSemanticCssVars(baseColor, "dark")),
+    "}",
+    BASE_CSS_END
+  ].join("\n");
 }
 
-// src/style-shape.ts
+// ../install-core/src/style-shape.ts
 function isCanonicalStyleShape(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const record = value;
@@ -2720,11 +3522,159 @@ function curatedFontsFromStyle(style) {
   return { headingFont: "system", bodyFont: "system" };
 }
 
-// src/config.ts
-async function loadConfig(cwd, overrides = {}) {
-  const foundPath = await findUp(cwd, CONFIG_FILE_NAME);
-  const projectRoot = foundPath ? dirname2(foundPath) : cwd;
-  const configPath = foundPath ?? join2(projectRoot, CONFIG_FILE_NAME);
+// ../install-core/src/tsconfig-paths.ts
+import { existsSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join4, posix, relative as relative4 } from "path";
+var MAX_CONFIG_HOPS = 8;
+var CONFIG_DIR = "${configDir}";
+function containedFile(projectRoot, relativePath) {
+  let absolute;
+  try {
+    absolute = resolveInside(projectRoot, relativePath);
+    assertNoSymlinkEscape(projectRoot, absolute);
+  } catch {
+    return void 0;
+  }
+  return existsSync(absolute) ? absolute : void 0;
+}
+function readPathMapping(projectRoot) {
+  for (const file of ["tsconfig.json", "jsconfig.json"]) {
+    if (!containedFile(projectRoot, file)) continue;
+    const root = parseConfig(projectRoot, file);
+    const own = resolveConfig(projectRoot, file, 0);
+    if (!root || own === UNKNOWN) return void 0;
+    if (own.paths) return toMapping(own, posix.dirname(file));
+    let unresolvedReference = false;
+    for (const reference of root.references ?? []) {
+      if (typeof reference.path !== "string") continue;
+      const referenced = referencePath(projectRoot, posix.join(posix.dirname(file), reference.path));
+      const resolved = referenced ? resolveConfig(projectRoot, referenced, 0) : UNKNOWN;
+      if (resolved === UNKNOWN) unresolvedReference = true;
+      else if (resolved.paths) return toMapping(resolved, posix.dirname(referenced));
+    }
+    return unresolvedReference ? void 0 : toMapping(own, posix.dirname(file));
+  }
+  return void 0;
+}
+function aliasResolvesTo(mapping, alias, target) {
+  const wanted = posix.normalize(stripExtension(target));
+  for (const [key, values] of Object.entries(mapping.paths)) {
+    const wildcard = key.endsWith("/*");
+    const prefix = wildcard ? key.slice(0, -1) : key;
+    if (wildcard ? !alias.startsWith(prefix) : alias !== key) continue;
+    const rest = wildcard ? alias.slice(prefix.length) : "";
+    for (const value of values) {
+      const targetBase = value.endsWith("/*") ? value.slice(0, -1) : value;
+      const candidate = posix.normalize(posix.join(mapping.base, targetBase, rest));
+      if (stripExtension(candidate) === wanted) return true;
+    }
+  }
+  return false;
+}
+function atAliasRoot(mapping) {
+  const target = mapping?.paths["@/*"]?.find((value) => value.endsWith("/*"));
+  if (target === void 0) return void 0;
+  const dir = posix.normalize(posix.join(mapping.base, target.slice(0, -2)));
+  if (dir === ".." || dir.startsWith("../") || posix.isAbsolute(dir)) return void 0;
+  if (dir === "node_modules" || dir.startsWith("node_modules/")) return void 0;
+  return dir === "." ? "" : dir;
+}
+var UNKNOWN = /* @__PURE__ */ Symbol("unknown");
+function resolveConfig(projectRoot, file, hops) {
+  const parsed = parseConfig(projectRoot, file);
+  if (!parsed || hops > MAX_CONFIG_HOPS) return UNKNOWN;
+  const dir = posix.dirname(file);
+  const options = parsed.compilerOptions ?? {};
+  let resolved = {};
+  const parents = typeof parsed.extends === "string" ? [parsed.extends] : parsed.extends ?? [];
+  for (const parent of parents) {
+    if (typeof parent !== "string") return UNKNOWN;
+    const parentFile = extendsTarget(projectRoot, dir, parent);
+    const inherited = parentFile ? resolveConfig(projectRoot, parentFile, hops + 1) : UNKNOWN;
+    if (inherited === UNKNOWN) return UNKNOWN;
+    resolved = {
+      baseUrl: inherited.baseUrl ?? resolved.baseUrl,
+      paths: inherited.paths ?? resolved.paths
+    };
+  }
+  if (options.baseUrl !== void 0) {
+    resolved.baseUrl = options.baseUrl.startsWith(CONFIG_DIR) ? options.baseUrl : posix.normalize(posix.join(dir, options.baseUrl));
+  }
+  if (options.paths) resolved.paths = { map: options.paths, dir };
+  return resolved;
+}
+function toMapping(resolved, configDir) {
+  const expand = (value) => posix.normalize(posix.join(configDir, value.slice(CONFIG_DIR.length)));
+  const baseUrl = resolved.baseUrl?.startsWith(CONFIG_DIR) ? expand(resolved.baseUrl) : resolved.baseUrl;
+  if (!resolved.paths) return { base: baseUrl ?? ".", paths: {} };
+  const base = baseUrl ?? resolved.paths.dir;
+  const rebase = (value) => {
+    if (!value.startsWith(CONFIG_DIR)) return value;
+    const wildcard = value.endsWith("/*");
+    const target = expand(wildcard ? value.slice(0, -2) : value);
+    const rel = posix.relative(base, target) || ".";
+    return wildcard ? `${rel}/*` : rel;
+  };
+  const paths = Object.fromEntries(Object.entries(resolved.paths.map).map(([key, values]) => [key, values.map(rebase)]));
+  return { base, paths };
+}
+function extendsTarget(projectRoot, fromDir, specifier) {
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    return configFile(projectRoot, posix.join(fromDir, specifier));
+  }
+  if (posix.isAbsolute(specifier) || /^[A-Za-z]:[\\/]/.test(specifier)) return void 0;
+  const inPackage = posix.join("node_modules", specifier);
+  const direct = configFile(projectRoot, inPackage);
+  if (direct) return direct;
+  const manifest = containedFile(projectRoot, posix.join(inPackage, "package.json"));
+  if (manifest) {
+    try {
+      const field = JSON.parse(readFileSync2(manifest, "utf8")).tsconfig;
+      if (typeof field === "string") {
+        const fromField = configFile(projectRoot, posix.join(inPackage, field));
+        if (fromField) return fromField;
+      }
+    } catch {
+    }
+  }
+  return configFile(projectRoot, posix.join(inPackage, "tsconfig.json"));
+}
+function parseConfig(projectRoot, file) {
+  const path = containedFile(projectRoot, file);
+  if (!path) return void 0;
+  try {
+    return JSON.parse(stripJsonComments(readFileSync2(path, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function configFile(projectRoot, path) {
+  const normalized = posix.normalize(path);
+  for (const candidate of [normalized, `${normalized}.json`]) {
+    const absolute = containedFile(projectRoot, candidate);
+    if (absolute && statSync(absolute).isFile()) return toPosixPath(relative4(projectRoot, absolute));
+  }
+  return void 0;
+}
+function referencePath(projectRoot, path) {
+  const absolute = containedFile(projectRoot, path);
+  if (!absolute) return void 0;
+  const file = statSync(absolute).isDirectory() ? join4(absolute, "tsconfig.json") : absolute;
+  const relativeFile = toPosixPath(relative4(projectRoot, file));
+  return containedFile(projectRoot, relativeFile) ? relativeFile : void 0;
+}
+function stripJsonComments(text) {
+  return text.replace(/("(?:\\.|[^"\\])*")|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, (match, string) => string ?? "").replace(/,(\s*[}\]])/g, "$1");
+}
+function stripExtension(path) {
+  return path.replace(/\.(tsx|ts|jsx|js)$/, "");
+}
+
+// ../install-core/src/config.ts
+async function loadConfig(cwd, overrides = {}, options = {}) {
+  const { projectRoot, configPath: foundPath } = await locateProject(cwd, options.home);
+  const configPath = foundPath ?? join5(projectRoot, CONFIG_FILE_NAME);
+  if (foundPath && options.rejectEscapingSymlink) assertNoSymlinkEscape(projectRoot, foundPath);
   const defaults = createDefaultConfig(projectRoot, overrides.apiUrl ?? DEFAULT_API_ORIGIN);
   if (!foundPath) {
     return {
@@ -2735,7 +3685,7 @@ async function loadConfig(cwd, overrides = {}) {
     };
   }
   try {
-    const parsed = JSON.parse(await readFile(foundPath, "utf8"));
+    const parsed = JSON.parse(await readFile2(foundPath, "utf8"));
     return {
       config: normalizeConfig(
         {
@@ -2757,22 +3707,23 @@ async function loadConfig(cwd, overrides = {}) {
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
-      throw new CliError(`${CONFIG_FILE_NAME} contains invalid JSON.`);
+      throw new WensityError("config_invalid", `${CONFIG_FILE_NAME} contains invalid JSON.`);
     }
     if (error instanceof PresetValidationError) {
-      throw new CliError(`${CONFIG_FILE_NAME}: ${error.message}`);
+      throw new WensityError("config_invalid", `${CONFIG_FILE_NAME}: ${error.message}`);
     }
     throw error;
   }
 }
 function createDefaultConfig(projectRoot, apiUrl = DEFAULT_API_ORIGIN) {
   const apiOrigin = normalizeUrlOrigin(apiUrl);
+  const sourceRoot = defaultSourceRoot(projectRoot);
   return {
     $schema: joinUrl(apiOrigin, "/schema/wensity.json"),
     version: CONFIG_SCHEMA_VERSION,
     registry: joinUrl(apiOrigin, DEFAULT_REGISTRY_PATH),
-    components: DEFAULT_COMPONENTS_DIR,
-    utils: DEFAULT_UTILS_PATH,
+    components: posix2.join(sourceRoot, "components/wensity"),
+    utils: posix2.join(sourceRoot, "lib/utils"),
     tailwind: {
       config: detectTailwindConfig(projectRoot),
       css: detectGlobalCss(projectRoot)
@@ -2786,20 +3737,21 @@ function createDefaultConfig(projectRoot, apiUrl = DEFAULT_API_ORIGIN) {
 }
 async function writeConfigFile(path, config, force) {
   if (!force && await fileExists(path)) {
-    throw new CliError(`${toPosixPath(relative2(process.cwd(), path))} already exists. Use --force to overwrite it.`);
+    throw new WensityError("file_conflict", `${toPosixPath(relative5(process.cwd(), path))} already exists. Use --force to overwrite it.`);
   }
-  await mkdir(dirname2(path), { recursive: true });
+  await mkdir2(dirname3(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function mergeStyleIntoConfigFile(configPath, style) {
-  const raw = JSON.parse(await readFile(configPath, "utf8"));
+  const raw = JSON.parse(await readFile2(configPath, "utf8"));
+  const defaults = raw.components && raw.utils ? void 0 : createDefaultConfig(dirname3(configPath));
   const merged = {
     ...raw,
     version: raw.version ?? CONFIG_SCHEMA_VERSION,
     registry: raw.registry ?? "",
-    components: raw.components ?? DEFAULT_COMPONENTS_DIR,
-    utils: raw.utils ?? DEFAULT_UTILS_PATH,
+    components: raw.components ?? defaults?.components ?? DEFAULT_COMPONENTS_DIR,
+    utils: raw.utils ?? defaults?.utils ?? DEFAULT_UTILS_PATH,
     aliases: {
       components: raw.aliases?.components ?? DEFAULT_COMPONENTS_ALIAS,
       utils: raw.aliases?.utils ?? DEFAULT_UTILS_ALIAS
@@ -2817,7 +3769,7 @@ function resolveConfiguredFilePath(projectRoot, relativePath, extension = "ts")
     return resolveInside(projectRoot, withExtension(relativePath, extension));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new CliError(message);
+    throw new WensityError("path_unsafe", message);
   }
 }
 async function fileExists(path) {
@@ -2829,16 +3781,52 @@ async function fileExists(path) {
     throw error;
   }
 }
-async function findUp(start, fileName) {
-  let current = start;
+function assertProjectRootCandidate(path, home = homedir()) {
+  const resolved = resolve2(path);
+  if (isFilesystemRoot(resolved)) {
+    throw new WensityError(
+      "project_ambiguous",
+      `${resolved} is a filesystem root, not a project. Run Wensity from your project directory (the one with package.json).`
+    );
+  }
+  if (isHomeDirectory(resolved, home)) {
+    throw new WensityError(
+      "project_ambiguous",
+      "Your home directory is not a project. Run Wensity from your project directory (the one with package.json)."
+    );
+  }
+}
+async function locateProject(start, home = homedir()) {
+  assertProjectRootCandidate(start, home);
+  const origin = resolve2(start);
+  let current = origin;
   while (true) {
-    const candidate = join2(current, fileName);
-    if (await fileExists(candidate)) return candidate;
-    const parent = dirname2(current);
-    if (parent === current) return void 0;
+    const candidate = join5(current, CONFIG_FILE_NAME);
+    if (await fileExists(candidate)) return { projectRoot: current, configPath: candidate };
+    if (await fileExists(join5(current, "package.json"))) return { projectRoot: current, configPath: void 0 };
+    const parent = dirname3(current);
+    if (isFilesystemRoot(parent) || isHomeDirectory(parent, home)) return { projectRoot: origin, configPath: void 0 };
     current = parent;
   }
 }
+function isFilesystemRoot(path) {
+  return dirname3(path) === path;
+}
+function isHomeDirectory(path, home) {
+  if (!home) return false;
+  if (resolve2(path) === resolve2(home)) return true;
+  try {
+    return realpathSync3(path) === realpathSync3(home);
+  } catch {
+    return false;
+  }
+}
+function defaultSourceRoot(projectRoot) {
+  const fromAlias = atAliasRoot(readPathMapping(projectRoot));
+  if (fromAlias !== void 0) return fromAlias;
+  const src = join5(projectRoot, "src");
+  return existsSync2(src) && statSync2(src).isDirectory() ? "src" : "";
+}
 function normalizeConfig(config, overrides) {
   const apiOrigin = overrides.apiUrl ? normalizeUrlOrigin(overrides.apiUrl) : void 0;
   try {
@@ -2858,14 +3846,14 @@ function normalizeConfig(config, overrides) {
     };
   } catch (error) {
     if (error instanceof PresetValidationError) {
-      throw new CliError(`${CONFIG_FILE_NAME}: ${error.message}`);
+      throw new WensityError("config_invalid", `${CONFIG_FILE_NAME}: ${error.message}`);
     }
     throw error;
   }
 }
 function detectTailwindConfig(projectRoot) {
   const candidates = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
-  return candidates.find((candidate) => existsSync(join2(projectRoot, candidate))) ?? "tailwind.config.ts";
+  return candidates.find((candidate) => existsSync2(join5(projectRoot, candidate))) ?? "tailwind.config.ts";
 }
 function detectGlobalCss(projectRoot) {
   const candidates = [
@@ -2875,230 +3863,356 @@ function detectGlobalCss(projectRoot) {
     "src/index.css",
     "styles/globals.css"
   ];
-  return candidates.find((candidate) => existsSync(join2(projectRoot, candidate))) ?? "src/app/globals.css";
+  return candidates.find((candidate) => existsSync2(join5(projectRoot, candidate))) ?? "src/app/globals.css";
 }
 function withExtension(path, extension) {
   if (/\.(ts|tsx|js|jsx)$/.test(path)) return path;
   return `${path}.${extension}`;
 }
 
-// src/credentials.ts
-import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2, chmod } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
-import { randomUUID } from "crypto";
-import { stdin, stdout } from "process";
-function credentialsPath(env) {
-  if (env.WENSITY_CREDENTIALS_FILE) return env.WENSITY_CREDENTIALS_FILE;
-  const configHome = env.WENSITY_CONFIG_HOME ?? env.XDG_CONFIG_HOME ?? join3(requiredHome(env), ".config");
-  return join3(configHome, "wensity", "credentials.json");
+// ../install-core/src/package-manager.ts
+import { accessSync, constants as fsConstants2, existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3, writeFileSync } from "fs";
+import { spawn, spawnSync } from "child_process";
+import { join as join6, posix as posix3, win32 } from "path";
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function parsePackageManager(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (isPackageManager(normalized)) return normalized;
+  throw new WensityError(
+    "unsupported_package_manager",
+    `Unsupported package manager "${value}". Use one of: ${PACKAGE_MANAGERS.join(", ")}.`
+  );
 }
-async function readCredentials(env) {
-  const path = credentialsPath(env);
-  try {
-    const content = await readFile2(path, "utf8");
-    const parsed = JSON.parse(content);
-    if (parsed.version !== 1 || !parsed.token || !parsed.apiBaseUrl) {
-      throw new CliError(`Credentials at ${path} are not valid. Run wensity login again.`);
-    }
-    return parsed;
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") return void 0;
-    if (error instanceof SyntaxError) {
-      throw new CliError(`Credentials at ${path} are not valid JSON. Run wensity login again.`);
-    }
-    throw error;
-  }
+function packageManagerFromUserAgent(env = process.env) {
+  const agent = env.npm_config_user_agent;
+  if (!agent) return void 0;
+  const first = agent.trim().split(/\s+/)[0] ?? "";
+  const name = first.split("/")[0]?.toLowerCase();
+  return name && isPackageManager(name) ? name : void 0;
 }
-async function writeCredentials(env, credentials) {
-  const path = credentialsPath(env);
-  const directory = dirname3(path);
-  const temporaryPath = join3(directory, `.credentials.${randomUUID()}.tmp`);
-  await mkdir2(directory, { recursive: true, mode: 448 });
-  await writeFile2(temporaryPath, `${JSON.stringify(credentials, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-  await rename(temporaryPath, path);
-  await chmod(path, 384);
-  return path;
+function detectPackageManager(projectRoot, env = process.env) {
+  if (existsSync3(join6(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join6(projectRoot, "bun.lockb")) || existsSync3(join6(projectRoot, "bun.lock"))) return "bun";
+  if (existsSync3(join6(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync3(join6(projectRoot, "package-lock.json"))) return "npm";
+  return packageManagerFromUserAgent(env) ?? "npm";
 }
-async function deleteCredentials(env) {
-  const path = credentialsPath(env);
-  try {
-    await rm(path, { force: false });
-    return true;
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") return false;
-    throw error;
-  }
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
 }
-async function readTokenInteractively(prompt = "Wensity API token: ") {
-  if (!stdin.isTTY) {
-    const chunks = [];
-    for await (const chunk of stdin) {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString("utf8").trim();
+function missingDependencies(projectRoot, dependencies) {
+  const installed = readInstalledPackageNames(projectRoot);
+  if (!installed) return dependencies;
+  return dependencies.filter((dependency) => !installed.has(dependency));
+}
+function readInstalledPackageNames(projectRoot) {
+  const packageJsonPath = join6(projectRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) return void 0;
+  const packageJson2 = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+  return new Set(
+    Object.keys({
+      ...packageJson2.dependencies,
+      ...packageJson2.devDependencies,
+      ...packageJson2.peerDependencies,
+      ...packageJson2.optionalDependencies
+    })
+  );
+}
+var YARN_CONFIG_FILE = ".yarnrc.yml";
+function prepareProjectPackageManager(projectRoot, options = {}) {
+  if (resolvePackageManager(projectRoot, options) !== "yarn") return [];
+  const configPath = join6(projectRoot, YARN_CONFIG_FILE);
+  if (existsSync3(configPath)) return [];
+  if (!options.dryRun) writeFileSync(configPath, "nodeLinker: node-modules\n", "utf8");
+  return [YARN_CONFIG_FILE];
+}
+async function runProjectInstall(projectRoot, options = {}) {
+  const packageJsonPath = join6(projectRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) return;
+  const packageManager = resolvePackageManager(projectRoot, options);
+  await runPackageManager(projectRoot, packageManager, ["install"], options);
+}
+function resolvePackageManager(projectRoot, options = {}) {
+  return options.packageManager ?? detectPackageManager(projectRoot, options.env);
+}
+async function runInstall(projectRoot, dependencies, options = {}) {
+  if (dependencies.length === 0) return;
+  const packageJsonPath = join6(projectRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    (options.onWarning ?? writeWarning)(
+      `No package.json found. Install these dependencies manually: ${dependencies.join(" ")}`
+    );
+    return;
   }
-  return new Promise((resolveToken, rejectToken) => {
-    const input = stdin;
-    const previousRawMode = input.isRaw;
-    let token = "";
-    function cleanup() {
-      input.off("data", onData);
-      if (typeof previousRawMode === "boolean") {
-        input.setRawMode(previousRawMode);
-      }
-      input.pause();
-    }
-    function onData(chunk) {
-      const value = chunk.toString("utf8");
-      if (value === "") {
-        cleanup();
-        stdout.write("\n");
-        rejectToken(new CliError("Login cancelled.", 130));
-        return;
-      }
-      if (value === "\r" || value === "\n" || value === "\r\n") {
-        cleanup();
-        stdout.write("\n");
-        resolveToken(token.trim());
-        return;
-      }
-      if (value === "\x7F") {
-        token = token.slice(0, -1);
-        return;
-      }
-      token += value;
-    }
-    stdout.write(prompt);
-    input.setRawMode(true);
-    input.resume();
-    input.on("data", onData);
-  });
+  const packageManager = resolvePackageManager(projectRoot, options);
+  await runPackageManager(projectRoot, packageManager, installArgs(packageManager, dependencies), options);
 }
-function requiredHome(env) {
-  if (env.HOME) return env.HOME;
-  throw new CliError("HOME is not set, so the CLI cannot locate ~/.config/wensity.");
+async function runPackageManager(projectRoot, packageManager, args, options) {
+  const outcome = await runPackageManagerCommand(projectRoot, packageManager, args, {
+    output: "inherit",
+    forwardSignals: true,
+    ...options.spawnImpl ? { spawnImpl: options.spawnImpl } : {}
+  });
+  throwForFailure(packageManager, args, outcome);
 }
-
-// src/font-install.ts
-var FONT_CSS_START_MARKER = "/* \u2500\u2500 Wensity Fonts";
-var FONT_CSS_END_MARKER = "/* \u2500\u2500 End Wensity Fonts \u2500\u2500 */";
-function planFontInstall(headingFont, bodyFont) {
-  const packages = [];
-  const importLines = [];
-  const seenPackages = /* @__PURE__ */ new Set();
-  const seenImports = /* @__PURE__ */ new Set();
-  const pushFont = (meta) => {
-    if (!meta) return;
-    if (!seenPackages.has(meta.packageName)) {
-      seenPackages.add(meta.packageName);
-      packages.push(meta.packageName);
-    }
-    for (const specifier of curatedFontCssImportSpecifiers(meta)) {
-      const line = `@import "${specifier}";`;
-      if (!seenImports.has(line)) {
-        seenImports.add(line);
-        importLines.push(line);
-      }
-    }
-  };
-  if (headingFont !== "system") {
-    pushFont(HEADING_FONT_PACKAGES[headingFont]);
+function throwForFailure(packageManager, args, outcome) {
+  if (outcome.spawnError) {
+    throw new WensityError("dependency_install_failed", `Could not run ${packageManager}: ${outcome.spawnError}`);
   }
-  if (bodyFont !== "system") {
-    pushFont(BODY_FONT_PACKAGES[bodyFont]);
+  if (outcome.timedOut) {
+    throw new WensityError(
+      "dependency_install_failed",
+      `${packageManager} ${args.join(" ")} did not finish within ${PACKAGE_MANAGER_TIMEOUT_MS / 1e3} s and was stopped.`
+    );
   }
-  packages.sort();
-  if (importLines.length === 0) {
-    return { packages: [], importLines: [], block: null };
+  if (outcome.exitCode !== 0) {
+    throw new WensityError("dependency_install_failed", `${packageManager} ${args.join(" ")} failed with exit code ${outcome.exitCode ?? 1}.`);
   }
-  const block = [
-    `${FONT_CSS_START_MARKER} \u2500\u2500 */`,
-    ...importLines,
-    FONT_CSS_END_MARKER
-  ].join("\n");
-  return { packages, importLines, block };
 }
-function upsertFontImportBlock(existingCss, block) {
-  const start = existingCss.indexOf(FONT_CSS_START_MARKER);
-  const end = existingCss.indexOf(FONT_CSS_END_MARKER);
-  if (start !== -1 || end !== -1) {
-    if (start === -1 || end === -1 || end <= start) {
-      throw new CliError(
-        "Configured Tailwind CSS has a partial Wensity Fonts block. Remove the broken markers and re-run install."
-      );
-    }
-    const before2 = existingCss.slice(0, start).replace(/\s*$/, "");
-    const after2 = existingCss.slice(end + FONT_CSS_END_MARKER.length).replace(/^\s*/, "");
-    if (!block) {
-      const joined = [before2, after2].filter((part) => part.length > 0).join("\n\n");
-      return joined ? `${joined.replace(/\n{3,}/g, "\n\n")}
-` : "";
+var PACKAGE_MANAGER_TIMEOUT_MS = 18e4;
+var PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["add", "install"]);
+var WINDOWS_UNSAFE = /["%!^&|<>()\r\n\t\u0000-\u001f\u007f]/;
+function assertValidPackageName(name) {
+  if (typeof name !== "string" || name.length > 214 || !PACKAGE_NAME.test(name) || /(^|\/|^@)[-._]/.test(name)) {
+    throw new WensityError("dependency_install_failed", `Refusing to install an invalid package name: ${JSON.stringify(String(name).slice(0, 80))}`);
+  }
+}
+var WINDOWS_JS_ENTRIES = {
+  npm: ["node_modules/npm/bin/npm-cli.js"],
+  pnpm: ["node_modules/pnpm/bin/pnpm.cjs", "node_modules/pnpm/bin/pnpm.mjs"],
+  yarn: ["node_modules/yarn/bin/yarn.js"],
+  bun: []
+};
+function buildPackageManagerInvocation(packageManager, args, options = {}) {
+  if (!PACKAGE_MANAGERS.includes(packageManager)) parsePackageManager(packageManager);
+  const [subcommand, ...names] = args;
+  if (!subcommand || !SUBCOMMANDS.has(subcommand)) {
+    throw new WensityError("dependency_install_failed", `Refusing to run ${packageManager} with an unexpected subcommand.`);
+  }
+  for (const name of names) assertValidPackageName(name);
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const display = [packageManager, ...args].join(" ");
+  const isFile = options.isFile ?? defaultIsFile;
+  if (platform !== "win32") {
+    const isExecutable = options.isExecutable ?? defaultIsExecutable;
+    const dirs = (env.PATH ?? "").split(posix3.delimiter).filter(Boolean);
+    const resolved = dirs.map((dir) => posix3.join(dir, packageManager)).find(isExecutable);
+    if (!resolved) throw notFound(packageManager);
+    return { shape: "posix", command: resolved, args, windowsVerbatimArguments: false, display };
+  }
+  const pathValue = env.PATH ?? env.Path ?? Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+  const extensions = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.toLowerCase()).filter(Boolean);
+  for (const dir of pathValue.split(win32.delimiter).filter(Boolean)) {
+    for (const extension of extensions) {
+      const candidate = win32.join(dir, `${packageManager}${extension}`);
+      if (!isFile(candidate)) continue;
+      if (extension === ".exe" || extension === ".com") {
+        return { shape: "windows-exe", command: candidate, args, windowsVerbatimArguments: false, display };
+      }
+      if (extension !== ".cmd" && extension !== ".bat") continue;
+      const entry = WINDOWS_JS_ENTRIES[packageManager].map((relative9) => win32.join(dir, relative9)).find(isFile);
+      if (entry) {
+        return { shape: "windows-node", command: options.nodePath ?? process.execPath, args: [entry, ...args], windowsVerbatimArguments: false, display };
+      }
+      const cmd = resolveCmdExe(env);
+      return {
+        shape: "windows-cmd",
+        command: cmd,
+        args: ["/d", "/s", "/c", `"${quoteWindowsCommandLine([candidate, ...args])}"`],
+        windowsVerbatimArguments: true,
+        display
+      };
     }
-    const normalizedBlock2 = block.trim();
-    const prefix2 = before2 ? `${before2}
-
-` : "";
-    const suffix2 = after2 ? `
-
-${after2}` : "\n";
-    return `${prefix2}${normalizedBlock2}${suffix2}`.replace(/\n{3,}/g, "\n\n");
   }
-  if (!block) return existingCss;
-  const normalizedBlock = block.trim();
-  const insertAt = findFontBlockInsertIndex(existingCss);
-  const before = existingCss.slice(0, insertAt).replace(/\s*$/, "");
-  const after = existingCss.slice(insertAt).replace(/^\s*/, "");
-  const prefix = before ? `${before}
-
-` : "";
-  const suffix = after ? `
-
-${after}` : "\n";
-  return `${prefix}${normalizedBlock}${suffix}`.replace(/\n{3,}/g, "\n\n");
+  throw notFound(packageManager);
 }
-function warnUnusedFontPackageMessage(headingFont, bodyFont, installedPackages) {
-  const needed = new Set(planFontInstall(headingFont, bodyFont).packages);
-  const curated = [
-    ...Object.values(HEADING_FONT_PACKAGES).map((entry) => entry.packageName),
-    ...Object.values(BODY_FONT_PACKAGES).map((entry) => entry.packageName)
-  ];
-  const leftover = curated.filter(
-    (pkg) => installedPackages.has(pkg) && !needed.has(pkg)
-  );
-  if (leftover.length === 0) return void 0;
-  return `Project package.json still lists ${leftover.join(", ")} while curated fonts are set to heading="${headingFont}" body="${bodyFont}". Wensity removed the @import for unused fonts but will not uninstall ${leftover.join(", ")} (it may be used outside Wensity).`;
+function quoteWindowsCommandLine(values) {
+  return values.map((value) => {
+    if (value.length === 0 || WINDOWS_UNSAFE.test(value)) {
+      throw new WensityError("dependency_install_failed", `Refusing to build a command line from an unsafe value: ${JSON.stringify(value.slice(0, 80))}`);
+    }
+    return /\s/.test(value) ? `"${value}"` : value;
+  }).join(" ");
 }
-function findFontBlockInsertIndex(css) {
-  let index = 0;
-  const length = css.length;
-  while (index < length) {
-    while (index < length && /\s/.test(css[index])) index += 1;
-    if (index >= length) break;
-    if (css.startsWith("/*", index)) {
-      const end = css.indexOf("*/", index + 2);
-      if (end === -1) break;
-      index = end + 2;
-      continue;
+function resolveCmdExe(env) {
+  const fromEnv = env.ComSpec ?? env.COMSPEC;
+  if (fromEnv && win32.isAbsolute(fromEnv) && win32.basename(fromEnv).toLowerCase() === "cmd.exe" && !WINDOWS_UNSAFE.test(fromEnv)) {
+    return fromEnv;
+  }
+  const systemRoot = env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows";
+  if (!win32.isAbsolute(systemRoot) || WINDOWS_UNSAFE.test(systemRoot)) {
+    throw new WensityError("dependency_install_failed", "Could not locate cmd.exe safely.");
+  }
+  return win32.join(systemRoot, "System32", "cmd.exe");
+}
+function notFound(packageManager) {
+  return new WensityError("dependency_install_failed", `Could not run ${packageManager}: it was not found on PATH.`);
+}
+function defaultIsExecutable(path) {
+  try {
+    accessSync(path, fsConstants2.X_OK);
+    return statSync3(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultIsFile(path) {
+  try {
+    return statSync3(path).isFile();
+  } catch {
+    return false;
+  }
+}
+var OUTPUT_KEEP = 256 * 1024;
+var TREE_EXIT_WAIT_MS = 5e3;
+function runPackageManagerCommand(projectRoot, packageManager, args, options = {}) {
+  const invocation = buildPackageManagerInvocation(packageManager, args, options);
+  const platform = options.platform ?? process.platform;
+  const inherit = options.output === "inherit";
+  const ownGroup = !inherit && platform !== "win32";
+  const timeoutMs = options.timeoutMs ?? (inherit ? void 0 : PACKAGE_MANAGER_TIMEOUT_MS);
+  const started = Date.now();
+  return new Promise((resolve3) => {
+    let stdout2 = "";
+    let stderr = "";
+    let timedOut = false;
+    const child = (options.spawnImpl ?? spawn)(invocation.command, invocation.args, {
+      cwd: projectRoot,
+      env: options.spawnEnv ?? process.env,
+      shell: false,
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+      detached: ownGroup
+    });
+    const killTree = () => killProcessTree(child.pid, platform, options.env ?? process.env, spawnSync, ownGroup);
+    const signalHandlers = [];
+    if (options.forwardSignals) {
+      for (const signal of ["SIGINT", "SIGTERM"]) {
+        const handler = () => {
+          killTree();
+          removeSignalHandlers();
+          process.kill(process.pid, signal);
+        };
+        signalHandlers.push([signal, handler]);
+        process.once(signal, handler);
+      }
     }
-    if (css.startsWith("//", index)) {
-      const end = css.indexOf("\n", index);
-      if (end === -1) return length;
-      index = end + 1;
-      continue;
+    const removeSignalHandlers = () => {
+      for (const [signal, handler] of signalHandlers.splice(0)) process.removeListener(signal, handler);
+    };
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      timedOut = true;
+      killTree();
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout2 = (stdout2 + chunk.toString("utf8")).slice(-OUTPUT_KEEP);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = (stderr + chunk.toString("utf8")).slice(-OUTPUT_KEEP);
+    });
+    let settled = false;
+    const finish = async (exitCode, spawnError) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (ownGroup && child.pid !== void 0 && groupAlive(child.pid)) {
+        killTree();
+        await waitForGroupExit(child.pid);
+      }
+      removeSignalHandlers();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve3({ invocation, exitCode, stdout: stdout2, stderr, durationMs: Date.now() - started, timedOut, ...spawnError ? { spawnError } : {} });
+    };
+    child.on("error", (error) => void finish(null, error.message));
+    child.on("exit", (code) => void finish(code));
+  });
+}
+function killProcessTree(pid, platform, env, run2 = spawnSync, ownGroup = true) {
+  if (pid === void 0) return;
+  try {
+    if (platform !== "win32" && !ownGroup) {
+      for (const member of [...descendantsOf(pid, run2).reverse(), pid]) {
+        try {
+          process.kill(member, "SIGKILL");
+        } catch {
+        }
+      }
+      return;
     }
-    if (css.startsWith("@charset", index) || css.startsWith("@import", index)) {
-      const end = css.indexOf(";", index);
-      if (end === -1) break;
-      index = end + 1;
-      continue;
+    if (platform === "win32") {
+      const systemRoot = env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows";
+      run2(win32.join(systemRoot, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], { shell: false, stdio: "ignore", windowsHide: true });
+    } else {
+      process.kill(-pid, "SIGKILL");
     }
-    break;
+  } catch {
   }
-  return index;
+}
+function descendantsOf(pid, run2) {
+  const listing = run2("ps", ["-A", "-o", "pid=,ppid="], { shell: false, encoding: "utf8" });
+  const children = /* @__PURE__ */ new Map();
+  for (const line of String(listing.stdout ?? "").split("\n")) {
+    const [child, parent] = line.trim().split(/\s+/).map(Number);
+    if (!child || !parent) continue;
+    children.set(parent, [...children.get(parent) ?? [], child]);
+  }
+  const found = [];
+  const queue = [...children.get(pid) ?? []];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    found.push(next);
+    queue.push(...children.get(next) ?? []);
+  }
+  return found;
+}
+function groupAlive(pid) {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function waitForGroupExit(pid) {
+  const deadline = Date.now() + TREE_EXIT_WAIT_MS;
+  while (groupAlive(pid) && Date.now() < deadline) {
+    await new Promise((resolve3) => setTimeout(resolve3, 20));
+  }
+}
+function installArgs(packageManager, dependencies) {
+  switch (packageManager) {
+    case "pnpm":
+      return ["add", ...dependencies];
+    case "yarn":
+      return ["add", ...dependencies];
+    case "bun":
+      return ["add", ...dependencies];
+    case "npm":
+      return ["install", ...dependencies];
+  }
+}
+function writeWarning(message) {
+  process.stderr.write(`Warning: ${message}
+`);
+}
+
+// ../install-core/src/project.ts
+var IMPORT_ALIAS_REMEDY = 'Add a compilerOptions.paths entry such as "@/*": ["./*"] (or ["./src/*"]) to tsconfig.json, or set components, utils and aliases in wensity.json so each alias maps to its folder.';
+function importAliasesResolve(projectRoot, config) {
+  const mapping = readPathMapping(projectRoot);
+  if (!mapping) return null;
+  return aliasResolvesTo(mapping, config.aliases.components, config.components) && aliasResolvesTo(mapping, config.aliases.utils, config.utils);
+}
+function importAliasMismatchMessage(config) {
+  return `Installed files would import ${config.aliases.components} and ${config.aliases.utils}, but the tsconfig/jsconfig paths do not map them to ${config.components} and ${config.utils}, so the imports would not resolve.`;
+}
+function importAliasBlockMessage(config) {
+  return `${importAliasMismatchMessage(config)} ${IMPORT_ALIAS_REMEDY}`;
 }
 
 // src/output.ts
@@ -3272,54 +4386,334 @@ function centerLine(line) {
   return `${" ".repeat(padding)}${line}`;
 }
 
-// src/http.ts
-async function requestJson(url, options = {}) {
-  const headers = new Headers(options.headers);
-  headers.set("accept", "application/json");
-  headers.set("user-agent", `${CLI_NAME}/${CLI_VERSION}`);
-  if (options.body && !headers.has("content-type")) {
-    headers.set("content-type", "application/json");
-  }
-  if (options.token) {
-    headers.set("authorization", `Bearer ${options.token}`);
+// src/errors.ts
+var PRICING_URL = "https://ui.wensity.com/pricing";
+var CliError = class _CliError extends Error {
+  exitCode;
+  /** The install-core error this one renders, when there is one. */
+  wensityError;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    if (options.cause) this.wensityError = options.cause;
+  }
+  /**
+   * install-core throws WensityError wherever this code used to throw CliError,
+   * so `instanceof CliError` keeps meaning "a user-facing CLI failure" for both.
+   * Render one with `toCliError` to get the exit code and CLI wording.
+   */
+  static [Symbol.hasInstance](value) {
+    return isWensityError(value) || Function.prototype[Symbol.hasInstance].call(_CliError, value);
+  }
+  static fromWensityError(error) {
+    return new _CliError(renderWensityErrorMessage(error), 1, { cause: error });
+  }
+};
+function renderWensityErrorMessage(error) {
+  if (error.code === "entitlement_required") {
+    return `${error.message}
+Upgrade here: ${pricingBlue(PRICING_URL)}`;
+  }
+  return error.message;
+}
+function toCliError(error) {
+  if (isWensityError(error)) return CliError.fromWensityError(error);
+  return error instanceof CliError ? error : void 0;
+}
+
+// src/args.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "--") {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+    const inlineValueIndex = token.indexOf("=");
+    const rawName = inlineValueIndex > -1 ? token.slice(2, inlineValueIndex) : token.slice(2);
+    const name = normalizeOptionName(rawName);
+    if (!name) {
+      throw new CliError(`Invalid option: ${token}`);
+    }
+    if (inlineValueIndex > -1) {
+      options.set(name, token.slice(inlineValueIndex + 1));
+      continue;
+    }
+    const nextToken = argv[index + 1];
+    if (nextToken && !nextToken.startsWith("--") && expectsValue(name)) {
+      options.set(name, nextToken);
+      index += 1;
+      continue;
+    }
+    options.set(name, true);
+  }
+  return { positionals, options };
+}
+function getStringOption(args, name) {
+  const value = args.options.get(name);
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") {
+    throw new CliError(`--${name} expects a value.`);
+  }
+  return value;
+}
+function hasFlag(args, name) {
+  return args.options.get(name) === true;
+}
+function expectsValue(name) {
+  return [
+    "api-url",
+    "registry",
+    "token",
+    "type",
+    "preset",
+    "preset-file",
+    "template",
+    "package-manager"
+  ].includes(name);
+}
+function normalizeOptionName(name) {
+  if (name === "dry") return "dry-run";
+  return name;
+}
+
+// src/credentials.ts
+import { stdin, stdout } from "process";
+
+// ../install-core/src/credentials.ts
+import { mkdir as mkdir3, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2, chmod as chmod2 } from "fs/promises";
+import { dirname as dirname4, join as join8 } from "path";
+import { randomUUID } from "crypto";
+function credentialsPath(env) {
+  if (env.WENSITY_CREDENTIALS_FILE) return env.WENSITY_CREDENTIALS_FILE;
+  const configHome = env.WENSITY_CONFIG_HOME ?? env.XDG_CONFIG_HOME ?? join8(requiredHome(env), ".config");
+  return join8(configHome, "wensity", "credentials.json");
+}
+async function readCredentials(env) {
+  const path = credentialsPath(env);
+  try {
+    const content = await readFile4(path, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed.version !== 1 || !parsed.token || !parsed.apiBaseUrl) {
+      throw new WensityError("auth_invalid", `Credentials at ${path} are not valid. Run wensity login again.`);
+    }
+    return parsed;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    if (error instanceof SyntaxError) {
+      throw new WensityError("auth_invalid", `Credentials at ${path} are not valid JSON. Run wensity login again.`);
+    }
+    throw error;
+  }
+}
+async function writeCredentials(env, credentials) {
+  const path = credentialsPath(env);
+  const directory = dirname4(path);
+  const temporaryPath = join8(directory, `.credentials.${randomUUID()}.tmp`);
+  await mkdir3(directory, { recursive: true, mode: 448 });
+  await writeFile2(temporaryPath, `${JSON.stringify(credentials, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename2(temporaryPath, path);
+  await chmod2(path, 384);
+  return path;
+}
+async function deleteCredentials(env) {
+  const path = credentialsPath(env);
+  try {
+    await rm2(path, { force: false });
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function requiredHome(env) {
+  if (env.HOME) return env.HOME;
+  throw new WensityError("config_missing", "HOME is not set, so the CLI cannot locate ~/.config/wensity.");
+}
+
+// src/credentials.ts
+async function readTokenInteractively(prompt = "Wensity API token: ") {
+  if (!stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of stdin) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8").trim();
+  }
+  return new Promise((resolveToken, rejectToken) => {
+    const input = stdin;
+    const previousRawMode = input.isRaw;
+    let token = "";
+    function cleanup() {
+      input.off("data", onData);
+      if (typeof previousRawMode === "boolean") {
+        input.setRawMode(previousRawMode);
+      }
+      input.pause();
+    }
+    function onData(chunk) {
+      const value = chunk.toString("utf8");
+      if (value === "") {
+        cleanup();
+        stdout.write("\n");
+        rejectToken(new CliError("Login cancelled.", 130));
+        return;
+      }
+      if (value === "\r" || value === "\n" || value === "\r\n") {
+        cleanup();
+        stdout.write("\n");
+        resolveToken(token.trim());
+        return;
+      }
+      if (value === "\x7F") {
+        token = token.slice(0, -1);
+        return;
+      }
+      token += value;
+    }
+    stdout.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
+
+// ../install-core/src/font-install.ts
+var FONT_CSS_START_MARKER = "/* \u2500\u2500 Wensity Fonts";
+var FONT_CSS_END_MARKER = "/* \u2500\u2500 End Wensity Fonts \u2500\u2500 */";
+function planFontInstall(headingFont, bodyFont) {
+  const packages = [];
+  const importLines = [];
+  const seenPackages = /* @__PURE__ */ new Set();
+  const seenImports = /* @__PURE__ */ new Set();
+  const pushFont = (meta) => {
+    if (!meta) return;
+    if (!seenPackages.has(meta.packageName)) {
+      seenPackages.add(meta.packageName);
+      packages.push(meta.packageName);
+    }
+    for (const specifier of curatedFontCssImportSpecifiers(meta)) {
+      const line = `@import "${specifier}";`;
+      if (!seenImports.has(line)) {
+        seenImports.add(line);
+        importLines.push(line);
+      }
+    }
+  };
+  if (headingFont !== "system") {
+    pushFont(HEADING_FONT_PACKAGES[headingFont]);
   }
-  let response;
-  try {
-    response = await fetch(url, { ...options, headers });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown network error";
-    throw new CliError(`Could not reach ${url}: ${message}`);
+  if (bodyFont !== "system") {
+    pushFont(BODY_FONT_PACKAGES[bodyFont]);
   }
-  const text = await response.text();
-  const payload = parseJson(text);
-  if (!response.ok) {
-    const message = formatErrorMessage(payload) ?? response.statusText;
-    throw new CliError(`${response.status} ${message}`);
+  packages.sort();
+  if (importLines.length === 0) {
+    return { packages: [], importLines: [], block: null };
   }
-  return payload;
+  const block = [
+    `${FONT_CSS_START_MARKER} \u2500\u2500 */`,
+    ...importLines,
+    FONT_CSS_END_MARKER
+  ].join("\n");
+  return { packages, importLines, block };
 }
-function parseJson(text) {
-  if (!text.trim()) return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new CliError("Registry returned invalid JSON.");
+function upsertFontImportBlock(existingCss, block) {
+  const start = existingCss.indexOf(FONT_CSS_START_MARKER);
+  const end = existingCss.indexOf(FONT_CSS_END_MARKER);
+  if (start !== -1 || end !== -1) {
+    if (start === -1 || end === -1 || end <= start) {
+      throw new WensityError(
+        "config_invalid",
+        "Configured Tailwind CSS has a partial Wensity Fonts block. Remove the broken markers and re-run install."
+      );
+    }
+    const before2 = existingCss.slice(0, start).replace(/\s*$/, "");
+    const after2 = existingCss.slice(end + FONT_CSS_END_MARKER.length).replace(/^\s*/, "");
+    if (!block) {
+      const joined = [before2, after2].filter((part) => part.length > 0).join("\n\n");
+      return joined ? `${joined.replace(/\n{3,}/g, "\n\n")}
+` : "";
+    }
+    const normalizedBlock2 = block.trim();
+    const prefix2 = before2 ? `${before2}
+
+` : "";
+    const suffix2 = after2 ? `
+
+${after2}` : "\n";
+    return `${prefix2}${normalizedBlock2}${suffix2}`.replace(/\n{3,}/g, "\n\n");
   }
+  if (!block) return existingCss;
+  const normalizedBlock = block.trim();
+  const insertAt = findFontBlockInsertIndex(existingCss);
+  const before = existingCss.slice(0, insertAt).replace(/\s*$/, "");
+  const after = existingCss.slice(insertAt).replace(/^\s*/, "");
+  const prefix = before ? `${before}
+
+` : "";
+  const suffix = after ? `
+
+${after}` : "\n";
+  return `${prefix}${normalizedBlock}${suffix}`.replace(/\n{3,}/g, "\n\n");
+}
+function warnUnusedFontPackageMessage(headingFont, bodyFont, installedPackages) {
+  const needed = new Set(planFontInstall(headingFont, bodyFont).packages);
+  const curated = [
+    ...Object.values(HEADING_FONT_PACKAGES).map((entry) => entry.packageName),
+    ...Object.values(BODY_FONT_PACKAGES).map((entry) => entry.packageName)
+  ];
+  const leftover = curated.filter(
+    (pkg) => installedPackages.has(pkg) && !needed.has(pkg)
+  );
+  if (leftover.length === 0) return void 0;
+  return `Project package.json still lists ${leftover.join(", ")} while curated fonts are set to heading="${headingFont}" body="${bodyFont}". Wensity removed the @import for unused fonts but will not uninstall ${leftover.join(", ")} (it may be used outside Wensity).`;
 }
-function formatErrorMessage(payload) {
-  if (!payload || typeof payload !== "object") return void 0;
-  const record = payload;
-  const code = typeof record.error === "string" ? record.error : void 0;
-  const message = typeof record.message === "string" ? record.message : code;
-  if (code === "pro_license_required") {
-    const base = message ?? "This component requires Wensity Pro.";
-    return `${base}
-Upgrade here: ${pricingBlue("https://ui.wensity.com/pricing")}`;
+function findFontBlockInsertIndex(css) {
+  let index = 0;
+  const length = css.length;
+  while (index < length) {
+    while (index < length && /\s/.test(css[index])) index += 1;
+    if (index >= length) break;
+    if (css.startsWith("/*", index)) {
+      const end = css.indexOf("*/", index + 2);
+      if (end === -1) break;
+      index = end + 2;
+      continue;
+    }
+    if (css.startsWith("//", index)) {
+      const end = css.indexOf("\n", index);
+      if (end === -1) return length;
+      index = end + 1;
+      continue;
+    }
+    if (css.startsWith("@charset", index) || css.startsWith("@import", index)) {
+      const end = css.indexOf(";", index);
+      if (end === -1) break;
+      index = end + 1;
+      continue;
+    }
+    break;
   }
-  return message;
+  return index;
+}
+
+// src/http.ts
+function requestJson2(url, options = {}) {
+  return requestJson(url, { userAgent: `${CLI_NAME}/${CLI_VERSION}`, ...options });
 }
 
-// src/icon-transform.ts
+// ../install-core/src/icon-transform.ts
 var UI_PRIMITIVES_CATEGORY = "UI Primitives";
 var TABLER_ICONS_PACKAGE = "@tabler/icons-react";
 var LUCIDE_ICONS_PACKAGE = "lucide-react";
@@ -3363,7 +4757,7 @@ function createLucideAdapter() {
         return resolveLucideExport(tablerName);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new CliError(`${context}: ${message}`);
+        throw new WensityError("source_integrity_failed", `${context}: ${message}`);
       }
     },
     strokePropTo: "strokeWidth"
@@ -3477,13 +4871,15 @@ function rewriteTablerImportsToTarget(content, adapter, context) {
       for (const spec of specs) {
         if (spec.isTypeOnly || typePrefix.includes("type")) {
           if (spec.imported === "Icon" || isIconTransformExclusion(spec.imported)) {
-            throw new CliError(
+            throw new WensityError(
+              "source_integrity_failed",
               `${context}: unexpected type-only icon import "${spec.imported}" from ${TABLER_ICONS_PACKAGE}.`
             );
           }
         }
         if (isIconTransformExclusion(spec.imported)) {
-          throw new CliError(
+          throw new WensityError(
+            "source_integrity_failed",
             `${context}: "${spec.imported}" is excluded from the icon map (Phase 0 internal geometry). It must not appear as a library import.`
           );
         }
@@ -3506,12 +4902,14 @@ function rewriteTablerImportsToTarget(content, adapter, context) {
     }
   );
   if (hasPackageImport(next, TABLER_ICONS_PACKAGE)) {
-    throw new CliError(
+    throw new WensityError(
+      "source_integrity_failed",
       `${context}: failed to rewrite all ${TABLER_ICONS_PACKAGE} imports for ${adapter.id}.`
     );
   }
   if (/(?:import|export)\s+\*\s+as\s+\w+\s+from\s+["']@tabler\/icons-react["']/.test(content)) {
-    throw new CliError(
+    throw new WensityError(
+      "source_integrity_failed",
       `${context}: namespace imports from ${TABLER_ICONS_PACKAGE} are not supported. Use named imports.`
     );
   }
@@ -3523,7 +4921,8 @@ function assertNoUnmappedTablerImports(content, context) {
     const specs = parseNamedImportClause(match[1] ?? "");
     for (const spec of specs) {
       if (isIconTransformExclusion(spec.imported)) {
-        throw new CliError(
+        throw new WensityError(
+          "source_integrity_failed",
           `${context}: "${spec.imported}" must not appear as a library import (Phase 0 exclusion).`
         );
       }
@@ -3576,108 +4975,12 @@ function rewriteStrokeProps(content, localBindings) {
 }
 
 // src/package-manager.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
-import { spawnSync } from "child_process";
-import { join as join4 } from "path";
-var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
-function parsePackageManager(value) {
-  if (!value) return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (isPackageManager(normalized)) return normalized;
-  throw new CliError(
-    `Unsupported package manager "${value}". Use one of: ${PACKAGE_MANAGERS.join(", ")}.`
-  );
-}
-function packageManagerFromUserAgent(env = process.env) {
-  const agent = env.npm_config_user_agent;
-  if (!agent) return void 0;
-  const first = agent.trim().split(/\s+/)[0] ?? "";
-  const name = first.split("/")[0]?.toLowerCase();
-  return name && isPackageManager(name) ? name : void 0;
-}
-function detectPackageManager(projectRoot, env = process.env) {
-  if (existsSync2(join4(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join4(projectRoot, "bun.lockb")) || existsSync2(join4(projectRoot, "bun.lock"))) return "bun";
-  if (existsSync2(join4(projectRoot, "yarn.lock"))) return "yarn";
-  if (existsSync2(join4(projectRoot, "package-lock.json"))) return "npm";
-  return packageManagerFromUserAgent(env) ?? "npm";
-}
-function isPackageManager(value) {
-  return PACKAGE_MANAGERS.includes(value);
-}
-function missingDependencies(projectRoot, dependencies) {
-  const installed = readInstalledPackageNames(projectRoot);
-  if (!installed) return dependencies;
-  return dependencies.filter((dependency) => !installed.has(dependency));
-}
-function readInstalledPackageNames(projectRoot) {
-  const packageJsonPath = join4(projectRoot, "package.json");
-  if (!existsSync2(packageJsonPath)) return void 0;
-  const packageJson2 = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  return new Set(
-    Object.keys({
-      ...packageJson2.dependencies,
-      ...packageJson2.devDependencies,
-      ...packageJson2.peerDependencies,
-      ...packageJson2.optionalDependencies
-    })
-  );
-}
-var YARN_CONFIG_FILE = ".yarnrc.yml";
-function prepareProjectPackageManager(projectRoot, options = {}) {
-  if (resolvePackageManager(projectRoot, options) !== "yarn") return [];
-  const configPath = join4(projectRoot, YARN_CONFIG_FILE);
-  if (existsSync2(configPath)) return [];
-  if (!options.dryRun) writeFileSync(configPath, "nodeLinker: node-modules\n", "utf8");
-  return [YARN_CONFIG_FILE];
-}
-function runProjectInstall(projectRoot, options = {}) {
-  const packageJsonPath = join4(projectRoot, "package.json");
-  if (!existsSync2(packageJsonPath)) return;
-  const packageManager = resolvePackageManager(projectRoot, options);
-  runPackageManager(projectRoot, packageManager, ["install"]);
-}
-function resolvePackageManager(projectRoot, options = {}) {
-  return options.packageManager ?? detectPackageManager(projectRoot, options.env);
-}
-function runInstall(projectRoot, dependencies, options = {}) {
-  if (dependencies.length === 0) return;
-  const packageJsonPath = join4(projectRoot, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    warn(`No package.json found. Install these dependencies manually: ${dependencies.join(" ")}`);
-    return;
-  }
-  const packageManager = resolvePackageManager(projectRoot, options);
-  runPackageManager(projectRoot, packageManager, installArgs(packageManager, dependencies));
-}
-function runPackageManager(projectRoot, packageManager, args) {
-  const result = spawnSync(packageManager, args, {
-    cwd: projectRoot,
-    stdio: "inherit",
-    shell: process.platform === "win32"
-  });
-  if (result.error) {
-    throw new CliError(`Could not run ${packageManager}: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new CliError(`${packageManager} ${args.join(" ")} failed with exit code ${result.status ?? 1}.`);
-  }
-}
-function installArgs(packageManager, dependencies) {
-  switch (packageManager) {
-    case "pnpm":
-      return ["add", ...dependencies];
-    case "yarn":
-      return ["add", ...dependencies];
-    case "bun":
-      return ["add", ...dependencies];
-    case "npm":
-      return ["install", ...dependencies];
-  }
+function runInstall2(projectRoot, dependencies, options = {}) {
+  return runInstall(projectRoot, dependencies, { onWarning: warn, ...options });
 }
 
 // src/preset.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 async function resolvePresetStyle(input) {
   if (input.presetCode && input.presetFile) {
     throw new CliError("Use either --preset or --preset-file, not both.");
@@ -3685,7 +4988,7 @@ async function resolvePresetStyle(input) {
   let code = input.presetCode;
   if (input.presetFile) {
     try {
-      const raw = await readFile3(input.presetFile, "utf8");
+      const raw = await readFile5(input.presetFile, "utf8");
       const trimmed = raw.trim();
       if (trimmed.startsWith("{")) {
         const parsed = JSON.parse(trimmed);
@@ -3885,18 +5188,18 @@ function formatTokenPanel(summary) {
 }
 
 // src/preset-init-writes.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 async function commitPresetInitWrites(input) {
   let cssWritten = false;
   try {
     if (input.cssChanged) {
-      await mkdir3(dirname4(input.cssAbsolute), { recursive: true });
+      await mkdir4(dirname5(input.cssAbsolute), { recursive: true });
       await writeFile3(input.cssAbsolute, input.nextCss, "utf8");
       cssWritten = true;
     }
     if (input.writeUtility) {
-      await mkdir3(dirname4(input.utilityAbsolutePath), { recursive: true });
+      await mkdir4(dirname5(input.utilityAbsolutePath), { recursive: true });
       await writeFile3(input.utilityAbsolutePath, input.utilityContent, "utf8");
     }
     await input.commitConfig();
@@ -3912,8 +5215,8 @@ async function commitPresetInitWrites(input) {
 }
 
 // src/project-templates.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5, join as join5 } from "path";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname6, join as join9 } from "path";
 function templateCss() {
   return `@import "tailwindcss";
 
@@ -3937,6 +5240,8 @@ function getProjectTemplateDefinition(id) {
 function applyTemplateToConfig(config, template) {
   return {
     ...config,
+    components: "src/components/wensity",
+    utils: "src/lib/utils",
     tailwind: {
       ...config.tailwind,
       css: template.cssPath
@@ -3948,7 +5253,7 @@ async function scaffoldProjectTemplate(projectRoot, template, options) {
   if (!options.force) {
     const conflicts = [];
     for (const file of template.files) {
-      if (await fileExists(join5(projectRoot, file.path))) {
+      if (await fileExists(join9(projectRoot, file.path))) {
         conflicts.push(file.path);
       }
     }
@@ -3965,10 +5270,10 @@ async function scaffoldProjectTemplate(projectRoot, template, options) {
   return planned;
 }
 async function writeTemplateFile(projectRoot, file) {
-  const absolute = join5(projectRoot, file.path);
-  await mkdir4(dirname5(absolute), { recursive: true });
+  const absolute = join9(projectRoot, file.path);
+  await mkdir5(dirname6(absolute), { recursive: true });
   if (file.path === "package.json" && await fileExists(absolute)) {
-    const existing = JSON.parse(await readFile4(absolute, "utf8"));
+    const existing = JSON.parse(await readFile6(absolute, "utf8"));
     const next = JSON.parse(file.content);
     await writeFile4(
       absolute,
@@ -4291,7 +5596,7 @@ function formatTemplateFiles(files) {
   return files.map(toPosixPath);
 }
 
-// src/style-css.ts
+// ../install-core/src/style-css.ts
 var ROOT_SELECTOR = ":root";
 var DARK_SELECTOR = ".dark";
 var SHARED_TOKEN_KEYS = ["radius", "fontSans", "fontDisplay", "fontMono"];
@@ -4375,11 +5680,11 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/component-install.ts
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname6, join as join6, relative as relative3 } from "path";
+// ../install-core/src/component-install.ts
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname7, join as join10, relative as relative7 } from "path";
 
-// src/templates.ts
+// ../install-core/src/templates.ts
 function cnUtilityTemplate() {
   return `import { clsx, type ClassValue } from "clsx";
 import { twMerge } from "tailwind-merge";
@@ -4532,7 +5837,13 @@ export function WensitySecondaryButton({
 `;
 }
 
-// src/component-install.ts
+// ../install-core/src/component-install.ts
+function safeTarget(projectRoot, relativePath) {
+  assertTargetPathLength(relativePath);
+  const absolutePath = resolveInside(projectRoot, relativePath);
+  assertNoSymlinkEscape(projectRoot, absolutePath);
+  return absolutePath;
+}
 var ALWAYS_PRESENT_PACKAGES = /* @__PURE__ */ new Set(["react", "react-dom", "next"]);
 var OVERLAY_HELPER_PATH = "components/wensity/overlay.tsx";
 var PRIMITIVE_CSS_START_MARKER = "/* \u2500\u2500 Wensity Primitive Tokens";
@@ -4554,7 +5865,7 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
   for (const [index, payloadFile] of payload.files.entries()) {
     const payloadFileKind = getPayloadFileKind(payloadFile);
     const relativeOutputPath = getPayloadOutputPath(payloadFile, fallbackFileName, config);
-    const absoluteOutputPath = resolveInside(projectRoot, relativeOutputPath);
+    const absoluteOutputPath = safeTarget(projectRoot, relativeOutputPath);
     if (!payloadHelperNeeds) mergeHelperNeeds(inferredHelperNeeds, inferHelperNeeds(payloadFile.content));
     const transformed = transformComponentSource(payloadFile.content, config, {
       isPrimitiveCategory,
@@ -4577,9 +5888,9 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
   const helperNeeds = payloadHelperNeeds ?? inferredHelperNeeds;
   if (!hasGraphHelperFiles && helperNeeds.utils) {
     const utilityPath = withSourceExtension(config.utils, "ts");
-    if (!await fileExists(resolveInside(projectRoot, utilityPath))) {
+    if (!await fileExists(safeTarget(projectRoot, utilityPath))) {
       files.push({
-        absolutePath: resolveInside(projectRoot, utilityPath),
+        absolutePath: safeTarget(projectRoot, utilityPath),
         relativePath: utilityPath,
         content: cnUtilityTemplate(),
         kind: "helper"
@@ -4587,11 +5898,11 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
     }
   }
   if (!hasGraphHelperFiles && helperNeeds.primitives) {
-    const primitivesPath = toPosixPath(join6(config.components, "primitives.tsx"));
-    if (!await fileExists(resolveInside(projectRoot, primitivesPath))) {
+    const primitivesPath = toPosixPath(join10(config.components, "primitives.tsx"));
+    if (!await fileExists(safeTarget(projectRoot, primitivesPath))) {
       const primitives = primitivesTemplate(config.aliases.utils);
       files.push({
-        absolutePath: resolveInside(projectRoot, primitivesPath),
+        absolutePath: safeTarget(projectRoot, primitivesPath),
         relativePath: primitivesPath,
         content: primitives,
         kind: "helper"
@@ -4627,8 +5938,8 @@ async function planPrimitiveCssFile(projectRoot, config, payload) {
   primitiveCss = applyStyleToPrimitiveCss(primitiveCss, style).trim();
   const cssRelative = config.tailwind?.css;
   if (!cssRelative) return void 0;
-  const absolutePath = resolveInside(projectRoot, cssRelative);
-  const existing = await fileExists(absolutePath) ? await readFile5(absolutePath, "utf8") : "";
+  const absolutePath = safeTarget(projectRoot, cssRelative);
+  const existing = await fileExists(absolutePath) ? await readFile7(absolutePath, "utf8") : "";
   const withBase = upsertBaseCssBlock(existing, buildBaseCssBlock(baseColorFromStyle(style)));
   const withTokens = upsertPrimitiveCssBlock(withBase, primitiveCss);
   const fonts = curatedFontsFromStyle(style);
@@ -4667,7 +5978,8 @@ function upsertDelimitedBlock(existingCss, block, options) {
     return `${before}${normalizedBlock}${after}`.replace(/\n{3,}/g, "\n\n");
   }
   if (start !== -1 || end !== -1) {
-    throw new CliError(
+    throw new WensityError(
+      "config_invalid",
       `Configured Tailwind CSS has a partial ${options.label} block. Remove the broken markers and re-run install.`
     );
   }
@@ -4697,18 +6009,12 @@ async function assertNoConflicts(files, force) {
     if (await fileExists(file.absolutePath)) conflicts.push(file.relativePath);
   }
   if (conflicts.length > 0) {
-    throw new CliError(`Refusing to overwrite existing files. Use --force to replace:
+    throw new WensityError("file_conflict", `Refusing to overwrite existing files. Use --force to replace:
 ${conflicts.map((path) => `  - ${path}`).join("\n")}`);
   }
 }
-async function writePlannedFiles(files) {
-  for (const file of files) {
-    await mkdir5(dirname6(file.absolutePath), { recursive: true });
-    await writeFile5(file.absolutePath, file.content, "utf8");
-  }
-}
 function summarizeFiles(projectRoot, files) {
-  return files.map((file) => toPosixPath(relative3(projectRoot, file.absolutePath)));
+  return files.map((file) => toPosixPath(relative7(projectRoot, file.absolutePath)));
 }
 function transformComponentSource(content, config, iconOptions) {
   let transformed = content;
@@ -4729,13 +6035,13 @@ function getPayloadFileKind(payloadFile) {
 }
 function getPayloadOutputPath(payloadFile, fallbackFileName, config) {
   if (isUtilsHelperFile(payloadFile)) return withSourceExtension(config.utils, "ts");
-  if (isOverlayHelperFile(payloadFile)) return toPosixPath(join6(config.components, "overlay.tsx"));
-  if (isPrimitivesHelperFile(payloadFile)) return toPosixPath(join6(config.components, "primitives.tsx"));
+  if (isOverlayHelperFile(payloadFile)) return toPosixPath(join10(config.components, "overlay.tsx"));
+  if (isPrimitivesHelperFile(payloadFile)) return toPosixPath(join10(config.components, "primitives.tsx"));
   if (payloadFile.kind === "helper") {
-    throw new CliError(`Unsupported registry helper file path: ${payloadFile.path}`);
+    throw new WensityError("path_unsafe", `Unsupported registry helper file path: ${payloadFile.path}`);
   }
   const safePayloadPath = sanitizePayloadPath(payloadFile.path, fallbackFileName);
-  return toPosixPath(join6(config.components, safePayloadPath));
+  return toPosixPath(join10(config.components, safePayloadPath));
 }
 function isGraphHelperFile(payloadFile) {
   return isUtilsHelperFile(payloadFile) || isOverlayHelperFile(payloadFile) || isPrimitivesHelperFile(payloadFile);
@@ -4832,7 +6138,7 @@ function normalizePackageName(specifier) {
 function withSourceExtension(path, extension) {
   const directory = parentDirectory(path);
   const fileName = extensionlessPath(path.split("/").at(-1) ?? path);
-  return toPosixPath(join6(directory === "." ? "" : directory, `${fileName}.${extension}`));
+  return toPosixPath(join10(directory === "." ? "" : directory, `${fileName}.${extension}`));
 }
 
 // src/commands.ts
@@ -4925,6 +6231,7 @@ async function initCommand(context, parsed) {
   const hasPreset = Boolean(presetCode || presetFile);
   const dependencies = ["clsx", "tailwind-merge"];
   const installOptions = installOptionsFrom(context, parsed);
+  assertProjectRootCandidate(context.cwd, context.env.HOME);
   if (hasPreset) {
     await initWithPreset(context, {
       dryRun,
@@ -4942,7 +6249,7 @@ async function initCommand(context, parsed) {
   const templateFiles = template ? await scaffoldProjectTemplate(context.cwd, template, { dryRun, force }) : [];
   const packageManagerFiles = template ? prepareProjectPackageManager(context.cwd, { ...installOptions, dryRun }) : [];
   const config = template ? applyTemplateToConfig(createDefaultConfig(context.cwd, apiUrl), template) : createDefaultConfig(context.cwd, apiUrl);
-  const configPath = join7(context.cwd, CONFIG_FILE_NAME);
+  const configPath = join11(context.cwd, CONFIG_FILE_NAME);
   const utilityPath = resolveConfiguredFilePath(context.cwd, config.utils);
   const utilityRelativePath = toPosixPath(config.utils.endsWith(".ts") ? config.utils : `${config.utils}.ts`);
   if (dryRun) {
@@ -4963,8 +6270,8 @@ async function initCommand(context, parsed) {
     await writeTextFile(utilityPath, cnUtilityTemplate());
   }
   if (install) {
-    if (template) runProjectInstall(context.cwd, installOptions);
-    runInstall(context.cwd, missingDependencies(context.cwd, dependencies), installOptions);
+    if (template) await runProjectInstall(context.cwd, installOptions);
+    await runInstall2(context.cwd, missingDependencies(context.cwd, dependencies), installOptions);
   }
   await assertInitPostconditions(context.cwd, [
     ...templateFiles,
@@ -4992,7 +6299,7 @@ async function initWithPreset(context, options) {
     presetCode: options.presetCode,
     presetFile: options.presetFile
   });
-  const configPath = join7(context.cwd, CONFIG_FILE_NAME);
+  const configPath = join11(context.cwd, CONFIG_FILE_NAME);
   const configExists = await fileExists(configPath);
   const templateFiles = options.template ? await scaffoldProjectTemplate(context.cwd, options.template, {
     dryRun: options.dryRun,
@@ -5007,7 +6314,7 @@ async function initWithPreset(context, options) {
     if (options.template) {
       throw new CliError(`${CONFIG_FILE_NAME} already exists. Omit --template for existing projects or use --force.`);
     }
-    const loaded = await loadConfig(context.cwd, { apiUrl: options.apiUrl });
+    const loaded = await loadConfig(context.cwd, { apiUrl: options.apiUrl }, { home: context.env.HOME });
     config = {
       ...loaded.config,
       style
@@ -5061,8 +6368,8 @@ async function initWithPreset(context, options) {
     }
   });
   if (options.install) {
-    if (options.template) runProjectInstall(context.cwd, options.installOptions);
-    runInstall(
+    if (options.template) await runProjectInstall(context.cwd, options.installOptions);
+    await runInstall2(
       context.cwd,
       missingDependencies(context.cwd, installDependencies),
       options.installOptions
@@ -5111,7 +6418,7 @@ async function applyCommand(context, parsed) {
   if (!presetCodeInput && !presetFile) {
     throw new CliError("Missing preset. Pass --preset <code> or --preset-file <path>.");
   }
-  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl });
+  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl }, { home: context.env.HOME });
   if (!loaded.exists) {
     throw new CliError(`${CONFIG_FILE_NAME} not found. Run "wensity init" first, then "wensity apply --preset <code>".`);
   }
@@ -5159,7 +6466,7 @@ async function applyCommand(context, parsed) {
     }
   });
   if (install && installDependencies.length > 0) {
-    runInstall(
+    await runInstall2(
       loaded.projectRoot,
       missingDependencies(loaded.projectRoot, installDependencies),
       installOptionsFrom(context, parsed)
@@ -5212,7 +6519,7 @@ async function preparePresetStyleApplication(projectRoot, config, style, operati
     throw new CliError("No Tailwind CSS path configured. Set tailwind.css in wensity.json.");
   }
   const cssAbsolute = resolveInside(projectRoot, cssRelative);
-  const existingCss = await fileExists(cssAbsolute) ? await readFile6(cssAbsolute, "utf8") : "";
+  const existingCss = await fileExists(cssAbsolute) ? await readFile8(cssAbsolute, "utf8") : "";
   const withBase = upsertBaseCssBlock(existingCss, buildBaseCssBlock(baseColorFromStyle(style)));
   const withTokens = upsertPrimitiveCssBlock(withBase, primitiveCss);
   const nextCss = upsertFontImportBlock(withTokens, fontPlan.block);
@@ -5237,7 +6544,7 @@ async function loginCommand(context, parsed) {
   if (!token) {
     throw new CliError("A token is required. Create one in the Wensity dashboard and run wensity login again.");
   }
-  const whoami = await requestJson(joinUrl(apiBaseUrl, "/api/cli/whoami"), { token });
+  const whoami = await requestJson2(joinUrl(apiBaseUrl, "/api/cli/whoami"), { token });
   const path = await writeCredentials(context.env, {
     version: 1,
     apiBaseUrl,
@@ -5266,7 +6573,7 @@ async function logoutCommand(context) {
 }
 async function whoamiCommand(context, parsed) {
   const credentials = await requireCredentials(context.env);
-  const whoami = await requestJson(joinUrl(credentials.apiBaseUrl, "/api/cli/whoami"), {
+  const whoami = await requestJson2(joinUrl(credentials.apiBaseUrl, "/api/cli/whoami"), {
     token: credentials.token
   });
   if (hasFlag(parsed, "json")) {
@@ -5280,10 +6587,15 @@ async function listCommand(context, parsed) {
   const resourceType = getResourceType(parsed);
   const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL;
   const registryOverride = getStringOption(parsed, "registry");
-  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl });
-  const registry = registryUrlForType(loaded.config.registry, resourceType, registryOverride);
+  const configuredRegistry = await loadConfig(context.cwd, { registry: registryOverride, apiUrl }, { home: context.env.HOME }).then((loaded) => loaded.config.registry).catch((error) => {
+    if (isWensityError(error) && error.code === "project_ambiguous") {
+      return registryOverride ?? createDefaultConfig(context.cwd, apiUrl).registry;
+    }
+    throw error;
+  });
+  const registry = registryUrlForType(configuredRegistry, resourceType, registryOverride);
   if (resourceType === "block") {
-    const response2 = await requestJson(registry);
+    const response2 = await requestJson2(registry);
     if (hasFlag(parsed, "json")) {
       printJson(response2);
       return;
@@ -5302,7 +6614,7 @@ async function listCommand(context, parsed) {
     ]));
     return;
   }
-  const response = await requestJson(registry);
+  const response = await requestJson2(registry);
   if (hasFlag(parsed, "json")) {
     printJson(response);
     return;
@@ -5354,7 +6666,10 @@ ${usage}`);
   }
   const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL;
   const registryOverride = getStringOption(parsed, "registry");
-  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl });
+  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl }, { home: context.env.HOME });
+  if (importAliasesResolve(loaded.projectRoot, loaded.config) === false) {
+    throw new CliError(importAliasBlockMessage(loaded.config));
+  }
   const credentials = await readCredentials(context.env);
   const registry = registryUrlForType(loaded.config.registry, resourceType, registryOverride);
   const force = updateMode || hasFlag(parsed, "force");
@@ -5405,13 +6720,12 @@ ${usage}`);
     if (unusedFontWarning) warn(unusedFontWarning);
     return;
   }
-  for (const prepared of installPlans) {
-    await writePlannedFiles(
-      prepared.cssFile ? [...prepared.files, prepared.cssFile] : prepared.files
-    );
-  }
+  await writeWithRollback(
+    loaded.projectRoot,
+    installPlans.flatMap((prepared) => prepared.cssFile ? [...prepared.files, prepared.cssFile] : prepared.files)
+  );
   if (install) {
-    runInstall(loaded.projectRoot, missing, installOptionsFrom(context, parsed));
+    await runInstall2(loaded.projectRoot, missing, installOptionsFrom(context, parsed));
   }
   const noun = payloads.length === 1 ? "Component" : "Components";
   printTitle(updateMode ? `${noun} updated` : `${noun} installed`);
@@ -5436,61 +6750,95 @@ ${usage}`);
     resourceType === "block" ? "Customize the block copy, colors, and sections" : "Customize props and styling for your app"
   ]));
 }
+async function writeWithRollback(projectRoot, files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byPath.delete(file.absolutePath);
+    byPath.set(file.absolutePath, file);
+  }
+  const result = await apply({
+    projectRoot,
+    planId: `cli_${randomBytes(8).toString("hex")}`,
+    files: [...byPath.values()].map((file) => ({
+      relativePath: toPosixPath(relative8(projectRoot, file.absolutePath)),
+      content: file.content,
+      action: existsSync5(file.absolutePath) ? file.kind === "config" ? "modify" : "overwrite" : "create"
+    }))
+  });
+  if (result.status === "committed") {
+    if (result.cleanupWarning) warn(result.cleanupWarning);
+    return;
+  }
+  const where = result.failedPath ? ` while writing ${result.failedPath}` : "";
+  if (result.status === "rolled_back") {
+    throw new WensityError(
+      result.error.code === "write_failed" ? "write_failed" : result.error.code,
+      `Installation failed${where}; all project-file changes were reverted.
+${result.error.message}` + (result.cleanupWarning ? `
+${result.cleanupWarning}` : ""),
+      { cause: result.error }
+    );
+  }
+  throw new WensityError(
+    "rollback_failed",
+    [
+      `Installation failed${where}, and some files could not be restored. Nothing was deleted: the backups are in ${result.journalPath}.`,
+      ...result.unrecovered.map((item) => `  - ${item.path}: ${item.recovery}`),
+      "Verify with git diff before removing that directory yourself."
+    ].join("\n"),
+    { cause: result.error }
+  );
+}
 function dedupe(values) {
   return [...new Set(values)];
 }
 async function fetchComponentPayload(input) {
+  const client = registryClient(input.registry, input.credentials);
   const metadata = await withSpinner(
     `Finding ${input.slug}`,
-    () => requestJson(registryMetadataUrl(input.registry, input.slug)),
+    () => client.fetchItemMetadata(input.slug, "component"),
     `Found ${input.slug}`
   );
-  if (input.credentials) {
-    const credentials = input.credentials;
-    const cliEndpoint = metadata.endpoints?.cli ?? `/api/cli/${input.slug}`;
-    const endpoint2 = cliEndpoint.startsWith("http") ? cliEndpoint : joinUrl(credentials.apiBaseUrl, cliEndpoint);
-    try {
-      return await withSpinner(
-        `Downloading ${metadata.name}`,
-        () => requestJson(endpoint2, { token: credentials.token }),
-        `Downloaded ${metadata.name}`
-      );
-    } catch (error) {
-      if (metadata.access === "pro" || !isAuthFailure(error)) throw error;
-      warn("Saved Wensity credentials were rejected; falling back to the public free registry payload.");
-    }
-  }
-  if (metadata.access === "pro") {
-    throw new CliError(formatProRequiredError(metadata.name, "component"));
+  try {
+    return await client.fetchSourcePayload(input.slug, "component", {
+      metadata,
+      download: (task) => withSpinner(`Downloading ${metadata.name}`, task, `Downloaded ${metadata.name}`),
+      onCredentialsRejected: () => warn("Saved Wensity credentials were rejected; falling back to the public free registry payload.")
+    });
+  } catch (error) {
+    throw proRequiredError(error, metadata.name, "component");
   }
-  const publicSourceEndpoint = metadata.endpoints?.registry ?? registrySlugUrl(input.registry, input.slug);
-  const endpoint = publicSourceEndpoint.startsWith("http") ? publicSourceEndpoint : joinUrl(registryOrigin(input.registry), publicSourceEndpoint);
-  return withSpinner(
-    `Downloading ${metadata.name}`,
-    () => requestJson(endpoint),
-    `Downloaded ${metadata.name}`
-  );
-}
-function isAuthFailure(error) {
-  return error instanceof CliError && /^(401|403)\b/.test(error.message);
 }
 async function fetchBlockPayload(input) {
+  const client = registryClient(input.registry, input.credentials);
   const metadata = await withSpinner(
     `Finding ${input.slug}`,
-    () => requestJson(registryMetadataUrl(input.registry, input.slug)),
+    () => client.fetchItemMetadata(input.slug, "block"),
     `Found ${input.slug}`
   );
-  if (!input.credentials) {
-    throw new CliError(formatProRequiredError(metadata.name, "block"));
-  }
-  const credentials = input.credentials;
-  const cliEndpoint = metadata.endpoints?.cli ?? `/api/cli/blocks/${input.slug}`;
-  const endpoint = cliEndpoint.startsWith("http") ? cliEndpoint : joinUrl(credentials.apiBaseUrl, cliEndpoint);
-  return withSpinner(
-    `Downloading ${metadata.name}`,
-    () => requestJson(endpoint, { token: credentials.token }),
-    `Downloaded ${metadata.name}`
-  );
+  try {
+    return await client.fetchSourcePayload(input.slug, "block", {
+      metadata,
+      download: (task) => withSpinner(`Downloading ${metadata.name}`, task, `Downloaded ${metadata.name}`)
+    });
+  } catch (error) {
+    throw proRequiredError(error, metadata.name, "block");
+  }
+}
+function registryClient(registry, credentials) {
+  return createWensityClient({
+    origin: registryOrigin(registry),
+    registryUrl: registry,
+    blocksRegistryUrl: registry,
+    ...credentials ? { token: credentials.token, apiBaseUrl: credentials.apiBaseUrl } : {},
+    userAgent: `${CLI_NAME}/${CLI_VERSION}`
+  });
+}
+function proRequiredError(error, resourceName, resourceType) {
+  if (isWensityError(error) && error.code === "auth_required") {
+    return new CliError(formatProRequiredError(resourceName, resourceType), 1, { cause: error });
+  }
+  return error;
 }
 function getResourceType(parsed) {
   const value = getStringOption(parsed, "type") ?? "component";
@@ -5509,18 +6857,6 @@ async function requireCredentials(env) {
   }
   return credentials;
 }
-function registryMetadataUrl(registry, slug) {
-  const url = new URL(registry);
-  url.searchParams.set("slug", slug);
-  return url.toString();
-}
-function registrySlugUrl(registry, slug) {
-  return joinUrl(registry.endsWith("/") ? registry : `${registry}/`, slug);
-}
-function registryOrigin(registry) {
-  const url = new URL(registry);
-  return `${url.protocol}//${url.host}`;
-}
 function formatHelp() {
   return [
     brandBanner("Own your component source."),
@@ -5548,7 +6884,7 @@ function formatAccountPanel(whoami, savedPath) {
   return panel(isPro ? "Wensity Pro" : "Wensity Free", lines);
 }
 async function writeTextFile(path, content) {
-  await mkdir6(dirname7(path), { recursive: true });
+  await mkdir7(dirname8(path), { recursive: true });
   await writeFile6(path, content, "utf8");
 }
 function installOptionsFrom(context, parsed) {
@@ -5560,7 +6896,7 @@ function installOptionsFrom(context, parsed) {
 async function assertInitPostconditions(projectRoot, relativePaths) {
   const missing = [];
   for (const relativePath of new Set(relativePaths)) {
-    const absolute = join7(projectRoot, relativePath);
+    const absolute = join11(projectRoot, relativePath);
     let size = 0;
     try {
       size = (await stat(absolute)).size;
@@ -5584,10 +6920,11 @@ run({
   cwd: process.cwd(),
   env: process.env
 }).catch((error) => {
-  if (error instanceof CliError) {
-    process.stderr.write(`${formatCliError(error.message)}
+  const cliError = toCliError(error);
+  if (cliError) {
+    process.stderr.write(`${formatCliError(cliError.message)}
 `);
-    process.exitCode = error.exitCode;
+    process.exitCode = cliError.exitCode;
     return;
   }
   const message = error instanceof Error ? error.stack ?? error.message : String(error);