@nateui/cli 0.0.0-stage → 0.0.3

package/dist/nateui.js

@@ -0,0 +1,2631 @@
+#!/usr/bin/env node
+
+// src/args.ts
+function parseFlags(argv, valueFlags) {
+  const flags = /* @__PURE__ */ new Set();
+  const values = {};
+  const positional = [];
+  const valueFlagSet = new Set(valueFlags);
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const body = arg.slice(2);
+    const eq = body.indexOf("=");
+    if (eq !== -1) {
+      values[body.slice(0, eq)] = body.slice(eq + 1);
+      continue;
+    }
+    if (valueFlagSet.has(body)) {
+      values[body] = argv[++i];
+      continue;
+    }
+    flags.add(body);
+  }
+  return { flags, values, positional };
+}
+
+// src/closure.ts
+async function closure(ids, catalog) {
+  const out = /* @__PURE__ */ new Map();
+  const queue = [...ids];
+  const scheduled = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  while (cursor < queue.length) {
+    const batch = [];
+    while (cursor < queue.length && batch.length < 4) {
+      const id = queue[cursor++];
+      if (scheduled.has(id)) continue;
+      scheduled.add(id);
+      batch.push(id);
+    }
+    const results = batch.map(async (id) => {
+      try {
+        return { status: "fulfilled", value: await catalog.item(id) };
+      } catch (reason) {
+        return { status: "rejected", reason };
+      }
+    });
+    for (const [index, pending] of results.entries()) {
+      const result = await pending;
+      if (result.status === "rejected") throw result.reason;
+      out.set(batch[index], result.value);
+      queue.push(...result.value.registryDependencies);
+    }
+  }
+  return out;
+}
+
+// src/components-json.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/project-detect.ts
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+function parseJsonc(raw) {
+  let out = "";
+  let inString = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inString) {
+      out += ch;
+      if (ch === "\\") out += raw[++i] ?? "";
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+    } else if (ch === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") i++;
+      out += "\n";
+    } else if (ch === "/" && raw[i + 1] === "*") {
+      i += 2;
+      while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+      i++;
+    } else {
+      out += ch;
+    }
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+async function readJson(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    return parseJsonc(await readFile(path, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+async function loadCompilerOptions(file, seen) {
+  if (seen.has(file)) return {};
+  const chain = new Set(seen).add(file);
+  const config = await readJson(file);
+  if (!config) return {};
+  let merged = {};
+  const parents = Array.isArray(config.extends) ? config.extends : config.extends ? [config.extends] : [];
+  for (const parent of parents) {
+    if (typeof parent !== "string" || !parent.startsWith(".")) continue;
+    const parentFile = resolve(dirname(file), parent.endsWith(".json") ? parent : `${parent}.json`);
+    const inherited = await loadCompilerOptions(parentFile, chain);
+    merged = { ...merged, ...inherited.paths ? { paths: inherited.paths } : {}, ...inherited.baseUrl ? { baseUrl: inherited.baseUrl } : {} };
+  }
+  const options = config.compilerOptions ?? {};
+  if (typeof options.baseUrl === "string") merged.baseUrl = resolve(dirname(file), options.baseUrl);
+  if (options.paths && typeof options.paths === "object") merged.paths = { value: options.paths, file };
+  return merged;
+}
+async function loadCompilerPaths(file) {
+  const { paths, baseUrl } = await loadCompilerOptions(file, /* @__PURE__ */ new Set());
+  if (!paths) return {};
+  const baseDir = baseUrl ?? dirname(paths.file);
+  const entries = [];
+  for (const [key, targets] of Object.entries(paths.value)) {
+    const first = Array.isArray(targets) ? targets[0] : targets;
+    if (typeof first === "string") entries.push({ key, target: first, baseDir, configFile: paths.file });
+  }
+  return { paths: entries };
+}
+async function collectPaths(projectDir) {
+  const files = [];
+  for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const file = join(projectDir, name);
+    if (!existsSync(file)) continue;
+    files.push(file);
+    const config = await readJson(file);
+    for (const ref of config?.references ?? []) {
+      if (typeof ref?.path !== "string") continue;
+      const refPath = resolve(projectDir, ref.path);
+      files.push(refPath.endsWith(".json") ? refPath : join(refPath, "tsconfig.json"));
+    }
+  }
+  for (const name of ["tsconfig.app.json", "tsconfig.web.json"]) {
+    const file = join(projectDir, name);
+    if (existsSync(file) && !files.includes(file)) files.push(file);
+  }
+  const entries = [];
+  for (const file of files) {
+    const { paths } = await loadCompilerPaths(file);
+    if (paths) entries.push(...paths);
+  }
+  return entries;
+}
+function insideProject(projectDir, dir) {
+  const rel = relative(projectDir, dir);
+  if (rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel === "" ? "." : rel.split(sep).join("/");
+}
+function layoutFor(prefix, installPath, aliasSource) {
+  return { aliasPrefix: prefix, aliasBase: installPath === "." ? "./*" : `./${installPath}/*`, installPath, aliasSource };
+}
+var PREFERRED_PREFIXES = ["@", "~", "#", "$"];
+var SOURCE_ROOTS = [".", "src", "app", "resources/js"];
+var SUBFOLDER_NAMES = /* @__PURE__ */ new Set(["components", "hooks", "utils", "lib", "ui", "styles", "assets", "types", "constants", "configs"]);
+async function aliasFromTsconfig(projectDir) {
+  const candidates = [];
+  for (const entry of await collectPaths(projectDir)) {
+    if (!entry.key.endsWith("/*") || !entry.target.endsWith("/*")) continue;
+    const prefix = entry.key.slice(0, -2);
+    if (!prefix || prefix.includes("*")) continue;
+    const installPath = insideProject(projectDir, resolve(entry.baseDir, entry.target.slice(0, -2)));
+    if (!installPath || SUBFOLDER_NAMES.has(posix.basename(installPath))) continue;
+    candidates.push({ prefix, installPath, source: relative(projectDir, entry.configFile).split(sep).join("/") });
+  }
+  if (candidates.length === 0) return null;
+  const rank = (c) => {
+    const p = PREFERRED_PREFIXES.indexOf(c.prefix);
+    const r = SOURCE_ROOTS.includes(c.installPath) ? 0 : 1;
+    return r * 10 + (p === -1 ? PREFERRED_PREFIXES.length : p);
+  };
+  candidates.sort((a, b) => rank(a) - rank(b));
+  const best = candidates[0];
+  return layoutFor(best.prefix, best.installPath, best.source);
+}
+function importTarget(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    for (const condition of ["types", "import", "default", "node"]) {
+      const resolved = importTarget(value[condition]);
+      if (resolved) return resolved;
+    }
+  }
+  return null;
+}
+function aliasFromPackageImports(projectDir, pkg) {
+  const imports = pkg?.imports;
+  if (!imports || typeof imports !== "object") return null;
+  for (const [key, value] of Object.entries(imports)) {
+    if (!key.startsWith("#") || !key.endsWith("/*")) continue;
+    const target = importTarget(value);
+    if (!target || !target.startsWith("./") || !target.includes("*")) continue;
+    const dir = posix.dirname(target.slice(0, target.indexOf("*")) + "x");
+    const installPath = insideProject(projectDir, resolve(projectDir, dir));
+    if (installPath) return layoutFor(key.slice(0, -2), installPath, "package.json imports");
+  }
+  return null;
+}
+function hasConfig(projectDir, names) {
+  let entries;
+  try {
+    entries = readdirSync(projectDir);
+  } catch {
+    return false;
+  }
+  return entries.some((entry) => names.some((name) => entry === name || entry.startsWith(`${name}.`)));
+}
+function detectFrameworkLabel(projectDir, pkg) {
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const has = (name) => name in deps;
+  const hasPrefix = (prefix) => Object.keys(deps).some((dep) => dep.startsWith(prefix));
+  if (hasConfig(projectDir, ["next.config"]) || has("next")) return "Next.js";
+  if (hasConfig(projectDir, ["react-router.config"]) || has("@react-router/dev")) return "React Router";
+  if (hasPrefix("@tanstack/react-start")) return "TanStack Start";
+  if (hasPrefix("@remix-run/")) return "Remix";
+  if (hasConfig(projectDir, ["astro.config"]) || has("astro")) return "Astro";
+  if (hasConfig(projectDir, ["gatsby-config"]) || has("gatsby")) return "Gatsby";
+  if (existsSync(join(projectDir, "artisan")) || has("laravel-vite-plugin")) return "Laravel";
+  if (has("waku")) return "Waku";
+  if (hasPrefix("@rsbuild/")) return "Rsbuild";
+  if (hasPrefix("@rspack/")) return "Rspack";
+  if (hasConfig(projectDir, ["vite.config"]) || has("vite")) return "Vite";
+  if (has("parcel")) return "Parcel";
+  if (has("react-scripts")) return "Create React App";
+  return "React";
+}
+function conventionalFolder(projectDir, framework) {
+  if (framework === "React Router" || framework === "Remix") {
+    if (existsSync(join(projectDir, "app"))) return "app";
+  }
+  if (framework === "Laravel" && existsSync(join(projectDir, "resources", "js"))) return "resources/js";
+  return existsSync(join(projectDir, "src")) ? "src" : ".";
+}
+var UnsupportedProjectError = class extends Error {
+};
+async function detectProject(projectDir) {
+  const pkg = await readJson(join(projectDir, "package.json"));
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (("react-native" in deps || "expo" in deps) && !("react-dom" in deps)) {
+    throw new UnsupportedProjectError(
+      "this looks like a React Native project \u2014 NateUI components are for React on the web (react-dom)"
+    );
+  }
+  const framework = detectFrameworkLabel(projectDir, pkg);
+  const layout = await aliasFromTsconfig(projectDir) ?? aliasFromPackageImports(projectDir, pkg) ?? layoutFor("@", conventionalFolder(projectDir, framework), null);
+  return { framework, ...layout };
+}
+function rewriteAliasImports(content, prefix) {
+  if (prefix === "@") return content;
+  return content.replace(
+    /(\bfrom\s*|\bimport\s*\(\s*|\bimport\s+|\brequire\s*\(\s*|\b(?:vi|jest)\.mock\s*\(\s*)(['"])@\//g,
+    (_match, lead, quote) => `${lead}${quote}${prefix}/`
+  );
+}
+function isScriptFile(path) {
+  return /\.(?:[cm]?[jt]sx?)$/.test(path);
+}
+
+// src/ui.ts
+var NateuiError = class extends Error {
+};
+function fail(message) {
+  throw new NateuiError(message);
+}
+function printError(message) {
+  console.error(`nateui: ${message}`);
+}
+function warn(message) {
+  console.log(`warn: ${message}`);
+}
+function info(message) {
+  console.log(message);
+}
+async function withSpinner(label, work) {
+  if (!process.stdout.isTTY) return work();
+  const fancy = process.platform !== "win32" || !!process.env.WT_SESSION || !!process.env.TERM_PROGRAM || !!process.env.TERM;
+  const frames = fancy ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+  let frame = 0;
+  const draw = () => process.stdout.write(`\r${frames[frame++ % frames.length]} ${label}`);
+  draw();
+  const interval = setInterval(draw, 90);
+  try {
+    return await work();
+  } finally {
+    clearInterval(interval);
+    process.stdout.write(`\r${" ".repeat(label.length + 2)}\r`);
+  }
+}
+
+// src/components-json.ts
+function componentsJsonPath(projectDir) {
+  return join2(projectDir, "components.json");
+}
+function componentsJsonExists(projectDir) {
+  return existsSync2(componentsJsonPath(projectDir));
+}
+async function readComponentsJson(projectDir) {
+  const raw = await readFile2(componentsJsonPath(projectDir), "utf-8");
+  return JSON.parse(raw);
+}
+async function writeComponentsJson(projectDir, data) {
+  await writeFile(componentsJsonPath(projectDir), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function newComponentsJson(framework, layout = { aliasBase: "./src/*", installPath: "src" }) {
+  return {
+    schemaVersion: 1,
+    framework,
+    alias: { scheme: layout.aliasPrefix ?? "@", base: layout.aliasBase },
+    installPath: layout.installPath,
+    installed: { components: [], pages: [] }
+  };
+}
+async function loadOrDetectComponentsJson(projectDir) {
+  if (componentsJsonExists(projectDir)) return readComponentsJson(projectDir);
+  let project;
+  try {
+    project = await detectProject(projectDir);
+  } catch (err) {
+    if (err instanceof UnsupportedProjectError) fail(err.message);
+    throw err;
+  }
+  const folder = project.installPath === "." ? "the project root" : `${project.installPath}/`;
+  if (project.aliasSource) {
+    info(`creating components.json (${project.framework}, "${project.aliasPrefix}/" -> ${folder}, from ${project.aliasSource})`);
+  } else {
+    info(`creating components.json (${project.framework}, installing into ${folder})`);
+    warn(
+      `no import shortcut found \u2014 NateUI files import from "@/". Add "paths": { "@/*": ["${project.aliasBase}"] } to your tsconfig` + (project.framework === "Vite" ? " (tsconfig.app.json) and a matching resolve.alias in vite.config" : "")
+    );
+  }
+  return newComponentsJson(project.framework, project);
+}
+function addInstalledComponents(data, ids) {
+  const set = new Set(data.installed.components);
+  for (const id of ids) set.add(id);
+  data.installed.components = [...set].sort();
+}
+function addInstalledPage(data, id) {
+  const set = new Set(data.installed.pages);
+  set.add(id);
+  data.installed.pages = [...set].sort();
+}
+function removeInstalledPage(data, id) {
+  data.installed.pages = data.installed.pages.filter((p) => p !== id);
+}
+
+// src/install-items.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/write-plan.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+function normalizeText(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+async function writeAction(file, overwrite) {
+  if (!existsSync3(file.targetPath)) return "written";
+  const existing = await readFile3(file.targetPath);
+  const text = normalizeText(existing.toString("utf-8"));
+  const identical = typeof file.content === "string" ? text === normalizeText(file.content) : existing.equals(file.content);
+  if (identical) return "skipped-identical";
+  if (overwrite || file.starterOverlay && text === normalizeText(file.starterOverlay.content)) return "written";
+  return "skipped-differs";
+}
+async function applyWritePlan(files, overwrite) {
+  const results = [];
+  for (const file of files) {
+    const action = await writeAction(file, overwrite);
+    if (action === "written") {
+      await mkdir(dirname2(file.targetPath), { recursive: true });
+      await writeFile2(file.targetPath, file.content, "utf-8");
+    } else if (action === "skipped-differs") {
+      const needed = file.starterOverlay ? `needed by ${file.starterOverlay.pageId}; ` : "";
+      warn(`exists, differs, skipped: ${file.targetPath} (${needed}rerun with --overwrite to replace)`);
+    }
+    results.push({ targetPath: file.targetPath, action });
+  }
+  return results;
+}
+
+// src/install-items.ts
+function planFiles(items, projectDir, installPath, aliasPrefix = "@") {
+  const plan = [];
+  for (const item of items) {
+    for (const file of item.files) {
+      if (file.content === null || file.content === void 0) {
+        throw new Error(`'${item.id}' requires a license \u2014 run: nateui login`);
+      }
+      const content = isScriptFile(file.path) ? rewriteAliasImports(file.content, aliasPrefix) : file.content;
+      plan.push({ targetPath: join3(projectDir, installPath, file.path), content });
+    }
+  }
+  return plan;
+}
+async function writeItemFiles(items, projectDir, installPath, overwrite, aliasPrefix = "@") {
+  const plan = planFiles(items, projectDir, installPath, aliasPrefix);
+  return applyWritePlan(plan, overwrite);
+}
+async function mergeNpmDependencies(items, projectDir) {
+  const pkgPath = join3(projectDir, "package.json");
+  if (!existsSync4(pkgPath)) return { changed: false, added: [] };
+  const pkg = JSON.parse(await readFile4(pkgPath, "utf-8"));
+  pkg.dependencies ??= {};
+  const added = [];
+  let changed = false;
+  for (const item of items) {
+    for (const [name, pin] of Object.entries(item.dependencies)) {
+      if (pkg.dependencies[name] !== void 0) {
+        if (pkg.dependencies[name] !== pin) {
+          warn(`'${name}' already at ${pkg.dependencies[name]}, registry wants ${pin} \u2014 not changed, resolve manually`);
+        }
+        continue;
+      }
+      pkg.dependencies[name] = pin;
+      added.push(name);
+      changed = true;
+    }
+  }
+  if (changed) await writeFile3(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+  return { changed, added };
+}
+function npmDependencyLines(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    for (const [name, pin] of Object.entries(item.dependencies)) {
+      if (!seen.has(name)) seen.set(name, pin);
+    }
+  }
+  return [...seen.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, pin]) => `  ${name} (>=${pin.replace(/^[\^~]/, "")})`);
+}
+
+// src/resolve-name.ts
+function itemName(id) {
+  return id.slice(id.indexOf("/") + 1);
+}
+function normalizedName(name) {
+  return name.replace(/[\s_-]/g, "").toLowerCase();
+}
+function resolveItemId(input, index) {
+  const nonHidden = index.items.filter((i) => !i.hidden);
+  if (input.includes("/")) {
+    const [kind, name] = input.split("/", 2);
+    const match = nonHidden.find(
+      (i) => i.kind.toLowerCase() === kind.toLowerCase() && normalizedName(itemName(i.id)) === normalizedName(name)
+    );
+    if (!match) fail(`unknown component '${input}' \u2014 run: nateui list`);
+    return match.id;
+  }
+  const matches = nonHidden.filter((i) => normalizedName(itemName(i.id)) === normalizedName(input));
+  if (matches.length === 0) fail(`unknown component '${input}' \u2014 run: nateui list`);
+  if (matches.length > 1) {
+    const ids = matches.map((m) => m.id).join(", ");
+    fail(`'${input}' matches more than one item: ${ids} \u2014 run with the layer prefix, e.g. nateui add ${matches[0].id}`);
+  }
+  return matches[0].id;
+}
+
+// src/transport.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// src/catalog.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { readFile as readFile6, readdir } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// src/login-flow.ts
+import { chmod, mkdir as mkdir2, writeFile as writeFile4 } from "node:fs/promises";
+import { createServer } from "node:http";
+import { hostname } from "node:os";
+import { createInterface } from "node:readline/promises";
+
+// src/open-browser.ts
+import { spawn } from "node:child_process";
+function openBrowser(url) {
+  const [command, args, verbatim] = process.platform === "win32" ? ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")], true] : process.platform === "darwin" ? ["open", [url], false] : ["xdg-open", [url], false];
+  return new Promise((resolve5) => {
+    let settled = false;
+    const settle = (opened) => {
+      if (settled) return;
+      settled = true;
+      resolve5(opened);
+    };
+    try {
+      const child = spawn(command, args, {
+        stdio: "ignore",
+        detached: true,
+        windowsVerbatimArguments: verbatim
+      });
+      child.on("error", () => settle(false));
+      child.on("exit", (code) => settle(code === 0));
+      child.unref();
+      setTimeout(() => settle(true), 3e3).unref();
+    } catch {
+      settle(false);
+    }
+  });
+}
+
+// src/paths.ts
+import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+var PACKAGE_ROOT = dirname3(dirname3(fileURLToPath(import.meta.url)));
+var CHASSIS_DIR = join4(PACKAGE_ROOT, "dist", "chassis");
+var NATEUI_HOME = join4(homedir(), ".nateui");
+var CACHE_DIR = join4(NATEUI_HOME, "cache");
+var CREDENTIALS_PATH = join4(NATEUI_HOME, "credentials");
+
+// src/pkce.ts
+import { createHash, randomBytes } from "node:crypto";
+function createPkcePair() {
+  const verifier = randomBytes(32).toString("base64url");
+  return { verifier, challenge: s256(verifier) };
+}
+function s256(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function createState() {
+  return randomBytes(24).toString("base64url");
+}
+
+// src/token.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
+async function resolveToken(flag) {
+  if (flag) return flag;
+  if (process.env.NATEUI_TOKEN) return process.env.NATEUI_TOKEN;
+  if (existsSync5(CREDENTIALS_PATH)) {
+    try {
+      const stored = JSON.parse(await readFile5(CREDENTIALS_PATH, "utf-8"));
+      if (stored.token) return stored.token;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function apiBase() {
+  return process.env.NATEUI_API ?? "https://nateui.com";
+}
+
+// src/login-flow.ts
+var MAX_PASTE_ATTEMPTS = 3;
+function machineLabel() {
+  let raw = "";
+  try {
+    raw = hostname();
+  } catch {
+  }
+  const cleaned = raw.replace(/[^A-Za-z0-9 ._-]/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, 64).trim();
+  return cleaned || "machine";
+}
+function connectUrl(params) {
+  return `${apiBase()}/cli/connect?${new URLSearchParams(params).toString()}`;
+}
+function isRemoteSession() {
+  return !!process.env.SSH_CONNECTION || !!process.env.SSH_TTY;
+}
+async function exchangeCode(code, verifier) {
+  let res;
+  try {
+    res = await fetch(`${apiBase()}/api/cli/auth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code, verifier })
+    });
+  } catch {
+    fail(`could not reach ${apiBase()} \u2014 check your connection and try again`);
+  }
+  if (res.status === 400) return null;
+  if (!res.ok) fail(`sign-in failed (${res.status})`);
+  return await res.json();
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+function resultPage(title, message, showDashboard) {
+  const dashboard = escapeHtml(`${apiBase()}/dashboard`);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>NateUI CLI</title>
+<style>
+:root{color-scheme:light dark;--bg:#fff;--fg:#0a0a0a;--muted:#525252;--btn:#0a0a0a;--btn-fg:#fff}
+@media (prefers-color-scheme:dark){:root{--bg:#0a0a0a;--fg:#fafafa;--muted:#a3a3a3;--btn:#fafafa;--btn-fg:#0a0a0a}}
+*{box-sizing:border-box}
+body{margin:0;min-height:100dvh;display:flex;align-items:center;justify-content:center;padding:24px 16px;background:var(--bg);color:var(--fg);font:16px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif}
+main{width:100%;max-width:28rem}
+h1{margin:0 0 8px;font-size:28px;line-height:36px;font-weight:600;letter-spacing:-.01em}
+p{margin:0 0 24px;color:var(--muted)}
+a{display:inline-flex;align-items:center;justify-content:center;min-height:40px;padding:0 20px;border-radius:999px;background:var(--btn);color:var(--btn-fg);font-size:14px;font-weight:500;text-decoration:none}
+a:focus-visible{outline:2px solid var(--fg);outline-offset:2px}
+</style>
+</head>
+<body>
+<main>
+<h1>${escapeHtml(title)}</h1>
+<p>${escapeHtml(message)}</p>
+${showDashboard ? `<a href="${dashboard}">Go to dashboard</a>` : ""}
+</main>
+</body>
+</html>`;
+}
+function sendPage(res, status, html) {
+  return new Promise((resolve5) => {
+    res.writeHead(status, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      Connection: "close"
+    });
+    res.end(html, () => resolve5());
+  });
+}
+async function loopbackLogin(pkce, state, label, open) {
+  let settle;
+  const result = new Promise((resolve5, reject) => {
+    settle = { resolve: resolve5, reject };
+  });
+  result.catch(() => {
+  });
+  let handled = false;
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (req.method !== "GET" || url.pathname !== "/callback") {
+      await sendPage(res, 404, resultPage("Not found", "Return to your terminal.", false));
+      return;
+    }
+    if (url.searchParams.get("state") !== state || handled) {
+      await sendPage(res, 400, resultPage("Sign-in not recognised", "Run the command again in your terminal.", false));
+      return;
+    }
+    handled = true;
+    if (url.searchParams.get("error")) {
+      await sendPage(res, 200, resultPage("Cancelled", "The CLI was not connected. You can close this tab.", false));
+      settle.reject(new NateuiError("sign-in cancelled in the browser"));
+      return;
+    }
+    const code = url.searchParams.get("code") ?? "";
+    try {
+      const token = await exchangeCode(code, pkce.verifier);
+      if (!token) {
+        await sendPage(res, 200, resultPage("Sign-in failed", "Return to your terminal and run the command again.", false));
+        settle.reject(new NateuiError("sign-in failed \u2014 the code was invalid or expired; run the command again"));
+        return;
+      }
+      await sendPage(
+        res,
+        200,
+        resultPage("Connected", "You can close this tab and return to your terminal, or", true)
+      );
+      settle.resolve(token);
+    } catch (error) {
+      await sendPage(res, 200, resultPage("Sign-in failed", "Return to your terminal for details.", false));
+      settle.reject(error instanceof Error ? error : new NateuiError("sign-in failed"));
+    }
+  });
+  await new Promise((resolve5, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve5());
+  });
+  const close = () => {
+    server.close();
+    server.closeAllConnections?.();
+  };
+  try {
+    const { port } = server.address();
+    const url = connectUrl({ state, challenge: pkce.challenge, label, port: String(port) });
+    info("Opening your browser to sign in\u2026");
+    info(`If it doesn't open, visit: ${url}`);
+    const opened = await open(url);
+    if (!opened && !handled) return null;
+    return await withSpinner("waiting for the browser", () => result);
+  } finally {
+    close();
+  }
+}
+async function pasteLogin(pkce, state, label) {
+  const url = connectUrl({ state, challenge: pkce.challenge, label, mode: "paste" });
+  info("Open this address in a browser to sign in:");
+  info(url);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    for (let attempt = 1; attempt <= MAX_PASTE_ATTEMPTS; attempt++) {
+      let pasted;
+      try {
+        pasted = (await rl.question("Paste code here if prompted: ")).trim();
+      } catch {
+        fail("sign-in cancelled \u2014 no code entered");
+      }
+      const [code, pastedState] = pasted.split("#");
+      if (!code) {
+        info("no code entered");
+        continue;
+      }
+      if (pastedState && pastedState !== state) fail("that code belongs to a different sign-in \u2014 run the command again");
+      const token = await withSpinner("checking your code", () => exchangeCode(code, pkce.verifier));
+      if (token) return token;
+      info("that code didn't work \u2014 copy it again from the browser page");
+    }
+    fail("too many attempts \u2014 run nateui login again");
+  } finally {
+    rl.close();
+  }
+}
+async function runLoginFlow(open = openBrowser) {
+  void fetch(`${apiBase()}/api/cli/validate`).then((r) => r.arrayBuffer()).catch(() => {
+  });
+  const pkce = createPkcePair();
+  const state = createState();
+  const label = machineLabel();
+  let result = isRemoteSession() ? null : await loopbackLogin(pkce, state, label, open);
+  if (!result) {
+    if (!isRemoteSession()) info("Couldn't open a browser on this machine.");
+    result = await pasteLogin(pkce, state, label);
+  }
+  await mkdir2(NATEUI_HOME, { recursive: true });
+  await writeFile4(CREDENTIALS_PATH, JSON.stringify({ token: result.token }) + "\n", "utf-8");
+  await chmod(CREDENTIALS_PATH, 384).catch(() => {
+  });
+  info(`Signed in as ${result.email}`);
+  if (result.needsPick) info(`pick your template at ${apiBase()}/dashboard`);
+  return result.token;
+}
+var pendingLogin;
+async function resolveOrLogin(flag) {
+  const stored = await resolveToken(flag);
+  if (stored) return stored;
+  if (!process.stdin.isTTY) return void 0;
+  pendingLogin ??= runLoginFlow();
+  return pendingLogin;
+}
+
+// src/catalog.ts
+function localCatalog(dir) {
+  const registryDir = join5(dir, "registry");
+  let cachedIndex;
+  return {
+    async index() {
+      if (cachedIndex) return cachedIndex;
+      const path = join5(registryDir, "index.json");
+      if (!existsSync6(path)) {
+        fail(`no registry source \u2014 pass --local <dir> (network transport lands in M4)`);
+      }
+      cachedIndex = JSON.parse(await readFile6(path, "utf-8"));
+      return cachedIndex;
+    },
+    async item(id) {
+      const path = join5(registryDir, "components", `${id}.json`);
+      if (!existsSync6(path)) fail(`unknown item '${id}'`);
+      return JSON.parse(await readFile6(path, "utf-8"));
+    },
+    async pageRegistry(slug) {
+      fail(`page registry for '${slug}' isn't available via --local alone \u2014 resolve the template tarball instead`);
+    }
+  };
+}
+function networkCatalog(base, initialToken) {
+  let token = initialToken;
+  let cachedIndex;
+  let pendingIndex;
+  async function ensureIndex() {
+    if (cachedIndex) return cachedIndex;
+    pendingIndex ??= (async () => {
+      const res = await fetch(`${base}/api/cli/registry/index`);
+      if (!res.ok) fail(`couldn't reach the registry (${res.status}) \u2014 check --local/--tarball or NATEUI_API`);
+      cachedIndex = await res.json();
+      return cachedIndex;
+    })().catch((error) => {
+      pendingIndex = void 0;
+      throw error;
+    });
+    return pendingIndex;
+  }
+  const authHeaders = () => token ? { Authorization: `Bearer ${token}` } : void 0;
+  return {
+    index: ensureIndex,
+    async item(id) {
+      const index = await ensureIndex();
+      const isPro = index.items.find((i) => i.id === id)?.tier === "pro";
+      if (isPro && !token) {
+        token = await resolveOrLogin();
+      }
+      const res = await fetch(`${base}/api/cli/registry/components/${id}`, { headers: authHeaders() });
+      if (res.status === 404) fail(`unknown item '${id}'`);
+      if (!res.ok) fail(`couldn't fetch '${id}' (${res.status})`);
+      return await res.json();
+    },
+    async pageRegistry(slug) {
+      if (!token) token = await resolveOrLogin();
+      const res = await fetch(`${base}/api/cli/registry/pages/${slug}`, { headers: authHeaders() });
+      if (res.status === 404) fail(`unknown template '${slug}'`);
+      if (res.status === 401 || res.status === 403) {
+        const body = await res.json().catch(() => ({}));
+        fail(body.error ?? `not entitled to '${slug}' (${res.status})`);
+      }
+      if (!res.ok) fail(`couldn't fetch pages for '${slug}' (${res.status})`);
+      return await res.json();
+    }
+  };
+}
+async function findLocalTarball(localDir, slug) {
+  const parent = join5(localDir, "..");
+  if (!existsSync6(parent)) return null;
+  for (const entry of await readdir(parent)) {
+    if (entry.startsWith(`${slug}-`) && entry.endsWith(".tar.gz")) {
+      return join5(parent, entry);
+    }
+  }
+  return null;
+}
+
+// src/transport.ts
+async function resolveCatalog(localDir, tokenFlag) {
+  if (localDir) return localCatalog(localDir);
+  const token = await resolveToken(tokenFlag);
+  return networkCatalog(apiBase(), token);
+}
+async function fetchTarballFromNetwork(slug, tokenFlag) {
+  const token = await resolveOrLogin(tokenFlag);
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await withSpinner(
+    "requesting template",
+    () => fetch(`${apiBase()}/api/cli/scaffold`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ template: slug })
+    })
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    fail(body.error ?? `scaffold request failed (${res.status})`);
+  }
+  const scaffold = await res.json();
+  const buffer = await withSpinner("downloading template", async () => {
+    const download = await fetch(scaffold.url);
+    if (!download.ok) fail(`tarball download failed (${download.status})`);
+    return Buffer.from(await download.arrayBuffer());
+  });
+  await mkdir3(CACHE_DIR, { recursive: true });
+  const cachePath = join6(CACHE_DIR, `${scaffold.template}@${scaffold.version}.tar.gz`);
+  await writeFile5(cachePath, buffer);
+  return cachePath;
+}
+async function resolveTarball(slug, opts) {
+  if (opts.tarball) {
+    if (!existsSync7(opts.tarball)) fail(`--tarball path does not exist: ${opts.tarball}`);
+    return opts.tarball;
+  }
+  if (opts.local) {
+    const found = await findLocalTarball(opts.local, slug);
+    if (found) return found;
+    fail(`no source for template '${slug}' \u2014 pass --tarball <path> or point --local at a dir with the tarball next to it`);
+  }
+  return fetchTarballFromNetwork(slug, opts.token);
+}
+
+// src/package-manager.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join7 } from "node:path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+function detectPackageManager(projectDir) {
+  for (const [lockfile, manager] of LOCKFILES) {
+    if (existsSync8(join7(projectDir, lockfile))) return manager;
+  }
+  return "npm";
+}
+function installCommand(projectDir) {
+  return `${detectPackageManager(projectDir)} install`;
+}
+function devCommand(projectDir) {
+  const manager = detectPackageManager(projectDir);
+  return manager === "npm" ? "npm run dev" : `${manager} dev`;
+}
+
+// src/commands/add.ts
+async function runAdd(argv) {
+  const { flags, values, positional } = parseFlags(argv, ["local", "token"]);
+  if (positional.length === 0) fail(`at least one component name required (e.g. nateui add button)`);
+  const projectDir = process.cwd();
+  const cj = await loadOrDetectComponentsJson(projectDir);
+  const overwrite = flags.has("overwrite");
+  const catalog = await resolveCatalog(values.local, values.token);
+  const index = await catalog.index();
+  let anyFailed = false;
+  const resolvedIds = [];
+  for (const name of positional) {
+    try {
+      const id = resolveItemId(name, index);
+      info(`add ${name} -> ${id}`);
+      resolvedIds.push(id);
+    } catch (err) {
+      anyFailed = true;
+      printError(err instanceof Error ? err.message : String(err));
+    }
+  }
+  if (resolvedIds.length === 0) process.exit(1);
+  const items = await closure(resolvedIds, catalog);
+  const results = await writeItemFiles(items.values(), projectDir, cj.installPath, overwrite, cj.alias.scheme);
+  const { changed: npmChanged } = await mergeNpmDependencies(items.values(), projectDir);
+  addInstalledComponents(cj, [...items.keys()]);
+  await writeComponentsJson(projectDir, cj);
+  for (const r of results) {
+    if (r.action === "written") info(`  wrote ${r.targetPath}`);
+  }
+  if (npmChanged) info(`run: ${installCommand(projectDir)}`);
+  if (anyFailed) process.exit(1);
+}
+
+// src/commands/add-page.ts
+import { existsSync as existsSync9, statSync } from "node:fs";
+import { mkdtemp, readFile as readFile9, readdir as readdir2, rm, writeFile as writeFile7 } from "node:fs/promises";
+import { isBuiltin } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/splice.ts
+import { readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+var NAV_MARKER = "// nateui:nav:insert";
+var NAV_SECONDARY_MARKER = "// nateui:nav:insert:secondary";
+var ROUTES_MARKER = "// nateui:routes:insert";
+var ICONS_IMPORTS_MARKER = "// nateui:icons:imports:insert";
+var ICONS_MAP_MARKER = "// nateui:icons:map:insert";
+function blockBegin(template, page) {
+  return `// nateui:page:${template}/${page}:begin`;
+}
+function blockEnd(template, page) {
+  return `// nateui:page:${template}/${page}:end`;
+}
+function findLine(lines, marker) {
+  return lines.findIndex((l) => l.trim() === marker);
+}
+function indentOf(line) {
+  const m = line.match(/^(\s*)/);
+  return m ? m[1] : "";
+}
+function insertAboveMarker(lines, marker, blockLines) {
+  const idx = findLine(lines, marker);
+  if (idx === -1) return lines;
+  return [...lines.slice(0, idx), ...blockLines, ...lines.slice(idx)];
+}
+function removeBlock(lines, begin, end) {
+  let out = lines;
+  while (true) {
+    const beginIdx = findLine(out, begin);
+    if (beginIdx === -1) return out;
+    const endIdx = out.findIndex((l, i) => i > beginIdx && l.trim() === end);
+    if (endIdx === -1) return out;
+    out = [...out.slice(0, beginIdx), ...out.slice(endIdx + 1)];
+  }
+}
+async function checkMarkers(configs) {
+  const [nav, routes, icon] = await Promise.all([
+    readFile7(configs.navPath, "utf-8"),
+    readFile7(configs.routesPath, "utf-8"),
+    readFile7(configs.iconPath, "utf-8")
+  ]);
+  const navLines = nav.split("\n");
+  const routesLines = routes.split("\n");
+  const iconLines = icon.split("\n");
+  return [
+    { file: configs.navPath, marker: NAV_MARKER, present: findLine(navLines, NAV_MARKER) !== -1 },
+    {
+      file: configs.navPath,
+      marker: NAV_SECONDARY_MARKER,
+      present: findLine(navLines, NAV_SECONDARY_MARKER) !== -1
+    },
+    { file: configs.routesPath, marker: ROUTES_MARKER, present: findLine(routesLines, ROUTES_MARKER) !== -1 },
+    {
+      file: configs.iconPath,
+      marker: ICONS_IMPORTS_MARKER,
+      present: findLine(iconLines, ICONS_IMPORTS_MARKER) !== -1
+    },
+    { file: configs.iconPath, marker: ICONS_MAP_MARKER, present: findLine(iconLines, ICONS_MAP_MARKER) !== -1 }
+  ];
+}
+function assertMarkersPresent(checks) {
+  const missing = checks.find((c) => !c.present);
+  if (missing) {
+    fail(`${missing.file} is missing the '${missing.marker}' marker \u2014 add-page needs it to know where to insert`);
+  }
+}
+function renderLiteralValue(value) {
+  if (typeof value === "string") return `'${value.replace(/'/g, "\\'")}'`;
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (Array.isArray(value)) return `[${value.map(renderLiteralValue).join(", ")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${renderLiteralValue(v)}`).join(", ");
+    return `{ ${entries} }`;
+  }
+  return JSON.stringify(value);
+}
+function renderNavItem(item, indent) {
+  const { slot: _slot, ...rest } = item;
+  const lines = [`${indent}{`];
+  for (const [key, value] of Object.entries(rest)) {
+    lines.push(`${indent}    ${key}: ${renderLiteralValue(value)},`);
+  }
+  lines.push(`${indent}},`);
+  return lines;
+}
+function renderRouteEntry(path, value, indent) {
+  const lines = [`${indent}'${path}': {`];
+  for (const [key, val] of Object.entries(value)) {
+    lines.push(`${indent}    ${key}: ${renderLiteralValue(val)},`);
+  }
+  lines.push(`${indent}},`);
+  return lines;
+}
+var PROPERTY_KEY = /^\s*(?:([$_\p{ID_Start}][$_\p{ID_Continue}\u200c\u200d]*)|'([^']+)'|"([^"]+)")\s*:/u;
+var STRING_VALUE = /^\s*(key|icon):\s*(?:'([^']+)'|"([^"]+)")\s*,?/;
+var NAMED_IMPORT = /\bimport\s+(?!type\b)(?:[$\w]+\s*,\s*)?\{([^}]+)\}\s*from\s*(['"])([^'"]+)\2/g;
+function propertyKey(line) {
+  const match = line.match(PROPERTY_KEY);
+  return match && (match[1] ?? match[2] ?? match[3]) || void 0;
+}
+function namedImports(raw) {
+  const imports = /* @__PURE__ */ new Map();
+  const source = raw.replace(
+    /(\/\/[^\n]*|\/\*[\s\S]*?\*\/)|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+    (match, comment) => comment ? " " : match
+  );
+  for (const [, bindings, , from] of source.matchAll(NAMED_IMPORT)) {
+    for (const binding of bindings.split(",")) {
+      const names = binding.trim().match(/^([$\w]+)(?:\s+as\s+([$\w]+))?$/);
+      if (names) imports.set(`${from}:${names[1]}`, names[2] ?? names[1]);
+    }
+  }
+  return imports;
+}
+function findOwner(lines, matches) {
+  let owner;
+  for (const line of lines) {
+    const match = line.match(/^\s*\/\/ nateui:page:(.+):begin\s*$/);
+    if (match) owner = match[1];
+    else if (/^\s*\/\/ nateui:page:.+:end\s*$/.test(line)) owner = void 0;
+    else if (owner && matches(line)) return owner;
+  }
+  return void 0;
+}
+function keepOwnedLine(lines, marker, owner, line) {
+  const end = `// nateui:page:${owner}:end`;
+  const markerIndex = findLine(lines, marker);
+  const existingEnd = lines.slice(0, markerIndex).map((entry) => entry.trim()).lastIndexOf(end);
+  if (existingEnd !== -1 && (marker !== ICONS_MAP_MARKER || existingEnd > findLine(lines, ICONS_IMPORTS_MARKER))) {
+    return [...lines.slice(0, existingEnd), line, ...lines.slice(existingEnd)];
+  }
+  const indent = indentOf(lines[markerIndex]);
+  return insertAboveMarker(lines, marker, [`${indent}// nateui:page:${owner}:begin`, line, indent + end]);
+}
+async function spliceAdd(target, template, page, registration) {
+  const begin = blockBegin(template, page);
+  const end = blockEnd(template, page);
+  {
+    const raw = await readFile7(target.navPath, "utf-8");
+    let lines = raw.split("\n");
+    const navKeys = new Set(lines.flatMap((line) => {
+      const match = line.match(STRING_VALUE);
+      return match?.[1] === "key" ? [match[2] ?? match[3]] : [];
+    }));
+    const nav = registration.nav.filter((item) => !navKeys.has(item.key));
+    const primary = nav.filter((n) => n.slot !== "secondary");
+    const secondary = nav.filter((n) => n.slot === "secondary");
+    if (primary.length) {
+      const idx = findLine(lines, NAV_MARKER);
+      const indent = indentOf(lines[idx]);
+      const block = [`${indent}${begin}`, ...primary.flatMap((n) => renderNavItem(n, indent)), `${indent}${end}`];
+      lines = insertAboveMarker(lines, NAV_MARKER, block);
+    }
+    if (secondary.length) {
+      const idx = findLine(lines, NAV_SECONDARY_MARKER);
+      const indent = indentOf(lines[idx]);
+      const block = [`${indent}${begin}`, ...secondary.flatMap((n) => renderNavItem(n, indent)), `${indent}${end}`];
+      lines = insertAboveMarker(lines, NAV_SECONDARY_MARKER, block);
+    }
+    await writeFile6(target.navPath, lines.join("\n"), "utf-8");
+  }
+  {
+    const raw = await readFile7(target.routesPath, "utf-8");
+    const lines = raw.split("\n");
+    const routeKeys = new Set(lines.map(propertyKey));
+    const entries = Object.entries(registration.routes).filter(([path]) => !routeKeys.has(path));
+    if (entries.length) {
+      const idx = findLine(lines, ROUTES_MARKER);
+      const indent = indentOf(lines[idx]);
+      const block = [
+        `${indent}${begin}`,
+        ...entries.flatMap(([path, value]) => renderRouteEntry(path, value, indent)),
+        `${indent}${end}`
+      ];
+      await writeFile6(target.routesPath, insertAboveMarker(lines, ROUTES_MARKER, block).join("\n"), "utf-8");
+    }
+  }
+  {
+    const raw = await readFile7(target.iconPath, "utf-8");
+    let lines = raw.split("\n");
+    const existing = new Set(lines.map(propertyKey));
+    const imports = namedImports(raw);
+    const localNames = new Set(imports.values());
+    const importIndent = indentOf(lines[findLine(lines, ICONS_IMPORTS_MARKER)]);
+    const mapIndent = indentOf(lines[findLine(lines, ICONS_MAP_MARKER)]);
+    const classConstant = raw.match(/^\s*const\s+(COMMON_CLASS_NAME|CLASS_NAME)\s*=/m)?.[1];
+    const className = classConstant ? ` className={${classConstant}}` : "";
+    const importLines = [];
+    const mapLines = [];
+    for (const [key, icon] of Object.entries(registration.icons)) {
+      if (existing.has(key)) continue;
+      const binding = `${icon.from}:${icon.import}`;
+      let local = imports.get(binding);
+      if (!local) {
+        local = icon.import;
+        for (let suffix = 2; localNames.has(local); suffix++) local = icon.import + suffix;
+        const specifier = local === icon.import ? local : `${icon.import} as ${local}`;
+        importLines.push(`${importIndent}import { ${specifier} } from '${icon.from}'`);
+        imports.set(binding, local);
+        localNames.add(local);
+      }
+      const mapKey = /^[$_\p{ID_Start}][$_\p{ID_Continue}\u200c\u200d]*$/u.test(key) ? key : JSON.stringify(key);
+      mapLines.push(`${mapIndent}${mapKey}: <${local}${className} />,`);
+    }
+    if (importLines.length) {
+      lines = insertAboveMarker(lines, ICONS_IMPORTS_MARKER, [importIndent + begin, ...importLines, importIndent + end]);
+    }
+    if (mapLines.length) {
+      lines = insertAboveMarker(lines, ICONS_MAP_MARKER, [mapIndent + begin, ...mapLines, mapIndent + end]);
+    }
+    await writeFile6(target.iconPath, lines.join("\n"), "utf-8");
+  }
+}
+async function spliceRemove(target, template, page) {
+  const begin = blockBegin(template, page);
+  const end = blockEnd(template, page);
+  const nav = removeBlock((await readFile7(target.navPath, "utf-8")).split("\n"), begin, end);
+  const routes = removeBlock((await readFile7(target.routesPath, "utf-8")).split("\n"), begin, end);
+  const original = (await readFile7(target.iconPath, "utf-8")).split("\n");
+  let icons = removeBlock(original, begin, end);
+  const retained = new Set(icons);
+  const removed = original.filter((line) => !retained.has(line));
+  const remainingKeys = new Set(icons.map(propertyKey));
+  for (const line of removed) {
+    const key = propertyKey(line);
+    if (!key || remainingKeys.has(key)) continue;
+    const owner = findOwner(nav, (entry) => {
+      const value = entry.match(STRING_VALUE);
+      return value?.[1] === "icon" && (value[2] ?? value[3]) === key;
+    });
+    if (owner) icons = keepOwnedLine(icons, ICONS_MAP_MARKER, owner, line);
+  }
+  const remainingImports = namedImports(icons.join("\n"));
+  for (const line of removed) {
+    const binding = line.match(/^\s*import \{ ([$\w]+)(?: as ([$\w]+))? \} from '([^']+)'/);
+    if (!binding) continue;
+    const local = binding[2] ?? binding[1];
+    if (remainingImports.get(`${binding[3]}:${binding[1]}`) === local) continue;
+    const owner = findOwner(icons, (entry) => entry.includes(`<${local} `));
+    if (owner) icons = keepOwnedLine(icons, ICONS_IMPORTS_MARKER, owner, line);
+  }
+  await writeFile6(target.navPath, nav.join("\n"), "utf-8");
+  await writeFile6(target.routesPath, routes.join("\n"), "utf-8");
+  await writeFile6(target.iconPath, icons.join("\n"), "utf-8");
+}
+
+// src/tarball.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir as mkdir4, readFile as readFile8 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+var execFileAsync = promisify(execFile);
+function toTarPath(p) {
+  return p.replace(/\\/g, "/");
+}
+async function extractTarball(tarballPath, destDir) {
+  await mkdir4(destDir, { recursive: true });
+  const src = toTarPath(tarballPath);
+  const dest = toTarPath(destDir);
+  try {
+    await execFileAsync("tar", ["-xzf", src, "-C", dest]);
+    return;
+  } catch {
+  }
+  try {
+    await execFileAsync("tar", ["--force-local", "-xzf", src, "-C", dest]);
+  } catch (err) {
+    const detail = (err instanceof Error ? err.message : String(err)).split("\n")[0];
+    fail(`couldn't unpack the template \u2014 ${detail}`);
+  }
+}
+async function readTarballManifest(extractedDir) {
+  const path = join8(extractedDir, "tarball.json");
+  return JSON.parse(await readFile8(path, "utf-8"));
+}
+function variantRoot(extractedDir, manifest) {
+  const variant = manifest.variants.find((v) => v.framework === "nextjs" && v.language === "typescript");
+  if (!variant) fail(`tarball has no nextjs/typescript variant`);
+  return join8(extractedDir, variant.path);
+}
+
+// src/commands/add-page.ts
+var KNOWN_SLUGS = ["crm", "project-management", "sales-inventory", "ai-chat"];
+function configPaths(projectDir) {
+  return {
+    navPath: join9(projectDir, "src", "configs", "navigation.config.ts"),
+    routesPath: join9(projectDir, "src", "configs", "routes.config.ts"),
+    iconPath: join9(projectDir, "src", "configs", "navigation-icon.config.tsx")
+  };
+}
+async function collectFilesUnder(dir) {
+  const out = [];
+  if (!existsSync9(dir)) return out;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join9(dir, entry.name);
+    if (entry.isDirectory()) out.push(...await collectFilesUnder(full));
+    else if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+var COMPONENT_ALIAS = /^@\/components\/(ui|composites|patterns|layouts|blocks)\/([^/]+)/;
+var SCRIPT_FILE = /\.[cm]?[jt]sx?$/;
+var COMMENT = String.raw`\/\/[^\n]*|\/\*[\s\S]*?\*\/`;
+var SPACE = String.raw`(?:\s|${COMMENT})*`;
+var IDENTIFIER = String.raw`[$_\p{ID_Start}][$_\p{ID_Continue}\u200c\u200d]*`;
+var NAMED = String.raw`\{[^}]*\}`;
+var NAMESPACE = String.raw`\*${SPACE}as\b${SPACE}${IDENTIFIER}`;
+var BINDINGS = String.raw`(?:type\b${SPACE})?(?:${IDENTIFIER}(?:${SPACE},${SPACE}(?:${NAMED}|${NAMESPACE}))?|${NAMED}|${NAMESPACE})`;
+var IMPORT_SPEC = new RegExp(
+  String.raw`${COMMENT}|(?<![\p{ID_Continue}$.])(?:import\b${SPACE}(?:\(${SPACE}|(${BINDINGS})${SPACE}from\b${SPACE})?|export\b${SPACE}(?:type\b${SPACE})?(${NAMED}|${NAMESPACE}|\*)${SPACE}from\b${SPACE})(["'])([^"'\r\n]+)\3|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'`,
+  "gu"
+);
+var EXPORTED_NAME = /^\s*export\s+(?:(?:declare|async|abstract)\s+)*(?:const|let|var|function|class|interface|type|enum|namespace)\s+([\w$]+)|^\s*export\s+(default)\b|^\s*export\s+(?:type\s+)?\{([^}]+)\}/gm;
+function namedBindings(clause) {
+  const body = clause.match(/\{([^}]*)\}/)?.[1];
+  return body?.replace(/\/\/[^\n]*|\/\*[\s\S]*?\*\//g, "").split(",").map((entry) => entry.trim().replace(/^type\s+/, "")) ?? [];
+}
+function importedNames(imports, reexports) {
+  if (imports) imports = imports.replace(new RegExp(COMMENT, "g"), " ");
+  const names = namedBindings(imports ?? reexports ?? "").map((binding) => binding.split(/\s+as\s+/)[0]);
+  if (imports && /^\s*(?:type\s+)?[$\w]+\s*(?:,|$)/.test(imports)) names.push("default");
+  return names.filter(Boolean);
+}
+function exportedNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const [statement, declared, defaultName, list] of source.matchAll(EXPORTED_NAME)) {
+    if (declared || defaultName) names.add(declared ?? defaultName);
+    if (list) {
+      for (const binding of namedBindings(statement)) names.add(binding.split(/\s+as\s+/).at(-1));
+    }
+  }
+  return names;
+}
+function resolveModule(variant, base) {
+  const rel = relative2(variant, base);
+  if (rel === ".." || rel.startsWith(".." + sep2) || isAbsolute2(rel)) return void 0;
+  const candidates = [base, ...[".ts", ".tsx", ".js", ".jsx"].map((ext) => base + ext)];
+  return candidates.find((file) => existsSync9(file));
+}
+async function checkOverlayConsumers(projectDir, writes, removedExports, pageId) {
+  if (!removedExports.size) return;
+  const sourceRoot = join9(projectDir, "src");
+  for (const file of await collectFilesUnder(sourceRoot)) {
+    if (writes.has(file) || !SCRIPT_FILE.test(file)) continue;
+    const source = await readFile9(file, "utf-8");
+    for (const [, imports, reexports, , spec] of source.matchAll(IMPORT_SPEC)) {
+      if (!spec) continue;
+      const base = spec.startsWith("@/") ? resolve2(sourceRoot, spec.slice(2)) : spec.startsWith("./") || spec.startsWith("../") ? resolve2(dirname4(file), spec) : void 0;
+      let resolved = base && resolveModule(projectDir, base);
+      if (resolved && statSync(resolved).isDirectory()) resolved = resolveModule(projectDir, join9(resolved, "index"));
+      if (!resolved) continue;
+      const removed = removedExports.get(resolved);
+      const missing = removed && importedNames(imports, reexports).find((name) => removed.has(name));
+      if (missing) {
+        fail(`can't add '${pageId}': replacing ${relative2(projectDir, resolved)} removes '${missing}', used by ${relative2(projectDir, file)}`);
+      }
+    }
+  }
+}
+function packageName(spec) {
+  if (spec.startsWith("node:") || isBuiltin(spec)) return void 0;
+  return spec.match(/^(?:@[^/\s]+\/)?[\w.-]+(?=\/|$)/)?.[0];
+}
+function mergePagePins(project, reference, packages, componentPins) {
+  let changed = false;
+  const has = (name) => project.dependencies?.[name] !== void 0 || project.devDependencies?.[name] !== void 0;
+  for (const name of /* @__PURE__ */ new Set([...packages, ...componentPins.keys()])) {
+    if (!has(name)) {
+      const pin = reference.dependencies?.[name] ?? reference.devDependencies?.[name] ?? componentPins.get(name);
+      if (pin) {
+        (project.dependencies ??= {})[name] = pin;
+        changed = true;
+      } else {
+        warn(`no template package pin for '${name}'`);
+      }
+    }
+    if (name.startsWith("@types/")) continue;
+    const types = "@types/" + (name.startsWith("@") ? name.slice(1).replace("/", "__") : name);
+    const typePin = reference.devDependencies?.[types] ?? reference.dependencies?.[types];
+    if (typePin && !has(types)) {
+      (project.devDependencies ??= {})[types] = typePin;
+      changed = true;
+    }
+  }
+  return changed;
+}
+async function runAddPage(argv) {
+  const { flags, values } = parseFlags(argv, ["tarball", "local", "token"]);
+  const template = KNOWN_SLUGS.find((s) => flags.has(s));
+  if (!template) fail(`template flag required, one of: ${KNOWN_SLUGS.map((s) => `--${s}`).join(", ")}`);
+  const pageFlag = [...flags].find((f) => f !== template && f !== "overwrite");
+  if (!pageFlag) fail(`page flag required (e.g. --deals)`);
+  const pageId = `${template}/${pageFlag}`;
+  const projectDir = process.cwd();
+  const overwrite = flags.has("overwrite");
+  const cj = await loadOrDetectComponentsJson(projectDir);
+  if (cj.installed.pages.includes(pageId) && !overwrite) {
+    info(`page '${pageId}' already installed \u2014 nothing to do`);
+    return;
+  }
+  const tarballPath = await resolveTarball(template, { tarball: values.tarball, local: values.local, token: values.token });
+  const scratch = await mkdtemp(join9(tmpdir(), "nateui-page-"));
+  try {
+    let addComponent2 = function(id) {
+      if (!componentItems.has(id)) components.add(id);
+    }, useTemplateComponent2 = function(id) {
+      const subpath = /^(ui|composites|patterns|layouts|blocks)\//.test(id) ? "components/" + id : id;
+      const base = resolve2(variant, "src", subpath);
+      if (!resolveModule(variant, base)) return false;
+      queue.push({ base, direct: false });
+      return true;
+    }, walkImports2 = function(content, file) {
+      for (const [, imports, reexports, , spec] of content.matchAll(IMPORT_SPEC)) {
+        if (!spec) continue;
+        if (spec.startsWith("@/")) {
+          const component = spec.match(COMPONENT_ALIAS);
+          const id = component && `${component[1]}/${component[2].replace(SCRIPT_FILE, "")}`;
+          if (id && catalogIds.has(id)) addComponent2(id);
+          else queue.push({ base: resolve2(variant, "src", spec.slice(2)), direct: false, names: importedNames(imports, reexports) });
+        } else if (spec.startsWith("./") || spec.startsWith("../")) {
+          queue.push({ base: resolve2(dirname4(file), spec), direct: false, names: importedNames(imports, reexports) });
+        } else {
+          const name = packageName(spec);
+          if (name) packages.add(name);
+        }
+      }
+    };
+    var addComponent = addComponent2, useTemplateComponent = useTemplateComponent2, walkImports = walkImports2;
+    await extractTarball(tarballPath, scratch);
+    const manifest = await readTarballManifest(scratch);
+    const variant = variantRoot(scratch, manifest);
+    const registry = JSON.parse(await readFile9(join9(variant, "registry.json"), "utf-8"));
+    const page = registry.pages.find((p) => p.id === pageId);
+    if (!page) fail(`unknown page '${pageFlag}' for template '${template}' \u2014 run: nateui list --template ${template}`);
+    const paths = configPaths(projectDir);
+    for (const p of Object.values(paths)) {
+      if (!existsSync9(p)) fail(`${p} not found \u2014 is this a NateUI-scaffolded project?`);
+    }
+    assertMarkersPresent(await checkMarkers(paths));
+    const catalog = await resolveCatalog(values.local, values.token);
+    const catalogIds = new Set((await catalog.index()).items.map((item) => item.id));
+    const components = /* @__PURE__ */ new Set();
+    const packages = new Set(page.npmDeps.filter((name) => !name.startsWith("node:") && !isBuiltin(name)));
+    const overlays = registry.starter?.overlays ?? {};
+    const configTargets = new Set(Object.values(paths));
+    const plan = /* @__PURE__ */ new Map();
+    const writes = /* @__PURE__ */ new Set();
+    const removedExports = /* @__PURE__ */ new Map();
+    const queue = [page.routeDir, ...page.sharedFiles].map((path) => ({ base: resolve2(variant, path), direct: true }));
+    const visited = /* @__PURE__ */ new Set();
+    const componentItems = /* @__PURE__ */ new Map();
+    const componentPins = /* @__PURE__ */ new Map();
+    for (const id of page.componentDeps) {
+      if (catalogIds.has(id) || !useTemplateComponent2(id)) addComponent2(id);
+    }
+    let cursor = 0;
+    while (cursor < queue.length || components.size) {
+      if (cursor === queue.length) {
+        const items = await closure([...components], {
+          ...catalog,
+          async item(id) {
+            const cached = componentItems.get(id);
+            if (cached) return cached;
+            const item = await catalog.item(id);
+            const registryDependencies = item.registryDependencies.filter(
+              (dependency) => catalogIds.has(dependency) || !useTemplateComponent2(dependency)
+            );
+            return { ...item, registryDependencies };
+          }
+        });
+        components.clear();
+        for (const [id, item] of items) {
+          if (componentItems.has(id)) continue;
+          componentItems.set(id, item);
+          for (const [name, pin] of Object.entries(item.dependencies)) {
+            if (!componentPins.has(name)) componentPins.set(name, pin);
+          }
+          const files = planFiles([item], projectDir, cj.installPath, cj.alias.scheme);
+          for (const [index, file2] of files.entries()) {
+            if (plan.has(file2.targetPath) || configTargets.has(file2.targetPath)) continue;
+            plan.set(file2.targetPath, file2);
+            if (await writeAction(file2, overwrite) !== "written") continue;
+            writes.add(file2.targetPath);
+            const { path, content: content2 } = item.files[index];
+            if (SCRIPT_FILE.test(path)) walkImports2(content2, join9(variant, "src", path));
+          }
+        }
+        continue;
+      }
+      const { base, direct, names } = queue[cursor++];
+      const file = resolveModule(variant, base);
+      if (!file || visited.has(file)) continue;
+      if (statSync(file).isDirectory()) {
+        visited.add(file);
+        for (const entry of await collectFilesUnder(file)) queue.push({ base: entry, direct, names });
+        continue;
+      }
+      const rel = relative2(variant, file);
+      const targetPath = join9(projectDir, rel);
+      if (configTargets.has(targetPath) || plan.has(targetPath)) continue;
+      const overlayPath = overlays[rel.split(sep2).join("/")];
+      const exists2 = existsSync9(targetPath);
+      if (!direct && !overlayPath && exists2) continue;
+      const script = SCRIPT_FILE.test(file);
+      const content = script || overlayPath ? await readFile9(file, "utf-8") : await readFile9(file);
+      const planned = { targetPath, content };
+      if (overlayPath) {
+        const overlay = resolveModule(variant, resolve2(variant, overlayPath));
+        if (overlay) planned.starterOverlay = { content: await readFile9(overlay, "utf-8"), pageId };
+      }
+      if (!direct && exists2 && planned.starterOverlay && typeof content === "string") {
+        const starterExports = exportedNames(planned.starterOverlay.content);
+        const fullExports = exportedNames(content);
+        const wanted = names?.length ? names : [...fullExports];
+        if (!wanted.some((name) => fullExports.has(name) && !starterExports.has(name))) continue;
+      }
+      visited.add(file);
+      plan.set(targetPath, planned);
+      if (await writeAction(planned, overwrite) !== "written") continue;
+      writes.add(targetPath);
+      if (typeof content !== "string" || !script) continue;
+      if (exists2 && planned.starterOverlay) {
+        const fullExports = exportedNames(content);
+        const removed = [...exportedNames(await readFile9(targetPath, "utf-8"))].filter((name) => !fullExports.has(name));
+        if (removed.length) removedExports.set(targetPath, new Set(removed));
+      }
+      walkImports2(content, file);
+    }
+    await checkOverlayConsumers(projectDir, writes, removedExports, pageId);
+    const refPkg = JSON.parse(await readFile9(join9(variant, "package.json"), "utf-8"));
+    const projectPkgPath = join9(projectDir, "package.json");
+    const projectPkg = existsSync9(projectPkgPath) ? JSON.parse(await readFile9(projectPkgPath, "utf-8")) : void 0;
+    const npmChanged = projectPkg && mergePagePins(projectPkg, refPkg, packages, componentPins);
+    await applyWritePlan([...plan.values()], overwrite);
+    if (npmChanged) await writeFile7(projectPkgPath, JSON.stringify(projectPkg, null, 2) + "\n", "utf-8");
+    await spliceAdd(paths, template, pageFlag, page.registration);
+    addInstalledPage(cj, pageId);
+    await writeComponentsJson(projectDir, cj);
+    info(`added page ${pageId}`);
+    if (npmChanged) info(`run: ${installCommand(projectDir)}`);
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+
+// src/commands/describe.ts
+async function runDescribe(argv) {
+  const { values, positional } = parseFlags(argv, ["local", "token"]);
+  const name = positional[0];
+  if (!name) fail(`component name required (e.g. nateui describe button)`);
+  const catalog = await resolveCatalog(values.local, values.token);
+  const index = await catalog.index();
+  const id = resolveItemId(name, index);
+  const item = await catalog.item(id);
+  const projectDir = process.cwd();
+  const installed = componentsJsonExists(projectDir) && (await readComponentsJson(projectDir)).installed.components.includes(id);
+  info(`${id}${installed ? " (installed)" : ""}`);
+  info(`tier: ${item.tier}`);
+  info(`files:`);
+  for (const f of item.files) info(`  ${f.path}`);
+  if (item.registryDependencies.length) info(`registryDependencies: ${item.registryDependencies.join(", ")}`);
+  const deps = Object.entries(item.dependencies);
+  if (deps.length) {
+    info(`dependencies:`);
+    for (const [dep, pin] of deps) info(`  ${dep}@${pin}`);
+  }
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync11 } from "node:fs";
+import { readdir as readdir3 } from "node:fs/promises";
+
+// src/chassis-write.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { cp, mkdir as mkdir5 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+async function writeChassis(framework, targetDir) {
+  const src = join10(CHASSIS_DIR, framework);
+  if (!existsSync10(src)) {
+    fail(
+      `bundled chassis for '${framework}' not found at ${src} \u2014 this package build is broken (run \`pnpm factory --chassis\` then \`pnpm build\` in nateui-cli/)`
+    );
+  }
+  await mkdir5(targetDir, { recursive: true });
+  await cp(src, targetDir, { recursive: true });
+}
+
+// src/commands/init.ts
+var LAYERS = ["ui", "composites", "layouts", "patterns", "blocks"];
+function freeItemIds(index) {
+  return index.items.filter((i) => i.kind === "ui" && !i.hidden).map((i) => i.id);
+}
+function layerItemIds(index, layers) {
+  const set = new Set(layers);
+  return index.items.filter((i) => set.has(i.kind) && !i.hidden).map((i) => i.id);
+}
+async function runInit(argv) {
+  const { flags, values, positional } = parseFlags(argv, ["local", "layers", "token"]);
+  const dir = positional[0];
+  if (!dir) fail(`target directory required (e.g. nateui init --nextjs my-app)`);
+  if (existsSync11(dir) && (await readdir3(dir)).length > 0) {
+    fail(`target '${dir}' is not empty`);
+  }
+  const framework = flags.has("nextjs") ? "nextjs" : flags.has("vite") ? "vite" : void 0;
+  if (!framework) fail(`framework flag required: --nextjs or --vite`);
+  const catalog = await resolveCatalog(values.local, values.token);
+  const index = await catalog.index();
+  let seedIds;
+  if (flags.has("pro")) {
+    let layers;
+    if (values.layers) {
+      layers = values.layers.split(",").map((l) => l.trim());
+      const unknown = layers.find((l) => !LAYERS.includes(l));
+      if (unknown) fail(`unknown layer '${unknown}' \u2014 one of ${LAYERS.join(", ")}`);
+    } else {
+      layers = [...LAYERS];
+    }
+    seedIds = layerItemIds(index, layers);
+  } else {
+    seedIds = freeItemIds(index);
+  }
+  const items = await closure(seedIds, catalog);
+  info("");
+  for (const line of npmDependencyLines(items.values())) info(line);
+  info("");
+  await writeChassis(framework, dir);
+  const results = await writeItemFiles(items.values(), dir, "src", true);
+  await mergeNpmDependencies(items.values(), dir);
+  const cj = newComponentsJson(framework);
+  addInstalledComponents(cj, [...items.keys()]);
+  await writeComponentsJson(dir, cj);
+  info(`scaffolded ${results.length} files -> ${dir}`);
+  info(`cd ${dir} && ${installCommand(dir)} && ${devCommand(dir)}`);
+}
+
+// src/commands/init-template.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { mkdir as mkdir6, mkdtemp as mkdtemp2, readdir as readdir5, rename, rm as rm3 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join12 } from "node:path";
+
+// src/starter-derive.ts
+import { existsSync as existsSync12, statSync as statSync2 } from "node:fs";
+import { cp as cp2, readFile as readFile10, readdir as readdir4, rm as rm2, rmdir, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname5, join as join11, relative as relative3, resolve as resolve3 } from "node:path";
+var KEEP_WHOLESALE = /* @__PURE__ */ new Set(["ui", "svg"]);
+var KEEP_ALWAYS = ["src/utils/axios/"];
+var TOOLCHAIN_DEPS = /* @__PURE__ */ new Set([
+  "next",
+  "react",
+  "react-dom",
+  "typescript",
+  "tailwindcss",
+  "@tailwindcss/postcss",
+  "@tailwindcss/typography",
+  "eslint",
+  "eslint-config-next",
+  "@types/node",
+  "@types/react",
+  "@types/react-dom",
+  "axios"
+]);
+var PEER_DEPS = /* @__PURE__ */ new Map([
+  ["@tiptap/pm", ["@tiptap/react", "@tiptap/starter-kit"]]
+]);
+var DEMO_ONLY_DEPS = /* @__PURE__ */ new Set(["@opennextjs/cloudflare", "wrangler"]);
+var DEMO_ONLY_SCRIPTS = /* @__PURE__ */ new Set(["cf:build", "cf:dry-run", "preview"]);
+var IMPORT_RE = /\b(?:from|import)\s*\(?\s*(['"])([^'"]+)\1/g;
+var ASSET_DIR_RE = /\/img\/([A-Za-z0-9_-]+)\//g;
+var STARTER_PAGES = {
+  "ai-chat": /* @__PURE__ */ new Set(["chat"])
+};
+var STARTER_API = {
+  "ai-chat": /* @__PURE__ */ new Set(["settings"])
+};
+function posix2(p) {
+  return p.replace(/\\/g, "/");
+}
+async function collectFiles(dir, filter) {
+  const out = [];
+  const entries = await readdir4(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join11(dir, entry.name);
+    if (entry.isDirectory()) out.push(...await collectFiles(full, filter));
+    else if (!filter || filter(entry.name)) out.push(full);
+  }
+  return out;
+}
+async function pruneEmptyDirs(dir) {
+  const entries = await readdir4(dir, { withFileTypes: true });
+  let remaining = entries.length;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (await pruneEmptyDirs(join11(dir, entry.name))) remaining--;
+  }
+  if (remaining === 0) {
+    await rmdir(dir);
+    return true;
+  }
+  return false;
+}
+function isPrunable(relPath) {
+  if (relPath.startsWith("src/app/")) return false;
+  if (KEEP_ALWAYS.some((prefix) => relPath.startsWith(prefix))) return false;
+  const m = relPath.match(/^src\/components\/([^/]+)\//);
+  if (m) return !KEEP_WHOLESALE.has(m[1]);
+  return true;
+}
+function importSpecs(text) {
+  const specs = [];
+  IMPORT_RE.lastIndex = 0;
+  let m;
+  while (m = IMPORT_RE.exec(text)) specs.push(m[2]);
+  return specs;
+}
+function resolveSpec(spec, fromFile, rootDir) {
+  let base;
+  if (spec.startsWith("@/")) {
+    base = resolve3(rootDir, "src", spec.slice(2));
+  } else if (spec.startsWith("./") || spec.startsWith("../")) {
+    base = resolve3(dirname5(fromFile), spec);
+  } else {
+    return null;
+  }
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}.mjs`,
+    `${base}.css`,
+    `${base}.json`,
+    join11(base, "index.ts"),
+    join11(base, "index.tsx")
+  ];
+  return candidates.find((c) => existsSync12(c) && statSync2(c).isFile()) ?? null;
+}
+function packageOf(spec) {
+  if (spec.startsWith("node:")) return null;
+  const parts = spec.split("/");
+  if (spec.startsWith("@")) return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  return parts[0] || null;
+}
+async function pruneUnreachable(rootDir) {
+  const srcDir = join11(rootDir, "src");
+  const files = await collectFiles(srcDir, (name) => /\.(ts|tsx)$/.test(name));
+  const rel = (f) => posix2(relative3(rootDir, f));
+  const roots = files.filter((f) => !isPrunable(rel(f)));
+  const reached = new Set(roots.map((f) => resolve3(f)));
+  const queue = [...roots];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    const text = await readFile10(file, "utf-8");
+    for (const spec of importSpecs(text)) {
+      const target = resolveSpec(spec, file, rootDir);
+      if (!target) continue;
+      const key = resolve3(target);
+      if (reached.has(key)) continue;
+      reached.add(key);
+      if (/\.(ts|tsx)$/.test(key)) queue.push(key);
+    }
+  }
+  for (const file of files) {
+    if (reached.has(resolve3(file))) continue;
+    await rm2(file, { force: true });
+  }
+}
+async function assertNoDanglingImports(rootDir) {
+  const files = await collectFiles(join11(rootDir, "src"), (name) => /\.(ts|tsx)$/.test(name));
+  const danglers = [];
+  for (const file of files) {
+    const text = await readFile10(file, "utf-8");
+    for (const spec of importSpecs(text)) {
+      if (!spec.startsWith("@/") && !spec.startsWith(".")) continue;
+      if (resolveSpec(spec, file, rootDir)) continue;
+      danglers.push(`${posix2(relative3(rootDir, file))} -> ${spec}`);
+    }
+  }
+  if (danglers.length > 0) {
+    throw new Error(`pruning left ${danglers.length} dangling import(s):
+  ${danglers.join("\n  ")}`);
+  }
+}
+async function pruneAssets(rootDir) {
+  const imgDir = join11(rootDir, "public", "img");
+  if (!existsSync12(imgDir)) return;
+  const referenced = /* @__PURE__ */ new Set();
+  for (const file of await collectFiles(join11(rootDir, "src"), (name) => /\.(ts|tsx|css|json)$/.test(name))) {
+    const text = await readFile10(file, "utf-8");
+    for (const m of text.matchAll(ASSET_DIR_RE)) referenced.add(m[1]);
+  }
+  for (const entry of await readdir4(imgDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (referenced.has(entry.name)) continue;
+    await rm2(join11(imgDir, entry.name), { recursive: true, force: true });
+  }
+}
+async function importedPackages(rootDir) {
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of await collectFiles(join11(rootDir, "src"), (name) => /\.(ts|tsx)$/.test(name))) {
+    const text = await readFile10(file, "utf-8");
+    for (const spec of importSpecs(text)) {
+      if (spec.startsWith("@/") || spec.startsWith(".")) continue;
+      const pkg = packageOf(spec);
+      if (pkg) packages.add(pkg);
+    }
+  }
+  return packages;
+}
+async function deriveManifest(rootDir, slug) {
+  const manifestPath = join11(rootDir, "package.json");
+  const manifest = JSON.parse(await readFile10(manifestPath, "utf-8"));
+  manifest.name = `nateui-${slug}-starter`;
+  const used = await importedPackages(rootDir);
+  const declared = /* @__PURE__ */ new Set([
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {})
+  ]);
+  const keep = (name) => {
+    if (DEMO_ONLY_DEPS.has(name)) return false;
+    if (TOOLCHAIN_DEPS.has(name)) return true;
+    const dependents = PEER_DEPS.get(name);
+    if (dependents) return dependents.some((dep) => used.has(dep));
+    if (name.startsWith("@types/")) {
+      const typed = name.slice("@types/".length);
+      return declared.has(typed) ? used.has(typed) : true;
+    }
+    return used.has(name);
+  };
+  const filterDeps = (deps) => {
+    if (!deps) return void 0;
+    const out = {};
+    for (const [name, range] of Object.entries(deps)) {
+      if (keep(name)) out[name] = range;
+    }
+    return out;
+  };
+  manifest.dependencies = filterDeps(manifest.dependencies);
+  manifest.devDependencies = filterDeps(manifest.devDependencies);
+  if (manifest.scripts) {
+    for (const name of Object.keys(manifest.scripts)) {
+      if (DEMO_ONLY_SCRIPTS.has(name)) delete manifest.scripts[name];
+    }
+  }
+  await writeFile8(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+async function subtractPages(starterDir, slug) {
+  const pagesDir = join11(starterDir, "src", "app", "(protected-pages)");
+  if (!existsSync12(pagesDir)) {
+    throw new Error("starter derivation: src/app/(protected-pages) not found in the tarball's demo tree");
+  }
+  const keep = STARTER_PAGES[slug] ?? /* @__PURE__ */ new Set();
+  const removed = [];
+  for (const entry of await readdir4(pagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (keep.has(entry.name)) continue;
+    removed.push(entry.name);
+    await rm2(join11(pagesDir, entry.name), { recursive: true, force: true });
+  }
+  return removed;
+}
+async function subtractApi(starterDir, removedPages, slug) {
+  const apiDir = join11(starterDir, "src", "app", "api");
+  if (!existsSync12(apiDir)) return;
+  const removedSet = new Set(removedPages);
+  const explicit = STARTER_API[slug] ?? /* @__PURE__ */ new Set();
+  for (const entry of await readdir4(apiDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (!removedSet.has(entry.name) && !explicit.has(entry.name)) continue;
+    await rm2(join11(apiDir, entry.name), { recursive: true, force: true });
+  }
+}
+async function applyOverlay(starterDir, overlayDir) {
+  await cp2(overlayDir, starterDir, { recursive: true, force: true });
+}
+async function deriveStarterInPlace(variantDir, slug) {
+  const overlayDir = join11(variantDir, "starter");
+  if (!existsSync12(overlayDir)) {
+    throw new Error(`starter derivation: no starter/ overlay found in the tarball for '${slug}'`);
+  }
+  const removedPages = await subtractPages(variantDir, slug);
+  await subtractApi(variantDir, removedPages, slug);
+  await applyOverlay(variantDir, overlayDir);
+  await pruneUnreachable(variantDir);
+  await assertNoDanglingImports(variantDir);
+  await pruneAssets(variantDir);
+  await deriveManifest(variantDir, slug);
+  await pruneEmptyDirs(join11(variantDir, "src"));
+  await rm2(overlayDir, { recursive: true, force: true });
+  await rm2(join11(variantDir, "registry.json"), { force: true });
+}
+
+// src/commands/init-template.ts
+var KNOWN_SLUGS2 = ["crm", "project-management", "sales-inventory", "ai-chat"];
+async function runInitTemplate(argv) {
+  const { flags, values, positional } = parseFlags(argv, ["tarball", "local", "token"]);
+  const slug = KNOWN_SLUGS2.find((s) => flags.has(s));
+  if (!slug) fail(`template flag required, one of: ${KNOWN_SLUGS2.map((s) => `--${s}`).join(", ")}`);
+  const dir = positional[0];
+  if (!dir) fail(`target directory required (e.g. nateui init-template --crm my-app)`);
+  if (existsSync13(dir) && (await readdir5(dir)).length > 0) {
+    fail(`target '${dir}' is not empty`);
+  }
+  const tarballPath = await resolveTarball(slug, { tarball: values.tarball, local: values.local, token: values.token });
+  const scratch = await mkdtemp2(join12(tmpdir2(), "nateui-"));
+  try {
+    const variant = await withSpinner("setting up your project", async () => {
+      await extractTarball(tarballPath, scratch);
+      const manifest = await readTarballManifest(scratch);
+      const root = variantRoot(scratch, manifest);
+      await deriveStarterInPlace(root, slug);
+      return root;
+    });
+    await mkdir6(join12(dir, ".."), { recursive: true }).catch(() => {
+    });
+    await rename(variant, dir);
+    const cj = newComponentsJson("nextjs");
+    await writeComponentsJson(dir, cj);
+    info(`scaffolded ${slug} -> ${dir}`);
+    info(`cd ${dir} && ${installCommand(dir)} && ${devCommand(dir)}`);
+  } finally {
+    await rm3(scratch, { recursive: true, force: true });
+  }
+}
+
+// src/commands/list.ts
+import { mkdtemp as mkdtemp3, readFile as readFile11, rm as rm4 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join13 } from "node:path";
+async function runList(argv) {
+  const { flags, values } = parseFlags(argv, ["local", "tarball", "template", "token"]);
+  if (values.template) {
+    if (!values.tarball && !values.local) {
+      const catalog2 = await resolveCatalog(void 0);
+      const registry = await catalog2.pageRegistry(values.template);
+      for (const page of registry.pages) info(`${page.id}  ${page.title}`);
+      return;
+    }
+    const tarballPath = await resolveTarball(values.template, { tarball: values.tarball, local: values.local, token: values.token });
+    const scratch = await mkdtemp3(join13(tmpdir3(), "nateui-list-"));
+    try {
+      await extractTarball(tarballPath, scratch);
+      const manifest = await readTarballManifest(scratch);
+      const variant = variantRoot(scratch, manifest);
+      const registry = JSON.parse(await readFile11(join13(variant, "registry.json"), "utf-8"));
+      for (const page of registry.pages) info(`${page.id}  ${page.title}`);
+    } finally {
+      await rm4(scratch, { recursive: true, force: true });
+    }
+    return;
+  }
+  if (flags.has("installed")) {
+    const projectDir = process.cwd();
+    if (!componentsJsonExists(projectDir)) {
+      fail(`no components.json found \u2014 run nateui init or nateui add first`);
+    }
+    const cj = await readComponentsJson(projectDir);
+    for (const id of cj.installed.components) info(id);
+    for (const id of cj.installed.pages) info(id);
+    return;
+  }
+  const catalog = await resolveCatalog(values.local, values.token);
+  const index = await catalog.index();
+  for (const item of index.items) {
+    if (item.hidden) continue;
+    info(`${item.id}  ${item.kind}  ${item.tier}`);
+  }
+}
+
+// src/commands/login.ts
+async function runLogin() {
+  if (!process.stdin.isTTY) fail(`login requires an interactive terminal`);
+  await runLoginFlow();
+}
+
+// src/commands/remove-page.ts
+import { existsSync as existsSync14 } from "node:fs";
+import { rm as rm5 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+async function runRemovePage(argv) {
+  const { flags } = parseFlags(argv, []);
+  const pageFlag = [...flags][0];
+  if (!pageFlag) fail(`page flag required (e.g. nateui remove-page --deals)`);
+  const projectDir = process.cwd();
+  if (!componentsJsonExists(projectDir)) fail(`no components.json found in ${projectDir}`);
+  const cj = await readComponentsJson(projectDir);
+  const installed = cj.installed.pages.find((p) => p.endsWith(`/${pageFlag}`));
+  if (!installed) fail(`no installed page '${pageFlag}' (see nateui list --installed)`);
+  const [template] = installed.split("/");
+  const routeDir = join14(projectDir, "src", "app", "(protected-pages)", pageFlag);
+  if (existsSync14(routeDir)) await rm5(routeDir, { recursive: true, force: true });
+  const configs = {
+    navPath: join14(projectDir, "src", "configs", "navigation.config.ts"),
+    routesPath: join14(projectDir, "src", "configs", "routes.config.ts"),
+    iconPath: join14(projectDir, "src", "configs", "navigation-icon.config.tsx")
+  };
+  await spliceRemove(configs, template, pageFlag);
+  removeInstalledPage(cj, installed);
+  await writeComponentsJson(projectDir, cj);
+  info(`removed page ${installed}`);
+}
+
+// src/skill/installer.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { access, lstat, mkdir as mkdir7, mkdtemp as mkdtemp4, readFile as readFile12, readdir as readdir6, realpath, rename as rename2, rm as rm6, stat, writeFile as writeFile9 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute3, join as join15, relative as relative4, resolve as resolve4 } from "node:path";
+var SKILL_CLIENTS = ["codex", "claude", "cursor", "opencode", "vscode"];
+var CURRENT_CLI_VERSION = "0.0.3";
+var DEFAULT_DESIGN_ASSET = "assets/default-design.md";
+var MAX_BUNDLE_BYTES = 2e6;
+var LOCAL_MANIFEST = ".nateui-skill-manifest.json";
+var RELEASE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+var SkillInstallError = class extends NateuiError {
+  code;
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "SkillInstallError";
+  }
+};
+var SkillSetupError = class extends SkillInstallError {
+  result;
+  constructor(error, result) {
+    const code = error instanceof SkillInstallError ? error.code : "SETUP_FAILED";
+    const message = error instanceof Error ? error.message : String(error);
+    super(code, error instanceof SkillInstallError ? message.slice(code.length + 2) : message);
+    this.result = { ...result, error: { code, message } };
+  }
+};
+function fail2(code, message) {
+  throw new SkillInstallError(code, message);
+}
+function assertObject(value, label, code = "INVALID_BUNDLE") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail2(code, `${label} must be an object`);
+}
+function requiredString(value, label) {
+  if (typeof value !== "string") fail2("INVALID_BUNDLE", `${label} must be a string`);
+  return value;
+}
+function nonnegativeInteger(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > MAX_BUNDLE_BYTES) fail2("INVALID_BUNDLE", `${label} must be a valid byte count`);
+  return value;
+}
+function safeSkillPath(value) {
+  const parts = typeof value === "string" ? value.split("/") : [];
+  const valid = typeof value === "string" && value !== "" && !value.includes("\\") && !value.startsWith("/") && parts.every((part) => part !== "" && part !== "." && part !== ".." && /^[A-Za-z0-9._-]+$/.test(part) && !part.endsWith(".") && !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part)) && (value === "SKILL.md" || value === DEFAULT_DESIGN_ASSET || parts[0] === "references" && parts.length > 1);
+  if (!valid) {
+    fail2("INVALID_BUNDLE", `unsafe public skill path: ${String(value)}`);
+  }
+  return value;
+}
+function pathsOverlap(left, right) {
+  const a = left.toLowerCase();
+  const b = right.toLowerCase();
+  return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function parseSemver(value, label) {
+  if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) {
+    fail2("INVALID_BUNDLE", `${label} must be a semantic version`);
+  }
+  const match = value.match(/^(\d+)\.(\d+)\.(\d+)/);
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function semverGreater(a, b) {
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] > b[index];
+  }
+  return false;
+}
+function validateReleaseId(value) {
+  if (typeof value !== "string" || !RELEASE_ID_PATTERN.test(value)) fail2("INVALID_BUNDLE", "release id is invalid");
+  return value;
+}
+function rejectPrivateText(path, content) {
+  if (/(?:^|[\s"'(=])(?:[A-Za-z]:[\\/]|(?:\.\.\/[\\/]*)?(?:wiki|private|\.nateui)[\\/]|platform[\\/]src|factory[\\/]dist|code[\\/]agent)/i.test(content)) {
+    fail2("INVALID_BUNDLE", `public skill file ${path} contains an internal path`);
+  }
+}
+function validateSkillBundle(input) {
+  assertObject(input, "skill bundle");
+  if (input.schemaVersion !== 1) fail2("INVALID_BUNDLE", "unsupported skill bundle schema");
+  const releaseId = validateReleaseId(input.releaseId);
+  assertObject(input.manifest, "skill manifest");
+  const rawManifest = input.manifest;
+  if (rawManifest.schemaVersion !== 1 || rawManifest.releaseId !== releaseId) fail2("INVALID_BUNDLE", "skill manifest identity is inconsistent");
+  const skillVersion = requiredString(rawManifest.skillVersion, "skillVersion");
+  const minimumCliVersion = requiredString(rawManifest.minimumCliVersion, "minimumCliVersion");
+  const parsedSkillVersion = parseSemver(skillVersion, "skillVersion");
+  const minimum = parseSemver(minimumCliVersion, "minimumCliVersion");
+  if (semverGreater(minimum, parseSemver(CURRENT_CLI_VERSION, "current CLI version"))) {
+    fail2("CLI_TOO_OLD", `skill requires CLI ${minimumCliVersion} or newer`);
+  }
+  const declaredDeliveryBytes = nonnegativeInteger(rawManifest.deliveryBytes, "skill delivery size");
+  if (!Array.isArray(rawManifest.files) || rawManifest.files.length === 0) fail2("INVALID_BUNDLE", "skill manifest has no files");
+  assertObject(input.files, "skill files");
+  const fileMap = input.files;
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  const deliveredFiles = {};
+  let deliveryBytes = 0;
+  for (const rawFile of rawManifest.files) {
+    assertObject(rawFile, "skill manifest file");
+    const path = safeSkillPath(rawFile.path);
+    const folded = path.toLowerCase();
+    if (seen.has(folded)) fail2("INVALID_BUNDLE", `duplicate skill path: ${path}`);
+    if ([...seen].some((existing) => pathsOverlap(existing, folded))) fail2("INVALID_BUNDLE", `overlapping skill paths: ${path}`);
+    seen.add(folded);
+    const fileDigest = requiredString(rawFile.sha256, `digest for ${path}`);
+    if (!/^[a-f0-9]{64}$/.test(fileDigest)) fail2("INVALID_BUNDLE", `invalid digest for ${path}`);
+    const fileBytes = nonnegativeInteger(rawFile.bytes, `byte count for ${path}`);
+    if (typeof fileMap[path] !== "string") fail2("INVALID_BUNDLE", `manifest file is missing from delivery: ${path}`);
+    const content = fileMap[path];
+    if (typeof content !== "string") fail2("INVALID_BUNDLE", `manifest file is missing from delivery: ${path}`);
+    const bytes = Buffer.from(content, "utf8");
+    if (bytes.byteLength !== fileBytes || sha256(bytes) !== fileDigest) fail2("INVALID_BUNDLE", `digest mismatch for ${path}`);
+    rejectPrivateText(path, content);
+    deliveryBytes += bytes.byteLength;
+    files.push({ path, sha256: fileDigest, bytes: fileBytes });
+    deliveredFiles[path] = content;
+  }
+  const deliveredPaths = Object.keys(fileMap);
+  if (deliveredPaths.some((path) => !seen.has(path.toLowerCase())) || deliveredPaths.length !== files.length) {
+    fail2("INVALID_BUNDLE", "delivery contains files outside its manifest");
+  }
+  if (deliveryBytes !== declaredDeliveryBytes) fail2("INVALID_BUNDLE", "deliveryBytes does not match delivered content");
+  if (!seen.has("skill.md")) fail2("INVALID_BUNDLE", "delivery must contain SKILL.md");
+  if (!semverGreater([0, 2, 0], parsedSkillVersion)) {
+    if (!seen.has(DEFAULT_DESIGN_ASSET)) fail2("INVALID_BUNDLE", `skill ${skillVersion} must include ${DEFAULT_DESIGN_ASSET}`);
+    if (semverGreater([0, 0, 2], minimum)) fail2("INVALID_BUNDLE", "theme-aware skill requires minimumCliVersion 0.0.2 or newer");
+  }
+  return {
+    schemaVersion: 1,
+    releaseId,
+    manifest: {
+      schemaVersion: 1,
+      releaseId,
+      skillVersion,
+      minimumCliVersion,
+      deliveryBytes,
+      files
+    },
+    files: deliveredFiles
+  };
+}
+var DESTINATIONS = {
+  codex: { project: [".agents", "skills", "nateui"], global: [".agents", "skills", "nateui"] },
+  claude: { project: [".claude", "skills", "nateui"], global: [".claude", "skills", "nateui"] },
+  cursor: { project: [".cursor", "skills", "nateui"], global: [".cursor", "skills", "nateui"] },
+  opencode: { project: [".opencode", "skills", "nateui"], global: [".config", "opencode", "skills", "nateui"] },
+  vscode: { project: [".github", "skills", "nateui"], global: [".copilot", "skills", "nateui"] }
+};
+var CLIENT_ROOTS = SKILL_CLIENTS.map((client) => ({
+  client,
+  path: DESTINATIONS[client].project.slice(0, -1)
+}));
+async function directoryExists(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function assertClient(value) {
+  if (value === void 0) return void 0;
+  if (!SKILL_CLIENTS.includes(value)) fail2("CLIENT_INVALID", `unsupported client '${value}'`);
+  return value;
+}
+async function resolveSkillDestination(options) {
+  if (options.path && (options.client || options.global)) fail2("DESTINATION_CONFLICT", "--path cannot be combined with --client or --global");
+  if (options.global && !options.client) fail2("CLIENT_REQUIRED", "--global requires --client");
+  if (options.path) return { destination: resolve4(options.path) };
+  const cwd = resolve4(options.cwd ?? process.cwd());
+  const home = resolve4(options.home ?? homedir2());
+  let client = assertClient(options.client);
+  if (!client) {
+    const detected = (await Promise.all(CLIENT_ROOTS.map(async ({ client: candidate, path }) => await directoryExists(join15(cwd, ...path)) ? candidate : void 0))).filter((candidate) => candidate !== void 0);
+    if (detected.length > 1) fail2("CLIENT_REQUIRED", `multiple client skill roots detected (${detected.join(", ")}); pass --client`);
+    client = detected[0] ?? "codex";
+  }
+  return {
+    client,
+    destination: join15(options.global ? home : cwd, ...DESTINATIONS[client][options.global ? "global" : "project"])
+  };
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function samePath(left, right) {
+  return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
+}
+function isMissing(error) {
+  return error.code === "ENOENT";
+}
+function assertDirectChild(path, parent, label) {
+  const relativePath = relative4(resolve4(parent), resolve4(path));
+  if (!relativePath || relativePath.startsWith("..") || isAbsolute3(relativePath) || relativePath.includes("\\") || relativePath.includes("/")) {
+    fail2("INSTALLATION_STATE_INVALID", `${label} is outside its safe parent: ${path}`);
+  }
+}
+async function ensureSafeExistingPath(path, label = "skill destination") {
+  let current = resolve4(path);
+  while (true) {
+    let entry;
+    try {
+      entry = await lstat(current);
+    } catch (error) {
+      if (!isMissing(error)) fail2("INSTALLATION_STATE_INVALID", `could not inspect the ${label}: ${current}`);
+      const parent = dirname6(current);
+      if (parent === current) return;
+      current = parent;
+      continue;
+    }
+    if (entry.isSymbolicLink()) fail2("INSTALLATION_STATE_INVALID", `symlinks and junctions are not supported in the ${label}: ${current}`);
+    let resolvedPath;
+    try {
+      resolvedPath = await realpath(current);
+    } catch {
+      fail2("INSTALLATION_STATE_INVALID", `could not resolve the ${label}: ${current}`);
+    }
+    if (!samePath(resolve4(resolvedPath), current)) {
+      fail2("INSTALLATION_STATE_INVALID", `redirecting filesystem entry is not supported in the ${label}: ${current}`);
+    }
+    return;
+  }
+}
+async function ensureNoSymlink(path) {
+  await ensureSafeExistingPath(path);
+}
+async function assertDirectoryAncestors(path) {
+  let current = dirname6(resolve4(path));
+  while (true) {
+    try {
+      if (!(await lstat(current)).isDirectory()) fail2("DESTINATION_INVALID", `destination parent is not a directory: ${current}`);
+      await ensureSafeExistingPath(current);
+      return;
+    } catch (error) {
+      if (!isMissing(error)) throw error;
+      const parent = dirname6(current);
+      if (parent === current) throw error;
+      current = parent;
+    }
+  }
+}
+async function listFiles(root, prefix = "", directories = []) {
+  await ensureSafeExistingPath(root);
+  const entries = await readdir6(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const absolutePath = join15(root, entry.name);
+    if (entry.isSymbolicLink()) fail2("INSTALLATION_STATE_INVALID", `symlinks are not supported in the skill destination: ${relativePath}`);
+    if (entry.isDirectory()) {
+      directories.push(relativePath);
+      files.push(...await listFiles(absolutePath, relativePath, directories));
+    } else if (entry.isFile()) {
+      await ensureSafeExistingPath(absolutePath);
+      files.push(relativePath);
+    } else fail2("INSTALLATION_STATE_INVALID", `unsupported filesystem entry in skill destination: ${relativePath}`);
+  }
+  return files.sort();
+}
+function localManifestString(value, label) {
+  if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) {
+    fail2("INSTALLATION_STATE_INVALID", `${label} is invalid`);
+  }
+  return value;
+}
+function parseLocalManifest(value) {
+  assertObject(value, "local skill manifest", "INSTALLATION_STATE_INVALID");
+  if (value.schemaVersion !== 1) fail2("INSTALLATION_STATE_INVALID", "local skill manifest is invalid");
+  const releaseId = value.releaseId;
+  if (typeof releaseId !== "string" || !RELEASE_ID_PATTERN.test(releaseId)) fail2("INSTALLATION_STATE_INVALID", "local skill manifest release id is invalid");
+  const skillVersion = localManifestString(value.skillVersion, "local skill manifest skill version");
+  if (!Array.isArray(value.files) || value.files.length === 0) fail2("INSTALLATION_STATE_INVALID", "local skill manifest has no files");
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const rawFile of value.files) {
+    assertObject(rawFile, "local skill manifest file", "INSTALLATION_STATE_INVALID");
+    const path = safeSkillPath(rawFile.path);
+    const folded = path.toLowerCase();
+    if (seen.has(folded)) fail2("INSTALLATION_STATE_INVALID", `duplicate local skill path: ${path}`);
+    if ([...seen].some((existing) => pathsOverlap(existing, folded))) fail2("INSTALLATION_STATE_INVALID", `overlapping local skill paths: ${path}`);
+    seen.add(folded);
+    const fileDigest = rawFile.sha256;
+    if (typeof fileDigest !== "string" || !/^[a-f0-9]{64}$/.test(fileDigest)) fail2("INSTALLATION_STATE_INVALID", `invalid local digest for ${path}`);
+    const bytes = rawFile.bytes;
+    if (typeof bytes !== "number" || !Number.isInteger(bytes) || bytes < 0 || bytes > MAX_BUNDLE_BYTES) fail2("INSTALLATION_STATE_INVALID", `invalid local byte count for ${path}`);
+    files.push({ path, sha256: fileDigest, bytes });
+  }
+  if (!seen.has("skill.md")) fail2("INSTALLATION_STATE_INVALID", "local skill manifest must own SKILL.md");
+  return { schemaVersion: 1, releaseId, skillVersion, files };
+}
+async function readLocalManifest(destination) {
+  const path = join15(destination, LOCAL_MANIFEST);
+  if (!await exists(path)) return null;
+  try {
+    return parseLocalManifest(JSON.parse(await readFile12(path, "utf8")));
+  } catch (error) {
+    if (error instanceof SkillInstallError) throw error;
+    fail2("INSTALLATION_STATE_INVALID", "local skill manifest is invalid");
+  }
+}
+async function validateOwnedFiles(destination, local) {
+  for (const file of local.files) {
+    const path = safeSkillPath(file.path);
+    const absolute = join15(destination, path);
+    if (!await exists(absolute)) fail2("INSTALLATION_STATE_INVALID", `owned skill file is missing: ${path}`);
+    const bytes = await readFile12(absolute);
+    if (bytes.byteLength !== file.bytes || sha256(bytes) !== file.sha256) fail2("INSTALLATION_STATE_INVALID", `owned skill file was modified: ${path}`);
+  }
+}
+async function ownedFilesMatch(destination, local) {
+  for (const file of local.files) {
+    const absolute = join15(destination, file.path);
+    try {
+      const bytes = await readFile12(absolute);
+      if (bytes.byteLength !== file.bytes || sha256(bytes) !== file.sha256) return false;
+    } catch (error) {
+      if (isMissing(error)) return false;
+      throw error;
+    }
+  }
+  return true;
+}
+function localManifestFor(bundle) {
+  return {
+    schemaVersion: 1,
+    releaseId: bundle.releaseId,
+    skillVersion: bundle.manifest.skillVersion,
+    files: bundle.manifest.files
+  };
+}
+async function interruptedBackup(destination) {
+  await ensureSafeExistingPath(destination);
+  if (await exists(destination)) return void 0;
+  const parent = dirname6(destination);
+  await ensureSafeExistingPath(parent);
+  if (!await directoryExists(parent)) return void 0;
+  const prefix = `.nateui-skill-backup-${basename(destination)}-`;
+  const candidates = (await readdir6(parent, { withFileTypes: true })).filter((entry) => entry.name.startsWith(prefix) && entry.isDirectory()).map((entry) => join15(parent, entry.name));
+  if (candidates.length === 0) return void 0;
+  if (candidates.length > 1) fail2("INSTALLATION_STATE_INVALID", "multiple interrupted skill backups require manual cleanup");
+  assertDirectChild(candidates[0], parent, "interrupted skill backup");
+  await ensureNoSymlink(candidates[0]);
+  if (!(await lstat(candidates[0])).isDirectory()) fail2("INSTALLATION_STATE_INVALID", "interrupted skill backup is not a directory");
+  return candidates[0];
+}
+async function installSkillBundle(bundle, options) {
+  const destination = resolve4(options.destination);
+  await ensureSafeExistingPath(destination);
+  const pendingBackup = await interruptedBackup(destination);
+  const recovered = Boolean(pendingBackup && !options.dryRun);
+  if (recovered) await rename2(pendingBackup, destination);
+  const sourceDestination = options.dryRun && pendingBackup ? pendingBackup : destination;
+  const destinationExists = await exists(sourceDestination);
+  if (destinationExists) await ensureNoSymlink(sourceDestination);
+  if (destinationExists && !(await lstat(sourceDestination)).isDirectory()) fail2("DESTINATION_INVALID", `skill destination is not a directory: ${destination}`);
+  await assertDirectoryAncestors(destination);
+  const local = destinationExists ? await readLocalManifest(sourceDestination) : null;
+  const ownedMatches = local ? await ownedFilesMatch(sourceDestination, local) : true;
+  if (local && !ownedMatches && !options.force) {
+    await validateOwnedFiles(sourceDestination, local);
+  }
+  const existingDirectories = [];
+  const existingFiles = destinationExists ? await listFiles(sourceDestination, "", existingDirectories) : [];
+  const owned = new Set((local?.files ?? []).map((file) => file.path));
+  owned.add(LOCAL_MANIFEST);
+  const incomingPaths = new Set(bundle.manifest.files.map((file) => file.path));
+  for (const path of incomingPaths) {
+    const collision = existingFiles.find((existing) => pathsOverlap(existing, path) && !owned.has(existing)) ?? existingDirectories.find((existing) => existing.toLowerCase() === path.toLowerCase() || existing.toLowerCase().startsWith(`${path.toLowerCase()}/`));
+    if (collision) fail2("DESTINATION_COLLISION", `destination contains an unowned file at ${collision}`);
+  }
+  const identical = local?.releaseId === bundle.releaseId && ownedMatches && local.files.length === bundle.manifest.files.length && local.files.every((file) => incomingPaths.has(file.path) && bundle.manifest.files.find((candidate) => candidate.path === file.path)?.sha256 === file.sha256);
+  if (identical) {
+    return { releaseId: bundle.releaseId, destination, dryRun: Boolean(options.dryRun), ...recovered ? { recovered: true } : {}, ...options.dryRun && pendingBackup ? { recoveryRequired: true } : {}, files: bundle.manifest.files.map((file) => ({ path: file.path, action: "unchanged", bytes: file.bytes })) };
+  }
+  if (local && !options.force) fail2("FORCE_REQUIRED", `skill destination already contains a different NateUI release; pass --force to replace it`);
+  const changes = bundle.manifest.files.map((file) => ({
+    path: file.path,
+    action: local?.files.some((old) => old.path === file.path && old.sha256 === file.sha256 && ownedMatches) ? "unchanged" : local?.files.some((old) => old.path === file.path) ? "replace" : "create",
+    bytes: file.bytes
+  }));
+  if (local) {
+    for (const old of local.files) if (!incomingPaths.has(old.path)) changes.push({ path: old.path, action: "remove", bytes: old.bytes });
+  }
+  changes.sort((a, b) => a.path.localeCompare(b.path));
+  if (options.dryRun) return { releaseId: bundle.releaseId, destination, dryRun: true, ...pendingBackup ? { recoveryRequired: true } : {}, files: changes };
+  const parent = dirname6(destination);
+  await ensureSafeExistingPath(parent);
+  await mkdir7(parent, { recursive: true });
+  const stage = await mkdtemp4(join15(parent, ".nateui-skill-stage-"));
+  assertDirectChild(stage, parent, "staging directory");
+  await ensureNoSymlink(stage);
+  let backup;
+  try {
+    for (const path of existingFiles) {
+      if (owned.has(path)) continue;
+      const source = join15(destination, path);
+      const target = join15(stage, path);
+      await mkdir7(dirname6(target), { recursive: true });
+      await writeFile9(target, await readFile12(source));
+    }
+    for (const file of bundle.manifest.files) {
+      const target = join15(stage, file.path);
+      await mkdir7(dirname6(target), { recursive: true });
+      await writeFile9(target, bundle.files[file.path], "utf8");
+    }
+    await writeFile9(join15(stage, LOCAL_MANIFEST), JSON.stringify(localManifestFor(bundle), null, 2) + "\n", "utf8");
+    if (destinationExists) {
+      backup = join15(parent, `.nateui-skill-backup-${basename(destination)}-${process.pid}-${randomUUID()}`);
+      assertDirectChild(backup, parent, "skill backup");
+      await rename2(destination, backup);
+      if (process.env.NATEUI_SKILL_FAIL_SWAP === "after-backup") fail2("SWAP_INTERRUPTED", "test failure injected after backup; rerun to recover");
+    }
+    await rename2(stage, destination);
+    if (backup) {
+      await ensureNoSymlink(backup);
+      await rm6(backup, { recursive: true, force: true });
+    }
+    return { releaseId: bundle.releaseId, destination, dryRun: false, ...recovered ? { recovered: true } : {}, files: changes };
+  } catch (error) {
+    if (backup && !(error instanceof SkillInstallError && error.code === "SWAP_INTERRUPTED")) {
+      try {
+        if (await exists(destination)) {
+          assertDirectChild(destination, parent, "skill destination");
+          await ensureNoSymlink(destination);
+          await rm6(destination, { recursive: true, force: true });
+        }
+        await ensureNoSymlink(backup);
+        await rename2(backup, destination);
+        backup = void 0;
+      } catch {
+        fail2("SWAP_RECOVERY_FAILED", `could not restore the previous skill directory; backup remains at ${backup}`);
+      }
+    }
+    throw error;
+  } finally {
+    if (await exists(stage)) {
+      await ensureNoSymlink(stage);
+      await rm6(stage, { recursive: true, force: true });
+    }
+  }
+}
+async function inspectProjectDesign(applicationRoot) {
+  const root = resolve4(applicationRoot);
+  const path = join15(root, "DESIGN.md");
+  await ensureSafeExistingPath(root, "application root");
+  if (!(await lstat(root)).isDirectory()) fail2("DESIGN_PATH_INVALID", `application root is not a directory: ${root}`);
+  const caseCollision = (await readdir6(root)).find((entry) => entry.toLowerCase() === "design.md" && entry !== "DESIGN.md");
+  if (caseCollision) fail2("DESIGN_PATH_INVALID", `project design has a case-colliding name: ${caseCollision}`);
+  await ensureSafeExistingPath(path, "project DESIGN.md");
+  try {
+    if (!(await lstat(path)).isFile()) fail2("DESIGN_PATH_INVALID", `project DESIGN.md must be a regular file: ${path}`);
+    return { path, action: "preserve" };
+  } catch (error) {
+    if (isMissing(error)) return { path, action: "create" };
+    throw error;
+  }
+}
+async function createProjectDesign(applicationRoot, content) {
+  const current = await inspectProjectDesign(applicationRoot);
+  if (current.action === "preserve") return current;
+  try {
+    await writeFile9(current.path, content, { encoding: "utf8", flag: "wx" });
+    return current;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const concurrent = await inspectProjectDesign(applicationRoot);
+    if (concurrent.action !== "preserve") throw error;
+    return concurrent;
+  }
+}
+async function installSkillSetup(bundle, options) {
+  const destination = resolve4(options.destination);
+  let result = {
+    releaseId: bundle.releaseId,
+    destination,
+    dryRun: Boolean(options.dryRun),
+    files: [],
+    status: "failed",
+    skill: { path: destination, action: "skip" },
+    design: options.applicationRoot ? { path: join15(resolve4(options.applicationRoot), "DESIGN.md"), action: "error" } : { action: "skip", reason: options.designSkipReason ?? "custom_skill_path" }
+  };
+  try {
+    if (options.applicationRoot) {
+      if (typeof bundle.files[DEFAULT_DESIGN_ASSET] !== "string") {
+        fail2("DESIGN_STARTER_MISSING", "this skill release has no Default starter; project setup requires a newer release");
+      }
+      const design = await inspectProjectDesign(options.applicationRoot);
+      const relation = relative4(destination, design.path);
+      if (!relation || !relation.startsWith(`..\\`) && !relation.startsWith("../") && relation !== ".." && !isAbsolute3(relation)) {
+        fail2("DESIGN_PATH_INVALID", "project DESIGN.md must be outside the updater-owned skill destination");
+      }
+      result.design = design;
+    }
+    const plan = await installSkillBundle(bundle, { ...options, dryRun: true });
+    const changes = plan.files.filter((file) => file.action !== "unchanged");
+    const previousInstallation = plan.recoveryRequired || await exists(join15(destination, LOCAL_MANIFEST));
+    const action = changes.length === 0 ? "preserve" : previousInstallation ? "update" : "create";
+    result = { ...result, ...plan, skill: { path: destination, action } };
+    if (options.dryRun) return { ...result, status: "planned" };
+  } catch (error) {
+    throw new SkillSetupError(error, result);
+  }
+  try {
+    const installed = await installSkillBundle(bundle, options);
+    result = { ...result, ...installed, dryRun: false, status: "partial" };
+    delete result.recoveryRequired;
+  } catch (error) {
+    throw new SkillSetupError(error, {
+      ...result,
+      dryRun: false,
+      status: error instanceof SkillInstallError && ["SWAP_INTERRUPTED", "SWAP_RECOVERY_FAILED"].includes(error.code) ? "partial" : "failed",
+      skill: { path: destination, action: "error" },
+      design: options.applicationRoot ? { path: result.design.path, action: "skip", reason: "skill_install_failed" } : result.design
+    });
+  }
+  if (options.applicationRoot) {
+    try {
+      result.design = await createProjectDesign(options.applicationRoot, bundle.files[DEFAULT_DESIGN_ASSET]);
+    } catch (error) {
+      throw new SkillSetupError(error, { ...result, design: { path: result.design.path, action: "error" } });
+    }
+  }
+  return { ...result, status: "complete" };
+}
+async function fetchSkillBundle() {
+  const base = apiBase().replace(/\/$/, "");
+  let latest;
+  try {
+    latest = await fetch(`${base}/api/agent/skill/latest`, { headers: { Accept: "application/json" } });
+  } catch {
+    fail2("NETWORK_ERROR", "could not reach the NateUI skill service");
+  }
+  if (!latest.ok) fail2("NETWORK_ERROR", `skill metadata request failed (${latest.status})`);
+  let metadata;
+  try {
+    metadata = await latest.json();
+  } catch {
+    fail2("INVALID_BUNDLE", "skill metadata was not valid JSON");
+  }
+  assertObject(metadata, "skill metadata");
+  const releaseId = validateReleaseId(metadata.releaseId);
+  let response;
+  try {
+    response = await fetch(`${base}/api/agent/skill/releases/${releaseId}`, { headers: { Accept: "application/json" } });
+  } catch {
+    fail2("NETWORK_ERROR", "could not download the NateUI skill release");
+  }
+  if (!response.ok) fail2("NETWORK_ERROR", `skill release request failed (${response.status})`);
+  try {
+    return validateSkillBundle(await response.json());
+  } catch (error) {
+    if (error instanceof SkillInstallError) throw error;
+    fail2("INVALID_BUNDLE", "skill release was not valid JSON");
+  }
+}
+
+// src/commands/skill.ts
+var VALUE_FLAGS = ["client", "path"];
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["global", "force", "dry-run", "json"]);
+async function runSkill(argv) {
+  const jsonRequested = argv.includes("--json");
+  const dryRunRequested = argv.includes("--dry-run");
+  let flags = /* @__PURE__ */ new Set();
+  let selected;
+  let phase = "options";
+  let result;
+  try {
+    for (const [index, arg] of argv.entries()) {
+      if (VALUE_FLAGS.some((flag) => arg === `--${flag}`)) {
+        const value = argv[index + 1];
+        if (!value || value.startsWith("--")) fail(`${arg} requires a value`);
+      }
+    }
+    const parsed = parseFlags(argv, VALUE_FLAGS);
+    flags = parsed.flags;
+    const { values, positional } = parsed;
+    const unknownFlags = [...flags].filter((flag) => !BOOLEAN_FLAGS.has(flag));
+    const unknownValues = Object.keys(values).filter((flag) => !VALUE_FLAGS.includes(flag));
+    if (unknownFlags.length > 0 || unknownValues.length > 0) fail(`unknown skill option: --${unknownFlags[0] ?? unknownValues[0]}`);
+    if (positional.length > 0) fail(`skill does not accept positional arguments: ${positional[0]}`);
+    for (const flag of VALUE_FLAGS) {
+      if (values[flag] === "") fail(`--${flag} requires a value`);
+    }
+    if (values.client !== void 0 && !SKILL_CLIENTS.includes(values.client)) {
+      fail(`unsupported client '${values.client}'`);
+    }
+    if (!values.path && flags.has("global") && !values.client) fail("--global requires --client");
+    phase = "destination";
+    selected = await resolveSkillDestination({
+      client: values.client,
+      global: flags.has("global"),
+      path: values.path
+    });
+    phase = "bundle";
+    const bundle = await fetchSkillBundle();
+    result = await installSkillSetup(bundle, {
+      destination: selected.destination,
+      ...flags.has("global") ? { designSkipReason: "global_install" } : values.path ? { designSkipReason: "custom_skill_path" } : { applicationRoot: process.cwd() },
+      force: flags.has("force"),
+      dryRun: flags.has("dry-run")
+    });
+  } catch (error) {
+    if (jsonRequested) {
+      const failure = error instanceof SkillSetupError ? error.result : {
+        status: "failed",
+        destination: selected?.destination ?? null,
+        dryRun: dryRunRequested,
+        skill: { path: selected?.destination ?? null, action: "skip" },
+        design: { action: "skip", reason: phase === "options" ? "invalid_options" : phase === "destination" ? "destination_not_selected" : "bundle_unavailable" },
+        error: { code: error instanceof SkillInstallError ? error.code : phase === "options" ? "INVALID_OPTIONS" : "SETUP_FAILED", message: error instanceof Error ? error.message : String(error) }
+      };
+      process.stdout.write(`${JSON.stringify({ ...failure, client: selected?.client ?? null }, null, 2)}
+`);
+    } else if (error instanceof SkillSetupError && error.result.status === "partial") {
+      console.error(`nateui: partial setup at ${error.result.destination}; project DESIGN.md was not completed`);
+      if (error.result.design.action === "error") console.error(`nateui: skill installed; inspect ${error.result.design.path} and rerun after resolving the write failure`);
+    }
+    throw error;
+  }
+  if (jsonRequested) {
+    process.stdout.write(`${JSON.stringify({ ...result, client: selected.client }, null, 2)}
+`);
+    return;
+  }
+  const changed = result.files.filter((file) => file.action !== "unchanged").length;
+  const verb = result.dryRun ? "would update" : changed === 0 ? "already current" : "updated";
+  console.error(`nateui: ${verb} ${result.destination} (${result.releaseId}; ${changed} file change${changed === 1 ? "" : "s"})`);
+  if (result.recovered) console.error("nateui: recovered an interrupted previous skill install");
+  if (result.recoveryRequired) console.error("nateui: would recover an interrupted previous skill install");
+  if (result.design.action === "skip") {
+    const starterHint = result.files.some((file) => file.path === DEFAULT_DESIGN_ASSET) ? "; copy assets/default-design.md to the application root deliberately if needed" : "; this release has no Default starter";
+    console.error(`nateui: DESIGN.md skipped (${result.design.reason === "global_install" ? "global installation" : "custom skill destination"})${starterHint}`);
+  } else {
+    const designVerb = result.design.action === "preserve" ? "preserved existing" : result.dryRun ? "would create" : "created";
+    console.error(`nateui: ${designVerb} ${result.design.path}`);
+  }
+}
+
+// src/main.ts
+var VERBS = {
+  init: runInit,
+  "init-template": runInitTemplate,
+  add: runAdd,
+  "add-page": runAddPage,
+  "remove-page": runRemovePage,
+  list: runList,
+  describe: runDescribe,
+  login: runLogin,
+  skill: runSkill
+};
+async function main() {
+  const [verb, ...rest] = process.argv.slice(2);
+  const handler = VERBS[verb];
+  if (!handler) {
+    printError(`unknown command '${verb ?? ""}' \u2014 one of: ${Object.keys(VERBS).join(", ")}`);
+    process.exit(1);
+  }
+  await handler(rest);
+}
+function closeFetchPool() {
+  try {
+    const dispatcher = globalThis[/* @__PURE__ */ Symbol.for("undici.globalDispatcher.1")];
+    void dispatcher?.close?.();
+  } catch {
+  }
+}
+main().catch((err) => {
+  if (err instanceof NateuiError) {
+    printError(err.message);
+  } else {
+    printError(err instanceof Error ? err.message : String(err));
+  }
+  process.exitCode = 1;
+  closeFetchPool();
+});