@fragments-sdk/cli 0.15.10 → 0.17.0

package/dist/{chunk-32LIWN2P.js → chunk-FFCI6OVZ.js}

@@ -2,6 +2,8 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 
 // ../core/dist/index.js
 import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import { createElement } from "react";
 import {
   toId as storybookToId,
@@ -9,8 +11,8 @@ import {
   isExportStory as storybookIsExportStory
 } from "@storybook/csf";
 import { generateContext, filterPlaceholders, PLACEHOLDER_PATTERNS } from "@fragments-sdk/context/generate";
-import { z as z2 } from "zod";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import { ComponentGraphEngine } from "@fragments-sdk/context/graph";
 import { useEffect, useState } from "react";
 import { Fragment, jsx } from "react/jsx-runtime";
@@ -136,6 +138,301 @@ function budgetBar(percent, width = 20) {
   const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
   return percent > 100 ? `\x1B[31m${bar}\x1B[0m` : `\x1B[32m${bar}\x1B[0m`;
 }
+var bundleSchemaVersionSchema = z.literal(1);
+var bundleTargetSchema = z.enum([
+  "cursor",
+  "agents",
+  "claude",
+  "copilot"
+]);
+var bundleArtifactMetadataSchema = z.object({
+  kind: z.enum([
+    "manifest",
+    "tokens",
+    "design-system",
+    "readme",
+    "helper",
+    "component"
+  ]),
+  key: z.string().min(1),
+  label: z.string().min(1),
+  path: z.string().min(1),
+  etag: z.string().min(1),
+  updatedAt: z.string().datetime(),
+  target: bundleTargetSchema.optional(),
+  componentId: z.string().optional(),
+  contentType: z.enum(["application/json", "text/markdown"])
+});
+var bundleManifestRelationSchema = z.object({
+  type: z.string().min(1),
+  componentId: z.string().min(1),
+  name: z.string().min(1)
+});
+var bundleManifestCompoundChildSchema = z.object({
+  componentId: z.string().min(1),
+  name: z.string().min(1)
+});
+var bundleManifestComponentEntrySchema = z.object({
+  componentId: z.string().min(1),
+  file: z.string().min(1),
+  name: z.string().min(1),
+  publicSlug: z.string().nullable(),
+  tier: z.enum(["core", "composition"]),
+  category: z.string().min(1),
+  status: z.string().min(1),
+  description: z.string(),
+  propCount: z.number().int().nonnegative(),
+  hasExamples: z.boolean(),
+  hasCompoundChildren: z.boolean(),
+  relations: z.array(bundleManifestRelationSchema),
+  compoundChildren: z.array(bundleManifestCompoundChildSchema)
+});
+var bundleManifestSchema = z.object({
+  schemaVersion: bundleSchemaVersionSchema,
+  catalogRevision: z.string().min(1),
+  catalogUpdatedAt: z.string().datetime(),
+  org: z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    slug: z.string().min(1)
+  }),
+  designSystem: z.object({
+    name: z.string().min(1),
+    packageName: z.string().nullable(),
+    importPath: z.string().nullable()
+  }),
+  sourceBinding: z.object({
+    bindingId: z.string().min(1),
+    projectId: z.string().min(1),
+    projectName: z.string().min(1),
+    repoFullName: z.string().min(1),
+    resolution: z.enum(["explicit", "auto"])
+  }),
+  totalComponents: z.number().int().nonnegative(),
+  totalTokens: z.number().int().nonnegative(),
+  tokenCategories: z.record(z.string(), z.number().int().nonnegative()),
+  components: z.record(z.string(), bundleManifestComponentEntrySchema)
+});
+var bundleTokenEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.array(z.string().min(1)),
+  category: z.string().min(1),
+  value: z.string(),
+  type: z.string().optional(),
+  description: z.string().optional()
+});
+var bundleTokenFileSchema = z.object({
+  schemaVersion: bundleSchemaVersionSchema,
+  catalogRevision: z.string().min(1),
+  catalogUpdatedAt: z.string().datetime(),
+  categories: z.record(
+    z.string(),
+    z.object({
+      count: z.number().int().nonnegative(),
+      tokens: z.array(bundleTokenEntrySchema)
+    })
+  ),
+  flat: z.array(bundleTokenEntrySchema)
+});
+var bundleComponentShardSchema = z.object({
+  schemaVersion: bundleSchemaVersionSchema,
+  catalogRevision: z.string().min(1),
+  catalogUpdatedAt: z.string().datetime(),
+  componentId: z.string().min(1),
+  file: z.string().min(1),
+  component: z.object({
+    componentKey: z.string().min(1),
+    publicRef: z.string().min(1),
+    publicId: z.string().nullable(),
+    publicSlug: z.string().nullable(),
+    isCanonical: z.boolean().optional(),
+    name: z.string().min(1),
+    tier: z.enum(["core", "composition"]),
+    category: z.string().min(1),
+    status: z.string().min(1),
+    description: z.string(),
+    usageGuidance: z.string(),
+    dos: z.array(z.string()),
+    donts: z.array(z.string()),
+    props: z.record(z.string(), z.unknown()),
+    relations: z.array(z.record(z.string(), z.unknown())),
+    compoundChildren: z.array(bundleManifestCompoundChildSchema),
+    examples: z.array(z.record(z.string(), z.unknown())),
+    source: z.literal("design-system"),
+    sourcePath: z.string().optional(),
+    sourceRepoFullName: z.string().optional(),
+    parentComponentName: z.string().optional(),
+    parentComponentKey: z.string().optional()
+  })
+});
+var mcpSnapshotSchemaVersionSchema = z2.literal(1);
+var mcpSourceTypeSchema = z2.enum([
+  "fragments-json",
+  "cloud",
+  "auto-extract",
+  "custom-json",
+  "bundle"
+]);
+var mcpCapabilitySchema = z2.enum([
+  "components",
+  "tokens",
+  "blocks",
+  "graph",
+  "performance"
+]);
+var mcpPerformanceImportSchema = z2.object({
+  path: z2.string().min(1),
+  bytes: z2.number().nonnegative(),
+  percent: z2.number().nonnegative()
+});
+var mcpPerformanceDataSchema = z2.object({
+  bundleSize: z2.number().nonnegative(),
+  rawSize: z2.number().nonnegative(),
+  complexity: z2.enum(["lightweight", "moderate", "heavy"]),
+  budgetPercent: z2.number().nonnegative(),
+  overBudget: z2.boolean(),
+  measuredAt: z2.string().datetime(),
+  imports: z2.array(mcpPerformanceImportSchema).optional()
+});
+var mcpPerformanceSummarySchema = z2.object({
+  preset: z2.string().min(1),
+  budget: z2.number().nonnegative(),
+  total: z2.number().int().nonnegative(),
+  overBudget: z2.number().int().nonnegative(),
+  tiers: z2.record(
+    z2.enum(["lightweight", "moderate", "heavy"]),
+    z2.number().int().nonnegative()
+  )
+});
+var mcpComponentPropSchema = z2.object({
+  type: z2.string().min(1),
+  description: z2.string().default(""),
+  required: z2.boolean().default(false),
+  default: z2.unknown().optional(),
+  values: z2.array(z2.string()).optional(),
+  constraints: z2.array(z2.string()).optional()
+});
+var mcpComponentExampleSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().optional(),
+  code: z2.string().optional(),
+  kind: z2.string().optional()
+});
+var mcpComponentRelationSchema = z2.object({
+  componentName: z2.string().min(1),
+  componentId: z2.string().optional(),
+  relationship: z2.string().min(1),
+  note: z2.string().optional(),
+  description: z2.string().optional()
+});
+var mcpCompoundChildSchema = z2.object({
+  name: z2.string().min(1),
+  componentId: z2.string().optional(),
+  description: z2.string().optional(),
+  required: z2.boolean().optional(),
+  accepts: z2.array(z2.string()).optional(),
+  visibility: z2.enum(["public", "internal"]).optional()
+});
+var mcpGuidancePatternSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().optional()
+});
+var mcpComponentGuidanceSchema = z2.object({
+  when: z2.array(z2.string()).default([]),
+  whenNot: z2.array(z2.string()).default([]),
+  guidelines: z2.array(z2.string()).default([]),
+  accessibility: z2.array(z2.string()).default([]),
+  usageGuidance: z2.string().optional(),
+  dos: z2.array(z2.string()).default([]),
+  donts: z2.array(z2.string()).default([]),
+  patterns: z2.array(mcpGuidancePatternSchema).default([])
+});
+var mcpComponentMetadataSchema = z2.object({
+  a11yRules: z2.array(z2.string()).default([]),
+  scenarioTags: z2.array(z2.string()).default([])
+});
+var mcpComponentSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string().default(""),
+  category: z2.string().default("uncategorized"),
+  status: z2.string().default("stable"),
+  tags: z2.array(z2.string()).default([]),
+  props: z2.record(z2.string(), mcpComponentPropSchema).default({}),
+  propsSummary: z2.array(z2.string()).default([]),
+  examples: z2.array(mcpComponentExampleSchema).default([]),
+  relations: z2.array(mcpComponentRelationSchema).default([]),
+  compoundChildren: z2.array(mcpCompoundChildSchema).default([]),
+  guidance: mcpComponentGuidanceSchema.default({
+    when: [],
+    whenNot: [],
+    guidelines: [],
+    accessibility: [],
+    dos: [],
+    donts: [],
+    patterns: []
+  }),
+  sourceType: mcpSourceTypeSchema,
+  sourcePath: z2.string().optional(),
+  sourceRepoFullName: z2.string().optional(),
+  packageName: z2.string().optional(),
+  importPath: z2.string().optional(),
+  publicRef: z2.string().optional(),
+  publicSlug: z2.string().nullable().optional(),
+  isCanonical: z2.boolean().optional(),
+  tier: z2.string().optional(),
+  parentComponentId: z2.string().optional(),
+  parentComponentName: z2.string().optional(),
+  performance: mcpPerformanceDataSchema.optional(),
+  metadata: mcpComponentMetadataSchema.default({
+    a11yRules: [],
+    scenarioTags: []
+  })
+});
+var mcpBlockSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string().default(""),
+  category: z2.string().default("uncategorized"),
+  components: z2.array(z2.string()).default([]),
+  tags: z2.array(z2.string()).default([]),
+  code: z2.string().default("")
+});
+var mcpTokenSchema = z2.object({
+  name: z2.string().min(1),
+  category: z2.string().min(1),
+  value: z2.string().optional(),
+  description: z2.string().optional(),
+  path: z2.array(z2.string()).optional(),
+  type: z2.string().optional()
+});
+var mcpTokenDataSchema = z2.object({
+  prefix: z2.string(),
+  total: z2.number().int().nonnegative(),
+  categories: z2.record(z2.string(), z2.array(mcpTokenSchema)),
+  flat: z2.array(mcpTokenSchema).default([])
+});
+var mcpSnapshotMetadataSchema = z2.object({
+  designSystemName: z2.string().optional(),
+  packageName: z2.string().optional(),
+  importPath: z2.string().optional(),
+  revision: z2.string().optional(),
+  updatedAt: z2.string().optional()
+});
+var mcpSnapshotSchema = z2.object({
+  schemaVersion: mcpSnapshotSchemaVersionSchema,
+  sourceType: mcpSourceTypeSchema,
+  sourceLabel: z2.string().min(1),
+  capabilities: z2.array(mcpCapabilitySchema),
+  metadata: mcpSnapshotMetadataSchema.default({}),
+  components: z2.record(z2.string(), mcpComponentSchema),
+  blocks: z2.record(z2.string(), mcpBlockSchema).optional(),
+  tokens: mcpTokenDataSchema.optional(),
+  graph: z2.unknown().optional(),
+  performanceSummary: mcpPerformanceSummarySchema.optional(),
+  packageMap: z2.record(z2.string(), z2.string()).default({}),
+  defaultPackageName: z2.string().optional()
+});
 var COLOR_PROPERTIES = /* @__PURE__ */ new Set(["backgroundColor", "borderColor", "color"]);
 var NUMERIC_PROPERTIES = /* @__PURE__ */ new Set([
   "borderWidth",
@@ -345,33 +642,33 @@ function getComplianceBadge(compliancePercent) {
     return { label: "Poor", color: "red" };
   }
 }
-var figmaStringMappingSchema = z.object({
-  __type: z.literal("figma-string"),
-  figmaProperty: z.string().min(1)
+var figmaStringMappingSchema = z3.object({
+  __type: z3.literal("figma-string"),
+  figmaProperty: z3.string().min(1)
 });
-var figmaBooleanMappingSchema = z.object({
-  __type: z.literal("figma-boolean"),
-  figmaProperty: z.string().min(1),
-  valueMapping: z.object({ true: z.unknown(), false: z.unknown() }).optional()
+var figmaBooleanMappingSchema = z3.object({
+  __type: z3.literal("figma-boolean"),
+  figmaProperty: z3.string().min(1),
+  valueMapping: z3.object({ true: z3.unknown(), false: z3.unknown() }).optional()
 });
-var figmaEnumMappingSchema = z.object({
-  __type: z.literal("figma-enum"),
-  figmaProperty: z.string().min(1),
-  valueMapping: z.record(z.unknown())
+var figmaEnumMappingSchema = z3.object({
+  __type: z3.literal("figma-enum"),
+  figmaProperty: z3.string().min(1),
+  valueMapping: z3.record(z3.unknown())
 });
-var figmaInstanceMappingSchema = z.object({
-  __type: z.literal("figma-instance"),
-  figmaProperty: z.string().min(1)
+var figmaInstanceMappingSchema = z3.object({
+  __type: z3.literal("figma-instance"),
+  figmaProperty: z3.string().min(1)
 });
-var figmaChildrenMappingSchema = z.object({
-  __type: z.literal("figma-children"),
-  layers: z.array(z.string().min(1))
+var figmaChildrenMappingSchema = z3.object({
+  __type: z3.literal("figma-children"),
+  layers: z3.array(z3.string().min(1))
 });
-var figmaTextContentMappingSchema = z.object({
-  __type: z.literal("figma-text-content"),
-  layer: z.string().min(1)
+var figmaTextContentMappingSchema = z3.object({
+  __type: z3.literal("figma-text-content"),
+  layer: z3.string().min(1)
 });
-var figmaPropMappingSchema = z.discriminatedUnion("__type", [
+var figmaPropMappingSchema = z3.discriminatedUnion("__type", [
   figmaStringMappingSchema,
   figmaBooleanMappingSchema,
   figmaEnumMappingSchema,
@@ -379,28 +676,28 @@ var figmaPropMappingSchema = z.discriminatedUnion("__type", [
   figmaChildrenMappingSchema,
   figmaTextContentMappingSchema
 ]);
-var fragmentMetaSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1),
-  category: z.string().min(1),
-  tags: z.array(z.string()).optional(),
-  status: z.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
-  since: z.string().optional(),
-  dependencies: z.array(z.object({
-    name: z.string().min(1),
-    version: z.string().min(1),
-    reason: z.string().optional()
+var fragmentMetaSchema = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().min(1),
+  category: z3.string().min(1),
+  tags: z3.array(z3.string()).optional(),
+  status: z3.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
+  since: z3.string().optional(),
+  dependencies: z3.array(z3.object({
+    name: z3.string().min(1),
+    version: z3.string().min(1),
+    reason: z3.string().optional()
   })).optional(),
-  figma: z.string().url().optional(),
-  figmaProps: z.record(figmaPropMappingSchema).optional()
+  figma: z3.string().url().optional(),
+  figmaProps: z3.record(figmaPropMappingSchema).optional()
 });
-var fragmentUsageSchema = z.object({
-  when: z.array(z.string()),
-  whenNot: z.array(z.string()),
-  guidelines: z.array(z.string()).optional(),
-  accessibility: z.array(z.string()).optional()
+var fragmentUsageSchema = z3.object({
+  when: z3.array(z3.string()),
+  whenNot: z3.array(z3.string()),
+  guidelines: z3.array(z3.string()).optional(),
+  accessibility: z3.array(z3.string()).optional()
 });
-var propTypeSchema = z.enum([
+var propTypeSchema = z3.enum([
   "string",
   "number",
   "boolean",
@@ -413,16 +710,16 @@ var propTypeSchema = z.enum([
   "union",
   "custom"
 ]);
-var propDefinitionSchema = z.object({
+var propDefinitionSchema = z3.object({
   type: propTypeSchema,
-  values: z.array(z.string()).readonly().optional(),
-  default: z.unknown().optional(),
-  description: z.string().optional(),
-  required: z.boolean().optional(),
-  constraints: z.array(z.string()).optional(),
-  typeDetails: z.record(z.unknown()).optional()
+  values: z3.array(z3.string()).readonly().optional(),
+  default: z3.unknown().optional(),
+  description: z3.string().optional(),
+  required: z3.boolean().optional(),
+  constraints: z3.array(z3.string()).optional(),
+  typeDetails: z3.record(z3.unknown()).optional()
 });
-var relationshipTypeSchema = z.enum([
+var relationshipTypeSchema = z3.enum([
   "alternative",
   "sibling",
   "parent",
@@ -431,136 +728,136 @@ var relationshipTypeSchema = z.enum([
   "complementary",
   "used-by"
 ]);
-var componentRelationSchema = z.object({
-  component: z.string().min(1),
+var componentRelationSchema = z3.object({
+  component: z3.string().min(1),
   relationship: relationshipTypeSchema,
-  note: z.string().min(1)
+  note: z3.string().min(1)
 });
-var fragmentVariantSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1),
-  render: z.function().returns(z.unknown()),
-  code: z.string().optional(),
-  figma: z.string().url().optional()
+var fragmentVariantSchema = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().min(1),
+  render: z3.function().returns(z3.unknown()),
+  code: z3.string().optional(),
+  figma: z3.string().url().optional()
 });
-var fragmentBanSchema = z.object({
-  pattern: z.string().min(1),
-  message: z.string().min(1)
+var fragmentBanSchema = z3.object({
+  pattern: z3.string().min(1),
+  message: z3.string().min(1)
 });
-var fragmentContractSchema = z.object({
-  propsSummary: z.array(z.string()).optional(),
-  a11yRules: z.array(z.string()).optional(),
-  bans: z.array(fragmentBanSchema).optional(),
-  scenarioTags: z.array(z.string()).optional(),
-  performanceBudget: z.number().positive().optional(),
-  compoundChildren: z.record(z.object({
-    required: z.boolean().optional(),
-    accepts: z.array(z.string()).optional(),
-    description: z.string().optional()
+var fragmentContractSchema = z3.object({
+  propsSummary: z3.array(z3.string()).optional(),
+  a11yRules: z3.array(z3.string()).optional(),
+  bans: z3.array(fragmentBanSchema).optional(),
+  scenarioTags: z3.array(z3.string()).optional(),
+  performanceBudget: z3.number().positive().optional(),
+  compoundChildren: z3.record(z3.object({
+    required: z3.boolean().optional(),
+    accepts: z3.array(z3.string()).optional(),
+    description: z3.string().optional()
   })).optional(),
-  canonicalUsage: z.array(z.string()).optional()
+  canonicalUsage: z3.array(z3.string()).optional()
 });
-var fragmentGeneratedSchema = z.object({
-  source: z.enum(["storybook", "manual", "ai"]),
-  sourceFile: z.string().optional(),
-  confidence: z.number().min(0).max(1).optional(),
-  timestamp: z.string().datetime().optional()
+var fragmentGeneratedSchema = z3.object({
+  source: z3.enum(["storybook", "manual", "ai"]),
+  sourceFile: z3.string().optional(),
+  confidence: z3.number().min(0).max(1).optional(),
+  timestamp: z3.string().datetime().optional()
 });
-var aiMetadataSchema = z.object({
-  compositionPattern: z.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
-  subComponents: z.array(z.string()).optional(),
-  requiredChildren: z.array(z.string()).optional(),
-  commonPatterns: z.array(z.string()).optional()
+var aiMetadataSchema = z3.object({
+  compositionPattern: z3.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
+  subComponents: z3.array(z3.string()).optional(),
+  requiredChildren: z3.array(z3.string()).optional(),
+  commonPatterns: z3.array(z3.string()).optional()
 });
-var blockDefinitionSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1),
-  category: z.string().min(1),
-  components: z.array(z.string().min(1)).min(1),
-  code: z.string().min(1),
-  tags: z.array(z.string()).optional()
+var blockDefinitionSchema = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().min(1),
+  category: z3.string().min(1),
+  components: z3.array(z3.string().min(1)).min(1),
+  code: z3.string().min(1),
+  tags: z3.array(z3.string()).optional()
 });
-var fragmentDefinitionSchema = z.object({
-  component: z.any(),
+var fragmentDefinitionSchema = z3.object({
+  component: z3.any(),
   // Allow any component type (function, class, forwardRef, etc.)
   meta: fragmentMetaSchema,
   usage: fragmentUsageSchema,
-  props: z.record(propDefinitionSchema),
-  relations: z.array(componentRelationSchema).optional(),
-  variants: z.array(fragmentVariantSchema),
+  props: z3.record(propDefinitionSchema),
+  relations: z3.array(componentRelationSchema).optional(),
+  variants: z3.array(fragmentVariantSchema),
   // Allow empty variants array
   contract: fragmentContractSchema.optional(),
   ai: aiMetadataSchema.optional(),
   _generated: fragmentGeneratedSchema.optional()
 });
-var fragmentsConfigSchema = z.object({
-  include: z.array(z.string()).min(1),
-  exclude: z.array(z.string()).optional(),
-  components: z.array(z.string()).optional(),
-  outFile: z.string().optional(),
-  framework: z.enum(["react", "vue", "svelte"]).optional(),
-  figmaFile: z.string().url().optional(),
-  figmaToken: z.string().optional(),
-  screenshots: z.object({}).passthrough().optional(),
-  service: z.object({}).passthrough().optional(),
-  registry: z.object({}).passthrough().optional(),
-  tokens: z.object({
-    include: z.array(z.string()).min(1)
+var fragmentsConfigSchema = z3.object({
+  include: z3.array(z3.string()).min(1),
+  exclude: z3.array(z3.string()).optional(),
+  components: z3.array(z3.string()).optional(),
+  outFile: z3.string().optional(),
+  framework: z3.enum(["react", "vue", "svelte"]).optional(),
+  figmaFile: z3.string().url().optional(),
+  figmaToken: z3.string().optional(),
+  screenshots: z3.object({}).passthrough().optional(),
+  service: z3.object({}).passthrough().optional(),
+  registry: z3.object({}).passthrough().optional(),
+  tokens: z3.object({
+    include: z3.array(z3.string()).min(1)
   }).passthrough().optional(),
-  snippets: z.object({
-    mode: z.enum(["warn", "error"]).optional(),
-    scope: z.enum(["snippet", "snippet+render"]).optional(),
-    requireFullSnippet: z.boolean().optional(),
-    allowedExternalModules: z.array(z.string().min(1)).optional()
+  snippets: z3.object({
+    mode: z3.enum(["warn", "error"]).optional(),
+    scope: z3.enum(["snippet", "snippet+render"]).optional(),
+    requireFullSnippet: z3.boolean().optional(),
+    allowedExternalModules: z3.array(z3.string().min(1)).optional()
   }).optional(),
-  performance: z.union([
-    z.enum(["strict", "standard", "relaxed"]),
-    z.object({
-      preset: z.enum(["strict", "standard", "relaxed"]).optional(),
-      budgets: z.object({
-        bundleSize: z.number().positive().optional()
+  performance: z3.union([
+    z3.enum(["strict", "standard", "relaxed"]),
+    z3.object({
+      preset: z3.enum(["strict", "standard", "relaxed"]).optional(),
+      budgets: z3.object({
+        bundleSize: z3.number().positive().optional()
       }).optional()
     })
   ]).optional(),
-  storybook: z.object({
-    exclude: z.array(z.string()).optional(),
-    include: z.array(z.string()).optional(),
-    excludeDeprecated: z.boolean().optional(),
-    excludeTests: z.boolean().optional(),
-    excludeSvgIcons: z.boolean().optional(),
-    excludeSubComponents: z.boolean().optional()
+  storybook: z3.object({
+    exclude: z3.array(z3.string()).optional(),
+    include: z3.array(z3.string()).optional(),
+    excludeDeprecated: z3.boolean().optional(),
+    excludeTests: z3.boolean().optional(),
+    excludeSvgIcons: z3.boolean().optional(),
+    excludeSubComponents: z3.boolean().optional()
   }).optional(),
-  govern: z.object({
-    extends: z.array(z.string()).optional(),
-    rules: z.record(z.string(), z.unknown()).optional(),
-    agents: z.record(z.string(), z.object({
-      rules: z.record(z.string(), z.unknown()).optional()
+  govern: z3.object({
+    extends: z3.array(z3.string()).optional(),
+    rules: z3.record(z3.string(), z3.unknown()).optional(),
+    agents: z3.record(z3.string(), z3.object({
+      rules: z3.record(z3.string(), z3.unknown()).optional()
     })).optional(),
-    audit: z.object({}).passthrough().optional(),
-    runners: z.record(z.string(), z.object({}).passthrough()).optional()
+    audit: z3.object({}).passthrough().optional(),
+    runners: z3.record(z3.string(), z3.object({}).passthrough()).optional()
   }).optional()
 });
-var compositionMetadataSchema = z.object({
-  pattern: z.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
-  subComponents: z.array(z.string()).optional(),
-  requiredChildren: z.array(z.string()).optional(),
-  commonPatterns: z.array(z.string()).optional()
+var compositionMetadataSchema = z3.object({
+  pattern: z3.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
+  subComponents: z3.array(z3.string()).optional(),
+  requiredChildren: z3.array(z3.string()).optional(),
+  commonPatterns: z3.array(z3.string()).optional()
 });
-var fragmentProvenanceSchema = z.object({
-  source: z.enum(["storybook", "manual", "ai", "scan"]),
-  sourceFile: z.string().optional(),
-  confidence: z.number().min(0).max(1).optional(),
-  timestamp: z.string().datetime().optional(),
-  autoFields: z.array(z.string()).optional(),
-  humanFields: z.array(z.string()).optional()
+var fragmentProvenanceSchema = z3.object({
+  source: z3.enum(["storybook", "manual", "ai", "scan"]),
+  sourceFile: z3.string().optional(),
+  confidence: z3.number().min(0).max(1).optional(),
+  timestamp: z3.string().datetime().optional(),
+  autoFields: z3.array(z3.string()).optional(),
+  humanFields: z3.array(z3.string()).optional()
 });
-var fragmentDefinitionV2Schema = z.object({
-  component: z.any(),
+var fragmentDefinitionV2Schema = z3.object({
+  component: z3.any(),
   meta: fragmentMetaSchema,
   guidance: fragmentUsageSchema,
-  props: z.record(propDefinitionSchema),
-  relations: z.array(componentRelationSchema).optional(),
-  examples: z.array(fragmentVariantSchema),
+  props: z3.record(propDefinitionSchema),
+  relations: z3.array(componentRelationSchema).optional(),
+  examples: z3.array(fragmentVariantSchema),
   composition: compositionMetadataSchema.optional(),
   contract: fragmentContractSchema.optional(),
   _provenance: fragmentProvenanceSchema.optional()
@@ -1739,7 +2036,7 @@ function parseDTCGFile(content, filePath) {
     total: resolvedTokens.length
   };
 }
-var dtcgTokenTypeSchema = z2.enum([
+var dtcgTokenTypeSchema = z4.enum([
   "color",
   "dimension",
   "fontFamily",
@@ -1754,159 +2051,159 @@ var dtcgTokenTypeSchema = z2.enum([
   "gradient",
   "typography"
 ]);
-var dtcgColorValueSchema = z2.union([
-  z2.string(),
-  z2.object({
-    colorSpace: z2.string().default("srgb"),
-    components: z2.array(z2.number()),
-    hex: z2.string().optional(),
-    alpha: z2.number().optional()
+var dtcgColorValueSchema = z4.union([
+  z4.string(),
+  z4.object({
+    colorSpace: z4.string().default("srgb"),
+    components: z4.array(z4.number()),
+    hex: z4.string().optional(),
+    alpha: z4.number().optional()
   })
 ]);
-var dtcgDimensionValueSchema = z2.union([
-  z2.string(),
-  z2.object({
-    value: z2.number(),
-    unit: z2.enum(["px", "rem"])
+var dtcgDimensionValueSchema = z4.union([
+  z4.string(),
+  z4.object({
+    value: z4.number(),
+    unit: z4.enum(["px", "rem"])
   })
 ]);
-var dtcgShadowValueSchema = z2.object({
+var dtcgShadowValueSchema = z4.object({
   color: dtcgColorValueSchema,
   offsetX: dtcgDimensionValueSchema,
   offsetY: dtcgDimensionValueSchema,
   blur: dtcgDimensionValueSchema,
   spread: dtcgDimensionValueSchema.optional(),
-  inset: z2.boolean().optional()
+  inset: z4.boolean().optional()
 });
-var dtcgBorderValueSchema = z2.object({
+var dtcgBorderValueSchema = z4.object({
   color: dtcgColorValueSchema,
   width: dtcgDimensionValueSchema,
-  style: z2.string()
+  style: z4.string()
 });
-var dtcgTypographyValueSchema = z2.object({
-  fontFamily: z2.union([z2.string(), z2.array(z2.string())]),
+var dtcgTypographyValueSchema = z4.object({
+  fontFamily: z4.union([z4.string(), z4.array(z4.string())]),
   fontSize: dtcgDimensionValueSchema,
-  fontWeight: z2.union([z2.number(), z2.string()]),
+  fontWeight: z4.union([z4.number(), z4.string()]),
   letterSpacing: dtcgDimensionValueSchema.optional(),
-  lineHeight: z2.union([z2.string(), z2.number()]).optional()
+  lineHeight: z4.union([z4.string(), z4.number()]).optional()
 });
-var dtcgTransitionValueSchema = z2.object({
-  duration: z2.string(),
-  delay: z2.string().optional(),
-  timingFunction: z2.array(z2.number()).length(4)
+var dtcgTransitionValueSchema = z4.object({
+  duration: z4.string(),
+  delay: z4.string().optional(),
+  timingFunction: z4.array(z4.number()).length(4)
 });
-var dtcgGradientStopSchema = z2.object({
+var dtcgGradientStopSchema = z4.object({
   color: dtcgColorValueSchema,
-  position: z2.number()
+  position: z4.number()
 });
-var dtcgCubicBezierValueSchema = z2.tuple([
-  z2.number(),
-  z2.number(),
-  z2.number(),
-  z2.number()
+var dtcgCubicBezierValueSchema = z4.tuple([
+  z4.number(),
+  z4.number(),
+  z4.number(),
+  z4.number()
 ]);
-var dtcgTokenSchema = z2.object({
-  $value: z2.unknown(),
+var dtcgTokenSchema = z4.object({
+  $value: z4.unknown(),
   $type: dtcgTokenTypeSchema.optional(),
-  $description: z2.string().optional(),
-  $deprecated: z2.union([z2.boolean(), z2.string()]).optional(),
-  $extensions: z2.record(z2.string(), z2.unknown()).optional()
+  $description: z4.string().optional(),
+  $deprecated: z4.union([z4.boolean(), z4.string()]).optional(),
+  $extensions: z4.record(z4.string(), z4.unknown()).optional()
 }).passthrough();
-var dtcgTokenFileSchema = z2.record(z2.string(), z2.unknown()).refine(
+var dtcgTokenFileSchema = z4.record(z4.string(), z4.unknown()).refine(
   (data) => {
     return data !== null && typeof data === "object" && !Array.isArray(data);
   },
   { message: "DTCG token file must be a JSON object" }
 );
-var contractPropSchema = z3.object({
-  type: z3.string(),
-  values: z3.array(z3.string()).optional(),
-  default: z3.unknown().optional(),
-  description: z3.string(),
-  required: z3.boolean().optional(),
-  constraints: z3.array(z3.string()).optional()
+var contractPropSchema = z5.object({
+  type: z5.string(),
+  values: z5.array(z5.string()).optional(),
+  default: z5.unknown().optional(),
+  description: z5.string(),
+  required: z5.boolean().optional(),
+  constraints: z5.array(z5.string()).optional()
 });
-var contractUsageSchema = z3.object({
-  when: z3.array(z3.string()),
-  whenNot: z3.array(z3.string()),
-  guidelines: z3.array(z3.string()).optional(),
-  accessibility: z3.array(z3.string()).optional()
+var contractUsageSchema = z5.object({
+  when: z5.array(z5.string()),
+  whenNot: z5.array(z5.string()),
+  guidelines: z5.array(z5.string()).optional(),
+  accessibility: z5.array(z5.string()).optional()
 });
-var contractExampleSchema = z3.object({
-  name: z3.string(),
-  description: z3.string(),
-  code: z3.string(),
-  args: z3.record(z3.string(), z3.unknown()).optional()
+var contractExampleSchema = z5.object({
+  name: z5.string(),
+  description: z5.string(),
+  code: z5.string(),
+  args: z5.record(z5.string(), z5.unknown()).optional()
 });
-var contractRelationSchema = z3.object({
-  component: z3.string(),
-  relationship: z3.enum(["alternative", "parent", "child", "sibling", "composition", "complementary", "used-by"]),
-  note: z3.string()
+var contractRelationSchema = z5.object({
+  component: z5.string(),
+  relationship: z5.enum(["alternative", "parent", "child", "sibling", "composition", "complementary", "used-by"]),
+  note: z5.string()
 });
-var contractContractSchema = z3.object({
-  propsSummary: z3.array(z3.string()).optional(),
-  scenarioTags: z3.array(z3.string()).optional(),
-  a11yRules: z3.array(z3.string()).optional(),
-  bans: z3.array(z3.object({
-    pattern: z3.string(),
-    message: z3.string()
+var contractContractSchema = z5.object({
+  propsSummary: z5.array(z5.string()).optional(),
+  scenarioTags: z5.array(z5.string()).optional(),
+  a11yRules: z5.array(z5.string()).optional(),
+  bans: z5.array(z5.object({
+    pattern: z5.string(),
+    message: z5.string()
   })).optional(),
-  compoundChildren: z3.record(z3.string(), z3.object({
-    required: z3.boolean().optional(),
-    accepts: z3.array(z3.string()).optional(),
-    description: z3.string().optional()
+  compoundChildren: z5.record(z5.string(), z5.object({
+    required: z5.boolean().optional(),
+    accepts: z5.array(z5.string()).optional(),
+    description: z5.string().optional()
   })).optional(),
-  canonicalUsage: z3.array(z3.string()).optional(),
-  performanceBudget: z3.number().optional()
+  canonicalUsage: z5.array(z5.string()).optional(),
+  performanceBudget: z5.number().optional()
 });
-var contractAiSchema = z3.object({
-  compositionPattern: z3.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
-  subComponents: z3.array(z3.string()).optional(),
-  requiredChildren: z3.array(z3.string()).optional(),
-  commonPatterns: z3.array(z3.string()).optional()
+var contractAiSchema = z5.object({
+  compositionPattern: z5.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
+  subComponents: z5.array(z5.string()).optional(),
+  requiredChildren: z5.array(z5.string()).optional(),
+  commonPatterns: z5.array(z5.string()).optional()
 });
-var contractPreviewSchema = z3.object({
-  setupModule: z3.string().optional(),
-  wrapperModule: z3.string().optional(),
-  wrapperExport: z3.string().optional(),
-  css: z3.array(z3.string()).optional(),
-  theme: z3.enum(["light", "dark"]).optional()
+var contractPreviewSchema = z5.object({
+  setupModule: z5.string().optional(),
+  wrapperModule: z5.string().optional(),
+  wrapperExport: z5.string().optional(),
+  css: z5.array(z5.string()).optional(),
+  theme: z5.enum(["light", "dark"]).optional()
 });
-var contractProvenanceSchema = z3.object({
-  source: z3.enum(["manual", "extracted", "merged", "migrated"]),
-  verified: z3.boolean(),
-  frameworkSupport: z3.enum(["native", "manual-only"]).optional(),
-  sourceHash: z3.string().optional(),
-  extractedAt: z3.string().optional()
+var contractProvenanceSchema = z5.object({
+  source: z5.enum(["manual", "extracted", "merged", "migrated"]),
+  verified: z5.boolean(),
+  frameworkSupport: z5.enum(["native", "manual-only"]).optional(),
+  sourceHash: z5.string().optional(),
+  extractedAt: z5.string().optional()
 });
-var contractFigmaSchema = z3.object({
-  nodeUrl: z3.string().optional(),
-  propMappings: z3.record(z3.string(), z3.object({
-    type: z3.enum(["string", "boolean", "enum", "instance", "children", "textContent"]),
-    figmaProperty: z3.string(),
-    values: z3.record(z3.string(), z3.string()).optional()
+var contractFigmaSchema = z5.object({
+  nodeUrl: z5.string().optional(),
+  propMappings: z5.record(z5.string(), z5.object({
+    type: z5.enum(["string", "boolean", "enum", "instance", "children", "textContent"]),
+    figmaProperty: z5.string(),
+    values: z5.record(z5.string(), z5.string()).optional()
   })).optional()
 });
-var componentContractSchema = z3.object({
-  $schema: z3.string(),
-  name: z3.string(),
-  description: z3.string(),
-  category: z3.string(),
-  tags: z3.array(z3.string()).optional(),
-  status: z3.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
-  framework: z3.enum(["react", "vue", "svelte", "web-components", "angular"]).optional(),
-  sourcePath: z3.string(),
-  exportName: z3.string(),
-  propsSummary: z3.array(z3.string()),
-  props: z3.record(z3.string(), contractPropSchema),
+var componentContractSchema = z5.object({
+  $schema: z5.string(),
+  name: z5.string(),
+  description: z5.string(),
+  category: z5.string(),
+  tags: z5.array(z5.string()).optional(),
+  status: z5.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
+  framework: z5.enum(["react", "vue", "svelte", "web-components", "angular"]).optional(),
+  sourcePath: z5.string(),
+  exportName: z5.string(),
+  propsSummary: z5.array(z5.string()),
+  props: z5.record(z5.string(), contractPropSchema),
   usage: contractUsageSchema,
-  examples: z3.array(contractExampleSchema).optional(),
-  relations: z3.array(contractRelationSchema).optional(),
+  examples: z5.array(contractExampleSchema).optional(),
+  relations: z5.array(contractRelationSchema).optional(),
   contract: contractContractSchema.optional(),
   ai: contractAiSchema.optional(),
   preview: contractPreviewSchema.optional(),
   provenance: contractProvenanceSchema,
-  tokens: z3.array(z3.string()).optional(),
+  tokens: z5.array(z5.string()).optional(),
   figma: contractFigmaSchema.optional()
 });
 function isContractFile(filePath) {
@@ -2459,6 +2756,32 @@ export {
   classifyComplexity,
   formatBytes,
   budgetBar,
+  bundleSchemaVersionSchema,
+  bundleTargetSchema,
+  bundleArtifactMetadataSchema,
+  bundleManifestComponentEntrySchema,
+  bundleManifestSchema,
+  bundleTokenFileSchema,
+  bundleComponentShardSchema,
+  mcpSnapshotSchemaVersionSchema,
+  mcpSourceTypeSchema,
+  mcpCapabilitySchema,
+  mcpPerformanceImportSchema,
+  mcpPerformanceDataSchema,
+  mcpPerformanceSummarySchema,
+  mcpComponentPropSchema,
+  mcpComponentExampleSchema,
+  mcpComponentRelationSchema,
+  mcpCompoundChildSchema,
+  mcpGuidancePatternSchema,
+  mcpComponentGuidanceSchema,
+  mcpComponentMetadataSchema,
+  mcpComponentSchema,
+  mcpBlockSchema,
+  mcpTokenSchema,
+  mcpTokenDataSchema,
+  mcpSnapshotMetadataSchema,
+  mcpSnapshotSchema,
   DEFAULT_STYLE_PROPERTIES,
   DEFAULT_ENHANCED_STYLE_PROPERTIES,
   normalizeStyleValue,
@@ -2527,4 +2850,4 @@ export {
   isReactComponent,
   discoverComponents
 };
-//# sourceMappingURL=chunk-32LIWN2P.js.map
+//# sourceMappingURL=chunk-FFCI6OVZ.js.map