inventive-ui 0.0.11 → 0.0.12

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path26 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.11" : "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 path27 = parsed.pathname.replace(/\/+$/, "");
-    if (path27 && !/^\/[a-zA-Z0-9._/-]+$/.test(path27)) {
+    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"
@@ -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";
@@ -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();
@@ -2443,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.");
@@ -2704,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;
@@ -3365,13 +3318,13 @@ function ensureInventiveUiViteConfig(cwd = process.cwd()) {
 }
 
 // src/services/auth.ts
-async function api(path27, opts) {
-  const res = await fetch(`${API_BASE_URL}${path27}`, {
+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 ${path27}`);
+  throwIfRateLimited(res, `calling ${path26}`);
   if (!res.ok) {
     const body = await res.text().catch(() => "");
     throw new CLIError(`API error ${res.status}: ${body || res.statusText}`);
@@ -3823,7 +3776,7 @@ async function promptText(title, hint2, placeholder, validate) {
 }
 
 // src/commands/init.ts
-import path22 from "path";
+import path21 from "path";
 import ora3 from "ora";
 
 // src/services/license.ts
@@ -4790,8 +4743,8 @@ function getMajorFromVersion(version) {
 import ora2 from "ora";
 
 // src/services/slot-registry.ts
-import fs17 from "fs-extra";
-import path21 from "path";
+import fs16 from "fs-extra";
+import path20 from "path";
 
 // src/services/registry-lock.ts
 import fs11 from "fs";
@@ -4877,113 +4830,107 @@ async function withRegistryLock(cwd, operation) {
   }
 }
 
-// src/services/slots.ts
-import fs14 from "fs-extra";
-import path18 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);
@@ -4997,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");
@@ -5009,348 +4956,13 @@ function safeWriteFile(filePath, content) {
   atomicWriteFile(filePath, content);
 }
 
-// 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");
-}
-
-// 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 path18.join(cwd, "src", "iui", "slot.tsx");
-}
-function cleanupLegacySourceSlotFiles(cwd) {
-  const legacySlotsDir = path18.join(cwd, "src", "iui", "slots");
-  if (!fs14.existsSync(legacySlotsDir)) return;
-  try {
-    const files = fs14.readdirSync(legacySlotsDir);
-    for (const file of files) {
-      if (file.endsWith(".slot.tsx")) {
-        fs14.removeSync(path18.join(legacySlotsDir, file));
-      }
-    }
-    const remaining = fs14.readdirSync(legacySlotsDir);
-    if (remaining.length === 0) {
-      fs14.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 (fs14.existsSync(slotsDir)) {
-      const existingSlots2 = fs14.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx"));
-      for (const file of existingSlots2) {
-        try {
-          fs14.removeSync(path18.join(slotsDir, file));
-        } catch {
-        }
-      }
-    }
-    return;
-  }
-  fs14.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 (fs14.existsSync(outPath)) fs14.removeSync(outPath);
-      continue;
-    }
-    safeWriteFile(
-      outPath,
-      renderGroupedSlotFileContent(group.emitters, {
-        prefetch: group.fileName === SLOT_GROUP_CORE_FILE
-      })
-    );
-  }
-  const existingSlots = fs14.existsSync(slotsDir) ? fs14.readdirSync(slotsDir).filter((f) => f.endsWith(".slot.tsx") || f.endsWith(".generated.tsx")) : [];
-  for (const file of existingSlots) {
-    if (file === SLOT_GROUP_CORE_FILE || file === SLOT_GROUP_OPTIONAL_FILE) continue;
-    if (file.endsWith(".slot.tsx")) {
-      try {
-        fs14.removeSync(path18.join(slotsDir, file));
-      } catch {
-      }
-      continue;
-    }
-    if (file.endsWith(".generated.tsx")) {
-      try {
-        fs14.removeSync(path18.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 = path18.join(generatedSlotsDir(cwd), SLOT_GROUP_CORE_FILE);
-  const optionalSlotsPath = path18.join(generatedSlotsDir(cwd), SLOT_GROUP_OPTIONAL_FILE);
-  if (fs14.existsSync(coreSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_CORE_FILE.replace(/\.tsx$/, "")}";`);
-  if (fs14.existsSync(optionalSlotsPath)) slotImports.push(`import "./slots/${SLOT_GROUP_OPTIONAL_FILE.replace(/\.tsx$/, "")}";`);
-  const componentSlotImports = slotImports.join("\n");
-  const outDir = generatedIuiDir(cwd);
-  fs14.ensureDirSync(outDir);
-  const outPath = path18.join(outDir, "slot.generated.tsx");
-  const sections = [
-    `// Managed by iui. Do not edit manually.`,
-    `// Rebuilt automatically when the CLI validates the project.`
-  ];
-  if (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 = path18.join(iuiRoot2, ".iui", "generated", "slot.generated.tsx");
-  const importBase = relativeImportPath(path18.dirname(bridgePath), generatedFile);
-  fs14.ensureDirSync(path18.dirname(bridgePath));
-  if (fs14.existsSync(bridgePath)) {
-    const existing = fs14.readFileSync(bridgePath, "utf-8");
-    if (existing.length > 0 && !/@iui-managed/.test(existing)) {
-      return;
-    }
-  }
-  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 path20 from "path";
-import fs16 from "fs-extra";
-
 // src/services/bootstrap.ts
-import fs15 from "fs-extra";
-import path19 from "path";
 var BOOTSTRAP_GENERATED_FILE = "bootstrap.generated.tsx";
 function bridgeBootstrapFilePath(cwd) {
-  return path19.join(cwd, "src", "iui", "bootstrap.ts");
+  return path18.join(cwd, "src", "iui", "bootstrap.ts");
 }
 function bootstrapGeneratedPath(cwd = process.cwd()) {
-  return path19.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
+  return path18.join(generatedIuiDir(cwd), BOOTSTRAP_GENERATED_FILE);
 }
 function resolveProjectConfigPaths(cwd) {
   const meta = readProjectMeta(cwd);
@@ -5365,8 +4977,8 @@ function resolveProjectConfigPaths(cwd) {
   };
 }
 function configImportFromGenerated(cwd, configRel) {
-  const generatedDir = path19.dirname(bootstrapGeneratedPath(cwd));
-  const abs = path19.resolve(cwd, configRel.replace(/^\.\//, ""));
+  const generatedDir = path18.dirname(bootstrapGeneratedPath(cwd));
+  const abs = path18.resolve(cwd, configRel.replace(/^\.\//, ""));
   return relativeImportPath(generatedDir, abs);
 }
 function expectedBootstrapImportPaths(cwd) {
@@ -5379,7 +4991,7 @@ function expectedBootstrapImportPaths(cwd) {
 }
 function writeBootstrapGenerated(cwd = process.cwd()) {
   const outPath = bootstrapGeneratedPath(cwd);
-  fs15.ensureDirSync(path19.dirname(outPath));
+  fs14.ensureDirSync(path18.dirname(outPath));
   const imports = expectedBootstrapImportPaths(cwd);
   const content = `// @iui-managed
 
@@ -5411,10 +5023,6 @@ import type { IUIAssetsConfig } from "@inventive-ui/framework/config";
 
 
 
-import "./slot.generated";
-
-
-
 const themeConfig = (theme as { default?: typeof theme }).default ?? theme;
 
 
@@ -5453,10 +5061,10 @@ export { projectComponentConfig as componentConfig };
 function writeBootstrapBridge(packageDir, iuiRoot2) {
   const bridgePath = bridgeBootstrapFilePath(packageDir);
   const generatedFile = bootstrapGeneratedPath(iuiRoot2);
-  const importBase = relativeImportPath(path19.dirname(bridgePath), generatedFile);
-  fs15.ensureDirSync(path19.dirname(bridgePath));
-  if (fs15.existsSync(bridgePath)) {
-    const existing = fs15.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;
     }
@@ -5477,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 path20.join(iuiRoot2, IUI_DIR, "workspace.json");
+  return path19.join(iuiRoot2, IUI_DIR, "workspace.json");
 }
 function readWorkspaceManifest(iuiRoot2) {
   const p = workspaceManifestPath(iuiRoot2);
-  if (!fs16.existsSync(p)) return null;
+  if (!fs15.existsSync(p)) return null;
   try {
-    const raw = fs16.readJsonSync(p);
+    const raw = fs15.readJsonSync(p);
     if (!Array.isArray(raw.packages)) return null;
     return {
       iuiRoot: raw.iuiRoot ?? iuiRoot2,
@@ -5499,40 +5108,45 @@ function readWorkspaceManifest(iuiRoot2) {
   }
 }
 function writeWorkspaceManifest(iuiRoot2, packageDirs) {
-  const unique = [...new Set(packageDirs.map((dir) => path20.resolve(dir)))];
+  const unique = [...new Set(packageDirs.map((dir) => path19.resolve(dir)))];
   atomicWriteJson(workspaceManifestPath(iuiRoot2), {
-    packages: unique.map((dir) => path20.relative(iuiRoot2, dir) || "."),
+    packages: unique.map((dir) => path19.relative(iuiRoot2, dir) || "."),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
 function resolveRegisteredPackageDirs(iuiRoot2) {
-  const resolvedRoot = path20.resolve(iuiRoot2);
+  const resolvedRoot = path19.resolve(iuiRoot2);
   const manifest = readWorkspaceManifest(resolvedRoot);
   if (!manifest) return [resolvedRoot];
   const dirs = manifest.packages.map(
-    (rel) => path20.resolve(resolvedRoot, rel === "." ? "" : rel)
+    (rel) => path19.resolve(resolvedRoot, rel === "." ? "" : rel)
   );
-  if (!dirs.some((dir) => path20.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 = path20.resolve(iuiRoot2);
-  const resolvedPackage = path20.resolve(packageDir);
+  const resolvedRoot = path19.resolve(iuiRoot2);
+  const resolvedPackage = path19.resolve(packageDir);
   const existing = resolveRegisteredPackageDirs(resolvedRoot);
-  if (!existing.some((dir) => path20.resolve(dir) === resolvedPackage)) {
+  if (!existing.some((dir) => path19.resolve(dir) === resolvedPackage)) {
     existing.push(resolvedPackage);
   }
   writeWorkspaceManifest(resolvedRoot, existing);
 }
 function registerAllWorkspacePackages(iuiRoot2) {
-  const resolvedRoot = path20.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(path20.resolve(pkgDir));
+      targets.add(path19.resolve(pkgDir));
     }
   }
   const dirs = [...targets];
@@ -5543,18 +5157,17 @@ function bootstrapRegisteredPackages(iuiRoot2) {
   const resolvedRoot = resolveIuiProjectRoot(iuiRoot2);
   const bootstrapped = [];
   for (const packageDir of resolveRegisteredPackageDirs(resolvedRoot)) {
-    if (!fs16.existsSync(path20.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 = path20.resolve(packageDir);
+  const resolvedPackage = path19.resolve(packageDir);
   const resolvedIuiRoot = resolveIuiProjectRoot(iuiRoot2);
-  if (!fs16.existsSync(path20.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."
@@ -5567,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."
   );
@@ -5579,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 (!fs17.existsSync(filePath)) return;
+  if (!fs16.existsSync(filePath)) return;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   try {
-    fs17.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
+    fs16.moveSync(filePath, `${filePath}.corrupt-${stamp}`, { overwrite: false });
   } catch {
   }
 }
 function readJsonObject(filePath, fallback, issues, label) {
-  if (!fs17.existsSync(filePath)) return fallback;
+  if (!fs16.existsSync(filePath)) return fallback;
   try {
-    const value = fs17.readJsonSync(filePath);
+    const value = fs16.readJsonSync(filePath);
     if (value && typeof value === "object" && !Array.isArray(value)) {
       return value;
     }
@@ -5612,9 +5225,9 @@ function readJsonObject(filePath, fallback, issues, label) {
 }
 function readState(cwd, issues) {
   const filePath = statePath(cwd);
-  if (!fs17.existsSync(filePath)) return null;
+  if (!fs16.existsSync(filePath)) return null;
   try {
-    const raw = fs17.readJsonSync(filePath);
+    const raw = fs16.readJsonSync(filePath);
     if (raw.schemaVersion !== STATE_SCHEMA_VERSION) {
       issues.push("registration state schema was upgraded");
       return null;
@@ -5643,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 {
@@ -5718,7 +5309,7 @@ async function ensureSlotRegistry(options = {}) {
   }
   const iuiRoot2 = resolveIuiProjectRoot(cwd);
   return withRegistryLock(iuiRoot2, async () => {
-    const iuiPath = path21.join(iuiRoot2, IUI_DIR);
+    const iuiPath = path20.join(iuiRoot2, IUI_DIR);
     const issues = [];
     cleanupTempFiles(iuiPath);
     const registry = ensureInstalledManifest(
@@ -5744,35 +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 integrityIssues = validateGeneratedSlotImports(iuiRoot2);
+      const staleSlotOutput = findStaleComponentSlotOutput(
+        iuiRoot2,
+        registeredPackageDirs(iuiRoot2)
+      );
+      const integrityIssues = staleSlotOutput.map(
+        (file) => `stale component-slot output: ${path20.relative(iuiRoot2, file) || file}`
+      );
       if (shouldSkipWritesFastPath({
         mode,
         previousState,
@@ -5790,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 {
@@ -5814,31 +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);
-        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",
@@ -5847,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",
@@ -5855,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",
@@ -5929,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 };
 }
@@ -6010,7 +5592,7 @@ async function initCommand(opts) {
   try {
     heading("Initialize Project");
     const existingIuiRoot = findIuiProjectRoot(invocationCwd);
-    if (existingIuiRoot && path22.resolve(existingIuiRoot) !== path22.resolve(invocationCwd)) {
+    if (existingIuiRoot && path21.resolve(existingIuiRoot) !== path21.resolve(invocationCwd)) {
       await bootstrapWorkspacePackage(invocationCwd, existingIuiRoot);
       return;
     }
@@ -6029,10 +5611,10 @@ async function initCommand(opts) {
       return;
     }
     const originalCwd = process.cwd();
-    if (path22.resolve(initRoot) !== path22.resolve(originalCwd)) {
+    if (path21.resolve(initRoot) !== path21.resolve(originalCwd)) {
       process.chdir(initRoot);
       hint(
-        `Monorepo --workspace: initializing at ${path22.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.");
@@ -6915,17 +6497,17 @@ async function deployTokenRevokeCommand(tokenId) {
 }
 
 // src/commands/setup.ts
-import path25 from "path";
-import fs19 from "fs-extra";
+import path24 from "path";
+import fs18 from "fs-extra";
 import ora6 from "ora";
 
 // src/commands/doctor.ts
-import path24 from "path";
+import path23 from "path";
 
 // src/services/health.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import path23 from "path";
-import fs18 from "fs-extra";
+import path22 from "path";
+import fs17 from "fs-extra";
 function installDevTypeScript(cwd) {
   const pm = detectPackageManager(cwd);
   try {
@@ -6953,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 = path23.join(cwd, COMPONENT_CONFIG_FILE);
-  if (!fs18.existsSync(configPath)) {
+  const configPath = path22.join(cwd, COMPONENT_CONFIG_FILE);
+  if (!fs17.existsSync(configPath)) {
     return {
       ok: false,
       summary: "component.config.ts not found",
@@ -6977,8 +6560,8 @@ function checkComponentConfigValidity(cwd = process.cwd(), options = {}) {
     };
   }
   const tsPkgDir = resolvePackageDir("typescript", cwd);
-  const tscPath = tsPkgDir ? path23.join(tsPkgDir, "bin", "tsc") : path23.join(cwd, "node_modules", "typescript", "bin", "tsc");
-  if (!fs18.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,
@@ -7046,12 +6629,12 @@ ${stderr}`.trim() };
 function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
   const warnings = [];
   const hints = [];
-  const configPath = path23.join(
+  const configPath = path22.join(
     cwd,
-    fs18.existsSync(path23.join(cwd, PROJECT_CONFIG_FILE)) || !fs18.existsSync(path23.join(cwd, "iui.config.ts")) ? PROJECT_CONFIG_FILE : "iui.config.ts"
+    fs17.existsSync(path22.join(cwd, PROJECT_CONFIG_FILE)) || !fs17.existsSync(path22.join(cwd, "iui.config.ts")) ? PROJECT_CONFIG_FILE : "iui.config.ts"
   );
-  if (fs18.existsSync(configPath)) {
-    const configContent = fs18.readFileSync(configPath, "utf-8");
+  if (fs17.existsSync(configPath)) {
+    const configContent = fs17.readFileSync(configPath, "utf-8");
     if (/packageSafelist\s*:\s*false/.test(configContent)) {
       warnings.push(
         "Deprecated theme.config build.packageSafelist \u2014 remove it; Framework always merges IUI package compile contracts"
@@ -7071,11 +6654,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
   }
   if (projectHasViteTooling(cwd)) {
     const viteCandidates = ["vite.config.ts", "vite.config.mjs", "vite.config.js"];
-    const vitePath = viteCandidates.map((name) => path23.join(cwd, name)).find((p) => fs18.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 = fs18.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()]");
@@ -7089,11 +6672,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
       "webpack.config.mjs",
       "webpack.config.ts"
     ];
-    const webpackPath = webpackCandidates.map((name) => path23.join(cwd, name)).find((p) => fs18.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 = fs18.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"');
@@ -7103,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) => path23.join(cwd, name)).find((p) => fs18.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 = fs18.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"');
@@ -7120,18 +6703,18 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
       "src/app/layout.jsx",
       "app/providers.tsx",
       "src/app/providers.tsx"
-    ].map((rel) => path23.join(cwd, rel));
-    const readableLayouts = layoutCandidates.filter((file) => fs18.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(fs18.readFileSync(file, "utf-8"));
+        return /\bIUIRegistry\b/.test(fs17.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
     });
     const hasBootstrapImport = readableLayouts.some((file) => {
       try {
-        const content = fs18.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;
@@ -7139,7 +6722,7 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
     });
     const hasProvider = readableLayouts.some((file) => {
       try {
-        return /\bIUIProvider\b/.test(fs18.readFileSync(file, "utf-8"));
+        return /\bIUIProvider\b/.test(fs17.readFileSync(file, "utf-8"));
       } catch {
         return false;
       }
@@ -7170,14 +6753,14 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
     "src/app/providers.tsx",
     "app/layout.tsx",
     "src/app/layout.tsx"
-  ].map((rel) => path23.join(cwd, rel));
+  ].map((rel) => path22.join(cwd, rel));
   for (const file of entryCandidates) {
-    if (!fs18.existsSync(file)) continue;
+    if (!fs17.existsSync(file)) continue;
     try {
-      const content = fs18.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 (${path23.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"
@@ -7197,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 = path23.join(cwd, ".gitignore");
-  if (fs18.existsSync(giPath)) {
-    const gi = fs18.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");
@@ -7210,11 +6793,11 @@ function checkCompileFirstReadiness(cwd = process.cwd(), _options = {}) {
 function checkMetadataPortability(cwd = process.cwd()) {
   const warnings = [];
   const hints = [];
-  const iuiPath = path23.join(cwd, IUI_DIR);
-  const projectPath = path23.join(iuiPath, "project.json");
-  if (fs18.existsSync(projectPath)) {
+  const iuiPath = path22.join(cwd, IUI_DIR);
+  const projectPath = path22.join(iuiPath, "project.json");
+  if (fs17.existsSync(projectPath)) {
     try {
-      const meta = fs18.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");
@@ -7223,15 +6806,15 @@ function checkMetadataPortability(cwd = process.cwd()) {
     } catch {
     }
   }
-  const workspacePath = path23.join(iuiPath, "workspace.json");
-  if (fs18.existsSync(workspacePath)) {
+  const workspacePath = path22.join(iuiPath, "workspace.json");
+  if (fs17.existsSync(workspacePath)) {
     try {
-      const ws = fs18.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) || path23.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");
         }
@@ -7240,9 +6823,9 @@ function checkMetadataPortability(cwd = process.cwd()) {
     }
   }
   const scanCachePath = iuiCacheFile(cwd, "scan");
-  if (fs18.existsSync(scanCachePath)) {
+  if (fs17.existsSync(scanCachePath)) {
     try {
-      const cache = fs18.readJsonSync(scanCachePath);
+      const cache = fs17.readJsonSync(scanCachePath);
       const absoluteKeys = Object.keys(cache.files ?? {}).filter(
         (key) => /^[A-Za-z]:[\\/]/.test(key) || key.startsWith("/") && !key.startsWith("//")
       );
@@ -7267,20 +6850,20 @@ var ICON_LIBRARY_PACKAGES = {
   phosphor: "icons-phosphor"
 };
 function checkAssetPipeline(cwd = process.cwd()) {
-  const assetsPath = path23.join(cwd, ASSETS_CONFIG_FILE);
-  if (!fs18.existsSync(assetsPath)) {
+  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 = fs18.readJsonSync(assetsPath);
+    assets2 = fs17.readJsonSync(assetsPath);
   } catch {
     return { ok: false, summary: "assets.config.json is not valid JSON" };
   }
-  const packagesDir = path23.join(cwd, "node_modules", "@inventive-ui");
-  const frameworkPkg = path23.join(packagesDir, "framework", "package.json");
-  if (fs18.existsSync(frameworkPkg)) {
-    const framework = fs18.readJsonSync(frameworkPkg);
+  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,
@@ -7292,8 +6875,8 @@ function checkAssetPipeline(cwd = process.cwd()) {
   const library = assets2.icon?.library;
   const pkg = library ? ICON_LIBRARY_PACKAGES[library] : void 0;
   if (!pkg) return { ok: true, summary: "Asset config valid" };
-  const iconsDir = path23.join(packagesDir, pkg, "dist", "icons");
-  if (!fs18.existsSync(iconsDir)) {
+  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`,
@@ -7305,7 +6888,7 @@ function checkAssetPipeline(cwd = process.cwd()) {
     ["placeholder", assets2.icon?.placeholder?.name],
     ["fallback", assets2.icon?.fallback]
   ].filter((entry) => typeof entry[1] === "string" && entry[1].length > 0);
-  const missing = glyphs.filter(([, glyph]) => !fs18.existsSync(path23.join(iconsDir, `${glyph}.js`)));
+  const missing = glyphs.filter(([, glyph]) => !fs17.existsSync(path22.join(iconsDir, `${glyph}.js`)));
   if (missing.length > 0) {
     return {
       ok: false,
@@ -7318,11 +6901,11 @@ function checkAssetPipeline(cwd = process.cwd()) {
 function checkBootstrapSync(cwd = process.cwd(), options = {}) {
   const iuiRoot2 = resolveIuiProjectRoot(cwd);
   const generatedPath = bootstrapGeneratedPath(iuiRoot2);
-  const bridgePath = path23.join(cwd, "src", "iui", "bootstrap.ts");
-  if (!fs18.existsSync(generatedPath)) {
+  const bridgePath = path22.join(cwd, "src", "iui", "bootstrap.ts");
+  if (!fs17.existsSync(generatedPath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs18.existsSync(generatedPath)) {
+      if (fs17.existsSync(generatedPath)) {
         return { ok: true, summary: "Generated bootstrap artifacts repaired" };
       }
     }
@@ -7332,10 +6915,10 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
       details: "Expected .iui/generated/bootstrap.generated.tsx \u2014 run iui doctor --fix."
     };
   }
-  if (!fs18.existsSync(bridgePath)) {
+  if (!fs17.existsSync(bridgePath)) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      if (fs18.existsSync(bridgePath)) {
+      if (fs17.existsSync(bridgePath)) {
         return { ok: true, summary: "Bootstrap bridge repaired" };
       }
     }
@@ -7348,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 = path23.resolve(iuiRoot2, rel.replace(/^\.\//, ""));
-    if (!fs18.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 {
@@ -7359,8 +6942,11 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
     };
   }
   const expected = expectedBootstrapImportPaths(iuiRoot2);
-  const generated = fs18.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}"`);
@@ -7369,11 +6955,11 @@ function checkBootstrapSync(cwd = process.cwd(), options = {}) {
   if (stale.length > 0) {
     if (options.autoFix) {
       writeProjectBootstrapArtifacts(cwd, iuiRoot2);
-      const refreshed = fs18.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" };
       }
     }
@@ -7387,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);
@@ -7397,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");
@@ -7412,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
@@ -7515,7 +7109,7 @@ async function runPackageDiagnostics(targetCwd, opts, counters) {
   if (opts?.configOnly) {
     await runConfigTierDiagnostics(targetCwd, opts, counters, {
       includePackageJson: true,
-      includeSlotCheck: true
+      includeStaleSlotCheck: true
     });
     return;
   }
@@ -7530,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");
@@ -7577,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);
@@ -7620,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
   });
@@ -7650,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 ? [path24.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");
@@ -7699,7 +7280,7 @@ async function doctorCommand(opts) {
     for (const targetCwd of targets) {
       if (multiPackage) {
         newline();
-        const label = path24.relative(installRoot, targetCwd) || path24.basename(targetCwd);
+        const label = path23.relative(installRoot, targetCwd) || path23.basename(targetCwd);
         kv("Package", label);
       }
       await runPackageDiagnostics(targetCwd, opts, counters);
@@ -7712,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");
       }
@@ -7727,9 +7308,9 @@ async function doctorCommand(opts) {
 
 // src/commands/setup.ts
 function detectDevScript(cwd) {
-  const pkgPath = path25.join(cwd, "package.json");
+  const pkgPath = path24.join(cwd, "package.json");
   try {
-    const pkg = fs19.readJsonSync(pkgPath);
+    const pkg = fs18.readJsonSync(pkgPath);
     if (pkg.scripts?.dev) return "npm run dev";
     if (pkg.scripts?.start) return "npm run start";
   } catch {
@@ -7738,8 +7319,8 @@ function detectDevScript(cwd) {
   return null;
 }
 function relativePackageLabel(installRoot, packageDir) {
-  const rel = path25.relative(installRoot, packageDir);
-  return rel && rel !== "." ? rel : path25.basename(packageDir);
+  const rel = path24.relative(installRoot, packageDir);
+  return rel && rel !== "." ? rel : path24.basename(packageDir);
 }
 async function setupCommand(opts) {
   try {
@@ -7748,7 +7329,7 @@ async function setupCommand(opts) {
     const installRoot = resolveDependencyInstallRoot(cwd);
     const workspaceRoot = findWorkspaceRoot(cwd);
     const inMonorepo = workspaceRoot !== null;
-    const installFromChild = inMonorepo && path25.resolve(installRoot) !== path25.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.",
@@ -7782,7 +7363,7 @@ async function setupCommand(opts) {
     for (const w of warnings) warn(w);
     kv("Package manager", `${pm} (${source})`);
     if (installFromChild) {
-      const rel = path25.relative(cwd, installRoot) || ".";
+      const rel = path24.relative(cwd, installRoot) || ".";
       kv("Install directory", rel === ".." || rel.includes("..") ? installRoot : rel);
     }
     const installCmd2 = syncInstallCommand(pm);
@@ -7796,7 +7377,7 @@ async function setupCommand(opts) {
     } catch (err) {
       installSpinner.fail("Dependency install failed");
       const detail = formatExecSyncError(err);
-      const manual = path25.resolve(installRoot) === path25.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.",
@@ -7923,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);
@@ -7954,7 +7518,7 @@ async function updateCommand(opts = {}) {
     const auth = await ensureAuthSession();
     await ensureLicenseSession();
     const inProject = isInsideProject();
-    const currentCliVersion = true ? "0.0.11" : "unknown";
+    const currentCliVersion = true ? "0.0.12" : "unknown";
     const latestCliVersion = await fetchLatestCliVersion(auth.token);
     const cliUpdateAvailable = latestCliVersion !== null && isVersionGreater(latestCliVersion, currentCliVersion);
     if (latestCliVersion && cliUpdateAvailable) {
@@ -8236,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.11" : "1.0.0").option("-C, --cwd <dir>", "Run as if started in the given directory").option("-q, --quiet", "Minimal output (also respects IUI_QUIET=1)").option("--no-color", "Disable ANSI colors");
+program.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);
@@ -8334,7 +7898,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
   const root = topLevelCommandName(actionCommand);
   const globalOpts = program.opts();
   if (globalOpts.cwd) {
-    process.chdir(path26.resolve(globalOpts.cwd));
+    process.chdir(path25.resolve(globalOpts.cwd));
   }
   if (isInsideProject()) {
     try {
@@ -8348,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.");
       }
     }
   }