@fragments-sdk/cli 0.2.2

package/dist/chunk-OAENNG3G.js

@@ -0,0 +1,1489 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  BRAND,
+  segmentsConfigSchema
+} from "./chunk-XHNKNI6J.js";
+
+// src/core/config.ts
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { createJiti } from "jiti";
+var DEFAULT_CONFIG = {
+  include: [
+    `src/**/*${BRAND.fileExtension}`,
+    // *.segment.tsx files
+    "src/**/*.stories.tsx"
+    // Storybook stories (auto-converted)
+  ],
+  exclude: ["**/node_modules/**"],
+  components: ["src/**/index.tsx", "src/**/*.tsx"],
+  framework: "react"
+};
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    const configPath = resolve(currentDir, BRAND.configFile);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+    const legacyConfigPath = resolve(currentDir, BRAND.legacyConfigFile);
+    if (existsSync(legacyConfigPath)) {
+      return legacyConfigPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  const resolvedPath = configPath ?? findConfigFile();
+  if (!resolvedPath) {
+    return {
+      config: DEFAULT_CONFIG,
+      configDir: process.cwd()
+    };
+  }
+  try {
+    const jiti = createJiti(import.meta.url, {
+      interopDefault: true
+    });
+    const rawConfig = await jiti.import(resolvedPath);
+    const result = segmentsConfigSchema.safeParse(rawConfig);
+    if (!result.success) {
+      const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+      throw new Error(`Invalid config in ${resolvedPath}:
+${errors}`);
+    }
+    return {
+      config: { ...DEFAULT_CONFIG, ...result.data },
+      configDir: dirname(resolvedPath)
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Invalid config")) {
+      throw error;
+    }
+    throw new Error(`Failed to load config from ${resolvedPath}: ${error}`);
+  }
+}
+
+// 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";
+async function discoverRecipeFiles(configDir, exclude) {
+  const pattern = `**/*${BRAND.recipeFileExtension}`;
+  const files = await fg(pattern, {
+    cwd: configDir,
+    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
+    absolute: false
+  });
+  return files.map((relativePath) => ({
+    relativePath,
+    absolutePath: resolve2(configDir, relativePath)
+  }));
+}
+async function discoverSegmentFiles(config, configDir) {
+  const files = await fg(config.include, {
+    cwd: configDir,
+    ignore: 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 [];
+  }
+  const files = await fg(config.components, {
+    cwd: configDir,
+    ignore: [
+      ...config.exclude ?? [],
+      // Exclude segment 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 fileName.replace(/\.(tsx?|jsx?)$/, "");
+}
+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 componentFiles = files.filter((file) => {
+    const name = extractComponentName(file);
+    return /^[A-Z]/.test(name);
+  });
+  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 componentFiles) {
+    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
+    });
+  }
+  components.sort((a, b) => a.name.localeCompare(b.name));
+  return components;
+}
+async function discoverComponentsFromBarrel(barrelPath, configDir) {
+  const absoluteBarrelPath = resolve2(configDir, barrelPath);
+  if (!existsSync2(absoluteBarrelPath)) {
+    return [];
+  }
+  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 (!existsSync2(resolvedPath)) {
+      continue;
+    }
+    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 components;
+}
+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 Array.from(componentsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// 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);
+}
+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 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
+      );
+      if (hasExport) {
+        componentExports.push(node.name.text);
+      }
+    }
+    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);
+          }
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node) && node.exportClause) {
+      if (ts.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;
+  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 (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;
+        }
+      }
+    }
+  }
+  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;
+          }
+        }
+      }
+    }
+  }
+  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 === 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" };
+  }
+  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;
+      }
+    }
+    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 (typeName === "JSX.Element") {
+      return { type: "JSX.Element", typeKind: "element" };
+    }
+    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"
+  };
+}
+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("");
+    }
+  }
+  return void 0;
+}
+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;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/core/generators/registry.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { relative, dirname as dirname3, basename as basename2, join } 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 = 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 fg2(storyPatterns, {
+    cwd: projectRoot,
+    ignore: ["**/node_modules/**"],
+    absolute: true
+  });
+  const storyMap = /* @__PURE__ */ new Map();
+  for (const storyPath of storyFiles) {
+    const storyDir = dirname3(storyPath);
+    const storyBase = basename2(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
+    storyMap.set(`${storyDir}/${storyBase}`, storyPath);
+  }
+  const componentFiles = await fg2(componentPatterns, {
+    cwd: projectRoot,
+    ignore: [
+      "**/node_modules/**",
+      "**/*.stories.*",
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.d.ts"
+    ],
+    absolute: true
+  });
+  const fragmentPattern = join(
+    BRAND.dataDir,
+    BRAND.componentsDir,
+    `*${BRAND.fileExtension}`
+  );
+  const fragmentFiles = await fg2(fragmentPattern, {
+    cwd: projectRoot,
+    absolute: true
+  });
+  const fragmentMap = /* @__PURE__ */ new Map();
+  for (const fragmentPath of fragmentFiles) {
+    const fragmentName = basename2(fragmentPath).replace(BRAND.fileExtension, "");
+    try {
+      const content = readFileSync2(fragmentPath, "utf-8");
+      const fragment = JSON.parse(content);
+      fragmentMap.set(fragmentName, {
+        path: relative(projectRoot, fragmentPath),
+        fragment
+      });
+    } catch (e) {
+      errors.push({
+        file: fragmentPath,
+        error: `Failed to parse fragment: ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+  const components = {};
+  const indexComponents = {};
+  const categories = {};
+  for (const filePath of componentFiles) {
+    try {
+      const extracted = extractPropsFromFile(filePath);
+      if (!extracted || !extracted.componentName) {
+        continue;
+      }
+      const componentName = extracted.componentName;
+      const relativePath = relative(projectRoot, filePath);
+      if (publicOnly && !extracted.exports.includes(componentName)) {
+        continue;
+      }
+      const componentDir = dirname3(filePath);
+      const baseNameWithoutExt = basename2(filePath).replace(/\.(tsx?|jsx?)$/, "");
+      const storyPath = storyMap.get(`${componentDir}/${baseNameWithoutExt}`);
+      if (requireStory && !storyPath) {
+        continue;
+      }
+      const fragmentData = fragmentMap.get(componentName);
+      const category = fragmentData?.fragment?.meta?.status ? void 0 : getCategoryFromPath(relativePath, categoryDepth);
+      const hasEnrichment = fragmentData ? hasRealEnrichment(fragmentData.fragment) : false;
+      const entry = {
+        path: relativePath
+      };
+      if (storyPath) {
+        entry.storyPath = relative(projectRoot, storyPath);
+      }
+      if (fragmentData) {
+        entry.fragmentPath = fragmentData.path;
+        if (hasEnrichment) {
+          entry.hasEnrichment = true;
+        }
+        if (fragmentData.fragment.description) {
+          entry.description = fragmentData.fragment.description;
+        }
+        if (fragmentData.fragment.meta?.status) {
+          entry.status = fragmentData.fragment.meta.status;
+        }
+        if (embedFragments) {
+          entry.fragment = fragmentData.fragment;
+        }
+      }
+      if (category) {
+        entry.category = category;
+        if (!categories[category]) {
+          categories[category] = [];
+        }
+        categories[category].push(componentName);
+      }
+      if (includeProps && extracted.props) {
+        entry.props = extracted.props;
+      }
+      if (extracted.exports.length > 1) {
+        entry.exports = extracted.exports;
+      }
+      components[componentName] = entry;
+      indexComponents[componentName] = relativePath;
+    } catch (e) {
+      errors.push({
+        file: filePath,
+        error: `Failed to extract component: ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+  const componentCount = Object.keys(components).length;
+  const registry = {
+    $schema: "https://fragments.dev/schema/registry-v1.json",
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    componentCount,
+    components,
+    categories
+  };
+  const index = {
+    version: "1.0",
+    generatedAt: registry.generatedAt,
+    components: indexComponents,
+    categories
+  };
+  return { registry, index, errors, warnings };
+}
+function getCategoryFromPath(relativePath, depth = 1) {
+  const parts = relativePath.split("/");
+  const componentsIndex = parts.findIndex((p) => p === "components");
+  if (componentsIndex === -1) {
+    return void 0;
+  }
+  const afterComponents = parts.slice(componentsIndex + 1);
+  if (afterComponents.length <= 1) {
+    return void 0;
+  }
+  const folderName = afterComponents[0];
+  const fileName = afterComponents[afterComponents.length - 1].replace(/\.(tsx?|jsx?)$/, "");
+  if (afterComponents.length === 2 && folderName === fileName) {
+    return void 0;
+  }
+  const categoryParts = afterComponents.slice(0, Math.min(depth, afterComponents.length - 1));
+  const lastCategoryPart = categoryParts[categoryParts.length - 1];
+  if (lastCategoryPart === fileName) {
+    categoryParts.pop();
+  }
+  if (categoryParts.length === 0) {
+    return void 0;
+  }
+  return categoryParts.join("/");
+}
+function hasRealEnrichment(fragment) {
+  if (fragment.description && fragment.description.length > 20) {
+    return true;
+  }
+  if (fragment.usage?.when && fragment.usage.when.length > 0) {
+    return true;
+  }
+  if (fragment.usage?.doNot && fragment.usage.doNot.length > 0) {
+    return true;
+  }
+  if (fragment.usage?.patterns && fragment.usage.patterns.length > 0) {
+    return true;
+  }
+  if (fragment.accessibility?.requirements && fragment.accessibility.requirements.length > 0) {
+    return true;
+  }
+  if (fragment.figma?.nodeId || fragment.figma?.variants) {
+    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;
+  }
+  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 resolveComponentPath(componentName, registry) {
+  return registry.components[componentName]?.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);
+}
+
+// src/core/loader.ts
+import { unlink } from "fs/promises";
+import { dirname as dirname4, basename as basename3, join as join2 } from "path";
+import { pathToFileURL } from "url";
+import { build } from "esbuild";
+var DEFINE_SEGMENT_SHIM = `
+export function defineSegment(def) {
+  return def;
+}
+export function defineFragment(def) {
+  return def;
+}
+export function defineRecipe(def) {
+  return def;
+}
+`;
+function createSegmentsCoreShimPlugin() {
+  return {
+    name: BRAND.vitePluginNamespace,
+    setup(build2) {
+      build2.onResolve({ filter: /^@fragments\/core$/ }, (args) => {
+        return {
+          path: args.path,
+          namespace: BRAND.vitePluginNamespace
+        };
+      });
+      build2.onLoad({ filter: /.*/, namespace: BRAND.vitePluginNamespace }, () => {
+        return {
+          contents: DEFINE_SEGMENT_SHIM,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+async function loadSegmentFile(absolutePath) {
+  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 module.default ?? null;
+  }
+  const sourceDir = dirname4(absolutePath);
+  const baseName = basename3(absolutePath, `.${ext}`);
+  const tempFile = join2(sourceDir, `.${baseName}.segments-temp-${Date.now()}.cjs`);
+  try {
+    await build({
+      entryPoints: [absolutePath],
+      outfile: tempFile,
+      bundle: true,
+      format: "cjs",
+      // Use CommonJS to avoid ESM issues with lodash, etc.
+      target: "es2022",
+      jsx: "automatic",
+      platform: "node",
+      plugins: [createSegmentsCoreShimPlugin()],
+      // Externalize all node_modules - we only need segment 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 module.default ?? null;
+  } finally {
+    try {
+      await unlink(tempFile);
+    } catch {
+    }
+  }
+}
+
+// src/core/parser.ts
+import ts2 from "typescript";
+function parseSegmentFile(fileContent, filePath) {
+  const warnings = [];
+  const sourceFile = ts2.createSourceFile(
+    filePath ?? "segment.tsx",
+    fileContent,
+    ts2.ScriptTarget.Latest,
+    true,
+    ts2.ScriptKind.TSX
+  );
+  const imports = extractImports(sourceFile);
+  const defineSegmentCall = findDefineSegmentCall(sourceFile);
+  if (!defineSegmentCall) {
+    warnings.push("No defineSegment() call found");
+    return {
+      componentImport: null,
+      componentName: null,
+      meta: {},
+      usage: { when: [], whenNot: [] },
+      props: {},
+      variants: [],
+      relations: [],
+      warnings
+    };
+  }
+  const arg = defineSegmentCall.arguments[0];
+  if (!arg || !ts2.isObjectLiteralExpression(arg)) {
+    warnings.push("defineSegment() 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 && 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);
+  return {
+    componentImport,
+    componentName,
+    meta,
+    usage,
+    props,
+    variants,
+    relations,
+    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);
+            }
+          }
+        }
+      }
+    }
+  });
+  return imports;
+}
+function findDefineSegmentCall(sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (ts2.isCallExpression(node)) {
+      const expression = node.expression;
+      if (ts2.isIdentifier(expression) && expression.text === "defineSegment") {
+        result = node;
+        return;
+      }
+    }
+    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;
+      }
+    }
+  }
+  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;
+  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);
+      }
+    }
+  }
+  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)) {
+          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 && ts2.isObjectLiteralExpression(argsProp)) {
+          const argsValue = extractLiteralValue(argsProp);
+          if (argsValue && typeof argsValue === "object" && !Array.isArray(argsValue)) {
+            variant.args = argsValue;
+          }
+        }
+        variants.push(variant);
+      }
+    }
+  }
+  return variants;
+}
+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();
+    }
+    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 ?? ""
+        });
+      }
+    }
+  }
+  return relations;
+}
+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 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;
+}
+function extractStringArray(obj, name) {
+  const prop = findProperty(obj, name);
+  if (!prop || !ts2.isArrayLiteralExpression(prop)) {
+    return [];
+  }
+  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);
+    }
+  }
+  return result;
+}
+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);
+  }
+  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);
+      }
+    }
+    return obj;
+  }
+  return void 0;
+}
+
+// src/core/previewLoader.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, 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 = join3(storybookDir, fileName);
+    if (existsSync4(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function findStorybookDir(projectRoot) {
+  const possiblePaths = [
+    join3(projectRoot, ".storybook"),
+    join3(projectRoot, "storybook")
+  ];
+  for (const dir of possiblePaths) {
+    if (existsSync4(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+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/importAnalyzer.ts
+import ts3 from "typescript";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, basename as basename4 } from "path";
+
+export {
+  findConfigFile,
+  loadConfig,
+  discoverRecipeFiles,
+  discoverSegmentFiles,
+  discoverComponentFiles,
+  extractComponentName,
+  discoverAllComponents,
+  loadSegmentFile,
+  parseSegmentFile,
+  findPreviewConfigPath,
+  findStorybookDir,
+  generatePreviewModule,
+  extractPropsFromFile,
+  generateRegistry,
+  generateContextMd
+};
+//# sourceMappingURL=chunk-OAENNG3G.js.map