@fragments-sdk/cli 0.15.0 → 0.15.1

package/dist/chunk-7WHVW72L.js

@@ -1,2664 +0,0 @@
-import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
-import {
-  createComponentExtractor
-} from "./chunk-MN3TJ3D5.js";
-import {
-  discoverBlockFiles,
-  discoverComponentFiles,
-  discoverFragmentFiles,
-  discoverTokenFiles,
-  extractComponentName,
-  generateContextMd,
-  generateRegistry,
-  loadFragmentFile,
-  parseFragmentFile
-} from "./chunk-65WSVDV5.js";
-import {
-  BrowserPool,
-  CaptureEngine,
-  DiffEngine,
-  StorageManager,
-  analyzeDesignSystem,
-  formatMs,
-  generateHtmlReport,
-  getGrade
-} from "./chunk-XJQ5BIWI.js";
-import {
-  BRAND,
-  DEFAULTS,
-  classifyComplexity,
-  compileBlock,
-  fragmentDefinitionSchema,
-  isContractFile,
-  isDTCGFile,
-  parseComponentContract,
-  parseDTCGFile,
-  parseTokenFile,
-  resolvePerformanceConfig
-} from "./chunk-32LIWN2P.js";
-
-// src/service/snippet-validation.ts
-import ts from "typescript";
-import { readFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-var INTRINSIC_TAGS = /* @__PURE__ */ new Set([
-  "div",
-  "span",
-  "p",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "main",
-  "section",
-  "article",
-  "aside",
-  "nav",
-  "header",
-  "footer",
-  "ul",
-  "ol",
-  "li",
-  "button",
-  "input",
-  "textarea",
-  "label",
-  "svg",
-  "path"
-]);
-var JSX_TAG_PATTERN = /<\s*([A-Za-z][A-Za-z0-9.]*)\b/g;
-var STYLE_PATTERN = /\bstyle\s*=\s*\{/;
-var TRANSPILED_PATTERN = /jsxDEV|_jsx|@__PURE__|\bfileName\s*:|\blineNumber\s*:|\bcolumnNumber\s*:/;
-var ALIAS_DRIFT_PATTERN = /<\s*[A-Z][A-Za-z0-9]*(?:Root|2)\b/;
-var HAS_IMPORT_PATTERN = /\bimport\s+[^;]+\s+from\s+['"][^'"]+['"]/;
-var HAS_JSX_PATTERN = /<\s*[A-Za-z][A-Za-z0-9.]*\b/;
-var DEFAULT_POLICY = {
-  mode: "warn",
-  scope: "snippet+render",
-  requireFullSnippet: true,
-  allowedExternalModules: /* @__PURE__ */ new Set([
-    "@phosphor-icons/react",
-    "recharts",
-    "react-day-picker"
-  ])
-};
-function normalizePolicy(configured, overrides) {
-  const fromConfig = {
-    mode: configured?.mode ?? DEFAULT_POLICY.mode,
-    scope: configured?.scope ?? DEFAULT_POLICY.scope,
-    requireFullSnippet: configured?.requireFullSnippet ?? DEFAULT_POLICY.requireFullSnippet,
-    allowedExternalModules: new Set(configured?.allowedExternalModules ?? [...DEFAULT_POLICY.allowedExternalModules]),
-    componentStart: overrides.componentStart,
-    componentLimit: overrides.componentLimit
-  };
-  if (overrides.mode) fromConfig.mode = overrides.mode;
-  if (overrides.scope) fromConfig.scope = overrides.scope;
-  if (typeof overrides.requireFullSnippet === "boolean") {
-    fromConfig.requireFullSnippet = overrides.requireFullSnippet;
-  }
-  if (overrides.allowedExternalModules && overrides.allowedExternalModules.length > 0) {
-    fromConfig.allowedExternalModules = new Set(overrides.allowedExternalModules);
-  }
-  return fromConfig;
-}
-function isFragmentsModule(modulePath) {
-  return modulePath === "@fragments-sdk/ui" || modulePath === "." || modulePath === ".." || modulePath.startsWith("@/components/") || modulePath.startsWith("@components/") || modulePath.startsWith("./") || modulePath.startsWith("../");
-}
-function collectSourceContext(sourceFile) {
-  const imports = /* @__PURE__ */ new Map();
-  const localComponents = /* @__PURE__ */ new Set();
-  function markLocal(name) {
-    if (!name) return;
-    if (/^[A-Z]/.test(name)) {
-      localComponents.add(name);
-    }
-  }
-  function visit(node) {
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-      const modulePath = node.moduleSpecifier.text;
-      const clause = node.importClause;
-      if (clause?.name) {
-        imports.set(clause.name.text, modulePath);
-      }
-      if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-        for (const item of clause.namedBindings.elements) {
-          imports.set(item.name.text, modulePath);
-        }
-      }
-    }
-    if (ts.isFunctionDeclaration(node)) {
-      markLocal(node.name?.text);
-    }
-    if (ts.isClassDeclaration(node)) {
-      markLocal(node.name?.text);
-    }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-      markLocal(node.name.text);
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return { imports, localComponents };
-}
-function getJsxTags(code) {
-  const tags = [];
-  JSX_TAG_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = JSX_TAG_PATTERN.exec(code)) !== null) {
-    tags.push(match[1]);
-  }
-  return tags;
-}
-function rootTagName(tag) {
-  return tag.split(".")[0];
-}
-function parseSnippetImports(snippet) {
-  const sourceFile = ts.createSourceFile(
-    "snippet.tsx",
-    snippet,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TSX
-  );
-  return collectSourceContext(sourceFile).imports;
-}
-function findDefineCall(sourceFile, name) {
-  let result = null;
-  function visit(node) {
-    if (result) return;
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name) {
-      result = node;
-      return;
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return result;
-}
-function findProperty(obj, propertyName) {
-  for (const prop of obj.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue;
-    if (!ts.isIdentifier(prop.name)) continue;
-    if (prop.name.text === propertyName) {
-      return prop.initializer;
-    }
-  }
-  return null;
-}
-function readStaticString(expr) {
-  if (!expr) return null;
-  if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
-    return expr.text;
-  }
-  return null;
-}
-function readRenderBody(renderExpr, sourceFile) {
-  if (!ts.isArrowFunction(renderExpr) && !ts.isFunctionExpression(renderExpr)) {
-    return null;
-  }
-  const body = renderExpr.body;
-  const start = body.getStart(sourceFile);
-  const end = body.getEnd();
-  return sourceFile.text.slice(start, end).trim();
-}
-function report(issues, file, message) {
-  issues.push({ file, message });
-}
-function validateRawRules(issues, file, label, code) {
-  if (STYLE_PATTERN.test(code)) {
-    report(issues, file, `${label}: inline style usage is not allowed; use Box/Stack/Text props.`);
-  }
-  if (TRANSPILED_PATTERN.test(code)) {
-    report(issues, file, `${label}: transpiler output detected (jsxDEV/_jsx/@__PURE__). Use authored snippet source.`);
-  }
-  if (ALIAS_DRIFT_PATTERN.test(code)) {
-    report(issues, file, `${label}: alias drift tag detected (*Root/*2). Use canonical component names.`);
-  }
-  const tags = getJsxTags(code);
-  const intrinsic = tags.map((tag) => rootTagName(tag)).filter((tag) => /^[a-z]/.test(tag)).map((tag) => tag.toLowerCase()).filter((tag) => INTRINSIC_TAGS.has(tag));
-  if (intrinsic.length > 0) {
-    const names = [...new Set(intrinsic)].sort().join(", ");
-    report(issues, file, `${label}: raw HTML tags are not allowed (${names}). Use Fragments primitives.`);
-  }
-}
-function validateComponentAllowlist(issues, file, label, code, imports, localComponents, policy) {
-  const tags = getJsxTags(code);
-  const seen = /* @__PURE__ */ new Set();
-  for (const tag of tags) {
-    const root = rootTagName(tag);
-    if (seen.has(root)) continue;
-    seen.add(root);
-    if (!/^[A-Z]/.test(root)) {
-      continue;
-    }
-    const modulePath = imports.get(root);
-    if (modulePath) {
-      if (isFragmentsModule(modulePath)) {
-        continue;
-      }
-      if (policy.allowedExternalModules.has(modulePath)) {
-        continue;
-      }
-      report(
-        issues,
-        file,
-        `${label}: component "${root}" comes from "${modulePath}" and is not in snippets.allowedExternalModules.`
-      );
-      continue;
-    }
-    if (localComponents.has(root)) {
-      report(
-        issues,
-        file,
-        `${label}: locally defined JSX component "${root}" is not allowed in snippets/renders. Import approved components instead.`
-      );
-      continue;
-    }
-    report(
-      issues,
-      file,
-      `${label}: component "${root}" is used without an import and is not allowed.`
-    );
-  }
-}
-function validateSnippetString(issues, file, label, snippet, policy) {
-  validateRawRules(issues, file, label, snippet);
-  if (policy.requireFullSnippet) {
-    if (!HAS_IMPORT_PATTERN.test(snippet)) {
-      report(issues, file, `${label}: full snippet required (missing import statement).`);
-    }
-    if (!HAS_JSX_PATTERN.test(snippet)) {
-      report(issues, file, `${label}: full snippet required (missing JSX usage).`);
-    }
-  }
-  const imports = parseSnippetImports(snippet);
-  validateComponentAllowlist(issues, file, label, snippet, imports, /* @__PURE__ */ new Set(), policy);
-}
-function validateFragmentSource(sourceFile, file, policy, issues) {
-  const context = collectSourceContext(sourceFile);
-  const defineCall = findDefineCall(sourceFile, "defineFragment");
-  if (!defineCall) {
-    return;
-  }
-  const arg = defineCall.arguments[0];
-  if (!arg || !ts.isObjectLiteralExpression(arg)) {
-    return;
-  }
-  const variantsExpr = findProperty(arg, "variants");
-  if (!variantsExpr || !ts.isArrayLiteralExpression(variantsExpr)) {
-    return;
-  }
-  for (const variantExpr of variantsExpr.elements) {
-    if (!ts.isObjectLiteralExpression(variantExpr)) continue;
-    const name = readStaticString(findProperty(variantExpr, "name")) ?? "Unknown";
-    const labelPrefix = `variant "${name}"`;
-    const codeExpr = findProperty(variantExpr, "code");
-    const snippet = readStaticString(codeExpr);
-    if (snippet) {
-      validateSnippetString(issues, file, `${labelPrefix} snippet`, snippet, policy);
-    } else {
-      report(issues, file, `${labelPrefix}: missing explicit code snippet (variant.code).`);
-    }
-    if (policy.scope === "snippet+render") {
-      const renderExpr = findProperty(variantExpr, "render");
-      if (renderExpr) {
-        const renderBody = readRenderBody(renderExpr, sourceFile);
-        if (!renderBody) {
-          report(issues, file, `${labelPrefix} render: expected a static render function.`);
-          continue;
-        }
-        validateRawRules(issues, file, `${labelPrefix} render`, renderBody);
-        validateComponentAllowlist(
-          issues,
-          file,
-          `${labelPrefix} render`,
-          renderBody,
-          context.imports,
-          context.localComponents,
-          policy
-        );
-      }
-    }
-  }
-}
-function validateBlockSource(sourceFile, file, policy, issues) {
-  const defineCall = findDefineCall(sourceFile, "defineBlock");
-  if (!defineCall) {
-    return;
-  }
-  const arg = defineCall.arguments[0];
-  if (!arg || !ts.isObjectLiteralExpression(arg)) {
-    return;
-  }
-  const codeExpr = findProperty(arg, "code");
-  const snippet = readStaticString(codeExpr);
-  if (!snippet) {
-    report(issues, file, "block snippet: missing static code string.");
-    return;
-  }
-  validateSnippetString(issues, file, "block snippet", snippet, policy);
-}
-function validateBlockPreviewExamples(sourceFile, file, policy, issues) {
-  if (policy.scope !== "snippet+render") {
-    return;
-  }
-  const code = sourceFile.text;
-  const context = collectSourceContext(sourceFile);
-  validateRawRules(issues, file, "block preview render", code);
-  validateComponentAllowlist(
-    issues,
-    file,
-    "block preview render",
-    code,
-    context.imports,
-    context.localComponents,
-    policy
-  );
-}
-function sourceFileFromText(filePath, content) {
-  return ts.createSourceFile(
-    filePath,
-    content,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TSX
-  );
-}
-function sortAndFilterBatch(files, componentStart, componentLimit) {
-  const getComponentName = (relativePath) => {
-    const normalized = relativePath.replace(/\\/g, "/");
-    const fileName = normalized.split("/").pop() ?? normalized;
-    for (const ext of [BRAND.fileExtension, ".fragment.tsx", ".fragment.ts"]) {
-      if (fileName.endsWith(ext)) {
-        return fileName.slice(0, -ext.length);
-      }
-    }
-    return extractComponentName(relativePath);
-  };
-  const sorted = [...files].sort((a, b) => {
-    const nameA = getComponentName(a.relativePath).toLowerCase();
-    const nameB = getComponentName(b.relativePath).toLowerCase();
-    return nameA.localeCompare(nameB);
-  });
-  if (!componentStart && !componentLimit) {
-    return { selected: sorted };
-  }
-  const startName = componentStart?.toLowerCase();
-  let startIndex = 0;
-  if (startName) {
-    const foundIndex = sorted.findIndex((file) => getComponentName(file.relativePath).toLowerCase() === startName);
-    if (foundIndex === -1) {
-      return {
-        selected: [],
-        warning: `Component start "${componentStart}" not found for snippet validation batch.`
-      };
-    }
-    startIndex = foundIndex;
-  }
-  const limit = componentLimit && componentLimit > 0 ? componentLimit : sorted.length;
-  return {
-    selected: sorted.slice(startIndex, startIndex + limit)
-  };
-}
-async function findBlockPreviewExamplesFile(configDir) {
-  const candidates = [
-    join(configDir, "apps/docs/src/app/(docs)/blocks/examples/index.tsx"),
-    join(configDir, "../apps/docs/src/app/(docs)/blocks/examples/index.tsx"),
-    join(configDir, "../../apps/docs/src/app/(docs)/blocks/examples/index.tsx")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function toValidationResult(policy, issues) {
-  if (policy.mode === "error") {
-    return {
-      errors: issues,
-      warnings: []
-    };
-  }
-  return {
-    errors: [],
-    warnings: issues
-  };
-}
-async function validateSnippetPolicy(config, configDir, options = {}) {
-  const policy = normalizePolicy(config.snippets, options);
-  const issues = [];
-  const discovered = await discoverFragmentFiles(config, configDir);
-  const fragmentFiles = discovered.filter(
-    (file) => file.relativePath.endsWith(".fragment.tsx") || file.relativePath.endsWith(".fragment.ts")
-  );
-  const batchResult = sortAndFilterBatch(fragmentFiles, policy.componentStart, policy.componentLimit);
-  if (batchResult.warning) {
-    issues.push({ file: "snippets", message: batchResult.warning });
-  }
-  for (const file of batchResult.selected) {
-    try {
-      const content = await readFile(file.absolutePath, "utf-8");
-      const sourceFile = sourceFileFromText(file.relativePath, content);
-      validateFragmentSource(sourceFile, file.relativePath, policy, issues);
-    } catch (error) {
-      issues.push({
-        file: file.relativePath,
-        message: `Failed to validate fragment snippets: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  const isBatchOnly = Boolean(policy.componentStart || policy.componentLimit);
-  if (!isBatchOnly) {
-    try {
-      const blockFiles = await discoverBlockFiles(configDir, config.exclude);
-      for (const file of blockFiles) {
-        try {
-          const content = await readFile(file.absolutePath, "utf-8");
-          const sourceFile = sourceFileFromText(file.relativePath, content);
-          validateBlockSource(sourceFile, file.relativePath, policy, issues);
-        } catch (error) {
-          issues.push({
-            file: file.relativePath,
-            message: `Failed to validate block snippets: ${error instanceof Error ? error.message : String(error)}`
-          });
-        }
-      }
-    } catch (error) {
-      issues.push({
-        file: "blocks",
-        message: `Failed to discover block files: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-    const blockPreviewFile = await findBlockPreviewExamplesFile(configDir);
-    if (blockPreviewFile) {
-      try {
-        const content = await readFile(blockPreviewFile, "utf-8");
-        const sourceFile = sourceFileFromText(blockPreviewFile, content);
-        validateBlockPreviewExamples(sourceFile, blockPreviewFile, policy, issues);
-      } catch (error) {
-        issues.push({
-          file: blockPreviewFile,
-          message: `Failed to validate block preview examples: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-  }
-  return toValidationResult(policy, issues);
-}
-
-// src/core/auto-props.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { dirname, extname, join as join2, resolve } from "path";
-import ts2 from "typescript";
-function isFile(filePath) {
-  if (!existsSync2(filePath)) return false;
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function resolveModulePath(basePath) {
-  const candidates = [];
-  const extension = extname(basePath);
-  if (extension) {
-    candidates.push(basePath);
-  } else {
-    candidates.push(
-      `${basePath}.tsx`,
-      `${basePath}.ts`,
-      `${basePath}.jsx`,
-      `${basePath}.js`,
-      join2(basePath, "index.tsx"),
-      join2(basePath, "index.ts"),
-      join2(basePath, "index.jsx"),
-      join2(basePath, "index.js")
-    );
-  }
-  for (const candidate of candidates) {
-    if (isFile(candidate)) {
-      return resolve(candidate);
-    }
-  }
-  return null;
-}
-function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
-  if (!componentImportPath) return null;
-  if (!componentImportPath.startsWith(".")) return null;
-  const fragmentDir = dirname(fragmentFileAbsolutePath);
-  const basePath = resolve(fragmentDir, componentImportPath);
-  return resolveModulePath(basePath);
-}
-
-// src/validators.ts
-import { readFile as readFile2 } from "fs/promises";
-async function validateSchema(config, configDir) {
-  const files = await discoverFragmentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  for (const file of files) {
-    try {
-      const fragment = await loadFragmentFile(file.absolutePath);
-      if (!fragment) {
-        errors.push({
-          file: file.relativePath,
-          message: "No default export found",
-          details: `Fragment files must have a default export from defineFragment()`
-        });
-        continue;
-      }
-      const result = fragmentDefinitionSchema.safeParse(fragment);
-      if (!result.success) {
-        const details = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
-        errors.push({
-          file: file.relativePath,
-          message: "Invalid fragment schema",
-          details
-        });
-      }
-    } catch (error) {
-      errors.push({
-        file: file.relativePath,
-        message: "Failed to load fragment file",
-        details: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateCoverage(config, configDir) {
-  const fragmentFiles = await discoverFragmentFiles(config, configDir);
-  const componentFiles = await discoverComponentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  const documentedComponents = /* @__PURE__ */ new Set();
-  for (const file of fragmentFiles) {
-    try {
-      const fragment = await loadFragmentFile(file.absolutePath);
-      if (fragment?.meta?.name) {
-        documentedComponents.add(fragment.meta.name);
-      }
-    } catch {
-    }
-  }
-  for (const file of componentFiles) {
-    const componentName = extractComponentName(file.relativePath);
-    const fragmentPath = file.relativePath.replace(
-      /\.(tsx?|jsx?)$/,
-      BRAND.fileExtension
-    );
-    const hasFragmentFile = fragmentFiles.some(
-      (s) => s.relativePath === fragmentPath
-    );
-    if (!hasFragmentFile && !documentedComponents.has(componentName)) {
-      warnings.push({
-        file: file.relativePath,
-        message: `Component "${componentName}" has no fragment documentation`
-      });
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateAll(config, configDir, options = {}) {
-  const [schemaResult, coverageResult] = await Promise.all([
-    validateSchema(config, configDir),
-    validateCoverage(config, configDir)
-  ]);
-  if (options.snippets === false) {
-    return {
-      valid: schemaResult.valid && coverageResult.valid,
-      errors: [...schemaResult.errors, ...coverageResult.errors],
-      warnings: [...schemaResult.warnings, ...coverageResult.warnings]
-    };
-  }
-  const snippetOptions = {
-    ...options.snippetMode && { mode: options.snippetMode },
-    ...options.componentStart && { componentStart: options.componentStart },
-    ...typeof options.componentLimit === "number" ? { componentLimit: options.componentLimit } : {}
-  };
-  const snippetResult = await validateSnippetPolicy(config, configDir, snippetOptions);
-  return {
-    valid: schemaResult.valid && coverageResult.valid && snippetResult.errors.length === 0,
-    errors: [...schemaResult.errors, ...coverageResult.errors, ...snippetResult.errors],
-    warnings: [...schemaResult.warnings, ...coverageResult.warnings, ...snippetResult.warnings]
-  };
-}
-async function validateSnippets(config, configDir, options = {}) {
-  const snippetResult = await validateSnippetPolicy(config, configDir, {
-    ...options.snippetMode && { mode: options.snippetMode },
-    ...options.componentStart && { componentStart: options.componentStart },
-    ...typeof options.componentLimit === "number" ? { componentLimit: options.componentLimit } : {}
-  });
-  return {
-    valid: snippetResult.errors.length === 0,
-    errors: snippetResult.errors,
-    warnings: snippetResult.warnings
-  };
-}
-async function validateDrift(config, configDir, options = {}) {
-  const fragmentFiles = await discoverFragmentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  const reports = [];
-  if (fragmentFiles.length === 0) {
-    return { valid: true, errors, warnings, reports };
-  }
-  const extractor = createComponentExtractor(options.tsconfig);
-  try {
-    for (const file of fragmentFiles) {
-      try {
-        const fragment = await loadFragmentFile(file.absolutePath);
-        if (!fragment?.meta?.name) continue;
-        const fileContent = await readFile2(file.absolutePath, "utf-8");
-        const parsed = parseFragmentFile(fileContent, file.absolutePath);
-        if (!parsed.componentImport) continue;
-        const sourcePath = resolveComponentSourcePath(file.absolutePath, parsed.componentImport);
-        if (!sourcePath) continue;
-        const meta = extractor.extract(sourcePath, fragment.meta.name);
-        if (!meta) continue;
-        const drifts = diffProps(fragment.props, meta.props);
-        let compositionDrift = null;
-        const fragmentAi = fragment.ai;
-        if (meta.composition && !fragmentAi?.compositionPattern) {
-          compositionDrift = `Source has "${meta.composition.pattern}" composition but fragment has no ai.compositionPattern`;
-        } else if (!meta.composition && fragmentAi?.compositionPattern) {
-          compositionDrift = `Fragment declares "${fragmentAi.compositionPattern}" but source has no compound pattern`;
-        } else if (meta.composition && fragmentAi?.compositionPattern && meta.composition.pattern !== fragmentAi.compositionPattern) {
-          compositionDrift = `Composition pattern changed: fragment="${fragmentAi.compositionPattern}" source="${meta.composition.pattern}"`;
-        }
-        if (drifts.length > 0 || compositionDrift) {
-          const report2 = {
-            component: fragment.meta.name,
-            file: file.relativePath,
-            drifts,
-            compositionDrift
-          };
-          reports.push(report2);
-          for (const drift of drifts) {
-            if (drift.kind === "removed") {
-              errors.push({
-                file: file.relativePath,
-                message: `Prop "${drift.prop}" documented in fragment but removed from source`,
-                details: `Fragment: ${drift.fragment} | Source: (not found)`
-              });
-            } else if (drift.kind === "added") {
-              warnings.push({
-                file: file.relativePath,
-                message: `Prop "${drift.prop}" exists in source but not documented in fragment`
-              });
-            } else {
-              warnings.push({
-                file: file.relativePath,
-                message: `Prop "${drift.prop}" ${drift.kind.replace("_", " ")}: fragment=${drift.fragment} source=${drift.source}`
-              });
-            }
-          }
-          if (compositionDrift) {
-            warnings.push({
-              file: file.relativePath,
-              message: compositionDrift
-            });
-          }
-        }
-      } catch {
-      }
-    }
-  } finally {
-    extractor.dispose();
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    reports
-  };
-}
-function diffProps(fragmentProps, sourceProps) {
-  const drifts = [];
-  const localSourceProps = Object.fromEntries(
-    Object.entries(sourceProps).filter(([_, p]) => p.source === "local")
-  );
-  for (const [name, sourceProp] of Object.entries(localSourceProps)) {
-    if (!(name in fragmentProps)) {
-      drifts.push({
-        prop: name,
-        kind: "added",
-        source: sourceProp.type,
-        fragment: "(not documented)"
-      });
-    }
-  }
-  for (const [name, fragProp] of Object.entries(fragmentProps)) {
-    if (!(name in localSourceProps)) {
-      drifts.push({
-        prop: name,
-        kind: "removed",
-        source: "(not found)",
-        fragment: String(fragProp.type ?? "unknown")
-      });
-      continue;
-    }
-    const sourceProp = localSourceProps[name];
-    if (fragProp.type && fragProp.type !== sourceProp.typeKind) {
-      drifts.push({
-        prop: name,
-        kind: "type_changed",
-        source: sourceProp.typeKind,
-        fragment: String(fragProp.type)
-      });
-    }
-    if (fragProp.required !== void 0 && fragProp.required !== sourceProp.required) {
-      drifts.push({
-        prop: name,
-        kind: "required_changed",
-        source: String(sourceProp.required),
-        fragment: String(fragProp.required)
-      });
-    }
-    if (fragProp.values && sourceProp.values) {
-      const fragSet = new Set(fragProp.values);
-      const srcSet = new Set(sourceProp.values);
-      const added = sourceProp.values.filter((v) => !fragSet.has(v));
-      const removed = Array.from(fragProp.values).filter((v) => !srcSet.has(v));
-      if (added.length > 0 || removed.length > 0) {
-        drifts.push({
-          prop: name,
-          kind: "values_changed",
-          source: sourceProp.values.join(", "),
-          fragment: Array.from(fragProp.values).join(", ")
-        });
-      }
-    }
-    if (fragProp.default !== void 0 && sourceProp.default !== void 0) {
-      if (String(fragProp.default) !== sourceProp.default) {
-        drifts.push({
-          prop: name,
-          kind: "default_changed",
-          source: sourceProp.default,
-          fragment: String(fragProp.default)
-        });
-      }
-    }
-  }
-  return drifts;
-}
-
-// src/build.ts
-import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve5, join as join5 } from "path";
-import { existsSync as existsSync6 } from "fs";
-
-// src/core/token-resolver.ts
-import { resolve as resolve2, dirname as dirname2, basename } from "path";
-import { existsSync as existsSync3, readdirSync } from "fs";
-function roundRgbValues(value) {
-  return value.replace(
-    /rgb\(([^)]+)\)/g,
-    (_full, inner) => {
-      const parts = inner.split(",").map((p) => p.trim());
-      const rounded = parts.map((p) => {
-        const num = parseFloat(p);
-        return isNaN(num) ? p : String(Math.round(num));
-      });
-      return `rgb(${rounded.join(", ")})`;
-    }
-  ).replace(
-    /rgba\(([^)]+)\)/g,
-    (_full, inner) => {
-      const parts = inner.split(",").map((p) => p.trim());
-      const rounded = parts.map((p, i) => {
-        if (i >= 3) return p;
-        const num = parseFloat(p);
-        return isNaN(num) ? p : String(Math.round(num));
-      });
-      return `rgba(${rounded.join(", ")})`;
-    }
-  );
-}
-async function resolveTokensWithSass(unresolvedTokens, tokensDir) {
-  const resolvedMap = /* @__PURE__ */ new Map();
-  const needsResolution = unresolvedTokens.filter(
-    (t) => t.value.includes("#{") || t.value.includes("$")
-  );
-  if (needsResolution.length === 0) {
-    return resolvedMap;
-  }
-  try {
-    const sass = await import("./sass.node-4XJK6YBF.js");
-    const variablesPath = findVariablesFile(tokensDir);
-    if (!variablesPath) {
-      return resolvedMap;
-    }
-    const fileName = basename(variablesPath);
-    const moduleName = fileName.replace(/^_/, "").replace(/\.scss$/, "");
-    const scssSource = `
-@use '${moduleName}' as vars;
-:root { @include vars.fui-css-variables; }
-`;
-    const compiled = sass.compileString(scssSource, {
-      loadPaths: [tokensDir, dirname2(tokensDir)],
-      style: "expanded",
-      // Suppress sass deprecation warnings during build
-      logger: { warn() {
-      }, debug() {
-      } }
-    });
-    const cssVarRegex = /(--[\w-]+)\s*:\s*([^;]+)/g;
-    let match;
-    const allResolved = /* @__PURE__ */ new Map();
-    while ((match = cssVarRegex.exec(compiled.css)) !== null) {
-      allResolved.set(match[1], roundRgbValues(match[2].trim()));
-    }
-    for (const token of needsResolution) {
-      const value = allResolved.get(token.name);
-      if (value !== void 0) {
-        resolvedMap.set(token.name, value);
-      }
-    }
-  } catch {
-  }
-  return resolvedMap;
-}
-function findVariablesFile(tokensDir) {
-  const candidates = ["_variables.scss", "variables.scss"];
-  for (const name of candidates) {
-    const path = resolve2(tokensDir, name);
-    if (existsSync3(path)) {
-      return path;
-    }
-  }
-  try {
-    const files = readdirSync(tokensDir).filter((f) => f.endsWith(".scss"));
-    for (const file of files) {
-      const path = resolve2(tokensDir, file);
-      if (file.includes("variables") || file.includes("tokens")) {
-        return path;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/core/extractor-adapter.ts
-var ReactExtractorAdapter = class {
-  extractor;
-  verificationLevel = "full";
-  constructor(tsconfigPath) {
-    this.extractor = createComponentExtractor(tsconfigPath);
-  }
-  canHandle(framework) {
-    return framework === "react";
-  }
-  extract(sourcePath, exportName) {
-    return this.extractor.extract(sourcePath, exportName);
-  }
-  dispose() {
-    this.extractor.dispose();
-  }
-};
-var NoopExtractorAdapter = class {
-  verificationLevel = "none";
-  canHandle() {
-    return true;
-  }
-  extract() {
-    return null;
-  }
-  dispose() {
-  }
-};
-function createExtractorAdapter(framework, tsconfigPath) {
-  if (framework === "react") {
-    return new ReactExtractorAdapter(tsconfigPath);
-  }
-  return new NoopExtractorAdapter();
-}
-
-// src/core/drift-verifier.ts
-function verifyContractDrift(contract, extracted) {
-  const contractPropNames = new Set(Object.keys(contract.props));
-  const sourcePropNames = new Set(
-    Object.entries(extracted.props).filter(([, p]) => p.source === "local").map(([name]) => name)
-  );
-  const removedProps = [];
-  const undocumentedProps = [];
-  const typeMismatches = [];
-  const defaultMismatches = [];
-  for (const name of contractPropNames) {
-    if (!sourcePropNames.has(name)) {
-      removedProps.push(name);
-    }
-  }
-  for (const name of sourcePropNames) {
-    if (!contractPropNames.has(name)) {
-      undocumentedProps.push(name);
-    }
-  }
-  for (const name of contractPropNames) {
-    const contractProp = contract.props[name];
-    const sourceProp = extracted.props[name];
-    if (!sourceProp || sourceProp.source !== "local") continue;
-    if (contractProp.type !== sourceProp.typeKind) {
-      typeMismatches.push({
-        prop: name,
-        contract: contractProp.type,
-        source: sourceProp.typeKind
-      });
-    }
-    const contractDefault = contractProp.default;
-    const sourceDefault = sourceProp.default;
-    if (contractDefault !== void 0 && sourceDefault !== void 0) {
-      if (String(contractDefault) !== String(sourceDefault)) {
-        defaultMismatches.push({
-          prop: name,
-          contract: contractDefault,
-          source: sourceDefault
-        });
-      }
-    }
-  }
-  const isClean = removedProps.length === 0 && undocumentedProps.length === 0 && typeMismatches.length === 0 && defaultMismatches.length === 0;
-  return {
-    componentName: contract.meta.name,
-    removedProps,
-    undocumentedProps,
-    typeMismatches,
-    defaultMismatches,
-    isClean
-  };
-}
-function formatDriftReport(report2) {
-  const lines = [`Drift detected for ${report2.componentName}:`];
-  if (report2.removedProps.length > 0) {
-    lines.push(`  Removed from source: ${report2.removedProps.join(", ")}`);
-  }
-  if (report2.undocumentedProps.length > 0) {
-    lines.push(`  Missing from contract: ${report2.undocumentedProps.join(", ")}`);
-  }
-  for (const m of report2.typeMismatches) {
-    lines.push(`  Type mismatch: ${m.prop} (contract: ${m.contract}, source: ${m.source})`);
-  }
-  for (const m of report2.defaultMismatches) {
-    lines.push(`  Default mismatch: ${m.prop} (contract: ${String(m.contract)}, source: ${String(m.source)})`);
-  }
-  return lines.join("\n");
-}
-
-// src/core/graph-extractor.ts
-import ts3 from "typescript";
-import { readFileSync, existsSync as existsSync4 } from "fs";
-import { join as join3 } from "path";
-import { readdirSync as readdirSync2 } from "fs";
-import { EDGE_TYPE_WEIGHTS, computeHealthFromData } from "@fragments-sdk/context/graph";
-async function buildComponentGraph(fragments, blocks, componentDir, options) {
-  const knownComponents = new Set(Object.keys(fragments));
-  const allEdges = [];
-  const autoDetected = /* @__PURE__ */ new Map();
-  const warnings = [];
-  if (!options?.skipSourceAnalysis) {
-    const sourceEdges = extractImportAndHookEdges(componentDir, knownComponents);
-    allEdges.push(...sourceEdges);
-    const subComponentResults = extractSubComponents(componentDir, knownComponents);
-    for (const [name, subs] of subComponentResults) {
-      autoDetected.set(name, {
-        ...autoDetected.get(name),
-        subComponents: subs,
-        compositionPattern: subs.length > 0 ? "compound" : "simple"
-      });
-    }
-  }
-  const jsxEdges = extractJsxUsageEdges(fragments, knownComponents);
-  allEdges.push(...jsxEdges);
-  const blockEdges = extractBlockEdges(blocks);
-  allEdges.push(...blockEdges);
-  const relationEdges = extractRelationEdges(fragments);
-  allEdges.push(...relationEdges);
-  const requiredChildrenMap = inferRequiredChildren(fragments, autoDetected);
-  for (const [name, children] of requiredChildrenMap) {
-    const existing = autoDetected.get(name) ?? {};
-    autoDetected.set(name, { ...existing, requiredChildren: children });
-  }
-  const patternsMap = generateCommonPatterns(fragments, autoDetected);
-  for (const [name, patterns] of patternsMap) {
-    const existing = autoDetected.get(name) ?? {};
-    autoDetected.set(name, { ...existing, commonPatterns: patterns });
-  }
-  const mergedEdges = mergeAndDeduplicate(allEdges);
-  const nodes = Object.entries(fragments).map(([name, fragment]) => {
-    const detected = autoDetected.get(name);
-    return {
-      name,
-      category: fragment.meta.category,
-      status: fragment.meta.status ?? "stable",
-      compositionPattern: fragment.ai?.compositionPattern ?? detected?.compositionPattern,
-      subComponents: fragment.ai?.subComponents ?? detected?.subComponents
-    };
-  });
-  const blockIndex = /* @__PURE__ */ new Map();
-  for (const [blockName, block] of Object.entries(blocks)) {
-    for (const comp of block.components) {
-      const existing = blockIndex.get(comp);
-      if (existing) existing.push(blockName);
-      else blockIndex.set(comp, [blockName]);
-    }
-  }
-  const health = computeHealthFromData(nodes, mergedEdges, blockIndex);
-  for (const [name, fragment] of Object.entries(fragments)) {
-    const detected = autoDetected.get(name);
-    if (!detected) continue;
-    if (fragment.ai?.subComponents && detected.subComponents) {
-      const declared = new Set(fragment.ai.subComponents);
-      const found = new Set(detected.subComponents);
-      const missing = detected.subComponents.filter((s) => !declared.has(s));
-      const extra = fragment.ai.subComponents.filter((s) => !found.has(s));
-      if (missing.length > 0) {
-        warnings.push(
-          `${name}: declares ${declared.size} subComponents but code has ${found.size}. Missing from declaration: ${missing.join(", ")}`
-        );
-      }
-      if (extra.length > 0) {
-        warnings.push(
-          `${name}: declares subComponents [${extra.join(", ")}] not found in Object.assign`
-        );
-      }
-    }
-  }
-  return {
-    graph: { nodes, edges: mergedEdges, health },
-    autoDetected,
-    warnings
-  };
-}
-function extractImportAndHookEdges(componentDir, knownComponents) {
-  const edges = [];
-  for (const componentName of knownComponents) {
-    const indexPath = findComponentIndex(componentDir, componentName);
-    if (!indexPath) continue;
-    let sourceText;
-    try {
-      sourceText = readFileSync(indexPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const sourceFile = ts3.createSourceFile(
-      indexPath,
-      sourceText,
-      ts3.ScriptTarget.Latest,
-      true,
-      indexPath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
-    );
-    const visitNode = (node) => {
-      if (ts3.isImportDeclaration(node)) {
-        const moduleSpecifier = node.moduleSpecifier;
-        if (ts3.isStringLiteral(moduleSpecifier)) {
-          const importPath = moduleSpecifier.text;
-          if (importPath.startsWith(".") || importPath.startsWith("/")) {
-            const clause = node.importClause;
-            if (clause) {
-              if (clause.name && isPascalCase(clause.name.text) && knownComponents.has(clause.name.text)) {
-                edges.push({
-                  source: componentName,
-                  target: clause.name.text,
-                  type: "imports",
-                  weight: EDGE_TYPE_WEIGHTS["imports"],
-                  provenance: `source:${componentName}/index.tsx`
-                });
-              }
-              if (clause.namedBindings && ts3.isNamedImports(clause.namedBindings)) {
-                for (const element of clause.namedBindings.elements) {
-                  const name = element.name.text;
-                  if (isPascalCase(name) && knownComponents.has(name) && name !== componentName) {
-                    edges.push({
-                      source: componentName,
-                      target: name,
-                      type: "imports",
-                      weight: EDGE_TYPE_WEIGHTS["imports"],
-                      provenance: `source:${componentName}/index.tsx`
-                    });
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      if (ts3.isCallExpression(node) && ts3.isIdentifier(node.expression)) {
-        const callName = node.expression.text;
-        const hookMatch = callName.match(/^use([A-Z][a-zA-Z]*)$/);
-        if (hookMatch) {
-          const hookTarget = hookMatch[1];
-          if (knownComponents.has(hookTarget) && hookTarget !== componentName) {
-            edges.push({
-              source: componentName,
-              target: hookTarget,
-              type: "hook-depends",
-              weight: EDGE_TYPE_WEIGHTS["hook-depends"],
-              provenance: `source:${componentName}/index.tsx`
-            });
-          }
-        }
-      }
-      ts3.forEachChild(node, visitNode);
-    };
-    ts3.forEachChild(sourceFile, visitNode);
-  }
-  return edges;
-}
-function extractSubComponents(componentDir, knownComponents) {
-  const result = /* @__PURE__ */ new Map();
-  for (const componentName of knownComponents) {
-    const indexPath = findComponentIndex(componentDir, componentName);
-    if (!indexPath) continue;
-    let sourceText;
-    try {
-      sourceText = readFileSync(indexPath, "utf-8");
-    } catch {
-      continue;
-    }
-    if (!sourceText.includes("Object.assign")) continue;
-    const sourceFile = ts3.createSourceFile(
-      indexPath,
-      sourceText,
-      ts3.ScriptTarget.Latest,
-      true,
-      indexPath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
-    );
-    const subComponents = [];
-    const visitNode = (node) => {
-      if (ts3.isCallExpression(node) && ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && node.expression.name.text === "assign" && node.arguments.length >= 2) {
-        const propsArg = node.arguments[1];
-        if (ts3.isObjectLiteralExpression(propsArg)) {
-          for (const prop of propsArg.properties) {
-            if (ts3.isShorthandPropertyAssignment(prop)) {
-              subComponents.push(prop.name.text);
-            } else if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.name)) {
-              subComponents.push(prop.name.text);
-            }
-          }
-        }
-      }
-      ts3.forEachChild(node, visitNode);
-    };
-    ts3.forEachChild(sourceFile, visitNode);
-    if (subComponents.length > 0) {
-      result.set(componentName, subComponents);
-    }
-  }
-  return result;
-}
-function extractJsxUsageEdges(fragments, knownComponents) {
-  const edges = [];
-  const jsxTagRegex = /<([A-Z][a-zA-Z]*(?:\.[A-Z][a-zA-Z]*)?)/g;
-  for (const [name, fragment] of Object.entries(fragments)) {
-    const usedComponents = /* @__PURE__ */ new Set();
-    for (const variant of fragment.variants) {
-      if (!variant.code) continue;
-      let match;
-      jsxTagRegex.lastIndex = 0;
-      while ((match = jsxTagRegex.exec(variant.code)) !== null) {
-        let tagName = match[1];
-        if (tagName.includes(".")) {
-          tagName = tagName.split(".")[0];
-        }
-        if (knownComponents.has(tagName) && tagName !== name) {
-          usedComponents.add(tagName);
-        }
-      }
-    }
-    for (const target of usedComponents) {
-      edges.push({
-        source: name,
-        target,
-        type: "renders",
-        weight: EDGE_TYPE_WEIGHTS["renders"],
-        provenance: `variant:${name}`
-      });
-    }
-  }
-  return edges;
-}
-function extractBlockEdges(blocks) {
-  const edges = [];
-  for (const [blockName, block] of Object.entries(blocks)) {
-    const components = block.components;
-    for (let i = 0; i < components.length; i++) {
-      for (let j = i + 1; j < components.length; j++) {
-        edges.push({
-          source: components[i],
-          target: components[j],
-          type: "composes",
-          weight: EDGE_TYPE_WEIGHTS["composes"],
-          provenance: `block:${blockName}`
-        });
-      }
-    }
-  }
-  return edges;
-}
-function extractRelationEdges(fragments) {
-  const edges = [];
-  const relationToEdgeType = {
-    parent: "parent-of",
-    child: "parent-of",
-    // reversed: if A declares child B, edge is A parent-of B
-    composition: "composes",
-    alternative: "alternative-to",
-    sibling: "sibling-of"
-  };
-  for (const [name, fragment] of Object.entries(fragments)) {
-    if (!fragment.relations) continue;
-    for (const rel of fragment.relations) {
-      const edgeType = relationToEdgeType[rel.relationship];
-      if (!edgeType) continue;
-      let source;
-      let target;
-      if (rel.relationship === "parent") {
-        source = rel.component;
-        target = name;
-      } else {
-        source = name;
-        target = rel.component;
-      }
-      edges.push({
-        source,
-        target,
-        type: edgeType,
-        weight: EDGE_TYPE_WEIGHTS[edgeType],
-        note: rel.note,
-        provenance: "relation"
-      });
-    }
-  }
-  return edges;
-}
-function inferRequiredChildren(fragments, autoDetected) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [name, fragment] of Object.entries(fragments)) {
-    const detected = autoDetected.get(name);
-    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
-    if (!subs || subs.length === 0) continue;
-    const variantsWithCode = fragment.variants.filter((v) => v.code);
-    if (variantsWithCode.length === 0) continue;
-    const required = [];
-    for (const sub of subs) {
-      const inAll = variantsWithCode.every((v) => {
-        const patterns = [
-          new RegExp(`<${name}\\.${sub}[\\s/>]`),
-          new RegExp(`<${sub}[\\s/>]`)
-        ];
-        return patterns.some((p) => p.test(v.code));
-      });
-      if (inAll) required.push(sub);
-    }
-    if (required.length > 0) {
-      result.set(name, required);
-    }
-  }
-  return result;
-}
-function generateCommonPatterns(fragments, autoDetected) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [name, fragment] of Object.entries(fragments)) {
-    const detected = autoDetected.get(name);
-    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
-    if (!subs || subs.length === 0) continue;
-    const firstVariant = fragment.variants.find((v) => v.code);
-    if (!firstVariant?.code) continue;
-    const usedSubs = [];
-    for (const sub of subs) {
-      const patterns = [
-        new RegExp(`<${name}\\.${sub}`),
-        new RegExp(`<${sub}[\\s/>]`)
-      ];
-      if (patterns.some((p) => p.test(firstVariant.code))) {
-        usedSubs.push(sub);
-      }
-    }
-    if (usedSubs.length > 0) {
-      const pattern = `<${name}>
-${usedSubs.map((s) => `  <${name}.${s}>...</${name}.${s}>`).join("\n")}
-</${name}>`;
-      result.set(name, [pattern]);
-    }
-  }
-  return result;
-}
-function mergeAndDeduplicate(edges) {
-  const edgeMap = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const key = `${edge.source}\u2192${edge.target}:${edge.type}`;
-    const existing = edgeMap.get(key);
-    if (!existing || edge.weight > existing.weight) {
-      edgeMap.set(key, edge);
-    }
-  }
-  return [...edgeMap.values()];
-}
-function isPascalCase(name) {
-  return /^[A-Z][a-zA-Z0-9]*$/.test(name);
-}
-function findComponentIndex(componentDir, componentName) {
-  const candidates = [
-    join3(componentDir, componentName, "index.tsx"),
-    join3(componentDir, componentName, "index.ts"),
-    join3(componentDir, componentName, `${componentName}.tsx`),
-    join3(componentDir, componentName, `${componentName}.ts`)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync4(candidate)) {
-      return candidate;
-    }
-  }
-  try {
-    const entries = readdirSync2(componentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && entry.name === componentName) {
-        const subCandidates = [
-          join3(componentDir, entry.name, "index.tsx"),
-          join3(componentDir, entry.name, "index.ts")
-        ];
-        for (const sc of subCandidates) {
-          if (existsSync4(sc)) return sc;
-        }
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/build.ts
-import { serializeGraph } from "@fragments-sdk/context/graph";
-
-// src/core/bundle-measurer.ts
-import { build } from "esbuild";
-import { gzipSync } from "zlib";
-import { resolve as resolve4, dirname as dirname3, join as join4, basename as basename3 } from "path";
-import { existsSync as existsSync5 } from "fs";
-function resolveEntryPoint(fragmentFilePath, configDir) {
-  const absPath = resolve4(configDir, fragmentFilePath);
-  const dir = dirname3(absPath);
-  const candidates = ["index.tsx", "index.ts", "index.jsx", "index.js"];
-  for (const candidate of candidates) {
-    const path = join4(dir, candidate);
-    if (existsSync5(path)) return path;
-  }
-  return null;
-}
-function labelForPath(filePath) {
-  const lastNmIdx = filePath.lastIndexOf("node_modules/");
-  if (lastNmIdx >= 0) {
-    const afterNm = filePath.slice(lastNmIdx + "node_modules/".length);
-    if (afterNm.startsWith("@")) {
-      const parts = afterNm.split("/");
-      return parts.slice(0, 2).join("/");
-    }
-    return afterNm.split("/")[0];
-  }
-  const componentsIdx = filePath.indexOf("components/");
-  if (componentsIdx >= 0) {
-    const afterComponents = filePath.slice(componentsIdx + "components/".length);
-    const componentName = afterComponents.split("/")[0];
-    return componentName;
-  }
-  const srcIdx = filePath.indexOf("src/");
-  if (srcIdx >= 0) return filePath.slice(srcIdx);
-  return filePath;
-}
-function groupImportsByDirectDep(metafile, entryPoint) {
-  const inputs = metafile.inputs;
-  const outputKey = Object.keys(metafile.outputs)[0];
-  const outputMeta = outputKey ? metafile.outputs[outputKey] : void 0;
-  if (!outputMeta?.inputs) return [];
-  const bytesMap = /* @__PURE__ */ new Map();
-  for (const [path, info] of Object.entries(outputMeta.inputs)) {
-    if (info.bytesInOutput > 0) {
-      bytesMap.set(path, info.bytesInOutput);
-    }
-  }
-  let entryKey;
-  for (const key of Object.keys(inputs)) {
-    if (key === entryPoint || entryPoint.endsWith(key) || key.endsWith(basename3(entryPoint))) {
-      const entryDir = dirname3(entryPoint);
-      if (key.includes(basename3(entryDir))) {
-        entryKey = key;
-        break;
-      }
-    }
-  }
-  if (!entryKey) {
-    const entryBasename = basename3(dirname3(entryPoint));
-    for (const key of Object.keys(inputs)) {
-      if (key.includes(`/${entryBasename}/index.`)) {
-        entryKey = key;
-        break;
-      }
-    }
-  }
-  if (!entryKey || !inputs[entryKey]) {
-    return groupByPackage(bytesMap);
-  }
-  const directImports = inputs[entryKey].imports.map((imp) => imp.path).filter((p) => inputs[p]);
-  const claimed = /* @__PURE__ */ new Set();
-  claimed.add(entryKey);
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const directPath of directImports) {
-    if (claimed.has(directPath)) continue;
-    const queue = [directPath];
-    const reachable = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const current = queue.pop();
-      if (reachable.has(current) || claimed.has(current)) continue;
-      reachable.add(current);
-      claimed.add(current);
-      const entry = inputs[current];
-      if (entry?.imports) {
-        for (const imp of entry.imports) {
-          if (inputs[imp.path] && !claimed.has(imp.path)) {
-            queue.push(imp.path);
-          }
-        }
-      }
-    }
-    let totalBytes = 0;
-    for (const path of reachable) {
-      totalBytes += bytesMap.get(path) ?? 0;
-    }
-    if (totalBytes > 0) {
-      const label = labelForPath(directPath);
-      const existing = groupMap.get(label);
-      if (existing) {
-        existing.bytes += totalBytes;
-      } else {
-        const entry = { path: label, bytes: totalBytes };
-        groupMap.set(label, entry);
-      }
-    }
-  }
-  const entryLabel = labelForPath(entryKey);
-  const selfLabel = entryLabel + " (self)";
-  let selfBytes = bytesMap.get(entryKey) ?? 0;
-  const siblingGroup = groupMap.get(entryLabel);
-  if (siblingGroup) {
-    selfBytes += siblingGroup.bytes;
-    groupMap.delete(entryLabel);
-  }
-  if (selfBytes > 0) {
-    groupMap.set(selfLabel, { path: selfLabel, bytes: selfBytes });
-  }
-  let unclaimedBytes = 0;
-  for (const [path, bytes] of bytesMap) {
-    if (!claimed.has(path)) unclaimedBytes += bytes;
-  }
-  if (unclaimedBytes > 0) {
-    groupMap.set("(other)", { path: "(other)", bytes: unclaimedBytes });
-  }
-  return [...groupMap.values()].sort((a, b) => b.bytes - a.bytes);
-}
-function groupByPackage(bytesMap) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [path, bytes] of bytesMap) {
-    const label = labelForPath(path);
-    const key = label.includes("/") && !label.startsWith("components/") ? label.split("/").slice(0, label.startsWith("@") ? 2 : 1).join("/") : label;
-    groups.set(key, (groups.get(key) ?? 0) + bytes);
-  }
-  return [...groups.entries()].map(([path, bytes]) => ({ path, bytes })).sort((a, b) => b.bytes - a.bytes);
-}
-async function measureSingleComponent(entryPoint, name) {
-  const result = await build({
-    entryPoints: [entryPoint],
-    bundle: true,
-    write: false,
-    minify: true,
-    metafile: true,
-    format: "esm",
-    target: "es2020",
-    platform: "browser",
-    treeShaking: true,
-    external: [
-      "react",
-      "react-dom",
-      "react/jsx-runtime",
-      "react/jsx-dev-runtime",
-      // Optional peer deps — excluded from measurement
-      "recharts",
-      "shiki",
-      "react-day-picker",
-      "@tanstack/react-table",
-      "date-fns",
-      "@base-ui-components/*",
-      "@base-ui/react/*"
-    ],
-    loader: {
-      ".scss": "empty",
-      ".css": "empty",
-      ".svg": "empty",
-      ".png": "empty",
-      ".jpg": "empty",
-      ".gif": "empty",
-      ".woff": "empty",
-      ".woff2": "empty",
-      ".ttf": "empty",
-      ".eot": "empty"
-    },
-    logLevel: "silent"
-  });
-  const output = result.outputFiles[0];
-  const rawBytes = output.contents.byteLength;
-  const gzipBytes = gzipSync(output.contents).byteLength;
-  const imports = result.metafile ? groupImportsByDirectDep(result.metafile, entryPoint) : void 0;
-  return { name, rawBytes, gzipBytes, imports };
-}
-async function measureBundleSizes(fragments, configDir, options = {}) {
-  const concurrency = options.concurrency ?? 4;
-  const measurements = /* @__PURE__ */ new Map();
-  const errors = [];
-  const start = Date.now();
-  const entries = [];
-  for (const [name, fragment] of Object.entries(fragments)) {
-    const entryPoint = resolveEntryPoint(fragment.filePath, configDir);
-    if (entryPoint) {
-      entries.push({ name, entryPoint });
-    } else {
-      errors.push({
-        name,
-        error: `Could not resolve entry point from ${fragment.filePath}`
-      });
-    }
-  }
-  let completed = 0;
-  for (let i = 0; i < entries.length; i += concurrency) {
-    const batch = entries.slice(i, i + concurrency);
-    const results = await Promise.allSettled(
-      batch.map(
-        ({ name, entryPoint }) => measureSingleComponent(entryPoint, name)
-      )
-    );
-    for (let j = 0; j < results.length; j++) {
-      const result = results[j];
-      const { name } = batch[j];
-      completed++;
-      if (result.status === "fulfilled") {
-        measurements.set(name, result.value);
-      } else {
-        errors.push({
-          name,
-          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-        });
-      }
-      options.onProgress?.(completed, entries.length, name);
-    }
-  }
-  return {
-    measurements,
-    errors,
-    elapsed: Date.now() - start
-  };
-}
-function toPerformanceData(measurement, config, contractBudget) {
-  const budget = contractBudget ?? config.budgets.bundleSize;
-  const budgetPercent = Math.round(measurement.gzipBytes / budget * 100);
-  const imports = measurement.imports?.slice(0, 10).map((imp) => ({
-    path: imp.path,
-    bytes: imp.bytes,
-    percent: Math.round(imp.bytes / measurement.rawBytes * 100)
-  }));
-  return {
-    bundleSize: measurement.gzipBytes,
-    rawSize: measurement.rawBytes,
-    complexity: classifyComplexity(measurement.gzipBytes),
-    budgetPercent,
-    overBudget: budgetPercent > 100,
-    measuredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...imports && imports.length > 0 ? { imports } : {}
-  };
-}
-
-// src/build.ts
-function normalizeParsedProps(parsedProps) {
-  return Object.fromEntries(
-    Object.entries(parsedProps).map(([name, prop]) => [
-      name,
-      {
-        type: prop.type ?? "custom",
-        description: prop.description ?? "",
-        default: prop.default,
-        required: prop.required,
-        values: prop.values,
-        constraints: prop.constraints
-      }
-    ])
-  );
-}
-function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
-  return Object.fromEntries(
-    Object.keys(autoProps).filter((name) => autoProps[name].source === "local" || name in documentedProps).map((name) => {
-      const documented = documentedProps[name];
-      const auto = autoProps[name];
-      return [
-        name,
-        {
-          type: auto.typeKind,
-          description: documented?.description ?? auto.description ?? "",
-          default: auto.default !== void 0 ? auto.default : documented?.default,
-          required: auto.required,
-          values: auto.values ?? documented?.values,
-          constraints: documented?.constraints
-        }
-      ];
-    })
-  );
-}
-function compilePropsSummary(props) {
-  return Object.entries(props).filter(([_, p]) => p.source === "local").map(([name, prop]) => {
-    let summary = name + ": ";
-    if (prop.values && prop.values.length > 0) {
-      summary += prop.values.join("|");
-    } else {
-      summary += prop.typeKind;
-    }
-    if (prop.default !== void 0) {
-      summary += ` (default: ${prop.default})`;
-    }
-    if (prop.required) {
-      summary += " (required)";
-    }
-    return summary;
-  });
-}
-async function buildFragments(config, configDir) {
-  const files = await discoverFragmentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  const fragments = {};
-  const contractSourcedNames = /* @__PURE__ */ new Set();
-  const tsconfigCandidates = [
-    resolve5(configDir, "tsconfig.json"),
-    resolve5(configDir, "..", "tsconfig.json")
-  ];
-  const tsconfigPath = tsconfigCandidates.find((p) => existsSync6(p));
-  const extractor = createComponentExtractor(tsconfigPath);
-  for (const file of files) {
-    try {
-      const content = await readFile3(file.absolutePath, "utf-8");
-      if (isContractFile(file.absolutePath)) {
-        try {
-          const parsed2 = parseComponentContract(content, file.relativePath);
-          const framework = parsed2.framework ?? config.framework ?? "react";
-          const contractAdapter = createExtractorAdapter(framework, tsconfigPath);
-          let extractedMeta2 = null;
-          if (parsed2.sourcePath && parsed2.exportName && contractAdapter.canHandle(framework)) {
-            try {
-              const absSourcePath = resolve5(configDir, parsed2.sourcePath);
-              extractedMeta2 = contractAdapter.extract(absSourcePath, parsed2.exportName);
-            } catch {
-            }
-          }
-          let mergedProps2 = parsed2.props;
-          if (extractedMeta2 && Object.keys(extractedMeta2.props).length > 0) {
-            mergedProps2 = mergeDocumentedAndAutoProps(mergedProps2, extractedMeta2.props);
-          }
-          let contractPropsSummary = parsed2.propsSummary;
-          if ((!contractPropsSummary || contractPropsSummary.length === 0) && extractedMeta2) {
-            contractPropsSummary = compilePropsSummary(extractedMeta2.props);
-          }
-          let ai2 = parsed2.ai;
-          if (extractedMeta2?.composition) {
-            const comp = extractedMeta2.composition;
-            ai2 = {
-              compositionPattern: comp.pattern,
-              subComponents: comp.parts.map((p) => p.name),
-              ...ai2
-            };
-          }
-          if (parsed2.provenance?.verified && extractedMeta2) {
-            const drift = verifyContractDrift(parsed2, extractedMeta2);
-            if (!drift.isClean) {
-              errors.push({
-                file: file.relativePath,
-                error: formatDriftReport(drift)
-              });
-              contractAdapter.dispose();
-              continue;
-            }
-          }
-          const compiled2 = {
-            filePath: file.relativePath,
-            meta: {
-              name: parsed2.meta.name,
-              description: parsed2.meta.description,
-              category: parsed2.meta.category,
-              tags: parsed2.meta.tags,
-              status: parsed2.meta.status,
-              figma: parsed2.meta.figma
-            },
-            usage: parsed2.usage,
-            props: mergedProps2,
-            relations: parsed2.relations,
-            variants: parsed2.variants,
-            ...parsed2.contract && { contract: parsed2.contract },
-            ...ai2 && { ai: ai2 },
-            framework: parsed2.framework,
-            propsSummary: contractPropsSummary,
-            sourcePath: parsed2.sourcePath,
-            exportName: parsed2.exportName,
-            provenance: parsed2.provenance
-          };
-          fragments[compiled2.meta.name] = compiled2;
-          contractSourcedNames.add(compiled2.meta.name);
-          contractAdapter.dispose();
-        } catch (error) {
-          errors.push({
-            file: file.relativePath,
-            error: `Contract parse error: ${error instanceof Error ? error.message : String(error)}`
-          });
-        }
-        continue;
-      }
-      if (file.absolutePath.endsWith(".fragment.tsx") || file.absolutePath.endsWith(".fragment.ts")) {
-        warnings.push({
-          file: file.relativePath,
-          warning: "Deprecated format: .fragment.tsx \u2014 run `fragments migrate-contract` to generate .contract.json"
-        });
-      }
-      if (!content.includes("defineFragment")) {
-        warnings.push({
-          file: file.relativePath,
-          warning: "No defineFragment() call found"
-        });
-        continue;
-      }
-      const parsed = parseFragmentFile(content, file.relativePath);
-      for (const warning of parsed.warnings) {
-        warnings.push({ file: file.relativePath, warning });
-      }
-      if (!parsed.meta.name) {
-        warnings.push({
-          file: file.relativePath,
-          warning: "Missing meta.name in fragment definition \u2014 skipped"
-        });
-        continue;
-      }
-      const documentedProps = normalizeParsedProps(parsed.props);
-      let mergedProps = documentedProps;
-      const componentExportName = parsed.componentName ?? parsed.meta.name;
-      const componentSourcePath = resolveComponentSourcePath(
-        file.absolutePath,
-        parsed.componentImport
-      );
-      let extractedMeta = null;
-      if (componentExportName && componentSourcePath) {
-        try {
-          extractedMeta = extractor.extract(componentSourcePath, componentExportName);
-        } catch {
-        }
-        if (extractedMeta) {
-          const autoProps = extractedMeta.props;
-          const hasAutoProps = Object.keys(autoProps).length > 0;
-          if (hasAutoProps) {
-            const removedDocumentedProps = Object.keys(documentedProps).filter(
-              (propName) => !(propName in autoProps)
-            );
-            if (removedDocumentedProps.length > 0) {
-              warnings.push({
-                file: file.relativePath,
-                warning: `Removed ${removedDocumentedProps.length} documented props not present in source API: ${removedDocumentedProps.join(", ")}`
-              });
-            }
-            mergedProps = mergeDocumentedAndAutoProps(documentedProps, autoProps);
-          } else if (Object.keys(documentedProps).length > 0) {
-            warnings.push({
-              file: file.relativePath,
-              warning: "Auto-props extraction returned no props; falling back to documented props"
-            });
-          }
-        }
-      } else if (!componentExportName) {
-        warnings.push({
-          file: file.relativePath,
-          warning: "Unable to resolve component export name for auto-props extraction"
-        });
-      } else if (!componentSourcePath) {
-        warnings.push({
-          file: file.relativePath,
-          warning: `Unable to resolve component source path from import: ${parsed.componentImport ?? "unknown"}`
-        });
-      }
-      let contract = parsed.contract;
-      if (!contract?.propsSummary && extractedMeta) {
-        const summary = compilePropsSummary(extractedMeta.props);
-        if (summary.length > 0) {
-          contract = { ...contract, propsSummary: summary };
-        }
-      }
-      let ai = parsed.ai;
-      if (extractedMeta?.composition) {
-        const comp = extractedMeta.composition;
-        ai = {
-          compositionPattern: comp.pattern,
-          subComponents: comp.parts.map((p) => p.name),
-          ...ai
-          // Manually authored ai fields take precedence
-        };
-      }
-      const compiled = {
-        filePath: file.relativePath,
-        meta: {
-          name: parsed.meta.name,
-          description: parsed.meta.description ?? "",
-          category: parsed.meta.category ?? "Uncategorized",
-          status: parsed.meta.status,
-          tags: parsed.meta.tags,
-          since: parsed.meta.since,
-          ...parsed.meta.dependencies && { dependencies: parsed.meta.dependencies },
-          figma: parsed.meta.figma
-        },
-        usage: {
-          when: parsed.usage.when ?? [],
-          whenNot: parsed.usage.whenNot ?? [],
-          guidelines: parsed.usage.guidelines,
-          accessibility: parsed.usage.accessibility
-        },
-        props: mergedProps,
-        relations: parsed.relations.map((rel) => ({
-          component: rel.component,
-          relationship: rel.relationship,
-          note: rel.note
-        })),
-        variants: parsed.variants.map((v) => ({
-          name: v.name,
-          description: v.description,
-          ...v.code && { code: v.code },
-          ...v.figma && { figma: v.figma },
-          ...v.args && { args: v.args }
-        })),
-        // Include AI metadata (auto-enriched or manual)
-        ...ai && { ai },
-        // Include contract metadata (auto-compiled or manual)
-        ...contract && { contract },
-        // Provenance from TSX path
-        provenance: {
-          source: extractedMeta ? "extracted" : "manual",
-          verified: !!extractedMeta
-        }
-      };
-      if (contractSourcedNames.has(parsed.meta.name)) {
-        warnings.push({
-          file: file.relativePath,
-          warning: `Duplicate: "${parsed.meta.name}" already loaded from .contract.json \u2014 skipping .fragment.tsx`
-        });
-      } else {
-        fragments[parsed.meta.name] = compiled;
-      }
-    } catch (error) {
-      errors.push({
-        file: file.relativePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  extractor.dispose();
-  const blocks = {};
-  try {
-    const blockFiles = await discoverBlockFiles(configDir, config.exclude);
-    for (const file of blockFiles) {
-      try {
-        let raw = await loadFragmentFile(file.absolutePath);
-        if (raw && "default" in raw && typeof raw.default === "object") {
-          raw = raw.default;
-        }
-        const def = raw;
-        if (def && typeof def === "object" && "name" in def && "code" in def && "components" in def) {
-          const compiled = compileBlock(def, file.relativePath);
-          blocks[compiled.name] = compiled;
-        }
-      } catch (error) {
-        warnings.push({
-          file: file.relativePath,
-          warning: `Failed to load block: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-  } catch {
-  }
-  let tokens;
-  try {
-    const tokenPatterns = config.tokens?.include;
-    const tokenFiles = await discoverTokenFiles(configDir, tokenPatterns, config.exclude);
-    if (tokenFiles.length > 0) {
-      const mergedCategories = {};
-      let prefix = "--";
-      let total = 0;
-      const fileContents = [];
-      for (const file of tokenFiles) {
-        const content = await readFile3(file.absolutePath, "utf-8");
-        fileContents.push({ content, path: file.relativePath });
-      }
-      const allContent = fileContents.map((f) => f.content).join("\n");
-      for (const { content, path } of fileContents) {
-        let fileParsed;
-        let parsed;
-        if (isDTCGFile(path)) {
-          fileParsed = parseDTCGFile(content, path);
-          parsed = fileParsed;
-        } else {
-          parsed = parseTokenFile(allContent, path);
-          fileParsed = parseTokenFile(content, path);
-        }
-        prefix = fileParsed.prefix;
-        total += fileParsed.total;
-        for (const [cat, catTokens] of Object.entries(fileParsed.categories)) {
-          if (!mergedCategories[cat]) {
-            mergedCategories[cat] = [];
-          }
-          for (const t of catTokens) {
-            if (!mergedCategories[cat].some((e) => e.name === t.name)) {
-              const combinedToken = Object.values(parsed.categories).flat().find((ct) => ct.name === t.name);
-              const resolvedValue = combinedToken?.resolvedValue ?? t.resolvedValue;
-              mergedCategories[cat].push({
-                name: t.name,
-                ...resolvedValue ? { value: resolvedValue } : t.value ? { value: t.value } : {},
-                description: t.description
-              });
-            }
-          }
-        }
-      }
-      if (total > 0) {
-        const allTokens = Object.values(mergedCategories).flat();
-        const unresolved = allTokens.filter(
-          (t) => t.value && (t.value.includes("#{") || t.value.includes("$"))
-        );
-        if (unresolved.length > 0 && tokenFiles.length > 0) {
-          const tokensDir = resolve5(configDir, tokenFiles[0].relativePath, "..");
-          const sassResolved = await resolveTokensWithSass(
-            unresolved,
-            tokensDir
-          );
-          if (sassResolved.size > 0) {
-            for (const catTokens of Object.values(mergedCategories)) {
-              for (const token of catTokens) {
-                const resolved = sassResolved.get(token.name);
-                if (resolved && token.value && (token.value.includes("#{") || token.value.includes("$"))) {
-                  token.value = resolved;
-                }
-              }
-            }
-          }
-        }
-        tokens = { prefix, total, categories: mergedCategories };
-      }
-    }
-  } catch {
-  }
-  let packageName;
-  const pkgJsonPath = resolve5(configDir, "package.json");
-  if (existsSync6(pkgJsonPath)) {
-    try {
-      const pkg = JSON.parse(await readFile3(pkgJsonPath, "utf-8"));
-      if (pkg.name) packageName = pkg.name;
-    } catch {
-    }
-  }
-  const componentDir = resolve5(configDir, "src", "components");
-  let graphData;
-  try {
-    const graphResult = await buildComponentGraph(fragments, blocks, componentDir);
-    for (const [name, fragment] of Object.entries(fragments)) {
-      const detected = graphResult.autoDetected.get(name);
-      if (!detected) continue;
-      if (!fragment.ai) fragment.ai = {};
-      if (!fragment.ai.subComponents && detected.subComponents) {
-        fragment.ai.subComponents = detected.subComponents;
-      }
-      if (!fragment.ai.compositionPattern && detected.compositionPattern) {
-        fragment.ai.compositionPattern = detected.compositionPattern;
-      }
-      if (!fragment.ai.commonPatterns && detected.commonPatterns) {
-        fragment.ai.commonPatterns = detected.commonPatterns;
-      }
-      if (!fragment.ai.requiredChildren && detected.requiredChildren) {
-        fragment.ai.requiredChildren = detected.requiredChildren;
-      }
-    }
-    for (const w of graphResult.warnings) {
-      warnings.push({ file: "graph", warning: w });
-    }
-    graphData = serializeGraph(graphResult.graph);
-  } catch (error) {
-    warnings.push({
-      file: "graph",
-      warning: `Graph extraction failed: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  let performanceSummary;
-  if (config.performance) {
-    try {
-      const perfConfig = resolvePerformanceConfig(config.performance);
-      const perfResult = await measureBundleSizes(fragments, configDir, {
-        perfConfig
-      });
-      const tiers = { lightweight: 0, moderate: 0, heavy: 0 };
-      let overBudgetCount = 0;
-      for (const [name, measurement] of perfResult.measurements) {
-        const fragment = fragments[name];
-        const contractBudget = fragment?.contract?.performanceBudget;
-        const perfData = toPerformanceData(measurement, perfConfig, contractBudget);
-        fragment.performance = perfData;
-        tiers[perfData.complexity]++;
-        if (perfData.overBudget) overBudgetCount++;
-      }
-      performanceSummary = {
-        preset: perfConfig.preset,
-        budget: perfConfig.budgets.bundleSize,
-        total: perfResult.measurements.size,
-        overBudget: overBudgetCount,
-        tiers
-      };
-      for (const err of perfResult.errors) {
-        warnings.push({
-          file: "performance",
-          warning: `Could not measure ${err.name}: ${err.error}`
-        });
-      }
-    } catch (error) {
-      warnings.push({
-        file: "performance",
-        warning: `Performance measurement failed: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  const output = {
-    version: "1.0.0",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...packageName && { packageName },
-    fragments,
-    ...Object.keys(blocks).length > 0 && { blocks },
-    ...tokens && { tokens },
-    ...graphData && { graph: graphData },
-    ...performanceSummary && { performanceSummary }
-  };
-  const outputPath = resolve5(configDir, config.outFile ?? BRAND.outFile);
-  await writeFile(outputPath, JSON.stringify(output));
-  return {
-    success: errors.length === 0,
-    outputPath,
-    fragmentCount: Object.keys(fragments).length,
-    errors,
-    warnings
-  };
-}
-async function buildFragmentsDir(config, configDir) {
-  const fragmentsDir = join5(configDir, BRAND.dataDir);
-  const componentsDir = join5(fragmentsDir, BRAND.componentsDir);
-  await mkdir(fragmentsDir, { recursive: true });
-  await mkdir(componentsDir, { recursive: true });
-  const registryResult = await generateRegistry({
-    projectRoot: configDir,
-    componentPatterns: config.components || ["src/**/*.tsx", "src/**/*.ts"],
-    storyPatterns: config.include || ["src/**/*.stories.tsx"],
-    fragmentsDir,
-    registryOptions: config.registry || {}
-  });
-  const errors = [...registryResult.errors];
-  const warnings = [...registryResult.warnings];
-  const indexPath = join5(fragmentsDir, "index.json");
-  await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
-  const registryPath = join5(fragmentsDir, BRAND.registryFile);
-  await writeFile(registryPath, JSON.stringify(registryResult.registry, null, 2));
-  const contextResult = generateContextMd(registryResult.registry, {
-    format: "markdown",
-    compact: false,
-    include: {
-      props: false,
-      // AI can read TypeScript directly
-      relations: true,
-      code: false
-    }
-  });
-  const contextPath = join5(fragmentsDir, BRAND.contextFile);
-  await writeFile(contextPath, contextResult.content);
-  return {
-    success: errors.length === 0,
-    indexPath,
-    registryPath,
-    contextPath,
-    componentCount: registryResult.registry.componentCount,
-    errors,
-    warnings
-  };
-}
-
-// src/screenshot.ts
-import pc from "picocolors";
-async function runScreenshotCommand(config, configDir, options = {}) {
-  const startTime = Date.now();
-  const errors = [];
-  const storage = new StorageManager({
-    projectRoot: configDir,
-    viewport: options.width && options.height ? { width: options.width, height: options.height } : config.screenshots?.viewport
-  });
-  await storage.initialize();
-  const fragmentFiles = await discoverFragmentFiles(config, configDir);
-  if (fragmentFiles.length === 0) {
-    console.log(pc.yellow("No fragment files found."));
-    return {
-      success: true,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const fragments = [];
-  for (const file of fragmentFiles) {
-    try {
-      const fragment = await loadFragmentFile(file.absolutePath);
-      if (fragment) {
-        fragments.push({ path: file.relativePath, fragment });
-      }
-    } catch (error) {
-      errors.push({
-        component: file.relativePath,
-        variant: "",
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  const filteredFragments = options.component ? fragments.filter((s) => s.fragment.meta.name === options.component) : fragments;
-  if (options.component && filteredFragments.length === 0) {
-    console.log(pc.yellow(`Component "${options.component}" not found.`));
-    return {
-      success: false,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const variantsToCapture = [];
-  for (const { fragment } of filteredFragments) {
-    const variants = options.variant ? fragment.variants.filter((v) => v.name === options.variant) : fragment.variants;
-    for (const variant of variants) {
-      variantsToCapture.push({
-        component: fragment.meta.name,
-        variant: variant.name,
-        render: variant.render
-      });
-    }
-  }
-  if (variantsToCapture.length === 0) {
-    console.log(pc.yellow("No variants to capture."));
-    return {
-      success: true,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const theme = options.theme ?? DEFAULTS.theme;
-  const viewport = {
-    width: options.width ?? config.screenshots?.viewport?.width ?? DEFAULTS.viewport.width,
-    height: options.height ?? config.screenshots?.viewport?.height ?? DEFAULTS.viewport.height
-  };
-  console.log(pc.cyan(`
-${BRAND.name} Screenshot
-`));
-  console.log(pc.dim(`Capturing variants (theme: ${theme}, viewport: ${viewport.width}x${viewport.height}):
-`));
-  const pool = new BrowserPool({
-    viewport
-  });
-  const viewerPort = DEFAULTS.port;
-  const baseUrl = `http://localhost:${viewerPort}`;
-  const captureEngine = new CaptureEngine(pool, baseUrl);
-  let captured = 0;
-  let skipped = 0;
-  const captureOptions = {
-    theme,
-    viewport,
-    delay: config.screenshots?.delay ?? DEFAULTS.captureDelayMs
-  };
-  try {
-    console.log(pc.dim("Starting browser..."));
-    await pool.warmup();
-    console.log(pc.dim("Browser ready.\n"));
-    for (const { component, variant } of variantsToCapture) {
-      const hasExisting = storage.hasBaseline(component, variant, theme);
-      if (hasExisting && !options.update) {
-        console.log(`  ${pc.dim("\u25CB")} ${component}/${variant} ${pc.dim("(skipped)")}`);
-        skipped++;
-        continue;
-      }
-      try {
-        const screenshot = await captureEngine.captureVariant(
-          component,
-          variant,
-          captureOptions
-        );
-        await storage.saveBaseline(screenshot);
-        const totalTime = screenshot.metadata.renderTimeMs + screenshot.metadata.captureTimeMs;
-        console.log(
-          `  ${pc.green("\u2713")} ${component}/${variant} ${pc.dim(formatMs(totalTime))}`
-        );
-        captured++;
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        console.log(`  ${pc.red("\u2717")} ${component}/${variant} ${pc.dim(errorMsg)}`);
-        errors.push({ component, variant, error: errorMsg });
-      }
-    }
-  } finally {
-    await pool.shutdown();
-  }
-  const totalTimeMs = Date.now() - startTime;
-  console.log();
-  if (errors.length === 0) {
-    console.log(pc.green(`\u2713 Captured ${captured} screenshot(s) in ${formatMs(totalTimeMs)}`));
-  } else {
-    console.log(pc.yellow(`\u26A0 Captured ${captured} screenshot(s) with ${errors.length} error(s)`));
-  }
-  if (skipped > 0) {
-    console.log(pc.dim(`  ${skipped} skipped (use --update to recapture)`));
-  }
-  console.log(pc.dim(`  Stored in ${storage.screenshotsDirPath}
-`));
-  return {
-    success: errors.length === 0,
-    captured,
-    skipped,
-    errors,
-    totalTimeMs
-  };
-}
-
-// src/diff.ts
-import pc2 from "picocolors";
-async function runDiffCommand(config, configDir, options = {}) {
-  const startTime = Date.now();
-  const results = [];
-  const storage = new StorageManager({
-    projectRoot: configDir,
-    viewport: config.screenshots?.viewport
-  });
-  await storage.initialize();
-  const threshold = options.threshold ?? config.screenshots?.threshold ?? DEFAULTS.diffThreshold;
-  const diffEngine = new DiffEngine(threshold);
-  const fragmentFiles = await discoverFragmentFiles(config, configDir);
-  if (fragmentFiles.length === 0) {
-    console.log(pc2.yellow("No fragment files found."));
-    return {
-      success: true,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const fragments = [];
-  for (const file of fragmentFiles) {
-    try {
-      const fragment = await loadFragmentFile(file.absolutePath);
-      if (fragment) {
-        fragments.push({ path: file.relativePath, fragment });
-      }
-    } catch {
-    }
-  }
-  const filteredFragments = options.component ? fragments.filter((s) => s.fragment.meta.name === options.component) : fragments;
-  if (options.component && filteredFragments.length === 0) {
-    console.log(pc2.yellow(`Component "${options.component}" not found.`));
-    return {
-      success: false,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const variantsToDiff = [];
-  for (const { fragment } of filteredFragments) {
-    const variants = options.variant ? fragment.variants.filter((v) => v.name === options.variant) : fragment.variants;
-    for (const variant of variants) {
-      variantsToDiff.push({
-        component: fragment.meta.name,
-        variant: variant.name
-      });
-    }
-  }
-  if (variantsToDiff.length === 0) {
-    console.log(pc2.yellow("No variants to compare."));
-    return {
-      success: true,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const theme = options.theme ?? DEFAULTS.theme;
-  const viewport = config.screenshots?.viewport ?? DEFAULTS.viewport;
-  console.log(pc2.cyan(`
-${BRAND.name} Diff
-`));
-  console.log(pc2.dim(`Comparing against baselines (theme: ${theme}, threshold: ${threshold}%):
-`));
-  const pool = new BrowserPool({
-    viewport
-  });
-  const viewerPort = DEFAULTS.port;
-  const baseUrl = `http://localhost:${viewerPort}`;
-  const captureEngine = new CaptureEngine(pool, baseUrl);
-  let passed = 0;
-  let failed = 0;
-  let missing = 0;
-  const captureOptions = {
-    theme,
-    viewport,
-    delay: config.screenshots?.delay ?? DEFAULTS.captureDelayMs
-  };
-  try {
-    await pool.warmup();
-    for (const { component, variant } of variantsToDiff) {
-      const baseline = await storage.loadBaseline(component, variant, theme);
-      if (!baseline) {
-        console.log(
-          `  ${pc2.yellow("?")} ${component}/${variant} ${pc2.dim("(no baseline)")}`
-        );
-        missing++;
-        continue;
-      }
-      try {
-        const current = await captureEngine.captureVariant(
-          component,
-          variant,
-          captureOptions
-        );
-        if (diffEngine.areIdentical(current, baseline)) {
-          console.log(`  ${pc2.green("\u2713")} ${component}/${variant} ${pc2.dim("0.0%")}`);
-          results.push({
-            component,
-            variant,
-            theme,
-            result: {
-              matches: true,
-              diffPercentage: 0,
-              diffPixelCount: 0,
-              totalPixels: current.viewport.width * current.viewport.height,
-              changedRegions: [],
-              diffTimeMs: 0
-            }
-          });
-          passed++;
-          continue;
-        }
-        const diffResult = diffEngine.compare(current, baseline, { threshold });
-        if (diffResult.matches) {
-          console.log(
-            `  ${pc2.green("\u2713")} ${component}/${variant} ${pc2.dim(`${diffResult.diffPercentage}%`)}`
-          );
-          passed++;
-        } else {
-          let diffImagePath;
-          if (diffResult.diffImage) {
-            diffImagePath = await storage.saveDiff(
-              component,
-              variant,
-              theme,
-              diffResult.diffImage
-            );
-          }
-          console.log(
-            `  ${pc2.red("\u2717")} ${component}/${variant} ${pc2.yellow(`${diffResult.diffPercentage}%`)}` + (diffImagePath ? pc2.dim(` \u2192 ${diffImagePath}`) : "")
-          );
-          failed++;
-          results.push({
-            component,
-            variant,
-            theme,
-            result: diffResult,
-            diffImagePath
-          });
-          continue;
-        }
-        results.push({
-          component,
-          variant,
-          theme,
-          result: diffResult
-        });
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        console.log(`  ${pc2.red("!")} ${component}/${variant} ${pc2.dim(errorMsg)}`);
-        failed++;
-      }
-    }
-  } finally {
-    await pool.shutdown();
-  }
-  const totalTimeMs = Date.now() - startTime;
-  const total = passed + failed + missing;
-  console.log();
-  if (failed === 0 && missing === 0) {
-    console.log(pc2.green(`\u2713 All ${passed} variant(s) match baselines`));
-  } else if (failed > 0) {
-    console.log(pc2.red(`\u2717 ${failed} variant(s) differ from baselines`));
-  }
-  if (missing > 0) {
-    console.log(pc2.yellow(`  ${missing} variant(s) have no baseline (run \`${BRAND.cliCommand} screenshot\`)`));
-  }
-  console.log(pc2.dim(`  Completed in ${formatMs(totalTimeMs)}
-`));
-  const success = failed === 0;
-  return {
-    success,
-    total,
-    passed,
-    failed,
-    missing,
-    results,
-    totalTimeMs
-  };
-}
-
-// src/analyze.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join6, dirname as dirname4 } from "path";
-import pc3 from "picocolors";
-async function runAnalyzeCommand(config, configDir, options = {}) {
-  const format = options.format ?? "html";
-  const minScore = options.minScore ?? 0;
-  console.log(pc3.cyan(`
-${BRAND.name} Analyzer
-`));
-  const fragmentsPath = join6(configDir, config.outFile ?? "fragments.json");
-  if (!existsSync7(fragmentsPath)) {
-    console.log(pc3.red(`\u2717 No fragments.json found. Run \`${BRAND.cliCommand} build\` first.
-`));
-    return {
-      success: false,
-      analytics: createEmptyAnalytics()
-    };
-  }
-  console.log(pc3.dim("Analyzing design system...\n"));
-  const content = await readFile4(fragmentsPath, "utf-8");
-  const data = JSON.parse(content);
-  const analytics = analyzeDesignSystem(data);
-  printConsoleSummary(analytics);
-  let outputPath;
-  if (format === "html" || format === "json") {
-    outputPath = options.output ?? getDefaultOutputPath(format, configDir);
-    await mkdir2(dirname4(outputPath), { recursive: true });
-    if (format === "html") {
-      const html = generateHtmlReport(analytics);
-      await writeFile2(outputPath, html);
-      console.log(pc3.green(`\u2713 Report generated: ${outputPath}
-`));
-    } else {
-      await writeFile2(outputPath, JSON.stringify(analytics, null, 2));
-      console.log(pc3.green(`\u2713 JSON report generated: ${outputPath}
-`));
-    }
-    if (options.open && format === "html") {
-      await openInBrowser(outputPath);
-    }
-  }
-  const passedCi = analytics.summary.overallScore >= minScore;
-  if (options.ci) {
-    if (passedCi) {
-      console.log(
-        pc3.green(`\u2713 Score ${analytics.summary.overallScore} meets minimum threshold ${minScore}
-`)
-      );
-    } else {
-      console.log(
-        pc3.red(
-          `\u2717 Score ${analytics.summary.overallScore} below minimum threshold ${minScore}
-`
-        )
-      );
-    }
-  }
-  return {
-    success: !options.ci || passedCi,
-    analytics,
-    outputPath
-  };
-}
-function printConsoleSummary(analytics) {
-  const { summary, coverage, recommendations } = analytics;
-  const grade = getGrade(summary.overallScore);
-  console.log(
-    pc3.bold(
-      `Overall Score: ${colorizeScore(summary.overallScore)} (${grade})
-`
-    )
-  );
-  console.log(pc3.dim("Summary"));
-  console.log(`  Components:  ${pc3.white(summary.totalComponents.toString())}`);
-  console.log(`  Variants:    ${pc3.white(summary.totalVariants.toString())}`);
-  console.log(`  Props:       ${pc3.white(summary.totalProps.toString())}`);
-  console.log(`  Categories:  ${pc3.white(summary.categories.join(", "))}`);
-  console.log();
-  console.log(pc3.dim("Coverage"));
-  console.log(`  Description:  ${formatCoverage(coverage.fields.description)}`);
-  console.log(`  Usage when:   ${formatCoverage(coverage.fields.usageWhen)}`);
-  console.log(`  Usage whenNot:${formatCoverage(coverage.fields.usageWhenNot)}`);
-  console.log(`  Guidelines:   ${formatCoverage(coverage.fields.guidelines)}`);
-  console.log(`  Relations:    ${formatCoverage(coverage.fields.relations)}`);
-  console.log();
-  if (recommendations.length > 0) {
-    console.log(pc3.dim("Top Recommendations"));
-    for (const rec of recommendations.slice(0, 3)) {
-      const priority = rec.priority === "high" ? pc3.red(`[${rec.priority}]`) : rec.priority === "medium" ? pc3.yellow(`[${rec.priority}]`) : pc3.dim(`[${rec.priority}]`);
-      console.log(`  ${priority} ${rec.title}`);
-    }
-    console.log();
-  }
-}
-function formatCoverage(field) {
-  const pct = colorizeScore(field.percentage);
-  return `${pct} (${field.covered}/${field.total})`;
-}
-function colorizeScore(score) {
-  if (score >= 80) return pc3.green(`${score}%`);
-  if (score >= 60) return pc3.yellow(`${score}%`);
-  return pc3.red(`${score}%`);
-}
-function getDefaultOutputPath(format, configDir) {
-  const filename = format === "html" ? "fragments-report.html" : "fragments-report.json";
-  return join6(configDir, filename);
-}
-async function openInBrowser(path) {
-  const { platform } = await import("os");
-  const { exec } = await import("child_process");
-  const os = platform();
-  const cmd = os === "darwin" ? `open "${path}"` : os === "win32" ? `start "" "${path}"` : `xdg-open "${path}"`;
-  exec(cmd);
-}
-function createEmptyAnalytics() {
-  return {
-    analyzedAt: /* @__PURE__ */ new Date(),
-    summary: {
-      totalComponents: 0,
-      totalVariants: 0,
-      totalProps: 0,
-      categories: [],
-      overallScore: 0
-    },
-    inventory: {
-      byCategory: {},
-      byStatus: {},
-      byVariantCount: [],
-      byPropCount: []
-    },
-    coverage: {
-      overall: 0,
-      fields: {
-        description: { covered: 0, total: 0, percentage: 0 },
-        usageWhen: { covered: 0, total: 0, percentage: 0 },
-        usageWhenNot: { covered: 0, total: 0, percentage: 0 },
-        guidelines: { covered: 0, total: 0, percentage: 0 },
-        accessibility: { covered: 0, total: 0, percentage: 0 },
-        relations: { covered: 0, total: 0, percentage: 0 },
-        propDescriptions: { covered: 0, total: 0, percentage: 0 },
-        propConstraints: { covered: 0, total: 0, percentage: 0 }
-      },
-      incomplete: []
-    },
-    quality: {
-      missingWhenNot: [],
-      isolated: [],
-      deprecated: [],
-      fewVariants: [],
-      undocumentedProps: [],
-      unconstrainedProps: []
-    },
-    distribution: {
-      variantsPerComponent: [],
-      propsPerComponent: [],
-      componentsPerCategory: [],
-      statusDistribution: [],
-      tagFrequency: []
-    },
-    recommendations: []
-  };
-}
-
-export {
-  resolveComponentSourcePath,
-  validateSchema,
-  validateCoverage,
-  validateAll,
-  validateSnippets,
-  validateDrift,
-  measureBundleSizes,
-  toPerformanceData,
-  buildFragments,
-  buildFragmentsDir,
-  runScreenshotCommand,
-  runDiffCommand,
-  runAnalyzeCommand
-};
-//# sourceMappingURL=chunk-7WHVW72L.js.map