@fragments-sdk/cli 0.7.4 → 0.7.6

package/dist/{chunk-S56I5FST.js → chunk-EFQ7SIBX.js}

@@ -4,7 +4,7 @@ import {
   generateRegistry,
   loadFragmentFile,
   parseFragmentFile
-} from "./chunk-R6IZZSE7.js";
+} from "./chunk-JZNATKQA.js";
 import {
   discoverBlockFiles,
   discoverComponentFiles,
@@ -25,15 +25,464 @@ import {
 import {
   compileBlock,
   parseTokenFile
-} from "./chunk-UXLGIGSX.js";
+} from "./chunk-GIC3I2KZ.js";
 import {
   fragmentDefinitionSchema
-} from "./chunk-P33AKQJW.js";
+} from "./chunk-SFWZ4K7C.js";
 import {
   BRAND,
   DEFAULTS
 } from "./chunk-EKLMXTWU.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 === "@fragments/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;
+    if (fileName.endsWith(BRAND.fileExtension)) {
+      return fileName.slice(0, -BRAND.fileExtension.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(BRAND.fileExtension));
+  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
 async function validateSchema(config, configDir) {
   const files = await discoverFragmentFiles(config, configDir);
@@ -110,26 +559,51 @@ async function validateCoverage(config, configDir) {
     warnings
   };
 }
-async function validateAll(config, configDir) {
+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: schemaResult.valid && coverageResult.valid,
-    errors: [...schemaResult.errors, ...coverageResult.errors],
-    warnings: [...schemaResult.warnings, ...coverageResult.warnings]
+    valid: snippetResult.errors.length === 0,
+    errors: snippetResult.errors,
+    warnings: snippetResult.warnings
   };
 }
 
 // src/build.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve4, join as join3 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { resolve as resolve4, join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
 
 // src/core/token-resolver.ts
 import { resolve, dirname, basename } from "path";
-import { existsSync, readdirSync } from "fs";
+import { existsSync as existsSync2, readdirSync } from "fs";
 function roundRgbValues(value) {
   return value.replace(
     /rgb\(([^)]+)\)/g,
@@ -202,7 +676,7 @@ function findVariablesFile(tokensDir) {
   const candidates = ["_variables.scss", "variables.scss"];
   for (const name of candidates) {
     const path = resolve(tokensDir, name);
-    if (existsSync(path)) {
+    if (existsSync2(path)) {
       return path;
     }
   }
@@ -220,14 +694,14 @@ function findVariablesFile(tokensDir) {
 }
 
 // src/core/auto-props.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { dirname as dirname2, extname, join, resolve as resolve2 } from "path";
-import ts from "typescript";
+import { existsSync as existsSync3, statSync } from "fs";
+import { dirname as dirname2, extname, join as join2, resolve as resolve2 } from "path";
+import ts2 from "typescript";
 function toPosixPath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function isFile(filePath) {
-  if (!existsSync2(filePath)) return false;
+  if (!existsSync3(filePath)) return false;
   try {
     return statSync(filePath).isFile();
   } catch {
@@ -245,10 +719,10 @@ function resolveModulePath(basePath) {
       `${basePath}.ts`,
       `${basePath}.jsx`,
       `${basePath}.js`,
-      join(basePath, "index.tsx"),
-      join(basePath, "index.ts"),
-      join(basePath, "index.jsx"),
-      join(basePath, "index.js")
+      join2(basePath, "index.tsx"),
+      join2(basePath, "index.ts"),
+      join2(basePath, "index.jsx"),
+      join2(basePath, "index.js")
     );
   }
   for (const candidate of candidates) {
@@ -270,21 +744,21 @@ function collectTopLevelDeclarations(sourceFile) {
   const functionDeclarations = /* @__PURE__ */ new Map();
   const variableDeclarations = /* @__PURE__ */ new Map();
   for (const node of sourceFile.statements) {
-    if (ts.isInterfaceDeclaration(node)) {
+    if (ts2.isInterfaceDeclaration(node)) {
       typeDeclarations.set(node.name.text, node);
       continue;
     }
-    if (ts.isTypeAliasDeclaration(node)) {
+    if (ts2.isTypeAliasDeclaration(node)) {
       typeDeclarations.set(node.name.text, node);
       continue;
     }
-    if (ts.isFunctionDeclaration(node) && node.name) {
+    if (ts2.isFunctionDeclaration(node) && node.name) {
       functionDeclarations.set(node.name.text, node);
       continue;
     }
-    if (ts.isVariableStatement(node)) {
+    if (ts2.isVariableStatement(node)) {
       for (const declaration of node.declarationList.declarations) {
-        if (ts.isIdentifier(declaration.name)) {
+        if (ts2.isIdentifier(declaration.name)) {
           variableDeclarations.set(declaration.name.text, declaration);
         }
       }
@@ -293,16 +767,16 @@ function collectTopLevelDeclarations(sourceFile) {
   return { typeDeclarations, functionDeclarations, variableDeclarations };
 }
 function readDefaultValue(expression) {
-  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+  if (ts2.isStringLiteral(expression) || ts2.isNoSubstitutionTemplateLiteral(expression)) {
     return expression.text;
   }
-  if (ts.isNumericLiteral(expression)) {
+  if (ts2.isNumericLiteral(expression)) {
     return Number(expression.text);
   }
-  if (expression.kind === ts.SyntaxKind.TrueKeyword) return true;
-  if (expression.kind === ts.SyntaxKind.FalseKeyword) return false;
-  if (expression.kind === ts.SyntaxKind.NullKeyword) return null;
-  if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand)) {
+  if (expression.kind === ts2.SyntaxKind.TrueKeyword) return true;
+  if (expression.kind === ts2.SyntaxKind.FalseKeyword) return false;
+  if (expression.kind === ts2.SyntaxKind.NullKeyword) return null;
+  if (ts2.isPrefixUnaryExpression(expression) && expression.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(expression.operand)) {
     return -Number(expression.operand.text);
   }
   return void 0;
@@ -311,14 +785,14 @@ function extractDefaultValues(componentNode) {
   const defaults = {};
   if (!componentNode?.parameters?.length) return defaults;
   const firstParam = componentNode.parameters[0];
-  if (!ts.isObjectBindingPattern(firstParam.name)) return defaults;
+  if (!ts2.isObjectBindingPattern(firstParam.name)) return defaults;
   for (const element of firstParam.name.elements) {
     let propName = null;
     if (element.propertyName) {
-      if (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName)) {
+      if (ts2.isIdentifier(element.propertyName) || ts2.isStringLiteral(element.propertyName)) {
         propName = element.propertyName.text;
       }
-    } else if (ts.isIdentifier(element.name)) {
+    } else if (ts2.isIdentifier(element.name)) {
       propName = element.name.text;
     }
     if (!propName || !element.initializer) continue;
@@ -330,13 +804,13 @@ function extractDefaultValues(componentNode) {
   return defaults;
 }
 function isNullishType(type) {
-  return (type.flags & ts.TypeFlags.Null) !== 0 || (type.flags & ts.TypeFlags.Undefined) !== 0 || (type.flags & ts.TypeFlags.Void) !== 0;
+  return (type.flags & ts2.TypeFlags.Null) !== 0 || (type.flags & ts2.TypeFlags.Undefined) !== 0 || (type.flags & ts2.TypeFlags.Void) !== 0;
 }
 function isBooleanLikeType(type) {
-  return (type.flags & ts.TypeFlags.BooleanLike) !== 0 || type.flags === ts.TypeFlags.BooleanLiteral;
+  return (type.flags & ts2.TypeFlags.BooleanLike) !== 0 || type.flags === ts2.TypeFlags.BooleanLiteral;
 }
 function inferPropType(type, checker) {
-  const typeText = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+  const typeText = checker.typeToString(type, void 0, ts2.TypeFormatFlags.NoTruncation);
   if (typeText.includes("ReactNode")) {
     return { type: "node" };
   }
@@ -354,7 +828,7 @@ function inferPropType(type, checker) {
     if (nonNullableTypes.length === 1) {
       return inferPropType(nonNullableTypes[0], checker);
     }
-    const stringLiteralValues = nonNullableTypes.filter((unionType) => (unionType.flags & ts.TypeFlags.StringLiteral) !== 0).map((unionType) => unionType.value);
+    const stringLiteralValues = nonNullableTypes.filter((unionType) => (unionType.flags & ts2.TypeFlags.StringLiteral) !== 0).map((unionType) => unionType.value);
     if (stringLiteralValues.length > 0 && stringLiteralValues.length === nonNullableTypes.length) {
       return { type: "enum", values: stringLiteralValues };
     }
@@ -363,16 +837,16 @@ function inferPropType(type, checker) {
     }
     return { type: "union" };
   }
-  if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+  if ((type.flags & ts2.TypeFlags.StringLike) !== 0) {
     return { type: "string" };
   }
-  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+  if ((type.flags & ts2.TypeFlags.NumberLike) !== 0) {
     return { type: "number" };
   }
-  if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) {
+  if ((type.flags & ts2.TypeFlags.BooleanLike) !== 0) {
     return { type: "boolean" };
   }
-  if ((type.flags & ts.TypeFlags.Object) !== 0) {
+  if ((type.flags & ts2.TypeFlags.Object) !== 0) {
     return { type: "object" };
   }
   return { type: "custom" };
@@ -384,42 +858,42 @@ function resolveComponentSignature(exportName, declarations, sourceFile) {
     componentNode: node
   });
   const resolveFromExpression = (expression) => {
-    if (ts.isParenthesizedExpression(expression)) {
+    if (ts2.isParenthesizedExpression(expression)) {
       return resolveFromExpression(expression.expression);
     }
-    if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+    if (ts2.isAsExpression(expression) || ts2.isTypeAssertionExpression(expression)) {
       return resolveFromExpression(expression.expression);
     }
-    if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+    if (ts2.isArrowFunction(expression) || ts2.isFunctionExpression(expression)) {
       return typeNodeFromFunction(expression);
     }
-    if (ts.isIdentifier(expression)) {
+    if (ts2.isIdentifier(expression)) {
       return resolveFromIdentifier(expression.text);
     }
-    if (ts.isCallExpression(expression)) {
-      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
+    if (ts2.isCallExpression(expression)) {
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
         const forwardRefPropsType = expression.typeArguments?.[1] ?? null;
         const innerArg = expression.arguments[0];
-        const inner = innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
+        const inner = innerArg && (ts2.isArrowFunction(innerArg) || ts2.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts2.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
         return {
           propsTypeNode: forwardRefPropsType ?? inner.propsTypeNode,
           componentNode: inner.componentNode
         };
       }
-      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
         return resolveFromExpression(expression.arguments[0]);
       }
-      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.expression.getText(sourceFile) === "Object" && expression.expression.name.text === "assign" && expression.arguments[0]) {
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.expression.getText(sourceFile) === "Object" && expression.expression.name.text === "assign" && expression.arguments[0]) {
         return resolveFromExpression(expression.arguments[0]);
       }
     }
     return { propsTypeNode: null, componentNode: null };
   };
   const resolveFromVariable = (declaration) => {
-    if (declaration.type && ts.isTypeReferenceNode(declaration.type) && declaration.type.typeArguments?.length) {
+    if (declaration.type && ts2.isTypeReferenceNode(declaration.type) && declaration.type.typeArguments?.length) {
       const typeName = declaration.type.typeName.getText(sourceFile);
       if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
-        const componentNode = declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) ? declaration.initializer : null;
+        const componentNode = declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer)) ? declaration.initializer : null;
         return {
           propsTypeNode: declaration.type.typeArguments[0] ?? null,
           componentNode
@@ -451,7 +925,7 @@ function resolveComponentSignature(exportName, declarations, sourceFile) {
 function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
   const warnings = [];
   const resolvedPath = resolve2(componentFilePath);
-  if (!existsSync2(resolvedPath)) {
+  if (!existsSync3(resolvedPath)) {
     return {
       props: {},
       warnings: [`Component file not found: ${resolvedPath}`],
@@ -459,17 +933,17 @@ function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
     };
   }
   const compilerOptions = {
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    jsx: ts.JsxEmit.ReactJSX,
+    target: ts2.ScriptTarget.ESNext,
+    module: ts2.ModuleKind.ESNext,
+    moduleResolution: ts2.ModuleResolutionKind.Bundler,
+    jsx: ts2.JsxEmit.ReactJSX,
     allowSyntheticDefaultImports: true,
     esModuleInterop: true,
     skipLibCheck: true,
     strict: false,
     noEmit: true
   };
-  const program = ts.createProgram([resolvedPath], compilerOptions);
+  const program = ts2.createProgram([resolvedPath], compilerOptions);
   const sourceFile = program.getSourceFile(resolvedPath);
   if (!sourceFile) {
     return {
@@ -506,11 +980,11 @@ function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
     }
     const referenceNode = localDeclarations[0];
     const inferredType = inferPropType(checker.getTypeOfSymbolAtLocation(symbol, referenceNode), checker);
-    const description = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    const description = ts2.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
     extractedProps[propName] = {
       type: inferredType.type,
       description,
-      required: (symbol.getFlags() & ts.SymbolFlags.Optional) === 0,
+      required: (symbol.getFlags() & ts2.SymbolFlags.Optional) === 0,
       ...inferredType.values && { values: inferredType.values },
       ...defaultValues[propName] !== void 0 && { default: defaultValues[propName] }
     };
@@ -526,9 +1000,9 @@ function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
 }
 
 // src/core/graph-extractor.ts
-import ts2 from "typescript";
-import { readFileSync, existsSync as existsSync3 } from "fs";
-import { join as join2 } from "path";
+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) {
@@ -621,17 +1095,17 @@ function extractImportAndHookEdges(componentDir, knownComponents) {
     } catch {
       continue;
     }
-    const sourceFile = ts2.createSourceFile(
+    const sourceFile = ts3.createSourceFile(
       indexPath,
       sourceText,
-      ts2.ScriptTarget.Latest,
+      ts3.ScriptTarget.Latest,
       true,
-      indexPath.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+      indexPath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
     );
     const visitNode = (node) => {
-      if (ts2.isImportDeclaration(node)) {
+      if (ts3.isImportDeclaration(node)) {
         const moduleSpecifier = node.moduleSpecifier;
-        if (ts2.isStringLiteral(moduleSpecifier)) {
+        if (ts3.isStringLiteral(moduleSpecifier)) {
           const importPath = moduleSpecifier.text;
           if (importPath.startsWith(".") || importPath.startsWith("/")) {
             const clause = node.importClause;
@@ -645,7 +1119,7 @@ function extractImportAndHookEdges(componentDir, knownComponents) {
                   provenance: `source:${componentName}/index.tsx`
                 });
               }
-              if (clause.namedBindings && ts2.isNamedImports(clause.namedBindings)) {
+              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) {
@@ -663,7 +1137,7 @@ function extractImportAndHookEdges(componentDir, knownComponents) {
           }
         }
       }
-      if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression)) {
+      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) {
@@ -679,9 +1153,9 @@ function extractImportAndHookEdges(componentDir, knownComponents) {
           }
         }
       }
-      ts2.forEachChild(node, visitNode);
+      ts3.forEachChild(node, visitNode);
     };
-    ts2.forEachChild(sourceFile, visitNode);
+    ts3.forEachChild(sourceFile, visitNode);
   }
   return edges;
 }
@@ -697,30 +1171,30 @@ function extractSubComponents(componentDir, knownComponents) {
       continue;
     }
     if (!sourceText.includes("Object.assign")) continue;
-    const sourceFile = ts2.createSourceFile(
+    const sourceFile = ts3.createSourceFile(
       indexPath,
       sourceText,
-      ts2.ScriptTarget.Latest,
+      ts3.ScriptTarget.Latest,
       true,
-      indexPath.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+      indexPath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
     );
     const subComponents = [];
     const visitNode = (node) => {
-      if (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && node.expression.name.text === "assign" && node.arguments.length >= 2) {
+      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 (ts2.isObjectLiteralExpression(propsArg)) {
+        if (ts3.isObjectLiteralExpression(propsArg)) {
           for (const prop of propsArg.properties) {
-            if (ts2.isShorthandPropertyAssignment(prop)) {
+            if (ts3.isShorthandPropertyAssignment(prop)) {
               subComponents.push(prop.name.text);
-            } else if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+            } else if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.name)) {
               subComponents.push(prop.name.text);
             }
           }
         }
       }
-      ts2.forEachChild(node, visitNode);
+      ts3.forEachChild(node, visitNode);
     };
-    ts2.forEachChild(sourceFile, visitNode);
+    ts3.forEachChild(sourceFile, visitNode);
     if (subComponents.length > 0) {
       result.set(componentName, subComponents);
     }
@@ -880,13 +1354,13 @@ function isPascalCase(name) {
 }
 function findComponentIndex(componentDir, componentName) {
   const candidates = [
-    join2(componentDir, componentName, "index.tsx"),
-    join2(componentDir, componentName, "index.ts"),
-    join2(componentDir, componentName, `${componentName}.tsx`),
-    join2(componentDir, componentName, `${componentName}.ts`)
+    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 (existsSync3(candidate)) {
+    if (existsSync4(candidate)) {
       return candidate;
     }
   }
@@ -895,11 +1369,11 @@ function findComponentIndex(componentDir, componentName) {
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name === componentName) {
         const subCandidates = [
-          join2(componentDir, entry.name, "index.tsx"),
-          join2(componentDir, entry.name, "index.ts")
+          join3(componentDir, entry.name, "index.tsx"),
+          join3(componentDir, entry.name, "index.ts")
         ];
         for (const sc of subCandidates) {
-          if (existsSync3(sc)) return sc;
+          if (existsSync4(sc)) return sc;
         }
       }
     }
@@ -951,7 +1425,7 @@ async function buildFragments(config, configDir) {
   const fragments = {};
   for (const file of files) {
     try {
-      const content = await readFile(file.absolutePath, "utf-8");
+      const content = await readFile2(file.absolutePath, "utf-8");
       const parsed = parseFragmentFile(content, file.relativePath);
       for (const warning of parsed.warnings) {
         warnings.push({ file: file.relativePath, warning });
@@ -1086,7 +1560,7 @@ async function buildFragments(config, configDir) {
       let total = 0;
       const fileContents = [];
       for (const file of tokenFiles) {
-        const content = await readFile(file.absolutePath, "utf-8");
+        const content = await readFile2(file.absolutePath, "utf-8");
         fileContents.push({ content, path: file.relativePath });
       }
       const allContent = fileContents.map((f) => f.content).join("\n");
@@ -1141,9 +1615,9 @@ async function buildFragments(config, configDir) {
   }
   let packageName;
   const pkgJsonPath = resolve4(configDir, "package.json");
-  if (existsSync4(pkgJsonPath)) {
+  if (existsSync5(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(await readFile2(pkgJsonPath, "utf-8"));
       if (pkg.name) packageName = pkg.name;
     } catch {
     }
@@ -1199,8 +1673,8 @@ async function buildFragments(config, configDir) {
   };
 }
 async function buildFragmentsDir(config, configDir) {
-  const fragmentsDir = join3(configDir, BRAND.dataDir);
-  const componentsDir = join3(fragmentsDir, BRAND.componentsDir);
+  const fragmentsDir = join4(configDir, BRAND.dataDir);
+  const componentsDir = join4(fragmentsDir, BRAND.componentsDir);
   await mkdir(fragmentsDir, { recursive: true });
   await mkdir(componentsDir, { recursive: true });
   const registryResult = await generateRegistry({
@@ -1212,9 +1686,9 @@ async function buildFragmentsDir(config, configDir) {
   });
   const errors = [...registryResult.errors];
   const warnings = [...registryResult.warnings];
-  const indexPath = join3(fragmentsDir, "index.json");
+  const indexPath = join4(fragmentsDir, "index.json");
   await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
-  const registryPath = join3(fragmentsDir, BRAND.registryFile);
+  const registryPath = join4(fragmentsDir, BRAND.registryFile);
   await writeFile(registryPath, JSON.stringify(registryResult.registry, null, 2));
   const contextResult = generateContextMd(registryResult.registry, {
     format: "markdown",
@@ -1226,7 +1700,7 @@ async function buildFragmentsDir(config, configDir) {
       code: false
     }
   });
-  const contextPath = join3(fragmentsDir, BRAND.contextFile);
+  const contextPath = join4(fragmentsDir, BRAND.contextFile);
   await writeFile(contextPath, contextResult.content);
   return {
     success: errors.length === 0,
@@ -1579,9 +2053,9 @@ ${BRAND.name} Diff
 }
 
 // src/analyze.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join4, dirname as dirname3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join5, dirname as dirname3 } from "path";
 import pc3 from "picocolors";
 async function runAnalyzeCommand(config, configDir, options = {}) {
   const format = options.format ?? "html";
@@ -1589,8 +2063,8 @@ async function runAnalyzeCommand(config, configDir, options = {}) {
   console.log(pc3.cyan(`
 ${BRAND.name} Analyzer
 `));
-  const fragmentsPath = join4(configDir, config.outFile ?? "fragments.json");
-  if (!existsSync5(fragmentsPath)) {
+  const fragmentsPath = join5(configDir, config.outFile ?? "fragments.json");
+  if (!existsSync6(fragmentsPath)) {
     console.log(pc3.red(`\u2717 No fragments.json found. Run \`${BRAND.cliCommand} build\` first.
 `));
     return {
@@ -1599,7 +2073,7 @@ ${BRAND.name} Analyzer
     };
   }
   console.log(pc3.dim("Analyzing design system...\n"));
-  const content = await readFile2(fragmentsPath, "utf-8");
+  const content = await readFile3(fragmentsPath, "utf-8");
   const data = JSON.parse(content);
   const analytics = analyzeDesignSystem(data);
   printConsoleSummary(analytics);
@@ -1685,7 +2159,7 @@ function colorizeScore(score) {
 }
 function getDefaultOutputPath(format, configDir) {
   const filename = format === "html" ? "fragments-report.html" : "fragments-report.json";
-  return join4(configDir, filename);
+  return join5(configDir, filename);
 }
 async function openInBrowser(path) {
   const { platform } = await import("os");
@@ -1747,10 +2221,11 @@ export {
   validateSchema,
   validateCoverage,
   validateAll,
+  validateSnippets,
   buildFragments,
   buildFragmentsDir,
   runScreenshotCommand,
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-S56I5FST.js.map
+//# sourceMappingURL=chunk-EFQ7SIBX.js.map