@fragments-sdk/cli 0.15.0 → 0.15.1

package/dist/chunk-5JF26E55.js

@@ -0,0 +1,1255 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  BrowserPool,
+  CaptureEngine,
+  DiffEngine,
+  StorageManager,
+  analyzeDesignSystem,
+  formatMs,
+  generateHtmlReport,
+  getGrade
+} from "./chunk-6SQPP47U.js";
+import {
+  discoverBlockFiles,
+  discoverComponentFiles,
+  discoverFragmentFiles,
+  extractComponentName,
+  loadFragmentFile,
+  parseFragmentFile
+} from "./chunk-HQ6A6DTV.js";
+import {
+  BRAND,
+  DEFAULTS,
+  fragmentDefinitionSchema
+} 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/validators.ts
+import { createComponentExtractor, resolveComponentSourcePath } from "@fragments-sdk/extract";
+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/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 existsSync2 } from "fs";
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
+import { join as join2, dirname } 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 = join2(configDir, config.outFile ?? "fragments.json");
+  if (!existsSync2(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 readFile3(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 mkdir(dirname(outputPath), { recursive: true });
+    if (format === "html") {
+      const html = generateHtmlReport(analytics);
+      await writeFile(outputPath, html);
+      console.log(pc3.green(`\u2713 Report generated: ${outputPath}
+`));
+    } else {
+      await writeFile(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 join2(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 {
+  validateSchema,
+  validateCoverage,
+  validateAll,
+  validateSnippets,
+  validateDrift,
+  runScreenshotCommand,
+  runDiffCommand,
+  runAnalyzeCommand
+};
+//# sourceMappingURL=chunk-5JF26E55.js.map