inventive-ui 0.0.10 → 0.0.11

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path27 from "path";
+import path26 from "path";
 import { Command } from "commander";
 
 // src/utils/ui.ts
@@ -190,7 +190,7 @@ var BANNER_COMPACT = [
 var FULL_BANNER_WIDTH = 101;
 function resolveCliVersion() {
   try {
-    return true ? "0.0.10" : "1.0.0";
+    return true ? "0.0.11" : "1.0.0";
   } catch {
     return "1.0.0";
   }
@@ -373,8 +373,8 @@ function resolveApiBaseUrl() {
     );
   }
   if (parsed.pathname && parsed.pathname !== "/" && parsed.pathname !== "") {
-    const path28 = parsed.pathname.replace(/\/+$/, "");
-    if (path28 && !/^\/[a-zA-Z0-9._/-]+$/.test(path28)) {
+    const path27 = parsed.pathname.replace(/\/+$/, "");
+    if (path27 && !/^\/[a-zA-Z0-9._/-]+$/.test(path27)) {
       throw new CLIError(
         "IUI_API_URL path contains invalid characters.",
         "Use a simple path prefix such as /v1"
@@ -434,7 +434,7 @@ var COMPONENTS_PACKAGE = "@inventive-ui/components";
 var NPM_SCOPE = "@inventive-ui";
 var IUI_DIR = ".iui";
 var GLOBAL_CONFIG_DIR = ".iui";
-var PROJECT_CONFIG_FILE = "iui.config.ts";
+var PROJECT_CONFIG_FILE = "theme.config.ts";
 var REQUIRED_REACT_MAJOR = 19;
 var REACT_SAFE_VERSION = "^19.0.0";
 var REQUIRED_VITE_MAJOR = 6;
@@ -596,7 +596,7 @@ var EMOJI_FAMILIES = [
   "twitter",
   "native"
 ];
-var DEFAULT_EMOJI_SKIN_TONE = "medium-light";
+var DEFAULT_EMOJI_SKIN_TONE = "mediumLight";
 var EMOJI_FAMILY_LABELS = {
   apple: "Apple",
   google: "Google",
@@ -1428,7 +1428,7 @@ function resolveFrameworkScriptsDir(startCwd) {
     if (existsSync(loader)) return scriptsDir;
   }
   throw new CLIError(
-    `Cannot scaffold iui.config.ts: ${FRAMEWORK_PACKAGE} is not installed or is missing scripts/load-framework-theme-defaults.mjs.`
+    `Cannot scaffold theme.config.ts: ${FRAMEWORK_PACKAGE} is not installed or is missing scripts/load-framework-theme-defaults.mjs.`
   );
 }
 function buildProjectConfigSource(cwd = process.cwd()) {
@@ -2043,7 +2043,6 @@ function mergeComponentConfigContent(source, manifest) {
 // src/utils/config-patch/tsconfig-iui.ts
 import path7 from "path";
 import fs6 from "fs-extra";
-var IUI_TS_ROOT_FILES = ["iui.config.ts", "component.config.ts"];
 function isSolutionStyleTsconfig(config) {
   const refs = config.references;
   return Array.isArray(refs) && refs.length > 0;
@@ -2101,7 +2100,8 @@ function patchSolutionStyleTsconfigForIui(cwd) {
   if (!isSolutionStyleTsconfig(existing)) return false;
   const repairedRoot = repairSolutionStyleRootTsconfig(cwd);
   const appPath = resolveAppTsconfigPath(cwd, existing);
-  const patchedApp = appPath ? patchJsonInclude(appPath, IUI_TS_ROOT_FILES) : false;
+  const themeFile = fs6.existsSync(path7.join(cwd, "iui.config.ts")) && !fs6.existsSync(path7.join(cwd, "theme.config.ts")) ? "iui.config.ts" : "theme.config.ts";
+  const patchedApp = appPath ? patchJsonInclude(appPath, [themeFile, "component.config.ts"]) : false;
   return repairedRoot || patchedApp;
 }
 
@@ -2119,10 +2119,9 @@ var iuiThemeConfigSchema = z2.object({
 }).strict();
 var IuiThemeConfigSchema = iuiThemeConfigSchema.refine(
   (data) => !("assets" in data),
-  { message: "iui.config must not contain an assets key \u2014 use assets.config.json" }
+  { message: "theme.config must not contain an assets key \u2014 use assets.config.json" }
 );
 var AssetsConfigSchema = z2.object({
-  binding: z2.enum(["lazy", "scanned"]).optional(),
   preload: z2.enum(["none", "configured", "scanned"]).optional(),
   icon: z2.object({
     library: z2.string().optional(),
@@ -2195,11 +2194,14 @@ function stripAssetsFromIuiConfig(content) {
   return next;
 }
 function checkIuiConfigTierBleed(cwd = process.cwd(), options = {}) {
-  const configPath = path8.join(cwd, PROJECT_CONFIG_FILE);
+  const configPath = path8.join(
+    cwd,
+    fs7.existsSync(path8.join(cwd, PROJECT_CONFIG_FILE)) || !fs7.existsSync(path8.join(cwd, "iui.config.ts")) ? PROJECT_CONFIG_FILE : "iui.config.ts"
+  );
   if (!fs7.existsSync(configPath)) {
     return {
       ok: false,
-      summary: "iui.config.ts not found",
+      summary: "theme.config.ts not found",
       details: "Run iui init to scaffold project config."
     };
   }
@@ -2214,7 +2216,7 @@ function checkIuiConfigTierBleed(cwd = process.cwd(), options = {}) {
     }
   }
   if (issues.length === 0) {
-    return { ok: true, summary: "iui.config.ts tier boundaries are valid" };
+    return { ok: true, summary: "theme.config.ts tier boundaries are valid" };
   }
   if (options.autoFix) {
     const fixed = stripAssetsFromIuiConfig(content);
@@ -2227,14 +2229,14 @@ function checkIuiConfigTierBleed(cwd = process.cwd(), options = {}) {
       if (remaining.length === 0 && /\bbuild\s*:\s*\{/.test(content)) {
         return {
           ok: true,
-          summary: "iui.config.ts repaired (removed assets tier bleed)"
+          summary: "theme.config.ts repaired (removed assets tier bleed)"
         };
       }
     }
   }
   return {
     ok: false,
-    summary: "iui.config.ts violates three-config tier boundaries",
+    summary: "theme.config.ts violates three-config tier boundaries",
     details: issues.map((i) => `- ${i}`).join("\n")
   };
 }
@@ -2528,12 +2530,6 @@ function mergeAssetSlotWithTemplate(slot, templateSlot) {
 function seedAssetsOutputFromTemplate(output) {
   const template = loadAssetsConfigTemplate();
   for (const [key, tplVal] of Object.entries(template)) {
-    if (key === "binding") {
-      if (output.binding === void 0 && tplVal !== void 0) {
-        output.binding = tplVal;
-      }
-      continue;
-    }
     if (typeof tplVal === "object" && tplVal !== null && !Array.isArray(tplVal)) {
       output[key] = mergeAssetSlotWithTemplate(
         output[key],
@@ -2541,13 +2537,6 @@ function seedAssetsOutputFromTemplate(output) {
       );
     }
   }
-  if (output.binding === "scanned") {
-    output.preload = output.preload ?? "scanned";
-    const icon = output.icon;
-    if (icon && typeof icon === "object" && !Array.isArray(icon)) {
-      icon.preload = icon.preload ?? "scanned";
-    }
-  }
 }
 function assetsConfigPath(cwd) {
   return path10.join(resolveIuiProjectRoot(cwd ?? process.cwd()), ASSETS_CONFIG_FILE);
@@ -2707,9 +2696,6 @@ function writeAssetsConfig(cwd = process.cwd()) {
       delete output[legacyKey];
     }
   }
-  if (output.binding === void 0 && Object.keys(assets2).length > 0 && projectHasViteTooling(cwd)) {
-    output.binding = "scanned";
-  }
   seedAssetsOutputFromTemplate(output);
   writeJson(assetsConfigPath(cwd), output);
   try {
@@ -2762,12 +2748,19 @@ function registryItemsMap(manifest) {
   }
   return map;
 }
+function resolveProjectConfigPath(root) {
+  const current = path10.join(root, PROJECT_CONFIG_FILE);
+  if (fs8.existsSync(current)) return current;
+  const previous = path10.join(root, "iui.config.ts");
+  if (fs8.existsSync(previous)) return previous;
+  return current;
+}
 function writeProjectConfig(cwd = process.cwd()) {
   const configPath = path10.join(cwd, PROJECT_CONFIG_FILE);
   atomicWriteFile(configPath, buildProjectConfigSource(cwd));
 }
 function ensureProjectConfigBuildBlock(cwd = process.cwd()) {
-  const configPath = path10.join(resolveIuiProjectRoot(cwd), PROJECT_CONFIG_FILE);
+  const configPath = resolveProjectConfigPath(resolveIuiProjectRoot(cwd));
   if (!fs8.existsSync(configPath)) return false;
   const before = fs8.readFileSync(configPath, "utf-8");
   const result = patchProjectConfigBuildBlock(before);
@@ -2777,7 +2770,7 @@ function ensureProjectConfigBuildBlock(cwd = process.cwd()) {
 }
 function ensureProjectConfig(cwd = process.cwd()) {
   const root = resolveIuiProjectRoot(cwd);
-  const configPath = path10.join(root, PROJECT_CONFIG_FILE);
+  const configPath = resolveProjectConfigPath(root);
   if (!fs8.existsSync(configPath)) {
     writeProjectConfig(root);
     return "scaffolded";
@@ -2907,7 +2900,8 @@ function writeFlatProjectTsConfig(framework, cwd = process.cwd()) {
   }
   const include = Array.isArray(existing.include) ? [...existing.include.map(String)] : [];
   if (!include.includes("src")) include.push("src");
-  const rootConfigFiles = ["iui.config.ts", "component.config.ts"];
+  const themeConfigFile = fs8.existsSync(path10.join(cwd, "iui.config.ts")) && !fs8.existsSync(path10.join(cwd, PROJECT_CONFIG_FILE)) ? "iui.config.ts" : PROJECT_CONFIG_FILE;
+  const rootConfigFiles = [themeConfigFile, "component.config.ts"];
   for (const rootFile of rootConfigFiles) {
     if (!include.includes(rootFile)) include.push(rootFile);
   }
@@ -3371,13 +3365,13 @@ function ensureInventiveUiViteConfig(cwd = process.cwd()) {
 }
 
 // src/services/auth.ts
-async function api(path28, opts) {
-  const res = await fetch(`${API_BASE_URL}${path28}`, {
+async function api(path27, opts) {
+  const res = await fetch(`${API_BASE_URL}${path27}`, {
     ...opts,
     signal: opts?.signal ?? AbortSignal.timeout(API_REQUEST_TIMEOUT_MS),
     headers: { "Content-Type": "application/json", ...opts?.headers }
   });
-  throwIfRateLimited(res, `calling ${path28}`);
+  throwIfRateLimited(res, `calling ${path27}`);
   if (!res.ok) {
     const body = await res.text().catch(() => "");
     throw new CLIError(`API error ${res.status}: ${body || res.statusText}`);
@@ -3629,10 +3623,12 @@ async function promptAssetSelection(installedPackages = []) {
   const choices = [];
   for (const cat of categories) {
     const inCategory = catalogue.filter((p) => p.category === cat);
+    if (choices.length > 0) {
+      choices.push(new inquirer.Separator(" "));
+    }
     choices.push(
       new inquirer.Separator(
-        `
-  ${brand.bold(ASSET_CATEGORY_LABELS[cat])} ${dim(`(${inCategory.length})`)}`
+        `  ${brand.bold(ASSET_CATEGORY_LABELS[cat])} ${dim(`(${inCategory.length})`)}`
       )
     );
     for (const pkg of inCategory) {
@@ -3644,6 +3640,8 @@ async function promptAssetSelection(installedPackages = []) {
     }
   }
   console.log();
+  const terminalRows = process.stdout.rows ?? 0;
+  const pageSize = terminalRows > 0 ? Math.max(10, Math.min(choices.length, terminalRows - 4)) : choices.length;
   const { selected } = await inquirer.prompt([
     {
       type: "checkbox",
@@ -3651,7 +3649,7 @@ async function promptAssetSelection(installedPackages = []) {
       message: chalk2.dim("Toggle packages to install"),
       prefix: PROMPT_PREFIX,
       choices,
-      pageSize: 20,
+      pageSize,
       loop: false
     }
   ]);
@@ -3733,7 +3731,7 @@ async function promptChooseEmojiFamily(fallbackCurrent) {
   assertInteractivePrompt("emoji family choice");
   inputBox(
     "Emoji Family",
-    "Choose the default CDN style for emoji slots. Skin tone defaults to medium-light."
+    "Choose the default CDN style for emoji slots. Skin tone defaults to medium-light (`mediumLight`)."
   );
   const { chosen } = await inquirer.prompt([
     {
@@ -3825,7 +3823,7 @@ async function promptText(title, hint2, placeholder, validate) {
 }
 
 // src/commands/init.ts
-import path23 from "path";
+import path22 from "path";
 import ora3 from "ora";
 
 // src/services/license.ts
@@ -4792,8 +4790,8 @@ function getMajorFromVersion(version) {
 import ora2 from "ora";
 
 // src/services/slot-registry.ts
-import fs18 from "fs-extra";
-import path22 from "path";
+import fs17 from "fs-extra";
+import path21 from "path";
 
 // src/services/registry-lock.ts
 import fs11 from "fs";
@@ -4880,8 +4878,8 @@ async function withRegistryLock(cwd, operation) {
 }
 
 // src/services/slots.ts
-import fs15 from "fs-extra";
-import path19 from "path";
+import fs14 from "fs-extra";
+import path18 from "path";
 
 // src/utils/public-slot-contract.ts
 import path15 from "path";
@@ -5011,11 +5009,6 @@ function safeWriteFile(filePath, content) {
   atomicWriteFile(filePath, content);
 }
 
-// src/services/asset-bound.ts
-import fs14 from "fs-extra";
-import path18 from "path";
-import { pathToFileURL } from "url";
-
 // src/services/generated-paths.ts
 import path17 from "path";
 function iuiProjectRoot2(cwd) {
@@ -5027,367 +5020,26 @@ function generatedIuiDir(cwd) {
 function generatedSlotsDir(cwd) {
   return path17.join(generatedIuiDir(cwd), "slots");
 }
-function generatedAssetsDir(cwd) {
-  return path17.join(generatedIuiDir(cwd), "assets");
-}
-
-// src/services/asset-bound.ts
-var LIBRARY_TO_PKG = {
-  lucide: "icons-lucide",
-  phosphor: "icons-phosphor",
-  material: "icons-material",
-  "material-icons": "icons-material",
-  materialSymbols: "material-symbols",
-  "material-symbols": "material-symbols"
-};
-var PKG_LOOKUP_PREFIX = {
-  "icons-lucide": "icons/",
-  "icons-phosphor": "icons/",
-  "icons-material": "icons/",
-  "material-symbols": "icons/",
-  logos: "logos/",
-  "color-logos": "logos/",
-  flags: "flags/",
-  "file-types": "types/",
-  loaders: "loaders/",
-  illustrations: ""
-};
-var BOUND_SPECS = [
-  {
-    slotType: "icon",
-    fileName: "icons.bound.ts",
-    exportName: "BOUND_ICONS",
-    packages: /* @__PURE__ */ new Set([
-      "material-symbols",
-      "icons-lucide",
-      "icons-phosphor",
-      "icons-material"
-    ]),
-    filterByDefaultIconLibrary: true
-  },
-  {
-    slotType: "logo",
-    fileName: "logos.bound.ts",
-    exportName: "BOUND_LOGOS",
-    packages: /* @__PURE__ */ new Set(["logos"])
-  },
-  {
-    slotType: "color-logo",
-    fileName: "color-logos.bound.ts",
-    exportName: "BOUND_COLOR_LOGOS",
-    packages: /* @__PURE__ */ new Set(["color-logos"])
-  },
-  {
-    slotType: "flag",
-    fileName: "flags.bound.ts",
-    exportName: "BOUND_FLAGS",
-    packages: /* @__PURE__ */ new Set(["flags"])
-  },
-  {
-    slotType: "file-type",
-    fileName: "file-types.bound.ts",
-    exportName: "BOUND_FILE_TYPES",
-    packages: /* @__PURE__ */ new Set(["file-types"])
-  },
-  {
-    slotType: "loader",
-    fileName: "loaders.bound.ts",
-    exportName: "BOUND_LOADERS",
-    packages: /* @__PURE__ */ new Set(["loaders"])
-  },
-  {
-    slotType: "illustration",
-    fileName: "illustrations.bound.ts",
-    exportName: "BOUND_ILLUSTRATIONS",
-    packages: /* @__PURE__ */ new Set(["illustrations"])
-  }
-];
-function isAssetPackageInstalled(cwd, pkgId) {
-  return resolvePackageDir(`@inventive-ui/${pkgId}`, cwd) !== null;
-}
-var DEFAULT_SCAN = {
-  scanDirs: ["src", ".storybook", "stories", ".iui"],
-  include: [
-    "**/*.stories.*",
-    "**/*.mdx",
-    "**/src/**/*.tsx",
-    "**/src/**/*.ts",
-    "**/src/**/*.jsx",
-    "**/src/**/*.js",
-    "**/.storybook/**/*.tsx",
-    "**/.storybook/**/*.ts",
-    "**/.storybook/**/*.jsx",
-    "**/.storybook/**/*.js"
-  ],
-  exclude: ["**/*.test.*", "**/*.spec.*"]
-};
-function resolveFrameworkModule(cwd, relativePath) {
-  const searchRoots = /* @__PURE__ */ new Set();
-  for (const candidate of [
-    resolveDependencyInstallRoot(cwd),
-    path18.resolve(cwd),
-    iuiProjectRoot2(cwd)
-  ]) {
-    searchRoots.add(path18.resolve(candidate));
-  }
-  for (const start of searchRoots) {
-    const frameworkDir = resolvePackageDir("@inventive-ui/framework", start);
-    if (!frameworkDir) continue;
-    const installed = path18.join(frameworkDir, relativePath);
-    if (fs14.existsSync(installed)) return installed;
-  }
-  const root = iuiProjectRoot2(cwd);
-  for (const candidate of [
-    path18.join(root, "..", "Framework", relativePath),
-    path18.join(root, "..", "..", "Framework", relativePath)
-  ]) {
-    if (fs14.existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-async function loadScanUtils(cwd) {
-  const scanPath = resolveFrameworkModule(
-    cwd,
-    "integrations/vite/scan-used-slot-assets.mjs"
-  );
-  const resolvePath = resolveFrameworkModule(
-    cwd,
-    "integrations/shared/resolve-scanned-icon-name.mjs"
-  );
-  if (!scanPath || !resolvePath) {
-    const installRoot = resolveDependencyInstallRoot(cwd);
-    const frameworkDir = resolvePackageDir("@inventive-ui/framework", installRoot);
-    const hint2 = frameworkDir && !scanPath ? "Update @inventive-ui/framework to the latest version (iui update) \u2014 scan utilities require a current Framework release." : "Install @inventive-ui/framework and run iui doctor again.";
-    throw new CLIError("Could not load Framework scan utilities.", hint2);
-  }
-  const scanMod = await import(pathToFileURL(scanPath).href);
-  const resolveMod = await import(pathToFileURL(resolvePath).href);
-  return { ...scanMod, ...resolveMod };
-}
-function lookupKeyToGlyphKey(pkg, lookupKey) {
-  let subpath = lookupKey.replace(/^\.\//, "").replace(/\.js$/, "");
-  if (pkg === "illustrations") {
-    return subpath;
-  }
-  const prefix = PKG_LOOKUP_PREFIX[pkg];
-  if (prefix && subpath.startsWith(prefix)) {
-    subpath = subpath.slice(prefix.length);
-  }
-  return subpath;
-}
-function glyphToIdentifier(name, used) {
-  let base = name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-  if (!base || !/^[A-Za-z_$]/.test(base)) {
-    base = `Glyph${base}`;
-  }
-  let id = base;
-  let suffix = 2;
-  while (used.has(id)) {
-    id = `${base}${suffix++}`;
-  }
-  used.add(id);
-  return id;
-}
-function resolveIconPkg(library) {
-  return LIBRARY_TO_PKG[library] ?? library;
-}
-function buildBoundFileContent(exportName, entries) {
-  const lines = [
-    "// Managed by iui. Do not edit manually.",
-    '// Static glyph bindings for scanned assets (`binding: "scanned"`).',
-    "",
-    'import type { ComponentType } from "react";'
-  ];
-  for (const entry of entries) {
-    lines.push(`import ${entry.identifier} from "${entry.moduleId}";`);
-  }
-  lines.push("");
-  lines.push(
-    `export const ${exportName}: Record<string, ComponentType<Record<string, unknown>>> = {`
-  );
-  for (const entry of entries) {
-    lines.push(`  ${JSON.stringify(entry.key)}: ${entry.identifier},`);
-  }
-  lines.push("};");
-  lines.push("");
-  return lines.join("\n");
-}
-function cleanupAssetBoundFiles(cwd) {
-  const assetsDir = generatedAssetsDir(cwd);
-  if (!fs14.existsSync(assetsDir)) return;
-  for (const file of fs14.readdirSync(assetsDir)) {
-    if (file.endsWith(".bound.ts") || file === "register-bound.ts") {
-      fs14.removeSync(path18.join(assetsDir, file));
-    }
-  }
-  const remaining = fs14.readdirSync(assetsDir);
-  if (remaining.length === 0) {
-    fs14.removeSync(assetsDir);
-  }
-}
-function hasAssetBoundRegistration(cwd) {
-  return fs14.existsSync(path18.join(generatedAssetsDir(cwd), "register-bound.ts"));
-}
-async function writeAssetBoundFiles(cwd = process.cwd()) {
-  const root = iuiProjectRoot2(cwd);
-  const scanUtils = await loadScanUtils(cwd);
-  const activeSpecs = BOUND_SPECS.filter(
-    (spec) => scanUtils.isScannedAssetBindingEnabled(root, spec.slotType)
-  );
-  if (activeSpecs.length === 0) {
-    cleanupAssetBoundFiles(root);
-    return;
-  }
-  const registry = scanUtils.scanUsedSlotAssets(root, DEFAULT_SCAN);
-  const defaultIconLibrary = scanUtils.readDefaultIconLibraryFromConfig(root);
-  const defaultIconPkg = resolveIconPkg(defaultIconLibrary);
-  const assetsDir = generatedAssetsDir(root);
-  fs14.ensureDirSync(assetsDir);
-  const generatedFiles = /* @__PURE__ */ new Set();
-  const registrationSpecs = [];
-  for (const spec of activeSpecs) {
-    const entries = [];
-    const usedIdentifiers = /* @__PURE__ */ new Set();
-    for (const [pkg, keys] of registry.entries()) {
-      if (!spec.packages.has(pkg)) continue;
-      if ("filterByDefaultIconLibrary" in spec && spec.filterByDefaultIconLibrary && pkg !== defaultIconPkg) {
-        continue;
-      }
-      if (!isAssetPackageInstalled(cwd, pkg)) continue;
-      for (const lookupKey of keys) {
-        const key = lookupKeyToGlyphKey(pkg, lookupKey);
-        const moduleId = scanUtils.lookupKeyToModuleId(pkg, lookupKey);
-        const identifier = glyphToIdentifier(key, usedIdentifiers);
-        if (entries.some((entry) => entry.key === key)) continue;
-        entries.push({ key, moduleId, identifier });
-      }
-    }
-    entries.sort((a, b) => a.key.localeCompare(b.key));
-    if (entries.length === 0) {
-      continue;
-    }
-    const content = buildBoundFileContent(spec.exportName, entries);
-    const outPath = resolveWithinRoot(
-      root,
-      ".iui",
-      "generated",
-      "assets",
-      spec.fileName
-    );
-    safeWriteFile(outPath, content);
-    generatedFiles.add(spec.fileName);
-    registrationSpecs.push({
-      slotType: spec.slotType,
-      exportName: spec.exportName,
-      fileName: spec.fileName
-    });
-  }
-  const existing = fs14.existsSync(assetsDir) ? fs14.readdirSync(assetsDir).filter((f) => f.endsWith(".bound.ts")) : [];
-  for (const file of existing) {
-    if (!generatedFiles.has(file)) {
-      fs14.removeSync(path18.join(assetsDir, file));
-    }
-  }
-  if (registrationSpecs.length === 0) {
-    cleanupAssetBoundFiles(root);
-    return;
-  }
-  const registerLines = [
-    "// Managed by iui. Do not edit manually.",
-    "",
-    'import { registerBoundAssetComponents } from "@inventive-ui/framework/slots";'
-  ];
-  for (const spec of registrationSpecs) {
-    registerLines.push(
-      `import { ${spec.exportName} } from "./${spec.fileName.replace(/\.ts$/, "")}";`
-    );
-  }
-  registerLines.push("");
-  for (const spec of registrationSpecs) {
-    registerLines.push(
-      `registerBoundAssetComponents(${JSON.stringify(spec.slotType)}, ${spec.exportName});`
-    );
-  }
-  registerLines.push("");
-  safeWriteFile(
-    resolveWithinRoot(root, ".iui", "generated", "assets", "register-bound.ts"),
-    registerLines.join("\n")
-  );
-}
-function assetModuleCandidates(pkgRoot, moduleId) {
-  const pkgName = moduleId.split("/").slice(0, 2).join("/");
-  const subpath = moduleId.slice(pkgName.length + 1);
-  const pkgId = pkgName.replace("@inventive-ui/", "");
-  if (!subpath || subpath.includes("..")) return [];
-  if (pkgId === "loaders") {
-    return [path18.join(pkgRoot, "dist", "loaders", `${subpath}.js`)];
-  }
-  if (pkgId === "illustrations") {
-    const [family, scene] = subpath.split("/");
-    if (family && scene) {
-      return [path18.join(pkgRoot, "dist", family, `${scene}.js`)];
-    }
-    return [path18.join(pkgRoot, "dist", `${subpath}.js`)];
-  }
-  const prefix = PKG_LOOKUP_PREFIX[pkgId];
-  if (prefix) {
-    const dir = prefix.replace(/\/$/, "");
-    return [
-      path18.join(pkgRoot, "dist", dir, `${subpath}.js`),
-      path18.join(pkgRoot, "dist", `${subpath}.js`),
-      path18.join(pkgRoot, "dist", subpath, "index.js")
-    ];
-  }
-  return [
-    path18.join(pkgRoot, "dist", `${subpath}.js`),
-    path18.join(pkgRoot, "dist", subpath, "index.js")
-  ];
-}
-function validateGeneratedAssetBoundImports(cwd = process.cwd()) {
-  const assetsDir = generatedAssetsDir(cwd);
-  if (!fs14.existsSync(assetsDir)) return [];
-  const issues = [];
-  const boundFiles = fs14.readdirSync(assetsDir).filter((file) => file.endsWith(".bound.ts"));
-  for (const file of boundFiles) {
-    const content = fs14.readFileSync(path18.join(assetsDir, file), "utf8");
-    const importRe = /from\s+["'](@inventive-ui\/[^"']+)["']/g;
-    let match;
-    while ((match = importRe.exec(content)) !== null) {
-      const moduleId = match[1];
-      const pkgName = moduleId.split("/").slice(0, 2).join("/");
-      const pkgRoot = resolvePackageDir(pkgName, cwd);
-      if (!pkgRoot) {
-        issues.push(`${file}: missing asset package ${pkgName}`);
-        continue;
-      }
-      const candidates = assetModuleCandidates(pkgRoot, moduleId);
-      if (!candidates.some((candidate) => fs14.existsSync(candidate))) {
-        issues.push(`${file}: missing asset module ${moduleId}`);
-      }
-    }
-  }
-  return issues;
-}
 
 // src/services/slots.ts
 var SLOT_GROUP_CORE_FILE = "slot-core.generated.tsx";
 var SLOT_GROUP_OPTIONAL_FILE = "slot-optional.generated.tsx";
 function bridgeSlotFilePath(cwd) {
-  return path19.join(cwd, "src", "iui", "slot.tsx");
+  return path18.join(cwd, "src", "iui", "slot.tsx");
 }
 function cleanupLegacySourceSlotFiles(cwd) {
-  const legacySlotsDir = path19.join(cwd, "src", "iui", "slots");
-  if (!fs15.existsSync(legacySlotsDir)) return;
+  const legacySlotsDir = path18.join(cwd, "src", "iui", "slots");
+  if (!fs14.existsSync(legacySlotsDir)) return;
   try {
-    const files = fs15.readdirSync(legacySlotsDir);
+    const files = fs14.readdirSync(legacySlotsDir);
     for (const file of files) {
       if (file.endsWith(".slot.tsx")) {
-        fs15.removeSync(path19.join(legacySlotsDir, file));
+        fs14.removeSync(path18.join(legacySlotsDir, file));
       }
     }
-    const remaining = fs15.readdirSync(legacySlotsDir);
+    const remaining = fs14.readdirSync(legacySlotsDir);
     if (remaining.length === 0) {
-      fs15.removeSync(legacySlotsDir);
+      fs14.removeSync(legacySlotsDir);
     }
   } catch {
   }
@@ -5451,18 +5103,18 @@ function writeComponentSlotFiles(cwd = process.cwd()) {
   const generationIssues = [];
   cleanupLegacySourceSlotFiles(cwd);
   if (Object.keys(components).length === 0) {
-    if (fs15.existsSync(slotsDir)) {
-      const existingSlots2 = fs15.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx"));
+    if (fs14.existsSync(slotsDir)) {
+      const existingSlots2 = fs14.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx"));
       for (const file of existingSlots2) {
         try {
-          fs15.removeSync(path19.join(slotsDir, file));
+          fs14.removeSync(path18.join(slotsDir, file));
         } catch {
         }
       }
     }
     return;
   }
-  fs15.ensureDirSync(slotsDir);
+  fs14.ensureDirSync(slotsDir);
   if (!pkgManifest) return;
   const itemsLookup = registryItemsMap(pkgManifest);
   const installedItems = Object.entries(components).map(([slug]) => itemsLookup[slug]).filter((item) => Boolean(item));
@@ -5503,7 +5155,7 @@ function writeComponentSlotFiles(cwd = process.cwd()) {
   for (const group of renderedGroups) {
     const outPath = resolveWithinRoot(root, ".iui", "generated", "slots", group.fileName);
     if (group.emitters.length === 0) {
-      if (fs15.existsSync(outPath)) fs15.removeSync(outPath);
+      if (fs14.existsSync(outPath)) fs14.removeSync(outPath);
       continue;
     }
     safeWriteFile(
@@ -5513,19 +5165,19 @@ function writeComponentSlotFiles(cwd = process.cwd()) {
       })
     );
   }
-  const existingSlots = fs15.existsSync(slotsDir) ? fs15.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx") || f.endsWith(".generated.tsx")) : [];
+  const existingSlots = fs14.existsSync(slotsDir) ? fs14.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx") || f.endsWith(".generated.tsx")) : [];
   for (const file of existingSlots) {
     if (file === SLOT_GROUP_CORE_FILE || file === SLOT_GROUP_OPTIONAL_FILE) continue;
     if (file.endsWith(".slot.tsx")) {
       try {
-        fs15.removeSync(path19.join(slotsDir, file));
+        fs14.removeSync(path18.join(slotsDir, file));
       } catch {
       }
       continue;
     }
     if (file.endsWith(".generated.tsx")) {
       try {
-        fs15.removeSync(path19.join(slotsDir, file));
+        fs14.removeSync(path18.join(slotsDir, file));
       } catch {
       }
     }
@@ -5629,24 +5281,18 @@ function writeSlotHelperFile(cwd = process.cwd()) {
   }
   const typesArray = Array.from(slotTypes).sort();
   const slotImports = [];
-  const coreSlotsPath = path19.join(generatedSlotsDir(cwd), SLOT_GROUP_CORE_FILE);
-  const optionalSlotsPath = path19.join(generatedSlotsDir(cwd), SLOT_GROUP_OPTIONAL_FILE);
-  if (fs15.existsSync(coreSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_CORE_FILE.replace(/\.tsx$/, "")}";`);
-  if (fs15.existsSync(optionalSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_OPTIONAL_FILE.replace(/\.tsx$/, "")}";`);
+  const coreSlotsPath = path18.join(generatedSlotsDir(cwd), SLOT_GROUP_CORE_FILE);
+  const optionalSlotsPath = path18.join(generatedSlotsDir(cwd), SLOT_GROUP_OPTIONAL_FILE);
+  if (fs14.existsSync(coreSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_CORE_FILE.replace(/\.tsx$/, "")}";`);
+  if (fs14.existsSync(optionalSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_OPTIONAL_FILE.replace(/\.tsx$/, "")}";`);
   const componentSlotImports = slotImports.join("\n");
-  const includeAssetBindings = hasAssetBoundRegistration(cwd);
   const outDir = generatedIuiDir(cwd);
-  fs15.ensureDirSync(outDir);
-  const outPath = path19.join(outDir, "slot.generated.tsx");
+  fs14.ensureDirSync(outDir);
+  const outPath = path18.join(outDir, "slot.generated.tsx");
   const sections = [
     `// Managed by iui. Do not edit manually.`,
     `// Rebuilt automatically when the CLI validates the project.`
   ];
-  if (includeAssetBindings) {
-    sections.push("");
-    sections.push("// Scanned asset bindings (static glyph imports)");
-    sections.push(`import "./assets/register-bound";`);
-  }
   if (componentSlotImports) {
     sections.push("");
     sections.push("// Component slot registrations");
@@ -5672,11 +5318,11 @@ ${typesArray.map((t) => `  | "${t}"`).join("\n")};` : `export type IUISlotType =
 }
 function writeSlotBridge(packageDir, iuiRoot2) {
   const bridgePath = bridgeSlotFilePath(packageDir);
-  const generatedFile = path19.join(iuiRoot2, ".iui", "generated", "slot.generated.tsx");
-  const importBase = relativeImportPath(path19.dirname(bridgePath), generatedFile);
-  fs15.ensureDirSync(path19.dirname(bridgePath));
-  if (fs15.existsSync(bridgePath)) {
-    const existing = fs15.readFileSync(bridgePath, "utf-8");
+  const generatedFile = path18.join(iuiRoot2, ".iui", "generated", "slot.generated.tsx");
+  const importBase = relativeImportPath(path18.dirname(bridgePath), generatedFile);
+  fs14.ensureDirSync(path18.dirname(bridgePath));
+  if (fs14.existsSync(bridgePath)) {
+    const existing = fs14.readFileSync(bridgePath, "utf-8");
     if (existing.length > 0 && !/@iui-managed/.test(existing)) {
       return;
     }
@@ -5693,18 +5339,18 @@ export type { IUISlotType } from "${importBase}";
 }
 
 // src/services/workspace-bootstrap.ts
-import path21 from "path";
-import fs17 from "fs-extra";
+import path20 from "path";
+import fs16 from "fs-extra";
 
 // src/services/bootstrap.ts
-import fs16 from "fs-extra";
-import path20 from "path";
+import fs15 from "fs-extra";
+import path19 from "path";
 var BOOTSTRAP_GENERATED_FILE = "bootstrap.generated.tsx";
 function bridgeBootstrapFilePath(cwd) {
-  return path20.join(cwd, "src", "iui", "bootstrap.ts");
+  return path19.join(cwd, "src", "iui", "bootstrap.ts");
 }
 function bootstrapGeneratedPath(cwd = process.cwd()) {
-  return path20.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
+  return path19.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
 }
 function resolveProjectConfigPaths(cwd) {
   const meta = readProjectMeta(cwd);
@@ -5719,8 +5365,8 @@ function resolveProjectConfigPaths(cwd) {
   };
 }
 function configImportFromGenerated(cwd, configRel) {
-  const generatedDir = path20.dirname(bootstrapGeneratedPath(cwd));
-  const abs = path20.resolve(cwd, configRel.replace(/^\.\//, ""));
+  const generatedDir = path19.dirname(bootstrapGeneratedPath(cwd));
+  const abs = path19.resolve(cwd, configRel.replace(/^\.\//, ""));
   return relativeImportPath(generatedDir, abs);
 }
 function expectedBootstrapImportPaths(cwd) {
@@ -5733,13 +5379,13 @@ function expectedBootstrapImportPaths(cwd) {
 }
 function writeBootstrapGenerated(cwd = process.cwd()) {
   const outPath = bootstrapGeneratedPath(cwd);
-  fs16.ensureDirSync(path20.dirname(outPath));
+  fs15.ensureDirSync(path19.dirname(outPath));
   const imports = expectedBootstrapImportPaths(cwd);
   const content = `// @iui-managed
 
 // Generated by iui CLI \u2014 do not edit manually.
 
-// Connects iui.config.ts + assets.config.json + component.config.ts for standard bootstrap.
+// Connects theme.config.ts + assets.config.json + component.config.ts for standard bootstrap.
 
 
 
@@ -5759,7 +5405,7 @@ import {
 
 } from "@inventive-ui/framework";
 
-import { initConfig as initSlotsConfig } from "@inventive-ui/framework/slots";
+import { initConfig as initAssetsConfig } from "@inventive-ui/framework/assets";
 
 import type { IUIAssetsConfig } from "@inventive-ui/framework/config";
 
@@ -5795,7 +5441,7 @@ registerBootstrapState({
 
 initFramework(frameworkConfig);
 
-initSlotsConfig(frameworkConfig);
+initAssetsConfig(frameworkConfig);
 
 
 
@@ -5807,10 +5453,10 @@ export { projectComponentConfig as componentConfig };
 function writeBootstrapBridge(packageDir, iuiRoot2) {
   const bridgePath = bridgeBootstrapFilePath(packageDir);
   const generatedFile = bootstrapGeneratedPath(iuiRoot2);
-  const importBase = relativeImportPath(path20.dirname(bridgePath), generatedFile);
-  fs16.ensureDirSync(path20.dirname(bridgePath));
-  if (fs16.existsSync(bridgePath)) {
-    const existing = fs16.readFileSync(bridgePath, "utf-8");
+  const importBase = relativeImportPath(path19.dirname(bridgePath), generatedFile);
+  fs15.ensureDirSync(path19.dirname(bridgePath));
+  if (fs15.existsSync(bridgePath)) {
+    const existing = fs15.readFileSync(bridgePath, "utf-8");
     if (existing.length > 0 && !/@iui-managed/.test(existing)) {
       return;
     }
@@ -5835,13 +5481,13 @@ function writeProjectBootstrapArtifacts(packageDir, iuiRoot2) {
 
 // src/services/workspace-bootstrap.ts
 function workspaceManifestPath(iuiRoot2) {
-  return path21.join(iuiRoot2, IUI_DIR, "workspace.json");
+  return path20.join(iuiRoot2, IUI_DIR, "workspace.json");
 }
 function readWorkspaceManifest(iuiRoot2) {
   const p = workspaceManifestPath(iuiRoot2);
-  if (!fs17.existsSync(p)) return null;
+  if (!fs16.existsSync(p)) return null;
   try {
-    const raw = fs17.readJsonSync(p);
+    const raw = fs16.readJsonSync(p);
     if (!Array.isArray(raw.packages)) return null;
     return {
       iuiRoot: raw.iuiRoot ?? iuiRoot2,
@@ -5853,40 +5499,40 @@ function readWorkspaceManifest(iuiRoot2) {
   }
 }
 function writeWorkspaceManifest(iuiRoot2, packageDirs) {
-  const unique = [...new Set(packageDirs.map((dir) => path21.resolve(dir)))];
+  const unique = [...new Set(packageDirs.map((dir) => path20.resolve(dir)))];
   atomicWriteJson(workspaceManifestPath(iuiRoot2), {
-    packages: unique.map((dir) => path21.relative(iuiRoot2, dir) || "."),
+    packages: unique.map((dir) => path20.relative(iuiRoot2, dir) || "."),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
 function resolveRegisteredPackageDirs(iuiRoot2) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
+  const resolvedRoot = path20.resolve(iuiRoot2);
   const manifest = readWorkspaceManifest(resolvedRoot);
   if (!manifest) return [resolvedRoot];
   const dirs = manifest.packages.map(
-    (rel) => path21.resolve(resolvedRoot, rel === "." ? "" : rel)
+    (rel) => path20.resolve(resolvedRoot, rel === "." ? "" : rel)
   );
-  if (!dirs.some((dir) => path21.resolve(dir) === resolvedRoot)) {
+  if (!dirs.some((dir) => path20.resolve(dir) === resolvedRoot)) {
     dirs.unshift(resolvedRoot);
   }
   return dirs;
 }
 function registerWorkspacePackage(iuiRoot2, packageDir) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
-  const resolvedPackage = path21.resolve(packageDir);
+  const resolvedRoot = path20.resolve(iuiRoot2);
+  const resolvedPackage = path20.resolve(packageDir);
   const existing = resolveRegisteredPackageDirs(resolvedRoot);
-  if (!existing.some((dir) => path21.resolve(dir) === resolvedPackage)) {
+  if (!existing.some((dir) => path20.resolve(dir) === resolvedPackage)) {
     existing.push(resolvedPackage);
   }
   writeWorkspaceManifest(resolvedRoot, existing);
 }
 function registerAllWorkspacePackages(iuiRoot2) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
+  const resolvedRoot = path20.resolve(iuiRoot2);
   const workspaceRoot = findWorkspaceRoot(resolvedRoot);
   const targets = /* @__PURE__ */ new Set([resolvedRoot]);
   if (workspaceRoot) {
     for (const pkgDir of listWorkspacePackageDirs(workspaceRoot)) {
-      targets.add(path21.resolve(pkgDir));
+      targets.add(path20.resolve(pkgDir));
     }
   }
   const dirs = [...targets];
@@ -5897,7 +5543,7 @@ function bootstrapRegisteredPackages(iuiRoot2) {
   const resolvedRoot = resolveIuiProjectRoot(iuiRoot2);
   const bootstrapped = [];
   for (const packageDir of resolveRegisteredPackageDirs(resolvedRoot)) {
-    if (!fs17.existsSync(path21.join(packageDir, "package.json"))) continue;
+    if (!fs16.existsSync(path20.join(packageDir, "package.json"))) continue;
     ensureProjectNpmrc(packageDir);
     writeSlotBridge(packageDir, resolvedRoot);
     writeProjectBootstrapArtifacts(packageDir, resolvedRoot);
@@ -5906,9 +5552,9 @@ function bootstrapRegisteredPackages(iuiRoot2) {
   return bootstrapped;
 }
 async function bootstrapWorkspacePackage(packageDir, iuiRoot2) {
-  const resolvedPackage = path21.resolve(packageDir);
+  const resolvedPackage = path20.resolve(packageDir);
   const resolvedIuiRoot = resolveIuiProjectRoot(iuiRoot2);
-  if (!fs17.existsSync(path21.join(resolvedPackage, "package.json"))) {
+  if (!fs16.existsSync(path20.join(resolvedPackage, "package.json"))) {
     throw new CLIError(
       `No package.json found in ${resolvedPackage}.`,
       "Run iui init from a workspace app directory that contains package.json."
@@ -5944,17 +5590,17 @@ function checksumFor(components, slots) {
   return sha256(JSON.stringify({ components, slots }));
 }
 function backupCorruptFile(filePath) {
-  if (!fs18.existsSync(filePath)) return;
+  if (!fs17.existsSync(filePath)) return;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   try {
-    fs18.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
+    fs17.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
   } catch {
   }
 }
 function readJsonObject(filePath, fallback, issues, label) {
-  if (!fs18.existsSync(filePath)) return fallback;
+  if (!fs17.existsSync(filePath)) return fallback;
   try {
-    const value = fs18.readJsonSync(filePath);
+    const value = fs17.readJsonSync(filePath);
     if (value && typeof value === "object" && !Array.isArray(value)) {
       return value;
     }
@@ -5966,9 +5612,9 @@ function readJsonObject(filePath, fallback, issues, label) {
 }
 function readState(cwd, issues) {
   const filePath = statePath(cwd);
-  if (!fs18.existsSync(filePath)) return null;
+  if (!fs17.existsSync(filePath)) return null;
   try {
-    const raw = fs18.readJsonSync(filePath);
+    const raw = fs17.readJsonSync(filePath);
     if (raw.schemaVersion !== STATE_SCHEMA_VERSION) {
       issues.push("registration state schema was upgraded");
       return null;
@@ -6072,7 +5718,7 @@ async function ensureSlotRegistry(options = {}) {
   }
   const iuiRoot2 = resolveIuiProjectRoot(cwd);
   return withRegistryLock(iuiRoot2, async () => {
-    const iuiPath = path22.join(iuiRoot2, IUI_DIR);
+    const iuiPath = path21.join(iuiRoot2, IUI_DIR);
     const issues = [];
     cleanupTempFiles(iuiPath);
     const registry = ensureInstalledManifest(
@@ -6126,9 +5772,7 @@ async function ensureSlotRegistry(options = {}) {
       if (driftDetected) {
         issues.push("slot manifests drifted");
       }
-      const generationIssues = validateGeneratedSlotImports(iuiRoot2);
-      const assetBoundIssues = validateGeneratedAssetBoundImports(iuiRoot2);
-      const integrityIssues = [...generationIssues, ...assetBoundIssues];
+      const integrityIssues = validateGeneratedSlotImports(iuiRoot2);
       if (shouldSkipWritesFastPath({
         mode,
         previousState,
@@ -6182,7 +5826,6 @@ async function ensureSlotRegistry(options = {}) {
         writeComponentSlotFiles(iuiRoot2);
         writeAssetsConfig(iuiRoot2);
         ensureProjectConfig(iuiRoot2);
-        await writeAssetBoundFiles(iuiRoot2);
         writeSlotHelperFile(iuiRoot2);
         if (projectHasViteTooling(cwd)) {
           ensureInventiveUiViteConfig(cwd);
@@ -6367,7 +6010,7 @@ async function initCommand(opts) {
   try {
     heading("Initialize Project");
     const existingIuiRoot = findIuiProjectRoot(invocationCwd);
-    if (existingIuiRoot && path23.resolve(existingIuiRoot) !== path23.resolve(invocationCwd)) {
+    if (existingIuiRoot && path22.resolve(existingIuiRoot) !== path22.resolve(invocationCwd)) {
       await bootstrapWorkspacePackage(invocationCwd, existingIuiRoot);
       return;
     }
@@ -6386,10 +6029,10 @@ async function initCommand(opts) {
       return;
     }
     const originalCwd = process.cwd();
-    if (path23.resolve(initRoot) !== path23.resolve(originalCwd)) {
+    if (path22.resolve(initRoot) !== path22.resolve(originalCwd)) {
       process.chdir(initRoot);
       hint(
-        `Monorepo --workspace: initializing at ${path23.relative(invocationCwd, initRoot) || initRoot}`
+        `Monorepo --workspace: initializing at ${path22.relative(invocationCwd, initRoot) || initRoot}`
       );
     } else if (!sharedWorkspace && findIuiProjectRoot(initRoot) === null) {
       hint("Initializing this package only \u2014 other monorepo apps are untouched.");
@@ -6450,7 +6093,7 @@ async function initCommand(opts) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         initScope: sharedWorkspace ? "workspace" : "package",
         configs: {
-          theme: "./iui.config.ts",
+          theme: "./theme.config.ts",
           assets: "./assets.config.json",
           components: "./component.config.ts"
         }
@@ -6514,12 +6157,12 @@ async function initCommand(opts) {
       ensureTsConfigForIui(framework.framework, initRoot);
       if (framework.framework === "vite") {
         ensureInventiveUiViteConfig(initRoot);
-        ok("Config files ready (iui.config.ts, tsconfig.json, tsconfig.node.json, vite.config.ts)");
+        ok("Config files ready (theme.config.ts, tsconfig.json, tsconfig.node.json, vite.config.ts)");
       } else {
         if (removeStaleIuiViteConfig(initRoot)) {
           hint("Removed vite.config.ts (React-only preset \u2014 no Vite tooling required).");
         }
-        ok("Config files ready (iui.config.ts, tsconfig.json)");
+        ok("Config files ready (theme.config.ts, tsconfig.json)");
       }
       step("Scaffolding component.config.ts\u2026");
       const fetchedRegistry = await fetchComponentRegistry(auth.token);
@@ -7272,17 +6915,17 @@ async function deployTokenRevokeCommand(tokenId) {
 }
 
 // src/commands/setup.ts
-import path26 from "path";
-import fs20 from "fs-extra";
+import path25 from "path";
+import fs19 from "fs-extra";
 import ora6 from "ora";
 
 // src/commands/doctor.ts
-import path25 from "path";
+import path24 from "path";
 
 // src/services/health.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import path24 from "path";
-import fs19 from "fs-extra";
+import path23 from "path";
+import fs18 from "fs-extra";
 function installDevTypeScript(cwd) {
   const pm = detectPackageManager(cwd);
   try {
@@ -7325,8 +6968,8 @@ function checkGeneratedSlotValidity(cwd = process.cwd()) {
   };
 }
 function checkComponentConfigValidity(cwd = process.cwd(), options = {}) {
-  const configPath = path24.join(cwd, COMPONENT_CONFIG_FILE);
-  if (!fs19.existsSync(configPath)) {
+  const configPath = path23.join(cwd, COMPONENT_CONFIG_FILE);
+  if (!fs18.existsSync(configPath)) {
     return {
       ok: false,
       summary: "component.config.ts not found",
@@ -7334,8 +6977,8 @@ function checkComponentConfigValidity(cwd = process.cwd(), options = {}) {
     };
   }
   const tsPkgDir = resolvePackageDir("typescript", cwd);
-  const tscPath = tsPkgDir ? path24.join(tsPkgDir, "bin", "tsc") : path24.join(cwd, "node_modules", "typescript", "bin", "tsc");
-  if (!fs19.existsSync(tscPath)) {
+  const tscPath = tsPkgDir ? path23.join(tsPkgDir, "bin", "tsc") : path23.join(cwd, "node_modules", "typescript", "bin", "tsc");
+  if (!fs18.existsSync(tscPath)) {
     if (!options.autoFix) {
       return {
         ok: false,
@@ -7403,33 +7046,36 @@ ${stderr}`.trim() };
 function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
   const warnings = [];
   const hints = [];
-  const configPath = path24.join(cwd, PROJECT_CONFIG_FILE);
-  if (fs19.existsSync(configPath)) {
-    const configContent = fs19.readFileSync(configPath, "utf-8");
+  const configPath = path23.join(
+    cwd,
+    fs18.existsSync(path23.join(cwd, PROJECT_CONFIG_FILE)) || !fs18.existsSync(path23.join(cwd, "iui.config.ts")) ? PROJECT_CONFIG_FILE : "iui.config.ts"
+  );
+  if (fs18.existsSync(configPath)) {
+    const configContent = fs18.readFileSync(configPath, "utf-8");
     if (/packageSafelist\s*:\s*false/.test(configContent)) {
       warnings.push(
-        "Deprecated iui.config build.packageSafelist \u2014 remove it; Framework always merges IUI package compile contracts"
+        "Deprecated theme.config build.packageSafelist \u2014 remove it; Framework always merges IUI package compile contracts"
       );
     }
     if (/includeShadeMatrix\s*:/.test(configContent)) {
       warnings.push(
-        "Deprecated compiler flags in iui.config build.* \u2014 remove them; compile policy is Framework-internal"
+        "Deprecated compiler flags in theme.config build.* \u2014 remove them; compile policy is Framework-internal"
       );
       hints.push("Use theme + optional scan.dirs only. See Framework docs/01-compile-first-guide.md");
     }
     if (/scanPackages\s*:/.test(configContent) || /scan\.packages\s*:/.test(configContent)) {
       warnings.push(
-        "Deprecated scanPackages in iui.config \u2014 IUI packages are discovered from package.json dependencies"
+        "Deprecated scanPackages in theme.config \u2014 IUI packages are discovered from package.json dependencies"
       );
     }
   }
   if (projectHasViteTooling(cwd)) {
     const viteCandidates = ["vite.config.ts", "vite.config.mjs", "vite.config.js"];
-    const vitePath = viteCandidates.map((name) => path24.join(cwd, name)).find((p) => fs19.existsSync(p));
+    const vitePath = viteCandidates.map((name) => path23.join(cwd, name)).find((p) => fs18.existsSync(p));
     if (!vitePath) {
       warnings.push("Vite tooling detected but no vite.config.* found");
     } else {
-      const viteContent = fs19.readFileSync(vitePath, "utf-8");
+      const viteContent = fs18.readFileSync(vitePath, "utf-8");
       if (!/inventiveUiVite\s*\(/.test(viteContent)) {
         warnings.push("vite.config is missing inventiveUiVite() \u2014 compile-first CSS will not generate");
         hints.push("Wire plugins: [...inventiveUiVite({ root: import.meta.dirname }), react()]");
@@ -7443,11 +7089,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
       "webpack.config.mjs",
       "webpack.config.ts"
     ];
-    const webpackPath = webpackCandidates.map((name) => path24.join(cwd, name)).find((p) => fs19.existsSync(p));
+    const webpackPath = webpackCandidates.map((name) => path23.join(cwd, name)).find((p) => fs18.existsSync(p));
     if (!webpackPath) {
       warnings.push("Webpack tooling detected but no webpack.config.* found");
     } else {
-      const webpackContent = fs19.readFileSync(webpackPath, "utf-8");
+      const webpackContent = fs18.readFileSync(webpackPath, "utf-8");
       if (!/inventiveUiWebpack\s*\(/.test(webpackContent)) {
         warnings.push("webpack.config is missing inventiveUiWebpack() \u2014 compile-first CSS will not generate");
         hints.push('Wire plugins: [...inventiveUiWebpack()] from "@inventive-ui/framework/webpack"');
@@ -7457,11 +7103,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
   }
   if (projectHasNextTooling(cwd)) {
     const nextCandidates = ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"];
-    const nextPath = nextCandidates.map((name) => path24.join(cwd, name)).find((p) => fs19.existsSync(p));
+    const nextPath = nextCandidates.map((name) => path23.join(cwd, name)).find((p) => fs18.existsSync(p));
     if (!nextPath) {
       warnings.push("Next.js detected but no next.config.* found");
     } else {
-      const nextContent = fs19.readFileSync(nextPath, "utf-8");
+      const nextContent = fs18.readFileSync(nextPath, "utf-8");
       if (!/withIUI\s*\(/.test(nextContent)) {
         warnings.push("next.config is missing withIUI() \u2014 compile-first CSS will not generate");
         hints.push('Wrap config: export default withIUI({ ... }) from "@inventive-ui/framework/next"');
@@ -7474,18 +7120,18 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
       "src/app/layout.jsx",
       "app/providers.tsx",
       "src/app/providers.tsx"
-    ].map((rel) => path24.join(cwd, rel));
-    const readableLayouts = layoutCandidates.filter((file) => fs19.existsSync(file));
+    ].map((rel) => path23.join(cwd, rel));
+    const readableLayouts = layoutCandidates.filter((file) => fs18.existsSync(file));
     const hasRegistry = readableLayouts.some((file) => {
       try {
-        return /\bIUIRegistry\b/.test(fs19.readFileSync(file, "utf-8"));
+        return /\bIUIRegistry\b/.test(fs18.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
     });
     const hasBootstrapImport = readableLayouts.some((file) => {
       try {
-        const content = fs19.readFileSync(file, "utf-8");
+        const content = fs18.readFileSync(file, "utf-8");
         return /next\/bootstrap/.test(content) || /["']iui-bootstrap["']/.test(content) || /iui\/bootstrap/.test(content);
       } catch {
         return false;
@@ -7493,7 +7139,7 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
     });
     const hasProvider = readableLayouts.some((file) => {
       try {
-        return /\bIUIProvider\b/.test(fs19.readFileSync(file, "utf-8"));
+        return /\bIUIProvider\b/.test(fs18.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
@@ -7524,14 +7170,14 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
     "src/app/providers.tsx",
     "app/layout.tsx",
     "src/app/layout.tsx"
-  ].map((rel) => path24.join(cwd, rel));
+  ].map((rel) => path23.join(cwd, rel));
   for (const file of entryCandidates) {
-    if (!fs19.existsSync(file)) continue;
+    if (!fs18.existsSync(file)) continue;
     try {
-      const content = fs19.readFileSync(file, "utf-8");
+      const content = fs18.readFileSync(file, "utf-8");
       if (/from\s+['"][^'"]*\.generated['"]/.test(content) || /import\s+['"][^'"]*\.generated['"]/.test(content)) {
         warnings.push(
-          `Do not import .generated style-map files into the browser (${path24.relative(cwd, file)})`
+          `Do not import .generated style-map files into the browser (${path23.relative(cwd, file)})`
         );
         hints.push(
           "Keep style maps on the scanner path (default src + .iui/generated, or override build.scanDirs) \u2014 see Framework compile-first docs"
@@ -7551,9 +7197,9 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
   hints.push(
     "Compile-first: avoid dynamic utility templates like `p-${n}` \u2014 use static strings, style maps, or safelist (ESLint: customPlugin/no-dynamic-utility-class)"
   );
-  const giPath = path24.join(cwd, ".gitignore");
-  if (fs19.existsSync(giPath)) {
-    const gi = fs19.readFileSync(giPath, "utf-8");
+  const giPath = path23.join(cwd, ".gitignore");
+  if (fs18.existsSync(giPath)) {
+    const gi = fs18.readFileSync(giPath, "utf-8");
     if (!gi.includes(".iui/cache/")) {
       warnings.push(".gitignore missing IUI cache directory (.iui/cache/)");
       hints.push("Run iui init or append .iui/cache/ from the IUI docs");
@@ -7564,11 +7210,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
 function checkMetadataPortability(cwd = process.cwd()) {
   const warnings = [];
   const hints = [];
-  const iuiPath = path24.join(cwd, IUI_DIR);
-  const projectPath = path24.join(iuiPath, "project.json");
-  if (fs19.existsSync(projectPath)) {
+  const iuiPath = path23.join(cwd, IUI_DIR);
+  const projectPath = path23.join(iuiPath, "project.json");
+  if (fs18.existsSync(projectPath)) {
     try {
-      const meta = fs19.readJsonSync(projectPath);
+      const meta = fs18.readJsonSync(projectPath);
       const repoUrl = meta.repoUrl ?? "";
       if (/^[A-Za-z]:[\\/]/.test(repoUrl) || repoUrl.startsWith("/") && !repoUrl.startsWith("//") || repoUrl.startsWith("file:")) {
         warnings.push("project.json repoUrl is a local filesystem path \u2014 use a git remote URL");
@@ -7577,15 +7223,15 @@ function checkMetadataPortability(cwd = process.cwd()) {
     } catch {
     }
   }
-  const workspacePath = path24.join(iuiPath, "workspace.json");
-  if (fs19.existsSync(workspacePath)) {
+  const workspacePath = path23.join(iuiPath, "workspace.json");
+  if (fs18.existsSync(workspacePath)) {
     try {
-      const ws = fs19.readJsonSync(workspacePath);
+      const ws = fs18.readJsonSync(workspacePath);
       if (ws.iuiRoot) {
         warnings.push("workspace.json contains deprecated iuiRoot \u2014 remove it (root is implicit)");
       }
       for (const pkg of ws.packages ?? []) {
-        if (/^[A-Za-z]:[\\/]/.test(pkg) || path24.isAbsolute(pkg)) {
+        if (/^[A-Za-z]:[\\/]/.test(pkg) || path23.isAbsolute(pkg)) {
           warnings.push(`workspace.json packages entry is absolute: ${pkg}`);
           hints.push("packages should be relative paths from the IUI root");
         }
@@ -7594,9 +7240,9 @@ function checkMetadataPortability(cwd = process.cwd()) {
     }
   }
   const scanCachePath = iuiCacheFile(cwd, "scan");
-  if (fs19.existsSync(scanCachePath)) {
+  if (fs18.existsSync(scanCachePath)) {
     try {
-      const cache = fs19.readJsonSync(scanCachePath);
+      const cache = fs18.readJsonSync(scanCachePath);
       const absoluteKeys = Object.keys(cache.files ?? {}).filter(
         (key) => /^[A-Za-z]:[\\/]/.test(key) || key.startsWith("/") && !key.startsWith("//")
       );
@@ -7613,38 +7259,70 @@ function checkMetadataPortability(cwd = process.cwd()) {
   }
   return { warnings, hints };
 }
-function checkAssetBoundBindings(cwd = process.cwd()) {
-  const assetsPath = path24.join(cwd, ASSETS_CONFIG_FILE);
-  if (!fs19.existsSync(assetsPath)) {
-    return { ok: true, summary: "Asset binding check skipped (no assets.config.json)" };
+var ICON_LIBRARY_PACKAGES = {
+  "material-symbols": "material-symbols",
+  materialSymbols: "material-symbols",
+  "material-icons": "icons-material",
+  lucide: "icons-lucide",
+  phosphor: "icons-phosphor"
+};
+function checkAssetPipeline(cwd = process.cwd()) {
+  const assetsPath = path23.join(cwd, ASSETS_CONFIG_FILE);
+  if (!fs18.existsSync(assetsPath)) {
+    return { ok: true, summary: "Asset check skipped (no assets.config.json)" };
   }
   let assets2;
   try {
-    assets2 = fs19.readJsonSync(assetsPath);
+    assets2 = fs18.readJsonSync(assetsPath);
   } catch {
     return { ok: false, summary: "assets.config.json is not valid JSON" };
   }
-  if (assets2.binding !== "scanned") {
-    return { ok: true, summary: "Asset slots use lazy binding (default)" };
+  const packagesDir = path23.join(cwd, "node_modules", "@inventive-ui");
+  const frameworkPkg = path23.join(packagesDir, "framework", "package.json");
+  if (fs18.existsSync(frameworkPkg)) {
+    const framework = fs18.readJsonSync(frameworkPkg);
+    if (!framework.exports?.["./assets"]) {
+      return {
+        ok: false,
+        summary: "Installed @inventive-ui/framework has no asset pipeline",
+        details: "Update it: iui update"
+      };
+    }
+  }
+  const library = assets2.icon?.library;
+  const pkg = library ? ICON_LIBRARY_PACKAGES[library] : void 0;
+  if (!pkg) return { ok: true, summary: "Asset config valid" };
+  const iconsDir = path23.join(packagesDir, pkg, "dist", "icons");
+  if (!fs18.existsSync(iconsDir)) {
+    return {
+      ok: false,
+      summary: `Icon library "${library}" is configured but @inventive-ui/${pkg} is not installed`,
+      details: `Install it: iui install assets @inventive-ui/${pkg}`
+    };
   }
-  const registerBound = path24.join(generatedAssetsDir(cwd), "register-bound.ts");
-  if (!fs19.existsSync(registerBound)) {
+  const glyphs = [
+    ...Object.entries(assets2.icon?.globalIcons ?? {}).map(([alias, glyph]) => [`@${alias}`, glyph]),
+    ["placeholder", assets2.icon?.placeholder?.name],
+    ["fallback", assets2.icon?.fallback]
+  ].filter((entry) => typeof entry[1] === "string" && entry[1].length > 0);
+  const missing = glyphs.filter(([, glyph]) => !fs18.existsSync(path23.join(iconsDir, `${glyph}.js`)));
+  if (missing.length > 0) {
     return {
       ok: false,
-      summary: 'binding is "scanned" but .iui/generated/assets/register-bound.ts is missing',
-      details: "Run any iui command to refresh the slot registry, or reinstall asset packages."
+      summary: `${missing.length} icon alias${missing.length === 1 ? "" : "es"} point at glyphs "${library}" does not have`,
+      details: missing.slice(0, 8).map(([name, glyph]) => `${name} \u2192 ${glyph}`).join(", ")
     };
   }
-  return { ok: true, summary: "Scanned asset bindings present" };
+  return { ok: true, summary: `Asset config valid (${glyphs.length} icon names checked in ${library})` };
 }
 function checkBootstrapSync(cwd = process.cwd(), options = {}) {
   const iuiRoot2 = resolveIuiProjectRoot(cwd);
   const generatedPath = bootstrapGeneratedPath(iuiRoot2);
-  const bridgePath = path24.join(cwd, "src", "iui", "bootstrap.ts");
-  if (!fs19.existsSync(generatedPath)) {
+  const bridgePath = path23.join(cwd, "src", "iui", "bootstrap.ts");
+  if (!fs18.existsSync(generatedPath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs19.existsSync(generatedPath)) {
+      if (fs18.existsSync(generatedPath)) {
         return { ok: true, summary: "Generated bootstrap artifacts repaired" };
       }
     }
@@ -7654,10 +7332,10 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
       details: "Expected .iui/generated/bootstrap.generated.tsx \u2014 run iui doctor --fix."
     };
   }
-  if (!fs19.existsSync(bridgePath)) {
+  if (!fs18.existsSync(bridgePath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs19.existsSync(bridgePath)) {
+      if (fs18.existsSync(bridgePath)) {
         return { ok: true, summary: "Bootstrap bridge repaired" };
       }
     }
@@ -7670,8 +7348,8 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
   const configs = resolveProjectConfigPaths(iuiRoot2);
   const missing = [];
   for (const [key, rel] of Object.entries(configs)) {
-    const abs = path24.resolve(iuiRoot2, rel.replace(/^\.\//, ""));
-    if (!fs19.existsSync(abs)) missing.push(`${key}: ${rel}`);
+    const abs = path23.resolve(iuiRoot2, rel.replace(/^\.\//, ""));
+    if (!fs18.existsSync(abs)) missing.push(`${key}: ${rel}`);
   }
   if (missing.length > 0) {
     return {
@@ -7681,7 +7359,7 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
     };
   }
   const expected = expectedBootstrapImportPaths(iuiRoot2);
-  const generated = fs19.readFileSync(generatedPath, "utf8");
+  const generated = fs18.readFileSync(generatedPath, "utf8");
   const stale = [];
   for (const [key, importPath] of Object.entries(expected)) {
     if (!generated.includes(`"${importPath}"`)) {
@@ -7691,7 +7369,7 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
   if (stale.length > 0) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      const refreshed = fs19.readFileSync(bootstrapGeneratedPath(iuiRoot2), "utf8");
+      const refreshed = fs18.readFileSync(bootstrapGeneratedPath(iuiRoot2), "utf8");
       const stillStale = Object.entries(expected).filter(
         ([, importPath]) => !refreshed.includes(`"${importPath}"`)
       );
@@ -7817,12 +7495,12 @@ async function runConfigTierDiagnostics(targetCwd, opts, counters, options = {})
       hint(hint2);
     }
   }
-  const assetBound = checkAssetBoundBindings(targetCwd);
-  if (assetBound.ok) {
-    pass(assetBound.summary);
+  const assetPipeline = checkAssetPipeline(targetCwd);
+  if (assetPipeline.ok) {
+    pass(assetPipeline.summary);
   } else {
-    warn(assetBound.summary);
-    if (assetBound.details) hint(assetBound.details);
+    warn(assetPipeline.summary);
+    if (assetPipeline.details) hint(assetPipeline.details);
   }
 }
 async function runPackageDiagnostics(targetCwd, opts, counters) {
@@ -7978,7 +7656,7 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
 async function doctorCommand(opts) {
   try {
     const invocationCwd = process.cwd();
-    const targets = opts?.cwd ? [path25.resolve(opts.cwd)] : resolveSetupDoctorTargets(invocationCwd);
+    const targets = opts?.cwd ? [path24.resolve(opts.cwd)] : resolveSetupDoctorTargets(invocationCwd);
     const installRoot = resolveDependencyInstallRoot(invocationCwd);
     const multiPackage = targets.length > 1;
     heading("Diagnostics");
@@ -8021,7 +7699,7 @@ async function doctorCommand(opts) {
     for (const targetCwd of targets) {
       if (multiPackage) {
         newline();
-        const label = path25.relative(installRoot, targetCwd) || path25.basename(targetCwd);
+        const label = path24.relative(installRoot, targetCwd) || path24.basename(targetCwd);
         kv("Package", label);
       }
       await runPackageDiagnostics(targetCwd, opts, counters);
@@ -8049,9 +7727,9 @@ async function doctorCommand(opts) {
 
 // src/commands/setup.ts
 function detectDevScript(cwd) {
-  const pkgPath = path26.join(cwd, "package.json");
+  const pkgPath = path25.join(cwd, "package.json");
   try {
-    const pkg = fs20.readJsonSync(pkgPath);
+    const pkg = fs19.readJsonSync(pkgPath);
     if (pkg.scripts?.dev) return "npm run dev";
     if (pkg.scripts?.start) return "npm run start";
   } catch {
@@ -8060,8 +7738,8 @@ function detectDevScript(cwd) {
   return null;
 }
 function relativePackageLabel(installRoot, packageDir) {
-  const rel = path26.relative(installRoot, packageDir);
-  return rel && rel !== "." ? rel : path26.basename(packageDir);
+  const rel = path25.relative(installRoot, packageDir);
+  return rel && rel !== "." ? rel : path25.basename(packageDir);
 }
 async function setupCommand(opts) {
   try {
@@ -8070,7 +7748,7 @@ async function setupCommand(opts) {
     const installRoot = resolveDependencyInstallRoot(cwd);
     const workspaceRoot = findWorkspaceRoot(cwd);
     const inMonorepo = workspaceRoot !== null;
-    const installFromChild = inMonorepo && path26.resolve(installRoot) !== path26.resolve(cwd);
+    const installFromChild = inMonorepo && path25.resolve(installRoot) !== path25.resolve(cwd);
     if (!hasPackageJson(cwd) && !hasPackageJson(installRoot)) {
       throw new CLIError(
         "No package.json found in the current directory.",
@@ -8104,7 +7782,7 @@ async function setupCommand(opts) {
     for (const w of warnings) warn(w);
     kv("Package manager", `${pm} (${source})`);
     if (installFromChild) {
-      const rel = path26.relative(cwd, installRoot) || ".";
+      const rel = path25.relative(cwd, installRoot) || ".";
       kv("Install directory", rel === ".." || rel.includes("..") ? installRoot : rel);
     }
     const installCmd2 = syncInstallCommand(pm);
@@ -8118,7 +7796,7 @@ async function setupCommand(opts) {
     } catch (err) {
       installSpinner.fail("Dependency install failed");
       const detail = formatExecSyncError(err);
-      const manual = path26.resolve(installRoot) === path26.resolve(cwd) ? installCmd2 : `cd ${JSON.stringify(installRoot)} && ${installCmd2}`;
+      const manual = path25.resolve(installRoot) === path25.resolve(cwd) ? installCmd2 : `cd ${JSON.stringify(installRoot)} && ${installCmd2}`;
       throw new CLIError(
         detail ? `Could not install project dependencies.
 ${detail}` : "Could not install project dependencies.",
@@ -8276,7 +7954,7 @@ async function updateCommand(opts = {}) {
     const auth = await ensureAuthSession();
     await ensureLicenseSession();
     const inProject = isInsideProject();
-    const currentCliVersion = true ? "0.0.10" : "unknown";
+    const currentCliVersion = true ? "0.0.11" : "unknown";
     const latestCliVersion = await fetchLatestCliVersion(auth.token);
     const cliUpdateAvailable = latestCliVersion !== null && isVersionGreater(latestCliVersion, currentCliVersion);
     if (latestCliVersion && cliUpdateAvailable) {
@@ -8558,7 +8236,7 @@ var AUTH_EXEMPT_COMMANDS = /* @__PURE__ */ new Set([
   "doctor",
   "list"
 ]);
-program.name("iui").description("The official CLI for the Inventive UI Design System").version(true ? "0.0.10" : "1.0.0").option("-C, --cwd <dir>", "Run as if started in the given directory").option("-q, --quiet", "Minimal output (also respects IUI_QUIET=1)").option("--no-color", "Disable ANSI colors");
+program.name("iui").description("The official CLI for the Inventive UI Design System").version(true ? "0.0.11" : "1.0.0").option("-C, --cwd <dir>", "Run as if started in the given directory").option("-q, --quiet", "Minimal output (also respects IUI_QUIET=1)").option("--no-color", "Disable ANSI colors");
 program.command("login").description("Authenticate with GitHub and link your license").option("-f, --force", "Force re-authentication and register this device").option("--bootstrap", "After login, run optional setup prompts").action((opts) => loginCommand(opts));
 program.command("logout").description("Remove stored credentials").action(logoutCommand);
 program.command("whoami").description("Show authenticated identity and license details").action(whoamiCommand);
@@ -8641,7 +8319,7 @@ program.command("update").description("Check for and apply framework, component,
 var assets = program.command("assets").description("Manage asset packages (icons, illustrations, logos, etc.)");
 assets.command("remove <package>").description("Remove an installed asset package").action((pkg) => assetsRemoveCommand(pkg));
 assets.command("list").description("Show all available and installed asset packages").action(assetsListCommand);
-program.command("doctor").description("Run project health diagnostics (read-only by default)").option("--fix", "Apply safe config patches (iui.config, vite.config, component.config)").option("--config-only", "Validate project config tiers only (no auth/registry)").action((opts) => doctorCommand(opts));
+program.command("doctor").description("Run project health diagnostics (read-only by default)").option("--fix", "Apply safe config patches (theme.config, vite.config, component.config)").option("--config-only", "Validate project config tiers only (no auth/registry)").action((opts) => doctorCommand(opts));
 if (shouldShowBanner()) {
   printBanner();
 }
@@ -8656,7 +8334,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
   const root = topLevelCommandName(actionCommand);
   const globalOpts = program.opts();
   if (globalOpts.cwd) {
-    process.chdir(path27.resolve(globalOpts.cwd));
+    process.chdir(path26.resolve(globalOpts.cwd));
   }
   if (isInsideProject()) {
     try {