@fragments-sdk/cli 0.14.3 → 0.15.1

package/dist/{chunk-55KERLWL.js → chunk-HQ6A6DTV.js}

@@ -2,7 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   fragmentsConfigSchema
-} from "./chunk-I34BC3CU.js";
+} from "./chunk-32LIWN2P.js";
 
 // src/core/config.ts
 import { existsSync } from "fs";
@@ -17,7 +17,9 @@ var STORYBOOK_FILTER_DEFAULTS = {
 var DEFAULT_CONFIG = {
   include: [
     `src/**/*${BRAND.fileExtension}`,
-    // *.fragment.tsx files
+    // *.contract.json files (V2 canonical)
+    "src/**/*.fragment.tsx",
+    // Legacy fragment files (still supported)
     "src/**/*.stories.tsx"
     // Storybook stories (auto-converted)
   ],
@@ -80,295 +82,1254 @@ ${errors}`);
   }
 }
 
-// src/core/generators/typescript-extractor.ts
-import ts from "typescript";
-import { readFileSync } from "fs";
-function extractPropsFromFile(filePath) {
-  const sourceText = readFileSync(filePath, "utf-8");
-  return extractPropsFromSource(sourceText, filePath);
+// src/core/discovery.ts
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import fg from "fast-glob";
+function toPascalCase(name) {
+  return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
-function extractPropsFromSource(sourceText, fileName = "component.tsx") {
-  const sourceFile = ts.createSourceFile(
-    fileName,
-    sourceText,
-    ts.ScriptTarget.Latest,
-    true,
-    fileName.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
-  );
-  const result = {
-    componentName: "",
-    props: {},
-    exports: [],
-    imports: []
-  };
-  const propsInterfaces = /* @__PURE__ */ new Map();
-  const componentExports = [];
-  const defaultExports = /* @__PURE__ */ new Set();
-  const importedModules = [];
-  ts.forEachChild(sourceFile, (node) => {
-    if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpecifier)) {
-        importedModules.push(moduleSpecifier.text);
-      }
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      const name = node.name.text;
-      if (name.endsWith("Props")) {
-        propsInterfaces.set(name, node);
-      }
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      const name = node.name.text;
-      if (name.endsWith("Props")) {
-        propsInterfaces.set(name, node);
-      }
-    }
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.ExportKeyword
-      );
-      const hasDefault = node.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.DefaultKeyword
-      );
-      if (hasExport) {
-        componentExports.push(node.name.text);
-        if (hasDefault) {
-          defaultExports.add(node.name.text);
-        }
-      }
+async function extractPascalCaseExports(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const exports = /* @__PURE__ */ new Set();
+    const exportFuncRegex = /export\s+function\s+([A-Z][a-zA-Z0-9]*)/g;
+    let match;
+    while ((match = exportFuncRegex.exec(content)) !== null) {
+      exports.add(match[1]);
     }
-    if (ts.isVariableStatement(node)) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.ExportKeyword
-      );
-      if (hasExport) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts.isIdentifier(decl.name)) {
-            componentExports.push(decl.name.text);
-          }
-        }
-      }
+    const exportConstRegex = /export\s+const\s+([A-Z][a-zA-Z0-9]*)/g;
+    while ((match = exportConstRegex.exec(content)) !== null) {
+      exports.add(match[1]);
     }
-    if (ts.isExportDeclaration(node) && node.exportClause) {
-      if (ts.isNamedExports(node.exportClause)) {
-        for (const element of node.exportClause.elements) {
-          componentExports.push(element.name.text);
+    const exportBlockRegex = /export\s*\{([^}]+)\}/g;
+    while ((match = exportBlockRegex.exec(content)) !== null) {
+      const names = match[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+      for (const name of names) {
+        if (/^[A-Z]/.test(name)) {
+          exports.add(name);
         }
       }
     }
-  });
-  result.exports = componentExports;
-  result.imports = importedModules;
-  const mainComponent = componentExports.find(
-    (name) => /^[A-Z]/.test(name) && !name.endsWith("Props")
-  );
-  if (!mainComponent) {
-    return null;
-  }
-  result.componentName = mainComponent;
-  result.isDefaultExport = defaultExports.has(mainComponent);
-  const propsInterfaceName = `${mainComponent}Props`;
-  const propsInterface = propsInterfaces.get(propsInterfaceName);
-  if (propsInterface) {
-    result.propsInterfaceName = propsInterfaceName;
-    result.props = extractPropsFromInterface(propsInterface, sourceFile);
+    return Array.from(exports);
+  } catch {
+    return [];
   }
-  return result;
 }
-function extractPropsFromInterface(node, sourceFile) {
-  const props = {};
-  if (ts.isInterfaceDeclaration(node)) {
-    for (const member of node.members) {
-      if (ts.isPropertySignature(member) && member.name) {
-        const propName = member.name.getText(sourceFile);
-        const prop = extractPropFromMember(member, sourceFile);
-        if (prop) {
-          props[propName] = prop;
-        }
-      }
-    }
+async function discoverBlockFiles(configDir, exclude) {
+  const patterns = [
+    `**/*${BRAND.blockFileExtension}`,
+    `**/*${BRAND.recipeFileExtension}`
+  ];
+  const files = await fg(patterns, {
+    cwd: configDir,
+    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+var discoverRecipeFiles = discoverBlockFiles;
+async function discoverFragmentFiles(config, configDir) {
+  const defaultExcludes = [
+    "**/*.test.stories.*",
+    "**/*.stories.test.*",
+    "**/*.test.story.*",
+    "**/*.story.test.*"
+  ];
+  const patterns = [
+    ...config.include,
+    "**/*.contract.json"
+  ];
+  const files = await fg(patterns, {
+    cwd: configDir,
+    ignore: [...defaultExcludes, ...config.exclude ?? []],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverComponentFiles(config, configDir) {
+  if (!config.components || config.components.length === 0) {
+    return [];
   }
-  if (ts.isTypeAliasDeclaration(node)) {
-    const typeNode = node.type;
-    if (ts.isTypeLiteralNode(typeNode)) {
-      for (const member of typeNode.members) {
-        if (ts.isPropertySignature(member) && member.name) {
-          const propName = member.name.getText(sourceFile);
-          const prop = extractPropFromMember(member, sourceFile);
-          if (prop) {
-            props[propName] = prop;
-          }
-        }
-      }
-    }
+  const files = await fg(config.components, {
+    cwd: configDir,
+    ignore: [
+      ...config.exclude ?? [],
+      // Exclude fragment files themselves
+      ...config.include,
+      // Exclude test files
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**"
+    ],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+function extractComponentName(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  const fileName = parts[parts.length - 1];
+  if (fileName === "index.tsx" || fileName === "index.ts") {
+    return parts[parts.length - 2] ?? "Unknown";
   }
-  return props;
+  return fileName.replace(/\.(tsx?|jsx?)$/, "");
 }
-function extractPropFromMember(member, sourceFile) {
-  const entry = {};
-  entry.required = !member.questionToken;
-  if (member.type) {
-    const typeInfo = parseTypeNode(member.type, sourceFile);
-    entry.type = typeInfo.type;
-    entry.typeKind = typeInfo.typeKind;
-    if (typeInfo.options) {
-      entry.options = typeInfo.options;
+var DEFAULT_COMPONENT_PATTERNS = [
+  "src/components/**/*.tsx",
+  "src/components/**/index.tsx",
+  "components/**/*.tsx",
+  "lib/components/**/*.tsx",
+  "packages/*/src/components/**/*.tsx"
+];
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*",
+  "**/*.story.*",
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/node_modules/**",
+  "**/dist/**"
+];
+async function discoverComponentsFromSource(configDir, patterns, exclude) {
+  const searchPatterns = patterns && patterns.length > 0 ? patterns : DEFAULT_COMPONENT_PATTERNS;
+  const excludePatterns = [
+    ...DEFAULT_EXCLUDE_PATTERNS,
+    ...exclude ?? []
+  ];
+  const files = await fg(searchPatterns, {
+    cwd: configDir,
+    ignore: excludePatterns,
+    absolute: false
+  });
+  const pascalCaseFiles = [];
+  const lowercaseFiles = [];
+  for (const file of files) {
+    const name = extractComponentName(file);
+    if (/^[A-Z]/.test(name)) {
+      pascalCaseFiles.push(file);
+    } else if (/^[a-z]/.test(name)) {
+      lowercaseFiles.push(file);
     }
   }
-  const jsDocComment = getJSDocComment(member);
-  if (jsDocComment) {
-    entry.description = jsDocComment;
+  const storyPatterns = [
+    "**/*.stories.tsx",
+    "**/*.stories.ts",
+    "**/*.story.tsx",
+    "**/*.story.ts"
+  ];
+  const storyFiles = await fg(storyPatterns, {
+    cwd: configDir,
+    ignore: ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  const storyMap = /* @__PURE__ */ new Map();
+  for (const storyFile of storyFiles) {
+    const name = extractComponentName(storyFile.replace(/\.stories?\.(tsx?|jsx?)$/, ".tsx"));
+    storyMap.set(name, storyFile);
+  }
+  const components = [];
+  for (const file of pascalCaseFiles) {
+    const name = extractComponentName(file);
+    const absolutePath = resolve2(configDir, file);
+    const storyFile = storyMap.get(name);
+    components.push({
+      name,
+      sourcePath: absolutePath,
+      relativePath: file,
+      storyPath: storyFile ? resolve2(configDir, storyFile) : void 0
+    });
   }
-  const defaultValue = getJSDocDefault(member);
-  if (defaultValue !== void 0) {
-    entry.default = defaultValue;
+  for (const file of lowercaseFiles) {
+    const absolutePath = resolve2(configDir, file);
+    const fileName = extractComponentName(file);
+    const pascalName = toPascalCase(fileName);
+    const exports = await extractPascalCaseExports(absolutePath);
+    const primaryExport = exports.find((e) => e === pascalName) || exports[0];
+    if (primaryExport) {
+      const storyFile = storyMap.get(primaryExport) || storyMap.get(fileName);
+      components.push({
+        name: primaryExport,
+        sourcePath: absolutePath,
+        relativePath: file,
+        storyPath: storyFile ? resolve2(configDir, storyFile) : void 0
+      });
+    }
   }
-  return entry;
+  components.sort((a, b) => a.name.localeCompare(b.name));
+  return components;
 }
-function parseTypeNode(typeNode, sourceFile) {
-  if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
-    return { type: "string", typeKind: "string" };
-  }
-  if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
-    return { type: "number", typeKind: "number" };
-  }
-  if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) {
-    return { type: "boolean", typeKind: "boolean" };
+async function discoverComponentsFromBarrel(barrelPath, configDir) {
+  const absoluteBarrelPath = resolve2(configDir, barrelPath);
+  if (!existsSync2(absoluteBarrelPath)) {
+    return [];
   }
-  if (ts.isUnionTypeNode(typeNode)) {
-    const options = [];
-    let allLiterals = true;
-    for (const subType of typeNode.types) {
-      if (ts.isLiteralTypeNode(subType)) {
-        if (ts.isStringLiteral(subType.literal)) {
-          options.push(subType.literal.text);
-        } else if (subType.literal.kind === ts.SyntaxKind.TrueKeyword) {
-          options.push("true");
-        } else if (subType.literal.kind === ts.SyntaxKind.FalseKeyword) {
-          options.push("false");
-        } else {
-          allLiterals = false;
-        }
-      } else {
-        allLiterals = false;
+  const content = await readFile(absoluteBarrelPath, "utf-8");
+  const components = [];
+  const exportRegex = /export\s+(?:\*|{([^}]+)})\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = exportRegex.exec(content)) !== null) {
+    const exportedNames = match[1];
+    const importPath = match[2];
+    const barrelDir = dirname2(absoluteBarrelPath);
+    let resolvedPath = resolve2(barrelDir, importPath);
+    if (!resolvedPath.endsWith(".tsx") && !resolvedPath.endsWith(".ts")) {
+      if (existsSync2(`${resolvedPath}.tsx`)) {
+        resolvedPath = `${resolvedPath}.tsx`;
+      } else if (existsSync2(`${resolvedPath}.ts`)) {
+        resolvedPath = `${resolvedPath}.ts`;
+      } else if (existsSync2(`${resolvedPath}/index.tsx`)) {
+        resolvedPath = `${resolvedPath}/index.tsx`;
+      } else if (existsSync2(`${resolvedPath}/index.ts`)) {
+        resolvedPath = `${resolvedPath}/index.ts`;
       }
     }
-    if (allLiterals && options.length > 0) {
-      return {
-        type: options.map((o) => `"${o}"`).join(" | "),
-        typeKind: "enum",
-        options
-      };
-    }
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "union"
-    };
-  }
-  if (ts.isFunctionTypeNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "function"
-    };
-  }
-  if (ts.isArrayTypeNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "array"
-    };
-  }
-  if (ts.isTypeReferenceNode(typeNode)) {
-    const typeName = typeNode.typeName.getText(sourceFile);
-    if (typeName === "ReactNode" || typeName === "React.ReactNode") {
-      return { type: "ReactNode", typeKind: "node" };
-    }
-    if (typeName === "ReactElement" || typeName === "React.ReactElement") {
-      return { type: "ReactElement", typeKind: "element" };
+    if (!existsSync2(resolvedPath)) {
+      continue;
     }
-    if (typeName === "JSX.Element") {
-      return { type: "JSX.Element", typeKind: "element" };
+    if (exportedNames) {
+      const names = exportedNames.split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+      for (const name of names) {
+        if (/^[A-Z]/.test(name)) {
+          const relativePath = resolvedPath.replace(configDir + "/", "");
+          components.push({
+            name,
+            sourcePath: resolvedPath,
+            relativePath
+          });
+        }
+      }
+    } else {
+      const name = extractComponentName(importPath);
+      if (/^[A-Z]/.test(name)) {
+        const relativePath = resolvedPath.replace(configDir + "/", "");
+        components.push({
+          name,
+          sourcePath: resolvedPath,
+          relativePath
+        });
+      }
     }
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "object"
-    };
-  }
-  if (ts.isTypeLiteralNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "object"
-    };
   }
-  return {
-    type: typeNode.getText(sourceFile),
-    typeKind: "unknown"
-  };
+  return components;
 }
-function getJSDocComment(node) {
-  const jsDocTags = ts.getJSDocTags(node);
-  const jsDoc = node.jsDoc;
-  if (jsDoc && jsDoc.length > 0) {
-    const comment = jsDoc[0].comment;
-    if (typeof comment === "string") {
-      return comment;
-    }
-    if (Array.isArray(comment)) {
-      return comment.map((c) => typeof c === "string" ? c : c.text).join("");
+var DEFAULT_TOKEN_PATTERNS = [
+  "src/**/tokens/**/_variables.scss",
+  "src/**/tokens/**/variables.scss",
+  "src/**/styles/**/variables.scss",
+  "src/**/styles/**/tokens.scss",
+  "src/**/styles/**/variables.css",
+  "src/**/theme/**/_variables.scss",
+  "src/**/theme/**/tokens.css",
+  // DTCG token files
+  "**/*.tokens.json",
+  "**/*.tokens"
+];
+async function discoverTokenFiles(configDir, patterns, exclude) {
+  const searchPatterns = patterns && patterns.length > 0 ? patterns : DEFAULT_TOKEN_PATTERNS;
+  const files = await fg(searchPatterns, {
+    cwd: configDir,
+    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverInstalledFragments(projectRoot) {
+  const pkgJsonPath = resolve2(projectRoot, "package.json");
+  if (!existsSync2(pkgJsonPath)) return [];
+  const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+  const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+  const results = [];
+  for (const depName of Object.keys(allDeps)) {
+    const depDir = resolve2(projectRoot, "node_modules", depName);
+    const depPkgPath = resolve2(depDir, "package.json");
+    if (!existsSync2(depPkgPath)) continue;
+    const depPkg = JSON.parse(await readFile(depPkgPath, "utf-8"));
+    if (!depPkg.fragments) continue;
+    const files = await fg(
+      [`src/**/*${BRAND.fileExtension}`, "src/**/*.stories.tsx"],
+      { cwd: depDir, ignore: ["**/node_modules/**"], absolute: false }
+    );
+    for (const rel of files) {
+      results.push({
+        relativePath: `${depName}/${rel}`,
+        absolutePath: resolve2(depDir, rel)
+      });
     }
   }
-  return void 0;
+  return results;
 }
-function getJSDocDefault(node) {
-  const jsDocTags = ts.getJSDocTags(node);
-  for (const tag of jsDocTags) {
-    if (tag.tagName.text === "default") {
-      const comment = tag.comment;
-      if (typeof comment === "string") {
-        try {
-          return JSON.parse(comment);
-        } catch {
-          return comment;
+async function discoverAllComponents(configDir, options = {}) {
+  const componentsMap = /* @__PURE__ */ new Map();
+  const sourceComponents = await discoverComponentsFromSource(
+    configDir,
+    options.patterns,
+    options.exclude
+  );
+  for (const comp of sourceComponents) {
+    componentsMap.set(comp.name, comp);
+  }
+  if (options.barrelFiles && options.barrelFiles.length > 0) {
+    for (const barrelFile of options.barrelFiles) {
+      const barrelComponents = await discoverComponentsFromBarrel(barrelFile, configDir);
+      for (const comp of barrelComponents) {
+        if (!componentsMap.has(comp.name)) {
+          componentsMap.set(comp.name, comp);
         }
       }
     }
   }
-  return void 0;
+  return Array.from(componentsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
 }
 
-// src/core/generators/registry.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { relative, dirname as dirname2, basename, join } from "path";
-import fg from "fast-glob";
-async function generateRegistry(options) {
-  const {
-    projectRoot,
-    componentPatterns = ["src/**/*.tsx", "src/**/*.ts"],
-    storyPatterns = ["src/**/*.stories.tsx", "src/**/*.stories.ts"],
-    fragmentsDir = join(projectRoot, BRAND.dataDir),
-    registryOptions = {}
-  } = options;
-  const {
-    requireStory = false,
-    publicOnly = false,
-    categoryDepth = 1,
-    includeProps = false,
-    embedFragments = false
-  } = registryOptions;
-  const errors = [];
-  const warnings = [];
-  const storyFiles = await fg(storyPatterns, {
-    cwd: projectRoot,
-    ignore: ["**/node_modules/**"],
-    absolute: true
+// src/core/loader.ts
+import { unlink } from "fs/promises";
+import { dirname as dirname3, basename as basename2, join } from "path";
+import { pathToFileURL } from "url";
+import { build } from "esbuild";
+var DEFINE_FRAGMENT_SHIM = `
+export function defineFragment(def) {
+  return def;
+}
+export function defineBlock(def) {
+  return def;
+}
+export function defineRecipe(def) {
+  return def;
+}
+`;
+function createFragmentsCoreShimPlugin() {
+  return {
+    name: BRAND.vitePluginNamespace,
+    setup(build2) {
+      build2.onResolve({ filter: /^@fragments-sdk\/cli\/core$/ }, (args) => {
+        return {
+          path: args.path,
+          namespace: BRAND.vitePluginNamespace
+        };
+      });
+      build2.onLoad({ filter: /.*/, namespace: BRAND.vitePluginNamespace }, () => {
+        return {
+          contents: DEFINE_FRAGMENT_SHIM,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+async function loadFragmentFile(absolutePath) {
+  const unwrapFragmentExport = (value) => {
+    if (!value) return null;
+    const asObject = (v) => v && typeof v === "object" ? v : null;
+    const isFragmentLike = (v) => {
+      const obj = asObject(v);
+      return !!obj && ("component" in obj || "meta" in obj || "variants" in obj);
+    };
+    if (isFragmentLike(value)) {
+      return value;
+    }
+    const first = asObject(value)?.default;
+    if (isFragmentLike(first)) {
+      return first;
+    }
+    const second = asObject(first)?.default;
+    if (isFragmentLike(second)) {
+      return second;
+    }
+    return value ?? null;
+  };
+  const ext = absolutePath.split(".").pop()?.toLowerCase();
+  const needsTransform = ext === "tsx" || ext === "ts" || ext === "jsx";
+  if (!needsTransform) {
+    const fileUrl = pathToFileURL(absolutePath).href;
+    const module = await import(fileUrl);
+    return unwrapFragmentExport(module.default ?? null);
+  }
+  const sourceDir = dirname3(absolutePath);
+  const baseName = basename2(absolutePath, `.${ext}`);
+  const tempFile = join(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
+  try {
+    await build({
+      entryPoints: [absolutePath],
+      outfile: tempFile,
+      bundle: true,
+      format: "esm",
+      target: "es2022",
+      jsx: "automatic",
+      platform: "node",
+      plugins: [createFragmentsCoreShimPlugin()],
+      // Externalize all node_modules - we only need fragment metadata, not component code
+      packages: "external",
+      // Also explicitly list patterns for nested imports
+      external: [
+        // React and its subpaths
+        "react",
+        "react-dom",
+        "react/*",
+        "react-dom/*"
+      ],
+      // Don't emit sourcemaps for temp files
+      sourcemap: false,
+      // Suppress warnings
+      logLevel: "silent",
+      // Use loader to ignore style imports
+      loader: {
+        ".scss": "empty",
+        ".css": "empty",
+        ".svg": "empty",
+        ".png": "empty",
+        ".jpg": "empty",
+        ".jpeg": "empty",
+        ".gif": "empty",
+        ".woff": "empty",
+        ".woff2": "empty",
+        ".ttf": "empty",
+        ".eot": "empty"
+      }
+    });
+    const fileUrl = pathToFileURL(tempFile).href;
+    const module = await import(fileUrl);
+    return unwrapFragmentExport(module.default ?? null);
+  } finally {
+    try {
+      await unlink(tempFile);
+    } catch {
+    }
+  }
+}
+async function loadFragmentFiles(absolutePaths) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    absolutePaths.map(async (path) => {
+      try {
+        const fragment = await loadFragmentFile(path);
+        if (fragment) {
+          results.set(path, fragment);
+        } else {
+          results.set(path, new Error("No default export found"));
+        }
+      } catch (error) {
+        results.set(
+          path,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    })
+  );
+  return results;
+}
+
+// src/core/parser.ts
+import ts from "typescript";
+function parseFragmentFile(fileContent, filePath) {
+  const warnings = [];
+  const sourceFile = ts.createSourceFile(
+    filePath ?? "fragment.tsx",
+    fileContent,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX
+  );
+  const imports = extractImports(sourceFile);
+  const defineFragmentCall = findDefineFragmentCall(sourceFile);
+  if (!defineFragmentCall) {
+    warnings.push("No defineFragment() call found");
+    return {
+      componentImport: null,
+      componentName: null,
+      meta: {},
+      usage: { when: [], whenNot: [] },
+      props: {},
+      variants: [],
+      relations: [],
+      warnings
+    };
+  }
+  const arg = defineFragmentCall.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+    warnings.push("defineFragment() argument is not an object literal");
+    return {
+      componentImport: null,
+      componentName: null,
+      meta: {},
+      usage: { when: [], whenNot: [] },
+      props: {},
+      variants: [],
+      relations: [],
+      warnings
+    };
+  }
+  const componentProp = findProperty(arg, "component");
+  let componentName = null;
+  let componentImport = null;
+  if (componentProp && ts.isIdentifier(componentProp)) {
+    componentName = componentProp.text;
+    componentImport = imports.get(componentName) ?? null;
+  }
+  const meta = extractMeta(arg, warnings);
+  const usage = extractUsage(arg, warnings);
+  const props = extractProps(arg, warnings);
+  const variants = extractVariants(arg, sourceFile, warnings);
+  const relations = extractRelations(arg, warnings);
+  const ai = extractAIMetadata(arg, warnings);
+  const contract = extractContractMetadata(arg);
+  return {
+    componentImport,
+    componentName,
+    meta,
+    usage,
+    props,
+    variants,
+    relations,
+    ai,
+    contract,
+    warnings
+  };
+}
+function extractImports(sourceFile) {
+  const imports = /* @__PURE__ */ new Map();
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpecifier)) {
+        const modulePath = moduleSpecifier.text;
+        const importClause = node.importClause;
+        if (importClause) {
+          if (importClause.name) {
+            imports.set(importClause.name.text, modulePath);
+          }
+          const namedBindings = importClause.namedBindings;
+          if (namedBindings && ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+              imports.set(element.name.text, modulePath);
+            }
+          }
+        }
+      }
+    }
+  });
+  return imports;
+}
+function findDefineFragmentCall(sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const expression = node.expression;
+      if (ts.isIdentifier(expression) && expression.text === "defineFragment") {
+        result = node;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findProperty(obj, name) {
+  for (const prop of obj.properties) {
+    if (ts.isPropertyAssignment(prop)) {
+      const propName = prop.name;
+      if (ts.isIdentifier(propName) && propName.text === name) {
+        return prop.initializer;
+      }
+    }
+  }
+  return null;
+}
+function extractMeta(arg, warnings) {
+  const metaProp = findProperty(arg, "meta");
+  if (!metaProp || !ts.isObjectLiteralExpression(metaProp)) {
+    warnings.push("No meta object found");
+    return {};
+  }
+  const meta = {};
+  const name = extractStringProperty(metaProp, "name");
+  if (name) meta.name = name;
+  const description = extractStringProperty(metaProp, "description");
+  if (description) meta.description = description;
+  const category = extractStringProperty(metaProp, "category");
+  if (category) meta.category = category;
+  const status = extractStringProperty(metaProp, "status");
+  if (status) meta.status = status;
+  const since = extractStringProperty(metaProp, "since");
+  if (since) meta.since = since;
+  const figma = extractStringProperty(metaProp, "figma");
+  if (figma) meta.figma = figma;
+  const tags = extractStringArray(metaProp, "tags");
+  if (tags.length > 0) meta.tags = tags;
+  const depsProp = findProperty(metaProp, "dependencies");
+  if (depsProp && ts.isArrayLiteralExpression(depsProp)) {
+    const deps = extractLiteralValue(depsProp);
+    if (Array.isArray(deps) && deps.length > 0) {
+      meta.dependencies = deps;
+    }
+  }
+  return meta;
+}
+function extractUsage(arg, warnings) {
+  const usageProp = findProperty(arg, "usage");
+  if (!usageProp || !ts.isObjectLiteralExpression(usageProp)) {
+    return { when: [], whenNot: [] };
+  }
+  return {
+    when: extractStringArray(usageProp, "when"),
+    whenNot: extractStringArray(usageProp, "whenNot"),
+    guidelines: extractStringArray(usageProp, "guidelines"),
+    accessibility: extractStringArray(usageProp, "accessibility")
+  };
+}
+function extractProps(arg, warnings) {
+  const propsProp = findProperty(arg, "props");
+  if (!propsProp || !ts.isObjectLiteralExpression(propsProp)) {
+    return {};
+  }
+  const props = {};
+  for (const prop of propsProp.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      const propName = prop.name.text;
+      const propValue = prop.initializer;
+      if (ts.isObjectLiteralExpression(propValue)) {
+        props[propName] = extractPropDefinition(propValue);
+      }
+    }
+  }
+  return props;
+}
+function extractPropDefinition(obj) {
+  const def = {};
+  const type = extractStringProperty(obj, "type");
+  if (type) def.type = type;
+  const description = extractStringProperty(obj, "description");
+  if (description) def.description = description;
+  const values = extractStringArray(obj, "values");
+  if (values.length > 0) def.values = values;
+  const required = extractBooleanProperty(obj, "required");
+  if (required !== null) def.required = required;
+  const defaultProp = findProperty(obj, "default");
+  if (defaultProp) {
+    def.default = extractLiteralValue(defaultProp);
+  }
+  const constraints = extractStringArray(obj, "constraints");
+  if (constraints.length > 0) def.constraints = constraints;
+  return def;
+}
+function extractVariants(arg, sourceFile, warnings) {
+  const variantsProp = findProperty(arg, "variants");
+  if (!variantsProp || !ts.isArrayLiteralExpression(variantsProp)) {
+    return [];
+  }
+  const variants = [];
+  for (const element of variantsProp.elements) {
+    if (ts.isObjectLiteralExpression(element)) {
+      const name = extractStringProperty(element, "name");
+      const description = extractStringProperty(element, "description");
+      if (name) {
+        const variant = {
+          name,
+          description: description ?? ""
+        };
+        const codeProp = findProperty(element, "code");
+        if (codeProp && (ts.isStringLiteral(codeProp) || ts.isNoSubstitutionTemplateLiteral(codeProp))) {
+          variant.code = codeProp.text;
+        }
+        const renderProp = findProperty(element, "render");
+        if (renderProp && !variant.code) {
+          variant.code = extractRenderCode(renderProp, sourceFile);
+        }
+        const figma = extractStringProperty(element, "figma");
+        if (figma) {
+          variant.figma = figma;
+        }
+        const argsProp = findProperty(element, "args");
+        if (argsProp && ts.isObjectLiteralExpression(argsProp)) {
+          const argsValue = extractLiteralValue(argsProp);
+          if (argsValue && typeof argsValue === "object" && !Array.isArray(argsValue)) {
+            variant.args = argsValue;
+          }
+        }
+        variants.push(variant);
+      }
+    }
+  }
+  return variants;
+}
+function dedent(str) {
+  const lines = str.split("\n");
+  if (lines.length <= 1) {
+    return str;
+  }
+  const firstLineIndent = lines[0].match(/^(\s*)/)?.[1].length ?? 0;
+  const startIndex = firstLineIndent === 0 ? 1 : 0;
+  let minIndent = Infinity;
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const match = line.match(/^(\s*)/);
+    if (match) {
+      minIndent = Math.min(minIndent, match[1].length);
+    }
+  }
+  if (minIndent === Infinity || minIndent === 0) {
+    return str;
+  }
+  return lines.map((line, index) => {
+    if (index === 0 && firstLineIndent === 0) {
+      return line;
+    }
+    return line.slice(minIndent);
+  }).join("\n");
+}
+function extractRenderCode(renderProp, sourceFile) {
+  if (ts.isArrowFunction(renderProp)) {
+    const body = renderProp.body;
+    const start = body.getStart(sourceFile);
+    const end = body.getEnd();
+    let code = sourceFile.text.substring(start, end).trim();
+    if (code.startsWith("(") && code.endsWith(")")) {
+      code = code.slice(1, -1).trim();
+    }
+    code = dedent(code);
+    return code;
+  }
+  return void 0;
+}
+function extractRelations(arg, warnings) {
+  const relationsProp = findProperty(arg, "relations");
+  if (!relationsProp || !ts.isArrayLiteralExpression(relationsProp)) {
+    return [];
+  }
+  const relations = [];
+  for (const element of relationsProp.elements) {
+    if (ts.isObjectLiteralExpression(element)) {
+      const component = extractStringProperty(element, "component");
+      const relationship = extractStringProperty(element, "relationship");
+      const note = extractStringProperty(element, "note");
+      if (component && relationship) {
+        relations.push({
+          component,
+          relationship,
+          note: note ?? ""
+        });
+      }
+    }
+  }
+  return relations;
+}
+function extractAIMetadata(arg, warnings) {
+  const aiProp = findProperty(arg, "ai");
+  if (!aiProp || !ts.isObjectLiteralExpression(aiProp)) {
+    return void 0;
+  }
+  const ai = {};
+  const compositionPattern = extractStringProperty(aiProp, "compositionPattern");
+  if (compositionPattern && ["compound", "simple", "controlled"].includes(compositionPattern)) {
+    ai.compositionPattern = compositionPattern;
+  }
+  const subComponents = extractStringArray(aiProp, "subComponents");
+  if (subComponents.length > 0) {
+    ai.subComponents = subComponents;
+  }
+  const requiredChildren = extractStringArray(aiProp, "requiredChildren");
+  if (requiredChildren.length > 0) {
+    ai.requiredChildren = requiredChildren;
+  }
+  const commonPatterns = extractStringArray(aiProp, "commonPatterns");
+  if (commonPatterns.length > 0) {
+    ai.commonPatterns = commonPatterns;
+  }
+  if (Object.keys(ai).length > 0) {
+    return ai;
+  }
+  return void 0;
+}
+function extractContractMetadata(arg) {
+  const contractProp = findProperty(arg, "contract");
+  if (!contractProp || !ts.isObjectLiteralExpression(contractProp)) {
+    return void 0;
+  }
+  const contract = {};
+  const propsSummary = extractStringArray(contractProp, "propsSummary");
+  if (propsSummary.length > 0) {
+    contract.propsSummary = propsSummary;
+  }
+  const a11yRules = extractStringArray(contractProp, "a11yRules");
+  if (a11yRules.length > 0) {
+    contract.a11yRules = a11yRules;
+  }
+  if (Object.keys(contract).length > 0) {
+    return contract;
+  }
+  return void 0;
+}
+function extractStringProperty(obj, name) {
+  const prop = findProperty(obj, name);
+  if (prop && ts.isStringLiteral(prop)) {
+    return prop.text;
+  }
+  if (prop && ts.isNoSubstitutionTemplateLiteral(prop)) {
+    return prop.text;
+  }
+  return null;
+}
+function extractBooleanProperty(obj, name) {
+  const prop = findProperty(obj, name);
+  if (prop) {
+    if (prop.kind === ts.SyntaxKind.TrueKeyword) return true;
+    if (prop.kind === ts.SyntaxKind.FalseKeyword) return false;
+  }
+  return null;
+}
+function extractStringArray(obj, name) {
+  const prop = findProperty(obj, name);
+  if (!prop || !ts.isArrayLiteralExpression(prop)) {
+    return [];
+  }
+  const result = [];
+  for (const element of prop.elements) {
+    if (ts.isStringLiteral(element)) {
+      result.push(element.text);
+    } else if (ts.isNoSubstitutionTemplateLiteral(element)) {
+      result.push(element.text);
+    }
+  }
+  return result;
+}
+function extractLiteralValue(expr) {
+  if (ts.isStringLiteral(expr)) {
+    return expr.text;
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return Number(expr.text);
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts.isArrayLiteralExpression(expr)) {
+    return expr.elements.map(extractLiteralValue);
+  }
+  if (ts.isObjectLiteralExpression(expr)) {
+    const obj = {};
+    for (const prop of expr.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        obj[prop.name.text] = extractLiteralValue(prop.initializer);
+      }
+    }
+    return obj;
+  }
+  return void 0;
+}
+
+// src/core/previewLoader.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join2, resolve as resolve3 } from "path";
+var PREVIEW_FILES = [
+  "preview.tsx",
+  "preview.ts",
+  "preview.jsx",
+  "preview.js"
+];
+function findPreviewConfigPath(storybookDir) {
+  for (const fileName of PREVIEW_FILES) {
+    const filePath = join2(storybookDir, fileName);
+    if (existsSync3(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function findStorybookDir(projectRoot) {
+  const possiblePaths = [
+    join2(projectRoot, ".storybook"),
+    join2(projectRoot, "storybook")
+  ];
+  for (const dir of possiblePaths) {
+    if (existsSync3(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function loadPreviewConfig(previewPath) {
+  try {
+    const fileUrl = new URL(`file://${resolve3(previewPath)}`);
+    const module = await import(fileUrl.href);
+    const config = {
+      decorators: module.decorators ?? module.default?.decorators ?? [],
+      parameters: module.parameters ?? module.default?.parameters ?? {},
+      globalTypes: module.globalTypes ?? module.default?.globalTypes ?? {},
+      args: module.args ?? module.default?.args ?? {},
+      argTypes: module.argTypes ?? module.default?.argTypes ?? {},
+      loaders: module.loaders ?? module.default?.loaders ?? []
+    };
+    return config;
+  } catch (error) {
+    console.warn(
+      `[Fragments] Failed to load preview config from ${previewPath}:`,
+      error instanceof Error ? error.message : error
+    );
+    return {};
+  }
+}
+async function autoLoadPreviewConfig(projectRoot) {
+  const storybookDir = findStorybookDir(projectRoot);
+  if (!storybookDir) {
+    return {};
+  }
+  const previewPath = findPreviewConfigPath(storybookDir);
+  if (!previewPath) {
+    return {};
+  }
+  return loadPreviewConfig(previewPath);
+}
+function generatePreviewModule(previewPath) {
+  if (!previewPath) {
+    return `
+export const decorators = [];
+export const parameters = {};
+export const globalTypes = {};
+export const args = {};
+export const argTypes = {};
+export const loaders = [];
+
+export default {
+  decorators,
+  parameters,
+  globalTypes,
+  args,
+  argTypes,
+  loaders,
+};
+`;
+  }
+  return `
+import * as preview from "${previewPath}";
+
+export const decorators = preview.decorators ?? preview.default?.decorators ?? [];
+export const parameters = preview.parameters ?? preview.default?.parameters ?? {};
+export const globalTypes = preview.globalTypes ?? preview.default?.globalTypes ?? {};
+export const args = preview.args ?? preview.default?.args ?? {};
+export const argTypes = preview.argTypes ?? preview.default?.argTypes ?? {};
+export const loaders = preview.loaders ?? preview.default?.loaders ?? [];
+
+export default {
+  decorators,
+  parameters,
+  globalTypes,
+  args,
+  argTypes,
+  loaders,
+};
+`;
+}
+
+// src/core/generators/typescript-extractor.ts
+import ts2 from "typescript";
+import { readFileSync } from "fs";
+function extractPropsFromFile(filePath) {
+  const sourceText = readFileSync(filePath, "utf-8");
+  return extractPropsFromSource(sourceText, filePath);
+}
+function extractPropsFromSource(sourceText, fileName = "component.tsx") {
+  const sourceFile = ts2.createSourceFile(
+    fileName,
+    sourceText,
+    ts2.ScriptTarget.Latest,
+    true,
+    fileName.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+  );
+  const result = {
+    componentName: "",
+    props: {},
+    exports: [],
+    imports: []
+  };
+  const propsInterfaces = /* @__PURE__ */ new Map();
+  const componentExports = [];
+  const defaultExports = /* @__PURE__ */ new Set();
+  const importedModules = [];
+  ts2.forEachChild(sourceFile, (node) => {
+    if (ts2.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts2.isStringLiteral(moduleSpecifier)) {
+        importedModules.push(moduleSpecifier.text);
+      }
+    }
+    if (ts2.isInterfaceDeclaration(node)) {
+      const name = node.name.text;
+      if (name.endsWith("Props")) {
+        propsInterfaces.set(name, node);
+      }
+    }
+    if (ts2.isTypeAliasDeclaration(node)) {
+      const name = node.name.text;
+      if (name.endsWith("Props")) {
+        propsInterfaces.set(name, node);
+      }
+    }
+    if (ts2.isFunctionDeclaration(node) && node.name) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts2.SyntaxKind.ExportKeyword
+      );
+      const hasDefault = node.modifiers?.some(
+        (m) => m.kind === ts2.SyntaxKind.DefaultKeyword
+      );
+      if (hasExport) {
+        componentExports.push(node.name.text);
+        if (hasDefault) {
+          defaultExports.add(node.name.text);
+        }
+      }
+    }
+    if (ts2.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts2.SyntaxKind.ExportKeyword
+      );
+      if (hasExport) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts2.isIdentifier(decl.name)) {
+            componentExports.push(decl.name.text);
+          }
+        }
+      }
+    }
+    if (ts2.isExportDeclaration(node) && node.exportClause) {
+      if (ts2.isNamedExports(node.exportClause)) {
+        for (const element of node.exportClause.elements) {
+          componentExports.push(element.name.text);
+        }
+      }
+    }
+  });
+  result.exports = componentExports;
+  result.imports = importedModules;
+  const mainComponent = componentExports.find(
+    (name) => /^[A-Z]/.test(name) && !name.endsWith("Props")
+  );
+  if (!mainComponent) {
+    return null;
+  }
+  result.componentName = mainComponent;
+  result.isDefaultExport = defaultExports.has(mainComponent);
+  const propsInterfaceName = `${mainComponent}Props`;
+  const propsInterface = propsInterfaces.get(propsInterfaceName);
+  if (propsInterface) {
+    result.propsInterfaceName = propsInterfaceName;
+    result.props = extractPropsFromInterface(propsInterface, sourceFile);
+  }
+  return result;
+}
+function extractPropsFromInterface(node, sourceFile) {
+  const props = {};
+  if (ts2.isInterfaceDeclaration(node)) {
+    for (const member of node.members) {
+      if (ts2.isPropertySignature(member) && member.name) {
+        const propName = member.name.getText(sourceFile);
+        const prop = extractPropFromMember(member, sourceFile);
+        if (prop) {
+          props[propName] = prop;
+        }
+      }
+    }
+  }
+  if (ts2.isTypeAliasDeclaration(node)) {
+    const typeNode = node.type;
+    if (ts2.isTypeLiteralNode(typeNode)) {
+      for (const member of typeNode.members) {
+        if (ts2.isPropertySignature(member) && member.name) {
+          const propName = member.name.getText(sourceFile);
+          const prop = extractPropFromMember(member, sourceFile);
+          if (prop) {
+            props[propName] = prop;
+          }
+        }
+      }
+    }
+  }
+  return props;
+}
+function extractPropFromMember(member, sourceFile) {
+  const entry = {};
+  entry.required = !member.questionToken;
+  if (member.type) {
+    const typeInfo = parseTypeNode(member.type, sourceFile);
+    entry.type = typeInfo.type;
+    entry.typeKind = typeInfo.typeKind;
+    if (typeInfo.options) {
+      entry.options = typeInfo.options;
+    }
+  }
+  const jsDocComment = getJSDocComment(member);
+  if (jsDocComment) {
+    entry.description = jsDocComment;
+  }
+  const defaultValue = getJSDocDefault(member);
+  if (defaultValue !== void 0) {
+    entry.default = defaultValue;
+  }
+  return entry;
+}
+function parseTypeNode(typeNode, sourceFile) {
+  if (typeNode.kind === ts2.SyntaxKind.StringKeyword) {
+    return { type: "string", typeKind: "string" };
+  }
+  if (typeNode.kind === ts2.SyntaxKind.NumberKeyword) {
+    return { type: "number", typeKind: "number" };
+  }
+  if (typeNode.kind === ts2.SyntaxKind.BooleanKeyword) {
+    return { type: "boolean", typeKind: "boolean" };
+  }
+  if (ts2.isUnionTypeNode(typeNode)) {
+    const options = [];
+    let allLiterals = true;
+    for (const subType of typeNode.types) {
+      if (ts2.isLiteralTypeNode(subType)) {
+        if (ts2.isStringLiteral(subType.literal)) {
+          options.push(subType.literal.text);
+        } else if (subType.literal.kind === ts2.SyntaxKind.TrueKeyword) {
+          options.push("true");
+        } else if (subType.literal.kind === ts2.SyntaxKind.FalseKeyword) {
+          options.push("false");
+        } else {
+          allLiterals = false;
+        }
+      } else {
+        allLiterals = false;
+      }
+    }
+    if (allLiterals && options.length > 0) {
+      return {
+        type: options.map((o) => `"${o}"`).join(" | "),
+        typeKind: "enum",
+        options
+      };
+    }
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "union"
+    };
+  }
+  if (ts2.isFunctionTypeNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "function"
+    };
+  }
+  if (ts2.isArrayTypeNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "array"
+    };
+  }
+  if (ts2.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(sourceFile);
+    if (typeName === "ReactNode" || typeName === "React.ReactNode") {
+      return { type: "ReactNode", typeKind: "node" };
+    }
+    if (typeName === "ReactElement" || typeName === "React.ReactElement") {
+      return { type: "ReactElement", typeKind: "element" };
+    }
+    if (typeName === "JSX.Element") {
+      return { type: "JSX.Element", typeKind: "element" };
+    }
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "object"
+    };
+  }
+  if (ts2.isTypeLiteralNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "object"
+    };
+  }
+  return {
+    type: typeNode.getText(sourceFile),
+    typeKind: "unknown"
+  };
+}
+function getJSDocComment(node) {
+  const jsDocTags = ts2.getJSDocTags(node);
+  const jsDoc = node.jsDoc;
+  if (jsDoc && jsDoc.length > 0) {
+    const comment = jsDoc[0].comment;
+    if (typeof comment === "string") {
+      return comment;
+    }
+    if (Array.isArray(comment)) {
+      return comment.map((c) => typeof c === "string" ? c : c.text).join("");
+    }
+  }
+  return void 0;
+}
+function getJSDocDefault(node) {
+  const jsDocTags = ts2.getJSDocTags(node);
+  for (const tag of jsDocTags) {
+    if (tag.tagName.text === "default") {
+      const comment = tag.comment;
+      if (typeof comment === "string") {
+        try {
+          return JSON.parse(comment);
+        } catch {
+          return comment;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/core/generators/registry.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { relative, dirname as dirname4, basename as basename3, join as join3 } from "path";
+import fg2 from "fast-glob";
+async function generateRegistry(options) {
+  const {
+    projectRoot,
+    componentPatterns = ["src/**/*.tsx", "src/**/*.ts"],
+    storyPatterns = ["src/**/*.stories.tsx", "src/**/*.stories.ts"],
+    fragmentsDir = join3(projectRoot, BRAND.dataDir),
+    registryOptions = {}
+  } = options;
+  const {
+    requireStory = false,
+    publicOnly = false,
+    categoryDepth = 1,
+    includeProps = false,
+    embedFragments = false
+  } = registryOptions;
+  const errors = [];
+  const warnings = [];
+  const storyFiles = await fg2(storyPatterns, {
+    cwd: projectRoot,
+    ignore: ["**/node_modules/**"],
+    absolute: true
   });
   const storyMap = /* @__PURE__ */ new Map();
   for (const storyPath of storyFiles) {
-    const storyDir = dirname2(storyPath);
-    const storyBase = basename(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
+    const storyDir = dirname4(storyPath);
+    const storyBase = basename3(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
     storyMap.set(`${storyDir}/${storyBase}`, storyPath);
   }
-  const componentFiles = await fg(componentPatterns, {
+  const componentFiles = await fg2(componentPatterns, {
     cwd: projectRoot,
     ignore: [
       "**/node_modules/**",
@@ -379,18 +1340,18 @@ async function generateRegistry(options) {
     ],
     absolute: true
   });
-  const fragmentPattern = join(
+  const fragmentPattern = join3(
     BRAND.dataDir,
     BRAND.componentsDir,
     `*${BRAND.fileExtension}`
   );
-  const fragmentFiles = await fg(fragmentPattern, {
+  const fragmentFiles = await fg2(fragmentPattern, {
     cwd: projectRoot,
     absolute: true
   });
   const fragmentMap = /* @__PURE__ */ new Map();
   for (const fragmentPath of fragmentFiles) {
-    const fragmentName = basename(fragmentPath).replace(BRAND.fileExtension, "");
+    const fragmentName = basename3(fragmentPath).replace(BRAND.fileExtension, "");
     try {
       const content = readFileSync2(fragmentPath, "utf-8");
       const fragment = JSON.parse(content);
@@ -419,8 +1380,8 @@ async function generateRegistry(options) {
       if (publicOnly && !extracted.exports.includes(componentName)) {
         continue;
       }
-      const componentDir = dirname2(filePath);
-      const baseNameWithoutExt = basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+      const componentDir = dirname4(filePath);
+      const baseNameWithoutExt = basename3(filePath).replace(/\.(tsx?|jsx?)$/, "");
       const storyPath = storyMap.get(`${componentDir}/${baseNameWithoutExt}`);
       if (requireStory && !storyPath) {
         continue;
@@ -533,880 +1494,433 @@ function hasRealEnrichment(fragment) {
     return true;
   }
   if (fragment.related?.similar && fragment.related.similar.length > 0) {
-    return true;
-  }
-  return false;
-}
-
-// src/core/generators/context.ts
-function generateContextMd(registry, options = {}) {
-  const {
-    format = "markdown",
-    compact = false,
-    include = { props: true, relations: true, code: false }
-  } = options;
-  if (format === "json") {
-    return generateJsonContext(registry, include, compact);
-  }
-  return generateMarkdownContext(registry, include, compact);
-}
-function generateMarkdownContext(registry, include, compact) {
-  const lines = [];
-  const componentNames = Object.keys(registry.components).sort();
-  const componentCount = componentNames.length;
-  lines.push("# Component Library Context");
-  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} | Components: ${componentCount}`);
-  lines.push("");
-  lines.push("## Quick Reference");
-  lines.push("");
-  lines.push("| Component | Path | Category | Status |");
-  lines.push("|-----------|------|----------|--------|");
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const status = entry.status || "stable";
-    const category = entry.category || "-";
-    lines.push(`| ${name} | ${entry.path} | ${category} | ${status} |`);
-  }
-  lines.push("");
-  if (compact) {
-    const content2 = lines.join("\n");
-    return {
-      content: content2,
-      tokenEstimate: estimateTokens(content2),
-      componentCount
-    };
-  }
-  lines.push("---");
-  lines.push("");
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const fragment = entry.fragment;
-    lines.push(`## ${name}`);
-    lines.push(`**Path:** \`${entry.path}\``);
-    if (entry.category) {
-      lines.push(`**Category:** ${entry.category} | **Status:** ${entry.status || "stable"}`);
-    }
-    lines.push("");
-    if (entry.description || fragment?.description) {
-      lines.push("### Description");
-      lines.push(entry.description || fragment?.description || "");
-      lines.push("");
-    }
-    if (fragment?.usage) {
-      if (fragment.usage.when && fragment.usage.when.length > 0) {
-        lines.push("### When to Use");
-        for (const when of fragment.usage.when) {
-          lines.push(`- ${when}`);
-        }
-        lines.push("");
-      }
-      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
-        lines.push("### Do Not");
-        for (const doNotItem of fragment.usage.doNot) {
-          if (typeof doNotItem === "string") {
-            lines.push(`- ${doNotItem}`);
-          } else {
-            const item = doNotItem;
-            if (item.instead) {
-              const alternativePath = resolveComponentPath(item.instead, registry);
-              if (alternativePath) {
-                lines.push(`- ${item.text} \u2192 use **${item.instead}** (\`${alternativePath}\`)`);
-              } else {
-                lines.push(`- ${item.text} \u2192 use **${item.instead}**`);
-              }
-            } else {
-              lines.push(`- ${item.text}`);
-            }
-          }
-        }
-        lines.push("");
-      }
-      if (include.code && fragment.usage.patterns && fragment.usage.patterns.length > 0) {
-        lines.push("### Patterns");
-        for (const pattern of fragment.usage.patterns) {
-          lines.push(`**${pattern.name}**`);
-          if (pattern.description) {
-            lines.push(pattern.description);
-          }
-          lines.push("```tsx");
-          lines.push(pattern.code);
-          lines.push("```");
-          lines.push("");
-        }
-      }
-    }
-    if (include.props && entry.props && Object.keys(entry.props).length > 0) {
-      lines.push("### Props");
-      lines.push("| Prop | Type | Default | Description |");
-      lines.push("|------|------|---------|-------------|");
-      for (const [propName, prop] of Object.entries(entry.props)) {
-        const type = formatPropType(prop);
-        const defaultVal = prop.default !== void 0 ? `\`${JSON.stringify(prop.default)}\`` : "-";
-        const desc = prop.description || "-";
-        const required = prop.required ? " (required)" : "";
-        lines.push(`| ${propName}${required} | ${type} | ${defaultVal} | ${desc} |`);
-      }
-      lines.push("");
-    }
-    if (fragment?.accessibility) {
-      lines.push("### Accessibility");
-      if (fragment.accessibility.role) {
-        lines.push(`**Role:** ${fragment.accessibility.role}`);
-      }
-      if (fragment.accessibility.requirements && fragment.accessibility.requirements.length > 0) {
-        for (const req of fragment.accessibility.requirements) {
-          lines.push(`- ${req}`);
-        }
-      }
-      if (fragment.accessibility.keyboard) {
-        lines.push("");
-        lines.push("**Keyboard:**");
-        for (const [key, action] of Object.entries(fragment.accessibility.keyboard)) {
-          lines.push(`- \`${key}\`: ${action}`);
-        }
-      }
-      lines.push("");
-    }
-    if (include.relations && fragment?.related) {
-      lines.push("### Related");
-      if (fragment.related.similar && fragment.related.similar.length > 0) {
-        const resolved = fragment.related.similar.map((comp) => {
-          const path = resolveComponentPath(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Similar:** ${resolved.join(", ")}`);
-      }
-      if (fragment.related.composedWith && fragment.related.composedWith.length > 0) {
-        const resolved = fragment.related.composedWith.map((comp) => {
-          const path = resolveComponentPath(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Composed with:** ${resolved.join(", ")}`);
-      }
-      if (fragment.related.usedIn && fragment.related.usedIn.length > 0) {
-        const resolved = fragment.related.usedIn.map((comp) => {
-          const path = resolveComponentPath(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Used in:** ${resolved.join(", ")}`);
-      }
-      lines.push("");
-    }
-    lines.push("---");
-    lines.push("");
-  }
-  const content = lines.join("\n");
-  return {
-    content,
-    tokenEstimate: estimateTokens(content),
-    componentCount
-  };
-}
-function generateJsonContext(registry, include, compact) {
-  const componentNames = Object.keys(registry.components).sort();
-  const componentCount = componentNames.length;
-  const components = {};
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const fragment = entry.fragment;
-    const component = {
-      path: entry.path
-    };
-    if (entry.category) component.category = entry.category;
-    if (entry.status) component.status = entry.status;
-    if (entry.description || fragment?.description) {
-      component.description = entry.description || fragment?.description;
-    }
-    if (!compact && fragment?.usage) {
-      if (fragment.usage.when && fragment.usage.when.length > 0) {
-        component.whenToUse = fragment.usage.when;
-      }
-      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
-        component.doNot = fragment.usage.doNot.map((item) => {
-          if (typeof item === "string") {
-            return { text: item };
-          }
-          const doNotItem = item;
-          const result = {
-            text: doNotItem.text
-          };
-          if (doNotItem.instead) {
-            result.instead = doNotItem.instead;
-            result.insteadPath = resolveComponentPath(doNotItem.instead, registry);
-          }
-          return result;
-        });
-      }
-    }
-    if (!compact && include.props && entry.props) {
-      component.props = {};
-      for (const [propName, prop] of Object.entries(entry.props)) {
-        component.props[propName] = {
-          type: formatPropType(prop)
-        };
-        if (prop.required) component.props[propName].required = true;
-        if (prop.default !== void 0) component.props[propName].default = prop.default;
-        if (prop.description) component.props[propName].description = prop.description;
-      }
-    }
-    if (!compact && include.relations && fragment?.related) {
-      component.related = {};
-      if (fragment.related.similar) {
-        component.related.similar = fragment.related.similar.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath(name2, registry)
-        }));
-      }
-      if (fragment.related.composedWith) {
-        component.related.composedWith = fragment.related.composedWith.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath(name2, registry)
-        }));
-      }
-      if (fragment.related.usedIn) {
-        component.related.usedIn = fragment.related.usedIn.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath(name2, registry)
-        }));
-      }
-    }
-    components[name] = component;
+    return true;
   }
-  const output = {
-    version: "1.0",
-    generatedAt: registry.generatedAt,
-    componentCount,
-    categories: registry.categories,
-    components
-  };
-  const content = JSON.stringify(output, null, 2);
-  return {
-    content,
-    tokenEstimate: estimateTokens(content),
-    componentCount
-  };
+  return false;
 }
 function resolveComponentPath(componentName, registry) {
-  return registry.components[componentName]?.path;
+  const entry = registry.components[componentName];
+  return entry?.path;
 }
-function formatPropType(prop) {
-  if (prop.options && prop.options.length > 0) {
-    return prop.options.map((o) => `"${o}"`).join(" \\| ");
-  }
-  return prop.type || "unknown";
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
+function getComponentsByCategory(category, registry) {
+  return registry.categories?.[category] || [];
 }
 
-// src/core/loader.ts
-import { unlink } from "fs/promises";
-import { dirname as dirname3, basename as basename2, join as join2 } from "path";
-import { pathToFileURL } from "url";
-import { build } from "esbuild";
-var DEFINE_FRAGMENT_SHIM = `
-export function defineFragment(def) {
-  return def;
-}
-export function defineBlock(def) {
-  return def;
-}
-export function defineRecipe(def) {
-  return def;
-}
-`;
-function createFragmentsCoreShimPlugin() {
-  return {
-    name: BRAND.vitePluginNamespace,
-    setup(build2) {
-      build2.onResolve({ filter: /^@fragments-sdk\/cli\/core$/ }, (args) => {
-        return {
-          path: args.path,
-          namespace: BRAND.vitePluginNamespace
-        };
-      });
-      build2.onLoad({ filter: /.*/, namespace: BRAND.vitePluginNamespace }, () => {
-        return {
-          contents: DEFINE_FRAGMENT_SHIM,
-          loader: "js"
-        };
-      });
-    }
-  };
-}
-async function loadFragmentFile(absolutePath) {
-  const unwrapFragmentExport = (value) => {
-    if (!value) return null;
-    const asObject = (v) => v && typeof v === "object" ? v : null;
-    const isFragmentLike = (v) => {
-      const obj = asObject(v);
-      return !!obj && ("component" in obj || "meta" in obj || "variants" in obj);
-    };
-    if (isFragmentLike(value)) {
-      return value;
-    }
-    const first = asObject(value)?.default;
-    if (isFragmentLike(first)) {
-      return first;
-    }
-    const second = asObject(first)?.default;
-    if (isFragmentLike(second)) {
-      return second;
-    }
-    return value ?? null;
-  };
-  const ext = absolutePath.split(".").pop()?.toLowerCase();
-  const needsTransform = ext === "tsx" || ext === "ts" || ext === "jsx";
-  if (!needsTransform) {
-    const fileUrl = pathToFileURL(absolutePath).href;
-    const module = await import(fileUrl);
-    return unwrapFragmentExport(module.default ?? null);
-  }
-  const sourceDir = dirname3(absolutePath);
-  const baseName = basename2(absolutePath, `.${ext}`);
-  const tempFile = join2(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
-  try {
-    await build({
-      entryPoints: [absolutePath],
-      outfile: tempFile,
-      bundle: true,
-      format: "esm",
-      target: "es2022",
-      jsx: "automatic",
-      platform: "node",
-      plugins: [createFragmentsCoreShimPlugin()],
-      // Externalize all node_modules - we only need fragment metadata, not component code
-      packages: "external",
-      // Also explicitly list patterns for nested imports
-      external: [
-        // React and its subpaths
-        "react",
-        "react-dom",
-        "react/*",
-        "react-dom/*"
-      ],
-      // Don't emit sourcemaps for temp files
-      sourcemap: false,
-      // Suppress warnings
-      logLevel: "silent",
-      // Use loader to ignore style imports
-      loader: {
-        ".scss": "empty",
-        ".css": "empty",
-        ".svg": "empty",
-        ".png": "empty",
-        ".jpg": "empty",
-        ".jpeg": "empty",
-        ".gif": "empty",
-        ".woff": "empty",
-        ".woff2": "empty",
-        ".ttf": "empty",
-        ".eot": "empty"
-      }
-    });
-    const fileUrl = pathToFileURL(tempFile).href;
-    const module = await import(fileUrl);
-    return unwrapFragmentExport(module.default ?? null);
-  } finally {
-    try {
-      await unlink(tempFile);
-    } catch {
-    }
+// src/core/generators/context.ts
+function generateContextMd(registry, options = {}) {
+  const {
+    format = "markdown",
+    compact = false,
+    include = { props: true, relations: true, code: false }
+  } = options;
+  if (format === "json") {
+    return generateJsonContext(registry, include, compact);
   }
+  return generateMarkdownContext(registry, include, compact);
 }
-
-// src/core/parser.ts
-import ts2 from "typescript";
-function parseFragmentFile(fileContent, filePath) {
-  const warnings = [];
-  const sourceFile = ts2.createSourceFile(
-    filePath ?? "fragment.tsx",
-    fileContent,
-    ts2.ScriptTarget.Latest,
-    true,
-    ts2.ScriptKind.TSX
-  );
-  const imports = extractImports(sourceFile);
-  const defineFragmentCall = findDefineFragmentCall(sourceFile);
-  if (!defineFragmentCall) {
-    warnings.push("No defineFragment() call found");
-    return {
-      componentImport: null,
-      componentName: null,
-      meta: {},
-      usage: { when: [], whenNot: [] },
-      props: {},
-      variants: [],
-      relations: [],
-      warnings
-    };
+function generateMarkdownContext(registry, include, compact) {
+  const lines = [];
+  const componentNames = Object.keys(registry.components).sort();
+  const componentCount = componentNames.length;
+  lines.push("# Component Library Context");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} | Components: ${componentCount}`);
+  lines.push("");
+  lines.push("## Quick Reference");
+  lines.push("");
+  lines.push("| Component | Path | Category | Status |");
+  lines.push("|-----------|------|----------|--------|");
+  for (const name of componentNames) {
+    const entry = registry.components[name];
+    const status = entry.status || "stable";
+    const category = entry.category || "-";
+    lines.push(`| ${name} | ${entry.path} | ${category} | ${status} |`);
   }
-  const arg = defineFragmentCall.arguments[0];
-  if (!arg || !ts2.isObjectLiteralExpression(arg)) {
-    warnings.push("defineFragment() argument is not an object literal");
+  lines.push("");
+  if (compact) {
+    const content2 = lines.join("\n");
     return {
-      componentImport: null,
-      componentName: null,
-      meta: {},
-      usage: { when: [], whenNot: [] },
-      props: {},
-      variants: [],
-      relations: [],
-      warnings
+      content: content2,
+      tokenEstimate: estimateTokens(content2),
+      componentCount
     };
   }
-  const componentProp = findProperty(arg, "component");
-  let componentName = null;
-  let componentImport = null;
-  if (componentProp && ts2.isIdentifier(componentProp)) {
-    componentName = componentProp.text;
-    componentImport = imports.get(componentName) ?? null;
-  }
-  const meta = extractMeta(arg, warnings);
-  const usage = extractUsage(arg, warnings);
-  const props = extractProps(arg, warnings);
-  const variants = extractVariants(arg, sourceFile, warnings);
-  const relations = extractRelations(arg, warnings);
-  const ai = extractAIMetadata(arg, warnings);
-  const contract = extractContractMetadata(arg);
-  return {
-    componentImport,
-    componentName,
-    meta,
-    usage,
-    props,
-    variants,
-    relations,
-    ai,
-    contract,
-    warnings
-  };
-}
-function extractImports(sourceFile) {
-  const imports = /* @__PURE__ */ new Map();
-  ts2.forEachChild(sourceFile, (node) => {
-    if (ts2.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (ts2.isStringLiteral(moduleSpecifier)) {
-        const modulePath = moduleSpecifier.text;
-        const importClause = node.importClause;
-        if (importClause) {
-          if (importClause.name) {
-            imports.set(importClause.name.text, modulePath);
-          }
-          const namedBindings = importClause.namedBindings;
-          if (namedBindings && ts2.isNamedImports(namedBindings)) {
-            for (const element of namedBindings.elements) {
-              imports.set(element.name.text, modulePath);
+  lines.push("---");
+  lines.push("");
+  for (const name of componentNames) {
+    const entry = registry.components[name];
+    const fragment = entry.fragment;
+    lines.push(`## ${name}`);
+    lines.push(`**Path:** \`${entry.path}\``);
+    if (entry.category) {
+      lines.push(`**Category:** ${entry.category} | **Status:** ${entry.status || "stable"}`);
+    }
+    lines.push("");
+    if (entry.description || fragment?.description) {
+      lines.push("### Description");
+      lines.push(entry.description || fragment?.description || "");
+      lines.push("");
+    }
+    if (fragment?.usage) {
+      if (fragment.usage.when && fragment.usage.when.length > 0) {
+        lines.push("### When to Use");
+        for (const when of fragment.usage.when) {
+          lines.push(`- ${when}`);
+        }
+        lines.push("");
+      }
+      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
+        lines.push("### Do Not");
+        for (const doNotItem of fragment.usage.doNot) {
+          if (typeof doNotItem === "string") {
+            lines.push(`- ${doNotItem}`);
+          } else {
+            const item = doNotItem;
+            if (item.instead) {
+              const alternativePath = resolveComponentPath2(item.instead, registry);
+              if (alternativePath) {
+                lines.push(`- ${item.text} \u2192 use **${item.instead}** (\`${alternativePath}\`)`);
+              } else {
+                lines.push(`- ${item.text} \u2192 use **${item.instead}**`);
+              }
+            } else {
+              lines.push(`- ${item.text}`);
             }
           }
         }
+        lines.push("");
       }
-    }
-  });
-  return imports;
-}
-function findDefineFragmentCall(sourceFile) {
-  let result = null;
-  function visit(node) {
-    if (ts2.isCallExpression(node)) {
-      const expression = node.expression;
-      if (ts2.isIdentifier(expression) && expression.text === "defineFragment") {
-        result = node;
-        return;
+      if (include.code && fragment.usage.patterns && fragment.usage.patterns.length > 0) {
+        lines.push("### Patterns");
+        for (const pattern of fragment.usage.patterns) {
+          lines.push(`**${pattern.name}**`);
+          if (pattern.description) {
+            lines.push(pattern.description);
+          }
+          lines.push("```tsx");
+          lines.push(pattern.code);
+          lines.push("```");
+          lines.push("");
+        }
       }
     }
-    ts2.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return result;
-}
-function findProperty(obj, name) {
-  for (const prop of obj.properties) {
-    if (ts2.isPropertyAssignment(prop)) {
-      const propName = prop.name;
-      if (ts2.isIdentifier(propName) && propName.text === name) {
-        return prop.initializer;
+    if (include.props && entry.props && Object.keys(entry.props).length > 0) {
+      lines.push("### Props");
+      lines.push("| Prop | Type | Default | Description |");
+      lines.push("|------|------|---------|-------------|");
+      for (const [propName, prop] of Object.entries(entry.props)) {
+        const type = formatPropType(prop);
+        const defaultVal = prop.default !== void 0 ? `\`${JSON.stringify(prop.default)}\`` : "-";
+        const desc = prop.description || "-";
+        const required = prop.required ? " (required)" : "";
+        lines.push(`| ${propName}${required} | ${type} | ${defaultVal} | ${desc} |`);
       }
+      lines.push("");
     }
-  }
-  return null;
-}
-function extractMeta(arg, warnings) {
-  const metaProp = findProperty(arg, "meta");
-  if (!metaProp || !ts2.isObjectLiteralExpression(metaProp)) {
-    warnings.push("No meta object found");
-    return {};
-  }
-  const meta = {};
-  const name = extractStringProperty(metaProp, "name");
-  if (name) meta.name = name;
-  const description = extractStringProperty(metaProp, "description");
-  if (description) meta.description = description;
-  const category = extractStringProperty(metaProp, "category");
-  if (category) meta.category = category;
-  const status = extractStringProperty(metaProp, "status");
-  if (status) meta.status = status;
-  const since = extractStringProperty(metaProp, "since");
-  if (since) meta.since = since;
-  const figma = extractStringProperty(metaProp, "figma");
-  if (figma) meta.figma = figma;
-  const tags = extractStringArray(metaProp, "tags");
-  if (tags.length > 0) meta.tags = tags;
-  const depsProp = findProperty(metaProp, "dependencies");
-  if (depsProp && ts2.isArrayLiteralExpression(depsProp)) {
-    const deps = extractLiteralValue(depsProp);
-    if (Array.isArray(deps) && deps.length > 0) {
-      meta.dependencies = deps;
-    }
-  }
-  return meta;
-}
-function extractUsage(arg, warnings) {
-  const usageProp = findProperty(arg, "usage");
-  if (!usageProp || !ts2.isObjectLiteralExpression(usageProp)) {
-    return { when: [], whenNot: [] };
-  }
-  return {
-    when: extractStringArray(usageProp, "when"),
-    whenNot: extractStringArray(usageProp, "whenNot"),
-    guidelines: extractStringArray(usageProp, "guidelines"),
-    accessibility: extractStringArray(usageProp, "accessibility")
-  };
-}
-function extractProps(arg, warnings) {
-  const propsProp = findProperty(arg, "props");
-  if (!propsProp || !ts2.isObjectLiteralExpression(propsProp)) {
-    return {};
-  }
-  const props = {};
-  for (const prop of propsProp.properties) {
-    if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
-      const propName = prop.name.text;
-      const propValue = prop.initializer;
-      if (ts2.isObjectLiteralExpression(propValue)) {
-        props[propName] = extractPropDefinition(propValue);
+    if (fragment?.accessibility) {
+      lines.push("### Accessibility");
+      if (fragment.accessibility.role) {
+        lines.push(`**Role:** ${fragment.accessibility.role}`);
       }
-    }
-  }
-  return props;
-}
-function extractPropDefinition(obj) {
-  const def = {};
-  const type = extractStringProperty(obj, "type");
-  if (type) def.type = type;
-  const description = extractStringProperty(obj, "description");
-  if (description) def.description = description;
-  const values = extractStringArray(obj, "values");
-  if (values.length > 0) def.values = values;
-  const required = extractBooleanProperty(obj, "required");
-  if (required !== null) def.required = required;
-  const defaultProp = findProperty(obj, "default");
-  if (defaultProp) {
-    def.default = extractLiteralValue(defaultProp);
-  }
-  const constraints = extractStringArray(obj, "constraints");
-  if (constraints.length > 0) def.constraints = constraints;
-  return def;
-}
-function extractVariants(arg, sourceFile, warnings) {
-  const variantsProp = findProperty(arg, "variants");
-  if (!variantsProp || !ts2.isArrayLiteralExpression(variantsProp)) {
-    return [];
-  }
-  const variants = [];
-  for (const element of variantsProp.elements) {
-    if (ts2.isObjectLiteralExpression(element)) {
-      const name = extractStringProperty(element, "name");
-      const description = extractStringProperty(element, "description");
-      if (name) {
-        const variant = {
-          name,
-          description: description ?? ""
-        };
-        const codeProp = findProperty(element, "code");
-        if (codeProp && (ts2.isStringLiteral(codeProp) || ts2.isNoSubstitutionTemplateLiteral(codeProp))) {
-          variant.code = codeProp.text;
-        }
-        const renderProp = findProperty(element, "render");
-        if (renderProp && !variant.code) {
-          variant.code = extractRenderCode(renderProp, sourceFile);
-        }
-        const figma = extractStringProperty(element, "figma");
-        if (figma) {
-          variant.figma = figma;
+      if (fragment.accessibility.requirements && fragment.accessibility.requirements.length > 0) {
+        for (const req of fragment.accessibility.requirements) {
+          lines.push(`- ${req}`);
         }
-        const argsProp = findProperty(element, "args");
-        if (argsProp && ts2.isObjectLiteralExpression(argsProp)) {
-          const argsValue = extractLiteralValue(argsProp);
-          if (argsValue && typeof argsValue === "object" && !Array.isArray(argsValue)) {
-            variant.args = argsValue;
-          }
+      }
+      if (fragment.accessibility.keyboard) {
+        lines.push("");
+        lines.push("**Keyboard:**");
+        for (const [key, action] of Object.entries(fragment.accessibility.keyboard)) {
+          lines.push(`- \`${key}\`: ${action}`);
         }
-        variants.push(variant);
       }
+      lines.push("");
     }
-  }
-  return variants;
-}
-function dedent(str) {
-  const lines = str.split("\n");
-  if (lines.length <= 1) {
-    return str;
-  }
-  const firstLineIndent = lines[0].match(/^(\s*)/)?.[1].length ?? 0;
-  const startIndex = firstLineIndent === 0 ? 1 : 0;
-  let minIndent = Infinity;
-  for (let i = startIndex; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "") continue;
-    const match = line.match(/^(\s*)/);
-    if (match) {
-      minIndent = Math.min(minIndent, match[1].length);
+    if (include.relations && fragment?.related) {
+      lines.push("### Related");
+      if (fragment.related.similar && fragment.related.similar.length > 0) {
+        const resolved = fragment.related.similar.map((comp) => {
+          const path = resolveComponentPath2(comp, registry);
+          return path ? `${comp} (\`${path}\`)` : comp;
+        });
+        lines.push(`- **Similar:** ${resolved.join(", ")}`);
+      }
+      if (fragment.related.composedWith && fragment.related.composedWith.length > 0) {
+        const resolved = fragment.related.composedWith.map((comp) => {
+          const path = resolveComponentPath2(comp, registry);
+          return path ? `${comp} (\`${path}\`)` : comp;
+        });
+        lines.push(`- **Composed with:** ${resolved.join(", ")}`);
+      }
+      if (fragment.related.usedIn && fragment.related.usedIn.length > 0) {
+        const resolved = fragment.related.usedIn.map((comp) => {
+          const path = resolveComponentPath2(comp, registry);
+          return path ? `${comp} (\`${path}\`)` : comp;
+        });
+        lines.push(`- **Used in:** ${resolved.join(", ")}`);
+      }
+      lines.push("");
     }
+    lines.push("---");
+    lines.push("");
   }
-  if (minIndent === Infinity || minIndent === 0) {
-    return str;
-  }
-  return lines.map((line, index) => {
-    if (index === 0 && firstLineIndent === 0) {
-      return line;
-    }
-    return line.slice(minIndent);
-  }).join("\n");
+  const content = lines.join("\n");
+  return {
+    content,
+    tokenEstimate: estimateTokens(content),
+    componentCount
+  };
 }
-function extractRenderCode(renderProp, sourceFile) {
-  if (ts2.isArrowFunction(renderProp)) {
-    const body = renderProp.body;
-    const start = body.getStart(sourceFile);
-    const end = body.getEnd();
-    let code = sourceFile.text.substring(start, end).trim();
-    if (code.startsWith("(") && code.endsWith(")")) {
-      code = code.slice(1, -1).trim();
+function generateJsonContext(registry, include, compact) {
+  const componentNames = Object.keys(registry.components).sort();
+  const componentCount = componentNames.length;
+  const components = {};
+  for (const name of componentNames) {
+    const entry = registry.components[name];
+    const fragment = entry.fragment;
+    const component = {
+      path: entry.path
+    };
+    if (entry.category) component.category = entry.category;
+    if (entry.status) component.status = entry.status;
+    if (entry.description || fragment?.description) {
+      component.description = entry.description || fragment?.description;
     }
-    code = dedent(code);
-    return code;
-  }
-  return void 0;
-}
-function extractRelations(arg, warnings) {
-  const relationsProp = findProperty(arg, "relations");
-  if (!relationsProp || !ts2.isArrayLiteralExpression(relationsProp)) {
-    return [];
-  }
-  const relations = [];
-  for (const element of relationsProp.elements) {
-    if (ts2.isObjectLiteralExpression(element)) {
-      const component = extractStringProperty(element, "component");
-      const relationship = extractStringProperty(element, "relationship");
-      const note = extractStringProperty(element, "note");
-      if (component && relationship) {
-        relations.push({
-          component,
-          relationship,
-          note: note ?? ""
+    if (!compact && fragment?.usage) {
+      if (fragment.usage.when && fragment.usage.when.length > 0) {
+        component.whenToUse = fragment.usage.when;
+      }
+      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
+        component.doNot = fragment.usage.doNot.map((item) => {
+          if (typeof item === "string") {
+            return { text: item };
+          }
+          const doNotItem = item;
+          const result = {
+            text: doNotItem.text
+          };
+          if (doNotItem.instead) {
+            result.instead = doNotItem.instead;
+            result.insteadPath = resolveComponentPath2(doNotItem.instead, registry);
+          }
+          return result;
         });
       }
     }
+    if (!compact && include.props && entry.props) {
+      component.props = {};
+      for (const [propName, prop] of Object.entries(entry.props)) {
+        component.props[propName] = {
+          type: formatPropType(prop)
+        };
+        if (prop.required) component.props[propName].required = true;
+        if (prop.default !== void 0) component.props[propName].default = prop.default;
+        if (prop.description) component.props[propName].description = prop.description;
+      }
+    }
+    if (!compact && include.relations && fragment?.related) {
+      component.related = {};
+      if (fragment.related.similar) {
+        component.related.similar = fragment.related.similar.map((name2) => ({
+          name: name2,
+          path: resolveComponentPath2(name2, registry)
+        }));
+      }
+      if (fragment.related.composedWith) {
+        component.related.composedWith = fragment.related.composedWith.map((name2) => ({
+          name: name2,
+          path: resolveComponentPath2(name2, registry)
+        }));
+      }
+      if (fragment.related.usedIn) {
+        component.related.usedIn = fragment.related.usedIn.map((name2) => ({
+          name: name2,
+          path: resolveComponentPath2(name2, registry)
+        }));
+      }
+    }
+    components[name] = component;
   }
-  return relations;
+  const output = {
+    version: "1.0",
+    generatedAt: registry.generatedAt,
+    componentCount,
+    categories: registry.categories,
+    components
+  };
+  const content = JSON.stringify(output, null, 2);
+  return {
+    content,
+    tokenEstimate: estimateTokens(content),
+    componentCount
+  };
 }
-function extractAIMetadata(arg, warnings) {
-  const aiProp = findProperty(arg, "ai");
-  if (!aiProp || !ts2.isObjectLiteralExpression(aiProp)) {
-    return void 0;
-  }
-  const ai = {};
-  const compositionPattern = extractStringProperty(aiProp, "compositionPattern");
-  if (compositionPattern && ["compound", "simple", "controlled"].includes(compositionPattern)) {
-    ai.compositionPattern = compositionPattern;
-  }
-  const subComponents = extractStringArray(aiProp, "subComponents");
-  if (subComponents.length > 0) {
-    ai.subComponents = subComponents;
-  }
-  const requiredChildren = extractStringArray(aiProp, "requiredChildren");
-  if (requiredChildren.length > 0) {
-    ai.requiredChildren = requiredChildren;
-  }
-  const commonPatterns = extractStringArray(aiProp, "commonPatterns");
-  if (commonPatterns.length > 0) {
-    ai.commonPatterns = commonPatterns;
-  }
-  if (Object.keys(ai).length > 0) {
-    return ai;
-  }
-  return void 0;
+function resolveComponentPath2(componentName, registry) {
+  return registry.components[componentName]?.path;
 }
-function extractContractMetadata(arg) {
-  const contractProp = findProperty(arg, "contract");
-  if (!contractProp || !ts2.isObjectLiteralExpression(contractProp)) {
-    return void 0;
-  }
-  const contract = {};
-  const propsSummary = extractStringArray(contractProp, "propsSummary");
-  if (propsSummary.length > 0) {
-    contract.propsSummary = propsSummary;
-  }
-  const a11yRules = extractStringArray(contractProp, "a11yRules");
-  if (a11yRules.length > 0) {
-    contract.a11yRules = a11yRules;
-  }
-  if (Object.keys(contract).length > 0) {
-    return contract;
+function formatPropType(prop) {
+  if (prop.options && prop.options.length > 0) {
+    return prop.options.map((o) => `"${o}"`).join(" \\| ");
   }
-  return void 0;
+  return prop.type || "unknown";
 }
-function extractStringProperty(obj, name) {
-  const prop = findProperty(obj, name);
-  if (prop && ts2.isStringLiteral(prop)) {
-    return prop.text;
-  }
-  if (prop && ts2.isNoSubstitutionTemplateLiteral(prop)) {
-    return prop.text;
-  }
-  return null;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
 }
-function extractBooleanProperty(obj, name) {
-  const prop = findProperty(obj, name);
-  if (prop) {
-    if (prop.kind === ts2.SyntaxKind.TrueKeyword) return true;
-    if (prop.kind === ts2.SyntaxKind.FalseKeyword) return false;
-  }
-  return null;
+
+// src/core/importAnalyzer.ts
+import ts3 from "typescript";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, basename as basename4 } from "path";
+function extractComponentNameFromPath(filePath) {
+  const fileName = basename4(filePath);
+  if (fileName === "index.tsx" || fileName === "index.ts" || fileName === "index.jsx" || fileName === "index.js") {
+    const parentDir = basename4(dirname5(filePath));
+    return parentDir;
+  }
+  return fileName.replace(/\.(tsx?|jsx?)$/, "").replace(/\.stories$/, "").replace(/\.fragment$/, "").replace(/\.fragment$/, "");
 }
-function extractStringArray(obj, name) {
-  const prop = findProperty(obj, name);
-  if (!prop || !ts2.isArrayLiteralExpression(prop)) {
-    return [];
+function isComponentImportPath(importPath) {
+  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+    return false;
   }
-  const result = [];
-  for (const element of prop.elements) {
-    if (ts2.isStringLiteral(element)) {
-      result.push(element.text);
-    } else if (ts2.isNoSubstitutionTemplateLiteral(element)) {
-      result.push(element.text);
+  const skipPatterns = [
+    /\/hooks\//,
+    /\/utils\//,
+    /\/helpers\//,
+    /\/lib\//,
+    /\/types\//,
+    /\/constants\//,
+    /\/styles\//,
+    /\/context\//,
+    /\.css$/,
+    /\.scss$/,
+    /\.less$/,
+    /\.json$/
+  ];
+  for (const pattern of skipPatterns) {
+    if (pattern.test(importPath)) {
+      return false;
     }
   }
-  return result;
+  return true;
 }
-function extractLiteralValue(expr) {
-  if (ts2.isStringLiteral(expr)) {
-    return expr.text;
-  }
-  if (ts2.isNumericLiteral(expr)) {
-    return Number(expr.text);
-  }
-  if (expr.kind === ts2.SyntaxKind.TrueKeyword) {
-    return true;
-  }
-  if (expr.kind === ts2.SyntaxKind.FalseKeyword) {
-    return false;
-  }
-  if (expr.kind === ts2.SyntaxKind.NullKeyword) {
-    return null;
-  }
-  if (ts2.isArrayLiteralExpression(expr)) {
-    return expr.elements.map(extractLiteralValue);
+function isPascalCase(name) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function analyzeFileImports(filePath) {
+  const componentName = extractComponentNameFromPath(filePath);
+  const imports = [];
+  let sourceText;
+  try {
+    sourceText = readFileSync3(filePath, "utf-8");
+  } catch {
+    return { filePath, componentName, imports };
   }
-  if (ts2.isObjectLiteralExpression(expr)) {
-    const obj = {};
-    for (const prop of expr.properties) {
-      if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
-        obj[prop.name.text] = extractLiteralValue(prop.initializer);
+  const sourceFile = ts3.createSourceFile(
+    filePath,
+    sourceText,
+    ts3.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
+  );
+  ts3.forEachChild(sourceFile, (node) => {
+    if (ts3.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (!ts3.isStringLiteral(moduleSpecifier)) return;
+      const importPath = moduleSpecifier.text;
+      if (!isComponentImportPath(importPath)) return;
+      const importClause = node.importClause;
+      if (!importClause) return;
+      if (importClause.name) {
+        const name = importClause.name.text;
+        if (isPascalCase(name)) {
+          imports.push({
+            name,
+            path: importPath,
+            isDefault: true,
+            isNamespace: false
+          });
+        }
+      }
+      const namedBindings = importClause.namedBindings;
+      if (namedBindings) {
+        if (ts3.isNamedImports(namedBindings)) {
+          for (const element of namedBindings.elements) {
+            const name = element.name.text;
+            if (isPascalCase(name)) {
+              imports.push({
+                name,
+                path: importPath,
+                isDefault: false,
+                isNamespace: false
+              });
+            }
+          }
+        } else if (ts3.isNamespaceImport(namedBindings)) {
+          const name = namedBindings.name.text;
+          imports.push({
+            name,
+            path: importPath,
+            isDefault: false,
+            isNamespace: true
+          });
+        }
       }
     }
-    return obj;
-  }
-  return void 0;
-}
-
-// src/core/previewLoader.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve2 } from "path";
-var PREVIEW_FILES = [
-  "preview.tsx",
-  "preview.ts",
-  "preview.jsx",
-  "preview.js"
-];
-function findPreviewConfigPath(storybookDir) {
-  for (const fileName of PREVIEW_FILES) {
-    const filePath = join3(storybookDir, fileName);
-    if (existsSync3(filePath)) {
-      return filePath;
-    }
-  }
-  return null;
+  });
+  return { filePath, componentName, imports };
 }
-function findStorybookDir(projectRoot) {
-  const possiblePaths = [
-    join3(projectRoot, ".storybook"),
-    join3(projectRoot, "storybook")
-  ];
-  for (const dir of possiblePaths) {
-    if (existsSync3(dir)) {
-      return dir;
+function buildImportGraph(filePaths) {
+  const importedBy = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    const result = analyzeFileImports(filePath);
+    for (const imp of result.imports) {
+      if (imp.isNamespace) continue;
+      const importedComponent = imp.name;
+      const importingComponent = result.componentName;
+      if (importedComponent === importingComponent) continue;
+      const existing = importedBy.get(importedComponent) || [];
+      if (!existing.includes(importingComponent)) {
+        existing.push(importingComponent);
+        importedBy.set(importedComponent, existing);
+      }
     }
   }
-  return null;
+  return importedBy;
 }
-function generatePreviewModule(previewPath) {
-  if (!previewPath) {
-    return `
-export const decorators = [];
-export const parameters = {};
-export const globalTypes = {};
-export const args = {};
-export const argTypes = {};
-export const loaders = [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
-  }
-  return `
-import * as preview from "${previewPath}";
-
-export const decorators = preview.decorators ?? preview.default?.decorators ?? [];
-export const parameters = preview.parameters ?? preview.default?.parameters ?? {};
-export const globalTypes = preview.globalTypes ?? preview.default?.globalTypes ?? {};
-export const args = preview.args ?? preview.default?.args ?? {};
-export const argTypes = preview.argTypes ?? preview.default?.argTypes ?? {};
-export const loaders = preview.loaders ?? preview.default?.loaders ?? [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
+function getImportedBy(componentName, importGraph) {
+  return importGraph.get(componentName) || [];
 }
 
-// src/core/importAnalyzer.ts
-import ts3 from "typescript";
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, basename as basename3 } from "path";
-
 export {
   findConfigFile,
   loadConfig,
+  discoverBlockFiles,
+  discoverRecipeFiles,
+  discoverFragmentFiles,
+  discoverComponentFiles,
+  extractComponentName,
+  discoverComponentsFromSource,
+  discoverComponentsFromBarrel,
+  discoverTokenFiles,
+  discoverInstalledFragments,
+  discoverAllComponents,
   loadFragmentFile,
+  loadFragmentFiles,
   parseFragmentFile,
   findPreviewConfigPath,
   findStorybookDir,
+  loadPreviewConfig,
+  autoLoadPreviewConfig,
   generatePreviewModule,
   extractPropsFromFile,
+  extractPropsFromSource,
   generateRegistry,
-  generateContextMd
+  resolveComponentPath,
+  getComponentsByCategory,
+  generateContextMd,
+  analyzeFileImports,
+  buildImportGraph,
+  getImportedBy
 };
-//# sourceMappingURL=chunk-55KERLWL.js.map
+//# sourceMappingURL=chunk-HQ6A6DTV.js.map