@fragments-sdk/mcp 0.6.2 → 0.7.1

package/dist/chunk-HGGAXLRO.js

@@ -0,0 +1,4501 @@
+import {
+  BRAND,
+  DEFAULTS
+} from "./chunk-4SVS3AA3.js";
+import {
+  componentNames,
+  findComponent,
+  findComponentByName,
+  getGuidanceWhen,
+  getGuidanceWhenNot,
+  listBlocks,
+  listComponents
+} from "./chunk-YSRGQDEB.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+import { fileURLToPath } from "url";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function loadConfigFile(projectRoot) {
+  const configPath = join(projectRoot, "ds-mcp.config.json");
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, "utf-8");
+      return JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  const pkgPath = join(projectRoot, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const content = readFileSync(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.dsMcp) return pkg.dsMcp;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/server.ts
+import { buildMcpTools, buildToolNames, MCP_TOOL_DEFINITIONS } from "@fragments-sdk/context/mcp-tools";
+
+// src/orama-index.ts
+import { create, insertMultiple, search } from "@orama/orama";
+var SYNONYM_MAP = {
+  "form": ["input", "field", "submit", "validation"],
+  "input": ["form", "field", "text", "entry"],
+  "button": ["action", "click", "submit", "trigger"],
+  "action": ["button", "click", "trigger"],
+  "submit": ["button", "form", "action", "send"],
+  "alert": ["notification", "message", "warning", "error", "feedback"],
+  "notification": ["alert", "message", "toast"],
+  "feedback": ["form", "comment", "review", "rating"],
+  "card": ["container", "panel", "box", "content"],
+  "toggle": ["switch", "checkbox", "boolean", "on/off"],
+  "switch": ["toggle", "checkbox", "boolean"],
+  "badge": ["tag", "label", "status", "indicator"],
+  "status": ["badge", "indicator", "state"],
+  "login": ["auth", "signin", "authentication", "form"],
+  "auth": ["login", "signin", "authentication"],
+  "chat": ["message", "conversation", "ai"],
+  "table": ["data", "grid", "list", "rows"],
+  "textarea": ["text", "input", "multiline", "area", "comment"],
+  "area": ["textarea", "multiline", "text"],
+  "landing": ["page", "hero", "marketing", "section", "layout"],
+  "hero": ["landing", "marketing", "banner", "headline", "section"],
+  "marketing": ["landing", "hero", "pricing", "testimonial", "cta"],
+  "cta": ["marketing", "banner", "action", "button"],
+  "testimonial": ["marketing", "review", "quote", "feedback"],
+  "layout": ["stack", "grid", "box", "container", "page"],
+  "page": ["layout", "landing", "section", "container"],
+  "section": ["hero", "feature", "testimonial", "cta", "faq"],
+  "pricing": ["card", "plan", "tier", "marketing"],
+  "plan": ["pricing", "card", "tier", "subscription"],
+  "dashboard": ["metrics", "stats", "chart", "card", "grid"],
+  "metrics": ["dashboard", "stats", "progress", "number"],
+  "stats": ["metrics", "dashboard", "progress", "badge"],
+  "chart": ["dashboard", "metrics", "data", "graph"]
+};
+function expandQuery(query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const expanded = new Set(terms);
+  for (const term of terms) {
+    const synonyms = SYNONYM_MAP[term];
+    if (synonyms) {
+      for (const syn of synonyms) expanded.add(syn);
+    }
+  }
+  return Array.from(expanded).join(" ");
+}
+function twoPassSearch(config) {
+  const { index, query, properties, boost, limit, kind } = config;
+  const baseConfig = {
+    mode: "fulltext",
+    properties,
+    boost,
+    limit
+  };
+  const originalTermsQuery = query.toLowerCase().split(/\s+/).filter(Boolean).join(" ");
+  const expandedQuery = expandQuery(query);
+  const originalResults = search(index, { term: originalTermsQuery, ...baseConfig, threshold: 0.8 });
+  const expandedResults = search(index, { term: expandedQuery, ...baseConfig, threshold: 1 });
+  const origHits = originalResults.hits;
+  const expHits = expandedResults.hits;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const hit of origHits) {
+    scoreMap.set(hit.document.name, (hit.score || 0) * 2);
+  }
+  for (const hit of expHits) {
+    const name = hit.document.name;
+    const existing = scoreMap.get(name) ?? 0;
+    scoreMap.set(name, existing + (hit.score || 0));
+  }
+  const scored = [];
+  for (const [name, score] of scoreMap) {
+    if (score > 0) {
+      scored.push({ name, kind, rank: scored.length, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  scored.forEach((s, i) => {
+    s.rank = i;
+  });
+  return scored;
+}
+var componentSchema = {
+  name: "string",
+  description: "string",
+  category: "string",
+  tags: "string",
+  whenUsed: "string",
+  patterns: "string",
+  variants: "string",
+  status: "string"
+};
+function isCompiledFragment(value) {
+  return "meta" in value;
+}
+function normalizeComponent(value) {
+  if (!isCompiledFragment(value)) return value;
+  return {
+    id: value.filePath ?? value.meta.name,
+    name: value.meta.name,
+    description: value.meta.description ?? "",
+    category: value.meta.category ?? "uncategorized",
+    status: value.meta.status ?? "stable",
+    tags: value.meta.tags ?? [],
+    props: {},
+    propsSummary: value.propsSummary ?? value.contract?.propsSummary ?? Object.entries(value.props ?? {}).map(
+      ([propName, prop]) => `${propName}${prop.required ? " (required)" : ""}: ${prop.type}`
+    ),
+    examples: (value.variants ?? []).map((variant) => ({
+      name: variant.name,
+      description: variant.description,
+      code: variant.code
+    })),
+    relations: (value.relations ?? []).map((relation) => ({
+      componentName: relation.component,
+      relationship: relation.relationship,
+      note: relation.note
+    })),
+    compoundChildren: [],
+    guidance: {
+      when: value.usage?.when ?? [],
+      whenNot: value.usage?.whenNot ?? [],
+      guidelines: value.usage?.guidelines ?? [],
+      accessibility: value.usage?.accessibility ?? [],
+      dos: value.usage?.when ?? [],
+      donts: value.usage?.whenNot ?? [],
+      patterns: []
+    },
+    sourceType: "fragments-json",
+    sourcePath: value.sourcePath ?? value.filePath,
+    metadata: {
+      a11yRules: value.contract?.a11yRules ?? [],
+      scenarioTags: value.contract?.scenarioTags ?? []
+    }
+  };
+}
+function buildComponentIndex(fragments) {
+  const db = create({ schema: componentSchema, language: "english" });
+  const normalized = fragments.map(normalizeComponent);
+  const docs = normalized.map((f) => ({
+    name: f.name,
+    description: f.description ?? "",
+    category: f.category ?? "",
+    tags: (f.tags ?? []).join(" "),
+    whenUsed: (f.guidance.when ?? []).join(" "),
+    patterns: (f.guidance.patterns ?? []).map(
+      (pattern) => `${pattern.name} ${pattern.description || ""}`
+    ).join(" "),
+    variants: f.examples.map(
+      (example) => `${example.name} ${example.description || ""}`
+    ).join(" "),
+    status: f.status ?? "stable"
+  }));
+  insertMultiple(db, docs);
+  return db;
+}
+function searchComponents(query, index, fragments, limit = 50) {
+  const normalized = fragments.map(normalizeComponent);
+  const boostConfig = {
+    mode: "fulltext",
+    properties: ["name", "whenUsed", "description", "patterns", "category", "tags", "variants"],
+    boost: {
+      name: 3,
+      whenUsed: 2.5,
+      description: 2,
+      patterns: 1.5,
+      category: 1.5,
+      tags: 1.5,
+      variants: 1
+    },
+    limit
+  };
+  const originalTermsList = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const originalTermsQuery = originalTermsList.join(" ");
+  const expandedQuery = expandQuery(query);
+  const originalResults = search(index, { term: originalTermsQuery, ...boostConfig, threshold: 0.8 });
+  const expandedResults = search(index, { term: expandedQuery, ...boostConfig, threshold: 1 });
+  const origHits = originalResults.hits;
+  const expHits = expandedResults.hits;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const hit of origHits) {
+    scoreMap.set(hit.document.name, (hit.score || 0) * 2);
+  }
+  for (const hit of expHits) {
+    const name = hit.document.name;
+    const existing = scoreMap.get(name) ?? 0;
+    scoreMap.set(name, existing + (hit.score || 0));
+  }
+  const fragmentMap = /* @__PURE__ */ new Map();
+  for (const f of normalized) {
+    fragmentMap.set(f.name.toLowerCase(), f);
+  }
+  const originalTermsSet = new Set(originalTermsList);
+  const scored = [];
+  for (const [name, rawScore] of scoreMap) {
+    let score = rawScore;
+    const nameLower = name.toLowerCase();
+    const fragment = fragmentMap.get(nameLower);
+    if (originalTermsSet.has(nameLower)) {
+      score += 25;
+    }
+    if (fragment) {
+      if (fragment.status === "stable") score += 5;
+      else if (fragment.status === "beta") score += 2;
+      if (fragment.status === "deprecated") score -= 25;
+    }
+    if (score > 0) {
+      scored.push({ name, kind: "component", rank: scored.length, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  scored.forEach((s, i) => {
+    s.rank = i;
+  });
+  return scored;
+}
+var blockSchema = {
+  name: "string",
+  description: "string",
+  category: "string",
+  tags: "string",
+  components: "string"
+};
+function normalizeBlock(value) {
+  if ("id" in value) return value;
+  return {
+    id: value.filePath ?? value.name,
+    name: value.name,
+    description: value.description ?? "",
+    category: value.category ?? "uncategorized",
+    components: value.components ?? [],
+    tags: value.tags ?? [],
+    code: value.code ?? ""
+  };
+}
+function buildBlockIndex(blocks) {
+  const db = create({ schema: blockSchema, language: "english" });
+  const normalized = blocks.map(normalizeBlock);
+  const docs = normalized.map((b) => ({
+    name: b.name,
+    description: b.description ?? "",
+    category: b.category ?? "",
+    tags: (b.tags ?? []).join(" "),
+    components: b.components.join(" ")
+  }));
+  insertMultiple(db, docs);
+  return db;
+}
+function searchBlocks(query, index, limit = 50) {
+  return twoPassSearch({
+    index,
+    query,
+    properties: ["name", "description", "components", "tags", "category"],
+    boost: {
+      name: 3,
+      description: 2,
+      components: 1.5,
+      tags: 1.5,
+      category: 1.5
+    },
+    limit,
+    kind: "block"
+  });
+}
+var tokenSchema = {
+  name: "string",
+  category: "string",
+  description: "string"
+};
+function normalizeTokenData(tokenData) {
+  if ("flat" in tokenData) return tokenData;
+  const categories = Object.fromEntries(
+    Object.entries(tokenData.categories).map(([category, entries]) => [
+      category,
+      entries.map((entry) => ({
+        name: entry.name,
+        category,
+        value: typeof entry.value === "string" ? entry.value : void 0,
+        description: entry.description
+      }))
+    ])
+  );
+  return {
+    prefix: tokenData.prefix,
+    total: tokenData.total,
+    categories,
+    flat: Object.values(categories).flat()
+  };
+}
+function buildTokenIndex(tokenData) {
+  const db = create({ schema: tokenSchema, language: "english" });
+  const normalizedData = normalizeTokenData(tokenData);
+  const docs = [];
+  for (const [cat, tokens] of Object.entries(normalizedData.categories)) {
+    for (const token of tokens) {
+      docs.push({
+        name: token.name,
+        category: cat,
+        description: token.description ?? ""
+      });
+    }
+  }
+  insertMultiple(db, docs);
+  return db;
+}
+function searchTokens(query, index, limit = 50) {
+  return twoPassSearch({
+    index,
+    query,
+    properties: ["name", "category", "description"],
+    boost: {
+      name: 2.5,
+      category: 2,
+      description: 1.5
+    },
+    limit,
+    kind: "token"
+  });
+}
+var USE_CASE_TOKEN_CATEGORIES = {
+  "table": ["spacing", "borders", "surfaces", "text"],
+  "data": ["spacing", "borders", "surfaces"],
+  "grid": ["spacing", "layout"],
+  "form": ["spacing", "borders", "radius", "focus"],
+  "input": ["spacing", "borders", "radius", "focus"],
+  "card": ["surfaces", "shadows", "radius", "borders", "spacing"],
+  "button": ["colors", "radius", "spacing", "focus"],
+  "layout": ["spacing", "layout", "surfaces"],
+  "dashboard": ["spacing", "surfaces", "borders", "shadows"],
+  "chat": ["spacing", "surfaces", "radius", "shadows"],
+  "modal": ["shadows", "surfaces", "radius", "spacing"],
+  "dialog": ["shadows", "surfaces", "radius", "spacing"],
+  "navigation": ["spacing", "surfaces", "borders"],
+  "sidebar": ["spacing", "surfaces", "borders"],
+  "hero": ["spacing", "typography", "colors"],
+  "landing": ["spacing", "typography", "colors"],
+  "pricing": ["spacing", "surfaces", "borders", "radius"],
+  "auth": ["spacing", "borders", "radius", "focus"],
+  "login": ["spacing", "borders", "radius", "focus"],
+  "dark": ["colors", "surfaces"],
+  "theme": ["colors", "surfaces", "text"]
+};
+function extractTokenCategories(query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const categories = /* @__PURE__ */ new Set();
+  for (const term of terms) {
+    const cats = USE_CASE_TOKEN_CATEGORIES[term];
+    if (cats) {
+      for (const cat of cats) categories.add(cat);
+    }
+  }
+  if (categories.size === 0) {
+    return ["spacing", "colors", "surfaces"];
+  }
+  return Array.from(categories);
+}
+
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+function readPackageVersion() {
+  try {
+    const raw = readFileSync2(new URL("../package.json", import.meta.url), "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var MCP_SERVER_VERSION = readPackageVersion();
+
+// src/search.ts
+var CONVEX_SEARCH_URL = "https://combative-jay-834.convex.site/search";
+var CONVEX_TIMEOUT_MS = 3e3;
+async function searchConvex(query, apiKey, limit = 10, kind) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), CONVEX_TIMEOUT_MS);
+    const response = await fetch(CONVEX_SEARCH_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ query, limit, ...kind && { kind } }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return data.results.map((r, i) => ({
+      name: r.name,
+      kind: r.kind ?? "component",
+      rank: i,
+      score: r.score
+    }));
+  } catch {
+    return [];
+  }
+}
+function keywordScoreComponents(query, fragments, componentIndex) {
+  const index = componentIndex ?? buildComponentIndex(fragments);
+  return searchComponents(query, index, fragments);
+}
+function keywordScoreBlocks(query, blocks, blockIndex) {
+  const index = blockIndex ?? buildBlockIndex(blocks);
+  return searchBlocks(query, index);
+}
+function keywordScoreTokens(query, tokenData, tokenIndex) {
+  const index = tokenIndex ?? buildTokenIndex(tokenData);
+  return searchTokens(query, index);
+}
+function reciprocalRankFusion(resultSets, k = 60) {
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const { results } of resultSets) {
+    for (let rank = 0; rank < results.length; rank++) {
+      const result = results[rank];
+      const key = `${result.kind}:${result.name}`;
+      const rrfScore = 1 / (k + rank + 1);
+      const existing = scoreMap.get(key);
+      if (existing) {
+        existing.score += rrfScore;
+      } else {
+        scoreMap.set(key, { score: rrfScore, kind: result.kind, name: result.name });
+      }
+    }
+  }
+  const fused = [];
+  for (const [, { score, kind, name }] of scoreMap) {
+    fused.push({ name, kind, rank: 0, score });
+  }
+  fused.sort((a, b) => b.score - a.score);
+  fused.forEach((r, i) => {
+    r.rank = i;
+  });
+  return fused;
+}
+async function hybridSearch(query, data, limit = 10, kind, apiKey) {
+  const keywordResults = [];
+  if (!kind || kind === "component") {
+    keywordResults.push(...keywordScoreComponents(query, data.fragments, data.componentIndex));
+  }
+  if ((!kind || kind === "block") && data.blocks) {
+    keywordResults.push(...keywordScoreBlocks(query, data.blocks, data.blockIndex));
+  }
+  if ((!kind || kind === "token") && data.tokenData) {
+    keywordResults.push(...keywordScoreTokens(query, data.tokenData, data.tokenIndex));
+  }
+  keywordResults.sort((a, b) => b.score - a.score);
+  keywordResults.forEach((r, i) => {
+    r.rank = i;
+  });
+  if (!apiKey) {
+    return keywordResults.slice(0, limit);
+  }
+  const vectorResults = await searchConvex(query, apiKey, limit, kind);
+  if (vectorResults.length === 0) {
+    return keywordResults.slice(0, limit);
+  }
+  const graphBoostResults = [];
+  if (data.graph) {
+    try {
+      const { ComponentGraphEngine: ComponentGraphEngine2, deserializeGraph: deserializeGraph2 } = await import("@fragments-sdk/context/graph");
+      const graph = deserializeGraph2(data.graph);
+      const engine = new ComponentGraphEngine2(graph);
+      const topComponents = [...keywordResults, ...vectorResults].filter((r) => r.kind === "component").slice(0, 5);
+      const neighborSet = /* @__PURE__ */ new Set();
+      for (const result of topComponents) {
+        const neighbors = engine.neighbors(result.name, 1);
+        for (const n of neighbors.neighbors) {
+          if (!neighborSet.has(n.component)) {
+            neighborSet.add(n.component);
+            graphBoostResults.push({
+              name: n.component,
+              kind: "component",
+              rank: graphBoostResults.length,
+              score: 1
+              // Will be normalized through RRF
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const resultSets = [
+    { label: "vector", results: vectorResults },
+    { label: "keyword", results: keywordResults }
+  ];
+  if (graphBoostResults.length > 0) {
+    resultSets.push({ label: "graph", results: graphBoostResults });
+  }
+  const fused = reciprocalRankFusion(resultSets);
+  return fused.slice(0, limit);
+}
+
+// src/scoring.ts
+var MINIMUM_SCORE_THRESHOLD = 5;
+function assignConfidence(score, maxScore) {
+  if (maxScore <= 0) return "low";
+  const ratio = score / maxScore;
+  if (ratio >= 0.7) return "high";
+  if (ratio >= 0.4) return "medium";
+  return "low";
+}
+function meetsMinimumThreshold(maxScore) {
+  return maxScore >= MINIMUM_SCORE_THRESHOLD;
+}
+function levenshtein(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  const dp = Array.from({ length: lb + 1 }, (_, i) => i);
+  for (let i = 1; i <= la; i++) {
+    let prev = i - 1;
+    dp[0] = i;
+    for (let j = 1; j <= lb; j++) {
+      const temp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = temp;
+    }
+  }
+  return dp[lb];
+}
+function findClosestMatch(input, candidates, maxDistance = 3) {
+  const inputLower = input.toLowerCase();
+  let bestMatch = null;
+  let bestDist = maxDistance + 1;
+  for (const candidate of candidates) {
+    const candidateLower = candidate.toLowerCase();
+    const dist = levenshtein(inputLower, candidateLower);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestMatch = candidate;
+    } else if (dist === bestDist && bestMatch) {
+      const currentLenDiff = Math.abs(bestMatch.length - input.length);
+      const newLenDiff = Math.abs(candidate.length - input.length);
+      if (newLenDiff < currentLenDiff) {
+        bestMatch = candidate;
+      }
+    }
+  }
+  return bestDist <= maxDistance ? bestMatch : null;
+}
+var BLOCK_BOOST_PER_OCCURRENCE = 5;
+function buildBlockComponentFrequency(blocks) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    for (const comp of block.components) {
+      const key = comp.toLowerCase();
+      freq.set(key, (freq.get(key) ?? 0) + 1);
+    }
+  }
+  return freq;
+}
+function boostByBlockFrequency(results, freq) {
+  for (const result of results) {
+    const count = freq.get(result.name.toLowerCase()) ?? 0;
+    if (count > 0) {
+      result.score += count * BLOCK_BOOST_PER_OCCURRENCE;
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  results.forEach((r, i) => {
+    r.rank = i;
+  });
+  return results;
+}
+
+// src/server-helpers.ts
+function normalizeFilter(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function categoryMatches(category, categoryFilter) {
+  if (!categoryFilter) return true;
+  return normalizeFilter(category) === categoryFilter;
+}
+function buildLocalSearchData(data, indexes) {
+  const isLegacy = "fragments" in data;
+  const allFragments = Object.values(
+    isLegacy ? data.fragments : data.components
+  );
+  const allBlocks = Object.values(
+    isLegacy ? data.blocks ?? data.recipes ?? {} : data.blocks ?? {}
+  );
+  const tokens = isLegacy ? data.tokens : data.tokens;
+  const graph = isLegacy ? data.graph : data.graph;
+  const localData = {
+    fragments: allFragments,
+    blocks: allBlocks,
+    tokenData: tokens,
+    graph,
+    componentIndex: indexes.componentIndex ?? void 0,
+    blockIndex: indexes.blockIndex ?? void 0,
+    tokenIndex: indexes.tokenIndex ?? void 0
+  };
+  return { allFragments, allBlocks, localData };
+}
+async function buildImportStatements(components, resolvePackageName) {
+  const grouped = /* @__PURE__ */ new Map();
+  const uniqueComponents = [...new Set(components.filter(Boolean))];
+  const resolvedPackages = await Promise.all(
+    uniqueComponents.map(async (component) => ({
+      component,
+      packageName: await resolvePackageName(component)
+    }))
+  );
+  for (const { component, packageName } of resolvedPackages) {
+    const existing = grouped.get(packageName);
+    if (!existing) {
+      grouped.set(packageName, [component]);
+      continue;
+    }
+    existing.push(component);
+  }
+  return Array.from(grouped.entries()).map(
+    ([packageName, componentNames2]) => `import { ${componentNames2.join(", ")} } from '${packageName}';`
+  );
+}
+function limitTokensPerCategory(categories, limit) {
+  if (limit === void 0) {
+    return {
+      categories,
+      total: Object.values(categories).reduce((sum, tokens) => sum + tokens.length, 0)
+    };
+  }
+  const limited = {};
+  let total = 0;
+  for (const [category, tokens] of Object.entries(categories)) {
+    const sliced = tokens.slice(0, limit);
+    if (sliced.length === 0) continue;
+    limited[category] = sliced;
+    total += sliced.length;
+  }
+  return { categories: limited, total };
+}
+
+// src/search-helpers.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "bar",
+  "build",
+  "button",
+  "for",
+  "form",
+  "i",
+  "login",
+  "me",
+  "need",
+  "of",
+  "or",
+  "the",
+  "to",
+  "use",
+  "with"
+]);
+function normalizeTerms(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/g).filter((term) => term.length > 1 && !STOP_WORDS.has(term));
+}
+function hasDirectQueryOverlap(query, component) {
+  const queryTerms = normalizeTerms(query);
+  if (queryTerms.length === 0) return true;
+  const haystack = new Set(
+    normalizeTerms(
+      [
+        component.name,
+        component.description,
+        component.category,
+        component.tags.join(" "),
+        getGuidanceWhen(component).join(" "),
+        getGuidanceWhenNot(component).join(" "),
+        component.propsSummary.join(" ")
+      ].join(" ")
+    )
+  );
+  return queryTerms.some((term) => haystack.has(term));
+}
+function getRankingBonus(component) {
+  let bonus = 0;
+  if (component.isCanonical) bonus += 30;
+  if (component.tier === "core") bonus += 20;
+  if (component.status === "stable") bonus += 5;
+  return bonus;
+}
+
+// src/tools/discover.ts
+function renderContextMarkdown(args) {
+  const lines = ["# Design System Context", ""];
+  for (const component of args.components) {
+    lines.push(`## ${component.name}`);
+    if (component.description) {
+      lines.push(component.description);
+    }
+    lines.push(
+      `- Category: ${component.category}`,
+      `- Status: ${component.status}`
+    );
+    if (component.propsSummary.length > 0) {
+      lines.push(`- Props: ${component.propsSummary.join(", ")}`);
+    }
+    const when = getGuidanceWhen(component);
+    if (when.length > 0) {
+      lines.push(`- Use when: ${when.slice(0, args.compact ? 1 : 3).join("; ")}`);
+    }
+    const whenNot = getGuidanceWhenNot(component);
+    if (whenNot.length > 0) {
+      lines.push(
+        `- Avoid when: ${whenNot.slice(0, args.compact ? 1 : 2).join("; ")}`
+      );
+    }
+    if (args.includeRelations && component.relations.length > 0) {
+      lines.push(
+        `- Related: ${component.relations.slice(0, 5).map(
+          (relation) => `${relation.componentName} (${relation.relationship})`
+        ).join(", ")}`
+      );
+    }
+    if (args.includeCode && component.examples[0]?.code) {
+      lines.push("", "```tsx", component.examples[0].code, "```");
+    }
+    lines.push("");
+  }
+  if (args.blocks.length > 0) {
+    lines.push("## Blocks", "");
+    for (const block of args.blocks) {
+      lines.push(`- ${block.name}: ${block.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function renderContextJson(args) {
+  return JSON.stringify({
+    components: args.components.map((component) => ({
+      name: component.name,
+      description: component.description,
+      category: component.category,
+      status: component.status,
+      propsSummary: component.propsSummary,
+      when: getGuidanceWhen(component),
+      whenNot: getGuidanceWhenNot(component),
+      ...args.includeRelations && { relations: component.relations },
+      ...args.includeCode && {
+        examples: component.examples.filter((example) => Boolean(example.code)).slice(0, 2)
+      }
+    })),
+    blocks: args.blocks
+  });
+}
+var discoverHandler = async (args, ctx) => {
+  const data = ctx.data;
+  const snapshotComponents = listComponents(data.snapshot);
+  const componentsByName = new Map(
+    snapshotComponents.map((component) => [
+      component.name.toLowerCase(),
+      component
+    ])
+  );
+  const useCase = args?.useCase ?? void 0;
+  const componentForAlts = args?.component ?? void 0;
+  const category = normalizeFilter(args?.category);
+  const search2 = args?.search?.toLowerCase() ?? void 0;
+  const status = args?.status ?? void 0;
+  const format = args?.format ?? "markdown";
+  const compact = args?.compact ?? false;
+  const includeCode = args?.includeCode ?? false;
+  const includeRelations = args?.includeRelations ?? false;
+  const depth = args?.depth ?? "quick";
+  const suggestLimit = typeof args?.limit === "number" ? Math.min(Math.max(args.limit, 1), 25) : 10;
+  const listLimit = typeof args?.limit === "number" ? Math.min(Math.max(args.limit, 1), 25) : void 0;
+  const verbosity = args?.verbosity ?? (compact ? "compact" : "standard");
+  const allSnapshotComponents = listComponents(data.snapshot);
+  if (!useCase && !componentForAlts && (args?.format || includeCode || includeRelations)) {
+    let components2 = allSnapshotComponents;
+    const allBlocks = listBlocks(data.snapshot);
+    if (category) {
+      components2 = components2.filter(
+        (component) => categoryMatches(component.category, category)
+      );
+    }
+    if (search2) {
+      const scored = keywordScoreComponents(
+        search2,
+        components2,
+        ctx.indexes.componentIndex ?? void 0
+      );
+      const allowedNames = new Set(components2.map((component) => component.name));
+      const sortedNames = scored.filter((result) => allowedNames.has(result.name)).map((result) => result.name.toLowerCase());
+      components2 = components2.filter((component) => sortedNames.includes(component.name.toLowerCase())).sort(
+        (a, b) => sortedNames.indexOf(a.name.toLowerCase()) - sortedNames.indexOf(b.name.toLowerCase())
+      );
+    }
+    if (status) {
+      components2 = components2.filter((component) => component.status === status);
+    }
+    const blocks = allBlocks.map((block) => ({
+      name: block.name,
+      description: block.description
+    }));
+    const ctxContent = format === "json" ? renderContextJson({
+      components: components2,
+      blocks,
+      includeCode: includeCode || verbosity === "full",
+      includeRelations
+    }) : renderContextMarkdown({
+      components: components2,
+      blocks,
+      includeCode: includeCode || verbosity === "full",
+      includeRelations,
+      compact: verbosity === "compact"
+    });
+    return {
+      content: [{ type: "text", text: ctxContent }],
+      _meta: {
+        componentCount: components2.length,
+        blockCount: blocks.length
+      }
+    };
+  }
+  if (useCase) {
+    const { allFragments, allBlocks, localData } = buildLocalSearchData(
+      {
+        components: data.components,
+        blocks: data.blocks,
+        tokens: data.tokens,
+        graph: data.graph
+      },
+      {
+        componentIndex: ctx.indexes.componentIndex,
+        blockIndex: ctx.indexes.blockIndex,
+        tokenIndex: ctx.indexes.tokenIndex
+      }
+    );
+    const context = args?.context?.toLowerCase() ?? "";
+    const fullQuery = context ? `${useCase} ${context}` : useCase;
+    const searchResults = await hybridSearch(
+      fullQuery,
+      localData,
+      suggestLimit,
+      "component",
+      ctx.config.searchApiKey
+    );
+    const filteredSearchResults = searchResults.filter((result) => {
+      const component = componentsByName.get(result.name.toLowerCase());
+      if (!component) return false;
+      if (category && !categoryMatches(component.category, category)) return false;
+      if (status && component.status !== status) return false;
+      result.score += getRankingBonus(component);
+      return true;
+    });
+    const blockMatches = keywordScoreBlocks(
+      fullQuery,
+      allBlocks,
+      ctx.indexes.blockIndex ?? void 0
+    ).slice(0, 5);
+    if (blockMatches.length > 0) {
+      const matchedBlocks = blockMatches.map(
+        (match) => allBlocks.find((block) => block.name.toLowerCase() === match.name.toLowerCase())
+      ).filter(Boolean);
+      const blockFreq = buildBlockComponentFrequency(matchedBlocks);
+      boostByBlockFrequency(filteredSearchResults, blockFreq);
+    }
+    const maxScore = filteredSearchResults.length > 0 ? filteredSearchResults[0].score : 0;
+    const scored = filteredSearchResults.map((result) => {
+      const component = componentsByName.get(result.name.toLowerCase());
+      if (!component) return null;
+      return {
+        component: component.name,
+        category: component.category,
+        description: component.description,
+        confidence: assignConfidence(result.score, maxScore),
+        reasons: [`Matched via hybrid search (score: ${result.score.toFixed(4)})`],
+        usage: {
+          when: getGuidanceWhen(component).slice(0, 3),
+          whenNot: getGuidanceWhenNot(component).slice(0, 2)
+        },
+        publicRef: component.publicRef,
+        componentKey: component.id,
+        tier: component.tier,
+        isCanonical: component.isCanonical ?? false,
+        sourcePath: component.sourcePath,
+        exampleCount: component.examples.length,
+        status: component.status
+      };
+    }).filter(Boolean);
+    const suggestions = [];
+    const categoryCount = {};
+    for (const item of scored) {
+      if (!item) continue;
+      const cat = item.category || "uncategorized";
+      const count = categoryCount[cat] || 0;
+      if (count < 2 || suggestions.length < 3) {
+        suggestions.push(item);
+        categoryCount[cat] = count + 1;
+        if (suggestions.length >= suggestLimit) break;
+      }
+    }
+    const compositionHint = suggestions.length >= 2 ? `These components work well together. For example, ${suggestions[0].component} can be combined with ${suggestions.slice(1, 3).map((item) => item.component).join(" and ")}.` : void 0;
+    const useCaseLower = useCase.toLowerCase();
+    const styleKeywords = [
+      "color",
+      "spacing",
+      "padding",
+      "margin",
+      "font",
+      "border",
+      "radius",
+      "shadow",
+      "variable",
+      "token",
+      "css",
+      "theme",
+      "dark mode",
+      "background",
+      "hover"
+    ];
+    const isStyleQuery = styleKeywords.some(
+      (keyword) => useCaseLower.includes(keyword)
+    );
+    const noMatch = suggestions.length === 0 || !suggestions.some((item) => {
+      const component = componentsByName.get(item.component.toLowerCase());
+      return component ? hasDirectQueryOverlap(useCase, component) : false;
+    });
+    const belowThreshold = !noMatch && maxScore > 1 && !meetsMinimumThreshold(maxScore);
+    const weakMatch = !noMatch && (belowThreshold || suggestions.every((item) => item.confidence === "low"));
+    let recommendation;
+    let nextStep;
+    if (noMatch) {
+      recommendation = isStyleQuery ? `No matching components found. Your query seems styling-related \u2014 try ${ctx.toolNames.tokens} to find tokens.` : `No matching components found. Try different keywords or browse all components with ${ctx.toolNames.discover}.`;
+      nextStep = isStyleQuery ? `Use ${ctx.toolNames.tokens}(search: "${useCaseLower.split(/\s+/)[0]}") to find tokens.` : void 0;
+    } else if (weakMatch) {
+      recommendation = `Weak matches only \u2014 ${suggestions[0].component} might work but confidence is low.${isStyleQuery ? ` If you need tokens, try ${ctx.toolNames.tokens}.` : ""}`;
+      nextStep = `Use ${ctx.toolNames.inspect}("${suggestions[0].component}") to check if it fits, or try broader search terms.`;
+    } else {
+      recommendation = `Best match: ${suggestions[0].component} (${suggestions[0].confidence} confidence) - ${suggestions[0].description}`;
+      nextStep = `Use ${ctx.toolNames.inspect}("${suggestions[0].component}") for full details.`;
+    }
+    const tokenHint = isStyleQuery && !noMatch ? `Your query includes styling terms. For tokens, also try ${ctx.toolNames.tokens}(search: "${useCaseLower.split(/\s+/)[0]}").` : void 0;
+    const blockNames = blockMatches.map(
+      (match) => allBlocks.find((block) => block.name.toLowerCase() === match.name.toLowerCase())
+    ).filter(Boolean).slice(0, 3).map((block) => block.name);
+    const blockHint = blockNames.length > 0 ? `Related blocks: ${blockNames.join(", ")}. Use ${ctx.toolNames.blocks}(search: "${useCase}") for ready-to-use patterns.` : void 0;
+    let fullBlocks;
+    let fullTokens;
+    let fullImports;
+    if (depth === "full" && !noMatch) {
+      const tokenData = ctx.data.tokens;
+      const [blockSearchResults, tokenSearchResults] = await Promise.all([
+        hybridSearch(fullQuery, localData, 5, "block", ctx.config.searchApiKey),
+        tokenData ? hybridSearch(fullQuery, localData, 10, "token", ctx.config.searchApiKey) : Promise.resolve([])
+      ]);
+      const topBlockScore = blockSearchResults.length > 0 ? blockSearchResults[0].score : 0;
+      const relevantBlockResults = blockSearchResults.filter(
+        (result) => result.score >= topBlockScore * 0.3
+      );
+      if (relevantBlockResults.length > 0) {
+        fullBlocks = (await Promise.all(
+          relevantBlockResults.slice(0, 5).map(async (result) => {
+            const block = allBlocks.find(
+              (entry) => entry.name.toLowerCase() === result.name.toLowerCase()
+            );
+            if (!block) return null;
+            const imports = await buildImportStatements(
+              block.components,
+              async (componentName) => ctx.resolvePackageName(componentName)
+            );
+            const codeLines = block.code.split("\n");
+            const code = codeLines.length > 30 ? `${codeLines.slice(0, 20).join("\n")}
+// ... truncated (${codeLines.length} lines total)` : block.code;
+            return {
+              name: block.name,
+              description: block.description,
+              components: block.components,
+              code,
+              imports
+            };
+          })
+        )).filter(Boolean);
+      }
+      if (tokenSearchResults.length > 0 && tokenData) {
+        fullTokens = {};
+        const tokensByName = /* @__PURE__ */ new Map();
+        for (const [cat, tokens] of Object.entries(tokenData.categories)) {
+          for (const token of tokens) {
+            tokensByName.set(token.name, cat);
+          }
+        }
+        for (const result of tokenSearchResults) {
+          const cat = tokensByName.get(result.name);
+          if (cat) {
+            if (!fullTokens[cat]) fullTokens[cat] = [];
+            fullTokens[cat].push(result.name);
+          }
+        }
+        if (Object.keys(fullTokens).length === 0) fullTokens = void 0;
+      }
+      if (!fullTokens && tokenData) {
+        const categories = extractTokenCategories(fullQuery);
+        fullTokens = {};
+        for (const cat of categories) {
+          const tokens = tokenData.categories[cat];
+          if (tokens && tokens.length > 0) {
+            fullTokens[cat] = tokens.slice(0, 5).map((token) => token.name);
+          }
+        }
+        if (Object.keys(fullTokens).length === 0) fullTokens = void 0;
+      }
+      if (suggestions.length > 0) {
+        fullImports = {};
+        for (const item of suggestions) {
+          if (!item) continue;
+          const pkgName = ctx.resolvePackageName(item.component);
+          fullImports[item.component] = `import { ${item.component} } from '${pkgName}';`;
+        }
+      }
+    }
+    const suggestResponse = verbosity === "compact" ? {
+      useCase,
+      suggestions: suggestions.map((item) => ({
+        component: item.component,
+        description: item.description,
+        confidence: item.confidence
+      })),
+      recommendation
+    } : {
+      useCase,
+      context: context || void 0,
+      suggestions: depth === "full" ? suggestions.map((item) => ({
+        ...item,
+        import: fullImports?.[item.component]
+      })) : suggestions,
+      noMatch,
+      weakMatch,
+      recommendation,
+      compositionHint,
+      ...tokenHint && { tokenHint },
+      ...blockHint && { blockHint },
+      nextStep,
+      ...fullBlocks && fullBlocks.length > 0 && { blocks: fullBlocks },
+      ...fullTokens && { tokens: fullTokens }
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(suggestResponse)
+        }
+      ]
+    };
+  }
+  if (componentForAlts) {
+    const component = findComponent(data.snapshot, componentForAlts);
+    if (!component) {
+      const closest = findClosestMatch(
+        componentForAlts,
+        componentNames(data.snapshot)
+      );
+      const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Component "${componentForAlts}" not found.${suggestion} Use ${ctx.toolNames.discover} to see available components.`
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const relations = component.relations;
+    const referencedBy = allSnapshotComponents.map((entry) => {
+      const relation = entry.relations.find(
+        (candidate) => candidate.componentName.toLowerCase() === component.name.toLowerCase()
+      );
+      if (!relation) return null;
+      return {
+        component: entry.name,
+        relationship: relation.relationship,
+        note: relation.note
+      };
+    }).filter(Boolean);
+    const sameCategory = allSnapshotComponents.filter(
+      (entry) => entry.category === component.category && entry.name.toLowerCase() !== component.name.toLowerCase()
+    ).map((entry) => ({
+      component: entry.name,
+      description: entry.description
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            component: component.name,
+            category: component.category,
+            directRelations: relations,
+            referencedBy,
+            sameCategory,
+            suggestion: relations.find(
+              (relation) => relation.relationship === "alternative"
+            ) ? `Consider ${relations.find((relation) => relation.relationship === "alternative")?.componentName}: ${relations.find((relation) => relation.relationship === "alternative")?.note}` : void 0
+          })
+        }
+      ]
+    };
+  }
+  let filteredComponents = allSnapshotComponents.filter((component) => {
+    if (category && !categoryMatches(component.category, category)) return false;
+    if (status && (component.status ?? "stable") !== status) return false;
+    return true;
+  });
+  if (search2) {
+    const scored = keywordScoreComponents(
+      search2,
+      filteredComponents,
+      ctx.indexes.componentIndex ?? void 0
+    ).map((result) => {
+      const component = filteredComponents.find(
+        (entry) => entry.name.toLowerCase() === result.name.toLowerCase()
+      );
+      if (!component) return null;
+      return {
+        component,
+        score: result.score + getRankingBonus(component)
+      };
+    }).filter(Boolean);
+    filteredComponents = scored.sort((a, b) => b.score - a.score).map((entry) => entry.component);
+  } else {
+    filteredComponents = filteredComponents.sort((a, b) => {
+      const bonusDiff = getRankingBonus(b) - getRankingBonus(a);
+      if (bonusDiff !== 0) return bonusDiff;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  const limitedComponents = listLimit === void 0 ? filteredComponents : filteredComponents.slice(0, listLimit);
+  const components = limitedComponents.map((component) => {
+    if (verbosity === "compact") {
+      return {
+        name: component.name,
+        category: component.category,
+        publicRef: component.publicRef,
+        componentKey: component.id,
+        tier: component.tier,
+        isCanonical: component.isCanonical ?? false,
+        ...component.propsSummary.length > 0 && {
+          propsSummary: component.propsSummary
+        }
+      };
+    }
+    return {
+      name: component.name,
+      category: component.category,
+      description: component.description,
+      status: component.status ?? "stable",
+      publicRef: component.publicRef,
+      componentKey: component.id,
+      tier: component.tier,
+      isCanonical: component.isCanonical ?? false,
+      sourcePath: component.sourcePath,
+      exampleCount: component.examples.length,
+      tags: component.tags,
+      ...(includeCode || verbosity === "full") && component.examples[0]?.code ? {
+        example: component.examples[0].code
+      } : {}
+    };
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          total: filteredComponents.length,
+          returned: components.length,
+          components,
+          categories: [...new Set(components.map((component) => component.category))],
+          hint: components.length === 0 ? "No components found. Try broader search terms or check available categories." : components.length > 5 ? `Use ${ctx.toolNames.discover} with useCase for recommendations, or ${ctx.toolNames.inspect} for details on a specific component.` : void 0
+        })
+      }
+    ]
+  };
+};
+
+// src/tools/inspect.ts
+import { promises as fs } from "fs";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils.ts
+function projectFields(obj, fields) {
+  if (!fields || fields.length === 0) {
+    return obj;
+  }
+  const result = {};
+  for (const field of fields) {
+    const parts = field.split(".");
+    let source = obj;
+    let target = result;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isLast = i === parts.length - 1;
+      if (source === null || source === void 0 || typeof source !== "object") {
+        break;
+      }
+      const sourceObj = source;
+      const value = sourceObj[part];
+      if (isLast) {
+        target[part] = value;
+      } else {
+        if (!(part in target)) {
+          target[part] = {};
+        }
+        target = target[part];
+        source = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/tools/inspect.ts
+async function getSourceCode(component, projectRoot) {
+  const sourcePath = component.sourcePath;
+  if (!sourcePath) return void 0;
+  const fullPath = join2(projectRoot, sourcePath);
+  if (!existsSync2(fullPath)) return { path: sourcePath, code: null };
+  try {
+    const code = await fs.readFile(fullPath, "utf-8");
+    return { path: sourcePath, code };
+  } catch {
+    return { path: sourcePath, code: null };
+  }
+}
+var inspectHandler = async (args, ctx) => {
+  const componentName = args?.component;
+  const fields = args?.fields;
+  const exampleName = args?.variant ?? void 0;
+  const maxExamples = args?.maxExamples;
+  const maxLines = args?.maxLines;
+  const verbosity = args?.verbosity ?? "standard";
+  if (!componentName) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "component is required" })
+        }
+      ],
+      isError: true
+    };
+  }
+  const component = findComponent(ctx.data.snapshot, componentName);
+  if (!component) {
+    const closest = findClosestMatch(
+      componentName,
+      componentNames(ctx.data.snapshot)
+    );
+    const suggestion = closest ? ` Did you mean "${closest}"? Use ${ctx.toolNames.inspect}("${closest}") to inspect it.` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Component "${componentName}" not found.${suggestion} Use ${ctx.toolNames.discover} to see available components.`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+  const pkgName = ctx.resolvePackageName(component.name);
+  let examples = component.examples;
+  if (exampleName) {
+    const query = exampleName.toLowerCase();
+    let filtered = examples.filter((example) => example.name.toLowerCase() === query);
+    if (filtered.length === 0) {
+      filtered = examples.filter(
+        (example) => example.name.toLowerCase().startsWith(query)
+      );
+    }
+    if (filtered.length === 0) {
+      filtered = examples.filter(
+        (example) => example.name.toLowerCase().includes(query)
+      );
+    }
+    if (filtered.length > 0) {
+      examples = filtered;
+    } else {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Example "${exampleName}" not found for ${componentName}. Available: ${component.examples.map((example) => example.name).join(", ")}`
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  if (maxExamples && maxExamples > 0) {
+    examples = examples.slice(0, maxExamples);
+  }
+  const truncateCode = (code) => {
+    if (!maxLines || maxLines <= 0) {
+      return { code, truncated: false, remainingLines: 0 };
+    }
+    const lines = code.split("\n");
+    if (lines.length <= maxLines) {
+      return { code, truncated: false, remainingLines: 0 };
+    }
+    return {
+      code: lines.slice(0, maxLines).join("\n"),
+      truncated: true,
+      remainingLines: lines.length - maxLines
+    };
+  };
+  const renderedExamples = examples.map((example) => ({
+    ...example.code ? truncateCode(example.code) : { truncated: false, remainingLines: 0 },
+    variant: example.name,
+    description: example.description,
+    code: example.code ? truncateCode(example.code).code : `<${component.name} />`,
+    ...example.code ? {} : {
+      note: "No code example provided. Refer to props for customization."
+    }
+  }));
+  const propsReference = Object.entries(component.props ?? {}).map(
+    ([propName, prop]) => ({
+      name: propName,
+      type: prop.type,
+      required: prop.required,
+      default: prop.default,
+      description: prop.description,
+      values: prop.values
+    })
+  );
+  const propConstraints = Object.entries(component.props ?? {}).filter(
+    ([, prop]) => Boolean(prop.constraints && prop.constraints.length > 0)
+  ).map(([propName, prop]) => ({
+    prop: propName,
+    constraints: prop.constraints
+  }));
+  const fullResult = {
+    meta: {
+      id: component.id,
+      name: component.name,
+      description: component.description,
+      category: component.category,
+      status: component.status,
+      publicRef: component.publicRef,
+      publicSlug: component.publicSlug,
+      isCanonical: component.isCanonical ?? false,
+      tier: component.tier
+    },
+    props: propsReference,
+    examples: {
+      import: `import { ${component.name} } from '${pkgName}';`,
+      code: renderedExamples
+    },
+    relations: component.relations,
+    compoundChildren: component.compoundChildren,
+    guidance: {
+      when: getGuidanceWhen(component),
+      whenNot: getGuidanceWhenNot(component),
+      guidelines: component.guidance.guidelines,
+      accessibility: component.guidance.accessibility,
+      usageGuidance: component.guidance.usageGuidance,
+      dos: component.guidance.dos,
+      donts: component.guidance.donts,
+      patterns: component.guidance.patterns,
+      propConstraints,
+      alternatives: component.relations?.filter((relation) => relation.relationship === "alternative").map((relation) => ({
+        component: relation.componentName,
+        note: relation.note
+      })) ?? []
+    },
+    metadata: component.metadata,
+    source: await getSourceCode(component, ctx.config.projectRoot)
+  };
+  const aliasMap = { usage: "guidance" };
+  const resolvedFields = fields?.map((field) => {
+    const parts = field.split(".");
+    if (aliasMap[parts[0]]) parts[0] = aliasMap[parts[0]];
+    return parts.join(".");
+  });
+  let result;
+  if (verbosity === "compact" && !resolvedFields?.length) {
+    result = {
+      meta: fullResult.meta,
+      propsSummary: component.propsSummary,
+      metadata: component.metadata
+    };
+  } else if (verbosity === "full") {
+    result = resolvedFields && resolvedFields.length > 0 ? projectFields(fullResult, resolvedFields) : fullResult;
+  } else if (resolvedFields && resolvedFields.length > 0) {
+    result = projectFields(fullResult, resolvedFields);
+  } else {
+    const { source: _source, ...withoutSource } = fullResult;
+    result = withoutSource;
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }]
+  };
+};
+
+// src/tools/blocks.ts
+var blocksHandler = async (args, ctx) => {
+  const blockName = args?.name;
+  const search2 = args?.search?.toLowerCase() ?? void 0;
+  const component = args?.component?.toLowerCase() ?? void 0;
+  const category = args?.category?.toLowerCase() ?? void 0;
+  const blocksLimit = typeof args?.limit === "number" ? Math.min(Math.max(args.limit, 1), 50) : void 0;
+  const allBlocks = listBlocks(ctx.data.snapshot);
+  if (allBlocks.length === 0) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          total: 0,
+          blocks: [],
+          hint: `No composition blocks found. Blocks are reusable patterns showing how components wire together (e.g., "Login Form", "Settings Page"). Create .block.ts files and run \`${BRAND.cliCommand} build\`.`
+        })
+      }]
+    };
+  }
+  let filtered = allBlocks;
+  if (blockName) {
+    filtered = filtered.filter(
+      (b) => b.name.toLowerCase() === blockName.toLowerCase()
+    );
+    if (filtered.length === 0) {
+      const allBlockNames = allBlocks.map((b) => b.name);
+      const closest = findClosestMatch(blockName, allBlockNames);
+      const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+      throw new Error(`Block "${blockName}" not found.${suggestion} Use ${ctx.toolNames.blocks} to see available blocks.`);
+    }
+  }
+  if (search2) {
+    if (ctx.indexes.blockIndex) {
+      const ranked = searchBlocks(search2, ctx.indexes.blockIndex, 50);
+      const rankedNames = new Set(ranked.map((r) => r.name.toLowerCase()));
+      filtered = filtered.filter((b) => rankedNames.has(b.name.toLowerCase()));
+      filtered.sort((a, b) => {
+        const aIdx = ranked.findIndex((r) => r.name.toLowerCase() === a.name.toLowerCase());
+        const bIdx = ranked.findIndex((r) => r.name.toLowerCase() === b.name.toLowerCase());
+        return (aIdx === -1 ? Infinity : aIdx) - (bIdx === -1 ? Infinity : bIdx);
+      });
+    } else {
+      filtered = filtered.filter((b) => {
+        const haystack = [
+          b.name,
+          b.description,
+          ...b.tags ?? [],
+          ...b.components,
+          b.category
+        ].join(" ").toLowerCase();
+        return haystack.includes(search2);
+      });
+    }
+  }
+  if (component) {
+    filtered = filtered.filter(
+      (b) => b.components.some((c) => c.toLowerCase() === component)
+    );
+  }
+  if (category) {
+    filtered = filtered.filter(
+      (b) => b.category.toLowerCase() === category
+    );
+  }
+  const blocksUseIcons = filtered.some(
+    (b) => b.components.some((c) => c === "Icon") || b.code && /\bIcon\b/.test(b.code)
+  );
+  const iconHint = blocksUseIcons ? "Icon components in block code are from @phosphor-icons/react. Import them as: import { IconName } from '@phosphor-icons/react';" : void 0;
+  if (blocksLimit !== void 0) {
+    filtered = filtered.slice(0, blocksLimit);
+  }
+  const verbosity = args?.verbosity ?? "standard";
+  const blocksWithImports = await Promise.all(filtered.map(async (b) => {
+    const imports = await buildImportStatements(
+      b.components,
+      async (componentName) => ctx.resolvePackageName(componentName)
+    );
+    const base = {
+      name: b.name,
+      description: b.description,
+      category: b.category,
+      components: b.components,
+      tags: b.tags,
+      import: imports.join("\n"),
+      imports
+    };
+    if (verbosity === "compact") return base;
+    if (verbosity === "full") return { ...base, code: b.code };
+    const codeLines = b.code.split("\n");
+    const code = codeLines.length > 30 ? codeLines.slice(0, 20).join("\n") + "\n// ... truncated (" + codeLines.length + " lines total)" : b.code;
+    return { ...base, code };
+  }));
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        total: blocksWithImports.length,
+        blocks: blocksWithImports,
+        ...iconHint && { iconHint },
+        ...blocksWithImports.length === 0 && allBlocks.length > 0 && {
+          hint: "No blocks matching your query. Try broader search terms."
+        }
+      })
+    }]
+  };
+};
+
+// src/tools/tokens.ts
+var TOKEN_CATEGORY_ALIASES = {
+  colors: ["color", "colors", "accent", "background", "foreground", "theme"],
+  spacing: ["spacing", "space", "spaces", "padding", "margin", "gap", "inset"],
+  typography: ["typography", "type", "font", "fonts", "letter", "line-height"],
+  surfaces: ["surface", "surfaces", "canvas"],
+  shadows: ["shadow", "shadows", "elevation"],
+  radius: ["radius", "radii", "corner", "corners", "rounded", "rounding"],
+  borders: ["border", "borders", "stroke", "outline"],
+  text: ["text", "copy", "content"],
+  focus: ["focus", "ring", "focus-ring"],
+  layout: ["layout", "container", "grid", "breakpoint"],
+  code: ["code"],
+  "component-sizing": ["component-sizing", "sizing", "size", "sizes"]
+};
+function normalizeCategoryValue(value) {
+  const normalized = value?.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function resolveCategoryKeys(categories, requestedCategory) {
+  const normalized = normalizeCategoryValue(requestedCategory);
+  if (!normalized) {
+    return Object.keys(categories);
+  }
+  const keys = Object.keys(categories);
+  const exactMatches = keys.filter((key) => normalizeCategoryValue(key) === normalized);
+  if (exactMatches.length > 0) {
+    return exactMatches;
+  }
+  const canonical = Object.entries(TOKEN_CATEGORY_ALIASES).find(
+    ([categoryName, aliases]) => categoryName === normalized || aliases.includes(normalized)
+  );
+  if (canonical) {
+    const aliases = [canonical[0], ...canonical[1]];
+    const aliasMatches = keys.filter((key) => {
+      const normalizedKey = normalizeCategoryValue(key) ?? "";
+      return aliases.some((alias) => normalizedKey.includes(alias));
+    });
+    if (aliasMatches.length > 0) {
+      return aliasMatches;
+    }
+  }
+  return keys.filter((key) => (normalizeCategoryValue(key) ?? "").includes(normalized));
+}
+function canonicalizeCategory(category, tokens) {
+  const normalizedCategory = normalizeCategoryValue(category);
+  const candidates = [
+    normalizedCategory,
+    ...tokens.flatMap((token) => [
+      normalizeCategoryValue(token.category),
+      normalizeCategoryValue(token.path?.[0]),
+      normalizeCategoryValue(token.name.split(/[.:/-]/)[0])
+    ])
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    for (const [canonical, aliases] of Object.entries(TOKEN_CATEGORY_ALIASES)) {
+      if (candidate === canonical || aliases.some(
+        (alias) => candidate === alias || candidate.includes(alias) || alias.includes(candidate)
+      )) {
+        return canonical;
+      }
+    }
+  }
+  return normalizedCategory || "other";
+}
+function normalizeTokenCategories(categories) {
+  const normalized = {};
+  for (const [category, tokens] of Object.entries(categories)) {
+    const canonical = canonicalizeCategory(category, tokens);
+    if (!normalized[canonical]) normalized[canonical] = [];
+    normalized[canonical].push(
+      ...tokens.map((token) => ({
+        ...token,
+        category: canonical
+      }))
+    );
+  }
+  for (const tokens of Object.values(normalized)) {
+    tokens.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  return normalized;
+}
+var tokensHandler = async (args, ctx) => {
+  const category = args?.category;
+  const search2 = args?.search?.toLowerCase() ?? void 0;
+  const tokensLimit = typeof args?.limit === "number" ? Math.min(Math.max(args.limit, 1), 100) : search2 ? 25 : void 0;
+  const tokenData = ctx.data.tokens;
+  if (!tokenData || tokenData.total === 0) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          total: 0,
+          categories: {},
+          hint: `No design tokens found. Add a tokens.include pattern to your ${BRAND.configFile} and run \`${BRAND.cliCommand} build\`.`
+        })
+      }]
+    };
+  }
+  const normalizedCategories = normalizeTokenCategories(tokenData.categories);
+  let filteredCategories = {};
+  let filteredTotal = 0;
+  const resolvedCategoryKeys = resolveCategoryKeys(normalizedCategories, category);
+  const friendlyCategories = Object.keys(TOKEN_CATEGORY_ALIASES);
+  const searchMatchesCategory = search2 ? resolveCategoryKeys(normalizedCategories, search2) : [];
+  for (const [cat, tokens] of Object.entries(normalizedCategories)) {
+    if (category && !resolvedCategoryKeys.includes(cat)) continue;
+    let filtered = tokens;
+    if (search2) {
+      if (searchMatchesCategory.includes(cat)) {
+        filtered = tokens;
+      } else {
+        filtered = tokens.filter(
+          (t) => t.name.toLowerCase().includes(search2) || t.description && t.description.toLowerCase().includes(search2) || (normalizeCategoryValue(cat) ?? "").includes(search2) || t.value && t.value.toLowerCase().includes(search2) || t.path && t.path.join(" ").toLowerCase().includes(search2)
+        );
+      }
+    }
+    if (filtered.length > 0) {
+      filteredCategories[cat] = filtered;
+      filteredTotal += filtered.length;
+    }
+  }
+  if (tokensLimit !== void 0) {
+    const limited = limitTokensPerCategory(filteredCategories, tokensLimit);
+    filteredCategories = limited.categories;
+    filteredTotal = limited.total;
+  }
+  let hint;
+  if (filteredTotal === 0) {
+    if (category && search2) {
+      const categoryTotal = resolvedCategoryKeys.reduce(
+        (sum, key) => sum + (normalizedCategories[key]?.length ?? 0),
+        0
+      );
+      hint = categoryTotal > 0 ? `No tokens matching "${search2}" in category "${category}" (${categoryTotal} tokens in this category). Try a broader search or remove the search term.` : `Category "${category}" not found. Try categories like: ${friendlyCategories.join(", ")}.`;
+    } else if (search2) {
+      hint = `No tokens matching "${search2}". Try categories like: ${friendlyCategories.join(", ")}.`;
+    } else if (category) {
+      hint = `Category "${category}" not found. Try categories like: ${friendlyCategories.join(", ")}.`;
+    }
+  } else if (!category && !search2) {
+    hint = `Use var(--token-name) in your CSS/styles. Filter by category or search to narrow results.`;
+  }
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        prefix: tokenData.prefix,
+        total: filteredTotal,
+        totalAvailable: tokenData.total,
+        categories: filteredCategories,
+        ...hint && { hint },
+        ...!category && !search2 && {
+          availableCategories: Object.entries(normalizedCategories).map(([cat, tokens]) => ({
+            category: cat,
+            count: tokens.length
+          }))
+        }
+      })
+    }]
+  };
+};
+
+// src/service.ts
+var DEFAULT_ENDPOINTS = {
+  render: "/fragments/render",
+  compare: "/fragments/compare",
+  fix: "/fragments/fix",
+  a11y: "/fragments/a11y"
+};
+async function renderComponent(viewerUrl, request, endpoints) {
+  const renderUrl = `${viewerUrl}${endpoints?.render ?? DEFAULT_ENDPOINTS.render}`;
+  const response = await fetch(renderUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      component: request.component,
+      props: request.props ?? {},
+      variant: request.variant,
+      viewport: request.viewport ?? { width: 800, height: 600 }
+    })
+  });
+  return await response.json();
+}
+async function compareComponent(viewerUrl, request, endpoints) {
+  const compareUrl = `${viewerUrl}${endpoints?.compare ?? DEFAULT_ENDPOINTS.compare}`;
+  const response = await fetch(compareUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+  return await response.json();
+}
+async function fixComponent(viewerUrl, request, endpoints) {
+  const fixUrl = `${viewerUrl}${endpoints?.fix ?? DEFAULT_ENDPOINTS.fix}`;
+  const response = await fetch(fixUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+  return await response.json();
+}
+async function auditComponent(viewerUrl, request, endpoints) {
+  const a11yUrl = `${viewerUrl}${endpoints?.a11y ?? DEFAULT_ENDPOINTS.a11y}`;
+  const response = await fetch(a11yUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      component: request.component,
+      variant: request.variant,
+      standard: request.standard,
+      includeFixPatches: request.includeFixPatches
+    })
+  });
+  const raw = await response.json();
+  if (raw.error) {
+    return {
+      component: request.component,
+      results: [],
+      score: 0,
+      aaPercent: 0,
+      aaaPercent: 0,
+      passed: false,
+      standard: request.standard ?? "AA",
+      error: raw.error
+    };
+  }
+  const results = raw.results ?? [];
+  const standard = request.standard ?? "AA";
+  let totalCritical = 0;
+  let totalSerious = 0;
+  let totalModerate = 0;
+  let totalMinor = 0;
+  for (const r of results) {
+    totalCritical += r.summary.critical;
+    totalSerious += r.summary.serious;
+    totalModerate += r.summary.moderate;
+    totalMinor += r.summary.minor;
+  }
+  const deductions = totalCritical * 10 + totalSerious * 5 + totalModerate * 2 + totalMinor * 1;
+  const score = Math.max(0, 100 - deductions);
+  const variantCount = results.length;
+  const aaPassCount = results.filter((r) => {
+    const critical = r.summary.critical;
+    const serious = r.summary.serious;
+    return critical === 0 && serious === 0;
+  }).length;
+  const aaaPassCount = results.filter((r) => {
+    const total = r.summary.critical + r.summary.serious + r.summary.moderate + r.summary.minor;
+    return total === 0;
+  }).length;
+  const totalPasses = results.reduce((sum, r) => sum + r.passes, 0);
+  const totalViolations = totalCritical + totalSerious + totalModerate + totalMinor;
+  const emptyAudit = results.length > 0 && totalPasses === 0 && totalViolations === 0;
+  const aaPercent = variantCount > 0 ? Math.round(aaPassCount / variantCount * 100) : 100;
+  const aaaPercent = variantCount > 0 ? Math.round(aaaPassCount / variantCount * 100) : 100;
+  const aaPass = !emptyAudit && totalCritical === 0 && totalSerious === 0;
+  const aaaPass = !emptyAudit && totalViolations === 0;
+  const passed = standard === "AAA" ? aaaPass : aaPass;
+  return {
+    component: request.component,
+    results,
+    score: emptyAudit ? 0 : score,
+    aaPercent: emptyAudit ? 0 : aaPercent,
+    aaaPercent: emptyAudit ? 0 : aaaPercent,
+    ...emptyAudit && { emptyAudit },
+    passed,
+    standard
+  };
+}
+
+// src/tools/render.ts
+var NO_VIEWER_MSG = "This tool requires a running dev server. Add --viewer-url http://localhost:PORT to this server's config args. Start the viewer with 'fragments dev' in your component library directory.";
+var renderHandler = async (args, ctx) => {
+  const componentName = args?.component;
+  const variantName = args?.variant;
+  const props = args?.props ?? {};
+  const viewport = args?.viewport;
+  const figmaUrl = args?.figmaUrl;
+  const threshold = args?.threshold ?? (figmaUrl ? 1 : ctx.config.threshold ?? DEFAULTS.diffThreshold);
+  if (!componentName) {
+    return {
+      content: [{ type: "text", text: "Error: component name is required" }],
+      isError: true
+    };
+  }
+  {
+    const component = findComponentByName(ctx.data.snapshot, componentName);
+    if (!component) {
+      const allNames = componentNames(ctx.data.snapshot);
+      const closest = findClosestMatch(componentName, allNames);
+      const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+      throw new Error(`Component "${componentName}" not found.${suggestion} Use ${ctx.toolNames.discover} to see available components.`);
+    }
+  }
+  const viewerUrl = ctx.config.viewerUrl;
+  if (!viewerUrl) {
+    return {
+      content: [{
+        type: "text",
+        text: NO_VIEWER_MSG
+      }],
+      isError: true
+    };
+  }
+  if (figmaUrl) {
+    try {
+      const result = await compareComponent(viewerUrl, {
+        component: componentName,
+        variant: variantName,
+        props,
+        figmaUrl,
+        threshold
+      }, ctx.config.fileConfig?.endpoints);
+      if (result.error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Compare error: ${result.error}${result.suggestion ? `
+Suggestion: ${result.suggestion}` : ""}`
+          }],
+          isError: true
+        };
+      }
+      const content = [];
+      const summaryText = result.match ? `MATCH: ${componentName} matches Figma design (${result.diffPercentage}% diff, threshold: ${result.threshold}%)` : `MISMATCH: ${componentName} differs from Figma design by ${result.diffPercentage}% (threshold: ${result.threshold}%)`;
+      content.push({ type: "text", text: summaryText });
+      if (result.diff && !result.match) {
+        content.push({
+          type: "image",
+          data: result.diff.replace("data:image/png;base64,", ""),
+          mimeType: "image/png"
+        });
+        content.push({
+          type: "text",
+          text: `Diff image above shows visual differences (red highlights). Changed regions: ${result.changedRegions?.length ?? 0}`
+        });
+      }
+      content.push({
+        type: "text",
+        text: JSON.stringify({
+          match: result.match,
+          diffPercentage: result.diffPercentage,
+          threshold: result.threshold,
+          figmaUrl: result.figmaUrl,
+          changedRegions: result.changedRegions
+        })
+      });
+      return { content };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to compare component: ${error instanceof Error ? error.message : "Unknown error"}. Make sure the Fragments dev server is running and FIGMA_ACCESS_TOKEN is set.`
+        }],
+        isError: true
+      };
+    }
+  }
+  try {
+    const result = await renderComponent(viewerUrl, {
+      component: componentName,
+      props,
+      variant: variantName,
+      viewport: viewport ?? { width: 800, height: 600 }
+    }, ctx.config.fileConfig?.endpoints);
+    if (result.error) {
+      return {
+        content: [{ type: "text", text: `Render error: ${result.error}` }],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "image",
+          data: result.screenshot.replace("data:image/png;base64,", ""),
+          mimeType: "image/png"
+        },
+        {
+          type: "text",
+          text: `Successfully rendered ${componentName}${variantName ? ` (variant: "${variantName}")` : ""}${Object.keys(props).length > 0 ? ` with props: ${JSON.stringify(props)}` : ""}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Failed to render component: ${error instanceof Error ? error.message : "Unknown error"}. Make sure the Fragments dev server is running.`
+      }],
+      isError: true
+    };
+  }
+};
+
+// src/tools/fix.ts
+var NO_VIEWER_MSG2 = "This tool requires a running dev server. Add --viewer-url http://localhost:PORT to this server's config args. Start the viewer with 'fragments dev' in your component library directory.";
+var fixHandler = async (args, ctx) => {
+  const componentName = args?.component;
+  const variantName = args?.variant ?? void 0;
+  const fixType = args?.fixType ?? "all";
+  if (!componentName) {
+    throw new Error("component is required");
+  }
+  const fragment = findComponentByName(ctx.data.snapshot, componentName);
+  if (!fragment) {
+    const allNames = componentNames(ctx.data.snapshot);
+    const closest = findClosestMatch(componentName, allNames);
+    const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+    throw new Error(`Component "${componentName}" not found.${suggestion} Use ${ctx.toolNames.discover} to see available components.`);
+  }
+  const viewerUrl = ctx.config.viewerUrl;
+  if (!viewerUrl) {
+    return {
+      content: [{
+        type: "text",
+        text: NO_VIEWER_MSG2
+      }],
+      isError: true
+    };
+  }
+  try {
+    const result = await fixComponent(viewerUrl, {
+      component: componentName,
+      variant: variantName,
+      fixType
+    }, ctx.config.fileConfig?.endpoints);
+    if (result.error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Fix generation error: ${result.error}`
+        }],
+        isError: true
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          component: componentName,
+          variant: variantName ?? "all",
+          fixType,
+          patches: result.patches,
+          summary: result.summary,
+          patchCount: result.patches.length,
+          nextStep: result.patches.length > 0 ? `Apply patches using your editor or \`patch\` command, then run ${ctx.toolNames.render} to confirm fixes.` : void 0
+        })
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Failed to generate fixes: ${error instanceof Error ? error.message : "Unknown error"}. Make sure the Fragments dev server is running.`
+      }],
+      isError: true
+    };
+  }
+};
+
+// src/tools/a11y.ts
+var NO_VIEWER_MSG3 = "This tool requires a running dev server. Add --viewer-url http://localhost:PORT to this server's config args. Start the viewer with 'fragments dev' in your component library directory.";
+var a11yHandler = async (args, ctx) => {
+  const componentName = args?.component;
+  const variantName = args?.variant ?? void 0;
+  const standard = args?.standard ?? "AA";
+  const includeFixPatches = args?.includeFixPatches ?? false;
+  if (!componentName) {
+    throw new Error("component is required");
+  }
+  {
+    const fragment = findComponentByName(ctx.data.snapshot, componentName);
+    if (!fragment) {
+      const allNames = componentNames(ctx.data.snapshot);
+      const closest = findClosestMatch(componentName, allNames);
+      const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+      throw new Error(`Component "${componentName}" not found.${suggestion} Use ${ctx.toolNames.discover} to see available components.`);
+    }
+  }
+  const viewerUrl = ctx.config.viewerUrl;
+  if (!viewerUrl) {
+    return {
+      content: [{
+        type: "text",
+        text: NO_VIEWER_MSG3
+      }],
+      isError: true
+    };
+  }
+  try {
+    const result = await auditComponent(viewerUrl, {
+      component: componentName,
+      variant: variantName,
+      standard,
+      includeFixPatches
+    }, ctx.config.fileConfig?.endpoints);
+    if (result.error) {
+      return {
+        content: [{
+          type: "text",
+          text: `A11y audit error: ${result.error}`
+        }],
+        isError: true
+      };
+    }
+    let nextStep;
+    if (result.emptyAudit) {
+      nextStep = `No testable elements found for ${variantName ? `variant "${variantName}"` : componentName}. The variant may not exist or renders no accessible content. Check available variants with ${ctx.toolNames.inspect}("${componentName}").`;
+    } else if (result.passed) {
+      nextStep = 'All accessibility checks passed. Consider running with standard: "AAA" for enhanced compliance.';
+    } else {
+      nextStep = `Fix the violations above, then re-run ${ctx.toolNames.a11y} to verify. Use ${ctx.toolNames.fix} for automated fixes.`;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          component: componentName,
+          variant: variantName ?? "all",
+          standard,
+          totalViolations: result.results.reduce((sum, r) => sum + r.summary.total, 0),
+          variantsPassingAA: `${result.aaPercent}%`,
+          variantsPassingAAA: `${result.aaaPercent}%`,
+          passed: result.passed,
+          ...result.emptyAudit && { emptyAudit: true },
+          results: result.results,
+          nextStep
+        })
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Failed to audit component: ${error instanceof Error ? error.message : "Unknown error"}. Make sure the Fragments dev server is running.`
+      }],
+      isError: true
+    };
+  }
+};
+
+// src/graph-handler.ts
+import {
+  ComponentGraphEngine,
+  deserializeGraph
+} from "@fragments-sdk/context/graph";
+function handleGraphTool(args, serializedGraph, blocks, componentNames2) {
+  if (!serializedGraph) {
+    return {
+      text: JSON.stringify({
+        error: "No graph data available. Run `fragments build` to generate the component graph.",
+        hint: "The graph is built automatically during `fragments build` and embedded in fragments.json."
+      }),
+      isError: true
+    };
+  }
+  const graph = deserializeGraph(serializedGraph);
+  const blockData = blocks ? Object.fromEntries(
+    Object.entries(blocks).map(([k, v]) => [k, { components: v.components }])
+  ) : void 0;
+  const engine = new ComponentGraphEngine(graph, blockData);
+  const edgeTypes = args.edgeTypes;
+  switch (args.mode) {
+    case "health": {
+      const health = engine.getHealth();
+      const blockCount = blocks ? Object.keys(blocks).length : 0;
+      return {
+        text: JSON.stringify({
+          mode: "health",
+          ...health,
+          ...health.compositionCoverage === 0 && blockCount === 0 && {
+            compositionNote: "No composition blocks defined yet \u2014 compositionCoverage will increase as blocks are added"
+          },
+          summary: `${health.nodeCount} components, ${health.edgeCount} edges, ${health.connectedComponents.length} island(s), ${health.orphans.length} orphan(s), ${health.compositionCoverage}% in blocks`
+        })
+      };
+    }
+    case "dependencies": {
+      if (!args.component) {
+        return { text: JSON.stringify({ error: "component is required for dependencies mode" }), isError: true };
+      }
+      if (!engine.hasNode(args.component)) {
+        const closest = componentNames2 ? findClosestMatch(args.component, componentNames2) : null;
+        const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+        return { text: JSON.stringify({ error: `Component "${args.component}" not found in graph.${suggestion}` }), isError: true };
+      }
+      const deps = engine.dependencies(args.component, edgeTypes);
+      return {
+        text: JSON.stringify({
+          mode: "dependencies",
+          component: args.component,
+          count: deps.length,
+          dependencies: deps.map((e) => ({
+            component: e.target,
+            type: e.type,
+            weight: e.weight,
+            note: e.note,
+            provenance: e.provenance
+          }))
+        })
+      };
+    }
+    case "dependents": {
+      if (!args.component) {
+        return { text: JSON.stringify({ error: "component is required for dependents mode" }), isError: true };
+      }
+      if (!engine.hasNode(args.component)) {
+        const closest = componentNames2 ? findClosestMatch(args.component, componentNames2) : null;
+        const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+        return { text: JSON.stringify({ error: `Component "${args.component}" not found in graph.${suggestion}` }), isError: true };
+      }
+      const deps = engine.dependents(args.component, edgeTypes);
+      return {
+        text: JSON.stringify({
+          mode: "dependents",
+          component: args.component,
+          count: deps.length,
+          dependents: deps.map((e) => ({
+            component: e.source,
+            type: e.type,
+            weight: e.weight,
+            note: e.note,
+            provenance: e.provenance
+          }))
+        })
+      };
+    }
+    case "impact": {
+      if (!args.component) {
+        return { text: JSON.stringify({ error: "component is required for impact mode" }), isError: true };
+      }
+      if (!engine.hasNode(args.component)) {
+        const closest = componentNames2 ? findClosestMatch(args.component, componentNames2) : null;
+        const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+        return { text: JSON.stringify({ error: `Component "${args.component}" not found in graph.${suggestion}` }), isError: true };
+      }
+      const result = engine.impact(args.component, args.maxDepth ?? 3);
+      return {
+        text: JSON.stringify({
+          mode: "impact",
+          ...result,
+          summary: `Changing ${args.component} affects ${result.totalAffected} component(s) and ${result.affectedBlocks.length} block(s)`
+        })
+      };
+    }
+    case "path": {
+      if (!args.component || !args.target) {
+        return { text: JSON.stringify({ error: "component and target are required for path mode" }), isError: true };
+      }
+      const result = engine.path(args.component, args.target);
+      return {
+        text: JSON.stringify({
+          mode: "path",
+          from: args.component,
+          to: args.target,
+          ...result,
+          edges: result.edges.map((e) => ({
+            source: e.source,
+            target: e.target,
+            type: e.type
+          }))
+        })
+      };
+    }
+    case "composition": {
+      if (!args.component) {
+        return { text: JSON.stringify({ error: "component is required for composition mode" }), isError: true };
+      }
+      if (!engine.hasNode(args.component)) {
+        const closest = componentNames2 ? findClosestMatch(args.component, componentNames2) : null;
+        const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+        return { text: JSON.stringify({ error: `Component "${args.component}" not found in graph.${suggestion}` }), isError: true };
+      }
+      const tree = engine.composition(args.component);
+      return {
+        text: JSON.stringify({
+          mode: "composition",
+          ...tree
+        })
+      };
+    }
+    case "alternatives": {
+      if (!args.component) {
+        return { text: JSON.stringify({ error: "component is required for alternatives mode" }), isError: true };
+      }
+      if (!engine.hasNode(args.component)) {
+        const closest = componentNames2 ? findClosestMatch(args.component, componentNames2) : null;
+        const suggestion = closest ? ` Did you mean "${closest}"?` : "";
+        return { text: JSON.stringify({ error: `Component "${args.component}" not found in graph.${suggestion}` }), isError: true };
+      }
+      const alts = engine.alternatives(args.component);
+      return {
+        text: JSON.stringify({
+          mode: "alternatives",
+          component: args.component,
+          count: alts.length,
+          alternatives: alts
+        })
+      };
+    }
+    case "islands": {
+      const islands = engine.islands();
+      return {
+        text: JSON.stringify({
+          mode: "islands",
+          count: islands.length,
+          islands: islands.map((island, i) => ({
+            id: i + 1,
+            size: island.length,
+            components: island
+          }))
+        })
+      };
+    }
+    default:
+      return {
+        text: JSON.stringify({
+          error: `Unknown mode: "${args.mode}". Valid modes: dependencies, dependents, impact, path, composition, alternatives, islands, health`
+        }),
+        isError: true
+      };
+  }
+}
+
+// src/tools/graph.ts
+var graphHandler = async (args, ctx) => {
+  const graphArgs = {
+    mode: args?.mode ?? "health",
+    component: args?.component,
+    target: args?.target,
+    edgeTypes: args?.edgeTypes,
+    maxDepth: args?.maxDepth
+  };
+  const data = ctx.data;
+  const allNames = componentNames(data.snapshot);
+  const result = handleGraphTool(
+    graphArgs,
+    data.graph,
+    data.blocks,
+    allNames
+  );
+  if (result.isError) {
+    return {
+      content: [{ type: "text", text: result.text }],
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: result.text }]
+  };
+};
+
+// src/tools/perf.ts
+var perfHandler = async (args, ctx) => {
+  const componentName = args?.component ?? void 0;
+  const sort = args?.sort ?? "size";
+  const filter = args?.filter ?? void 0;
+  let entries = Object.values(ctx.data.components).filter((component) => component.performance).map((component) => ({
+    name: component.name,
+    ...component.performance
+  }));
+  if (entries.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            total: 0,
+            components: [],
+            hint: `No performance data found. Run \`${BRAND.cliCommand} perf\` first to measure bundle sizes.`
+          })
+        }
+      ]
+    };
+  }
+  if (componentName) {
+    entries = entries.filter(
+      (entry) => entry.name.toLowerCase() === componentName.toLowerCase()
+    );
+    if (entries.length === 0) {
+      throw new Error(
+        `No performance data for "${componentName}". Run \`${BRAND.cliCommand} perf --component ${componentName}\` first.`
+      );
+    }
+  }
+  if (filter) {
+    if (filter === "over-budget") {
+      entries = entries.filter((entry) => entry.overBudget);
+    } else {
+      entries = entries.filter((entry) => entry.complexity === filter);
+    }
+  }
+  switch (sort) {
+    case "name":
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      break;
+    case "budget":
+      entries.sort((a, b) => b.budgetPercent - a.budgetPercent);
+      break;
+    case "size":
+    default:
+      entries.sort((a, b) => b.bundleSize - a.bundleSize);
+      break;
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          total: entries.length,
+          summary: ctx.data.performanceSummary ?? void 0,
+          components: entries
+        })
+      }
+    ]
+  };
+};
+
+// src/tools/govern.ts
+import {
+  handleGovernTool,
+  formatVerdict,
+  universal,
+  fragments as fragmentsPreset
+} from "@fragments-sdk/govern";
+var governHandler = async (args, ctx) => {
+  const spec = args?.spec;
+  if (!spec || typeof spec !== "object") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "spec is required and must be an object with { nodes: [{ id, type, props, children }] }"
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+  const policyOverrides = args?.policy;
+  const format = args?.format ?? "json";
+  const allowedComponents = Object.values(ctx.data.components).map(
+    (component) => component.name
+  );
+  const tokenPrefix = ctx.data.tokens?.prefix;
+  const basePolicy = tokenPrefix === "fui-" ? { rules: fragmentsPreset().rules } : { rules: universal().rules };
+  basePolicy.rules["components/allow"] = {
+    enabled: true,
+    severity: "serious",
+    options: {
+      components: allowedComponents
+    }
+  };
+  const engineOptions = ctx.data.tokens ? { tokenData: ctx.data.tokens } : void 0;
+  const input = {
+    spec,
+    policy: policyOverrides,
+    format
+  };
+  try {
+    const verdict = await handleGovernTool(input, basePolicy, engineOptions);
+    const text = format === "summary" ? formatVerdict(verdict, "summary") : JSON.stringify(verdict);
+    return {
+      content: [{ type: "text", text }],
+      _meta: {
+        score: verdict.score,
+        passed: verdict.passed,
+        violationCount: verdict.results.reduce(
+          (sum, r) => sum + r.violations.length,
+          0
+        )
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const isSpecError = message.includes("Expected") || message.includes("Required");
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: isSpecError ? `Invalid spec format: ${message}. Expected: { nodes: [{ id: string, type: string, props: object, children?: string[] }] }` : message
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+};
+
+// src/tools/generate-ui.ts
+var generateUiHandler = async (args, ctx) => {
+  const prompt = args?.prompt;
+  if (!prompt) {
+    throw new Error("prompt is required");
+  }
+  const currentTree = args?.currentTree;
+  const playgroundUrl = ctx.config.playgroundUrl ?? "https://usefragments.com";
+  const response = await fetch(`${playgroundUrl}/api/playground/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      prompt,
+      ...currentTree && { currentSpec: currentTree }
+    })
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Playground API error (${response.status}): ${errorBody}`);
+  }
+  const text = await response.text();
+  return {
+    content: [{
+      type: "text",
+      text
+    }]
+  };
+};
+
+// src/tools/index.ts
+var CORE_TOOLS = {
+  discover: discoverHandler,
+  inspect: inspectHandler,
+  blocks: blocksHandler,
+  tokens: tokensHandler,
+  graph: graphHandler,
+  perf: perfHandler,
+  govern: governHandler
+};
+var VIEWER_TOOLS = {
+  render: renderHandler,
+  fix: fixHandler,
+  a11y: a11yHandler
+};
+var INFRA_TOOLS = {
+  generate_ui: generateUiHandler
+};
+var BUILTIN_TOOLS = {
+  ...CORE_TOOLS,
+  ...VIEWER_TOOLS,
+  ...INFRA_TOOLS
+};
+var TOOL_CAPABILITIES = {
+  discover: ["components"],
+  inspect: ["components"],
+  blocks: ["blocks"],
+  tokens: ["tokens"],
+  graph: ["graph"],
+  perf: ["performance"],
+  render: ["components"],
+  fix: ["components"],
+  a11y: ["components"]
+};
+
+// src/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  prefix;
+  onChanged;
+  constructor(prefix, opts) {
+    this.prefix = prefix;
+    this.onChanged = opts?.onChanged;
+  }
+  /** Register a single tool */
+  register(key, handler, definition, availability = "always", requiredCapabilities = []) {
+    this.tools.set(key, {
+      key,
+      handler,
+      definition,
+      availability,
+      requiredCapabilities
+    });
+    this.onChanged?.();
+  }
+  /** Unregister a tool by key */
+  unregister(key) {
+    if (this.tools.delete(key)) {
+      this.onChanged?.();
+    }
+  }
+  /** Bulk register built-in tools with availability metadata */
+  registerBuiltins(toolSets, definitions, capabilityByKey = {}) {
+    const defMap = new Map(definitions.map((d) => [d.key, d]));
+    for (const [key, handler] of Object.entries(toolSets.core)) {
+      this.tools.set(key, {
+        key,
+        handler,
+        definition: defMap.get(key),
+        availability: "always",
+        requiredCapabilities: capabilityByKey[key] ?? []
+      });
+    }
+    for (const [key, handler] of Object.entries(toolSets.viewer)) {
+      this.tools.set(key, {
+        key,
+        handler,
+        definition: defMap.get(key),
+        availability: "viewer",
+        requiredCapabilities: capabilityByKey[key] ?? []
+      });
+    }
+    for (const [key, handler] of Object.entries(toolSets.infra)) {
+      this.tools.set(key, {
+        key,
+        handler,
+        definition: defMap.get(key),
+        availability: "playground",
+        requiredCapabilities: capabilityByKey[key] ?? []
+      });
+    }
+  }
+  /** Get handler for a tool (by unprefixed key or prefixed name) */
+  getHandler(nameOrKey) {
+    const direct = this.tools.get(nameOrKey);
+    if (direct) return direct.handler;
+    if (!this.prefix) return void 0;
+    const prefixStr = this.prefix + "_";
+    if (nameOrKey.startsWith(prefixStr)) {
+      const key = nameOrKey.slice(prefixStr.length);
+      return this.tools.get(key)?.handler;
+    }
+    return void 0;
+  }
+  /** Resolve unprefixed key from a potentially prefixed tool name */
+  resolveKey(name) {
+    if (!this.prefix) return name;
+    const prefixStr = this.prefix + "_";
+    return name.startsWith(prefixStr) ? name.slice(prefixStr.length) : name;
+  }
+  /** List available tools as MCP Tool[] based on current availability context */
+  listTools(ctx, allToolSchemas) {
+    const availableKeys = /* @__PURE__ */ new Set();
+    for (const [key, tool] of this.tools) {
+      const hasCapabilities = tool.requiredCapabilities.every(
+        (capability) => ctx.capabilities.has(capability)
+      );
+      if (!hasCapabilities) continue;
+      if (tool.availability === "always") {
+        availableKeys.add(key);
+      } else if (tool.availability === "viewer" && ctx.hasViewer) {
+        availableKeys.add(key);
+      } else if (tool.availability === "playground" && ctx.hasPlayground) {
+        availableKeys.add(key);
+      }
+    }
+    if (!this.prefix) {
+      return allToolSchemas.filter((t) => availableKeys.has(t.name));
+    }
+    const prefixStr = this.prefix + "_";
+    return allToolSchemas.filter((t) => {
+      const key = t.name.startsWith(prefixStr) ? t.name.slice(prefixStr.length) : t.name;
+      return availableKeys.has(key);
+    });
+  }
+  /** Execute a tool by name, dispatching to its handler */
+  async execute(name, args, ctx) {
+    const key = this.resolveKey(name);
+    const registered = this.tools.get(key);
+    if (!registered) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    return registered.handler(args, ctx);
+  }
+  /** Get the number of registered tools */
+  get size() {
+    return this.tools.size;
+  }
+  /** Get all registered keys */
+  keys() {
+    return Array.from(this.tools.keys());
+  }
+};
+
+// src/middleware.ts
+function executeWithMiddleware(middlewares, mCtx, handler) {
+  const chain = [...middlewares].reverse().reduce(
+    (next, mw) => () => mw(mCtx, next),
+    handler
+  );
+  return chain();
+}
+function telemetryMiddleware(logger) {
+  return async (mCtx, next) => {
+    const start = Date.now();
+    const result = await next();
+    logger(`${mCtx.toolKey}: ${Date.now() - start}ms`);
+    return result;
+  };
+}
+
+// src/source-selection.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+
+// src/adapters/fragments-json.ts
+import { readFile } from "fs/promises";
+
+// src/discovery.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join3, dirname, resolve } from "path";
+import { createRequire } from "module";
+function resolveWorkspaceGlob(baseDir, pattern) {
+  const parts = pattern.split("/");
+  let dirs = [baseDir];
+  for (const part of parts) {
+    if (part === "**") continue;
+    const next = [];
+    for (const d of dirs) {
+      if (part === "*") {
+        try {
+          for (const entry of readdirSync(d, { withFileTypes: true })) {
+            if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+              next.push(join3(d, entry.name));
+            }
+          }
+        } catch {
+        }
+      } else {
+        const candidate = join3(d, part);
+        if (existsSync3(candidate)) next.push(candidate);
+      }
+    }
+    dirs = next;
+  }
+  return dirs;
+}
+function getWorkspaceDirs(rootDir) {
+  const dirs = [];
+  const rootPkgPath = join3(rootDir, "package.json");
+  if (existsSync3(rootPkgPath)) {
+    try {
+      const rootPkg = JSON.parse(readFileSync3(rootPkgPath, "utf-8"));
+      const workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages;
+      if (Array.isArray(workspaces)) {
+        for (const pattern of workspaces) {
+          dirs.push(...resolveWorkspaceGlob(rootDir, pattern));
+        }
+        return dirs;
+      }
+    } catch {
+    }
+  }
+  const pnpmWsPath = join3(rootDir, "pnpm-workspace.yaml");
+  if (existsSync3(pnpmWsPath)) {
+    try {
+      const content = readFileSync3(pnpmWsPath, "utf-8");
+      const lines = content.split("\n");
+      let inPackages = false;
+      for (const line of lines) {
+        if (/^packages\s*:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          const match = line.match(/^\s+-\s+['"]?([^'"#\n]+)['"]?/);
+          if (match) {
+            dirs.push(...resolveWorkspaceGlob(rootDir, match[1].trim()));
+          } else if (/^\S/.test(line) && line.trim()) {
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return dirs;
+}
+function resolveDepPackageJson(localRequire, depName) {
+  try {
+    return localRequire.resolve(`${depName}/package.json`);
+  } catch {
+  }
+  try {
+    const mainPath = localRequire.resolve(depName);
+    let dir = dirname(mainPath);
+    while (true) {
+      const candidate = join3(dir, "package.json");
+      if (existsSync3(candidate)) {
+        const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
+        if (pkg.name === depName) return candidate;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return null;
+}
+function findFragmentsInDeps(dir, found, depField) {
+  const pkgJsonPath = join3(dir, "package.json");
+  if (!existsSync3(pkgJsonPath)) return;
+  try {
+    const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+    const allDeps = {
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies
+    };
+    const localRequire = createRequire(join3(dir, "noop.js"));
+    for (const depName of Object.keys(allDeps)) {
+      try {
+        const depPkgPath = resolveDepPackageJson(localRequire, depName);
+        if (!depPkgPath) continue;
+        const depPkg = JSON.parse(readFileSync3(depPkgPath, "utf-8"));
+        if (depPkg[depField]) {
+          const fragmentsPath = join3(dirname(depPkgPath), depPkg[depField]);
+          if (existsSync3(fragmentsPath) && !found.includes(fragmentsPath)) {
+            found.push(fragmentsPath);
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function findDesignSystemJson(startDir, outFile, depField) {
+  const found = [];
+  const resolvedStart = resolve(startDir);
+  let dir = resolvedStart;
+  while (true) {
+    const candidate = join3(dir, outFile);
+    if (existsSync3(candidate)) {
+      found.push(candidate);
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  findFragmentsInDeps(resolvedStart, found, depField);
+  if (found.length === 0 || existsSync3(join3(resolvedStart, "pnpm-workspace.yaml"))) {
+    const workspaceDirs = getWorkspaceDirs(resolvedStart);
+    for (const wsDir of workspaceDirs) {
+      findFragmentsInDeps(wsDir, found, depField);
+    }
+  }
+  return found;
+}
+function findFragmentsJson(startDir) {
+  return findDesignSystemJson(startDir, BRAND.outFile, "fragments");
+}
+function findBundleManifest(startDir) {
+  const found = [];
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join3(dir, BRAND.dataDir, BRAND.manifestFile);
+    if (existsSync3(candidate)) {
+      found.push(candidate);
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return found;
+}
+
+// src/adapters/snapshot-converters.ts
+import { mcpSnapshotSchema } from "@fragments-sdk/core";
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function buildComponentId(args) {
+  const base = args.filePath ?? args.packageName ?? args.name;
+  return `${slugify(args.name)}:${base}`;
+}
+function valueToString(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function buildCompoundChildren(contract, ai) {
+  const contractChildren = Object.entries(contract?.compoundChildren ?? {});
+  if (contractChildren.length > 0) {
+    return contractChildren.map(([childName, child]) => ({
+      name: childName,
+      description: child.description,
+      required: child.required,
+      accepts: child.accepts,
+      visibility: "public"
+    }));
+  }
+  const subs = ai?.subComponents;
+  if (!subs || subs.length === 0) return [];
+  const requiredSet = new Set(ai?.requiredChildren ?? []);
+  return subs.map((name) => ({
+    name,
+    required: requiredSet.has(name) || void 0,
+    visibility: "public"
+  }));
+}
+function componentFromCompiledFragment(args) {
+  const { fragment, sourceType } = args;
+  const name = fragment.meta.name;
+  const description = fragment.meta.description ?? "";
+  const usage = fragment.usage ?? { when: [], whenNot: [] };
+  const contract = fragment.contract;
+  const ai = fragment.ai;
+  const guidancePatterns = (fragment._cloudPatterns ?? []).map((pattern) => ({
+    name: pattern.name ?? "Pattern",
+    description: pattern.description
+  }));
+  return {
+    id: args.id ?? buildComponentId({
+      name,
+      filePath: fragment.sourcePath ?? fragment.filePath,
+      packageName: args.packageName
+    }),
+    name,
+    description,
+    category: fragment.meta.category ?? "uncategorized",
+    status: fragment.meta.status ?? "stable",
+    tags: fragment.meta.tags ?? [],
+    props: Object.fromEntries(
+      Object.entries(fragment.props ?? {}).map(([propName, prop]) => [
+        propName,
+        {
+          type: prop.type,
+          description: prop.description ?? "",
+          required: prop.required ?? false,
+          default: prop.default,
+          values: prop.values ? [...prop.values] : void 0,
+          constraints: prop.constraints ? [...prop.constraints] : void 0
+        }
+      ])
+    ),
+    propsSummary: fragment.propsSummary ?? contract?.propsSummary ?? Object.entries(fragment.props ?? {}).map(
+      ([propName, prop]) => `${propName}${prop.required ? " (required)" : ""}: ${prop.type}`
+    ),
+    examples: (fragment.variants ?? []).map((variant) => ({
+      name: variant.name,
+      description: variant.description,
+      code: variant.code,
+      kind: "example"
+    })),
+    relations: (fragment.relations ?? []).map((relation) => ({
+      componentName: relation.component,
+      relationship: relation.relationship,
+      note: relation.note
+    })),
+    compoundChildren: buildCompoundChildren(contract, ai),
+    guidance: {
+      when: usage.when ?? [],
+      whenNot: usage.whenNot ?? [],
+      guidelines: usage.guidelines ?? [],
+      accessibility: usage.accessibility ?? [],
+      dos: usage.when ?? [],
+      donts: usage.whenNot ?? [],
+      patterns: guidancePatterns.length > 0 ? guidancePatterns : (ai?.commonPatterns ?? []).map((pattern) => ({
+        name: pattern
+      }))
+    },
+    sourceType,
+    sourcePath: fragment.sourcePath ?? fragment.filePath,
+    packageName: args.packageName,
+    importPath: args.importPath ?? args.packageName,
+    performance: fragment.performance ? {
+      bundleSize: fragment.performance.bundleSize,
+      rawSize: fragment.performance.rawSize,
+      complexity: fragment.performance.complexity,
+      budgetPercent: fragment.performance.budgetPercent,
+      overBudget: fragment.performance.overBudget,
+      measuredAt: fragment.performance.measuredAt,
+      imports: fragment.performance.imports?.map((entry) => ({
+        path: entry.path,
+        bytes: entry.bytes,
+        percent: entry.percent
+      }))
+    } : void 0,
+    metadata: {
+      a11yRules: contract?.a11yRules ?? [],
+      scenarioTags: contract?.scenarioTags ?? []
+    }
+  };
+}
+function blockFromCompiledBlock(key, block) {
+  return {
+    id: key,
+    name: block.name,
+    description: block.description ?? "",
+    category: block.category ?? "uncategorized",
+    components: block.components ?? [],
+    tags: block.tags ?? [],
+    code: block.code ?? ""
+  };
+}
+function tokensFromCompiledTokenData(tokens) {
+  const flat = [];
+  const categories = {};
+  for (const [category, entries] of Object.entries(tokens.categories)) {
+    const normalized = entries.map((entry) => ({
+      name: entry.name,
+      category,
+      value: valueToString(entry.value),
+      description: entry.description
+    }));
+    categories[category] = normalized;
+    flat.push(...normalized);
+  }
+  return {
+    prefix: tokens.prefix,
+    total: tokens.total,
+    categories,
+    flat
+  };
+}
+function buildCapabilities(args) {
+  const capabilities = /* @__PURE__ */ new Set();
+  if (Object.keys(args.components).length > 0) {
+    capabilities.add("components");
+  }
+  if (args.tokens && args.tokens.total > 0) {
+    capabilities.add("tokens");
+  }
+  if (args.blocks && Object.keys(args.blocks).length > 0) {
+    capabilities.add("blocks");
+  }
+  if (args.graph) {
+    capabilities.add("graph");
+  }
+  const hasPerformance = Boolean(args.performanceSummary) || Object.values(args.components).some((component) => Boolean(component.performance));
+  if (hasPerformance) {
+    capabilities.add("performance");
+  }
+  return Array.from(capabilities);
+}
+function validateSnapshot(snapshot) {
+  return mcpSnapshotSchema.parse(snapshot);
+}
+
+// src/adapters/fragments-json.ts
+var FragmentsJsonAdapter = class {
+  name = "fragments-json";
+  discover(startDir) {
+    return findFragmentsJson(startDir);
+  }
+  async load(projectRoot) {
+    const paths = this.discover(projectRoot);
+    if (paths.length === 0) {
+      throw new Error(
+        `No ${BRAND.outFile} found. Searched ${projectRoot} and package.json dependencies.
+
+Fix: Add a project-level MCP config so the server runs from your workspace root:
+
+  Cursor:    .cursor/mcp.json
+  VS Code:   .vscode/mcp.json
+  Claude:    claude mcp add ${BRAND.nameLower} -- npx @fragments-sdk/mcp
+  Windsurf:  .windsurf/mcp.json
+
+Or pass --project-root: npx @fragments-sdk/mcp -p /path/to/project
+
+If you're a library author, run \`${BRAND.cliCommand} build\` first.`
+      );
+    }
+    const content = await readFile(paths[0], "utf-8");
+    const primary = JSON.parse(content);
+    if (!primary.blocks && primary.recipes) {
+      primary.blocks = primary.recipes;
+    }
+    const packageMap = {};
+    if (primary.packageName) {
+      for (const name of Object.keys(primary.fragments)) {
+        packageMap[name] = primary.packageName;
+      }
+    }
+    for (let i = 1; i < paths.length; i++) {
+      const extra = JSON.parse(await readFile(paths[i], "utf-8"));
+      if (extra.packageName) {
+        for (const name of Object.keys(extra.fragments)) {
+          packageMap[name] = extra.packageName;
+        }
+      }
+      Object.assign(primary.fragments, extra.fragments);
+      const extraBlocks = extra.blocks ?? extra.recipes;
+      if (extraBlocks) {
+        primary.blocks = { ...primary.blocks, ...extraBlocks };
+      }
+    }
+    const components = Object.fromEntries(
+      Object.entries(primary.fragments).map(([key, fragment]) => [
+        key,
+        componentFromCompiledFragment({
+          id: key,
+          fragment,
+          sourceType: "fragments-json",
+          packageName: packageMap[fragment.meta.name] ?? primary.packageName,
+          importPath: packageMap[fragment.meta.name] ?? primary.packageName
+        })
+      ])
+    );
+    const blocks = primary.blocks ? Object.fromEntries(
+      Object.entries(primary.blocks).map(([key, block]) => [
+        key,
+        blockFromCompiledBlock(key, block)
+      ])
+    ) : void 0;
+    const tokens = primary.tokens ? tokensFromCompiledTokenData(primary.tokens) : void 0;
+    const snapshot = validateSnapshot({
+      schemaVersion: 1,
+      sourceType: "fragments-json",
+      sourceLabel: BRAND.outFile,
+      capabilities: buildCapabilities({
+        components,
+        blocks,
+        tokens,
+        graph: primary.graph,
+        performanceSummary: primary.performanceSummary
+      }),
+      metadata: {
+        designSystemName: primary.packageName,
+        packageName: primary.packageName,
+        importPath: primary.packageName
+      },
+      components,
+      blocks,
+      tokens,
+      graph: primary.graph,
+      performanceSummary: primary.performanceSummary,
+      packageMap,
+      defaultPackageName: primary.packageName
+    });
+    return {
+      snapshot,
+      components: snapshot.components,
+      blocks: snapshot.blocks,
+      tokens: snapshot.tokens,
+      graph: primary.graph,
+      performanceSummary: primary.performanceSummary,
+      packageMap: snapshot.packageMap,
+      defaultPackageName: snapshot.defaultPackageName,
+      capabilities: new Set(snapshot.capabilities)
+    };
+  }
+};
+
+// src/adapters/auto-extract.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6, relative, sep } from "path";
+
+// src/adapters/discover-components.ts
+import { readdirSync as readdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join4, extname, basename } from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  "__tests__",
+  "__mocks__",
+  ".git",
+  ".cache",
+  ".turbo",
+  "out"
+]);
+var EXCLUDED_PATTERNS = [
+  /\.test\./,
+  /\.spec\./,
+  /\.stories\./,
+  /\.story\./,
+  /\.fragment\./,
+  /\.d\.ts$/,
+  /\.config\./,
+  /\.mock\./,
+  /\.fixture\./
+];
+function discoverComponentFiles(projectRoot) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const scanDirs = [
+    "src/components",
+    "components",
+    "lib/components",
+    "src/ui",
+    "lib/ui",
+    "packages"
+  ].map((d) => join4(projectRoot, d)).filter((d) => existsSync4(d));
+  if (scanDirs.length === 0) {
+    const srcDir = join4(projectRoot, "src");
+    if (existsSync4(srcDir)) scanDirs.push(srcDir);
+  }
+  for (const dir of scanDirs) {
+    walkDir(dir, results, seen);
+  }
+  return results;
+}
+function walkDir(dir, results, seen, depth = 0) {
+  if (depth > 6) return;
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) continue;
+      walkDir(join4(dir, entry.name), results, seen, depth + 1);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const ext = extname(entry.name);
+    if (ext !== ".tsx" && ext !== ".jsx") continue;
+    if (EXCLUDED_PATTERNS.some((p) => p.test(entry.name))) continue;
+    const filePath = join4(dir, entry.name);
+    if (seen.has(filePath)) continue;
+    seen.add(filePath);
+    const name = inferComponentName(entry.name, dir);
+    if (name) {
+      results.push({ filePath, componentName: name });
+    }
+  }
+}
+function inferComponentName(fileName, dirPath) {
+  const withoutExt = fileName.replace(/\.(tsx|jsx)$/, "");
+  if (withoutExt === "index") {
+    return basename(dirPath);
+  }
+  return withoutExt;
+}
+
+// src/adapters/scan-tokens.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join5, extname as extname2 } from "path";
+function scanTokens(projectRoot) {
+  const cssFiles = discoverCssFiles(projectRoot);
+  if (cssFiles.length === 0) return void 0;
+  const allTokens = [];
+  let prefix = "";
+  for (const filePath of cssFiles) {
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      const tokens = extractCustomProperties(content);
+      allTokens.push(...tokens);
+    } catch {
+      continue;
+    }
+  }
+  if (allTokens.length === 0) return void 0;
+  prefix = detectPrefix(allTokens.map((t) => t.name));
+  const categories = {};
+  for (const token of allTokens) {
+    const category = inferTokenCategory(token.name);
+    if (!categories[category]) categories[category] = [];
+    if (!categories[category].some((t) => t.name === token.name)) {
+      categories[category].push(token);
+    }
+  }
+  return {
+    prefix,
+    total: Object.values(categories).reduce((sum, arr) => sum + arr.length, 0),
+    categories
+  };
+}
+function discoverCssFiles(projectRoot) {
+  const files = [];
+  const searchDirs = [
+    "src",
+    "styles",
+    "css",
+    "app"
+  ].map((d) => join5(projectRoot, d)).filter((d) => existsSync5(d));
+  searchDirs.push(projectRoot);
+  for (const dir of searchDirs) {
+    try {
+      const entries = readdirSync3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const ext = extname2(entry.name);
+        if (ext === ".css" || ext === ".scss") {
+          files.push(join5(dir, entry.name));
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  const srcDir = join5(projectRoot, "src");
+  if (existsSync5(srcDir)) {
+    try {
+      for (const subEntry of readdirSync3(srcDir, { withFileTypes: true })) {
+        if (subEntry.isDirectory() && ["styles", "css", "theme", "tokens"].includes(subEntry.name)) {
+          const subDir = join5(srcDir, subEntry.name);
+          for (const file of readdirSync3(subDir, { withFileTypes: true })) {
+            if (file.isFile() && (file.name.endsWith(".css") || file.name.endsWith(".scss"))) {
+              files.push(join5(subDir, file.name));
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return [...new Set(files)];
+}
+function extractCustomProperties(content) {
+  const tokens = [];
+  let inRelevantBlock = false;
+  let braceDepth = 0;
+  const relevantSelectors = [":root", ".dark", "[data-theme", "@theme"];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!inRelevantBlock && braceDepth === 0) {
+      if (relevantSelectors.some((sel) => trimmed.startsWith(sel) || trimmed.includes(sel))) {
+        if (trimmed.includes("{")) {
+          inRelevantBlock = true;
+          braceDepth = 1;
+        }
+      }
+    }
+    if (inRelevantBlock) {
+      for (const ch of trimmed) {
+        if (ch === "{") braceDepth++;
+        else if (ch === "}") {
+          braceDepth--;
+          if (braceDepth <= 0) {
+            inRelevantBlock = false;
+            braceDepth = 0;
+          }
+        }
+      }
+    }
+    if (!inRelevantBlock && braceDepth === 0) continue;
+    const match = trimmed.match(/^(--[\w-]+)\s*:\s*(.+?)\s*;/);
+    if (match) {
+      const [, name, value] = match;
+      const commentMatch = value.match(/\/\*\s*(.+?)\s*\*\//);
+      const cleanValue = value.replace(/\/\*.*?\*\//, "").trim();
+      tokens.push({
+        name,
+        value: cleanValue,
+        description: commentMatch?.[1]
+      });
+    }
+  }
+  return tokens;
+}
+function detectPrefix(names) {
+  if (names.length === 0) return "--";
+  const stripped = names.map((n) => n.slice(2));
+  let prefix = "";
+  const first = stripped[0];
+  for (let i = 0; i < first.length; i++) {
+    const ch = first[i];
+    if (stripped.every((n) => n[i] === ch)) {
+      prefix += ch;
+    } else {
+      break;
+    }
+  }
+  const lastDash = prefix.lastIndexOf("-");
+  if (lastDash > 0) {
+    return "--" + prefix.slice(0, lastDash + 1);
+  }
+  return "--";
+}
+function inferTokenCategory(name) {
+  const n = name.toLowerCase();
+  if (n.includes("color") || n.includes("background") || n.includes("foreground") || n.includes("primary") || n.includes("secondary") || n.includes("accent") || n.includes("muted") || n.includes("destructive") || n.includes("popover") || n.includes("card") && !n.includes("card-") || n.includes("chart")) {
+    return "colors";
+  }
+  if (n.includes("font") || n.includes("text") || n.includes("letter") || n.includes("line-height")) {
+    return "typography";
+  }
+  if (n.includes("space") || n.includes("gap") || n.includes("padding") || n.includes("margin")) {
+    return "spacing";
+  }
+  if (n.includes("radius")) {
+    return "radius";
+  }
+  if (n.includes("shadow")) {
+    return "shadows";
+  }
+  if (n.includes("border")) {
+    return "borders";
+  }
+  if (n.includes("ring")) {
+    return "focus";
+  }
+  if (n.includes("sidebar")) {
+    return "sidebar";
+  }
+  if (n.includes("input")) {
+    return "forms";
+  }
+  return "other";
+}
+
+// src/adapters/auto-extract.ts
+var AutoExtractionAdapter = class {
+  name = "auto-extract";
+  discover(startDir) {
+    return discoverComponentFiles(startDir).map((f) => f.filePath);
+  }
+  async load(projectRoot) {
+    let extractMod;
+    try {
+      extractMod = await loadExtractorModule();
+    } catch (e) {
+      throw new Error(
+        "Auto-extraction requires @fragments-sdk/extract and TypeScript.\n\nIf you see this error, the MCP server may not be installed correctly.\nAlternative: pre-build your design system with `npx fragments build`"
+      );
+    }
+    const tsconfigPath = findTsConfig(projectRoot);
+    const extractor = extractMod.createComponentExtractor(tsconfigPath ?? void 0);
+    try {
+      const discovered = discoverComponentFiles(projectRoot);
+      if (discovered.length === 0) {
+        throw new Error(
+          `No component files found in ${projectRoot}.
+Searched: src/components/, components/, lib/components/, src/ui/
+
+If your components are elsewhere, create a fragments.json with:
+  npx fragments build`
+        );
+      }
+      const components = {};
+      const packageMap = /* @__PURE__ */ new Map();
+      const defaultPackageName = readPackageName(projectRoot);
+      let extractedCount = 0;
+      const fileToComponents = /* @__PURE__ */ new Map();
+      for (const { filePath, componentName } of discovered) {
+        try {
+          const metas = extractor.extractAll(filePath);
+          for (const meta of metas) {
+            const fragment = mapToCompiledFragment(meta, filePath, projectRoot);
+            components[meta.name] = fragment;
+            if (defaultPackageName) {
+              packageMap.set(meta.name, defaultPackageName);
+            }
+            extractedCount++;
+            const relPath = relative(projectRoot, filePath);
+            if (!fileToComponents.has(relPath)) fileToComponents.set(relPath, []);
+            fileToComponents.get(relPath).push(meta.name);
+          }
+          if (metas.length === 0) {
+            const meta = extractor.extract(filePath, componentName);
+            if (meta) {
+              const fragment = mapToCompiledFragment(meta, filePath, projectRoot);
+              components[meta.name] = fragment;
+              if (defaultPackageName) {
+                packageMap.set(meta.name, defaultPackageName);
+              }
+              extractedCount++;
+              const relPath = relative(projectRoot, filePath);
+              if (!fileToComponents.has(relPath)) fileToComponents.set(relPath, []);
+              fileToComponents.get(relPath).push(meta.name);
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      inferRelations(components, fileToComponents);
+      console.error(`[fragments-mcp] Extracted ${extractedCount} components from ${discovered.length} files.`);
+      if (extractedCount === 0) {
+        throw new Error(
+          `Found ${discovered.length} component files but could not extract any props.
+This usually means TypeScript cannot parse the files.
+Check that your tsconfig.json includes the component directories.`
+        );
+      }
+      const tokens = scanTokens(projectRoot);
+      if (tokens) {
+        console.error(`[fragments-mcp] Found ${tokens.total} design tokens across ${Object.keys(tokens.categories).length} categories.`);
+      }
+      const snapshotComponents = Object.fromEntries(
+        Object.entries(components).map(([key, fragment]) => [
+          key,
+          componentFromCompiledFragment({
+            id: key,
+            fragment,
+            sourceType: "auto-extract",
+            packageName: packageMap.get(fragment.meta.name) ?? defaultPackageName,
+            importPath: packageMap.get(fragment.meta.name) ?? defaultPackageName
+          })
+        ])
+      );
+      const snapshotTokens = tokens ? tokensFromCompiledTokenData(tokens) : void 0;
+      const packageMapRecord = Object.fromEntries(packageMap.entries());
+      const snapshot = validateSnapshot({
+        schemaVersion: 1,
+        sourceType: "auto-extract",
+        sourceLabel: "Auto-extracted source files",
+        capabilities: buildCapabilities({
+          components: snapshotComponents,
+          tokens: snapshotTokens
+        }),
+        metadata: {
+          packageName: defaultPackageName,
+          importPath: defaultPackageName
+        },
+        components: snapshotComponents,
+        tokens: snapshotTokens,
+        packageMap: packageMapRecord,
+        defaultPackageName
+      });
+      return {
+        snapshot,
+        components: snapshot.components,
+        blocks: snapshot.blocks,
+        tokens: snapshot.tokens,
+        graph: void 0,
+        performanceSummary: void 0,
+        packageMap: snapshot.packageMap,
+        defaultPackageName: snapshot.defaultPackageName,
+        capabilities: new Set(snapshot.capabilities)
+      };
+    } finally {
+      extractor.dispose();
+    }
+  }
+};
+var extractorModulePromise = null;
+async function loadExtractorModule() {
+  if (!extractorModulePromise) {
+    extractorModulePromise = import("./dist-V7D67NXS.js");
+  }
+  return extractorModulePromise;
+}
+var UNIVERSAL_INHERITED = /* @__PURE__ */ new Set(["children", "className", "id", "disabled"]);
+var FORM_INPUT_INHERITED = /* @__PURE__ */ new Set([
+  "placeholder",
+  "value",
+  "defaultValue",
+  "onChange",
+  "name",
+  "required",
+  "autoFocus",
+  "autoComplete",
+  "checked",
+  "defaultChecked",
+  "type"
+]);
+var LABEL_INHERITED = /* @__PURE__ */ new Set(["htmlFor"]);
+var INPUT_LIKE_NAMES = /input|select|textarea|checkbox|radio|switch|slider|combobox/i;
+var LABEL_LIKE_NAMES = /label/i;
+function getRelevantInheritedProps(componentName) {
+  const allowed = new Set(UNIVERSAL_INHERITED);
+  if (INPUT_LIKE_NAMES.test(componentName)) {
+    for (const p of FORM_INPUT_INHERITED) allowed.add(p);
+  }
+  if (LABEL_LIKE_NAMES.test(componentName)) {
+    for (const p of LABEL_INHERITED) allowed.add(p);
+  }
+  return allowed;
+}
+function mapToCompiledFragment(meta, filePath, projectRoot) {
+  const relevantInherited = getRelevantInheritedProps(meta.name);
+  const props = {};
+  for (const [name, propMeta] of Object.entries(meta.props)) {
+    if (propMeta.source === "inherited" && !relevantInherited.has(name)) continue;
+    props[name] = {
+      type: propMeta.type,
+      description: propMeta.description ?? "",
+      required: propMeta.required,
+      ...propMeta.values && { values: propMeta.values },
+      ...propMeta.default !== void 0 && { default: propMeta.default }
+    };
+  }
+  const relativePath = relative(projectRoot, filePath);
+  const category = inferCategory(relativePath);
+  const importPath = buildImportPath(relativePath);
+  const description = buildDescription(meta, props);
+  const propsSummary = buildPropsSummary(props);
+  const codeExample = buildCodeExample(meta.name, props);
+  const fragmentMeta = {
+    name: meta.name,
+    description,
+    category
+  };
+  return {
+    filePath: relativePath,
+    meta: fragmentMeta,
+    usage: {
+      when: [`Use ${meta.name} when you need a ${category} ${meta.name.toLowerCase()} element.`],
+      whenNot: [],
+      guidelines: importPath ? [`import { ${meta.name} } from "${importPath}"`] : []
+    },
+    props,
+    propsSummary,
+    variants: codeExample ? [{ name: "Default", description: `Basic ${meta.name} usage`, code: codeExample }] : [],
+    sourcePath: relativePath,
+    exportName: meta.name,
+    _generated: {
+      source: "extracted",
+      verified: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    ...meta.composition && {
+      ai: {
+        compositionPattern: meta.composition.pattern
+      }
+    }
+  };
+}
+function buildImportPath(relativePath) {
+  const withoutExt = relativePath.replace(/\.(tsx|jsx|ts|js)$/, "");
+  if (withoutExt.startsWith(`src${sep}`)) {
+    return "@/" + withoutExt.slice(4).split(sep).join("/");
+  }
+  return "./" + withoutExt.split(sep).join("/");
+}
+function buildDescription(meta, localProps) {
+  if (meta.description && meta.description !== meta.name && !meta.description.endsWith(" component")) {
+    return meta.description;
+  }
+  const propEntries = Object.entries(localProps);
+  if (propEntries.length === 0) {
+    return `${meta.name} component`;
+  }
+  const details = [];
+  for (const [name, prop] of propEntries) {
+    if (prop.values && prop.values.length > 0) {
+      details.push(`${prop.values.length} ${name} options`);
+    }
+  }
+  if (details.length > 0) {
+    return `${meta.name} component with ${details.join(" and ")}.`;
+  }
+  return `${meta.name} component with ${propEntries.length} configurable prop${propEntries.length === 1 ? "" : "s"}.`;
+}
+function buildPropsSummary(props) {
+  const summaries = [];
+  for (const [name, prop] of Object.entries(props)) {
+    let summary = `${name}`;
+    if (prop.values && prop.values.length > 0) {
+      summary += `: ${prop.values.map((v) => `"${v}"`).join(" | ")}`;
+    } else {
+      summary += `: ${prop.type}`;
+    }
+    if (prop.default !== void 0) {
+      summary += ` (default: ${JSON.stringify(prop.default)})`;
+    }
+    if (prop.required) {
+      summary += " (required)";
+    }
+    summaries.push(summary);
+  }
+  return summaries;
+}
+function buildCodeExample(name, props) {
+  const propsStr = [];
+  for (const [pName, prop] of Object.entries(props)) {
+    if (pName === "children" || pName === "asChild" || pName === "className") continue;
+    if (pName === "onChange" || pName === "onSubmit" || pName === "value" || pName === "defaultValue" || pName === "checked" || pName === "defaultChecked" || pName === "autoFocus" || pName === "autoComplete" || pName === "required" || pName === "disabled" || pName === "name") continue;
+    if (prop.default !== void 0) {
+      if (prop.values && prop.values.length > 1) {
+        const nonDefault = prop.values.find((v) => v !== String(prop.default));
+        if (nonDefault) {
+          propsStr.push(`${pName}="${nonDefault}"`);
+          continue;
+        }
+      }
+    }
+    if (pName === "placeholder" && INPUT_LIKE_NAMES.test(name)) {
+      propsStr.push(`placeholder="Enter ${name.toLowerCase()}..."`);
+      continue;
+    }
+    if (pName === "htmlFor" && LABEL_LIKE_NAMES.test(name)) {
+      propsStr.push(`htmlFor="field-id"`);
+      continue;
+    }
+    if (pName === "id" || pName === "className" || pName === "children") continue;
+    if (prop.required) {
+      if (prop.values && prop.values.length > 0) {
+        propsStr.push(`${pName}="${prop.values[0]}"`);
+      } else if (prop.type === "string") {
+        propsStr.push(`${pName}="..."`);
+      }
+    }
+  }
+  const propsJsx = propsStr.length > 0 ? " " + propsStr.join(" ") : "";
+  const nameLower = name.toLowerCase();
+  const selfClosing = nameLower.includes("input") || nameLower.includes("separator") || nameLower.includes("slider") || nameLower.includes("switch");
+  if (selfClosing) {
+    return `<${name}${propsJsx} />`;
+  }
+  return `<${name}${propsJsx}>${name}</${name}>`;
+}
+function buildCompositionExample(root, subs) {
+  const header = subs.filter((s) => s.includes("Header"));
+  const title = subs.filter((s) => s.includes("Title"));
+  const description = subs.filter((s) => s.includes("Description"));
+  const content = subs.filter((s) => s.includes("Content") || s.includes("Body"));
+  const footer = subs.filter((s) => s.includes("Footer"));
+  const action = subs.filter((s) => s.includes("Action"));
+  const other = subs.filter(
+    (s) => !header.includes(s) && !title.includes(s) && !description.includes(s) && !content.includes(s) && !footer.includes(s) && !action.includes(s)
+  );
+  const lines = [`<${root}>`];
+  if (header.length > 0) {
+    lines.push(`  <${header[0]}>`);
+    for (const t of title) lines.push(`    <${t}>Title</${t}>`);
+    for (const d of description) lines.push(`    <${d}>Description</${d}>`);
+    lines.push(`  </${header[0]}>`);
+  } else {
+    for (const t of title) lines.push(`  <${t}>Title</${t}>`);
+    for (const d of description) lines.push(`  <${d}>Description</${d}>`);
+  }
+  for (const c of content) lines.push(`  <${c}>Content</${c}>`);
+  for (const o of other) lines.push(`  <${o}>...</${o}>`);
+  if (footer.length > 0) {
+    lines.push(`  <${footer[0]}>`);
+    for (const a of action) lines.push(`    <${a}>Action</${a}>`);
+    lines.push(`  </${footer[0]}>`);
+  } else {
+    for (const a of action) lines.push(`  <${a}>Action</${a}>`);
+  }
+  lines.push(`</${root}>`);
+  return lines.join("\n");
+}
+function inferRelations(components, fileToComponents) {
+  for (const [_file, names] of fileToComponents) {
+    if (names.length <= 1) continue;
+    const sorted = [...names].sort((a, b) => a.length - b.length);
+    const root = sorted[0];
+    const subs = sorted.slice(1).filter((n) => n.startsWith(root));
+    if (subs.length === 0) continue;
+    const rootComp = components[root];
+    if (rootComp) {
+      rootComp.ai = {
+        ...rootComp.ai,
+        compositionPattern: "compound",
+        subComponents: subs
+      };
+      rootComp.relations = subs.map((sub) => ({
+        component: sub,
+        relationship: "parent-of",
+        note: `${sub} is a sub-component of ${root}`
+      }));
+      const compositionCode = buildCompositionExample(root, subs);
+      rootComp.variants = [
+        ...rootComp.variants ?? [],
+        { name: "Composition", description: `${root} with all sub-components`, code: compositionCode }
+      ];
+    }
+    const rootImportPath = rootComp?.usage?.guidelines?.[0];
+    for (const sub of subs) {
+      const subComp = components[sub];
+      if (subComp) {
+        subComp.relations = [{
+          component: root,
+          relationship: "child-of",
+          note: `Use inside <${root}>`
+        }];
+        if (rootImportPath) {
+          const allNames = [root, ...subs].join(", ");
+          const fromPath = rootImportPath.match(/from\s+"([^"]+)"/)?.[1] ?? "";
+          if (fromPath) {
+            subComp.usage = {
+              ...subComp.usage,
+              guidelines: [`import { ${allNames} } from "${fromPath}"`]
+            };
+          }
+        }
+      }
+    }
+    if (rootComp && rootComp.usage?.guidelines?.[0]) {
+      const fromPath = rootComp.usage.guidelines[0].match(/from\s+"([^"]+)"/)?.[1] ?? "";
+      if (fromPath) {
+        const allNames = [root, ...subs].join(", ");
+        rootComp.usage.guidelines = [`import { ${allNames} } from "${fromPath}"`];
+      }
+    }
+  }
+}
+function inferCategory(relativePath) {
+  const parts = relativePath.split(sep);
+  const componentsIdx = parts.findIndex(
+    (p) => p === "components" || p === "ui"
+  );
+  if (componentsIdx >= 0 && componentsIdx + 1 < parts.length - 1) {
+    const nextPart = parts[componentsIdx + 1];
+    if (/^[A-Z]/.test(nextPart)) return parts[componentsIdx] || "uncategorized";
+    return nextPart;
+  }
+  return "uncategorized";
+}
+function findTsConfig(projectRoot) {
+  const candidates = ["tsconfig.json", "tsconfig.app.json"];
+  for (const name of candidates) {
+    const p = join6(projectRoot, name);
+    if (existsSync6(p)) return p;
+  }
+  return null;
+}
+function readPackageName(projectRoot) {
+  try {
+    const pkgPath = join6(projectRoot, "package.json");
+    if (!existsSync6(pkgPath)) return void 0;
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/cloud-catalog.ts
+var DEFAULT_CLOUD_URL = "https://app.usefragments.com/api/catalog";
+var TOKEN_CATEGORY_ALIASES2 = {
+  color: ["color", "colors", "accent", "background", "foreground", "danger", "brand"],
+  spacing: ["spacing", "space", "padding", "margin", "gap", "inset"],
+  typography: ["typography", "font", "text", "copy", "line-height", "letter"],
+  border: ["border", "borders", "stroke", "outline"],
+  radius: ["radius", "radii", "corner", "corners", "rounded"],
+  shadow: ["shadow", "shadows", "elevation"],
+  layout: ["layout", "grid", "container", "breakpoint"],
+  focus: ["focus", "ring", "focus-ring"],
+  surface: ["surface", "surfaces", "canvas", "card", "background"]
+};
+function normalizeCatalogUrl(url) {
+  if (!url) return DEFAULT_CLOUD_URL;
+  if (url.endsWith("/api/catalog")) return url;
+  return `${url.replace(/\/+$/, "")}/api/catalog`;
+}
+function normalizeValue(value) {
+  return value?.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() ?? "";
+}
+function canonicalizeTokenCategory(token) {
+  const candidates = [
+    token.category,
+    token.path?.[0],
+    token.name.split(/[.:/-]/)[0]
+  ].map(normalizeValue).filter(Boolean);
+  for (const candidate of candidates) {
+    for (const [canonical, aliases] of Object.entries(
+      TOKEN_CATEGORY_ALIASES2
+    )) {
+      if (candidate === canonical || aliases.some(
+        (alias) => candidate === alias || candidate.includes(alias) || alias.includes(candidate)
+      )) {
+        return canonical;
+      }
+    }
+  }
+  return candidates[0] || "other";
+}
+function groupTokens(flat) {
+  const categories = {};
+  const normalizedFlat = (flat ?? []).map((token) => {
+    const category = canonicalizeTokenCategory(token);
+    const normalized = {
+      name: token.name,
+      category,
+      value: token.value,
+      description: token.description,
+      path: token.path,
+      type: token.type
+    };
+    if (!categories[category]) {
+      categories[category] = [];
+    }
+    categories[category].push(normalized);
+    return normalized;
+  });
+  return {
+    prefix: "",
+    total: normalizedFlat.length,
+    categories,
+    flat: normalizedFlat
+  };
+}
+function mapComponent(component, designSystem) {
+  return {
+    id: component.componentKey,
+    name: component.name,
+    description: component.description ?? "",
+    category: component.category ?? "uncategorized",
+    status: component.status ?? "stable",
+    tags: [],
+    props: Object.fromEntries(
+      Object.entries(component.props ?? {}).map(([propName, prop]) => [
+        propName,
+        {
+          type: prop.type ?? "unknown",
+          description: prop.description ?? "",
+          required: prop.required ?? false,
+          default: prop.default,
+          values: prop.values
+        }
+      ])
+    ),
+    propsSummary: Object.entries(component.props ?? {}).map(
+      ([propName, prop]) => `${propName}${prop.required ? " (required)" : ""}: ${prop.type ?? "unknown"}`
+    ),
+    examples: (component.examples ?? []).map((example) => ({
+      name: example.title ?? "Example",
+      description: example.kind,
+      code: example.code,
+      kind: example.kind
+    })),
+    relations: (component.relations ?? []).map((relation) => ({
+      componentName: relation.component ?? relation.componentKey ?? "Unknown",
+      componentId: relation.componentKey,
+      relationship: relation.relationship ?? relation.type ?? "related",
+      note: relation.note,
+      description: relation.description
+    })),
+    compoundChildren: (component.compoundChildren ?? []).filter((child) => child.subcomponentVisibility !== "internal").map((child) => ({
+      name: child.name,
+      componentId: child.componentKey,
+      description: child.description,
+      required: child.required,
+      accepts: child.accepts,
+      visibility: child.subcomponentVisibility === "internal" ? "internal" : "public"
+    })),
+    guidance: {
+      when: component.usageGuidance ? [component.usageGuidance] : [],
+      whenNot: component.donts ?? [],
+      guidelines: component.usageGuidance ? [component.usageGuidance] : [],
+      accessibility: [],
+      usageGuidance: component.usageGuidance,
+      dos: component.dos ?? [],
+      donts: component.donts ?? [],
+      patterns: []
+    },
+    sourceType: "cloud",
+    sourcePath: component.sourcePath,
+    sourceRepoFullName: component.sourceRepoFullName ?? void 0,
+    packageName: designSystem?.packageName ?? void 0,
+    importPath: designSystem?.importPath ?? designSystem?.packageName ?? void 0,
+    publicRef: component.publicRef,
+    publicSlug: component.publicSlug ?? null,
+    isCanonical: component.isCanonical ?? false,
+    tier: component.tier,
+    parentComponentId: component.parentComponentKey,
+    parentComponentName: component.parentComponentName,
+    metadata: {
+      a11yRules: [],
+      scenarioTags: []
+    }
+  };
+}
+var CloudCatalogAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  name = "cloud";
+  async load(_projectRoot) {
+    const response = await fetch(normalizeCatalogUrl(this.options.url), {
+      headers: {
+        "X-API-Key": this.options.apiKey
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to load Cloud catalog (${response.status} ${response.statusText}).`
+      );
+    }
+    const raw = await response.json();
+    const components = Object.fromEntries(
+      (raw.components ?? []).map((component) => [
+        component.componentKey,
+        mapComponent(component, raw.designSystem)
+      ])
+    );
+    const tokens = raw.tokens?.flat ? groupTokens(raw.tokens.flat) : void 0;
+    const packageName = raw.designSystem?.packageName ?? void 0;
+    const importPath = raw.designSystem?.importPath ?? raw.designSystem?.packageName ?? void 0;
+    const packageMap = packageName ? Object.fromEntries(
+      Object.values(components).map((component) => [
+        component.name,
+        packageName
+      ])
+    ) : {};
+    const snapshot = validateSnapshot({
+      schemaVersion: 1,
+      sourceType: "cloud",
+      sourceLabel: "Fragments Cloud catalog",
+      capabilities: buildCapabilities({
+        components,
+        tokens
+      }),
+      metadata: {
+        designSystemName: raw.designSystem?.name ?? raw.org.name,
+        packageName,
+        importPath,
+        revision: raw.revision,
+        updatedAt: typeof raw.updatedAt === "number" ? new Date(raw.updatedAt).toISOString() : void 0
+      },
+      components,
+      tokens,
+      packageMap,
+      defaultPackageName: packageName
+    });
+    const hydratedComponents = Object.fromEntries(
+      Object.entries(snapshot.components).map(([componentId, component]) => [
+        componentId,
+        {
+          ...component,
+          isCanonical: components[componentId]?.isCanonical ?? false
+        }
+      ])
+    );
+    return {
+      snapshot: {
+        ...snapshot,
+        components: hydratedComponents
+      },
+      components: hydratedComponents,
+      blocks: snapshot.blocks,
+      tokens: snapshot.tokens,
+      graph: void 0,
+      performanceSummary: void 0,
+      packageMap: snapshot.packageMap,
+      defaultPackageName: snapshot.defaultPackageName,
+      capabilities: new Set(snapshot.capabilities)
+    };
+  }
+};
+
+// src/adapters/bundle.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve2 } from "path";
+import {
+  bundleComponentShardSchema,
+  bundleManifestSchema,
+  bundleTokenFileSchema
+} from "@fragments-sdk/core";
+async function readJsonFile(path, parser, label) {
+  const content = await readFile2(path, "utf-8");
+  try {
+    return parser.parse(JSON.parse(content));
+  } catch (error) {
+    throw new Error(
+      `Invalid ${label} at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function normalizeProps(props) {
+  return Object.fromEntries(
+    Object.entries(props ?? {}).map(([propName, value]) => {
+      const prop = value && typeof value === "object" ? value : {};
+      return [
+        propName,
+        {
+          type: typeof prop.type === "string" && prop.type.length > 0 ? prop.type : "unknown",
+          description: typeof prop.description === "string" ? prop.description : "",
+          required: Boolean(prop.required),
+          default: prop.default,
+          values: Array.isArray(prop.values) ? prop.values.filter((entry) => typeof entry === "string") : void 0,
+          constraints: Array.isArray(prop.constraints) ? prop.constraints.filter(
+            (entry) => typeof entry === "string"
+          ) : void 0
+        }
+      ];
+    })
+  );
+}
+function normalizeExamples(examples) {
+  return examples.map((example) => {
+    const record = example && typeof example === "object" ? example : {};
+    return {
+      name: typeof record.title === "string" && record.title || typeof record.name === "string" && record.name || "Example",
+      description: typeof record.description === "string" ? record.description : void 0,
+      code: typeof record.code === "string" ? record.code : void 0,
+      kind: typeof record.kind === "string" ? record.kind : void 0
+    };
+  });
+}
+function normalizeRelations(relations, fallback) {
+  if (relations.length > 0) {
+    return relations.map((relation) => {
+      const record = relation && typeof relation === "object" ? relation : {};
+      return {
+        componentName: typeof record.component === "string" && record.component || typeof record.name === "string" && record.name || typeof record.componentName === "string" && record.componentName || typeof record.componentId === "string" && record.componentId || "Unknown",
+        componentId: typeof record.componentId === "string" ? record.componentId : void 0,
+        relationship: typeof record.relationship === "string" && record.relationship || typeof record.type === "string" && record.type || "related",
+        note: typeof record.note === "string" ? record.note : void 0,
+        description: typeof record.description === "string" ? record.description : void 0
+      };
+    });
+  }
+  return fallback.map((relation) => ({
+    componentName: relation.name,
+    componentId: relation.componentId,
+    relationship: relation.type
+  }));
+}
+function buildComponent(manifest, entry, shard) {
+  const sourcePackage = manifest.designSystem.importPath ?? manifest.designSystem.packageName ?? void 0;
+  const component = shard.component;
+  const componentRecord = component;
+  const props = normalizeProps(component.props);
+  return {
+    id: shard.componentId,
+    name: component.name,
+    description: component.description,
+    category: component.category,
+    status: component.status,
+    tags: [],
+    props,
+    propsSummary: Object.entries(props).map(
+      ([propName, prop]) => `${propName}${prop.required ? " (required)" : ""}: ${prop.type}`
+    ),
+    examples: normalizeExamples(component.examples),
+    relations: normalizeRelations(component.relations, entry.relations),
+    compoundChildren: entry.compoundChildren.map((child) => ({
+      name: child.name,
+      componentId: child.componentId,
+      visibility: "public"
+    })),
+    guidance: {
+      when: component.usageGuidance ? [component.usageGuidance] : [],
+      whenNot: component.donts,
+      guidelines: component.usageGuidance ? [component.usageGuidance] : [],
+      accessibility: [],
+      usageGuidance: component.usageGuidance || void 0,
+      dos: component.dos,
+      donts: component.donts,
+      patterns: []
+    },
+    sourceType: "bundle",
+    sourcePath: component.sourcePath,
+    sourceRepoFullName: component.sourceRepoFullName,
+    packageName: manifest.designSystem.packageName ?? void 0,
+    importPath: sourcePackage,
+    publicRef: component.publicRef,
+    publicSlug: component.publicSlug,
+    isCanonical: componentRecord.isCanonical ?? component.tier === "core",
+    tier: component.tier,
+    parentComponentName: component.parentComponentName,
+    metadata: {
+      a11yRules: [],
+      scenarioTags: []
+    }
+  };
+}
+var BundleAdapter = class {
+  name = "bundle";
+  discover(startDir) {
+    return findBundleManifest(startDir);
+  }
+  async load(projectRoot) {
+    const manifests = this.discover(projectRoot);
+    if (manifests.length === 0) {
+      throw new Error(
+        `No ${BRAND.dataDir}/${BRAND.manifestFile} found. Run \`${BRAND.cliCommand} context install --cloud\` or commit a Fragments bundle into your workspace.`
+      );
+    }
+    const manifestPath = manifests[0];
+    const manifest = await readJsonFile(
+      manifestPath,
+      bundleManifestSchema,
+      "bundle manifest"
+    );
+    const bundleDir = dirname3(manifestPath);
+    const repoRoot = dirname3(bundleDir);
+    const tokensPath = resolve2(bundleDir, "tokens.json");
+    const tokensFile = existsSync7(tokensPath) ? await readJsonFile(tokensPath, bundleTokenFileSchema, "bundle tokens") : void 0;
+    const components = Object.fromEntries(
+      await Promise.all(
+        Object.values(manifest.components).map(async (entry) => {
+          const shardPath = resolve2(repoRoot, entry.file);
+          const shard = await readJsonFile(
+            shardPath,
+            bundleComponentShardSchema,
+            `bundle component shard (${entry.name})`
+          );
+          return [entry.componentId, buildComponent(manifest, entry, shard)];
+        })
+      )
+    );
+    const packageName = manifest.designSystem.importPath ?? manifest.designSystem.packageName ?? void 0;
+    const packageMap = packageName ? Object.fromEntries(
+      Object.values(components).map((component) => [component.name, packageName])
+    ) : {};
+    const tokens = tokensFile ? {
+      prefix: "",
+      total: tokensFile.flat.length,
+      categories: Object.fromEntries(
+        Object.entries(tokensFile.categories).map(([category, value]) => [
+          category,
+          value.tokens.map((token) => ({
+            name: token.name,
+            category: token.category,
+            value: token.value,
+            description: token.description,
+            path: token.path,
+            type: token.type
+          }))
+        ])
+      ),
+      flat: tokensFile.flat.map((token) => ({
+        name: token.name,
+        category: token.category,
+        value: token.value,
+        description: token.description,
+        path: token.path,
+        type: token.type
+      }))
+    } : void 0;
+    const snapshot = validateSnapshot({
+      schemaVersion: 1,
+      sourceType: "bundle",
+      sourceLabel: `${BRAND.dataDir}/${BRAND.manifestFile}`,
+      capabilities: buildCapabilities({
+        components,
+        tokens
+      }),
+      metadata: {
+        designSystemName: manifest.designSystem.name,
+        packageName: manifest.designSystem.packageName ?? void 0,
+        importPath: manifest.designSystem.importPath ?? void 0,
+        revision: manifest.catalogRevision,
+        updatedAt: manifest.catalogUpdatedAt
+      },
+      components,
+      tokens,
+      packageMap,
+      defaultPackageName: packageName
+    });
+    const hydratedComponents = Object.fromEntries(
+      Object.entries(snapshot.components).map(([componentId, component]) => [
+        componentId,
+        {
+          ...component,
+          isCanonical: components[componentId]?.isCanonical ?? component.tier === "core"
+        }
+      ])
+    );
+    return {
+      snapshot: {
+        ...snapshot,
+        components: hydratedComponents
+      },
+      components: hydratedComponents,
+      blocks: snapshot.blocks,
+      tokens: snapshot.tokens,
+      graph: snapshot.graph,
+      performanceSummary: snapshot.performanceSummary,
+      packageMap: snapshot.packageMap,
+      defaultPackageName: snapshot.defaultPackageName,
+      capabilities: new Set(snapshot.capabilities)
+    };
+  }
+};
+
+// src/source-selection.ts
+function resolveCloudApiKey(config, fileConfig) {
+  return config.cloudApiKey ?? fileConfig?.cloud?.apiKey ?? process.env.FRAGMENTS_API_KEY;
+}
+function resolveCloudUrl(fileConfig) {
+  return fileConfig?.cloud?.url ?? process.env.FRAGMENTS_CLOUD_URL;
+}
+function hasTsProject(projectRoot) {
+  return existsSync8(join7(projectRoot, "tsconfig.json")) || existsSync8(join7(projectRoot, "tsconfig.app.json"));
+}
+function resolveDataAdapter(config, fileConfig) {
+  const source = config.source ?? fileConfig?.source ?? "auto";
+  const fragmentsJsonPaths = findFragmentsJson(config.projectRoot);
+  const bundleManifestPaths = findBundleManifest(config.projectRoot);
+  const cloudApiKey = resolveCloudApiKey(config, fileConfig);
+  const cloudUrl = resolveCloudUrl(fileConfig);
+  switch (source) {
+    case "fragments-json":
+      return { adapter: new FragmentsJsonAdapter(), mode: "fragments-json" };
+    case "cloud":
+      if (!cloudApiKey) {
+        throw new Error(
+          "Cloud source requires a Cloud API key. Set FRAGMENTS_API_KEY or pass cloudApiKey."
+        );
+      }
+      return {
+        adapter: new CloudCatalogAdapter({ apiKey: cloudApiKey, url: cloudUrl }),
+        mode: "cloud"
+      };
+    case "bundle":
+      return { adapter: new BundleAdapter(), mode: "bundle" };
+    case "extract":
+      return { adapter: new AutoExtractionAdapter(), mode: "extract" };
+    case "auto":
+    default:
+      if (fragmentsJsonPaths.length > 0) {
+        return {
+          adapter: new FragmentsJsonAdapter(),
+          mode: "fragments-json"
+        };
+      }
+      if (cloudApiKey) {
+        return {
+          adapter: new CloudCatalogAdapter({
+            apiKey: cloudApiKey,
+            url: cloudUrl
+          }),
+          mode: "cloud"
+        };
+      }
+      if (bundleManifestPaths.length > 0) {
+        return {
+          adapter: new BundleAdapter(),
+          mode: "bundle"
+        };
+      }
+      if (hasTsProject(config.projectRoot)) {
+        return { adapter: new AutoExtractionAdapter(), mode: "extract" };
+      }
+      return {
+        adapter: new FragmentsJsonAdapter(),
+        mode: "fragments-json"
+      };
+  }
+}
+function resolveSearchApiKey(config, fileConfig) {
+  return config.searchApiKey ?? config.apiKey ?? fileConfig?.vectorSearch?.apiKey;
+}
+
+// src/server.ts
+var TOOL_NAMES = buildToolNames();
+var TOOLS = buildMcpTools();
+var TOOL_DEFINITION_BY_KEY = new Map(
+  MCP_TOOL_DEFINITIONS.map((definition) => [definition.key, definition])
+);
+function createMcpServer(config) {
+  const server = new Server(
+    {
+      name: `${BRAND.nameLower}-mcp`,
+      version: MCP_SERVER_VERSION
+    },
+    {
+      capabilities: {
+        tools: { listChanged: true }
+      }
+    }
+  );
+  const registry = new ToolRegistry("", {
+    onChanged: () => {
+      server.notification({ method: "notifications/tools/list_changed", params: {} });
+    }
+  });
+  registry.registerBuiltins(
+    { core: CORE_TOOLS, viewer: VIEWER_TOOLS, infra: INFRA_TOOLS },
+    MCP_TOOL_DEFINITIONS,
+    TOOL_CAPABILITIES
+  );
+  const fileConfig = config.fileConfig ?? loadConfigFile(config.projectRoot) ?? void 0;
+  const mergedConfig = {
+    ...fileConfig ? { ...config, fileConfig } : config,
+    searchApiKey: resolveSearchApiKey(config, fileConfig)
+  };
+  const adapter = config.adapter ?? resolveDataAdapter(mergedConfig, fileConfig).adapter;
+  config.onRegistry?.(registry);
+  if (fileConfig?.tools?.exclude) {
+    for (const key of fileConfig.tools.exclude) {
+      registry.unregister(key);
+    }
+  }
+  let cachedData = null;
+  let loadDataPromise = null;
+  let resolvedRoot = null;
+  let resolveProjectRootPromise = null;
+  let componentIndex = null;
+  let blockIndex = null;
+  let tokenIndex = null;
+  async function resolveProjectRoot() {
+    if (resolvedRoot) return resolvedRoot;
+    if (resolveProjectRootPromise) return resolveProjectRootPromise;
+    resolveProjectRootPromise = (async () => {
+      try {
+        const result = await server.listRoots();
+        if (result.roots?.length > 0) {
+          const rootUri = result.roots[0].uri;
+          resolvedRoot = fileURLToPath(rootUri);
+          return resolvedRoot;
+        }
+      } catch {
+      }
+      resolvedRoot = config.projectRoot;
+      return resolvedRoot;
+    })();
+    try {
+      return await resolveProjectRootPromise;
+    } finally {
+      resolveProjectRootPromise = null;
+    }
+  }
+  async function loadData() {
+    if (cachedData) return cachedData;
+    if (loadDataPromise) return loadDataPromise;
+    loadDataPromise = (async () => {
+      const projectRoot = await resolveProjectRoot();
+      const loaded = await adapter.load(projectRoot);
+      const allFragments = Object.values(loaded.components);
+      const allBlocks = Object.values(loaded.blocks ?? {});
+      componentIndex = buildComponentIndex(allFragments);
+      blockIndex = allBlocks.length > 0 ? buildBlockIndex(allBlocks) : null;
+      tokenIndex = loaded.tokens && loaded.tokens.total > 0 ? buildTokenIndex(loaded.tokens) : null;
+      cachedData = loaded;
+      return loaded;
+    })();
+    try {
+      return await loadDataPromise;
+    } finally {
+      loadDataPromise = null;
+    }
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const data = await loadData();
+    return {
+      tools: registry.listTools(
+        {
+          hasViewer: !!config.viewerUrl,
+          hasPlayground: !!(config.playgroundUrl ?? fileConfig?.playgroundUrl),
+          capabilities: data.capabilities
+        },
+        TOOLS
+      )
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const data = await loadData();
+    const toolContext = {
+      data,
+      config: mergedConfig,
+      indexes: { componentIndex, blockIndex, tokenIndex },
+      resolvePackageName: (name2) => {
+        if (name2) {
+          const pkg = data.packageMap[name2];
+          if (pkg) return pkg;
+        }
+        if (data.defaultPackageName) return data.defaultPackageName;
+        const root = resolvedRoot ?? config.projectRoot;
+        const packageJsonPath = join8(root, "package.json");
+        if (existsSync9(packageJsonPath)) {
+          try {
+            const content = readFileSync6(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.name) {
+              return pkg.name;
+            }
+          } catch {
+          }
+        }
+        return "your-component-library";
+      },
+      toolNames: TOOL_NAMES
+    };
+    try {
+      const toolKey = registry.resolveKey(name);
+      const definition = TOOL_DEFINITION_BY_KEY.get(toolKey);
+      const argumentKeys = Object.keys(args ?? {});
+      const allowedKeys = new Set(Object.keys(definition?.params ?? {}));
+      const unknownKeys = definition ? argumentKeys.filter((key) => !allowedKeys.has(key)) : [];
+      if (unknownKeys.length > 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Unknown argument(s) for ${toolKey}: ${unknownKeys.join(", ")}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const mCtx = {
+        toolName: name,
+        toolKey,
+        args: args ?? {},
+        ctx: toolContext
+      };
+      return await executeWithMiddleware(
+        config.middleware ?? [],
+        mCtx,
+        () => registry.execute(name, args ?? {}, toolContext)
+      );
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }) }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function startMcpServer(config) {
+  const server = createMcpServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function createSandboxServer() {
+  return createMcpServer({ projectRoot: process.cwd() });
+}
+
+export {
+  loadConfigFile,
+  SYNONYM_MAP,
+  USE_CASE_TOKEN_CATEGORIES,
+  MINIMUM_SCORE_THRESHOLD,
+  BLOCK_BOOST_PER_OCCURRENCE,
+  DEFAULT_ENDPOINTS,
+  CORE_TOOLS,
+  VIEWER_TOOLS,
+  INFRA_TOOLS,
+  BUILTIN_TOOLS,
+  ToolRegistry,
+  executeWithMiddleware,
+  telemetryMiddleware,
+  componentFromCompiledFragment,
+  blockFromCompiledBlock,
+  tokensFromCompiledTokenData,
+  buildCapabilities,
+  validateSnapshot,
+  FragmentsJsonAdapter,
+  AutoExtractionAdapter,
+  resolveDataAdapter,
+  resolveSearchApiKey,
+  createMcpServer,
+  startMcpServer,
+  createSandboxServer
+};
+//# sourceMappingURL=chunk-HGGAXLRO.js.map