aplance-ui 1.0.1

package/dist/api.js

@@ -0,0 +1,1954 @@
+// src/commands/init.ts
+import { join as join9, relative as relative4 } from "path";
+import pc4 from "picocolors";
+
+// src/lib/fs-ops.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, relative } from "path";
+import pc3 from "picocolors";
+import * as p2 from "@clack/prompts";
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  code;
+  hint;
+  constructor(code, message, hint) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+var ConfigError = class extends CliError {
+  constructor(code, message, hint) {
+    super(code, message, hint);
+    this.name = "ConfigError";
+  }
+};
+var TemplateError = class extends CliError {
+  constructor(code, message, hint) {
+    super(code, message, hint);
+    this.name = "TemplateError";
+  }
+};
+var RegistryError = class extends CliError {
+  constructor(code, message, hint) {
+    super(code, message, hint);
+    this.name = "RegistryError";
+  }
+};
+var AbortError = class extends CliError {
+  constructor(message = "Aborted by user.") {
+    super("E_ABORTED", message);
+    this.name = "AbortError";
+  }
+};
+
+// src/lib/logger.ts
+import pc from "picocolors";
+var indent = (s, level) => s.split("\n").map((line) => "  ".repeat(level) + line).join("\n");
+var logger = {
+  ok: (msg, level = 0) => console.log(indent(`${pc.green("\u2713")} ${msg}`, level)),
+  info: (msg, level = 0) => console.log(indent(`${pc.cyan("\u25C6")} ${msg}`, level)),
+  action: (msg, level = 0) => console.log(indent(`${pc.gray("\u2192")} ${msg}`, level)),
+  warn: (msg, level = 0) => console.log(indent(`${pc.yellow("\u25B2")} ${msg}`, level)),
+  error: (msg, level = 0) => console.error(indent(`${pc.red("\u2717")} ${msg}`, level)),
+  dim: (msg) => pc.dim(msg)
+};
+
+// src/lib/ui.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+var unwrap = (value) => {
+  if (p.isCancel(value)) throw new AbortError();
+  return value;
+};
+var brand = () => {
+  const colours = [pc2.magenta, pc2.cyan, pc2.blue];
+  const gradient = "aplance-ui".split("").map((ch, i) => colours[i % colours.length](ch)).join("");
+  return `${gradient} ${pc2.dim("\xB7")} ${pc2.dim("design system scaffolder")}`;
+};
+var headline = (subtitle) => {
+  p.intro(brand());
+  if (subtitle) p.log.message(pc2.dim(subtitle));
+};
+var goodbye = (message) => p.outro(pc2.green(message));
+var select2 = async (opts) => unwrap(await p.select(opts));
+var multiselect2 = async (opts) => unwrap(await p.multiselect(opts));
+var confirm2 = async (opts) => unwrap(await p.confirm(opts));
+var note2 = (body, title) => p.note(body, title);
+var step = (message) => p.log.step(message);
+var info = (message) => p.log.info(message);
+var warn = (message) => p.log.warn(message);
+
+// src/lib/fs-ops.ts
+var ensureDir = (filePath) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+};
+var sameContent = (target, content) => {
+  if (!existsSync(target)) return false;
+  try {
+    if (Buffer.isBuffer(content)) {
+      return readFileSync(target).equals(content);
+    }
+    return readFileSync(target, "utf8") === content;
+  } catch {
+    return false;
+  }
+};
+var planActions = async (ops, opts) => {
+  const plan = [];
+  let bulk = null;
+  for (const op of ops) {
+    if (sameContent(op.target, op.content)) {
+      plan.push({ op, action: "unchanged" });
+      continue;
+    }
+    if (!existsSync(op.target)) {
+      plan.push({ op, action: "write" });
+      continue;
+    }
+    if (opts.mode === "force") {
+      plan.push({ op, action: "write" });
+      continue;
+    }
+    if (opts.mode === "skip") {
+      plan.push({ op, action: "skip" });
+      continue;
+    }
+    if (opts.mode === "dry-run") {
+      plan.push({ op, action: "write" });
+      continue;
+    }
+    if (bulk === "all") {
+      plan.push({ op, action: "write" });
+      continue;
+    }
+    if (bulk === "skip-all") {
+      plan.push({ op, action: "skip" });
+      continue;
+    }
+    const choice = unwrap(
+      await p2.select({
+        message: `${pc3.yellow("exists")}  ${op.label}`,
+        options: [
+          { value: "overwrite", label: "Overwrite" },
+          { value: "skip", label: "Skip" },
+          { value: "all", label: "Overwrite all remaining" },
+          { value: "skip-all", label: "Skip all remaining" },
+          { value: "abort", label: "Abort" }
+        ],
+        initialValue: "skip"
+      })
+    );
+    if (choice === "abort") throw new AbortError();
+    if (choice === "all") {
+      bulk = "all";
+      plan.push({ op, action: "write" });
+    } else if (choice === "skip-all") {
+      bulk = "skip-all";
+      plan.push({ op, action: "skip" });
+    } else {
+      plan.push({ op, action: choice === "overwrite" ? "write" : "skip" });
+    }
+  }
+  return plan;
+};
+var applyFileOps = async (ops, opts) => {
+  const plan = await planActions(ops, opts);
+  if (opts.mode === "dry-run") {
+    for (const { op, action } of plan) {
+      const rel = relative(opts.cwd, op.target);
+      if (action === "write") logger.action(`would write  ${rel}`);
+      else if (action === "skip") logger.action(`would skip   ${rel}`);
+      else logger.action(`unchanged    ${logger.dim(rel)}`);
+    }
+    return {
+      written: plan.filter((x) => x.action === "write").length,
+      skipped: plan.filter((x) => x.action === "skip").length,
+      unchanged: plan.filter((x) => x.action === "unchanged").length
+    };
+  }
+  let written = 0;
+  let skipped = 0;
+  let unchanged = 0;
+  for (const { op, action } of plan) {
+    const rel = relative(opts.cwd, op.target);
+    if (action === "write") {
+      try {
+        ensureDir(op.target);
+        writeFileSync(op.target, op.content);
+      } catch (err) {
+        const cause = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Failed to write ${rel}: ${cause}
+${written} file(s) were already written before this failure. Fix the underlying issue (permissions? disk space?) and re-run - identical files will be detected as unchanged and skipped.`
+        );
+      }
+      logger.ok(`wrote  ${rel}`);
+      written++;
+    } else if (action === "skip") {
+      logger.action(`skip   ${logger.dim(rel)}`);
+      skipped++;
+    } else {
+      unchanged++;
+    }
+  }
+  return { written, skipped, unchanged };
+};
+
+// src/lib/styles.ts
+import { readdirSync, readFileSync as readFileSync3, statSync, existsSync as existsSync3 } from "fs";
+import { join as join2, relative as relative2, sep, posix } from "path";
+
+// src/lib/registry.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join } from "path";
+import { fileURLToPath } from "url";
+var resolveRegistryRoot = () => {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  for (const depth of [1, 2, 3, 4]) {
+    const candidate = join(here, ...Array(depth).fill(".."), "registry");
+    if (existsSync2(join(candidate, "registry.json"))) return candidate;
+  }
+  throw new RegistryError(
+    "E_REGISTRY_MISSING",
+    `Bundled registry not found next to the CLI binary.`,
+    `This indicates a packaging problem - reinstall the aplance-ui CLI.`
+  );
+};
+var EXPECTED_VERSION = 3;
+var EMPTY_INSTALL_META = {
+  baseDependencies: {},
+  baseDevDependencies: {},
+  utilitiesDevDependencies: {},
+  packageVersions: {}
+};
+var loadRegistry = () => {
+  const root = resolveRegistryRoot();
+  const manifestPath = join(root, "registry.json");
+  const raw = readFileSync2(manifestPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== EXPECTED_VERSION) {
+    throw new RegistryError(
+      "E_REGISTRY_MISSING",
+      `Unsupported registry version ${parsed.version}. This CLI expects version ${EXPECTED_VERSION}.`
+    );
+  }
+  return {
+    ...parsed,
+    themes: parsed.themes ?? { colors: [], radii: [], spacing: [] },
+    installMeta: parsed.installMeta ?? EMPTY_INSTALL_META,
+    root
+  };
+};
+var resolveUnits = (registry, names) => {
+  const byName = new Map(registry.units.map((u) => [u.name, u]));
+  for (const name of names) {
+    if (!byName.has(name)) {
+      throw new RegistryError(
+        "E_UNKNOWN_UNIT",
+        `Unknown unit "${name}".`,
+        `Run \`aplance-ui list\` to see every available unit.`
+      );
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  const visit = (name) => {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const unit = byName.get(name);
+    if (!unit) return;
+    for (const dep of unit.deps) visit(dep);
+    result.push(unit);
+  };
+  for (const name of names) visit(name);
+  return result;
+};
+var allUnitsInOrder = (registry) => resolveUnits(registry, registry.units.map((u) => u.name));
+var pickVariant = (list, id, dimensionLabel) => {
+  const match = list.find((t) => t.id === id);
+  if (!match) {
+    const available = list.map((t) => t.id).join(", ");
+    throw new RegistryError(
+      "E_UNKNOWN_THEME",
+      `Unknown ${dimensionLabel} "${id}". Available: ${available}.`
+    );
+  }
+  return match;
+};
+var findColor = (registry, id) => pickVariant(registry.themes.colors, id, "color");
+var findRadius = (registry, id) => pickVariant(registry.themes.radii, id, "radius");
+var findSpacing = (registry, id) => pickVariant(registry.themes.spacing, id, "spacing");
+
+// src/lib/styles.ts
+var planUtilitiesGitignoreOp = (opts) => ({
+  target: join2(opts.targetStylesDir, ".gitignore"),
+  content: GITIGNORE_BODY,
+  label: "styles/.gitignore"
+});
+var GITIGNORE_BODY = "# Generated by postcss-token-utilities on every build - do not commit.\nutilities.gen.css\n";
+var EXCLUDE_PATTERNS = [/\.gen\.css$/];
+var BINARY_EXTENSIONS = /\.(woff2?|ttf|otf|eot|png|jpe?g|gif|webp|avif|ico)$/i;
+var toPosix = (p3) => p3.split(sep).join(posix.sep);
+var walkStyles = (dir, base) => {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join2(dir, entry);
+    if (statSync(full).isDirectory()) {
+      out.push(...walkStyles(full, base));
+    } else {
+      const rel = toPosix(relative2(base, full));
+      if (EXCLUDE_PATTERNS.some((re) => re.test(rel))) continue;
+      out.push(rel);
+    }
+  }
+  return out;
+};
+var readOverride = (registry, theme, kind) => {
+  if (!theme.file) return null;
+  const abs = join2(registry.root, theme.file);
+  if (!existsSync3(abs)) return null;
+  return { id: theme.id, kind, css: readFileSync3(abs, "utf8") };
+};
+var planStylesOps = (opts) => {
+  const sourceStylesDir = join2(opts.registry.root, "styles");
+  const relFiles = walkStyles(sourceStylesDir, sourceStylesDir);
+  const overrides = [];
+  const colorOverride = readOverride(
+    opts.registry,
+    findColor(opts.registry, opts.color),
+    "color"
+  );
+  if (colorOverride) overrides.push(colorOverride);
+  const radiusOverride = readOverride(
+    opts.registry,
+    findRadius(opts.registry, opts.radius),
+    "radius"
+  );
+  if (radiusOverride) overrides.push(radiusOverride);
+  const spacingOverride = readOverride(
+    opts.registry,
+    findSpacing(opts.registry, opts.spacing),
+    "spacing"
+  );
+  if (spacingOverride) overrides.push(spacingOverride);
+  return relFiles.map((relPath) => {
+    const sourceAbs = join2(sourceStylesDir, relPath);
+    const targetAbs = join2(opts.targetStylesDir, relPath);
+    const isApp = relPath === "app.css";
+    const content = BINARY_EXTENSIONS.test(sourceAbs) ? readFileSync3(sourceAbs) : isApp && overrides.length > 0 ? mergeOverrides(readFileSync3(sourceAbs, "utf8"), overrides) : readFileSync3(sourceAbs, "utf8");
+    return {
+      target: targetAbs,
+      content,
+      label: `styles/${relPath}`
+    };
+  });
+};
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var parseOverrideBlocks = (css) => {
+  const stripped = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const blocks = [];
+  const blockRe = /([^{}]+?)\{([^{}]*)\}/g;
+  let m;
+  while ((m = blockRe.exec(stripped)) !== null) {
+    const selector = m[1].trim();
+    if (!selector) continue;
+    const vars = [];
+    const varRe = /(--[a-zA-Z0-9_-]+)\s*:\s*([^;]+);/g;
+    let vm;
+    while ((vm = varRe.exec(m[2])) !== null) {
+      vars.push([vm[1], vm[2].trim()]);
+    }
+    if (vars.length > 0) blocks.push({ selector, vars });
+  }
+  return blocks;
+};
+var findTopLevelBlock = (css, selector) => {
+  const re = new RegExp(`(^|\\n)${escapeRegex(selector)}\\s*\\{`, "g");
+  const m = re.exec(css);
+  if (!m) return null;
+  const bodyStart = css.indexOf("{", m.index + m[1].length) + 1;
+  let depth = 0;
+  for (let i = bodyStart; i < css.length; i++) {
+    const c = css[i];
+    if (c === "{") depth++;
+    else if (c === "}") {
+      if (depth === 0) {
+        const sample = css.slice(bodyStart, i).match(/\n([ \t]+)\S/);
+        return { bodyStart, bodyEnd: i, indent: sample ? sample[1] : "  " };
+      }
+      depth--;
+    }
+  }
+  return null;
+};
+var mergeOverrides = (base, overrides) => {
+  let out = base;
+  for (const o of overrides) {
+    for (const block of parseOverrideBlocks(o.css)) {
+      out = mergeBlock(out, block);
+    }
+  }
+  return out;
+};
+var mergeBlock = (base, block) => {
+  const loc = findTopLevelBlock(base, block.selector);
+  if (!loc) {
+    const lines = [
+      `${block.selector} {`,
+      ...block.vars.map(([n, v]) => `  ${n}: ${v};`),
+      `}`
+    ];
+    return `${base.replace(/\s*$/, "")}
+
+${lines.join("\n")}
+`;
+  }
+  let body = base.slice(loc.bodyStart, loc.bodyEnd);
+  for (const [name, value] of block.vars) {
+    const varRe = new RegExp(`(${escapeRegex(name)}\\s*:\\s*)[^;]+;`);
+    if (varRe.test(body)) {
+      body = body.replace(varRe, `$1${value};`);
+    } else {
+      body = body.replace(/([ \t]*)$/, `${loc.indent}${name}: ${value};
+$1`);
+    }
+  }
+  return base.slice(0, loc.bodyStart) + body + base.slice(loc.bodyEnd);
+};
+
+// src/lib/components.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
+var DEFAULT_SEGMENTS = ["components", "hooks", "lib"];
+var remap = (relFile, paths) => {
+  const idx = relFile.indexOf("/");
+  if (idx === -1) return relFile;
+  const head = relFile.slice(0, idx);
+  const tail = relFile.slice(idx + 1);
+  if (DEFAULT_SEGMENTS.includes(head)) {
+    const override = paths[head];
+    return `${override}/${tail}`;
+  }
+  return relFile;
+};
+var planComponentOps = (opts) => {
+  const ops = [];
+  for (const unit of opts.units) {
+    for (const relFile of unit.files) {
+      const sourceAbs = join3(opts.registry.root, relFile);
+      const mapped = remap(relFile, opts.paths);
+      const targetAbs = join3(opts.targetSrcDir, mapped);
+      ops.push({
+        target: targetAbs,
+        content: readFileSync4(sourceAbs, "utf8"),
+        label: mapped
+      });
+    }
+  }
+  return ops;
+};
+
+// src/lib/css-orchestrate.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join5, relative as relative3 } from "path";
+
+// src/lib/templates.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var HERE = dirname3(fileURLToPath2(import.meta.url));
+var TEMPLATES_DIR = (() => {
+  for (const depth of [0, 1, 2, 3]) {
+    const candidate = join4(HERE, ...Array(depth).fill(".."), "frameworks");
+    if (existsSync4(candidate)) return candidate;
+  }
+  return join4(HERE, "..", "frameworks");
+})();
+var truthy = (v) => Boolean(v);
+var resolveTemplatePath = (name) => {
+  const p3 = join4(TEMPLATES_DIR, name);
+  if (!existsSync4(p3)) {
+    throw new TemplateError(
+      "E_TEMPLATE_MISSING",
+      `Template not found: ${name} (looked in ${TEMPLATES_DIR}).`,
+      `This is a CLI packaging bug - please file an issue.`
+    );
+  }
+  return p3;
+};
+var loadTemplate = (name) => readFileSync5(resolveTemplatePath(name), "utf8");
+var renderTemplate = (name, vars) => {
+  let src = loadTemplate(name);
+  src = src.replace(
+    /\{\{#(if|unless)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}([\s\S]*?)\{\{\/\1\}\}\n?/g,
+    (_full, kind, key, body) => {
+      const keep = kind === "if" ? truthy(vars[key]) : !truthy(vars[key]);
+      return keep ? body : "";
+    }
+  );
+  src = src.replace(
+    /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g,
+    (_full, key) => {
+      if (!(key in vars)) {
+        throw new TemplateError(
+          "E_TEMPLATE_RENDER",
+          `Template ${name} references unknown variable {{${key}}}.`,
+          `This is a CLI bug - please file an issue.`
+        );
+      }
+      const v = vars[key];
+      return v === void 0 || v === false ? "" : String(v);
+    }
+  );
+  return src;
+};
+
+// src/frameworks/shared.ts
+import { posix as posix2, sep as sep2 } from "path";
+
+// src/lib/postcss-plugins.ts
+var renderPluginChain = (opts) => {
+  const normalizeRel = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+  const rel = (...parts) => `./${parts.map(normalizeRel).filter(Boolean).join("/").replace(/\/+/g, "/")}`;
+  const srcDir = normalizeRel(opts.srcDir);
+  const stylesRel = normalizeRel(opts.stylesRel);
+  const stylesDir = rel(srcDir, stylesRel);
+  const mediaSource = `${stylesDir}/media.css`;
+  const tokenSource = `${stylesDir}/app.css`;
+  const generatedPath = `${stylesDir}/utilities.gen.css`;
+  const extensions = opts.contentExtensions && opts.contentExtensions.length > 0 ? opts.contentExtensions : ["tsx", "ts", "jsx", "js"];
+  const contentGlob = rel(srcDir, "**", `*.{${extensions.join(",")}}`);
+  const imports = [
+    `import postcssPresetEnv from "postcss-preset-env";`,
+    `import postcssGlobalData from "@csstools/postcss-global-data";`,
+    `import autoprefixer from "autoprefixer";`
+  ];
+  if (opts.withTokenUtilities) {
+    imports.push(`import tokenUtilities from "postcss-token-utilities";`);
+  }
+  const invocations = [];
+  invocations.push(
+    `postcssGlobalData({
+  files: ["${mediaSource}"],
+}),`
+  );
+  if (opts.withTokenUtilities) {
+    invocations.push(
+      `tokenUtilities({
+  designTokenSource: "${tokenSource}",
+  customMediaSource: "${mediaSource}",
+  content: ["${contentGlob}"],
+  classMatcher: ["optionClassName"],
+  generated: {
+    path: "${generatedPath}",
+  },
+}),`
+    );
+  }
+  invocations.push(
+    `postcssPresetEnv({
+  stage: 2,
+  preserve: true,
+  features: {
+    "nesting-rules": true,
+    "custom-media-queries": true,
+    "color-mix": true,
+  },
+}),`
+  );
+  invocations.push(`autoprefixer(),`);
+  return { imports, invocations };
+};
+var indent2 = (src, level = 1) => {
+  const pad = "  ".repeat(level);
+  return src.split("\n").map((line) => line.length ? pad + line : line).join("\n");
+};
+
+// src/frameworks/shared.ts
+var toPosix2 = (p3) => p3.split(sep2).join(posix2.sep);
+var renderPluginStrings = (opts, context, indentInvocations) => {
+  const chain = renderPluginChain({
+    withTokenUtilities: opts.withTokenUtilities,
+    srcDir: context.srcDir,
+    stylesRel: context.stylesRel,
+    contentExtensions: context.contentExtensions
+  });
+  const imports = chain.imports.join("\n");
+  const invocations = chain.invocations.map((inv) => indent2(inv, indentInvocations)).join("\n");
+  return { imports, invocations };
+};
+var toCommonJsImports = (imports) => imports.split("\n").map((line) => {
+  const trimmed = line.trim();
+  const m = trimmed.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\s+"([^"]+)";?$/);
+  if (!m) return line;
+  return `const ${m[1]} = require("${m[2]}");`;
+}).join("\n");
+var renderInlinePlan = (args) => {
+  const chain = renderPluginChain({
+    withTokenUtilities: args.options.withTokenUtilities,
+    srcDir: args.context.srcDir,
+    stylesRel: args.context.stylesRel,
+    contentExtensions: args.context.contentExtensions
+  });
+  const snippetInvocations = chain.invocations.map((inv) => indent2(inv, args.snippetInvocationIndent)).join("\n");
+  return {
+    target: args.target,
+    imports: chain.imports,
+    invocations: chain.invocations,
+    manualSnippet: {
+      title: args.title,
+      content: renderTemplate(args.templatePath, {
+        imports: chain.imports.join("\n"),
+        invocations: snippetInvocations,
+        ...args.extraTemplateVars ?? {}
+      })
+    }
+  };
+};
+
+// src/frameworks/vite-react/index.ts
+var renderViteReactCssConfig = (input, context) => {
+  const files = [];
+  const snippets = [];
+  if (input.placement === "inline") {
+    return {
+      files,
+      snippets,
+      inline: renderInlinePlan({
+        target: "vite",
+        title: "Merge this into your existing vite.config.ts",
+        templatePath: "vite-react/vite-inline.snippet.md",
+        context: context.pluginCtx,
+        options: input.options,
+        snippetInvocationIndent: 2,
+        extraTemplateVars: { pretty: input.options.prettyCssModuleNames }
+      })
+    };
+  }
+  if (input.viteConfigExists) {
+    const inline = renderInlinePlan({
+      target: "vite",
+      title: "Optional: move the PostCSS chain into vite.config.ts",
+      templatePath: "vite-react/vite-inline.snippet.md",
+      context: context.pluginCtx,
+      options: input.options,
+      snippetInvocationIndent: 2,
+      extraTemplateVars: { pretty: input.options.prettyCssModuleNames }
+    });
+    snippets.push(inline.manualSnippet);
+    const pc7 = renderPluginStrings(input.options, context.pluginCtx, 2);
+    files.push({
+      filename: "postcss.config.ts",
+      content: renderTemplate("vite-react/postcss.config.ts.template", {
+        imports: pc7.imports,
+        invocations: pc7.invocations
+      }),
+      label: "postcss.config.ts"
+    });
+    return { files, snippets };
+  }
+  const { imports, invocations } = renderPluginStrings(
+    input.options,
+    context.pluginCtx,
+    4
+  );
+  files.push({
+    filename: "vite.config.ts",
+    content: renderTemplate("vite-react/vite.config.ts.template", {
+      imports,
+      invocations,
+      alias: input.alias,
+      srcDir: context.posixSrc,
+      pretty: input.options.prettyCssModuleNames
+    }),
+    label: "vite.config.ts"
+  });
+  return { files, snippets };
+};
+
+// src/frameworks/next/index.ts
+var renderNextCssConfig = (input, context) => {
+  const files = [];
+  const snippets = [];
+  const { imports: esmImports, invocations } = renderPluginStrings(
+    input.options,
+    context.pluginCtx,
+    2
+  );
+  const imports = toCommonJsImports(esmImports);
+  files.push({
+    filename: "postcss.config.js",
+    content: renderTemplate("next/postcss.config.js.template", {
+      imports,
+      invocations
+    }),
+    label: "postcss.config.js"
+  });
+  snippets.push({
+    title: "Wire globals.css into app/layout.tsx",
+    content: renderTemplate("next/layout-import.snippet.md", {
+      srcDir: context.posixSrc,
+      stylesRel: context.posixStyles,
+      utilities: input.options.withTokenUtilities
+    })
+  });
+  snippets.push({
+    title: "Ensure next.config.* transpiles @aplance-ui/core",
+    content: renderTemplate("next/next.config.snippet.md", {})
+  });
+  return { files, snippets };
+};
+
+// src/frameworks/tanstack-start/index.ts
+var renderTanstackStartCssConfig = (input, context) => {
+  const files = [];
+  const snippets = [];
+  if (input.placement === "inline") {
+    return {
+      files,
+      snippets,
+      inline: renderInlinePlan({
+        target: "tanstack-start",
+        title: "Merge this into app.config.ts (vite block)",
+        templatePath: "tanstack-start/vite-inline.snippet.md",
+        context: context.pluginCtx,
+        options: input.options,
+        snippetInvocationIndent: 4
+      })
+    };
+  }
+  const { imports, invocations } = renderPluginStrings(
+    input.options,
+    context.pluginCtx,
+    2
+  );
+  files.push({
+    filename: "postcss.config.ts",
+    content: renderTemplate("tanstack-start/postcss.config.ts.template", {
+      imports,
+      invocations
+    }),
+    label: "postcss.config.ts"
+  });
+  const inline = renderInlinePlan({
+    target: "tanstack-start",
+    title: "Optional: move the PostCSS chain into app.config.ts",
+    templatePath: "tanstack-start/vite-inline.snippet.md",
+    context: context.pluginCtx,
+    options: input.options,
+    snippetInvocationIndent: 4
+  });
+  snippets.push(inline.manualSnippet);
+  return { files, snippets };
+};
+
+// src/frameworks/astro/index.ts
+var ASTRO_PLUGIN_CONTEXT = {
+  contentExtensions: ["tsx", "ts", "jsx", "js", "astro"]
+};
+var renderAstroCssConfig = (input, context) => {
+  const files = [];
+  const snippets = [];
+  snippets.push({
+    title: "Wire the React integration + global styles",
+    content: renderTemplate("astro/astro.config.snippet.md", {
+      stylesRel: context.posixStyles,
+      utilities: input.options.withTokenUtilities
+    })
+  });
+  if (input.placement === "inline") {
+    return {
+      files,
+      snippets,
+      inline: renderInlinePlan({
+        target: "astro",
+        title: "Merge this into astro.config.* (vite block)",
+        templatePath: "astro/vite-inline.snippet.md",
+        context: {
+          ...context.pluginCtx,
+          ...ASTRO_PLUGIN_CONTEXT
+        },
+        options: input.options,
+        snippetInvocationIndent: 6
+      })
+    };
+  }
+  const { imports, invocations } = renderPluginStrings(
+    input.options,
+    {
+      ...context.pluginCtx,
+      ...ASTRO_PLUGIN_CONTEXT
+    },
+    2
+  );
+  files.push({
+    filename: "postcss.config.mjs",
+    content: renderTemplate("astro/postcss.config.mjs.template", {
+      imports,
+      invocations
+    }),
+    label: "postcss.config.mjs"
+  });
+  return { files, snippets };
+};
+
+// src/frameworks/electron-vite/index.ts
+var renderElectronViteCssConfig = (input, context) => {
+  const files = [];
+  const snippets = [];
+  if (input.placement === "inline") {
+    return {
+      files,
+      snippets,
+      inline: renderInlinePlan({
+        target: "electron-vite",
+        title: "Merge this into electron.vite.config.ts (renderer block)",
+        templatePath: "electron-vite/vite.config.snippet.md",
+        context: context.pluginCtx,
+        options: input.options,
+        snippetInvocationIndent: 5,
+        extraTemplateVars: {
+          alias: input.alias,
+          srcDir: context.posixSrc,
+          stylesRel: context.posixStyles,
+          utilities: input.options.withTokenUtilities
+        }
+      })
+    };
+  }
+  const { imports, invocations } = renderPluginStrings(
+    input.options,
+    context.pluginCtx,
+    2
+  );
+  files.push({
+    filename: "postcss.config.ts",
+    content: renderTemplate("vite-react/postcss.config.ts.template", {
+      imports,
+      invocations
+    }),
+    label: "postcss.config.ts"
+  });
+  return { files, snippets };
+};
+
+// src/frameworks/renderers.ts
+var FRAMEWORK_CSS_RENDERERS = {
+  "vite-react": renderViteReactCssConfig,
+  next: renderNextCssConfig,
+  "tanstack-start": renderTanstackStartCssConfig,
+  astro: renderAstroCssConfig,
+  "electron-vite": renderElectronViteCssConfig
+};
+
+// src/lib/css-config.ts
+var renderCssConfig = (input) => {
+  const posixSrc = toPosix2(input.srcDir);
+  const posixStyles = toPosix2(input.stylesRel);
+  const context = {
+    posixSrc,
+    posixStyles,
+    pluginCtx: {
+      srcDir: posixSrc,
+      stylesRel: posixStyles
+    }
+  };
+  const renderer = FRAMEWORK_CSS_RENDERERS[input.template];
+  if (!renderer) {
+    const exhaustive = input.template;
+    throw new TemplateError(
+      "E_UNKNOWN_TEMPLATE",
+      `Unknown framework template: ${String(exhaustive)}.`
+    );
+  }
+  return renderer(input, context);
+};
+
+// src/lib/css-inline.ts
+var TOP_LEVEL_OBJECT_PATTERNS = [
+  /^[ \t]*export\s+default\s+defineConfig\s*\(\s*\{/m,
+  /^[ \t]*defineConfig\s*\(\s*\{/m,
+  /^[ \t]*export\s+default\s*\{/m
+];
+var extractModuleSpecifier = (line) => {
+  const fromMatch = line.match(/from\s+"([^"]+)"/) ?? line.match(/from\s+'([^']+)'/);
+  if (fromMatch?.[1]) return fromMatch[1];
+  const requireMatch = line.match(/require\(\s*"([^"]+)"\s*\)/) ?? line.match(/require\(\s*'([^']+)'\s*\)/);
+  return requireMatch?.[1] ?? null;
+};
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var ensureImports = (source, imports) => {
+  const missing = imports.filter((line) => {
+    const moduleName = extractModuleSpecifier(line);
+    if (moduleName) {
+      const modulePattern = new RegExp(
+        `from\\s+["']${escapeRegExp(moduleName)}["']|require\\(\\s*["']${escapeRegExp(moduleName)}["']\\s*\\)`
+      );
+      return !modulePattern.test(source);
+    }
+    return !source.includes(line.trim());
+  });
+  if (missing.length === 0) return source;
+  const importMatches = Array.from(source.matchAll(/^import[^\n]*$/gm));
+  if (importMatches.length === 0) {
+    return `${missing.join("\n")}
+
+${source}`;
+  }
+  const lastImport = importMatches[importMatches.length - 1];
+  const insertAt = lastImport.index + lastImport[0].length;
+  return `${source.slice(0, insertAt)}
+${missing.join("\n")}${source.slice(insertAt)}`;
+};
+var renderIndentedBlock = (source, indent3) => source.split("\n").map((line) => line.length > 0 ? `${indent3}${line}` : line).join("\n");
+var buildCssPostcssBlock = (invocations, cssIndent) => {
+  const postcssIndent = `${cssIndent}  `;
+  const pluginsIndent = `${postcssIndent}  `;
+  const itemIndent = `${pluginsIndent}  `;
+  const plugins = invocations.map((invocation) => renderIndentedBlock(invocation, itemIndent)).join("\n");
+  return [
+    `${cssIndent}css: {`,
+    `${postcssIndent}postcss: {`,
+    `${pluginsIndent}plugins: [`,
+    plugins,
+    `${pluginsIndent}],`,
+    `${postcssIndent}},`,
+    `${cssIndent}},`
+  ].join("\n");
+};
+var buildViteBlock = (invocations, viteIndent) => [
+  `${viteIndent}vite: {`,
+  buildCssPostcssBlock(invocations, `${viteIndent}  `),
+  `${viteIndent}},`
+].join("\n");
+var insertIntoTopLevelObject = (source, blockFactory) => {
+  for (const pattern of TOP_LEVEL_OBJECT_PATTERNS) {
+    const match = pattern.exec(source);
+    if (!match) continue;
+    const lineIndent = (match[0].match(/^[ \t]*/) ?? [""])[0];
+    const insertAt = match.index + match[0].length;
+    const block = blockFactory(`${lineIndent}  `);
+    return `${source.slice(0, insertAt)}
+${block}${source.slice(insertAt)}`;
+  }
+  return null;
+};
+var findNamedObjectProperty = (source, propertyName) => {
+  const pattern = new RegExp(`(^[ \\t]*)${escapeRegExp(propertyName)}\\s*:\\s*\\{`, "m");
+  const match = pattern.exec(source);
+  if (!match) return null;
+  return {
+    insertAt: match.index + match[0].length,
+    childIndent: `${match[1] ?? ""}  `
+  };
+};
+var insertIntoNamedObjectProperty = (source, propertyName, blockFactory) => {
+  const found = findNamedObjectProperty(source, propertyName);
+  if (!found) return null;
+  const block = blockFactory(found.childIndent);
+  return `${source.slice(0, found.insertAt)}
+${block}${source.slice(found.insertAt)}`;
+};
+var hasPostcssConfig = (source) => /\bpostcss\s*:/.test(source);
+var applyViteInline = (source, invocations) => insertIntoTopLevelObject(
+  source,
+  (childIndent) => buildCssPostcssBlock(invocations, childIndent)
+);
+var applyVitePropertyInline = (source, invocations) => {
+  const inVite = insertIntoNamedObjectProperty(
+    source,
+    "vite",
+    (childIndent) => buildCssPostcssBlock(invocations, childIndent)
+  );
+  if (inVite) return inVite;
+  return insertIntoTopLevelObject(
+    source,
+    (childIndent) => buildViteBlock(invocations, childIndent)
+  );
+};
+var applyElectronRendererInline = (source, invocations) => insertIntoNamedObjectProperty(
+  source,
+  "renderer",
+  (childIndent) => buildCssPostcssBlock(invocations, childIndent)
+);
+var applyInlineCssConfig = (input) => {
+  if (hasPostcssConfig(input.source)) {
+    return {
+      ok: false,
+      reason: "Config already contains a postcss block."
+    };
+  }
+  const withImports = ensureImports(input.source, input.plan.imports);
+  const patched = (() => {
+    switch (input.plan.target) {
+      case "vite":
+        return applyViteInline(withImports, input.plan.invocations);
+      case "astro":
+      case "tanstack-start":
+        return applyVitePropertyInline(withImports, input.plan.invocations);
+      case "electron-vite":
+        return applyElectronRendererInline(withImports, input.plan.invocations);
+      default:
+        return null;
+    }
+  })();
+  if (!patched) {
+    return {
+      ok: false,
+      reason: `Could not locate a writable ${input.plan.target} config object.`
+    };
+  }
+  return { ok: true, content: patched };
+};
+
+// src/lib/css-orchestrate.ts
+var planCssConfigOps = (input) => {
+  const { cwd, cfg, placement, project } = input;
+  const ops = [];
+  const snippets = [];
+  const warnings = [];
+  const render = (p3) => renderCssConfig({
+    template: cfg.template,
+    srcDir: cfg.srcDir,
+    alias: cfg.alias,
+    stylesRel: cfg.paths.styles,
+    options: {
+      withTokenUtilities: cfg.utilities.enabled,
+      prettyCssModuleNames: cfg.cssModules.pretty
+    },
+    placement: p3,
+    viteConfigExists: Boolean(project.viteConfigPath)
+  });
+  let result = render(placement.effective);
+  if (placement.effective === "inline" && result.inline) {
+    const hostPath = placement.hostPath;
+    if (!hostPath || !existsSync5(hostPath)) {
+      warnings.push("Inline host config not found at apply-time. Falling back to standalone PostCSS config.");
+      result = render("file");
+    } else {
+      const inline = applyInlineCssConfig({
+        source: readFileSync6(hostPath, "utf8"),
+        plan: result.inline
+      });
+      if (inline.ok && inline.content) {
+        ops.push({
+          target: hostPath,
+          content: inline.content,
+          label: relative3(cwd, hostPath) || hostPath
+        });
+        snippets.push(...result.snippets);
+        result = { files: [], snippets: [] };
+      } else {
+        warnings.push(`Could not inline CSS plugins (${inline.reason ?? "unknown reason"}). Falling back to standalone PostCSS config.`);
+        snippets.push(result.inline.manualSnippet);
+        const fallback = render("file");
+        result = {
+          files: fallback.files,
+          snippets: [...result.snippets, ...fallback.snippets]
+        };
+      }
+    }
+  }
+  for (const file of result.files) {
+    ops.push({
+      target: join5(cwd, file.filename),
+      content: file.content,
+      label: file.label
+    });
+  }
+  snippets.push(...result.snippets);
+  return { ops, snippets, warnings };
+};
+
+// src/lib/detect.ts
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { join as join6 } from "path";
+var VITE_CONFIG_NAMES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+var NEXT_CONFIG_NAMES = [
+  "next.config.ts",
+  "next.config.js",
+  "next.config.mjs"
+];
+var ASTRO_CONFIG_NAMES = [
+  "astro.config.ts",
+  "astro.config.js",
+  "astro.config.mjs"
+];
+var ELECTRON_VITE_CONFIG_NAMES = [
+  "electron.vite.config.ts",
+  "electron.vite.config.js",
+  "electron.vite.config.mjs"
+];
+var TANSTACK_APP_CONFIG_NAMES = [
+  "app.config.ts",
+  "app.config.mts",
+  "app.config.js",
+  "app.config.mjs"
+];
+var firstExisting = (cwd, names) => {
+  for (const name of names) {
+    const p3 = join6(cwd, name);
+    if (existsSync6(p3)) return p3;
+  }
+  return null;
+};
+var readDeclaredDeps = (packageJsonPath) => {
+  try {
+    const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+    return /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {}),
+      ...Object.keys(pkg.peerDependencies ?? {})
+    ]);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+};
+var detectProject = (cwd) => {
+  const packageJsonPath = existsSync6(join6(cwd, "package.json")) ? join6(cwd, "package.json") : null;
+  const declaredDeps = packageJsonPath ? readDeclaredDeps(packageJsonPath) : /* @__PURE__ */ new Set();
+  const viteConfigPath = firstExisting(cwd, VITE_CONFIG_NAMES);
+  const nextConfigPath = firstExisting(cwd, NEXT_CONFIG_NAMES);
+  const astroConfigPath = firstExisting(cwd, ASTRO_CONFIG_NAMES);
+  const electronViteConfigPath = firstExisting(cwd, ELECTRON_VITE_CONFIG_NAMES);
+  const tanstackConfigPath = firstExisting(cwd, TANSTACK_APP_CONFIG_NAMES);
+  return {
+    isVite: Boolean(viteConfigPath) || declaredDeps.has("vite"),
+    viteConfigPath,
+    isNext: Boolean(nextConfigPath) || declaredDeps.has("next"),
+    nextConfigPath,
+    isAstro: Boolean(astroConfigPath) || declaredDeps.has("astro"),
+    astroConfigPath,
+    isTanstackStart: Boolean(tanstackConfigPath) || declaredDeps.has("@tanstack/start") || declaredDeps.has("@tanstack/react-start"),
+    tanstackConfigPath,
+    isElectronVite: Boolean(electronViteConfigPath) || declaredDeps.has("electron-vite"),
+    electronViteConfigPath,
+    packageJsonPath,
+    declaredDeps
+  };
+};
+var suggestTemplate = (p3) => {
+  if (p3.isElectronVite) return "electron-vite";
+  if (p3.isNext) return "next";
+  if (p3.isAstro) return "astro";
+  if (p3.isTanstackStart) return "tanstack-start";
+  if (p3.isVite) return "vite-react";
+  return null;
+};
+var describeProject = (p3) => {
+  const parts = [];
+  if (p3.isElectronVite) parts.push("electron-vite");
+  else if (p3.isNext) parts.push("Next.js");
+  else if (p3.isAstro) parts.push("Astro");
+  else if (p3.isTanstackStart) parts.push("TanStack Start");
+  else if (p3.isVite) parts.push("Vite");
+  return parts.length ? parts.join(", ") : "unknown framework";
+};
+
+// src/frameworks/meta.ts
+var FRAMEWORK_META = {
+  "vite-react": {
+    label: "Vite + React",
+    supportsPrettyCssModuleNames: true,
+    resolveInlineHostPath: (project) => project.viteConfigPath
+  },
+  next: {
+    label: "Next.js (App Router)",
+    supportsPrettyCssModuleNames: false,
+    resolveInlineHostPath: () => null
+  },
+  "tanstack-start": {
+    label: "TanStack Start",
+    supportsPrettyCssModuleNames: true,
+    resolveInlineHostPath: (project) => project.tanstackConfigPath
+  },
+  astro: {
+    label: "Astro",
+    supportsPrettyCssModuleNames: false,
+    resolveInlineHostPath: (project) => project.astroConfigPath
+  },
+  "electron-vite": {
+    label: "Electron + Vite",
+    supportsPrettyCssModuleNames: true,
+    resolveInlineHostPath: (project) => project.electronViteConfigPath
+  }
+};
+var getFrameworkLabel = (template) => FRAMEWORK_META[template].label;
+var supportsPrettyCssModules = (template) => FRAMEWORK_META[template].supportsPrettyCssModuleNames;
+var getInlineHostPath = (template, project) => FRAMEWORK_META[template].resolveInlineHostPath(project);
+
+// src/lib/config.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
+var CONFIG_FILE_NAME = "components.json";
+var CONFIG_SCHEMA_URL = "https://aplance-ui.dev/schema.json";
+var SUPPORTED_TEMPLATES = [
+  "vite-react",
+  "next",
+  "tanstack-start",
+  "astro",
+  "electron-vite"
+];
+var CSS_CONFIG_PLACEMENTS = ["auto", "inline", "file"];
+var DEFAULT_PATHS = {
+  styles: "styles",
+  components: "components",
+  hooks: "hooks",
+  lib: "lib"
+};
+var TEMPLATE_DEFAULT_SRCDIR = {
+  "vite-react": "src",
+  next: "src",
+  "tanstack-start": "src",
+  astro: "src",
+  "electron-vite": "src/renderer/src"
+};
+var makeDefaultConfig = (opts) => ({
+  $schema: CONFIG_SCHEMA_URL,
+  template: opts.template,
+  srcDir: opts.srcDir ?? TEMPLATE_DEFAULT_SRCDIR[opts.template],
+  alias: opts.alias ?? "@",
+  theme: {
+    color: opts.color ?? "default",
+    radius: opts.radius ?? "default",
+    spacing: opts.spacing ?? "default"
+  },
+  paths: { ...DEFAULT_PATHS },
+  cssModules: { pretty: opts.pretty ?? false },
+  utilities: { enabled: opts.utilities ?? false },
+  cssConfig: { placement: opts.cssConfigPlacement ?? "auto" }
+});
+var configPath = (cwd) => join7(cwd, CONFIG_FILE_NAME);
+var configExists = (cwd) => existsSync7(configPath(cwd));
+var loadConfig = (cwd) => {
+  const p3 = configPath(cwd);
+  if (!existsSync7(p3)) {
+    throw new ConfigError(
+      "E_CONFIG_MISSING",
+      `No ${CONFIG_FILE_NAME} found at ${p3}.`,
+      `Run \`aplance-ui init\` once to create it.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(p3, "utf8"));
+  } catch (err) {
+    throw new ConfigError(
+      "E_CONFIG_INVALID",
+      `Failed to parse ${p3}: ${err.message}`,
+      `Delete ${CONFIG_FILE_NAME} and re-run \`aplance-ui init\` to recreate it.`
+    );
+  }
+  return validateConfig(parsed, p3);
+};
+var resolvePaths = (cwd, cfg) => {
+  const srcDir = join7(cwd, cfg.srcDir);
+  return {
+    srcDir,
+    stylesDir: join7(srcDir, cfg.paths.styles),
+    componentsDir: join7(srcDir, cfg.paths.components),
+    hooksDir: join7(srcDir, cfg.paths.hooks),
+    libDir: join7(srcDir, cfg.paths.lib)
+  };
+};
+var normalizeTheme = (raw) => {
+  if (typeof raw === "string") {
+    return { color: raw, radius: "default", spacing: "default" };
+  }
+  if (raw && typeof raw === "object") {
+    const t = raw;
+    return {
+      color: typeof t.color === "string" ? t.color : "default",
+      radius: typeof t.radius === "string" ? t.radius : "default",
+      spacing: typeof t.spacing === "string" ? t.spacing : "default"
+    };
+  }
+  return { color: "default", radius: "default", spacing: "default" };
+};
+var validateConfig = (raw, file) => {
+  if (!raw || typeof raw !== "object") {
+    throw new ConfigError(
+      "E_CONFIG_INVALID",
+      `${file} is not a JSON object.`
+    );
+  }
+  const c = raw;
+  const must = (cond, msg) => {
+    if (!cond) throw new ConfigError("E_CONFIG_INVALID", `${file}: ${msg}`);
+  };
+  must(typeof c.template === "string", `"template" must be a string.`);
+  must(
+    SUPPORTED_TEMPLATES.includes(c.template),
+    `"template" must be one of: ${SUPPORTED_TEMPLATES.join(", ")} (got "${c.template}").`
+  );
+  must(typeof c.srcDir === "string" && c.srcDir.length > 0, `"srcDir" must be a non-empty string.`);
+  must(typeof c.alias === "string" && c.alias.length > 0, `"alias" must be a non-empty string.`);
+  must(c.paths && typeof c.paths === "object", `"paths" must be an object.`);
+  const ps = c.paths;
+  for (const k of ["styles", "components", "hooks", "lib"]) {
+    must(typeof ps[k] === "string" && ps[k].length > 0, `"paths.${k}" must be a non-empty string.`);
+  }
+  must(c.cssModules && typeof c.cssModules === "object", `"cssModules" must be an object.`);
+  must(typeof c.cssModules.pretty === "boolean", `"cssModules.pretty" must be a boolean.`);
+  must(c.utilities && typeof c.utilities === "object", `"utilities" must be an object.`);
+  must(typeof c.utilities.enabled === "boolean", `"utilities.enabled" must be a boolean.`);
+  if (c.cssConfig !== void 0) {
+    must(c.cssConfig && typeof c.cssConfig === "object", `"cssConfig" must be an object.`);
+    must(
+      CSS_CONFIG_PLACEMENTS.includes(c.cssConfig.placement),
+      `"cssConfig.placement" must be one of: ${CSS_CONFIG_PLACEMENTS.join(", ")} (got "${String(c.cssConfig.placement)}").`
+    );
+  }
+  return {
+    $schema: c.$schema ?? CONFIG_SCHEMA_URL,
+    template: c.template,
+    srcDir: c.srcDir,
+    alias: c.alias,
+    theme: normalizeTheme(c.theme),
+    paths: ps,
+    cssModules: { pretty: c.cssModules.pretty },
+    utilities: { enabled: c.utilities.enabled },
+    cssConfig: {
+      placement: c.cssConfig?.placement ?? "auto"
+    }
+  };
+};
+
+// src/lib/units.ts
+var BUCKETS = [
+  { label: "ui", predicate: (u) => u.kind === "component" && u.group === "ui" },
+  { label: "primitive", predicate: (u) => u.kind === "component" && u.group === "primitives" },
+  { label: "hook", predicate: (u) => u.kind === "hook" },
+  { label: "lib", predicate: (u) => u.kind === "lib" }
+];
+var groupedUnitOptions = (units) => BUCKETS.flatMap(
+  ({ label, predicate }) => units.filter(predicate).map((u) => ({
+    value: u.name,
+    label: u.name,
+    hint: `${label}${u.deps.length ? ` \xB7 deps: ${u.deps.join(", ")}` : ""}`
+  }))
+);
+
+// src/lib/installer.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var detectPackageManager = (cwd) => {
+  const pkgJsonPath = join8(cwd, "package.json");
+  if (existsSync8(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync9(pkgJsonPath, "utf8"));
+      if (typeof pkg.packageManager === "string") {
+        const name = pkg.packageManager.split("@")[0].trim();
+        if (PACKAGE_MANAGERS.includes(name)) {
+          return name;
+        }
+      }
+    } catch {
+    }
+  }
+  if (existsSync8(join8(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync8(join8(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync8(join8(cwd, "bun.lockb"))) return "bun";
+  if (existsSync8(join8(cwd, "bun.lock"))) return "bun";
+  if (existsSync8(join8(cwd, "package-lock.json"))) return "npm";
+  return "npm";
+};
+var computeDependencyPlan = (input) => {
+  const { registry, units, cfg, project } = input;
+  const meta = registry.installMeta;
+  const dependencies = { ...meta.baseDependencies };
+  const devDependencies = { ...meta.baseDevDependencies };
+  if (cfg.utilities.enabled) {
+    Object.assign(devDependencies, meta.utilitiesDevDependencies);
+  }
+  for (const unit of units) {
+    for (const pkg of unit.externalDeps) {
+      if (pkg in dependencies) continue;
+      const version = meta.packageVersions[pkg];
+      if (!version) continue;
+      dependencies[pkg] = version;
+    }
+  }
+  const skipped = [];
+  const filter = (bag) => {
+    for (const name of Object.keys(bag)) {
+      if (project.declaredDeps.has(name)) {
+        skipped.push({ name, reason: "already-declared" });
+        delete bag[name];
+      }
+    }
+  };
+  filter(dependencies);
+  filter(devDependencies);
+  return { dependencies, devDependencies, skipped };
+};
+var buildInstallCommands = (pm, plan) => {
+  const commands = [];
+  const runtimeSpecs = Object.entries(plan.dependencies).map(
+    ([name, v]) => `${name}@${v}`
+  );
+  const devSpecs = Object.entries(plan.devDependencies).map(
+    ([name, v]) => `${name}@${v}`
+  );
+  const runtimeArgs = installArgs(pm, runtimeSpecs, false);
+  const devArgs = installArgs(pm, devSpecs, true);
+  if (runtimeSpecs.length > 0) {
+    commands.push({
+      bin: pm,
+      args: runtimeArgs,
+      label: `${pm} ${runtimeArgs.join(" ")}`
+    });
+  }
+  if (devSpecs.length > 0) {
+    commands.push({
+      bin: pm,
+      args: devArgs,
+      label: `${pm} ${devArgs.join(" ")}`
+    });
+  }
+  return commands;
+};
+var installArgs = (pm, specs, dev) => {
+  switch (pm) {
+    case "npm":
+      return [
+        "install",
+        dev ? "--save-dev" : "--save",
+        "--no-fund",
+        "--no-audit",
+        ...specs
+      ];
+    case "pnpm":
+      return ["add", dev ? "--save-dev" : "", ...specs].filter(Boolean);
+    case "yarn":
+      return ["add", dev ? "--dev" : "", ...specs].filter(Boolean);
+    case "bun":
+      return ["add", dev ? "--dev" : "", ...specs].filter(Boolean);
+  }
+};
+var runInstall = async (commands, opts) => {
+  for (const cmd of commands) {
+    opts.onCommand?.(cmd);
+    await new Promise((resolve, reject) => {
+      const child = spawn(cmd.bin, cmd.args, {
+        cwd: opts.cwd,
+        stdio: "inherit",
+        env: { ...process.env, ...opts.env },
+        shell: process.platform === "win32"
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else
+          reject(
+            new Error(
+              `${cmd.label} exited with code ${code ?? "null"}. Aborting install.`
+            )
+          );
+      });
+    });
+  }
+};
+var describePlan = (plan) => {
+  const lines = [];
+  const rows = (bag) => Object.entries(bag).sort(([a], [b]) => a.localeCompare(b)).map(([name, v]) => `  ${name} ${v}`);
+  if (Object.keys(plan.dependencies).length) {
+    lines.push("dependencies:");
+    lines.push(...rows(plan.dependencies));
+  }
+  if (Object.keys(plan.devDependencies).length) {
+    if (lines.length) lines.push("");
+    lines.push("devDependencies:");
+    lines.push(...rows(plan.devDependencies));
+  }
+  if (plan.skipped.length) {
+    if (lines.length) lines.push("");
+    lines.push("already declared (kept as-is):");
+    lines.push(...plan.skipped.map((s) => `  ${s.name}`));
+  }
+  if (!lines.length) lines.push("nothing to install - all deps already declared.");
+  return lines.join("\n");
+};
+
+// src/commands/init.ts
+var resolveConflictMode = (opts) => {
+  if (opts.dryRun) return "dry-run";
+  if (opts.force) return "force";
+  return "prompt";
+};
+var resolveEffectivePlacement = (template, preference, project) => {
+  const hostPath = getInlineHostPath(template, project);
+  if (template === "next") {
+    return {
+      preference,
+      effective: "file",
+      hostPath: null,
+      fallbackReason: preference === "file" ? void 0 : "Next.js uses a standalone postcss.config.js in this CLI."
+    };
+  }
+  if (preference === "auto") {
+    return { preference, effective: "file", hostPath };
+  }
+  if (preference === "inline" && !hostPath) {
+    return {
+      preference,
+      effective: "file",
+      hostPath,
+      fallbackReason: "No inline config host was detected for this template; using standalone PostCSS config."
+    };
+  }
+  return { preference, effective: preference, hostPath };
+};
+var promptForConfig = async (opts, project, registry) => {
+  const suggestedTemplate = suggestTemplate(project);
+  const template = opts.template ? opts.template : opts.yes ? suggestedTemplate ?? "vite-react" : await select2({
+    message: "Which framework are you scaffolding for?",
+    options: SUPPORTED_TEMPLATES.map((t) => ({
+      value: t,
+      label: getFrameworkLabel(t) + (t === suggestedTemplate ? pc4.dim(" (detected)") : "")
+    })),
+    initialValue: suggestedTemplate ?? "vite-react"
+  });
+  const colorOptions = registry.themes.colors.map((t) => ({
+    value: t.id,
+    label: t.label,
+    hint: t.description
+  }));
+  const color = opts.color ? opts.color : opts.yes ? "default" : await select2({
+    message: "Pick a color palette",
+    options: colorOptions,
+    initialValue: "default"
+  });
+  const radiusOptions = registry.themes.radii.map((t) => ({
+    value: t.id,
+    label: t.label,
+    hint: t.description
+  }));
+  const radius = opts.radius ? opts.radius : opts.yes ? "default" : await select2({
+    message: "Pick a radius scale",
+    options: radiusOptions,
+    initialValue: "default"
+  });
+  const spacingOptions = registry.themes.spacing.map((t) => ({
+    value: t.id,
+    label: t.label,
+    hint: t.description
+  }));
+  const spacing = opts.spacing ? opts.spacing : opts.yes ? "default" : await select2({
+    message: "Pick a spacing scale",
+    options: spacingOptions,
+    initialValue: "default"
+  });
+  let pretty = opts.prettyCssModules ?? false;
+  if (!opts.yes && supportsPrettyCssModules(template) && opts.prettyCssModules === void 0) {
+    pretty = await confirm2({
+      message: "Use human-readable CSS Modules class names? (great in devtools)",
+      initialValue: true
+    });
+  }
+  let utilities = opts.withUtilities ?? false;
+  if (!opts.yes && opts.withUtilities === void 0) {
+    utilities = await confirm2({
+      message: "Include postcss-token-utilities? (adds token-driven utility classes like p-4, bg-primary)",
+      initialValue: false
+    });
+  }
+  let placement = opts.cssConfigPlacement ?? "auto";
+  if (!opts.yes && opts.cssConfigPlacement === void 0 && template !== "next") {
+    const hostPath = getInlineHostPath(template, project);
+    const hostLabel = hostPath ? relative4(opts.cwd, hostPath) || hostPath : "none detected";
+    placement = await select2({
+      message: "How should CSS plugins be wired?",
+      options: CSS_CONFIG_PLACEMENTS.map((p3) => ({
+        value: p3,
+        label: p3,
+        hint: p3 === "auto" ? "recommended: standalone postcss.config.*" : p3 === "inline" ? `inject into ${hostLabel}` : "write a standalone postcss.config.*"
+      })),
+      initialValue: "auto"
+    });
+  }
+  return makeDefaultConfig({
+    template,
+    srcDir: opts.srcDir,
+    alias: opts.alias,
+    color,
+    radius,
+    spacing,
+    pretty,
+    utilities,
+    cssConfigPlacement: placement
+  });
+};
+var resolveConfig = async (opts, project, registry) => {
+  if (configExists(opts.cwd) && !opts.overwriteConfig) {
+    const cfg2 = loadConfig(opts.cwd);
+    if (opts.srcDir) cfg2.srcDir = opts.srcDir;
+    if (opts.alias) cfg2.alias = opts.alias;
+    if (opts.color) cfg2.theme.color = opts.color;
+    if (opts.radius) cfg2.theme.radius = opts.radius;
+    if (opts.spacing) cfg2.theme.spacing = opts.spacing;
+    if (opts.prettyCssModules !== void 0) cfg2.cssModules.pretty = opts.prettyCssModules;
+    if (opts.withUtilities !== void 0) cfg2.utilities.enabled = opts.withUtilities;
+    if (opts.cssConfigPlacement !== void 0) cfg2.cssConfig.placement = opts.cssConfigPlacement;
+    return { cfg: cfg2, existed: true };
+  }
+  const cfg = await promptForConfig(opts, project, registry);
+  return { cfg, existed: false };
+};
+var pickInitialComponents = async (opts, registry) => {
+  if (opts.all) return registry.units.map((u) => u.name);
+  if (opts.components && opts.components.length > 0) return opts.components;
+  if (opts.yes) return [];
+  const addNow = await confirm2({
+    message: "Copy components/hooks into your project now?",
+    initialValue: false
+  });
+  if (!addNow) return [];
+  return multiselect2({
+    message: `Select units to copy ${pc4.dim("(space to toggle, enter to confirm - leave empty to skip)")}`,
+    options: groupedUnitOptions(registry.units),
+    initialValues: [],
+    required: false
+  });
+};
+var runInit = async (opts) => {
+  headline("Scaffold tokens, theme, PostCSS, and optionally copy components.");
+  const registry = loadRegistry();
+  const project = detectProject(opts.cwd);
+  const { cfg, existed } = await resolveConfig(opts, project, registry);
+  const placement = resolveEffectivePlacement(
+    cfg.template,
+    cfg.cssConfig.placement,
+    project
+  );
+  const paths = resolvePaths(opts.cwd, cfg);
+  const detected = project.isVite || project.isNext || project.isAstro || project.isTanstackStart || project.isElectronVite;
+  const summary = [
+    `${pc4.bold("framework")}  ${cfg.template}`,
+    `${pc4.bold("color")}      ${cfg.theme.color}`,
+    `${pc4.bold("radius")}     ${cfg.theme.radius}`,
+    `${pc4.bold("spacing")}    ${cfg.theme.spacing}`,
+    `${pc4.bold("srcDir")}     ${cfg.srcDir}`,
+    `${pc4.bold("alias")}      ${cfg.alias}`,
+    `${pc4.bold("css")}        ${placement.preference} \u2192 ${placement.effective}`,
+    detected ? `${pc4.bold("detected")}   ${describeProject(project)}` : ""
+  ].filter(Boolean).join("\n");
+  note2(summary, "configuration");
+  if (placement.fallbackReason) warn(placement.fallbackReason);
+  const componentNames = await pickInitialComponents(opts, registry);
+  const units = componentNames.length ? resolveUnits(registry, componentNames) : [];
+  const ops = [];
+  const snippetsToPrint = [];
+  if (!existed || opts.overwriteConfig) {
+    ops.push({
+      target: join9(opts.cwd, "components.json"),
+      content: JSON.stringify(cfg, null, 2) + "\n",
+      label: "components.json"
+    });
+  }
+  if (!opts.skipStyles) {
+    ops.push(
+      ...planStylesOps({
+        registry,
+        targetStylesDir: paths.stylesDir,
+        color: cfg.theme.color,
+        radius: cfg.theme.radius,
+        spacing: cfg.theme.spacing
+      })
+    );
+  }
+  if (cfg.utilities.enabled) {
+    ops.push(planUtilitiesGitignoreOp({ targetStylesDir: paths.stylesDir }));
+  }
+  if (!opts.skipCssConfig) {
+    const css = planCssConfigOps({ cwd: opts.cwd, cfg, placement, project });
+    ops.push(...css.ops);
+    snippetsToPrint.push(...css.snippets);
+    for (const w of css.warnings) warn(w);
+  }
+  if (units.length > 0) {
+    ops.push(
+      ...planComponentOps({
+        registry,
+        targetSrcDir: paths.srcDir,
+        units,
+        paths: cfg.paths
+      })
+    );
+    info(`planned ${units.length} unit${units.length === 1 ? "" : "s"} to copy`);
+  }
+  step("Writing files\u2026");
+  const result = await applyFileOps(ops, {
+    cwd: opts.cwd,
+    mode: resolveConflictMode(opts)
+  });
+  const summaryLine = `${result.written} written \xB7 ${result.skipped} skipped \xB7 ${result.unchanged} unchanged`;
+  const plan = computeDependencyPlan({ registry, units, cfg, project });
+  const pm = opts.packageManager ?? detectPackageManager(opts.cwd);
+  const installCommands = buildInstallCommands(pm, plan);
+  const hasWork = installCommands.length > 0;
+  if (opts.dryRun) {
+    note2(summaryLine, "dry run");
+    if (hasWork) {
+      note2(
+        [
+          describePlan(plan),
+          "",
+          `would run with ${pm}:`,
+          ...installCommands.map((c) => `  ${c.label}`)
+        ].join("\n"),
+        "dry run \xB7 install"
+      );
+    }
+    goodbye("Preview only - no files were touched.");
+    return;
+  }
+  let willInstall;
+  if (!hasWork) {
+    willInstall = false;
+  } else if (opts.install === false) {
+    willInstall = false;
+  } else if (opts.install === true || opts.yes) {
+    willInstall = true;
+  } else {
+    note2(describePlan(plan), `install with ${pm}`);
+    willInstall = await confirm2({
+      message: `Run ${pm} now to install the dependencies above?`,
+      initialValue: true
+    });
+  }
+  if (willInstall) {
+    step(`Installing dependencies with ${pm}\u2026`);
+    await runInstall(installCommands, {
+      cwd: opts.cwd,
+      onCommand: (cmd) => logger.action(`$ ${cmd.label}`)
+    });
+    logger.ok(
+      `installed ${Object.keys(plan.dependencies).length} runtime + ${Object.keys(plan.devDependencies).length} dev dependenc${Object.keys(plan.dependencies).length + Object.keys(plan.devDependencies).length === 1 ? "y" : "ies"}`
+    );
+  } else if (hasWork) {
+    note2(
+      [
+        describePlan(plan),
+        "",
+        "run:",
+        ...installCommands.map((c) => `  ${c.label}`)
+      ].join("\n"),
+      `manual install (skipped)`
+    );
+  }
+  const steps = [
+    `${pc4.cyan("1")}  ${pc4.bold("Import styles once at your app entry")}
+    import "./${cfg.paths.styles}/globals.css";`
+  ];
+  let stepIdx = 2;
+  for (const snippet of snippetsToPrint) {
+    steps.push(`${pc4.cyan(String(stepIdx++))}  ${pc4.bold(snippet.title)}
+${snippet.content.split("\n").map((l) => "    " + l).join("\n")}`);
+  }
+  steps.push(
+    `${pc4.cyan(String(stepIdx++))}  ${pc4.bold("Add more components anytime")}
+    npx aplance-ui add <name>     ${pc4.dim("# e.g. button modal tooltip")}
+    npx aplance-ui add             ${pc4.dim("# interactive multi-select")}
+    npx aplance-ui list            ${pc4.dim("# see everything available")}`
+  );
+  note2(steps.join("\n\n"), "next steps");
+  logger.info(summaryLine);
+  goodbye("All set.");
+};
+
+// src/commands/add.ts
+import pc5 from "picocolors";
+var resolveConflictMode2 = (opts) => {
+  if (opts.dryRun) return "dry-run";
+  if (opts.force) return "force";
+  return "prompt";
+};
+var runAdd = async (opts) => {
+  headline("Add components/hooks/utilities from the registry.");
+  const cfg = loadConfig(opts.cwd);
+  const paths = resolvePaths(opts.cwd, cfg);
+  const registry = loadRegistry();
+  let names = opts.names;
+  if (opts.all) names = registry.units.map((u) => u.name);
+  if (names.length === 0) {
+    if (opts.yes) {
+      goodbye("Nothing to add. Pass unit names, --all, or run without --yes for interactive mode.");
+      return;
+    }
+    names = await pickUnits(registry.units);
+    if (names.length === 0) {
+      goodbye("Nothing selected.");
+      return;
+    }
+  }
+  const units = resolveUnits(registry, names);
+  const depsAdded = units.filter((u) => !names.includes(u.name));
+  if (depsAdded.length > 0) {
+    note2(
+      depsAdded.map((u) => `${pc5.dim("+")} ${u.name} ${pc5.dim("(dep)")}`).join("\n"),
+      `transitive dependencies (${depsAdded.length})`
+    );
+  }
+  const ops = planComponentOps({
+    registry,
+    targetSrcDir: paths.srcDir,
+    units,
+    paths: cfg.paths
+  });
+  if (cfg.utilities.enabled) {
+    ops.push(planUtilitiesGitignoreOp({ targetStylesDir: paths.stylesDir }));
+  }
+  step(`Writing ${units.length} unit${units.length === 1 ? "" : "s"} (${ops.length} file${ops.length === 1 ? "" : "s"})\u2026`);
+  const result = await applyFileOps(ops, {
+    cwd: opts.cwd,
+    mode: resolveConflictMode2(opts)
+  });
+  const summary = `${result.written} written \xB7 ${result.skipped} skipped \xB7 ${result.unchanged} unchanged`;
+  const project = detectProject(opts.cwd);
+  const plan = computeRuntimePlan(registry, units, project);
+  const pm = opts.packageManager ?? detectPackageManager(opts.cwd);
+  const installCommands = buildInstallCommands(pm, plan);
+  const hasWork = installCommands.length > 0;
+  if (opts.dryRun) {
+    note2(summary, "dry run");
+    if (hasWork) {
+      note2(
+        [
+          describePlan(plan),
+          "",
+          `would run with ${pm}:`,
+          ...installCommands.map((c) => `  ${c.label}`)
+        ].join("\n"),
+        "dry run \xB7 install"
+      );
+    }
+    goodbye("Preview only - no files were touched.");
+    return;
+  }
+  let willInstall;
+  if (!hasWork) {
+    willInstall = false;
+  } else if (opts.install === false) {
+    willInstall = false;
+  } else if (opts.install === true || opts.yes) {
+    willInstall = true;
+  } else {
+    note2(describePlan(plan), `install with ${pm}`);
+    willInstall = await confirm2({
+      message: `Run ${pm} now to install the dependencies above?`,
+      initialValue: true
+    });
+  }
+  if (willInstall) {
+    step(`Installing dependencies with ${pm}\u2026`);
+    await runInstall(installCommands, {
+      cwd: opts.cwd,
+      onCommand: (cmd) => logger.action(`$ ${cmd.label}`)
+    });
+  } else if (hasWork) {
+    note2(
+      [
+        describePlan(plan),
+        "",
+        "run:",
+        ...installCommands.map((c) => `  ${c.label}`)
+      ].join("\n"),
+      "manual install (skipped)"
+    );
+  }
+  logger.info(summary);
+  goodbye(`Added ${units.length} unit${units.length === 1 ? "" : "s"}.`);
+};
+var computeRuntimePlan = (registry, units, project) => {
+  const dependencies = {};
+  const meta = registry.installMeta;
+  for (const unit of units) {
+    for (const pkg of unit.externalDeps) {
+      const version = meta.packageVersions[pkg];
+      if (!version) continue;
+      if (project.declaredDeps.has(pkg)) continue;
+      dependencies[pkg] = version;
+    }
+  }
+  return { dependencies, devDependencies: {}, skipped: [] };
+};
+var pickUnits = async (all) => multiselect2({
+  message: `Select units to add ${pc5.dim("(space to toggle, enter to confirm)")}`,
+  options: groupedUnitOptions(all),
+  required: false
+});
+
+// src/commands/list.ts
+import pc6 from "picocolors";
+var runList = (opts) => {
+  const registry = loadRegistry();
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(registry, null, 2) + "\n");
+    return;
+  }
+  const colorCount = registry.themes.colors.length;
+  const radiusCount = registry.themes.radii.length;
+  const spacingCount = registry.themes.spacing.length;
+  headline(
+    `${registry.units.length} units \xB7 ${colorCount} colors \xB7 ${radiusCount} radii \xB7 ${spacingCount} spacing`
+  );
+  const ui = registry.units.filter((u) => u.kind === "component" && u.group === "ui");
+  const primitives = registry.units.filter((u) => u.kind === "component" && u.group === "primitives");
+  const hooks = registry.units.filter((u) => u.kind === "hook");
+  const libs = registry.units.filter((u) => u.kind === "lib");
+  const renderBucket = (title, units) => {
+    if (units.length === 0) return null;
+    const body = units.map((u) => {
+      const deps = u.deps.length ? pc6.dim(`  deps: ${u.deps.join(", ")}`) : "";
+      return `  ${pc6.cyan(u.name.padEnd(22))}${deps}`;
+    }).join("\n");
+    return `${pc6.bold(title)} ${pc6.dim(`(${units.length})`)}
+${body}`;
+  };
+  const blocks = [
+    renderBucket("UI components", ui),
+    renderBucket("Primitives", primitives),
+    renderBucket("Hooks", hooks),
+    renderBucket("Utilities", libs)
+  ].filter(Boolean);
+  note2(blocks.join("\n\n"), "registry");
+  const renderVariants = (title, variants) => {
+    if (variants.length === 0) return;
+    const body = variants.map((t) => `  ${pc6.cyan(t.id.padEnd(12))}${pc6.dim(t.description)}`).join("\n");
+    note2(body, title);
+  };
+  renderVariants("colors", registry.themes.colors);
+  renderVariants("radii", registry.themes.radii);
+  renderVariants("spacing", registry.themes.spacing);
+  goodbye(`Use ${pc6.cyan("aplance-ui add <name>")} to install anything above.`);
+};
+export {
+  CSS_CONFIG_PLACEMENTS,
+  SUPPORTED_TEMPLATES,
+  allUnitsInOrder,
+  configExists,
+  findColor,
+  findRadius,
+  findSpacing,
+  loadConfig,
+  loadRegistry,
+  makeDefaultConfig,
+  resolvePaths,
+  resolveUnits,
+  runAdd,
+  runInit,
+  runList
+};
+//# sourceMappingURL=api.js.map