inventive-ui 0.0.10 → 0.0.12

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path27 from "path";
+import path25 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.12" : "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 path26 = parsed.pathname.replace(/\/+$/, "");
+    if (path26 && !/^\/[a-zA-Z0-9._/-]+$/.test(path26)) {
       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",
@@ -763,22 +763,6 @@ function writeJsonRestricted(filePath, data) {
 
 // src/utils/security/paths.ts
 import path4 from "path";
-function assertWithinRoot(rootDir, targetPath, label) {
-  const root = path4.resolve(rootDir);
-  const target = path4.resolve(targetPath);
-  const rel = path4.relative(root, target);
-  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
-    throw new CLIError(
-      `Unsafe ${label} path: ${targetPath}`,
-      `Path must stay within ${rootDir}`
-    );
-  }
-}
-function resolveWithinRoot(rootDir, ...segments) {
-  const joined = path4.join(rootDir, ...segments);
-  assertWithinRoot(rootDir, joined, "file");
-  return joined;
-}
 
 // src/utils/security/process.ts
 import fs5 from "fs-extra";
@@ -1428,7 +1412,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()) {
@@ -1934,32 +1918,12 @@ function patchProjectConfigBuildBlock(content) {
 import ts2 from "typescript";
 
 // src/utils/security/identifiers.ts
-var SLUG_RE = /^[a-z][a-z0-9-]*$/;
 var JS_IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var NPM_SCOPE_IMPORT_RE = /^@inventive-ui\/[a-z0-9][a-z0-9._-]*$/;
-var NPM_COMPONENT_SUBPATH_RE = /^@inventive-ui\/components\/[A-Za-z][A-Za-z0-9-]*$/;
-function assertComponentSlug(slug) {
-  if (!SLUG_RE.test(slug)) {
-    throw new CLIError(
-      `Invalid component slug: "${slug}"`,
-      "Use lowercase letters, numbers, and hyphens (e.g. button, input)."
-    );
-  }
-}
 function assertJsIdentifier(name, label) {
   if (!JS_IDENTIFIER_RE.test(name)) {
     throw new CLIError(`Invalid ${label}: "${name}"`);
   }
 }
-function assertImportSpecifier(specifier) {
-  if (NPM_SCOPE_IMPORT_RE.test(specifier)) return;
-  if (NPM_COMPONENT_SUBPATH_RE.test(specifier)) return;
-  if (/^@inventive-ui\/[a-z0-9][a-z0-9-]*$/.test(specifier)) return;
-  throw new CLIError(`Unsafe import specifier: "${specifier}"`);
-}
-function escapeTsStringLiteral(value) {
-  return JSON.stringify(value);
-}
 function sanitizePackageVersionHeader(value) {
   if (!value) return null;
   const trimmed = value.trim();
@@ -2043,7 +2007,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 +2064,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 +2083,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 +2158,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 +2180,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 +2193,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")
   };
 }
@@ -2441,9 +2407,6 @@ function componentManifestPath(cwd) {
 function packageManifestPath(cwd) {
   return metaPath("packages.json", cwd);
 }
-function slotManifestPath(cwd) {
-  return metaPath("slots.json", cwd);
-}
 function readProjectJsonStrict(p, label) {
   if (!fs8.existsSync(p)) {
     throw new CLIError(`Missing ${label}.`, "Run iui init to initialize the project.");
@@ -2528,12 +2491,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 +2498,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 +2657,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 {
@@ -2718,14 +2665,6 @@ function writeAssetsConfig(cwd = process.cwd()) {
   } catch {
   }
 }
-function readSlotManifest(cwd) {
-  const p = slotManifestPath(cwd);
-  if (!fs8.existsSync(p)) return {};
-  return readProjectJsonStrict(p, ".iui/slots.json");
-}
-function writeSlotManifest(manifest, cwd) {
-  writeJson(slotManifestPath(cwd), manifest);
-}
 function readComponentPackageManifest(cwd = process.cwd()) {
   const pkgDir = resolvePackageDir("@inventive-ui/components", cwd);
   if (!pkgDir) return null;
@@ -2762,12 +2701,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 +2723,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 +2853,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 +3318,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(path26, opts) {
+  const res = await fetch(`${API_BASE_URL}${path26}`, {
     ...opts,
     signal: opts?.signal ?? AbortSignal.timeout(API_REQUEST_TIMEOUT_MS),
     headers: { "Content-Type": "application/json", ...opts?.headers }
   });
-  throwIfRateLimited(res, `calling ${path28}`);
+  throwIfRateLimited(res, `calling ${path26}`);
   if (!res.ok) {
     const body = await res.text().catch(() => "");
     throw new CLIError(`API error ${res.status}: ${body || res.statusText}`);
@@ -3629,10 +3576,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 +3593,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 +3602,7 @@ async function promptAssetSelection(installedPackages = []) {
       message: chalk2.dim("Toggle packages to install"),
       prefix: PROMPT_PREFIX,
       choices,
-      pageSize: 20,
+      pageSize,
       loop: false
     }
   ]);
@@ -3733,7 +3684,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 +3776,7 @@ async function promptText(title, hint2, placeholder, validate) {
 }
 
 // src/commands/init.ts
-import path23 from "path";
+import path21 from "path";
 import ora3 from "ora";
 
 // src/services/license.ts
@@ -4792,8 +4743,8 @@ function getMajorFromVersion(version) {
 import ora2 from "ora";
 
 // src/services/slot-registry.ts
-import fs18 from "fs-extra";
-import path22 from "path";
+import fs16 from "fs-extra";
+import path20 from "path";
 
 // src/services/registry-lock.ts
 import fs11 from "fs";
@@ -4879,113 +4830,107 @@ async function withRegistryLock(cwd, operation) {
   }
 }
 
-// src/services/slots.ts
-import fs15 from "fs-extra";
-import path19 from "path";
+// src/services/legacy-slot-cleanup.ts
+import fs12 from "fs-extra";
+import path16 from "path";
 
-// src/utils/public-slot-contract.ts
+// src/services/generated-paths.ts
 import path15 from "path";
-import fs12 from "fs-extra";
-var CONTRACT_FILENAME = "public-slot-contract.json";
-function loadPublicSlotContract(cwd = process.cwd()) {
-  const pkgRoot = resolvePackageDir("@inventive-ui/components", cwd);
-  if (!pkgRoot) return null;
-  const contractPath = path15.join(pkgRoot, CONTRACT_FILENAME);
-  if (!fs12.existsSync(contractPath)) return null;
+function iuiProjectRoot2(cwd) {
+  return resolveIuiProjectRoot(cwd);
+}
+function generatedIuiDir(cwd) {
+  return path15.join(iuiProjectRoot2(cwd), ".iui", "generated");
+}
+
+// src/services/legacy-slot-cleanup.ts
+var MANAGED_MARKER = /@iui-managed|Managed by iui/;
+function isManagedFile(filePath) {
   try {
-    return fs12.readJsonSync(contractPath);
+    return MANAGED_MARKER.test(fs12.readFileSync(filePath, "utf-8"));
   } catch {
-    return null;
+    return false;
   }
 }
-function slotRequiresPrefetch(entry) {
-  if (entry.prefetch === true) return true;
-  if (entry.prefetch === false) return false;
-  if (entry.bootstrap === "sync") return true;
-  return Array.isArray(entry.profile) && entry.profile.includes("critical");
-}
-function contractEntryToBootstrapPolicy(entry) {
-  return slotRequiresPrefetch(entry) ? "core" : "optional";
-}
-function validateSlotPrefetchPolicy(entry) {
-  const type = entry.type ?? "?";
-  const requires = slotRequiresPrefetch(entry);
-  if (requires && entry.prefetch === false) {
-    return `slot "${type}" is core/critical but prefetch is false`;
-  }
-  if ((entry.bootstrap === "sync" || Array.isArray(entry.profile) && entry.profile.includes("critical")) && entry.prefetch !== true) {
-    return `slot "${type}" must declare prefetch: true (sync/critical peer hub)`;
-  }
-  if (!requires && entry.prefetch === true) {
-    return `slot "${type}" declares prefetch: true but is not sync/critical`;
+function listFiles(dir, match) {
+  if (!fs12.existsSync(dir)) return [];
+  try {
+    return fs12.readdirSync(dir).filter(match).map((file) => path16.join(dir, file));
+  } catch {
+    return [];
   }
-  return null;
-}
-
-// src/utils/slot-emitters.ts
-function contractEntryToEmitter(entry) {
-  const lazyAccess = entry.lazyAccess.startsWith(".") ? entry.lazyAccess : `.${entry.lazyAccess}`;
-  return {
-    type: entry.type,
-    parentSlug: entry.parent,
-    componentName: entry.component ?? entry.type,
-    propsName: entry.props,
-    importSpecifier: entry.import,
-    lazyImportSpecifier: entry.lazyImport ?? entry.import,
-    lazyAccess
-  };
 }
-function isContractEntryInstalled(entry, installedSlugs) {
-  if (!entry.public) return false;
-  if (installedSlugs.has(entry.type)) return true;
-  if (installedSlugs.has(entry.parent)) return true;
-  return false;
+function ownedDirs(iuiRoot2, packageDirs) {
+  const generated = generatedIuiDir(iuiRoot2);
+  return [
+    path16.join(generated, "slots"),
+    path16.join(generated, "assets"),
+    ...packageDirs.map((dir) => path16.join(dir, "src", "iui", "slots"))
+  ];
 }
-function collectInstalledSlotEmitters(items, installedSlugs, cwd = process.cwd()) {
-  const contract = loadPublicSlotContract(cwd);
-  if (!contract) {
-    return {
-      emitters: [],
-      issues: [
-        "@inventive-ui/components/public-slot-contract.json is missing from node_modules."
-      ]
-    };
-  }
-  const issues = [];
-  const emitters = [];
-  const registrySlugs = new Set(items.map((item) => item.name));
-  for (const slug of installedSlugs) {
-    if (!registrySlugs.has(slug)) continue;
-    const hasPrimary = contract.slots.some(
-      (entry) => entry.public && entry.type === slug
+function findStaleComponentSlotOutput(cwd, packageDirs = []) {
+  const iuiRoot2 = iuiProjectRoot2(cwd);
+  const generated = generatedIuiDir(iuiRoot2);
+  const packages = [...new Set([iuiRoot2, ...packageDirs].map((dir) => path16.resolve(dir)))];
+  const stale = [];
+  stale.push(
+    ...listFiles(
+      path16.join(generated, "slots"),
+      (file) => file.endsWith(".generated.tsx") || file.endsWith(".slot.tsx")
+    )
+  );
+  const helper = path16.join(generated, "slot.generated.tsx");
+  if (fs12.existsSync(helper) && isManagedFile(helper)) stale.push(helper);
+  stale.push(
+    ...listFiles(
+      path16.join(generated, "assets"),
+      (file) => file.endsWith(".bound.ts") || file === "register-bound.ts"
+    )
+  );
+  const manifest = path16.join(iuiRoot2, ".iui", "slots.json");
+  if (fs12.existsSync(manifest)) stale.push(manifest);
+  for (const packageDir of packages) {
+    const bridge = path16.join(packageDir, "src", "iui", "slot.tsx");
+    if (fs12.existsSync(bridge) && isManagedFile(bridge)) stale.push(bridge);
+    stale.push(
+      ...listFiles(
+        path16.join(packageDir, "src", "iui", "slots"),
+        (file) => file.endsWith(".slot.tsx")
+      )
     );
-    if (!hasPrimary) {
-      issues.push(`${slug}: no public slot contract entry for primary type "${slug}"`);
-    }
   }
-  for (const entry of contract.slots) {
-    if (!isContractEntryInstalled(entry, installedSlugs)) continue;
-    if (!entry.props || !entry.lazyAccess || !entry.import) {
-      issues.push(`${entry.type}: incomplete public slot contract entry`);
-      continue;
+  return stale;
+}
+function removeStaleComponentSlotOutput(cwd, packageDirs = []) {
+  const iuiRoot2 = iuiProjectRoot2(cwd);
+  const removed = [];
+  for (const file of findStaleComponentSlotOutput(iuiRoot2, packageDirs)) {
+    try {
+      fs12.removeSync(file);
+      removed.push(file);
+    } catch {
     }
-    emitters.push(contractEntryToEmitter(entry));
   }
-  const deduped = /* @__PURE__ */ new Map();
-  for (const emitter of emitters) {
-    if (!deduped.has(emitter.type)) {
-      deduped.set(emitter.type, emitter);
+  for (const dir of ownedDirs(iuiRoot2, [iuiRoot2, ...packageDirs])) {
+    try {
+      if (fs12.existsSync(dir) && fs12.readdirSync(dir).length === 0) fs12.removeSync(dir);
+    } catch {
     }
   }
-  return {
-    emitters: [...deduped.values()].sort((a, b) => a.type.localeCompare(b.type)),
-    issues
-  };
+  return removed;
 }
 
+// src/services/workspace-bootstrap.ts
+import path19 from "path";
+import fs15 from "fs-extra";
+
+// src/services/bootstrap.ts
+import fs14 from "fs-extra";
+import path18 from "path";
+
 // src/utils/security/fsSafe.ts
 import fs13 from "fs";
-import path16 from "path";
+import path17 from "path";
 function assertNotSymlink(filePath, label) {
   try {
     const stat = fs13.lstatSync(filePath);
@@ -4999,11 +4944,11 @@ function assertNotSymlink(filePath, label) {
   }
 }
 function safeWriteFile(filePath, content) {
-  const dir = path16.dirname(filePath);
+  const dir = path17.dirname(filePath);
   if (fs13.existsSync(dir)) {
     assertNotSymlink(dir, "directory");
   }
-  const parent = path16.dirname(filePath);
+  const parent = path17.dirname(filePath);
   fs13.mkdirSync(parent, { recursive: true });
   if (fs13.existsSync(filePath)) {
     assertNotSymlink(filePath, "file");
@@ -5011,700 +4956,13 @@ 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) {
-  return resolveIuiProjectRoot(cwd);
-}
-function generatedIuiDir(cwd) {
-  return path17.join(iuiProjectRoot2(cwd), ".iui", "generated");
-}
-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");
-}
-function cleanupLegacySourceSlotFiles(cwd) {
-  const legacySlotsDir = path19.join(cwd, "src", "iui", "slots");
-  if (!fs15.existsSync(legacySlotsDir)) return;
-  try {
-    const files = fs15.readdirSync(legacySlotsDir);
-    for (const file of files) {
-      if (file.endsWith(".slot.tsx")) {
-        fs15.removeSync(path19.join(legacySlotsDir, file));
-      }
-    }
-    const remaining = fs15.readdirSync(legacySlotsDir);
-    if (remaining.length === 0) {
-      fs15.removeSync(legacySlotsDir);
-    }
-  } catch {
-  }
-}
-function loadSlotBootstrapPolicy(cwd) {
-  const policy = /* @__PURE__ */ new Map();
-  const contract = loadPublicSlotContract(cwd);
-  if (!contract) return policy;
-  for (const entry of contract.slots ?? []) {
-    if (!entry?.type || !entry.public) continue;
-    policy.set(entry.type, contractEntryToBootstrapPolicy(entry));
-  }
-  return policy;
-}
-function validateGeneratedSlotImports(cwd = process.cwd()) {
-  const components = readComponentManifest(cwd);
-  const pkgManifest = readComponentPackageManifest(cwd);
-  if (!pkgManifest) {
-    return ["@inventive-ui/components manifest is missing from node_modules."];
-  }
-  const itemsLookup = registryItemsMap(pkgManifest);
-  const installedItems = Object.keys(components).map((slug) => itemsLookup[slug]).filter((item) => Boolean(item));
-  const { issues } = collectInstalledSlotEmitters(
-    installedItems,
-    new Set(Object.keys(components)),
-    cwd
-  );
-  return issues.map((issue) => issue);
-}
-function renderGetComponentExpr(emitter, _slotPropsType = "unknown") {
-  const access = emitter.lazyAccess.replace(/^\./, "").trim();
-  const parts = access.split(".").filter(Boolean);
-  const compName = emitter.componentName;
-  if (parts.length === 0) {
-    assertJsIdentifier(compName, "component export");
-    return `resolveComponentExport(mod, ${JSON.stringify(compName)})`;
-  }
-  if (parts.length === 1) {
-    const name = parts[0] === "default" ? compName : parts[0];
-    assertJsIdentifier(name, "component export");
-    return `resolveComponentExport(mod, ${JSON.stringify(name)})`;
-  }
-  const [root, ...rest] = parts;
-  if (root !== "default") {
-    assertJsIdentifier(root, "component export");
-  }
-  for (const part of rest) {
-    assertJsIdentifier(part, "component export member");
-  }
-  const rootName = root === "default" ? compName : root;
-  if (rest.length === 1) {
-    return `resolveComponentExport(mod, ${JSON.stringify(rootName)}, ${JSON.stringify(rest[0])})`;
-  }
-  const rootExpr = `resolveComponentExport(mod, ${JSON.stringify(rootName)})`;
-  return `${rootExpr}?.${rest.join(".")}`;
-}
-function writeComponentSlotFiles(cwd = process.cwd()) {
-  const components = readComponentManifest(cwd);
-  const pkgManifest = readComponentPackageManifest(cwd);
-  const slotsDir = generatedSlotsDir(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"));
-      for (const file of existingSlots2) {
-        try {
-          fs15.removeSync(path19.join(slotsDir, file));
-        } catch {
-        }
-      }
-    }
-    return;
-  }
-  fs15.ensureDirSync(slotsDir);
-  if (!pkgManifest) return;
-  const itemsLookup = registryItemsMap(pkgManifest);
-  const installedItems = Object.entries(components).map(([slug]) => itemsLookup[slug]).filter((item) => Boolean(item));
-  const { emitters, issues: emitterIssues } = collectInstalledSlotEmitters(
-    installedItems,
-    new Set(Object.keys(components)),
-    cwd
-  );
-  generationIssues.push(...emitterIssues.map((issue) => `- ${issue}`));
-  const contract = loadPublicSlotContract(cwd);
-  if (contract) {
-    for (const entry of contract.slots ?? []) {
-      if (!entry.public) continue;
-      const prefetchError = validateSlotPrefetchPolicy(entry);
-      if (prefetchError) {
-        generationIssues.push(prefetchError);
-      }
-    }
-  }
-  const slotPolicy = loadSlotBootstrapPolicy(cwd);
-  const coreEmitters = [];
-  const optionalEmitters = [];
-  for (const emitter of emitters) {
-    assertComponentSlug(emitter.type);
-    assertJsIdentifier(emitter.componentName, "component export");
-    if (emitter.propsName !== "Props") assertJsIdentifier(emitter.propsName, "props type");
-    assertImportSpecifier(emitter.importSpecifier);
-    assertImportSpecifier(emitter.lazyImportSpecifier);
-    const policy = slotPolicy.get(emitter.type) ?? "optional";
-    if (policy === "core") coreEmitters.push(emitter);
-    else optionalEmitters.push(emitter);
-  }
-  const root = iuiProjectRoot2(cwd);
-  const renderedGroups = [
-    { fileName: SLOT_GROUP_CORE_FILE, emitters: coreEmitters },
-    { fileName: SLOT_GROUP_OPTIONAL_FILE, emitters: optionalEmitters }
-  ];
-  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);
-      continue;
-    }
-    safeWriteFile(
-      outPath,
-      renderGroupedSlotFileContent(group.emitters, {
-        prefetch: group.fileName === SLOT_GROUP_CORE_FILE
-      })
-    );
-  }
-  const existingSlots = fs15.existsSync(slotsDir) ? fs15.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));
-      } catch {
-      }
-      continue;
-    }
-    if (file.endsWith(".generated.tsx")) {
-      try {
-        fs15.removeSync(path19.join(slotsDir, file));
-      } catch {
-      }
-    }
-  }
-  if (generationIssues.length > 0) {
-    throw new CLIError(
-      [
-        "Component public slot contract mismatch while generating slot files:",
-        ...generationIssues
-      ].join("\n"),
-      "Reinstall @inventive-ui/components and run iui doctor to repair the slot registry."
-    );
-  }
-}
-function renderGroupedSlotFileContent(emitters, options = {}) {
-  const needsComponentProps = emitters.some((emitter) => emitter.propsName === "Props");
-  const lines = [
-    "// Managed by iui. Do not edit manually.",
-    'import React from "react";',
-    'import { registerSlot, createEagerComponent, resolveComponentExport } from "@inventive-ui/framework/slots";'
-  ];
-  if (needsComponentProps) {
-    lines.push('import type { ComponentProps } from "react";');
-  }
-  lines.push("");
-  const imports = /* @__PURE__ */ new Set();
-  let idx = 0;
-  for (const emitter of emitters) {
-    idx += 1;
-    const alias = `Comp${idx}`;
-    if (emitter.propsName === "Props") {
-      imports.add(
-        `import type { ${emitter.componentName} as ${alias}Type } from "${emitter.importSpecifier}";`
-      );
-    } else {
-      imports.add(`import type { ${emitter.propsName} } from "${emitter.importSpecifier}";`);
-    }
-  }
-  lines.push(...[...imports].sort(), "");
-  idx = 0;
-  for (const emitter of emitters) {
-    idx += 1;
-    const alias = `Comp${idx}`;
-    const slotType = emitter.propsName === "Props" ? `ComponentProps<typeof ${alias}Type>` : emitter.propsName;
-    lines.push(`type ${alias}Slot = { type: "${emitter.type}" } & Omit<${slotType}, "type">;`);
-    lines.push(`type ${alias}SlotProps = Omit<${alias}Slot, "type">;`);
-  }
-  lines.push("", 'declare module "@inventive-ui/framework/slots" {', "  interface SlotMap {");
-  idx = 0;
-  for (const emitter of emitters) {
-    idx += 1;
-    lines.push(`    "${emitter.type}": Comp${idx}Slot;`);
-  }
-  lines.push("  }", "}", "");
-  idx = 0;
-  for (const emitter of emitters) {
-    idx += 1;
-    const alias = `Comp${idx}`;
-    const renderer = `${alias}Renderer`;
-    lines.push(`const ${renderer} = createEagerComponent<${alias}SlotProps>(`);
-    lines.push(`  () => import(${escapeTsStringLiteral(emitter.lazyImportSpecifier)}),`);
-    lines.push(`  (mod) => ${renderGetComponentExpr(emitter, `${alias}SlotProps`)} as React.ComponentType<${alias}SlotProps>,`);
-    if (options.prefetch) {
-      lines.push("  { prefetch: true },");
-    }
-    lines.push(");", "");
-    lines.push(`registerSlot(${escapeTsStringLiteral(emitter.type)}, (slot) => {`);
-    lines.push("  const { type, ...props } = slot;");
-    lines.push(`  return <${renderer} {...props} />;`);
-    lines.push("});", "");
-  }
-  return `${lines.join("\n")}
-`;
-}
-function writeSlotHelperFile(cwd = process.cwd()) {
-  const manifest = readSlotManifest(cwd);
-  const components = readComponentManifest(cwd);
-  const pkgManifest = readComponentPackageManifest(cwd);
-  const slotTypes = /* @__PURE__ */ new Set();
-  for (const record of Object.values(manifest)) {
-    if (record.slotType && record.slotType !== "component") {
-      slotTypes.add(record.slotType);
-    }
-    if (Array.isArray(record.supportedSlots)) {
-      for (const t of record.supportedSlots) slotTypes.add(t);
-    }
-  }
-  let emitterSlotTypes = [];
-  if (pkgManifest) {
-    const itemsLookup = registryItemsMap(pkgManifest);
-    const installedItems = Object.keys(components).map((slug) => itemsLookup[slug]).filter((item) => Boolean(item));
-    const { emitters } = collectInstalledSlotEmitters(
-      installedItems,
-      new Set(Object.keys(components)),
-      cwd
-    );
-    emitterSlotTypes = emitters.map((emitter) => emitter.type);
-    for (const type of emitterSlotTypes) slotTypes.add(type);
-  } else {
-    for (const slug of Object.keys(components)) slotTypes.add(slug);
-  }
-  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 componentSlotImports = slotImports.join("\n");
-  const includeAssetBindings = hasAssetBoundRegistration(cwd);
-  const outDir = generatedIuiDir(cwd);
-  fs15.ensureDirSync(outDir);
-  const outPath = path19.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");
-    sections.push(componentSlotImports);
-  }
-  sections.push("");
-  sections.push(`// Framework slot system \u2014 flag, icon, loader, etc. registrations run as side effects`);
-  sections.push(`// when @inventive-ui/framework is first imported. No explicit registration needed here.`);
-  sections.push(`import { SlotRenderer, useSlotRenderer } from "@inventive-ui/framework/slots";`);
-  sections.push(`import slotManifest from "../slots.json";`);
-  sections.push("");
-  sections.push(
-    typesArray.length > 0 ? `export type IUISlotType =
-${typesArray.map((t) => `  | "${t}"`).join("\n")};` : `export type IUISlotType = never;`
-  );
-  sections.push("");
-  sections.push(`export { SlotRenderer, useSlotRenderer };`);
-  sections.push("");
-  sections.push(`export const slots = slotManifest;`);
-  sections.push("");
-  const content = sections.join("\n");
-  safeWriteFile(outPath, content);
-}
-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");
-    if (existing.length > 0 && !/@iui-managed/.test(existing)) {
-      return;
-    }
-  }
-  const bridgeContent = `// Managed by iui. Do not edit manually.
-// @iui-managed
-// Compatibility bridge: keep project imports stable at src/iui/slot.tsx.
-
-export { SlotRenderer, useSlotRenderer, slots } from "${importBase}";
-export type { IUISlotType } from "${importBase}";
-`;
-  safeWriteFile(bridgePath, bridgeContent);
-  cleanupLegacySourceSlotFiles(packageDir);
-}
-
-// src/services/workspace-bootstrap.ts
-import path21 from "path";
-import fs17 from "fs-extra";
-
 // src/services/bootstrap.ts
-import fs16 from "fs-extra";
-import path20 from "path";
 var BOOTSTRAP_GENERATED_FILE = "bootstrap.generated.tsx";
 function bridgeBootstrapFilePath(cwd) {
-  return path20.join(cwd, "src", "iui", "bootstrap.ts");
+  return path18.join(cwd, "src", "iui", "bootstrap.ts");
 }
 function bootstrapGeneratedPath(cwd = process.cwd()) {
-  return path20.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
+  return path18.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
 }
 function resolveProjectConfigPaths(cwd) {
   const meta = readProjectMeta(cwd);
@@ -5719,8 +4977,8 @@ function resolveProjectConfigPaths(cwd) {
   };
 }
 function configImportFromGenerated(cwd, configRel) {
-  const generatedDir = path20.dirname(bootstrapGeneratedPath(cwd));
-  const abs = path20.resolve(cwd, configRel.replace(/^\.\//, ""));
+  const generatedDir = path18.dirname(bootstrapGeneratedPath(cwd));
+  const abs = path18.resolve(cwd, configRel.replace(/^\.\//, ""));
   return relativeImportPath(generatedDir, abs);
 }
 function expectedBootstrapImportPaths(cwd) {
@@ -5733,13 +4991,13 @@ function expectedBootstrapImportPaths(cwd) {
 }
 function writeBootstrapGenerated(cwd = process.cwd()) {
   const outPath = bootstrapGeneratedPath(cwd);
-  fs16.ensureDirSync(path20.dirname(outPath));
+  fs14.ensureDirSync(path18.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,16 +5017,12 @@ 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";
 
 
 
-import "./slot.generated";
-
-
-
 const themeConfig = (theme as { default?: typeof theme }).default ?? theme;
 
 
@@ -5795,7 +5049,7 @@ registerBootstrapState({
 
 initFramework(frameworkConfig);
 
-initSlotsConfig(frameworkConfig);
+initAssetsConfig(frameworkConfig);
 
 
 
@@ -5807,10 +5061,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(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;
     }
@@ -5831,17 +5085,18 @@ import "${importBase}";
 function writeProjectBootstrapArtifacts(packageDir, iuiRoot2) {
   writeBootstrapGenerated(iuiRoot2);
   writeBootstrapBridge(packageDir, iuiRoot2);
+  removeStaleComponentSlotOutput(iuiRoot2, [packageDir]);
 }
 
 // src/services/workspace-bootstrap.ts
 function workspaceManifestPath(iuiRoot2) {
-  return path21.join(iuiRoot2, IUI_DIR, "workspace.json");
+  return path19.join(iuiRoot2, IUI_DIR, "workspace.json");
 }
 function readWorkspaceManifest(iuiRoot2) {
   const p = workspaceManifestPath(iuiRoot2);
-  if (!fs17.existsSync(p)) return null;
+  if (!fs15.existsSync(p)) return null;
   try {
-    const raw = fs17.readJsonSync(p);
+    const raw = fs15.readJsonSync(p);
     if (!Array.isArray(raw.packages)) return null;
     return {
       iuiRoot: raw.iuiRoot ?? iuiRoot2,
@@ -5853,40 +5108,45 @@ function readWorkspaceManifest(iuiRoot2) {
   }
 }
 function writeWorkspaceManifest(iuiRoot2, packageDirs) {
-  const unique = [...new Set(packageDirs.map((dir) => path21.resolve(dir)))];
+  const unique = [...new Set(packageDirs.map((dir) => path19.resolve(dir)))];
   atomicWriteJson(workspaceManifestPath(iuiRoot2), {
-    packages: unique.map((dir) => path21.relative(iuiRoot2, dir) || "."),
+    packages: unique.map((dir) => path19.relative(iuiRoot2, dir) || "."),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
 function resolveRegisteredPackageDirs(iuiRoot2) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
+  const resolvedRoot = path19.resolve(iuiRoot2);
   const manifest = readWorkspaceManifest(resolvedRoot);
   if (!manifest) return [resolvedRoot];
   const dirs = manifest.packages.map(
-    (rel) => path21.resolve(resolvedRoot, rel === "." ? "" : rel)
+    (rel) => path19.resolve(resolvedRoot, rel === "." ? "" : rel)
   );
-  if (!dirs.some((dir) => path21.resolve(dir) === resolvedRoot)) {
+  if (!dirs.some((dir) => path19.resolve(dir) === resolvedRoot)) {
     dirs.unshift(resolvedRoot);
   }
   return dirs;
 }
+function registeredPackageDirs(iuiRoot2) {
+  return resolveRegisteredPackageDirs(resolveIuiProjectRoot(iuiRoot2)).filter(
+    (dir) => fs15.existsSync(path19.join(dir, "package.json"))
+  );
+}
 function registerWorkspacePackage(iuiRoot2, packageDir) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
-  const resolvedPackage = path21.resolve(packageDir);
+  const resolvedRoot = path19.resolve(iuiRoot2);
+  const resolvedPackage = path19.resolve(packageDir);
   const existing = resolveRegisteredPackageDirs(resolvedRoot);
-  if (!existing.some((dir) => path21.resolve(dir) === resolvedPackage)) {
+  if (!existing.some((dir) => path19.resolve(dir) === resolvedPackage)) {
     existing.push(resolvedPackage);
   }
   writeWorkspaceManifest(resolvedRoot, existing);
 }
 function registerAllWorkspacePackages(iuiRoot2) {
-  const resolvedRoot = path21.resolve(iuiRoot2);
+  const resolvedRoot = path19.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(path19.resolve(pkgDir));
     }
   }
   const dirs = [...targets];
@@ -5897,18 +5157,17 @@ 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 (!fs15.existsSync(path19.join(packageDir, "package.json"))) continue;
     ensureProjectNpmrc(packageDir);
-    writeSlotBridge(packageDir, resolvedRoot);
     writeProjectBootstrapArtifacts(packageDir, resolvedRoot);
     bootstrapped.push(packageDir);
   }
   return bootstrapped;
 }
 async function bootstrapWorkspacePackage(packageDir, iuiRoot2) {
-  const resolvedPackage = path21.resolve(packageDir);
+  const resolvedPackage = path19.resolve(packageDir);
   const resolvedIuiRoot = resolveIuiProjectRoot(iuiRoot2);
-  if (!fs17.existsSync(path21.join(resolvedPackage, "package.json"))) {
+  if (!fs15.existsSync(path19.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."
@@ -5921,7 +5180,7 @@ async function bootstrapWorkspacePackage(packageDir, iuiRoot2) {
   }
   registerWorkspacePackage(resolvedIuiRoot, resolvedPackage);
   bootstrapRegisteredPackages(resolvedIuiRoot);
-  ok("Slot bridge ready");
+  ok("Bootstrap bridge ready");
   hint(
     "This app is linked to an existing IUI setup \u2014 packages and configs stay at the IUI root."
   );
@@ -5933,28 +5192,28 @@ async function bootstrapWorkspacePackage(packageDir, iuiRoot2) {
 }
 
 // src/services/slot-registry.ts
-var STATE_SCHEMA_VERSION = 1;
+var STATE_SCHEMA_VERSION = 2;
 function statePath(cwd) {
   return iuiCacheFile(cwd, "slotState");
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function checksumFor(components, slots) {
-  return sha256(JSON.stringify({ components, slots }));
+function checksumFor(components, packages) {
+  return sha256(JSON.stringify({ components, packages }));
 }
 function backupCorruptFile(filePath) {
-  if (!fs18.existsSync(filePath)) return;
+  if (!fs16.existsSync(filePath)) return;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   try {
-    fs18.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
+    fs16.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
   } catch {
   }
 }
 function readJsonObject(filePath, fallback, issues, label) {
-  if (!fs18.existsSync(filePath)) return fallback;
+  if (!fs16.existsSync(filePath)) return fallback;
   try {
-    const value = fs18.readJsonSync(filePath);
+    const value = fs16.readJsonSync(filePath);
     if (value && typeof value === "object" && !Array.isArray(value)) {
       return value;
     }
@@ -5966,9 +5225,9 @@ function readJsonObject(filePath, fallback, issues, label) {
 }
 function readState(cwd, issues) {
   const filePath = statePath(cwd);
-  if (!fs18.existsSync(filePath)) return null;
+  if (!fs16.existsSync(filePath)) return null;
   try {
-    const raw = fs18.readJsonSync(filePath);
+    const raw = fs16.readJsonSync(filePath);
     if (raw.schemaVersion !== STATE_SCHEMA_VERSION) {
       issues.push("registration state schema was upgraded");
       return null;
@@ -5997,37 +5256,15 @@ function updateState(cwd, state, phase, patch = {}) {
   writeState(cwd, next);
   return next;
 }
-function buildDesiredState(registry, packageVersion, currentSlots, packages) {
+function buildDesiredComponents(registry, packageVersion) {
   const components = {};
-  const slots = {};
-  const timestamp = now();
   for (const item of registry.items) {
     components[item.name] = packageVersion;
-    slots[item.name] = {
-      component: item.name,
-      slotType: "component",
-      registeredAt: currentSlots[item.name]?.registeredAt ?? timestamp,
-      version: packageVersion
-    };
-    if (item.slots.length > 0) {
-      slots[item.name].supportedSlots = [...item.slots].sort();
-    }
-  }
-  for (const [packageId, meta] of Object.entries(packages)) {
-    const def = ASSET_PACKAGES_MAP[packageId];
-    if (!def) continue;
-    const key = `asset:${packageId}`;
-    slots[key] = {
-      component: packageId,
-      slotType: def.slotType,
-      registeredAt: currentSlots[key]?.registeredAt ?? timestamp,
-      version: meta.version
-    };
   }
-  return { components, slots };
+  return components;
 }
-function hasManifestDrift(currentComponents, currentSlots, desiredComponents, desiredSlots) {
-  return JSON.stringify(currentComponents) !== JSON.stringify(desiredComponents) || JSON.stringify(currentSlots) !== JSON.stringify(desiredSlots);
+function hasManifestDrift(currentComponents, desiredComponents) {
+  return JSON.stringify(currentComponents) !== JSON.stringify(desiredComponents);
 }
 function shouldSkipWritesFastPath(params) {
   const {
@@ -6072,7 +5309,7 @@ async function ensureSlotRegistry(options = {}) {
   }
   const iuiRoot2 = resolveIuiProjectRoot(cwd);
   return withRegistryLock(iuiRoot2, async () => {
-    const iuiPath = path22.join(iuiRoot2, IUI_DIR);
+    const iuiPath = path20.join(iuiRoot2, IUI_DIR);
     const issues = [];
     cleanupTempFiles(iuiPath);
     const registry = ensureInstalledManifest(
@@ -6098,37 +5335,25 @@ async function ensureSlotRegistry(options = {}) {
         issues,
         ".iui/packages.json"
       );
-      const currentSlots = readJsonObject(
-        slotManifestPath(iuiRoot2),
-        {},
-        issues,
-        ".iui/slots.json"
-      );
-      const desired = buildDesiredState(
-        registry,
-        packageVersion,
-        currentSlots,
-        currentPackages
-      );
-      const checksum = checksumFor(desired.components, desired.slots);
+      const desiredComponents = buildDesiredComponents(registry, packageVersion);
+      const checksum = checksumFor(desiredComponents, currentPackages);
       if (previousState?.status === "running" || previousState?.status === "failed") {
         issues.push("interrupted registration was resumed");
       }
       if (previousState?.checksum && previousState.checksum !== checksum) {
-        issues.push("slot registry checksum changed");
+        issues.push("registry checksum changed");
       }
-      const driftDetected = hasManifestDrift(
-        currentComponents,
-        currentSlots,
-        desired.components,
-        desired.slots
-      );
+      const driftDetected = hasManifestDrift(currentComponents, desiredComponents);
       if (driftDetected) {
-        issues.push("slot manifests drifted");
+        issues.push("component manifest drifted");
       }
-      const generationIssues = validateGeneratedSlotImports(iuiRoot2);
-      const assetBoundIssues = validateGeneratedAssetBoundImports(iuiRoot2);
-      const integrityIssues = [...generationIssues, ...assetBoundIssues];
+      const staleSlotOutput = findStaleComponentSlotOutput(
+        iuiRoot2,
+        registeredPackageDirs(iuiRoot2)
+      );
+      const integrityIssues = staleSlotOutput.map(
+        (file) => `stale component-slot output: ${path20.relative(iuiRoot2, file) || file}`
+      );
       if (shouldSkipWritesFastPath({
         mode,
         previousState,
@@ -6146,8 +5371,8 @@ async function ensureSlotRegistry(options = {}) {
       if (mode === "validate") {
         if (integrityIssues.length > 0) {
           throw new CLIError(
-            "Slot registry integrity check failed.",
-            integrityIssues.map((issue) => `- ${issue}`).join("\n")
+            "Stale component-slot files from an older iui version were found.",
+            "Run iui doctor --fix (or iui update) to regenerate .iui/generated and remove them."
           );
         }
         return {
@@ -6170,32 +5395,32 @@ async function ensureSlotRegistry(options = {}) {
       writeState(iuiRoot2, state);
       updateState(iuiRoot2, state, "state-loaded");
       await retry(() => {
-        writeComponentManifest(desired.components, iuiRoot2);
+        writeComponentManifest(desiredComponents, iuiRoot2);
         writePackageManifest(currentPackages, iuiRoot2);
-        writeSlotManifest(desired.slots, iuiRoot2);
       });
       let next = updateState(iuiRoot2, state, "manifests-written", {
         checksum,
         repairedIssues: issues
       });
       await retry(async () => {
-        writeComponentSlotFiles(iuiRoot2);
         writeAssetsConfig(iuiRoot2);
         ensureProjectConfig(iuiRoot2);
-        await writeAssetBoundFiles(iuiRoot2);
-        writeSlotHelperFile(iuiRoot2);
         if (projectHasViteTooling(cwd)) {
           ensureInventiveUiViteConfig(cwd);
         }
       });
       bootstrapRegisteredPackages(iuiRoot2);
-      next = updateState(iuiRoot2, next, "slot-files-written", { repairedIssues: issues });
-      if (integrityIssues.length > 0) {
+      next = updateState(iuiRoot2, next, "generated-files-written", { repairedIssues: issues });
+      const leftover = findStaleComponentSlotOutput(iuiRoot2, registeredPackageDirs(iuiRoot2));
+      if (leftover.length > 0) {
         throw new CLIError(
-          "Slot registry integrity check failed.",
-          integrityIssues.map((issue) => `- ${issue}`).join("\n")
+          "Could not remove stale component-slot output.",
+          leftover.map((file) => `- ${path20.relative(iuiRoot2, file) || file}`).join("\n")
         );
       }
+      if (integrityIssues.length > 0) {
+        issues.push(...integrityIssues.map((issue) => `removed ${issue}`));
+      }
       next = updateState(iuiRoot2, next, "integrity-verified", { repairedIssues: issues });
       updateState(iuiRoot2, next, "complete", {
         status: "complete",
@@ -6204,7 +5429,7 @@ async function ensureSlotRegistry(options = {}) {
         repairedIssues: issues
       });
       if (!options.quiet && issues.length > 0) {
-        ok("Slot registry repaired");
+        ok("Project registry repaired");
       }
       return {
         status: issues.length > 0 ? "repaired" : "valid",
@@ -6212,7 +5437,7 @@ async function ensureSlotRegistry(options = {}) {
         repairedIssues: issues
       };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Slot registry update failed";
+      const message = error instanceof Error ? error.message : "Project registry update failed";
       if (state) {
         updateState(iuiRoot2, state, "state-loaded", {
           status: "failed",
@@ -6286,15 +5511,15 @@ async function installComponentsPackage(opts) {
     mode: "repair"
   });
   if (result.status === "skipped") {
-    warn("Component slot registry was not generated.");
+    warn("Component registry was not generated.");
     hint(
       "Run iui init in this package (or iui doctor). Hoisted node_modules are supported \u2014 a root-level install is not required."
     );
   } else {
     ok(
-      result.status === "repaired" ? `Component slots repaired for ${COMPONENTS_PACKAGE} ${dim(`v${pkgVersion}`)}` : `Component slots ready for ${COMPONENTS_PACKAGE} ${dim(`v${pkgVersion}`)}`
+      result.status === "repaired" ? `Components registry repaired for ${COMPONENTS_PACKAGE} ${dim(`v${pkgVersion}`)}` : `Components ready for ${COMPONENTS_PACKAGE} ${dim(`v${pkgVersion}`)}`
     );
-    hint('Import components from "@inventive-ui/components"; slots are available automatically.');
+    hint('Import components from "@inventive-ui/components".');
   }
   return { previousVersion, version: pkgVersion };
 }
@@ -6367,7 +5592,7 @@ async function initCommand(opts) {
   try {
     heading("Initialize Project");
     const existingIuiRoot = findIuiProjectRoot(invocationCwd);
-    if (existingIuiRoot && path23.resolve(existingIuiRoot) !== path23.resolve(invocationCwd)) {
+    if (existingIuiRoot && path21.resolve(existingIuiRoot) !== path21.resolve(invocationCwd)) {
       await bootstrapWorkspacePackage(invocationCwd, existingIuiRoot);
       return;
     }
@@ -6386,10 +5611,10 @@ async function initCommand(opts) {
       return;
     }
     const originalCwd = process.cwd();
-    if (path23.resolve(initRoot) !== path23.resolve(originalCwd)) {
+    if (path21.resolve(initRoot) !== path21.resolve(originalCwd)) {
       process.chdir(initRoot);
       hint(
-        `Monorepo --workspace: initializing at ${path23.relative(invocationCwd, initRoot) || initRoot}`
+        `Monorepo --workspace: initializing at ${path21.relative(invocationCwd, initRoot) || initRoot}`
       );
     } else if (!sharedWorkspace && findIuiProjectRoot(initRoot) === null) {
       hint("Initializing this package only \u2014 other monorepo apps are untouched.");
@@ -6450,7 +5675,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 +5739,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 +6497,17 @@ async function deployTokenRevokeCommand(tokenId) {
 }
 
 // src/commands/setup.ts
-import path26 from "path";
-import fs20 from "fs-extra";
+import path24 from "path";
+import fs18 from "fs-extra";
 import ora6 from "ora";
 
 // src/commands/doctor.ts
-import path25 from "path";
+import path23 from "path";
 
 // src/services/health.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import path24 from "path";
-import fs19 from "fs-extra";
+import path22 from "path";
+import fs17 from "fs-extra";
 function installDevTypeScript(cwd) {
   const pm = detectPackageManager(cwd);
   try {
@@ -7310,23 +6535,24 @@ function checkPackageCompatibility(cwd = process.cwd()) {
     summary: `Core packages installed (framework ${frameworkVersion}, components ${componentsVersion})`
   };
 }
-function checkGeneratedSlotValidity(cwd = process.cwd()) {
-  const issues = validateGeneratedSlotImports(cwd);
-  if (issues.length > 0) {
+function checkStaleComponentSlotOutput(cwd = process.cwd()) {
+  const iuiRoot2 = resolveIuiProjectRoot(cwd);
+  const stale = findStaleComponentSlotOutput(iuiRoot2, [cwd]);
+  if (stale.length > 0) {
     return {
       ok: false,
-      summary: "Managed slot imports are invalid",
-      details: issues.map((i) => `- ${i}`).join("\n")
+      summary: `${stale.length} stale component-slot file${stale.length === 1 ? "" : "s"} from an older iui version`,
+      details: stale.slice(0, 8).map((file) => `- ${path22.relative(iuiRoot2, file) || file}`).join("\n")
     };
   }
   return {
     ok: true,
-    summary: "Managed slot imports are valid"
+    summary: "No stale component-slot output"
   };
 }
 function checkComponentConfigValidity(cwd = process.cwd(), options = {}) {
-  const configPath = path24.join(cwd, COMPONENT_CONFIG_FILE);
-  if (!fs19.existsSync(configPath)) {
+  const configPath = path22.join(cwd, COMPONENT_CONFIG_FILE);
+  if (!fs17.existsSync(configPath)) {
     return {
       ok: false,
       summary: "component.config.ts not found",
@@ -7334,8 +6560,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 ? path22.join(tsPkgDir, "bin", "tsc") : path22.join(cwd, "node_modules", "typescript", "bin", "tsc");
+  if (!fs17.existsSync(tscPath)) {
     if (!options.autoFix) {
       return {
         ok: false,
@@ -7403,33 +6629,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 = path22.join(
+    cwd,
+    fs17.existsSync(path22.join(cwd, PROJECT_CONFIG_FILE)) || !fs17.existsSync(path22.join(cwd, "iui.config.ts")) ? PROJECT_CONFIG_FILE : "iui.config.ts"
+  );
+  if (fs17.existsSync(configPath)) {
+    const configContent = fs17.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) => path22.join(cwd, name)).find((p) => fs17.existsSync(p));
     if (!vitePath) {
       warnings.push("Vite tooling detected but no vite.config.* found");
     } else {
-      const viteContent = fs19.readFileSync(vitePath, "utf-8");
+      const viteContent = fs17.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 +6672,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) => path22.join(cwd, name)).find((p) => fs17.existsSync(p));
     if (!webpackPath) {
       warnings.push("Webpack tooling detected but no webpack.config.* found");
     } else {
-      const webpackContent = fs19.readFileSync(webpackPath, "utf-8");
+      const webpackContent = fs17.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 +6686,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) => path22.join(cwd, name)).find((p) => fs17.existsSync(p));
     if (!nextPath) {
       warnings.push("Next.js detected but no next.config.* found");
     } else {
-      const nextContent = fs19.readFileSync(nextPath, "utf-8");
+      const nextContent = fs17.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 +6703,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) => path22.join(cwd, rel));
+    const readableLayouts = layoutCandidates.filter((file) => fs17.existsSync(file));
     const hasRegistry = readableLayouts.some((file) => {
       try {
-        return /\bIUIRegistry\b/.test(fs19.readFileSync(file, "utf-8"));
+        return /\bIUIRegistry\b/.test(fs17.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
     });
     const hasBootstrapImport = readableLayouts.some((file) => {
       try {
-        const content = fs19.readFileSync(file, "utf-8");
+        const content = fs17.readFileSync(file, "utf-8");
         return /next\/bootstrap/.test(content) || /["']iui-bootstrap["']/.test(content) || /iui\/bootstrap/.test(content);
       } catch {
         return false;
@@ -7493,7 +6722,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(fs17.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
@@ -7524,14 +6753,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) => path22.join(cwd, rel));
   for (const file of entryCandidates) {
-    if (!fs19.existsSync(file)) continue;
+    if (!fs17.existsSync(file)) continue;
     try {
-      const content = fs19.readFileSync(file, "utf-8");
+      const content = fs17.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 (${path22.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 +6780,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 = path22.join(cwd, ".gitignore");
+  if (fs17.existsSync(giPath)) {
+    const gi = fs17.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 +6793,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 = path22.join(cwd, IUI_DIR);
+  const projectPath = path22.join(iuiPath, "project.json");
+  if (fs17.existsSync(projectPath)) {
     try {
-      const meta = fs19.readJsonSync(projectPath);
+      const meta = fs17.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 +6806,15 @@ function checkMetadataPortability(cwd = process.cwd()) {
     } catch {
     }
   }
-  const workspacePath = path24.join(iuiPath, "workspace.json");
-  if (fs19.existsSync(workspacePath)) {
+  const workspacePath = path22.join(iuiPath, "workspace.json");
+  if (fs17.existsSync(workspacePath)) {
     try {
-      const ws = fs19.readJsonSync(workspacePath);
+      const ws = fs17.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) || path22.isAbsolute(pkg)) {
           warnings.push(`workspace.json packages entry is absolute: ${pkg}`);
           hints.push("packages should be relative paths from the IUI root");
         }
@@ -7594,9 +6823,9 @@ function checkMetadataPortability(cwd = process.cwd()) {
     }
   }
   const scanCachePath = iuiCacheFile(cwd, "scan");
-  if (fs19.existsSync(scanCachePath)) {
+  if (fs17.existsSync(scanCachePath)) {
     try {
-      const cache = fs19.readJsonSync(scanCachePath);
+      const cache = fs17.readJsonSync(scanCachePath);
       const absoluteKeys = Object.keys(cache.files ?? {}).filter(
         (key) => /^[A-Za-z]:[\\/]/.test(key) || key.startsWith("/") && !key.startsWith("//")
       );
@@ -7613,38 +6842,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 = path22.join(cwd, ASSETS_CONFIG_FILE);
+  if (!fs17.existsSync(assetsPath)) {
+    return { ok: true, summary: "Asset check skipped (no assets.config.json)" };
   }
   let assets2;
   try {
-    assets2 = fs19.readJsonSync(assetsPath);
+    assets2 = fs17.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 = path22.join(cwd, "node_modules", "@inventive-ui");
+  const frameworkPkg = path22.join(packagesDir, "framework", "package.json");
+  if (fs17.existsSync(frameworkPkg)) {
+    const framework = fs17.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 = path22.join(packagesDir, pkg, "dist", "icons");
+  if (!fs17.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]) => !fs17.existsSync(path22.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 = path22.join(cwd, "src", "iui", "bootstrap.ts");
+  if (!fs17.existsSync(generatedPath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs19.existsSync(generatedPath)) {
+      if (fs17.existsSync(generatedPath)) {
         return { ok: true, summary: "Generated bootstrap artifacts repaired" };
       }
     }
@@ -7654,10 +6915,10 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
       details: "Expected .iui/generated/bootstrap.generated.tsx \u2014 run iui doctor --fix."
     };
   }
-  if (!fs19.existsSync(bridgePath)) {
+  if (!fs17.existsSync(bridgePath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs19.existsSync(bridgePath)) {
+      if (fs17.existsSync(bridgePath)) {
         return { ok: true, summary: "Bootstrap bridge repaired" };
       }
     }
@@ -7670,8 +6931,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 = path22.resolve(iuiRoot2, rel.replace(/^\.\//, ""));
+    if (!fs17.existsSync(abs)) missing.push(`${key}: ${rel}`);
   }
   if (missing.length > 0) {
     return {
@@ -7681,8 +6942,11 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
     };
   }
   const expected = expectedBootstrapImportPaths(iuiRoot2);
-  const generated = fs19.readFileSync(generatedPath, "utf8");
+  const generated = fs17.readFileSync(generatedPath, "utf8");
   const stale = [];
+  if (/["']\.\/slot\.generated["']|@inventive-ui\/framework\/slots/.test(generated)) {
+    stale.push("bootstrap still imports removed component-slot output");
+  }
   for (const [key, importPath] of Object.entries(expected)) {
     if (!generated.includes(`"${importPath}"`)) {
       stale.push(`${key} import should be "${importPath}"`);
@@ -7691,11 +6955,11 @@ 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 = fs17.readFileSync(bootstrapGeneratedPath(iuiRoot2), "utf8");
       const stillStale = Object.entries(expected).filter(
         ([, importPath]) => !refreshed.includes(`"${importPath}"`)
       );
-      if (stillStale.length === 0) {
+      if (stillStale.length === 0 && !/slot\.generated/.test(refreshed)) {
         return { ok: true, summary: "Generated bootstrap refreshed from project.json" };
       }
     }
@@ -7709,6 +6973,24 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
 }
 
 // src/commands/doctor.ts
+function repairStaleSlotOutput(targetCwd) {
+  if (!isInsideProject(targetCwd)) return;
+  writeProjectBootstrapArtifacts(targetCwd, resolveIuiProjectRoot(targetCwd));
+}
+function reportStaleSlotOutput(targetCwd, pass, fail2) {
+  const staleSlots = checkStaleComponentSlotOutput(targetCwd);
+  if (staleSlots.ok) {
+    pass(staleSlots.summary);
+    return;
+  }
+  fail2(staleSlots.summary);
+  if (staleSlots.details) {
+    for (const line of staleSlots.details.split("\n")) {
+      hint(line);
+    }
+  }
+  hint("Fix: run iui doctor --fix to remove it and regenerate bootstrap");
+}
 async function runConfigTierDiagnostics(targetCwd, opts, counters, options = {}) {
   const pass = (label) => {
     checkPass(label);
@@ -7719,7 +7001,7 @@ async function runConfigTierDiagnostics(targetCwd, opts, counters, options = {})
     counters.failed++;
   };
   const includePackageJson = options.includePackageJson !== false;
-  const includeSlotCheck = options.includeSlotCheck === true;
+  const includeStaleSlotCheck = options.includeStaleSlotCheck === true;
   if (includePackageJson) {
     if (hasPackageJson(targetCwd)) pass("package.json found");
     else fail2("package.json missing");
@@ -7734,20 +7016,10 @@ async function runConfigTierDiagnostics(targetCwd, opts, counters, options = {})
     }
     ensureComponentConfig(readComponentPackageManifest(targetCwd), targetCwd);
     await ensureSlotRegistry({ cwd: targetCwd, quiet: true, mode: "repair" });
+    repairStaleSlotOutput(targetCwd);
   }
-  if (includeSlotCheck && isInsideProject(targetCwd) && getInstalledPackageVersion(COMPONENTS_PACKAGE, targetCwd)) {
-    const slotValidity = checkGeneratedSlotValidity(targetCwd);
-    if (slotValidity.ok) {
-      pass(slotValidity.summary);
-    } else {
-      fail2(slotValidity.summary);
-      if (slotValidity.details) {
-        for (const line of slotValidity.details.split("\n")) {
-          hint(line);
-        }
-      }
-      hint("Fix: reinstall @inventive-ui/components and rerun iui doctor");
-    }
+  if (includeStaleSlotCheck && isInsideProject(targetCwd)) {
+    reportStaleSlotOutput(targetCwd, pass, fail2);
   }
   const configValidity = checkComponentConfigValidity(targetCwd, {
     autoFix: opts?.fix === true
@@ -7817,12 +7089,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) {
@@ -7837,7 +7109,7 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
   if (opts?.configOnly) {
     await runConfigTierDiagnostics(targetCwd, opts, counters, {
       includePackageJson: true,
-      includeSlotCheck: true
+      includeStaleSlotCheck: true
     });
     return;
   }
@@ -7852,6 +7124,7 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
     }
     ensureComponentConfig(readComponentPackageManifest(targetCwd), targetCwd);
     await ensureSlotRegistry({ cwd: targetCwd, quiet: true, mode: "repair" });
+    repairStaleSlotOutput(targetCwd);
   }
   if (isInsideProject(targetCwd)) {
     pass("Inventive UI project initialized");
@@ -7899,9 +7172,6 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
   const packages = readPackageManifest(targetCwd);
   const pkgCount = Object.keys(packages).length;
   pass(`${pkgCount} asset package${pkgCount !== 1 ? "s" : ""} installed`);
-  const slots = readSlotManifest(targetCwd);
-  const slotCount = Object.keys(slots).length;
-  pass(`${slotCount} slot${slotCount !== 1 ? "s" : ""} registered`);
   const compatibility = checkPackageCompatibility(targetCwd);
   if (compatibility.ok) {
     pass(compatibility.summary);
@@ -7942,18 +7212,7 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
       pass("Inventive UI packages are on the latest version");
     }
   }
-  const slotValidity = checkGeneratedSlotValidity(targetCwd);
-  if (slotValidity.ok) {
-    pass(slotValidity.summary);
-  } else {
-    fail2(slotValidity.summary);
-    if (slotValidity.details) {
-      for (const line of slotValidity.details.split("\n")) {
-        hint(line);
-      }
-    }
-    hint("Fix: reinstall @inventive-ui/components and rerun iui doctor");
-  }
+  reportStaleSlotOutput(targetCwd, pass, fail2);
   const bootstrapSync = checkBootstrapSync(targetCwd, {
     autoFix: opts?.fix === true
   });
@@ -7972,13 +7231,13 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
   }
   await runConfigTierDiagnostics(targetCwd, opts, counters, {
     includePackageJson: false,
-    includeSlotCheck: false
+    includeStaleSlotCheck: false
   });
 }
 async function doctorCommand(opts) {
   try {
     const invocationCwd = process.cwd();
-    const targets = opts?.cwd ? [path25.resolve(opts.cwd)] : resolveSetupDoctorTargets(invocationCwd);
+    const targets = opts?.cwd ? [path23.resolve(opts.cwd)] : resolveSetupDoctorTargets(invocationCwd);
     const installRoot = resolveDependencyInstallRoot(invocationCwd);
     const multiPackage = targets.length > 1;
     heading("Diagnostics");
@@ -8021,7 +7280,7 @@ async function doctorCommand(opts) {
     for (const targetCwd of targets) {
       if (multiPackage) {
         newline();
-        const label = path25.relative(installRoot, targetCwd) || path25.basename(targetCwd);
+        const label = path23.relative(installRoot, targetCwd) || path23.basename(targetCwd);
         kv("Package", label);
       }
       await runPackageDiagnostics(targetCwd, opts, counters);
@@ -8034,7 +7293,7 @@ async function doctorCommand(opts) {
     } else {
       fail(`${counters.failed} issue${counters.failed > 1 ? "s" : ""} found`);
       hint("Resolve the issues above and re-run iui doctor");
-      hint("Checklist: compatibility, managed slots, config validity, required types");
+      hint("Checklist: compatibility, generated bootstrap, config validity, required types");
       if (!opts?.fix) {
         hint("Use iui doctor --fix to apply safe automatic repairs");
       }
@@ -8049,9 +7308,9 @@ async function doctorCommand(opts) {
 
 // src/commands/setup.ts
 function detectDevScript(cwd) {
-  const pkgPath = path26.join(cwd, "package.json");
+  const pkgPath = path24.join(cwd, "package.json");
   try {
-    const pkg = fs20.readJsonSync(pkgPath);
+    const pkg = fs18.readJsonSync(pkgPath);
     if (pkg.scripts?.dev) return "npm run dev";
     if (pkg.scripts?.start) return "npm run start";
   } catch {
@@ -8060,8 +7319,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 = path24.relative(installRoot, packageDir);
+  return rel && rel !== "." ? rel : path24.basename(packageDir);
 }
 async function setupCommand(opts) {
   try {
@@ -8070,7 +7329,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 && path24.resolve(installRoot) !== path24.resolve(cwd);
     if (!hasPackageJson(cwd) && !hasPackageJson(installRoot)) {
       throw new CLIError(
         "No package.json found in the current directory.",
@@ -8104,7 +7363,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 = path24.relative(cwd, installRoot) || ".";
       kv("Install directory", rel === ".." || rel.includes("..") ? installRoot : rel);
     }
     const installCmd2 = syncInstallCommand(pm);
@@ -8118,7 +7377,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 = path24.resolve(installRoot) === path24.resolve(cwd) ? installCmd2 : `cd ${JSON.stringify(installRoot)} && ${installCmd2}`;
       throw new CLIError(
         detail ? `Could not install project dependencies.
 ${detail}` : "Could not install project dependencies.",
@@ -8245,23 +7504,6 @@ async function listCommand(opts) {
       newline();
       info(`${pkgKeys.length} asset package${pkgKeys.length !== 1 ? "s" : ""} installed`);
     }
-    heading("Slot Registry");
-    const slots = readSlotManifest();
-    const slotKeys = Object.keys(slots);
-    if (slotKeys.length === 0) {
-      info("No component slots available yet.");
-    } else {
-      for (const [key, record] of Object.entries(slots)) {
-        const displayName = itemsLookup[key]?.title ?? key;
-        const slotInfo = record.supportedSlots?.length ? `${record.slotType} \xB7 slots: ${record.supportedSlots.join(", ")}` : `${record.slotType}`;
-        bulletItem(
-          displayName.padEnd(26),
-          `${slotInfo} \xB7 v${record.version}`
-        );
-      }
-      newline();
-      info(`${slotKeys.length} slot${slotKeys.length !== 1 ? "s" : ""} registered`);
-    }
     newline();
   } catch (error) {
     handleError(error);
@@ -8276,7 +7518,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.12" : "unknown";
     const latestCliVersion = await fetchLatestCliVersion(auth.token);
     const cliUpdateAvailable = latestCliVersion !== null && isVersionGreater(latestCliVersion, currentCliVersion);
     if (latestCliVersion && cliUpdateAvailable) {
@@ -8558,7 +7800,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.12" : "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 +7883,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 +7898,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(path25.resolve(globalOpts.cwd));
   }
   if (isInsideProject()) {
     try {
@@ -8670,14 +7912,14 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         mode: slotPolicy.mode
       });
       if (result.status === "repaired") {
-        info("Slot registry repaired");
+        info("Project registry repaired");
       }
     } catch (error) {
       if (error instanceof CLIError) {
         warn(error.message);
         if (error.hint) hint(error.hint);
       } else {
-        warn("Slot registry validation failed; run iui doctor for diagnostics.");
+        warn("Project registry validation failed; run iui doctor for diagnostics.");
       }
     }
   }