wensity 0.1.6 → 0.1.7

package/dist/index.js

@@ -4,10 +4,160 @@
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname6, join as join6 } from "path";
 
+// src/constants.ts
+var CLI_NAME = "wensity";
+var CLI_VERSION = "0.1.7";
+var CONFIG_FILE_NAME = "wensity.json";
+var DEFAULT_API_ORIGIN = "https://ui.wensity.com";
+var DEFAULT_REGISTRY_PATH = "/api/registry";
+var DEFAULT_COMPONENTS_DIR = "src/components/wensity";
+var DEFAULT_UTILS_PATH = "src/lib/utils";
+var DEFAULT_COMPONENTS_ALIAS = "@/components/wensity";
+var DEFAULT_UTILS_ALIAS = "@/lib/utils";
+var INIT_PRIMITIVE_CSS_SLUG = "button";
+var HELP_TEXT = `Wensity CLI ${CLI_VERSION}
+
+Usage:
+  wensity init [--preset <code>] [--preset-file <path>] [options]
+  wensity login [options]
+  wensity logout
+  wensity whoami [--json]
+  wensity list [--type component|block] [options]
+  wensity add <slug> [--type component|block] [options]
+  wensity update <slug> [--type component|block] [options]
+  wensity version
+
+Commands:
+  init       Create wensity.json and local helper files (optional --preset applies style + CSS)
+  login      Save a Wensity API token for premium component access
+  logout     Remove saved CLI credentials
+  whoami     Verify the saved token and print the authenticated account
+  list       List registry components or blocks
+  add        Download a component or block source file into this project
+  update     Re-download a component or block and overwrite the local copy
+  version    Print the CLI version
+
+Options:
+  --api-url <url>      Override the Wensity app origin, defaults to ${DEFAULT_API_ORIGIN}
+  --registry <url>     Override the registry endpoint
+  --type <type>        Select component or block, defaults to component
+  --token <token>      Provide a token non-interactively for login
+  --preset <code>      Apply a shareable Wensity style preset (wsty1.\u2026); merges style when config exists
+  --preset-file <path> Read a preset code or JSON payload from a file
+  --force              Overwrite generated files when adding or initializing
+  --no-install         Write files without running the package manager
+  --dry-run            Print planned writes and installs without changing files
+  --json               Print machine-readable output where supported
+  --help               Show help
+  --version            Print the CLI version
+
+Preset notes:
+  Generate codes at ${DEFAULT_API_ORIGIN}/docs/primitives/setup
+  Plain init refuses an existing wensity.json unless --force
+  init --preset merges style + primitive CSS; does not rewrite installed source
+  add/update read style.iconLibrary for UI primitives only (Tabler|Lucide)
+  Invalid/expired/unsupported codes exit non-zero with an actionable message
+`;
+
+// src/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/args.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "--") {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+    const inlineValueIndex = token.indexOf("=");
+    const rawName = inlineValueIndex > -1 ? token.slice(2, inlineValueIndex) : token.slice(2);
+    const name = normalizeOptionName(rawName);
+    if (!name) {
+      throw new CliError(`Invalid option: ${token}`);
+    }
+    if (inlineValueIndex > -1) {
+      options.set(name, token.slice(inlineValueIndex + 1));
+      continue;
+    }
+    const nextToken = argv[index + 1];
+    if (nextToken && !nextToken.startsWith("--") && expectsValue(name)) {
+      options.set(name, nextToken);
+      index += 1;
+      continue;
+    }
+    options.set(name, true);
+  }
+  return { positionals, options };
+}
+function getStringOption(args, name) {
+  const value = args.options.get(name);
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") {
+    throw new CliError(`--${name} expects a value.`);
+  }
+  return value;
+}
+function hasFlag(args, name) {
+  return args.options.get(name) === true;
+}
+function expectsValue(name) {
+  return ["api-url", "registry", "token", "type", "preset", "preset-file"].includes(name);
+}
+function normalizeOptionName(name) {
+  if (name === "dry") return "dry-run";
+  return name;
+}
+
+// src/config.ts
+import { existsSync } from "fs";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join2, relative as relative2 } from "path";
+
 // ../wensity-preset/src/constants.ts
 var ICON_LIBRARIES = ["tabler", "lucide"];
 var RADIUS_PRESETS = ["none", "small", "medium", "large"];
 var BUILTIN_FONT_IDS = ["site", "system-sans", "system-mono"];
+var BASE_COLOR_IDS = [
+  "inherit",
+  "neutral",
+  "zinc",
+  "slate",
+  "stone",
+  "taupe"
+];
+var THEME_COLOR_IDS = [
+  "ink",
+  "red",
+  "blue",
+  "violet",
+  "green",
+  "orange"
+];
+var CHART_PALETTE_IDS = [
+  "theme",
+  "warm",
+  "cool",
+  "mixed"
+];
+var HEADING_FONT_IDS = ["system", "playfair"];
+var BODY_FONT_IDS = ["system", "inter"];
 var RADIUS_PRESET_CSS = {
   none: "0px",
   small: "0.5rem",
@@ -27,12 +177,6 @@ var CONTROL_SOLID_COLOR_KEYS = [
   "controlSolidActive",
   "controlSolidForeground"
 ];
-var CONTROL_SOLID_CSS_VARS = {
-  controlSolid: "--primitive-control-solid",
-  controlSolidHover: "--primitive-control-solid-hover",
-  controlSolidActive: "--primitive-control-solid-active",
-  controlSolidForeground: "--primitive-control-solid-foreground"
-};
 var STYLE_OBJECT_KEYS = [
   "iconLibrary",
   "radius",
@@ -40,6 +184,16 @@ var STYLE_OBJECT_KEYS = [
   "colors",
   "presetCode"
 ];
+var STYLE_OBJECT_KEYS_CANONICAL = [
+  "baseColor",
+  "themeColor",
+  "chartPalette",
+  "headingFont",
+  "bodyFont",
+  "iconLibrary",
+  "radius",
+  "presetCode"
+];
 var FONT_ROLE_KEYS = ["sans", "display", "mono"];
 var COLOR_MODE_KEYS = ["light", "dark"];
 var HEX_COLOR_PATTERN = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
@@ -62,6 +216,21 @@ function isFontRoleValue(value) {
   if (isBuiltinFontId(value)) return true;
   return value.startsWith(CUSTOM_FONT_PREFIX) && value.length > CUSTOM_FONT_PREFIX.length;
 }
+function isBaseColorId(value) {
+  return BASE_COLOR_IDS.includes(value);
+}
+function isThemeColorId(value) {
+  return THEME_COLOR_IDS.includes(value);
+}
+function isChartPaletteId(value) {
+  return CHART_PALETTE_IDS.includes(value);
+}
+function isHeadingFontId(value) {
+  return HEADING_FONT_IDS.includes(value);
+}
+function isBodyFontId(value) {
+  return BODY_FONT_IDS.includes(value);
+}
 
 // ../wensity-preset/src/defaults.ts
 var DEFAULT_STYLE_FONTS = {
@@ -101,6 +270,26 @@ function createDefaultStyleConfig() {
     }
   };
 }
+var DEFAULT_STYLE_CONFIG_CANONICAL = {
+  baseColor: "inherit",
+  themeColor: "ink",
+  chartPalette: "theme",
+  headingFont: "system",
+  bodyFont: "system",
+  iconLibrary: "tabler",
+  radius: "medium"
+};
+function createDefaultStyleConfigCanonical() {
+  return {
+    baseColor: DEFAULT_STYLE_CONFIG_CANONICAL.baseColor,
+    themeColor: DEFAULT_STYLE_CONFIG_CANONICAL.themeColor,
+    chartPalette: DEFAULT_STYLE_CONFIG_CANONICAL.chartPalette,
+    headingFont: DEFAULT_STYLE_CONFIG_CANONICAL.headingFont,
+    bodyFont: DEFAULT_STYLE_CONFIG_CANONICAL.bodyFont,
+    iconLibrary: DEFAULT_STYLE_CONFIG_CANONICAL.iconLibrary,
+    radius: DEFAULT_STYLE_CONFIG_CANONICAL.radius
+  };
+}
 
 // ../wensity-preset/src/schema.ts
 var fontRoleSchema = {
@@ -123,66 +312,53 @@ var controlSolidColorsSchema = {
     ])
   )
 };
-var WENSITY_CONFIG_SCHEMA = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "https://ui.wensity.com/schema/wensity.json",
-  title: "Wensity CLI configuration",
+var legacyStyleSchema = {
   type: "object",
   additionalProperties: false,
   properties: {
-    $schema: { type: "string" },
-    version: { type: "integer", const: 1 },
-    registry: { type: "string", format: "uri" },
-    components: { type: "string", minLength: 1 },
-    utils: { type: "string", minLength: 1 },
-    tailwind: {
+    iconLibrary: { type: "string", enum: [...ICON_LIBRARIES] },
+    radius: { type: "string", enum: [...RADIUS_PRESETS] },
+    fonts: {
       type: "object",
       additionalProperties: false,
       properties: {
-        config: { type: "string" },
-        css: { type: "string" }
+        sans: fontRoleSchema,
+        display: fontRoleSchema,
+        mono: fontRoleSchema
       }
     },
-    aliases: {
+    colors: {
       type: "object",
       additionalProperties: false,
       properties: {
-        components: { type: "string", minLength: 1 },
-        utils: { type: "string", minLength: 1 }
+        light: controlSolidColorsSchema,
+        dark: controlSolidColorsSchema
       }
     },
-    style: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        iconLibrary: { type: "string", enum: [...ICON_LIBRARIES] },
-        radius: { type: "string", enum: [...RADIUS_PRESETS] },
-        fonts: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            sans: fontRoleSchema,
-            display: fontRoleSchema,
-            mono: fontRoleSchema
-          }
-        },
-        colors: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            light: controlSolidColorsSchema,
-            dark: controlSolidColorsSchema
-          }
-        },
-        presetCode: {
-          type: "string",
-          minLength: 1,
-          maxLength: PRESET_CODEC_MAX_CODE_LENGTH
-        }
-      }
+    presetCode: {
+      type: "string",
+      minLength: 1,
+      maxLength: PRESET_CODEC_MAX_CODE_LENGTH
     }
-  },
-  required: ["registry", "components", "utils", "aliases"]
+  }
+};
+var canonicalStyleSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    baseColor: { type: "string", enum: [...BASE_COLOR_IDS] },
+    themeColor: { type: "string", enum: [...THEME_COLOR_IDS] },
+    chartPalette: { type: "string", enum: [...CHART_PALETTE_IDS] },
+    headingFont: { type: "string", enum: [...HEADING_FONT_IDS] },
+    bodyFont: { type: "string", enum: [...BODY_FONT_IDS] },
+    iconLibrary: { type: "string", enum: [...ICON_LIBRARIES] },
+    radius: { type: "string", enum: [...RADIUS_PRESETS] },
+    presetCode: {
+      type: "string",
+      minLength: 1,
+      maxLength: PRESET_CODEC_MAX_CODE_LENGTH
+    }
+  }
 };
 
 // ../wensity-preset/src/fonts.ts
@@ -420,6 +596,91 @@ function validateStyleConfigPartial(value) {
   }
   return result;
 }
+function validateStyleConfigCanonicalPartial(value) {
+  if (value === void 0 || value === null) return {};
+  assertPlainObject(value, "style");
+  assertAllowedKeys(value, STYLE_OBJECT_KEYS_CANONICAL, "style");
+  const result = {};
+  if ("baseColor" in value) {
+    if (typeof value.baseColor !== "string" || !isBaseColorId(value.baseColor)) {
+      throw new PresetValidationError(
+        "Invalid style.baseColor. Expected inherit | neutral | zinc | slate | stone | taupe.",
+        "style.baseColor"
+      );
+    }
+    result.baseColor = value.baseColor;
+  }
+  if ("themeColor" in value) {
+    if (typeof value.themeColor !== "string" || !isThemeColorId(value.themeColor)) {
+      throw new PresetValidationError(
+        "Invalid style.themeColor. Expected ink | red | blue | violet | green | orange.",
+        "style.themeColor"
+      );
+    }
+    result.themeColor = value.themeColor;
+  }
+  if ("chartPalette" in value) {
+    if (typeof value.chartPalette !== "string" || !isChartPaletteId(value.chartPalette)) {
+      throw new PresetValidationError(
+        "Invalid style.chartPalette. Expected theme | warm | cool | mixed.",
+        "style.chartPalette"
+      );
+    }
+    result.chartPalette = value.chartPalette;
+  }
+  if ("headingFont" in value) {
+    if (typeof value.headingFont !== "string" || !isHeadingFontId(value.headingFont)) {
+      throw new PresetValidationError(
+        "Invalid style.headingFont. Expected system | playfair.",
+        "style.headingFont"
+      );
+    }
+    result.headingFont = value.headingFont;
+  }
+  if ("bodyFont" in value) {
+    if (typeof value.bodyFont !== "string" || !isBodyFontId(value.bodyFont)) {
+      throw new PresetValidationError(
+        "Invalid style.bodyFont. Expected system | inter.",
+        "style.bodyFont"
+      );
+    }
+    result.bodyFont = value.bodyFont;
+  }
+  if ("iconLibrary" in value) {
+    if (typeof value.iconLibrary !== "string" || !isIconLibrary(value.iconLibrary)) {
+      throw new PresetValidationError(
+        "Invalid style.iconLibrary. Expected tabler | lucide.",
+        "style.iconLibrary"
+      );
+    }
+    result.iconLibrary = value.iconLibrary;
+  }
+  if ("radius" in value) {
+    if (typeof value.radius !== "string" || !isRadiusPreset(value.radius)) {
+      throw new PresetValidationError(
+        "Invalid style.radius. Expected none | small | medium | large.",
+        "style.radius"
+      );
+    }
+    result.radius = value.radius;
+  }
+  if ("presetCode" in value) {
+    if (typeof value.presetCode !== "string" || value.presetCode.length === 0) {
+      throw new PresetValidationError(
+        "Invalid style.presetCode. Expected a non-empty string.",
+        "style.presetCode"
+      );
+    }
+    if (value.presetCode.length > PRESET_CODEC_MAX_CODE_LENGTH) {
+      throw new PresetValidationError(
+        `Invalid style.presetCode. Exceeds ${PRESET_CODEC_MAX_CODE_LENGTH} characters.`,
+        "style.presetCode"
+      );
+    }
+    result.presetCode = value.presetCode;
+  }
+  return result;
+}
 
 // ../wensity-preset/src/normalize.ts
 function mergeControlSolid(base, partial) {
@@ -460,9 +721,36 @@ function normalizeStyleConfig(partial) {
   }
   return normalized;
 }
+function normalizeStyleConfigCanonical(partial) {
+  const validated = validateStyleConfigCanonicalPartial(partial ?? void 0);
+  const defaults = createDefaultStyleConfigCanonical();
+  const normalized = {
+    baseColor: validated.baseColor ?? defaults.baseColor,
+    themeColor: validated.themeColor ?? defaults.themeColor,
+    chartPalette: validated.chartPalette ?? defaults.chartPalette,
+    headingFont: validated.headingFont ?? defaults.headingFont,
+    bodyFont: validated.bodyFont ?? defaults.bodyFont,
+    iconLibrary: validated.iconLibrary ?? defaults.iconLibrary,
+    radius: validated.radius ?? defaults.radius
+  };
+  if (validated.presetCode !== void 0) {
+    normalized.presetCode = validated.presetCode;
+  }
+  return normalized;
+}
 
 // ../wensity-preset/src/codec.ts
 var CODEC_PAYLOAD_KEYS = ["v", "iconLibrary", "radius", "fonts", "colors"];
+var CODEC_PAYLOAD_KEYS_CANONICAL = [
+  "v",
+  "baseColor",
+  "themeColor",
+  "chartPalette",
+  "headingFont",
+  "bodyFont",
+  "iconLibrary",
+  "radius"
+];
 function assertPlainObject2(value, path) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new PresetValidationError(`Expected an object at ${path}.`, path);
@@ -675,7 +963,124 @@ function pickDefinedColors(partial) {
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function decodePreset(code) {
+var CODEC_CANONICAL_REQUIRED_FIELDS = [
+  "baseColor",
+  "themeColor",
+  "chartPalette",
+  "headingFont",
+  "bodyFont",
+  "iconLibrary",
+  "radius"
+];
+function validateCodecPayloadCanonical(value) {
+  assertPlainObject2(value, "preset");
+  assertAllowedKeys2(value, CODEC_PAYLOAD_KEYS_CANONICAL, "preset");
+  if (value.v !== 2) {
+    throw new PresetValidationError(
+      typeof value.v === "number" ? `Unsupported preset codec version ${value.v}. Expected v: 2.` : "Preset payload missing v: 2.",
+      "preset.v"
+    );
+  }
+  for (const key of CODEC_CANONICAL_REQUIRED_FIELDS) {
+    if (!(key in value)) {
+      throw new PresetValidationError(`Preset payload missing ${key}.`, `preset.${key}`);
+    }
+  }
+  if (typeof value.baseColor !== "string" || !isBaseColorId(value.baseColor)) {
+    throw new PresetValidationError(
+      "Invalid preset.baseColor. Expected inherit | neutral | zinc | slate | stone | taupe.",
+      "preset.baseColor"
+    );
+  }
+  if (typeof value.themeColor !== "string" || !isThemeColorId(value.themeColor)) {
+    throw new PresetValidationError(
+      "Invalid preset.themeColor. Expected ink | red | blue | violet | green | orange.",
+      "preset.themeColor"
+    );
+  }
+  if (typeof value.chartPalette !== "string" || !isChartPaletteId(value.chartPalette)) {
+    throw new PresetValidationError(
+      "Invalid preset.chartPalette. Expected theme | warm | cool | mixed.",
+      "preset.chartPalette"
+    );
+  }
+  if (typeof value.headingFont !== "string" || !isHeadingFontId(value.headingFont)) {
+    throw new PresetValidationError(
+      "Invalid preset.headingFont. Expected system | playfair.",
+      "preset.headingFont"
+    );
+  }
+  if (typeof value.bodyFont !== "string" || !isBodyFontId(value.bodyFont)) {
+    throw new PresetValidationError(
+      "Invalid preset.bodyFont. Expected system | inter.",
+      "preset.bodyFont"
+    );
+  }
+  if (typeof value.iconLibrary !== "string" || !isIconLibrary(value.iconLibrary)) {
+    throw new PresetValidationError(
+      "Invalid preset.iconLibrary. Expected tabler | lucide.",
+      "preset.iconLibrary"
+    );
+  }
+  if (typeof value.radius !== "string" || !isRadiusPreset(value.radius)) {
+    throw new PresetValidationError(
+      "Invalid preset.radius. Expected none | small | medium | large.",
+      "preset.radius"
+    );
+  }
+  return {
+    v: 2,
+    baseColor: value.baseColor,
+    themeColor: value.themeColor,
+    chartPalette: value.chartPalette,
+    headingFont: value.headingFont,
+    bodyFont: value.bodyFont,
+    iconLibrary: value.iconLibrary,
+    radius: value.radius
+  };
+}
+function stableStringifyCodecPayloadCanonical(payload) {
+  return `{${[
+    `"v":${payload.v}`,
+    `"baseColor":${JSON.stringify(payload.baseColor)}`,
+    `"themeColor":${JSON.stringify(payload.themeColor)}`,
+    `"chartPalette":${JSON.stringify(payload.chartPalette)}`,
+    `"headingFont":${JSON.stringify(payload.headingFont)}`,
+    `"bodyFont":${JSON.stringify(payload.bodyFont)}`,
+    `"iconLibrary":${JSON.stringify(payload.iconLibrary)}`,
+    `"radius":${JSON.stringify(payload.radius)}`
+  ].join(",")}}`;
+}
+function encodePresetCanonical(style) {
+  const normalized = normalizeStyleConfigCanonical(style);
+  const payload = {
+    v: 2,
+    baseColor: normalized.baseColor,
+    themeColor: normalized.themeColor,
+    chartPalette: normalized.chartPalette,
+    headingFont: normalized.headingFont,
+    bodyFont: normalized.bodyFont,
+    iconLibrary: normalized.iconLibrary,
+    radius: normalized.radius
+  };
+  const json = stableStringifyCodecPayloadCanonical(payload);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength > PRESET_CODEC_MAX_DECODED_JSON_BYTES) {
+    throw new PresetValidationError(
+      `Preset JSON exceeds ${PRESET_CODEC_MAX_DECODED_JSON_BYTES} bytes.`,
+      "preset"
+    );
+  }
+  const code = `${PRESET_CODEC_PREFIX}.${toBase64Url(bytes)}`;
+  if (code.length > PRESET_CODEC_MAX_CODE_LENGTH) {
+    throw new PresetValidationError(
+      `Preset code exceeds ${PRESET_CODEC_MAX_CODE_LENGTH} characters.`,
+      "preset"
+    );
+  }
+  return code;
+}
+function decodePresetEnvelope(code) {
   if (typeof code !== "string" || code.length === 0) {
     throw new PresetValidationError("Preset code is required.", "preset");
   }
@@ -727,7 +1132,26 @@ function decodePreset(code) {
   } catch {
     throw new PresetValidationError("Preset payload is not valid JSON.", "preset");
   }
-  return validateCodecPayload(parsed);
+  return parsed;
+}
+function formatUnsupportedPayloadVersion(v) {
+  const label = v === void 0 ? "undefined" : String(v);
+  return `Unsupported preset payload version ${label}. This preset may require a newer version of the Wensity CLI.`;
+}
+function decodeAnyPreset(code) {
+  const parsed = decodePresetEnvelope(code);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new PresetValidationError("Expected an object at preset.", "preset");
+  }
+  assertNoForbiddenObjectKeys(parsed, "preset");
+  const v = parsed.v;
+  if (v === 1) {
+    return validateCodecPayload(parsed);
+  }
+  if (v === 2) {
+    return validateCodecPayloadCanonical(parsed);
+  }
+  throw new PresetValidationError(formatUnsupportedPayloadVersion(v), "preset.v");
 }
 
 // ../wensity-preset/src/icon-map.ts
@@ -747,185 +1171,473 @@ var TABLER_TO_LUCIDE = {
   IconArrowUpRight: "ArrowUpRight",
   IconCalendar: "Calendar",
   IconCamera: "Camera",
-  IconCheck: "Check",
-  IconChevronDown: "ChevronDown",
-  IconChevronLeft: "ChevronLeft",
-  IconChevronRight: "ChevronRight",
-  IconChevronUp: "ChevronUp",
-  IconChevronsLeft: "ChevronsLeft",
-  IconChevronsRight: "ChevronsRight",
-  IconCircleX: "CircleX",
-  IconClock: "Clock",
-  IconCornerDownLeft: "CornerDownLeft",
-  IconDots: "Ellipsis",
-  IconDownload: "Download",
-  IconFile: "File",
-  IconFileMusic: "FileAudio",
-  IconFileText: "FileText",
-  IconFileZip: "FileArchive",
-  IconInfoCircle: "Info",
-  IconLayoutSidebarLeftCollapse: "PanelLeftClose",
-  IconLayoutSidebarLeftExpand: "PanelLeftOpen",
-  IconMinus: "Minus",
-  IconPhoto: "Image",
-  IconPlus: "Plus",
-  IconRefresh: "RefreshCw",
-  IconSearch: "Search",
-  IconSelector: "ChevronsUpDown",
-  IconSlash: "Slash",
-  IconUser: "User",
-  IconVideo: "Video",
-  IconX: "X"
-};
-var EXCLUSION_SET = new Set(ICON_TRANSFORM_EXCLUSIONS);
-function isIconTransformExclusion(name) {
-  return EXCLUSION_SET.has(name);
-}
-function isMappedTablerIcon(name) {
-  return Object.prototype.hasOwnProperty.call(TABLER_TO_LUCIDE, name);
-}
-function resolveLucideExport(tablerName) {
-  if (isIconTransformExclusion(tablerName)) {
-    throw new Error(
-      `Icon "${tablerName}" is a Phase 0 exclusion and must not be transformed. Use internal SVG/CSS geometry instead.`
-    );
-  }
-  if (!isMappedTablerIcon(tablerName)) {
-    throw new Error(
-      `No approved Lucide mapping for Tabler icon "${tablerName}". Add an audited map entry or convert it to internal geometry.`
-    );
-  }
-  return TABLER_TO_LUCIDE[tablerName];
-}
-var LUCIDE_TO_TABLER = Object.fromEntries(
-  Object.entries(TABLER_TO_LUCIDE).map(([tabler, lucide]) => [lucide, tabler])
-);
-
-// src/constants.ts
-var CLI_NAME = "wensity";
-var CLI_VERSION = "0.1.6";
-var CONFIG_FILE_NAME = "wensity.json";
-var DEFAULT_API_ORIGIN = "https://ui.wensity.com";
-var DEFAULT_REGISTRY_PATH = "/api/registry";
-var DEFAULT_COMPONENTS_DIR = "src/components/wensity";
-var DEFAULT_UTILS_PATH = "src/lib/utils";
-var DEFAULT_COMPONENTS_ALIAS = "@/components/wensity";
-var DEFAULT_UTILS_ALIAS = "@/lib/utils";
-var INIT_PRIMITIVE_CSS_SLUG = "button";
-var HELP_TEXT = `Wensity CLI ${CLI_VERSION}
-
-Usage:
-  wensity init [--preset <code>] [--preset-file <path>] [options]
-  wensity login [options]
-  wensity logout
-  wensity whoami [--json]
-  wensity list [--type component|block] [options]
-  wensity add <slug> [--type component|block] [options]
-  wensity update <slug> [--type component|block] [options]
-  wensity version
-
-Commands:
-  init       Create wensity.json and local helper files (optional --preset applies style + CSS)
-  login      Save a Wensity API token for premium component access
-  logout     Remove saved CLI credentials
-  whoami     Verify the saved token and print the authenticated account
-  list       List registry components or blocks
-  add        Download a component or block source file into this project
-  update     Re-download a component or block and overwrite the local copy
-  version    Print the CLI version
-
-Options:
-  --api-url <url>      Override the Wensity app origin, defaults to ${DEFAULT_API_ORIGIN}
-  --registry <url>     Override the registry endpoint
-  --type <type>        Select component or block, defaults to component
-  --token <token>      Provide a token non-interactively for login
-  --preset <code>      Apply a shareable Wensity style preset (wsty1.\u2026); merges style when config exists
-  --preset-file <path> Read a preset code or JSON payload from a file
-  --force              Overwrite generated files when adding or initializing
-  --no-install         Write files without running the package manager
-  --dry-run            Print planned writes and installs without changing files
-  --json               Print machine-readable output where supported
-  --help               Show help
-  --version            Print the CLI version
-
-Preset notes:
-  Generate codes at ${DEFAULT_API_ORIGIN}/docs/primitives/setup
-  Plain init refuses an existing wensity.json unless --force
-  init --preset merges style + primitive CSS; does not rewrite installed source
-  add/update read style.iconLibrary for UI primitives only (Tabler|Lucide)
-  Invalid/expired/unsupported codes exit non-zero with an actionable message
-`;
-
-// src/errors.ts
-var CliError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.name = "CliError";
-    this.exitCode = exitCode;
-  }
+  IconCheck: "Check",
+  IconChevronDown: "ChevronDown",
+  IconChevronLeft: "ChevronLeft",
+  IconChevronRight: "ChevronRight",
+  IconChevronUp: "ChevronUp",
+  IconChevronsLeft: "ChevronsLeft",
+  IconChevronsRight: "ChevronsRight",
+  IconCircleX: "CircleX",
+  IconClock: "Clock",
+  IconCornerDownLeft: "CornerDownLeft",
+  IconDots: "Ellipsis",
+  IconDownload: "Download",
+  IconFile: "File",
+  IconFileMusic: "FileAudio",
+  IconFileText: "FileText",
+  IconFileZip: "FileArchive",
+  IconInfoCircle: "Info",
+  IconLayoutSidebarLeftCollapse: "PanelLeftClose",
+  IconLayoutSidebarLeftExpand: "PanelLeftOpen",
+  IconMinus: "Minus",
+  IconPhoto: "Image",
+  IconPlus: "Plus",
+  IconRefresh: "RefreshCw",
+  IconSearch: "Search",
+  IconSelector: "ChevronsUpDown",
+  IconSlash: "Slash",
+  IconUser: "User",
+  IconVideo: "Video",
+  IconX: "X"
 };
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
+var EXCLUSION_SET = new Set(ICON_TRANSFORM_EXCLUSIONS);
+function isIconTransformExclusion(name) {
+  return EXCLUSION_SET.has(name);
+}
+function isMappedTablerIcon(name) {
+  return Object.prototype.hasOwnProperty.call(TABLER_TO_LUCIDE, name);
+}
+function resolveLucideExport(tablerName) {
+  if (isIconTransformExclusion(tablerName)) {
+    throw new Error(
+      `Icon "${tablerName}" is a Phase 0 exclusion and must not be transformed. Use internal SVG/CSS geometry instead.`
+    );
+  }
+  if (!isMappedTablerIcon(tablerName)) {
+    throw new Error(
+      `No approved Lucide mapping for Tabler icon "${tablerName}". Add an audited map entry or convert it to internal geometry.`
+    );
+  }
+  return TABLER_TO_LUCIDE[tablerName];
 }
+var LUCIDE_TO_TABLER = Object.fromEntries(
+  Object.entries(TABLER_TO_LUCIDE).map(([tabler, lucide]) => [lucide, tabler])
+);
 
-// src/args.ts
-function parseArgs(argv) {
-  const positionals = [];
-  const options = /* @__PURE__ */ new Map();
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (!token.startsWith("--")) {
-      positionals.push(token);
-      continue;
+// ../wensity-preset/src/palettes.ts
+var BASE_COLOR_PALETTE = {
+  zinc: {
+    light: {
+      surfaceElevated: "#ffffff",
+      surfaceOverlay: "#ffffff",
+      foreground: "#09090b",
+      border: "rgba(9, 9, 11, 0.08)",
+      mutedForeground: "#71717a"
+    },
+    dark: {
+      surfaceElevated: "#18181b",
+      surfaceOverlay: "#27272a",
+      foreground: "#fafafa",
+      border: "rgba(250, 250, 250, 0.10)",
+      mutedForeground: "#a1a1aa"
     }
-    if (token === "--") {
-      positionals.push(...argv.slice(index + 1));
-      break;
+  },
+  neutral: {
+    light: {
+      surfaceElevated: "#ffffff",
+      surfaceOverlay: "#ffffff",
+      foreground: "#171717",
+      border: "rgba(23, 23, 23, 0.08)",
+      mutedForeground: "#737373"
+    },
+    dark: {
+      surfaceElevated: "#171717",
+      surfaceOverlay: "#262626",
+      foreground: "#fafafa",
+      border: "rgba(250, 250, 250, 0.10)",
+      mutedForeground: "#a3a3a3"
     }
-    const inlineValueIndex = token.indexOf("=");
-    const rawName = inlineValueIndex > -1 ? token.slice(2, inlineValueIndex) : token.slice(2);
-    const name = normalizeOptionName(rawName);
-    if (!name) {
-      throw new CliError(`Invalid option: ${token}`);
+  },
+  slate: {
+    light: {
+      surfaceElevated: "#ffffff",
+      surfaceOverlay: "#ffffff",
+      foreground: "#0f172a",
+      border: "rgba(15, 23, 42, 0.08)",
+      mutedForeground: "#64748b"
+    },
+    dark: {
+      surfaceElevated: "#0f172a",
+      surfaceOverlay: "#1e293b",
+      foreground: "#f8fafc",
+      border: "rgba(248, 250, 252, 0.10)",
+      mutedForeground: "#94a3b8"
     }
-    if (inlineValueIndex > -1) {
-      options.set(name, token.slice(inlineValueIndex + 1));
-      continue;
+  },
+  stone: {
+    light: {
+      surfaceElevated: "#ffffff",
+      surfaceOverlay: "#ffffff",
+      foreground: "#1c1917",
+      border: "rgba(28, 25, 23, 0.08)",
+      mutedForeground: "#78716c"
+    },
+    dark: {
+      surfaceElevated: "#1c1917",
+      surfaceOverlay: "#292524",
+      foreground: "#fafaf9",
+      border: "rgba(250, 250, 249, 0.10)",
+      mutedForeground: "#a8a29e"
     }
-    const nextToken = argv[index + 1];
-    if (nextToken && !nextToken.startsWith("--") && expectsValue(name)) {
-      options.set(name, nextToken);
-      index += 1;
-      continue;
+  },
+  taupe: {
+    light: {
+      surfaceElevated: "#faf8f5",
+      surfaceOverlay: "#ffffff",
+      foreground: "#3b342e",
+      border: "rgba(59, 52, 46, 0.10)",
+      mutedForeground: "#8a7f74"
+    },
+    dark: {
+      surfaceElevated: "#1c1916",
+      surfaceOverlay: "#2a2521",
+      foreground: "#f5f0ea",
+      border: "rgba(245, 240, 234, 0.10)",
+      mutedForeground: "#a89f94"
     }
-    options.set(name, true);
   }
-  return { positionals, options };
+};
+var THEME_COLOR_PALETTE = {
+  ink: {
+    light: { ...DEFAULT_CONTROL_SOLID_LIGHT },
+    dark: { ...DEFAULT_CONTROL_SOLID_DARK }
+  },
+  red: {
+    light: {
+      controlSolid: "#b91c1c",
+      controlSolidHover: "#dc2626",
+      controlSolidActive: "#991b1b",
+      controlSolidForeground: "#ffffff"
+    },
+    dark: {
+      controlSolid: "#f87171",
+      controlSolidHover: "#fca5a5",
+      controlSolidActive: "#ef4444",
+      controlSolidForeground: "#450a0a"
+    }
+  },
+  blue: {
+    light: {
+      controlSolid: "#1d4ed8",
+      controlSolidHover: "#2563eb",
+      controlSolidActive: "#1e40af",
+      controlSolidForeground: "#ffffff"
+    },
+    dark: {
+      controlSolid: "#60a5fa",
+      controlSolidHover: "#93c5fd",
+      controlSolidActive: "#3b82f6",
+      controlSolidForeground: "#172554"
+    }
+  },
+  violet: {
+    light: {
+      controlSolid: "#6d28d9",
+      controlSolidHover: "#7c3aed",
+      controlSolidActive: "#5b21b6",
+      controlSolidForeground: "#ffffff"
+    },
+    dark: {
+      controlSolid: "#a78bfa",
+      controlSolidHover: "#c4b5fd",
+      controlSolidActive: "#8b5cf6",
+      controlSolidForeground: "#2e1065"
+    }
+  },
+  green: {
+    light: {
+      controlSolid: "#047857",
+      controlSolidHover: "#059669",
+      controlSolidActive: "#065f46",
+      controlSolidForeground: "#ffffff"
+    },
+    dark: {
+      controlSolid: "#34d399",
+      controlSolidHover: "#6ee7b7",
+      controlSolidActive: "#10b981",
+      controlSolidForeground: "#022c22"
+    }
+  },
+  orange: {
+    light: {
+      controlSolid: "#c2410c",
+      controlSolidHover: "#ea580c",
+      controlSolidActive: "#9a3412",
+      controlSolidForeground: "#ffffff"
+    },
+    dark: {
+      controlSolid: "#fb923c",
+      controlSolidHover: "#fdba74",
+      controlSolidActive: "#f97316",
+      controlSolidForeground: "#431407"
+    }
+  }
+};
+var DEFAULT_CHART_STOPS = {
+  light: [
+    "#2a78d6",
+    "#1baf7a",
+    "#eda100",
+    "#008300",
+    "#4a3aa7",
+    "#e34948"
+  ],
+  dark: [
+    "#3987e5",
+    "#199e70",
+    "#c98500",
+    "#008300",
+    "#9085e9",
+    "#e66767"
+  ]
+};
+var CHART_PALETTES = {
+  theme: {
+    ink: DEFAULT_CHART_STOPS,
+    red: {
+      light: ["#e34948", "#f97316", "#eda100", "#db2777", "#b91c1c", "#9f1239"],
+      dark: ["#e66767", "#fb923c", "#c98500", "#f472b6", "#f87171", "#fb7185"]
+    },
+    blue: {
+      light: ["#2a78d6", "#0284c7", "#4a3aa7", "#0e7490", "#1d4ed8", "#0369a1"],
+      dark: ["#3987e5", "#38bdf8", "#9085e9", "#22d3ee", "#60a5fa", "#7dd3fc"]
+    },
+    violet: {
+      light: ["#4a3aa7", "#7c3aed", "#2a78d6", "#a21caf", "#6d28d9", "#db2777"],
+      dark: ["#9085e9", "#a78bfa", "#3987e5", "#e879f9", "#c4b5fd", "#f472b6"]
+    },
+    green: {
+      light: ["#1baf7a", "#008300", "#0d9488", "#2a78d6", "#047857", "#65a30d"],
+      dark: ["#199e70", "#34d399", "#2dd4bf", "#3987e5", "#4ade80", "#a3e635"]
+    },
+    orange: {
+      light: ["#eda100", "#f97316", "#e34948", "#ca8a04", "#c2410c", "#db2777"],
+      dark: ["#c98500", "#fb923c", "#e66767", "#facc15", "#fdba74", "#f472b6"]
+    }
+  },
+  warm: {
+    light: ["#ea580c", "#d97706", "#e34948", "#db2777", "#ca8a04", "#c2410c"],
+    dark: ["#fb923c", "#fbbf24", "#e66767", "#f472b6", "#facc15", "#fdba74"]
+  },
+  cool: {
+    light: ["#2a78d6", "#0e7490", "#4a3aa7", "#0284c7", "#1d4ed8", "#0f766e"],
+    dark: ["#3987e5", "#22d3ee", "#9085e9", "#38bdf8", "#60a5fa", "#2dd4bf"]
+  },
+  mixed: {
+    light: ["#2a78d6", "#e34948", "#1baf7a", "#eda100", "#4a3aa7", "#db2777"],
+    dark: ["#3987e5", "#e66767", "#199e70", "#c98500", "#9085e9", "#f472b6"]
+  }
+};
+
+// ../wensity-preset/src/curated-fonts.ts
+var HEADING_FONT_PACKAGES = {
+  playfair: {
+    packageName: "@fontsource/playfair-display",
+    importSpecifier: "@fontsource/playfair-display",
+    familyName: "Playfair Display"
+  }
+};
+var BODY_FONT_PACKAGES = {
+  inter: {
+    packageName: "@fontsource/inter",
+    importSpecifier: "@fontsource/inter",
+    familyName: "Inter"
+  }
+};
+var HEADING_FONT_CSS = {
+  system: "var(--font-display)",
+  playfair: "'Playfair Display', Georgia, 'Times New Roman', serif"
+};
+var BODY_FONT_CSS = {
+  system: "var(--font-sans)",
+  inter: "'Inter', ui-sans-serif, system-ui, sans-serif"
+};
+
+// ../wensity-preset/src/resolve.ts
+var RESOLVED_TOKEN_CSS_VARS = {
+  surfaceElevated: "--primitive-surface-elevated",
+  surfaceOverlay: "--primitive-surface-overlay",
+  surfaceHover: "--primitive-surface-hover",
+  surfaceActive: "--primitive-surface-active",
+  surfaceSelected: "--primitive-surface-selected",
+  borderSubtle: "--primitive-border-subtle",
+  ring: "--primitive-ring",
+  textSecondary: "--primitive-text-secondary",
+  textPlaceholder: "--primitive-text-placeholder",
+  controlSolid: "--primitive-control-solid",
+  controlSolidHover: "--primitive-control-solid-hover",
+  controlSolidActive: "--primitive-control-solid-active",
+  controlSolidForeground: "--primitive-control-solid-foreground",
+  chart1: "--primitive-chart-1",
+  chart2: "--primitive-chart-2",
+  chart3: "--primitive-chart-3",
+  chart4: "--primitive-chart-4",
+  chart5: "--primitive-chart-5",
+  chart6: "--primitive-chart-6",
+  radius: "--primitive-radius",
+  fontSans: "--primitive-font-sans",
+  fontDisplay: "--primitive-font-display",
+  fontMono: "--primitive-font-mono"
+};
+var INHERIT_BASE_EXPRESSIONS = {
+  light: {
+    surfaceElevated: "#ffffff",
+    surfaceOverlay: "#ffffff",
+    surfaceHover: "color-mix(in srgb, var(--foreground) 4%, transparent)",
+    surfaceActive: "color-mix(in srgb, var(--foreground) 7%, transparent)",
+    borderSubtle: "color-mix(in srgb, var(--border) 60%, transparent)",
+    textSecondary: "color-mix(in srgb, var(--foreground) 72%, transparent)",
+    textPlaceholder: "color-mix(in srgb, var(--muted-foreground) 85%, transparent)"
+  },
+  dark: {
+    surfaceElevated: "#0f0f10",
+    surfaceOverlay: "#141415",
+    surfaceHover: "color-mix(in srgb, var(--foreground) 5%, transparent)",
+    surfaceActive: "color-mix(in srgb, var(--foreground) 10%, transparent)",
+    borderSubtle: "color-mix(in srgb, var(--border) 60%, transparent)",
+    textSecondary: "color-mix(in srgb, var(--foreground) 72%, transparent)",
+    textPlaceholder: "color-mix(in srgb, var(--muted-foreground) 85%, transparent)"
+  }
+};
+var FIXED_RING = "color-mix(in srgb, var(--foreground) 45%, transparent)";
+var FIXED_SURFACE_SELECTED = {
+  light: "color-mix(in srgb, var(--foreground) 6%, transparent)",
+  dark: "color-mix(in srgb, var(--foreground) 8%, transparent)"
+};
+var COLORED_THEME_IDS = /* @__PURE__ */ new Set([
+  "red",
+  "blue",
+  "violet",
+  "green",
+  "orange"
+]);
+function colorMix(source, percent) {
+  return `color-mix(in srgb, ${source} ${percent}%, transparent)`;
 }
-function getStringOption(args, name) {
-  const value = args.options.get(name);
-  if (value === void 0) return void 0;
-  if (typeof value === "boolean") {
-    throw new CliError(`--${name} expects a value.`);
+function resolveControlSolid(partial, fallback) {
+  const out = { ...fallback };
+  for (const key of CONTROL_SOLID_COLOR_KEYS) {
+    const value = partial?.[key];
+    if (value !== void 0) out[key] = value;
   }
-  return value;
+  return out;
 }
-function hasFlag(args, name) {
-  return args.options.get(name) === true;
+function chartStopsToModeTokens(stops) {
+  return {
+    chart1: stops[0],
+    chart2: stops[1],
+    chart3: stops[2],
+    chart4: stops[3],
+    chart5: stops[4],
+    chart6: stops[5]
+  };
 }
-function expectsValue(name) {
-  return ["api-url", "registry", "token", "type", "preset", "preset-file"].includes(name);
+function baseFromInherit(mode) {
+  return { ...INHERIT_BASE_EXPRESSIONS[mode] };
 }
-function normalizeOptionName(name) {
-  if (name === "dry") return "dry-run";
-  return name;
+function baseFromSeeds(seeds, mode) {
+  const hoverPercent = mode === "light" ? 4 : 5;
+  const activePercent = mode === "light" ? 7 : 10;
+  return {
+    surfaceElevated: seeds.surfaceElevated,
+    surfaceOverlay: seeds.surfaceOverlay,
+    surfaceHover: colorMix(seeds.foreground, hoverPercent),
+    surfaceActive: colorMix(seeds.foreground, activePercent),
+    borderSubtle: colorMix(seeds.border, 60),
+    textSecondary: colorMix(seeds.foreground, 72),
+    textPlaceholder: colorMix(seeds.mutedForeground, 85)
+  };
+}
+function ringAndSelectedForInk(mode) {
+  return {
+    ring: FIXED_RING,
+    surfaceSelected: FIXED_SURFACE_SELECTED[mode]
+  };
+}
+function ringAndSelectedFromAccent(accent, mode) {
+  return {
+    ring: colorMix(accent, 45),
+    surfaceSelected: colorMix(accent, mode === "light" ? 6 : 8)
+  };
+}
+function buildModeTokens(args) {
+  return {
+    ...args.base,
+    ...args.ringSelected,
+    controlSolid: args.control.controlSolid,
+    controlSolidHover: args.control.controlSolidHover,
+    controlSolidActive: args.control.controlSolidActive,
+    controlSolidForeground: args.control.controlSolidForeground,
+    ...chartStopsToModeTokens(args.charts)
+  };
+}
+function resolveStyleConfig(style) {
+  const lightControl = resolveControlSolid(
+    style.colors?.light,
+    DEFAULT_CONTROL_SOLID_LIGHT
+  );
+  const darkControl = resolveControlSolid(
+    style.colors?.dark,
+    DEFAULT_CONTROL_SOLID_DARK
+  );
+  return {
+    iconLibrary: style.iconLibrary,
+    radius: RADIUS_PRESET_CSS[style.radius],
+    fontSans: expandFontRole(style.fonts.sans, "sans"),
+    fontDisplay: expandFontRole(style.fonts.display, "display"),
+    fontMono: expandFontRole(style.fonts.mono, "mono"),
+    light: buildModeTokens({
+      base: baseFromInherit("light"),
+      control: lightControl,
+      ringSelected: ringAndSelectedForInk("light"),
+      charts: DEFAULT_CHART_STOPS.light
+    }),
+    dark: buildModeTokens({
+      base: baseFromInherit("dark"),
+      control: darkControl,
+      ringSelected: ringAndSelectedForInk("dark"),
+      charts: DEFAULT_CHART_STOPS.dark
+    })
+  };
+}
+function resolveChartStops(chartPalette, themeColor, mode) {
+  if (chartPalette === "theme") {
+    return CHART_PALETTES.theme[themeColor][mode];
+  }
+  return CHART_PALETTES[chartPalette][mode];
+}
+function resolveStyleConfigCanonical(style) {
+  const theme = THEME_COLOR_PALETTE[style.themeColor];
+  const useAccentRing = COLORED_THEME_IDS.has(style.themeColor);
+  const resolveMode = (mode) => {
+    const base = style.baseColor === "inherit" ? baseFromInherit(mode) : baseFromSeeds(BASE_COLOR_PALETTE[style.baseColor][mode], mode);
+    const control = theme[mode];
+    const ringSelected = useAccentRing ? ringAndSelectedFromAccent(control.controlSolid, mode) : ringAndSelectedForInk(mode);
+    const charts = resolveChartStops(style.chartPalette, style.themeColor, mode);
+    return buildModeTokens({ base, control, ringSelected, charts });
+  };
+  return {
+    iconLibrary: style.iconLibrary,
+    radius: RADIUS_PRESET_CSS[style.radius],
+    fontSans: BODY_FONT_CSS[style.bodyFont],
+    fontDisplay: HEADING_FONT_CSS[style.headingFont],
+    // Canonical model has no mono field — lock to today's system-mono expansion.
+    fontMono: FONT_ID_EXPANSIONS["system-mono"],
+    light: resolveMode("light"),
+    dark: resolveMode("dark")
+  };
 }
-
-// src/config.ts
-import { existsSync } from "fs";
-import { access, mkdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join2, relative as relative2 } from "path";
 
 // src/paths.ts
 import { dirname, isAbsolute, relative, resolve, sep } from "path";
@@ -995,6 +1707,35 @@ function extensionlessPath(path) {
   return path.replace(/\.(tsx|ts|jsx|js)$/, "");
 }
 
+// src/style-shape.ts
+function isCanonicalStyleShape(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return "baseColor" in record || "themeColor" in record || "chartPalette" in record || "headingFont" in record || "bodyFont" in record;
+}
+function normalizeProjectStyle(style) {
+  if (isCanonicalStyleShape(style)) {
+    return normalizeStyleConfigCanonical(style);
+  }
+  return normalizeStyleConfig(style);
+}
+function resolveTokensForStyle(style) {
+  if (isCanonicalStyleShape(style)) {
+    return resolveStyleConfigCanonical(normalizeStyleConfigCanonical(style));
+  }
+  return resolveStyleConfig(normalizeStyleConfig(style));
+}
+function curatedFontsFromStyle(style) {
+  if (isCanonicalStyleShape(style)) {
+    const normalized = normalizeStyleConfigCanonical(style);
+    return {
+      headingFont: normalized.headingFont,
+      bodyFont: normalized.bodyFont
+    };
+  }
+  return { headingFont: "system", bodyFont: "system" };
+}
+
 // src/config.ts
 async function loadConfig(cwd, overrides = {}) {
   const foundPath = await findUp(cwd, CONFIG_FILE_NAME);
@@ -1128,7 +1869,8 @@ function normalizeConfig(config, overrides) {
         utils: config.aliases?.utils || DEFAULT_UTILS_ALIAS
       },
       // In-memory only: missing style fields resolve to defaults without rewriting disk.
-      style: normalizeStyleConfig(config.style)
+      // Accepts either legacy or canonical style shapes.
+      style: normalizeProjectStyle(config.style)
     };
   } catch (error) {
     if (error instanceof PresetValidationError) {
@@ -1257,6 +1999,122 @@ function requiredHome(env) {
   throw new CliError("HOME is not set, so the CLI cannot locate ~/.config/wensity.");
 }
 
+// src/font-install.ts
+var FONT_CSS_START_MARKER = "/* \u2500\u2500 Wensity Fonts";
+var FONT_CSS_END_MARKER = "/* \u2500\u2500 End Wensity Fonts \u2500\u2500 */";
+function planFontInstall(headingFont, bodyFont) {
+  const packages = [];
+  const importLines = [];
+  const seenPackages = /* @__PURE__ */ new Set();
+  const seenImports = /* @__PURE__ */ new Set();
+  const pushFont = (meta) => {
+    if (!meta) return;
+    if (!seenPackages.has(meta.packageName)) {
+      seenPackages.add(meta.packageName);
+      packages.push(meta.packageName);
+    }
+    const line = `@import "${meta.importSpecifier}";`;
+    if (!seenImports.has(line)) {
+      seenImports.add(line);
+      importLines.push(line);
+    }
+  };
+  if (headingFont !== "system") {
+    pushFont(HEADING_FONT_PACKAGES[headingFont]);
+  }
+  if (bodyFont !== "system") {
+    pushFont(BODY_FONT_PACKAGES[bodyFont]);
+  }
+  packages.sort();
+  if (importLines.length === 0) {
+    return { packages: [], importLines: [], block: null };
+  }
+  const block = [
+    `${FONT_CSS_START_MARKER} \u2500\u2500 */`,
+    ...importLines,
+    FONT_CSS_END_MARKER
+  ].join("\n");
+  return { packages, importLines, block };
+}
+function upsertFontImportBlock(existingCss, block) {
+  const start = existingCss.indexOf(FONT_CSS_START_MARKER);
+  const end = existingCss.indexOf(FONT_CSS_END_MARKER);
+  if (start !== -1 || end !== -1) {
+    if (start === -1 || end === -1 || end <= start) {
+      throw new CliError(
+        "Configured Tailwind CSS has a partial Wensity Fonts block. Remove the broken markers and re-run install."
+      );
+    }
+    const before2 = existingCss.slice(0, start).replace(/\s*$/, "");
+    const after2 = existingCss.slice(end + FONT_CSS_END_MARKER.length).replace(/^\s*/, "");
+    if (!block) {
+      const joined = [before2, after2].filter((part) => part.length > 0).join("\n\n");
+      return joined ? `${joined.replace(/\n{3,}/g, "\n\n")}
+` : "";
+    }
+    const normalizedBlock2 = block.trim();
+    const prefix2 = before2 ? `${before2}
+
+` : "";
+    const suffix2 = after2 ? `
+
+${after2}` : "\n";
+    return `${prefix2}${normalizedBlock2}${suffix2}`.replace(/\n{3,}/g, "\n\n");
+  }
+  if (!block) return existingCss;
+  const normalizedBlock = block.trim();
+  const insertAt = findFontBlockInsertIndex(existingCss);
+  const before = existingCss.slice(0, insertAt).replace(/\s*$/, "");
+  const after = existingCss.slice(insertAt).replace(/^\s*/, "");
+  const prefix = before ? `${before}
+
+` : "";
+  const suffix = after ? `
+
+${after}` : "\n";
+  return `${prefix}${normalizedBlock}${suffix}`.replace(/\n{3,}/g, "\n\n");
+}
+function warnUnusedFontPackageMessage(headingFont, bodyFont, installedPackages) {
+  const needed = new Set(planFontInstall(headingFont, bodyFont).packages);
+  const curated = [
+    ...Object.values(HEADING_FONT_PACKAGES).map((entry) => entry.packageName),
+    ...Object.values(BODY_FONT_PACKAGES).map((entry) => entry.packageName)
+  ];
+  const leftover = curated.filter(
+    (pkg) => installedPackages.has(pkg) && !needed.has(pkg)
+  );
+  if (leftover.length === 0) return void 0;
+  return `Project package.json still lists ${leftover.join(", ")} while curated fonts are set to heading="${headingFont}" body="${bodyFont}". Wensity removed the @import for unused fonts but will not uninstall ${leftover.join(", ")} (it may be used outside Wensity).`;
+}
+function findFontBlockInsertIndex(css) {
+  let index = 0;
+  const length = css.length;
+  while (index < length) {
+    while (index < length && /\s/.test(css[index])) index += 1;
+    if (index >= length) break;
+    if (css.startsWith("/*", index)) {
+      const end = css.indexOf("*/", index + 2);
+      if (end === -1) break;
+      index = end + 2;
+      continue;
+    }
+    if (css.startsWith("//", index)) {
+      const end = css.indexOf("\n", index);
+      if (end === -1) return length;
+      index = end + 1;
+      continue;
+    }
+    if (css.startsWith("@charset", index) || css.startsWith("@import", index)) {
+      const end = css.indexOf(";", index);
+      if (end === -1) break;
+      index = end + 1;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
 // src/output.ts
 import boxen from "boxen";
 import Table from "cli-table3";
@@ -1807,19 +2665,13 @@ async function resolvePresetStyle(input) {
       const trimmed = raw.trim();
       if (trimmed.startsWith("{")) {
         const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === "object" && "v" in parsed) {
-          const payload = validateCodecPayload(parsed);
-          const json = stableStringifyCodecPayload(payload);
-          code = `${PRESET_CODEC_PREFIX}.${Buffer.from(json, "utf8").toString("base64url")}`;
-        } else {
-          code = encodePreset(parsed);
-        }
+        code = encodePresetFileJson(parsed);
       } else {
         code = trimmed;
       }
     } catch (error) {
       if (error instanceof PresetValidationError) {
-        throw new CliError(`Invalid preset file: ${error.message}`);
+        throw toCliPresetError(error);
       }
       if (error instanceof SyntaxError) {
         throw new CliError(`Preset file contains invalid JSON: ${error.message}`);
@@ -1834,19 +2686,69 @@ async function resolvePresetStyle(input) {
   }
   try {
     const trimmed = code.trim();
-    const payload = decodePreset(trimmed);
-    const style = normalizeStyleConfig({
-      ...codecPayloadToStyleInput(payload),
-      presetCode: trimmed
-    });
+    const payload = decodeAnyPreset(trimmed);
+    const style = styleFromDecodedPayload(payload, trimmed);
     return { style, presetCode: trimmed };
   } catch (error) {
     if (error instanceof PresetValidationError) {
-      throw new CliError(`Invalid preset: ${error.message}`);
+      throw toCliPresetError(error);
     }
     throw error;
   }
 }
+function encodePresetFileJson(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new PresetValidationError("Expected an object at preset.", "preset");
+  }
+  if ("v" in parsed) {
+    const v = parsed.v;
+    if (v === 1) {
+      const payload = validateCodecPayload(parsed);
+      const json = stableStringifyCodecPayload(payload);
+      return `${PRESET_CODEC_PREFIX}.${Buffer.from(json, "utf8").toString("base64url")}`;
+    }
+    if (v === 2) {
+      const payload = validateCodecPayloadCanonical(parsed);
+      const json = stableStringifyCodecPayloadCanonical(payload);
+      return `${PRESET_CODEC_PREFIX}.${Buffer.from(json, "utf8").toString("base64url")}`;
+    }
+    throw new PresetValidationError(
+      `Unsupported preset payload version ${String(v)}. This preset may require a newer version of the Wensity CLI.`,
+      "preset.v"
+    );
+  }
+  if ("baseColor" in parsed || "themeColor" in parsed || "chartPalette" in parsed || "headingFont" in parsed || "bodyFont" in parsed) {
+    return encodePresetCanonical(parsed);
+  }
+  return encodePreset(parsed);
+}
+function styleFromDecodedPayload(payload, presetCode) {
+  if (payload.v === 1) {
+    return normalizeStyleConfig({
+      ...codecPayloadToStyleInput(payload),
+      presetCode
+    });
+  }
+  return normalizeStyleConfigCanonical({
+    baseColor: payload.baseColor,
+    themeColor: payload.themeColor,
+    chartPalette: payload.chartPalette,
+    headingFont: payload.headingFont,
+    bodyFont: payload.bodyFont,
+    iconLibrary: payload.iconLibrary,
+    radius: payload.radius,
+    presetCode
+  });
+}
+function toCliPresetError(error) {
+  const message = error.message;
+  if (/Unsupported preset payload version/i.test(message)) {
+    return new CliError(
+      `Invalid preset: ${message} Upgrade the Wensity CLI (wensity@0.1.7 or newer) and try again.`
+    );
+  }
+  return new CliError(`Invalid preset: ${message}`);
+}
 
 // src/preset-init-writes.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
@@ -1878,34 +2780,29 @@ async function commitPresetInitWrites(input) {
 // src/style-css.ts
 var ROOT_SELECTOR = ":root";
 var DARK_SELECTOR = ".dark";
-function applyStyleToPrimitiveCss(block, styleInput) {
-  const style = normalizeStyleConfig(styleInput);
+var SHARED_TOKEN_KEYS = ["radius", "fontSans", "fontDisplay", "fontMono"];
+var MODE_TOKEN_KEYS = Object.keys(RESOLVED_TOKEN_CSS_VARS).filter(
+  (key) => !SHARED_TOKEN_KEYS.includes(key)
+);
+function applyResolvedTokensToPrimitiveCss(block, tokens) {
   let next = block;
-  const radiusValue = RADIUS_PRESET_CSS[style.radius];
-  next = replaceDeclInSelector(next, ROOT_SELECTOR, "--primitive-radius", radiusValue);
-  next = replaceDeclInSelector(next, DARK_SELECTOR, "--primitive-radius", radiusValue);
-  for (const role of FONT_ROLE_KEYS) {
-    const cssVar = `--primitive-font-${role}`;
-    const cssValue = expandFontRole(style.fonts[role], role);
-    next = replaceDeclInSelector(next, ROOT_SELECTOR, cssVar, cssValue);
-    next = replaceDeclInSelector(next, DARK_SELECTOR, cssVar, cssValue);
-  }
-  if (style.colors?.light) {
-    for (const key of CONTROL_SOLID_COLOR_KEYS) {
-      const value = style.colors.light[key];
-      if (value === void 0) continue;
-      next = replaceDeclInSelector(next, ROOT_SELECTOR, CONTROL_SOLID_CSS_VARS[key], value);
-    }
+  for (const key of SHARED_TOKEN_KEYS) {
+    const cssVar = RESOLVED_TOKEN_CSS_VARS[key];
+    const value = tokens[key];
+    next = replaceDeclInSelector(next, ROOT_SELECTOR, cssVar, value);
+    next = replaceDeclInSelector(next, DARK_SELECTOR, cssVar, value);
   }
-  if (style.colors?.dark) {
-    for (const key of CONTROL_SOLID_COLOR_KEYS) {
-      const value = style.colors.dark[key];
-      if (value === void 0) continue;
-      next = replaceDeclInSelector(next, DARK_SELECTOR, CONTROL_SOLID_CSS_VARS[key], value);
-    }
+  for (const key of MODE_TOKEN_KEYS) {
+    const cssVar = RESOLVED_TOKEN_CSS_VARS[key];
+    next = replaceDeclInSelector(next, ROOT_SELECTOR, cssVar, tokens.light[key]);
+    next = replaceDeclInSelector(next, DARK_SELECTOR, cssVar, tokens.dark[key]);
   }
   return next;
 }
+function applyStyleToPrimitiveCss(block, styleInput) {
+  const style = normalizeProjectStyle(styleInput);
+  return applyResolvedTokensToPrimitiveCss(block, resolveTokensForStyle(style));
+}
 function replaceDeclInSelector(css, selector, property, value) {
   const block = findTopLevelRule(css, selector);
   if (!block) return css;
@@ -2131,7 +3028,7 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
   const files = [];
   const componentContents = [];
   const iconSwaps = [];
-  const style = normalizeStyleConfig(config.style);
+  const style = normalizeProjectStyle(config.style);
   const isPrimitiveCategory = isPrimitivePayloadCategory(payload.category);
   const payloadHelperNeeds = normalizePayloadHelperNeeds(
     "helperNeeds" in payload ? payload.helperNeeds : void 0
@@ -2188,8 +3085,10 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
   }
   const iconDependencySwap = aggregateIconDependencySwaps(iconSwaps);
   const declaredAfterSwap = applyIconDependencySwap(payload.dependencies ?? [], iconDependencySwap);
+  const fonts = curatedFontsFromStyle(style);
+  const fontPlan = planFontInstall(fonts.headingFont, fonts.bodyFont);
   const dependencies = collectDependencies({
-    declared: declaredAfterSwap,
+    declared: [...declaredAfterSwap, ...fontPlan.packages],
     source: componentContents.join("\n"),
     needsUtility: helperNeeds.utils
   });
@@ -2198,7 +3097,8 @@ async function prepareInstall(projectRoot, config, payload, options = {}) {
     files,
     dependencies,
     ...cssFile ? { cssFile } : {},
-    ...isPrimitiveCategory ? { iconDependencySwap } : {}
+    ...isPrimitiveCategory ? { iconDependencySwap } : {},
+    ...fontPlan.packages.length > 0 ? { fontPackages: fontPlan.packages } : {}
   };
 }
 async function planPrimitiveCssFile(projectRoot, config, payload) {
@@ -2207,13 +3107,16 @@ async function planPrimitiveCssFile(projectRoot, config, payload) {
   }
   let primitiveCss = payload.primitiveCss.trim();
   if (!primitiveCss) return void 0;
-  const style = normalizeStyleConfig(config.style);
+  const style = normalizeProjectStyle(config.style);
   primitiveCss = applyStyleToPrimitiveCss(primitiveCss, style).trim();
   const cssRelative = config.tailwind?.css;
   if (!cssRelative) return void 0;
   const absolutePath = resolveInside(projectRoot, cssRelative);
   const existing = await fileExists(absolutePath) ? await readFile4(absolutePath, "utf8") : "";
-  const next = upsertPrimitiveCssBlock(existing, primitiveCss);
+  const withTokens = upsertPrimitiveCssBlock(existing, primitiveCss);
+  const fonts = curatedFontsFromStyle(style);
+  const fontPlan = planFontInstall(fonts.headingFont, fonts.bodyFont);
+  const next = upsertFontImportBlock(withTokens, fontPlan.block);
   if (next === existing) return void 0;
   return {
     absolutePath,
@@ -2489,6 +3392,9 @@ async function initWithPreset(context, options) {
     presetCode: options.presetCode,
     presetFile: options.presetFile
   });
+  const fonts = curatedFontsFromStyle(style);
+  const fontPlan = planFontInstall(fonts.headingFont, fonts.bodyFont);
+  const installDependencies = [...options.dependencies, ...fontPlan.packages];
   const configPath = join6(context.cwd, CONFIG_FILE_NAME);
   const configExists = await fileExists(configPath);
   let config;
@@ -2531,8 +3437,11 @@ async function initWithPreset(context, options) {
   }
   const cssAbsolute = resolveInside(context.cwd, cssRelative);
   const existingCss = await fileExists(cssAbsolute) ? await readFile5(cssAbsolute, "utf8") : "";
-  const nextCss = upsertPrimitiveCssBlock(existingCss, primitiveCss);
+  const withTokens = upsertPrimitiveCssBlock(existingCss, primitiveCss);
+  const nextCss = upsertFontImportBlock(withTokens, fontPlan.block);
   const cssChanged = nextCss !== existingCss;
+  const installedPackages = readInstalledPackageNames(context.cwd);
+  const unusedFontWarning = installedPackages ? warnUnusedFontPackageMessage(fonts.headingFont, fonts.bodyFont, installedPackages) : void 0;
   if (options.dryRun) {
     printTitle("Project initialization preview (preset)");
     print(action("Would write:"));
@@ -2541,7 +3450,11 @@ async function initWithPreset(context, options) {
     print(formatList(planned));
     print(action(`Preset: ${presetCode.slice(0, 24)}\u2026`));
     print(action(`Style: icon=${style.iconLibrary} radius=${style.radius}`));
-    if (options.install) print(action(`Would install: ${options.dependencies.join(" ")}`));
+    if (fontPlan.packages.length > 0) {
+      print(action(`Fonts: ${fontPlan.packages.join(" ")}`));
+    }
+    if (options.install) print(action(`Would install: ${installDependencies.join(" ")}`));
+    if (unusedFontWarning) warn(unusedFontWarning);
     return;
   }
   const shouldWriteUtility = options.force || !await fileExists(utilityPath);
@@ -2562,7 +3475,7 @@ async function initWithPreset(context, options) {
     }
   });
   if (options.install) {
-    runInstall(context.cwd, missingDependencies(context.cwd, options.dependencies));
+    runInstall(context.cwd, missingDependencies(context.cwd, installDependencies));
   }
   printTitle("Project initialized");
   const created = [
@@ -2576,7 +3489,11 @@ async function initWithPreset(context, options) {
   } else {
     created.push(action(`CSS tokens unchanged: ${toPosixPath(cssRelative)}`));
   }
+  if (fontPlan.packages.length > 0) {
+    created.push(success(`fonts: ${fontPlan.packages.join(", ")}`));
+  }
   print(panel("Created", created));
+  if (unusedFontWarning) warn(unusedFontWarning);
   print(nextSteps([
     "Browse available components: npx wensity list",
     "Install a primitive: npx wensity add button"
@@ -2721,9 +3638,11 @@ Usage: wensity ${updateMode ? "update" : "add"} <slug>${resourceType === "block"
   await assertNoConflicts(plannedInstallFiles, force || dryRun);
   const plannedFiles = summarizeFiles(loaded.projectRoot, plannedInstallFiles);
   const missing = missingDependencies(loaded.projectRoot, prepared.dependencies);
-  const style = normalizeStyleConfig(loaded.config.style);
+  const style = normalizeProjectStyle(loaded.config.style);
+  const fonts = curatedFontsFromStyle(style);
   const installedPackages = readInstalledPackageNames(loaded.projectRoot);
   const oppositeIconWarning = installedPackages && prepared.iconDependencySwap ? warnOppositeIconPackageMessage(style.iconLibrary, installedPackages) : void 0;
+  const unusedFontWarning = installedPackages ? warnUnusedFontPackageMessage(fonts.headingFont, fonts.bodyFont, installedPackages) : void 0;
   if (dryRun) {
     printTitle(updateMode ? "Update preview" : "Install preview");
     print(action("Would write:"));
@@ -2733,6 +3652,7 @@ Usage: wensity ${updateMode ? "update" : "add"} <slug>${resourceType === "block"
     }
     if (install && missing.length > 0) print(action(`Would install: ${missing.join(" ")}`));
     if (oppositeIconWarning) warn(oppositeIconWarning);
+    if (unusedFontWarning) warn(unusedFontWarning);
     return;
   }
   await writePlannedFiles(plannedInstallFiles);
@@ -2745,6 +3665,7 @@ Usage: wensity ${updateMode ? "update" : "add"} <slug>${resourceType === "block"
     ...plannedFiles.map((file) => success(file))
   ]));
   if (oppositeIconWarning) warn(oppositeIconWarning);
+  if (unusedFontWarning) warn(unusedFontWarning);
   if (!install && missing.length > 0) {
     warn(`Dependencies were not installed: ${missing.join(" ")}`);
     print(nextSteps([