@usefragments/core 1.0.0

package/dist/governance-BOa3KyiJ.d.ts

@@ -0,0 +1,3279 @@
+import { z } from 'zod';
+import { ComponentType, ReactNode, JSX } from 'react';
+import { Topology } from './topology/index.js';
+import { S as SerializedComponentGraph } from './types-xJ2xyp_G.js';
+
+/**
+ * Frontend Contract preimage — the projection that defines what the contract IS.
+ *
+ * The FCID used to be a hash of the raw `code-contracts` artifact payload. That
+ * conflated identity with display: a copy-edit to a component description moved
+ * the hash, and tokens / canonical mappings / policy — the things gates actually
+ * enforce — were not part of identity at all. This module widens the preimage to
+ * the full enforcement surface as ONE shared projection, imported by both Cloud
+ * (mint) and the CLI (reportedHash). Neither side may reimplement it: parity is
+ * a property of the shared import, not a test you can fail.
+ *
+ * Enforced-only is implemented structurally: {@link projectContractPreimage}
+ * copies an explicit pick-list of fields per domain. Anything an adapter passes
+ * beyond that list (descriptions, docs URLs, timestamps, heuristic signals)
+ * never reaches the hash. Proposed canonical mappings are excluded for the same
+ * reason — they cannot block, so they are not identity; confirmation is the
+ * moment a mapping enters the contract.
+ *
+ * The preimage itself is the record of four domain sub-hashes, so
+ * `contractHash(preimage)` is the fcid and a domain diff is a four-string
+ * compare — no deep structural diffing. Determinism (key sorting, undefined
+ * dropping, number normalization) is inherited from `canonicalPreimage`; this
+ * module adds element-level sorting for the arrays it owns and nothing else.
+ *
+ * Runtime-portable by construction: no Node APIs, no Convex imports, no React.
+ */
+
+/**
+ * The fixed domain enum. Adding a domain is a spine change (update
+ * `01-architecture.md` first); never rename — deprecate and alias.
+ */
+declare const CONTRACT_DOMAINS: readonly ["components", "tokens", "canonicalMap", "policy"];
+type ContractDomain = (typeof CONTRACT_DOMAINS)[number];
+/**
+ * One component's enforcement identity. Props are the *name* membership surface
+ * (what unknown-prop checks today); prop types/defaults are not enforced by the
+ * rules engine, so they are not identity — enforced-only cuts both ways.
+ */
+interface ContractComponentInput {
+    name: string;
+    /** Parent component name when this is a subcomponent (compound identity). */
+    parentName?: string;
+    /** Prop names the component accepts. */
+    props?: readonly string[];
+    /**
+     * The per-component enforcement contract as authored (bans, a11y rules,
+     * required compound children). Passed through whole — it is enforcement data
+     * by definition.
+     */
+    contract?: unknown;
+    /** Required compound-children names, when the structure is declared. */
+    compoundChildren?: readonly string[];
+}
+interface ContractTokenInput {
+    name: string;
+    value: string | number;
+    type?: string;
+}
+type CanonicalMappingStatus = "confirmed" | "proposed" | "unknown";
+interface ContractPropMappingInput {
+    rawProp: string;
+    canonicalProp: string;
+    valueMap?: Readonly<Record<string, string>>;
+}
+interface ContractCanonicalMappingInput {
+    /** The raw/source component the mapping covers. */
+    component: string;
+    /** The canonical component it maps to. */
+    canonical: string;
+    status: CanonicalMappingStatus;
+    /** Local/offline canonical import target, when the mapping is config-authored. */
+    importPath?: string;
+    /** Explicit raw element or semantic resolutions covered by a local declaration. */
+    resolves?: readonly {
+        tag: string;
+        role?: string;
+        inputType?: string;
+    }[];
+    propMapping?: readonly ContractPropMappingInput[];
+}
+/**
+ * An authored waiver record. Hashed as data — including `expiresOn` as a plain
+ * date string. Expiry *evaluation* happens at enforcement time and must never
+ * change the fcid (no time-dependent hashing).
+ */
+interface ContractWaiverInput {
+    id: string;
+    /** The diagnostic code or rule the waiver suppresses. */
+    target: string;
+    reason: string;
+    /** YYYY-MM-DD, treated as opaque data. */
+    expiresOn?: string;
+}
+/**
+ * Active policy: everything that changes what a gate would allow or deny.
+ * Waivers live here (spine open question 1, resolved): a waiver changes what
+ * blocks, so it is enforcement-relevant.
+ */
+interface ContractPolicyInput {
+    rules?: Readonly<Record<string, unknown>>;
+    codes?: Readonly<Record<string, unknown>>;
+    compositionPatterns?: readonly unknown[];
+    waivers?: readonly ContractWaiverInput[];
+}
+/**
+ * The neutral catalog shape both adapters (Cloud mint, CLI scan) assemble.
+ * Adapters gather data; the projection owns all normalization — element order,
+ * optional fields, and display-data stripping never reach the hash.
+ */
+interface ContractCatalogInput {
+    components?: readonly ContractComponentInput[];
+    tokens?: readonly ContractTokenInput[];
+    canonicalMappings?: readonly ContractCanonicalMappingInput[];
+    policy?: ContractPolicyInput | null;
+}
+declare const CONTRACT_PREIMAGE_SCHEMA: "fcid-preimage:v1";
+/**
+ * The hashed identity record: four domain sub-hashes plus the projection schema
+ * version (so an intentional projection change mints a new fcid). The fcid is
+ * `contractHash(preimage)` — hash of the domain hashes, per the spine pipeline.
+ */
+interface ContractPreimage {
+    schema: typeof CONTRACT_PREIMAGE_SCHEMA;
+    domains: Record<ContractDomain, string>;
+}
+/**
+ * Project a catalog onto the contract preimage: four enforced-only domain
+ * bodies, each hashed independently. `contractHash(projectContractPreimage(x))`
+ * is the fcid.
+ */
+declare function projectContractPreimage(catalog: ContractCatalogInput): ContractPreimage;
+/**
+ * Name the domains whose identity differs between two preimages — a four-string
+ * compare, no structural diffing. Returned in fixed {@link CONTRACT_DOMAINS}
+ * order. Staleness checks compare these, never whole fcids.
+ */
+declare function diffContractDomains(a: ContractPreimage, b: ContractPreimage): ContractDomain[];
+/**
+ * Map defineFragment-shaped records — the `code-contracts` payload's
+ * `fragments` array (Cloud mint) or the CLI's loaded fragment definitions —
+ * onto their enforcement identity. The one shared mapping is what keeps the
+ * two adapters from drifting into a second "catalog → preimage"
+ * implementation: both sides gather fragments however they like, then this
+ * picks the identity fields. Records without a string `meta.name` are skipped
+ * (no identity to hash).
+ */
+/**
+ * The enforced-only slice of a resolved CLI governance config — the fields
+ * that change what a scan allows or denies. CI gate options, agent repair
+ * order, and runner config change how/when gates run, not what they enforce,
+ * so they are not identity. This pick-list lives here, beside the projection,
+ * so adapters cannot drift into private enforced-only boundaries: a new
+ * enforcement field on {@link GovernanceConfig} is added to the contract in
+ * exactly one place.
+ */
+declare function contractPolicyFromGovernanceConfig(config: GovernanceConfig | null | undefined): ContractPolicyInput | null;
+declare function contractComponentsFromFragments(fragments: readonly unknown[]): ContractComponentInput[];
+
+interface LocalCanonicalResolveRule {
+    tag: string;
+    role?: string;
+    inputType?: string;
+}
+interface LocalCanonicalDeclaration {
+    importPath: string;
+    resolves: readonly LocalCanonicalResolveRule[];
+}
+interface InspectConfig {
+    localCanonical?: Readonly<Record<string, LocalCanonicalDeclaration>>;
+}
+declare function localCanonicalContractMappings(inspect: InspectConfig | null | undefined): ContractCanonicalMappingInput[];
+declare function governanceConfigWithLocalCanonical(config: GovernanceConfig | undefined, inspect: InspectConfig | null | undefined): GovernanceConfig | undefined;
+
+/**
+ * Component metadata
+ */
+interface FragmentMeta$1 {
+    name: string;
+    description: string;
+    category: string;
+    tags?: string[];
+    status?: "stable" | "beta" | "deprecated" | "experimental";
+    since?: string;
+    dependencies?: Array<{
+        name: string;
+        version: string;
+        reason?: string;
+    }>;
+    figma?: string;
+    figmaProps?: Record<string, unknown>;
+}
+/**
+ * Usage guidelines for AI agents and developers
+ */
+interface FragmentUsage$1 {
+    when: string[];
+    whenNot: string[];
+    guidelines?: string[];
+    accessibility?: string[];
+}
+/**
+ * Definition for a single prop
+ */
+interface PropDefinition$1 {
+    type: string;
+    values?: readonly string[];
+    default?: unknown;
+    description: string;
+    required?: boolean;
+    constraints?: string[];
+    typeDetails?: Record<string, unknown>;
+    controlType?: string;
+    controlOptions?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        presetColors?: string[];
+    };
+}
+/**
+ * Relationship to another component
+ */
+interface ComponentRelation$1 {
+    component: string;
+    relationship: string;
+    note: string;
+}
+/**
+ * Agent-optimized contract metadata
+ */
+interface FragmentContract$1 {
+    propsSummary?: string[];
+    a11yRules?: string[];
+    bans?: Array<{
+        pattern: string;
+        message: string;
+    }>;
+    scenarioTags?: string[];
+    /** Per-component performance budget override in bytes (gzipped) */
+    performanceBudget?: number;
+    /** Sub-component slot metadata for compound components */
+    compoundChildren?: Record<string, {
+        required?: boolean;
+        accepts?: string[];
+        description?: string;
+    }>;
+    /** Canonical JSX usage examples showing how to assemble the component */
+    canonicalUsage?: string[];
+}
+/**
+ * Provenance tracking for generated fragments
+ */
+interface FragmentGenerated$1 {
+    source: "storybook" | "manual" | "ai" | "extracted" | "merged" | "migrated";
+    sourceFile?: string;
+    /** @deprecated Use provenance.verified instead */
+    confidence?: number;
+    verified?: boolean;
+    timestamp?: string;
+}
+/**
+ * AI-specific metadata
+ */
+interface AIMetadata$1 {
+    compositionPattern?: "compound" | "simple" | "controlled" | "wrapper";
+    subComponents?: string[];
+    requiredChildren?: string[];
+    commonPatterns?: string[];
+}
+/**
+ * Performance data for a component (from bundle size measurement)
+ */
+/**
+ * A single import contributing to bundle size
+ */
+interface ImportEntry {
+    /** Resolved file path (relative to project root) */
+    path: string;
+    /** Bytes contributed to the bundle */
+    bytes: number;
+    /** Percentage of total bundle size */
+    percent: number;
+}
+interface PerformanceData {
+    /** Gzipped bundle size in bytes */
+    bundleSize: number;
+    /** Raw (minified, not gzipped) bundle size in bytes */
+    rawSize: number;
+    /** Complexity classification */
+    complexity: 'lightweight' | 'moderate' | 'heavy';
+    /** Percentage of budget used (0-100+) */
+    budgetPercent: number;
+    /** Whether the component exceeds its budget */
+    overBudget: boolean;
+    /** ISO timestamp when measured */
+    measuredAt: string;
+    /** Top imports by size (largest first) */
+    imports?: ImportEntry[];
+}
+interface ObservedUsageProp {
+    name: string;
+    kind: 'static' | 'dynamic' | 'spread' | 'jsx' | 'boolean' | 'null';
+    value?: string | number | boolean | null;
+}
+interface ObservedComponentUsage {
+    /** Source file path relative to the fragments config root */
+    file: string;
+    /** 1-indexed source line */
+    line: number;
+    /** 0-indexed source column */
+    column: number;
+    props: ObservedUsageProp[];
+    parentElement?: string;
+    conditional?: boolean;
+}
+/**
+ * Compiled fragment data (JSON-serializable for AI consumption)
+ */
+interface CompiledFragment {
+    filePath: string;
+    meta: FragmentMeta$1;
+    /** Canonical v2 guidance. `usage` is retained for compatibility. */
+    guidance?: FragmentUsage$1;
+    usage: FragmentUsage$1;
+    props: Record<string, PropDefinition$1>;
+    /** Normalized component governance records emitted from *.fragment.ts. */
+    governance?: ComponentGovernanceRecord[];
+    relations?: ComponentRelation$1[];
+    variants: Array<{
+        name: string;
+        description: string;
+        code?: string;
+        figma?: string;
+        args?: Record<string, unknown>;
+    }>;
+    contract?: FragmentContract$1;
+    ai?: AIMetadata$1;
+    /** Framework hint from contract, used by preview adapters and Cloud */
+    framework?: string;
+    /** Top-level compact prop summaries for agent first-pass */
+    propsSummary?: string[];
+    /** Source file path relative to config root (for contract-sourced fragments) */
+    sourcePath?: string;
+    /** Named export for preview adapter resolution */
+    exportName?: string;
+    /** Clean provenance tracking (V2) */
+    provenance?: {
+        source: string;
+        verified: boolean;
+        frameworkSupport?: string;
+        sourceHash?: string;
+        extractedAt?: string;
+    };
+    /** Component performance data from bundle size measurement */
+    performance?: PerformanceData;
+    /** Observed JSX call sites captured during `fragments scan` */
+    usages?: ObservedComponentUsage[];
+    _generated?: FragmentGenerated$1;
+}
+/**
+ * Compiled block data (JSON-serializable for AI consumption)
+ */
+interface CompiledBlock {
+    filePath: string;
+    name: string;
+    description: string;
+    category: string;
+    components: string[];
+    code: string;
+    tags?: string[];
+}
+/**
+ * A single token entry in the compiled output
+ */
+interface CompiledTokenEntry {
+    name: string;
+    value?: string;
+    description?: string;
+}
+/**
+ * Compiled token data stored in fragments.json
+ */
+interface CompiledTokenData {
+    prefix: string;
+    total: number;
+    categories: Record<string, CompiledTokenEntry[]>;
+}
+/**
+ * Performance summary across all components
+ */
+interface PerformanceSummary {
+    /** Preset name used */
+    preset: string;
+    /** Budget applied in bytes */
+    budget: number;
+    /** Total components measured */
+    total: number;
+    /** Number of components over budget */
+    overBudget: number;
+    /** Distribution by tier */
+    tiers: Record<string, number>;
+}
+/**
+ * The compiled fragments.json structure
+ */
+interface CompiledFragmentsFile {
+    version: string;
+    generatedAt: string;
+    /** CLI version that produced this file, used for freshness checks */
+    generatorVersion?: string;
+    /** Relative source/config inputs used to build this file, used for freshness checks */
+    buildInputs?: string[];
+    packageName?: string;
+    fragments: Record<string, CompiledFragment>;
+    blocks?: Record<string, CompiledBlock>;
+    tokens?: CompiledTokenData;
+    /** Component relationship graph for AI structural queries */
+    graph?: SerializedComponentGraph;
+    /** Performance measurement summary */
+    performanceSummary?: PerformanceSummary;
+    /** @deprecated Use blocks instead */
+    recipes?: Record<string, CompiledBlock>;
+}
+/**
+ * Theme identifier
+ */
+type Theme$1 = "light" | "dark";
+/**
+ * Verification result
+ */
+interface VerifyResult$1 {
+    verdict: "pass" | "fail" | "error";
+    matches: boolean;
+    diffPercentage: number;
+    screenshot: string;
+    baseline: string;
+    diffImage?: string;
+    notes: string[];
+    error?: string;
+    timing: {
+        renderMs: number;
+        captureMs: number;
+        diffMs: number;
+        totalMs: number;
+    };
+}
+
+/**
+ * A React component that can be used in a fragment definition.
+ * This type is intentionally broad to support various React component patterns
+ * including FC, forwardRef, memo, and class components across different React versions.
+ */
+type FragmentComponent<TProps = any> = ComponentType<TProps> | ((props: TProps) => ReactNode | JSX.Element | null);
+/**
+ * Framework-agnostic component reference.
+ * Used in contexts where React is not required (e.g., JSON component contracts).
+ * Accepts a string identifier, a generic function, or a record of metadata.
+ */
+type ComponentRef = string | ((...args: unknown[]) => unknown) | Record<string, unknown>;
+/**
+ * Metadata about the component
+ */
+interface FragmentMeta {
+    /** Component display name */
+    name: string;
+    /** Brief description of the component's purpose */
+    description: string;
+    /** Category for organizing components (e.g., "actions", "forms", "layout") */
+    category: string;
+    /** Optional tags for additional categorization */
+    tags?: string[];
+    /** Component status */
+    status?: "stable" | "beta" | "deprecated" | "experimental";
+    /** Version when component was introduced */
+    since?: string;
+    /** External npm packages required by this component (displayed in docs Setup section) */
+    dependencies?: Array<{
+        name: string;
+        version: string;
+        reason?: string;
+    }>;
+    /** Figma frame URL for design verification */
+    figma?: string;
+    /** Figma property mappings (how Figma props map to code props) */
+    figmaProps?: Record<string, FigmaPropMapping>;
+}
+/**
+ * Figma property mapping types - describes how a Figma property maps to code
+ */
+type FigmaPropMapping = FigmaStringMapping | FigmaBooleanMapping | FigmaEnumMapping | FigmaInstanceMapping | FigmaChildrenMapping | FigmaTextContentMapping;
+/** Maps a Figma text property to a string prop */
+interface FigmaStringMapping {
+    __type: "figma-string";
+    figmaProperty: string;
+}
+/** Maps a Figma boolean property to a boolean prop (with optional value mapping) */
+interface FigmaBooleanMapping {
+    __type: "figma-boolean";
+    figmaProperty: string;
+    valueMapping?: {
+        true: unknown;
+        false: unknown;
+    };
+}
+/** Maps a Figma variant property to an enum prop */
+interface FigmaEnumMapping {
+    __type: "figma-enum";
+    figmaProperty: string;
+    valueMapping: Record<string, unknown>;
+}
+/** References a nested Figma component instance */
+interface FigmaInstanceMapping {
+    __type: "figma-instance";
+    figmaProperty: string;
+}
+/** Renders children from Figma layer names */
+interface FigmaChildrenMapping {
+    __type: "figma-children";
+    layers: string[];
+}
+/** Extracts text content from a Figma text layer */
+interface FigmaTextContentMapping {
+    __type: "figma-text-content";
+    layer: string;
+}
+/**
+ * Usage guidelines for AI agents and developers
+ */
+interface FragmentUsage {
+    /** When to use this component */
+    when: string[];
+    /** When NOT to use this component (with alternatives) */
+    whenNot: string[];
+    /** Additional usage guidelines and best practices */
+    guidelines?: string[];
+    /** Accessibility considerations */
+    accessibility?: string[];
+}
+/**
+ * Prop type definitions
+ */
+type PropType = {
+    type: "string";
+    pattern?: string;
+} | {
+    type: "number";
+    min?: number;
+    max?: number;
+} | {
+    type: "boolean";
+} | {
+    type: "enum";
+    values: readonly string[];
+} | {
+    type: "function";
+    signature?: string;
+} | {
+    type: "node";
+} | {
+    type: "element";
+} | {
+    type: "object";
+    shape?: Record<string, PropDefinition>;
+} | {
+    type: "array";
+    items?: PropType;
+} | {
+    type: "union";
+    types: PropType[];
+} | {
+    type: "custom";
+    typescript: string;
+};
+/**
+ * Storybook control types for UI rendering
+ */
+type ControlType = "text" | "number" | "range" | "boolean" | "select" | "multi-select" | "radio" | "inline-radio" | "check" | "inline-check" | "object" | "file" | "color" | "date";
+/**
+ * Definition for a single prop
+ */
+interface PropDefinition {
+    /** The prop type */
+    type: PropType["type"];
+    /** For enum types, the allowed values */
+    values?: readonly string[];
+    /** Default value if not provided */
+    default?: unknown;
+    /** Description of what this prop does */
+    description: string;
+    /** Whether this prop is required */
+    required?: boolean;
+    /** Usage constraints for AI agents */
+    constraints?: string[];
+    /** Additional type details for complex types */
+    typeDetails?: Omit<PropType, "type">;
+    /** Original Storybook control type for UI rendering (e.g., "color", "date", "range") */
+    controlType?: ControlType;
+    /** Control options (e.g., min/max for range, presetColors for color) */
+    controlOptions?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        presetColors?: string[];
+    };
+}
+/**
+ * Relationship types between components
+ */
+type RelationshipType = "alternative" | "sibling" | "parent" | "child" | "composition" | "complementary" | "used-by";
+/**
+ * Relationship to another component
+ */
+interface ComponentRelation {
+    /** Name of the related component */
+    component: string;
+    /** Type of relationship */
+    relationship: RelationshipType;
+    /** Explanation of the relationship */
+    note: string;
+}
+/**
+ * Loader function type for async data loading before render
+ */
+type VariantLoader = () => Promise<Record<string, unknown>>;
+/**
+ * Play function context passed during interaction testing
+ */
+interface PlayFunctionContext {
+    /** The rendered canvas element containing the story */
+    canvasElement: HTMLElement;
+    /** Args passed to the story */
+    args: Record<string, unknown>;
+    /** Step function for organizing interactions */
+    step: (name: string, fn: () => Promise<void>) => Promise<void>;
+}
+/**
+ * Play function type for interaction testing
+ */
+type PlayFunction = (context: PlayFunctionContext) => Promise<void>;
+/**
+ * Options passed to variant render function
+ */
+interface VariantRenderOptions {
+    /** Props/args to override the variant defaults */
+    args?: Record<string, unknown>;
+    /** Data loaded from async loaders */
+    loadedData?: Record<string, unknown>;
+}
+/**
+ * A single variant/example of the component
+ */
+interface FragmentVariant {
+    /** Variant name */
+    name: string;
+    /** Description of when to use this variant */
+    description: string;
+    /** Render function that returns the component example
+     * @param options - Optional args overrides and loaded data
+     */
+    render: (options?: VariantRenderOptions) => ReactNode;
+    /** Optional code string for display (auto-generated if not provided) */
+    code?: string;
+    /** Figma frame URL for this specific variant (overrides meta.figma) */
+    figma?: string;
+    /** Whether this variant has a Storybook play function (for display purposes) */
+    hasPlayFunction?: boolean;
+    /** The actual play function for interaction testing */
+    play?: PlayFunction;
+    /** Storybook story ID for this variant (generated by @storybook/csf toId) */
+    storyId?: string;
+    /** Optional tags for this variant (inherited from story tags) */
+    tags?: string[];
+    /** Async loaders to execute before rendering (from Storybook loaders) */
+    loaders?: VariantLoader[];
+    /** The args/props used to render this variant (for code generation) */
+    args?: Record<string, unknown>;
+}
+/**
+ * Agent-optimized contract metadata
+ * Provides compact, structured data for AI code generation
+ */
+interface FragmentContract {
+    /** Short prop descriptions for agents (e.g., "variant: primary|secondary (required)") */
+    propsSummary?: string[];
+    /** Accessibility rule IDs for lookup in glossary (e.g., "A11Y_BTN_LABEL") */
+    a11yRules?: string[];
+    /** Banned patterns in codebase - triggers warnings during code review */
+    bans?: Array<{
+        /** Pattern to match (regex string or literal) */
+        pattern: string;
+        /** Message explaining why this pattern is banned and what to use instead */
+        message: string;
+    }>;
+    /** Scenario tags for use-case matching (e.g., "form.submit", "navigation.primary") */
+    scenarioTags?: string[];
+    /** Per-component performance budget override in bytes (gzipped). Overrides global budget. */
+    performanceBudget?: number;
+    /** Sub-component slot metadata for compound components (e.g., Card.Header, Dialog.Body) */
+    compoundChildren?: Record<string, {
+        required?: boolean;
+        accepts?: string[];
+        description?: string;
+    }>;
+    /** Canonical JSX usage examples showing how to assemble the component */
+    canonicalUsage?: string[];
+}
+/**
+ * Provenance tracking for generated fragments
+ * Helps distinguish human-authored from machine-generated content
+ */
+interface FragmentGenerated {
+    /** Source of this fragment definition */
+    source: "storybook" | "manual" | "ai" | "extracted" | "merged" | "migrated";
+    /** Original source file (e.g., "Button.stories.tsx") */
+    sourceFile?: string;
+    /** @deprecated Use provenance.verified instead — kept for backwards compatibility */
+    confidence?: number;
+    /** Whether the fragment has been verified against source */
+    verified?: boolean;
+    /** ISO timestamp when this was generated */
+    timestamp?: string;
+}
+/**
+ * AI-specific metadata for playground context generation
+ * Provides hints for AI code generation about component composition
+ */
+interface AIMetadata {
+    /** How this component is composed with others */
+    compositionPattern?: "compound" | "simple" | "controlled" | "wrapper";
+    /** Sub-component names (without parent prefix, e.g., "Header" not "Card.Header") */
+    subComponents?: string[];
+    /** Sub-components that must be present for valid composition */
+    requiredChildren?: string[];
+    /** Common usage patterns as JSX strings for AI reference */
+    commonPatterns?: string[];
+}
+/**
+ * Complete fragment definition
+ */
+interface FragmentDefinition<TProps = unknown> {
+    /** The component being documented */
+    component: FragmentComponent<TProps>;
+    /** Component metadata */
+    meta: FragmentMeta;
+    /** Usage guidelines */
+    usage: FragmentUsage;
+    /** Props documentation */
+    props: Record<string, PropDefinition>;
+    /** Relationships to other components */
+    relations?: ComponentRelation[];
+    /** Component variants/examples */
+    variants: FragmentVariant[];
+    /** Agent-optimized contract metadata */
+    contract?: FragmentContract;
+    /** AI-specific metadata for playground context generation */
+    ai?: AIMetadata;
+    /** Provenance tracking (for generated fragments) */
+    _generated?: FragmentGenerated;
+}
+/**
+ * Usage guidelines for AI agents and developers.
+ * v2 alias for FragmentUsage — clearer naming.
+ * @since 2.0
+ */
+type FragmentGuidance = FragmentUsage;
+/**
+ * A single example of the component.
+ * v2 alias for FragmentVariant — research shows "examples" is clearer for AI consumption.
+ * @since 2.0
+ */
+type FragmentExample = FragmentVariant;
+/**
+ * Composition metadata — promoted from ai.compositionPattern to first-class field.
+ * Uses shorter field names since the parent field is already `composition`.
+ * @since 2.0
+ */
+interface CompositionMetadata {
+    /** How this component is composed with others */
+    pattern?: "compound" | "simple" | "controlled" | "wrapper";
+    /** Sub-component names (without parent prefix, e.g., "Header" not "Card.Header") */
+    subComponents?: string[];
+    /** Sub-components that must be present for valid composition */
+    requiredChildren?: string[];
+    /** Common usage patterns as JSX strings for AI reference */
+    commonPatterns?: string[];
+}
+/**
+ * Extended provenance tracking for generated fragments.
+ * Superset of FragmentGenerated with field-level attribution.
+ * @since 2.0
+ */
+interface FragmentProvenance {
+    /** Source of this fragment definition */
+    source: "storybook" | "manual" | "ai" | "scan" | "extracted" | "merged" | "migrated";
+    /** Original source file (e.g., "Button.stories.tsx") */
+    sourceFile?: string;
+    /** @deprecated Use verified instead */
+    confidence?: number;
+    /** Whether the fragment has been verified against source */
+    verified: boolean;
+    /** Framework support level */
+    frameworkSupport?: "native" | "manual-only";
+    /** SHA hash of the source file at extraction time */
+    sourceHash?: string;
+    /** ISO timestamp when this was generated */
+    timestamp?: string;
+    /** Fields that were auto-extracted (e.g., ['props', 'composition']) */
+    autoFields?: string[];
+    /** Fields that were human-authored (e.g., ['guidance', 'examples']) */
+    humanFields?: string[];
+}
+/**
+ * v2 fragment definition with clearer field names.
+ *
+ * Changes from v1 FragmentDefinition:
+ * - `usage` → `guidance` (clearer intent)
+ * - `variants` → `examples` (research-backed: examples > parameter lists)
+ * - `ai` → `composition` (promoted to first-class, shorter field names)
+ * - `_generated` → `_provenance` (extended with autoFields/humanFields)
+ * - `contract` remains but is auto-compiled at build time
+ *
+ * @since 2.0
+ */
+interface FragmentDefinitionV2<TProps = unknown> {
+    /** The component being documented */
+    component: FragmentComponent<TProps>;
+    /** Component metadata */
+    meta: FragmentMeta;
+    /** Usage guidelines (v2 name for 'usage') */
+    guidance: FragmentGuidance;
+    /** Props documentation */
+    props: Record<string, PropDefinition>;
+    /** Relationships to other components */
+    relations?: ComponentRelation[];
+    /** Component examples (v2 name for 'variants') */
+    examples: FragmentExample[];
+    /** Composition metadata (v2 name for 'ai', promoted to first-class) */
+    composition?: CompositionMetadata;
+    /** Agent-optimized contract — auto-compiled at build time */
+    contract?: FragmentContract;
+    /** Provenance tracking (v2 name for '_generated', extended) */
+    _provenance?: FragmentProvenance;
+}
+/**
+ * Registry generation options
+ */
+interface RegistryOptions {
+    /** Only include components that have a corresponding .stories.tsx file */
+    requireStory?: boolean;
+    /** Only include components that are exported (public API) */
+    publicOnly?: boolean;
+    /** Maximum depth for category inference from directory structure (default: 1) */
+    categoryDepth?: number;
+    /** Include props in registry (default: false - AI can read TypeScript directly) */
+    includeProps?: boolean;
+    /** Include full fragment data in registry (default: false - reference fragmentPath instead) */
+    embedFragments?: boolean;
+}
+/**
+ * Design token configuration
+ */
+type RepoRelativePath = string;
+interface AppConfig {
+    /** Repo-root-relative app/source directory to scan. Defaults to ".". */
+    path?: RepoRelativePath;
+    /** Optional source globs relative to app.path. */
+    include?: string[];
+    /** Optional source exclusions relative to app.path. */
+    exclude?: string[];
+}
+interface DesignSystemConfig {
+    /** Repo-root-relative directory that owns the canonical primitives. */
+    path?: RepoRelativePath;
+    /** Package name for primitive imports. Inferred from path/package.json when omitted. */
+    packageName?: string;
+    /** Component source globs relative to designSystem.path. */
+    components?: string[];
+}
+type TokenSourceFormat = "auto" | "css" | "scss" | "dtcg" | "tailwind";
+interface TokenSourceConfig {
+    /** Repo-root-relative token file or glob. */
+    path: RepoRelativePath;
+    /** Explicit token format, or "auto" to infer from extension/content. */
+    format?: TokenSourceFormat;
+}
+interface TokenConfig {
+    /**
+     * Glob patterns for files to scan for tokens
+     * e.g., ["src/styles/theme.scss", "src/styles/variables.css"]
+     */
+    include?: string[];
+    /** Repo-root-relative token source files/globs for monorepos and Cloud setup. */
+    sources?: TokenSourceConfig[];
+    /**
+     * Glob patterns to exclude
+     * @example ["node_modules"]
+     */
+    exclude?: string[];
+    /**
+     * Map CSS selectors to theme names
+     * @example { ":root": "default", "[data-theme='dark']": "dark" }
+     */
+    themeSelectors?: Record<string, string>;
+    /** Enable token comparison in style diffs (default: true) */
+    enabled?: boolean;
+    /** Token source format detection ('auto' detects from file extension) */
+    format?: TokenSourceFormat;
+    /** Vendor namespace for Fragments extensions in DTCG files (default: 'com.usefragments') */
+    namespace?: string;
+}
+/**
+ * CI configuration for automated compliance checks
+ */
+interface CIConfig {
+    /** Minimum compliance percentage to pass (default: 80) */
+    minCompliance?: number;
+    /** Whether to fail on any visual regression */
+    failOnDiff?: boolean;
+    /** Whether to output JSON format */
+    jsonOutput?: boolean;
+}
+/**
+ * Snippet policy configuration.
+ * Controls snippet/render quality enforcement in `fragments validate`.
+ */
+interface SnippetPolicyConfig {
+    /** Validation mode: warn (non-blocking) or error (blocking). Default: warn */
+    mode?: "warn" | "error";
+    /** Validate snippet strings only, or snippet strings + render functions. Default: snippet+render */
+    scope?: "snippet" | "snippet+render";
+    /** Require authored snippets to be full, copy-pasteable examples with imports. Default: true */
+    requireFullSnippet?: boolean;
+    /** Allow these external modules for JSX components in snippets/renders. */
+    allowedExternalModules?: string[];
+}
+/**
+ * Storybook adapter filtering configuration.
+ * Controls which Storybook stories are included when generating fragments.
+ */
+interface StorybookFilterConfig {
+    /** Glob-style patterns for component names to explicitly exclude */
+    exclude?: string[];
+    /** Glob-style patterns for component names to force-include (bypasses all heuristic filters) */
+    include?: string[];
+    /** Exclude stories with "Deprecated" in the title (default: true) */
+    excludeDeprecated?: boolean;
+    /** Exclude test stories (title ending /test(s) or *.test.stories.* files) (default: true) */
+    excludeTests?: boolean;
+    /** Exclude SVG icon components (names matching Svg[A-Z]*) (default: true) */
+    excludeSvgIcons?: boolean;
+    /** Exclude sub-components detected by directory structure (default: true) */
+    excludeSubComponents?: boolean;
+}
+/**
+ * Theme seed configuration.
+ * The 5 root values that derive 120+ CSS custom properties.
+ */
+interface ThemeSeeds {
+    /** Primary brand color as hex (e.g., "#6366f1") */
+    brand?: string;
+    /** Neutral palette name */
+    neutral?: "stone" | "ice" | "earth" | "sand" | "fire" | "fragments";
+    /** Spacing density scale */
+    density?: "compact" | "default" | "relaxed";
+    /** Border radius style */
+    radiusStyle?: "sharp" | "subtle" | "default" | "rounded" | "pill";
+    /** Danger/error color as hex (e.g., "#ef4444") */
+    danger?: string;
+}
+/**
+ * Visual snapshot testing configuration.
+ */
+interface SnapshotConfig {
+    /** Enable visual snapshot tests (default: false) */
+    enabled: boolean;
+    /** Output directory for snapshot baselines (relative to project root) */
+    outputDir?: string;
+    /** Viewport width for snapshots (default: 1440) */
+    viewportWidth?: number;
+    /** Viewport height for snapshots (default: 1100) */
+    viewportHeight?: number;
+    /** Diff threshold percentage before a snapshot fails (default: 0.1) */
+    threshold?: number;
+    /** Disable CSS animations during capture (default: true) */
+    disableAnimations?: boolean;
+}
+/**
+ * Config file structure
+ */
+interface FragmentsConfig {
+    /** App/source scan scope. Paths are repo-root-relative. */
+    app?: AppConfig;
+    /** Canonical primitive component source. Paths are repo-root-relative. */
+    designSystem?: DesignSystemConfig;
+    /** Glob patterns for finding fragment/fragment files */
+    include?: string[];
+    /** Glob patterns to exclude */
+    exclude?: string[];
+    /** Glob patterns for finding component files (for coverage validation) */
+    components?: string[];
+    /** Output path for compiled output */
+    outFile?: string;
+    /** Framework adapter to use */
+    framework?: "react" | "vue" | "svelte";
+    /** Figma file URL for the design system (used by `fragments link`) */
+    figmaFile?: string;
+    /** Figma access token (alternative to FIGMA_ACCESS_TOKEN env var) */
+    figmaToken?: string;
+    /** Screenshot configuration */
+    screenshots?: ScreenshotConfig;
+    /** Service configuration */
+    service?: ServiceConfig;
+    /** Registry generation options */
+    registry?: RegistryOptions;
+    /** Design token discovery and mapping configuration */
+    tokens?: TokenConfig;
+    /** CI pipeline configuration */
+    ci?: CIConfig;
+    /** Snippet/render policy validation */
+    snippets?: SnippetPolicyConfig;
+    /** Performance budgets: preset name or custom config */
+    performance?: string | {
+        preset?: string;
+        budgets?: {
+            bundleSize?: number;
+        };
+    };
+    /** Storybook adapter filtering configuration */
+    storybook?: StorybookFilterConfig;
+    /** Theme seed values for the 5-seed theming system */
+    theme?: ThemeSeeds;
+    /**
+     * Product-area topology — maps file paths to areas (checkout, dashboard, …)
+     * for area-scoped governance. Resolved at scan time; areas are tagged onto
+     * findings and coverage. See `apps/cloud/docs/topology/`.
+     */
+    topology?: Topology;
+    /** Visual snapshot testing configuration */
+    snapshots?: SnapshotConfig;
+    /** Preview configuration for component rendering */
+    preview?: {
+        /** Module that runs before any render (global CSS, MSW, mocks) */
+        setupModule?: string;
+        /** Module path for the render wrapper component (ThemeProvider, etc.) */
+        wrapperModule?: string;
+        /** Named export from wrapperModule (e.g., 'ThemeProvider') */
+        wrapperExport?: string;
+        /** Additional CSS files to inject */
+        css?: string[];
+        /** Default theme for previews */
+        theme?: "light" | "dark";
+    };
+    /** Governance policy configuration (replaces standalone govern.config.ts) */
+    govern?: GovernanceConfig;
+    /** Local Inspect-only configuration. */
+    inspect?: InspectConfig;
+    /**
+     * Identifier names recognized as className-helper callees during Tailwind
+     * extraction (e.g. `clsx`, `cn`). Supplying this list **replaces** the
+     * default `['clsx', 'cn', 'classnames', 'twMerge', 'tw', 'cva']` — it does
+     * not merge.
+     */
+    recognizedClassHelpers?: string[];
+}
+/**
+ * Screenshot capture configuration
+ */
+interface ScreenshotConfig {
+    /** Default viewport for captures */
+    viewport?: Viewport;
+    /** Diff threshold percentage (0-100) */
+    threshold?: number;
+    /** Additional delay after render before capture (ms) */
+    delay?: number;
+    /** Output directory for baselines (relative to project root) */
+    outputDir?: string;
+    /** Themes to capture */
+    themes?: Theme[];
+}
+/**
+ * Service configuration
+ */
+interface ServiceConfig {
+    /** Browser pool size */
+    poolSize?: number;
+    /** Idle timeout before shutdown (ms) */
+    idleTimeout?: number;
+}
+/**
+ * Viewport dimensions
+ */
+interface Viewport {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+/**
+ * Theme identifier
+ */
+type Theme = "light" | "dark";
+/**
+ * Screenshot metadata
+ */
+interface Screenshot {
+    /** PNG image data */
+    data: Buffer;
+    /** SHA-256 hash of image data (for change detection) */
+    hash: string;
+    /** Viewport used for capture */
+    viewport: Viewport;
+    /** When this screenshot was taken */
+    capturedAt: Date;
+    /** Capture metadata */
+    metadata: ScreenshotMetadata;
+}
+/**
+ * Screenshot metadata
+ */
+interface ScreenshotMetadata {
+    /** Component name */
+    component: string;
+    /** Variant name */
+    variant: string;
+    /** Theme used */
+    theme: Theme;
+    /** Time to render the component (ms) */
+    renderTimeMs: number;
+    /** Time to capture the screenshot (ms) */
+    captureTimeMs: number;
+}
+/**
+ * Result of comparing two screenshots
+ */
+interface DiffResult {
+    /** Whether images are considered matching (below threshold) */
+    matches: boolean;
+    /** Percentage of pixels that differ (0-100) */
+    diffPercentage: number;
+    /** Number of differing pixels */
+    diffPixelCount: number;
+    /** Total pixels compared */
+    totalPixels: number;
+    /** PNG image highlighting differences */
+    diffImage?: Buffer;
+    /** Bounding boxes of changed regions */
+    changedRegions: BoundingBox[];
+    /** Time taken to compute diff (ms) */
+    diffTimeMs: number;
+}
+/**
+ * Bounding box for changed region
+ */
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Baseline information stored in manifest
+ */
+interface BaselineInfo {
+    /** Component name */
+    component: string;
+    /** Variant name */
+    variant: string;
+    /** Theme */
+    theme: Theme;
+    /** Relative path to image file */
+    path: string;
+    /** SHA-256 hash */
+    hash: string;
+    /** Viewport used */
+    viewport: Viewport;
+    /** When captured */
+    capturedAt: string;
+    /** File size in bytes */
+    fileSize: number;
+}
+/**
+ * Manifest file structure
+ */
+interface Manifest {
+    /** Schema version */
+    version: "1.0.0";
+    /** When manifest was generated */
+    generatedAt: string;
+    /** Configuration used for capture */
+    config: {
+        defaultViewport: Viewport;
+        defaultThreshold: number;
+        captureDelay: number;
+    };
+    /** All baselines indexed by component/variant */
+    baselines: Record<string, Record<string, BaselineInfo>>;
+}
+/**
+ * Verification request from AI agents
+ */
+interface VerifyRequest {
+    /** Component name */
+    component: string;
+    /** Variant name */
+    variant: string;
+    /** Theme to verify against */
+    theme?: Theme;
+    /** Override diff threshold */
+    threshold?: number;
+}
+/**
+ * Verification result
+ */
+interface VerifyResult {
+    /** Overall verdict */
+    verdict: "pass" | "fail" | "error";
+    /** Whether diff is below threshold */
+    matches: boolean;
+    /** Percentage of pixels that differ */
+    diffPercentage: number;
+    /** Current screenshot (base64 PNG) */
+    screenshot: string;
+    /** Baseline screenshot (base64 PNG) */
+    baseline: string;
+    /** Diff image if different (base64 PNG) */
+    diffImage?: string;
+    /** Human-readable notes */
+    notes: string[];
+    /** Error message if verdict is "error" */
+    error?: string;
+    /** Performance metrics */
+    timing: {
+        renderMs: number;
+        captureMs: number;
+        diffMs: number;
+        totalMs: number;
+    };
+}
+
+/**
+ * Block definition — a named composition pattern showing how
+ * design system components wire together for a common use case.
+ */
+interface BlockDefinition {
+    name: string;
+    description: string;
+    category: string;
+    components: string[];
+    code: string;
+    tags?: string[];
+}
+/**
+ * @deprecated Use BlockDefinition instead
+ */
+type RecipeDefinition = BlockDefinition;
+/**
+ * @deprecated Use CompiledBlock instead
+ */
+type CompiledRecipe = CompiledBlock;
+
+declare const governanceSeveritySchema: z.ZodEnum<["error", "warn", "info"]>;
+type GovernanceSeverity = z.infer<typeof governanceSeveritySchema>;
+declare const scaleGovernanceRecordSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodLiteral<"scale">>;
+    name: z.ZodOptional<z.ZodString>;
+    unit: z.ZodEnum<["px", "rem"]>;
+    values: z.ZodArray<z.ZodNumber, "many">;
+    rootFontSizePx: z.ZodOptional<z.ZodNumber>;
+    emBasePx: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    values: number[];
+    kind: "scale";
+    unit: "px" | "rem";
+    name?: string | undefined;
+    rootFontSizePx?: number | undefined;
+    emBasePx?: number | undefined;
+}, {
+    values: number[];
+    unit: "px" | "rem";
+    kind?: "scale" | undefined;
+    name?: string | undefined;
+    rootFontSizePx?: number | undefined;
+    emBasePx?: number | undefined;
+}>;
+declare const globalStyleGovernanceRecordSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawColors.forbid">;
+    except: z.ZodArray<z.ZodString, "many">;
+    prefer: z.ZodEnum<["token", "css-variable"]>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawColors.forbid";
+    severity: "error" | "info" | "warn";
+    except: string[];
+    prefer: "token" | "css-variable";
+}, {
+    kind: "style.rawColors.forbid";
+    severity: "error" | "info" | "warn";
+    except: string[];
+    prefer: "token" | "css-variable";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawDimensions.forbid">;
+    appliesTo: z.ZodArray<z.ZodString, "many">;
+    prefer: z.ZodEnum<["token", "css-variable"]>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawDimensions.forbid";
+    severity: "error" | "info" | "warn";
+    prefer: "token" | "css-variable";
+    appliesTo: string[];
+}, {
+    kind: "style.rawDimensions.forbid";
+    severity: "error" | "info" | "warn";
+    prefer: "token" | "css-variable";
+    appliesTo: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawSpacing.mustMatchScale">;
+    scale: z.ZodString;
+    appliesTo: z.ZodArray<z.ZodString, "many">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawSpacing.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+    appliesTo: string[];
+}, {
+    kind: "style.rawSpacing.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+    appliesTo: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.fontSize.mustMatchScale">;
+    scale: z.ZodString;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.fontSize.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+}, {
+    kind: "style.fontSize.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.cssVars.mustBeDefined">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.cssVars.mustBeDefined";
+    severity: "error" | "info" | "warn";
+}, {
+    kind: "style.cssVars.mustBeDefined";
+    severity: "error" | "info" | "warn";
+}>]>;
+declare const globalJsxGovernanceRecordSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.unknownProps.forbid">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.unknownProps.forbid";
+    severity: "error" | "info" | "warn";
+}, {
+    kind: "jsx.unknownProps.forbid";
+    severity: "error" | "info" | "warn";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.inlineStyle.forbidRaw">;
+    properties: z.ZodArray<z.ZodString, "many">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.inlineStyle.forbidRaw";
+    severity: "error" | "info" | "warn";
+    properties: string[];
+}, {
+    kind: "jsx.inlineStyle.forbidRaw";
+    severity: "error" | "info" | "warn";
+    properties: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.importPath.prefer">;
+    from: z.ZodString;
+    to: z.ZodString;
+    imported: z.ZodOptional<z.ZodString>;
+    because: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.importPath.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    imported?: string | undefined;
+    because?: string | undefined;
+}, {
+    kind: "jsx.importPath.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    imported?: string | undefined;
+    because?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.component.prefer">;
+    from: z.ZodString;
+    to: z.ZodString;
+    because: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.component.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    because?: string | undefined;
+}, {
+    kind: "jsx.component.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    because?: string | undefined;
+}>]>;
+declare const globalGovernanceRecordSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodDefault<z.ZodLiteral<"scale">>;
+    name: z.ZodOptional<z.ZodString>;
+    unit: z.ZodEnum<["px", "rem"]>;
+    values: z.ZodArray<z.ZodNumber, "many">;
+    rootFontSizePx: z.ZodOptional<z.ZodNumber>;
+    emBasePx: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    values: number[];
+    kind: "scale";
+    unit: "px" | "rem";
+    name?: string | undefined;
+    rootFontSizePx?: number | undefined;
+    emBasePx?: number | undefined;
+}, {
+    values: number[];
+    unit: "px" | "rem";
+    kind?: "scale" | undefined;
+    name?: string | undefined;
+    rootFontSizePx?: number | undefined;
+    emBasePx?: number | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawColors.forbid">;
+    except: z.ZodArray<z.ZodString, "many">;
+    prefer: z.ZodEnum<["token", "css-variable"]>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawColors.forbid";
+    severity: "error" | "info" | "warn";
+    except: string[];
+    prefer: "token" | "css-variable";
+}, {
+    kind: "style.rawColors.forbid";
+    severity: "error" | "info" | "warn";
+    except: string[];
+    prefer: "token" | "css-variable";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawDimensions.forbid">;
+    appliesTo: z.ZodArray<z.ZodString, "many">;
+    prefer: z.ZodEnum<["token", "css-variable"]>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawDimensions.forbid";
+    severity: "error" | "info" | "warn";
+    prefer: "token" | "css-variable";
+    appliesTo: string[];
+}, {
+    kind: "style.rawDimensions.forbid";
+    severity: "error" | "info" | "warn";
+    prefer: "token" | "css-variable";
+    appliesTo: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.rawSpacing.mustMatchScale">;
+    scale: z.ZodString;
+    appliesTo: z.ZodArray<z.ZodString, "many">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.rawSpacing.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+    appliesTo: string[];
+}, {
+    kind: "style.rawSpacing.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+    appliesTo: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.fontSize.mustMatchScale">;
+    scale: z.ZodString;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.fontSize.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+}, {
+    kind: "style.fontSize.mustMatchScale";
+    severity: "error" | "info" | "warn";
+    scale: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"style.cssVars.mustBeDefined">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "style.cssVars.mustBeDefined";
+    severity: "error" | "info" | "warn";
+}, {
+    kind: "style.cssVars.mustBeDefined";
+    severity: "error" | "info" | "warn";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.unknownProps.forbid">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.unknownProps.forbid";
+    severity: "error" | "info" | "warn";
+}, {
+    kind: "jsx.unknownProps.forbid";
+    severity: "error" | "info" | "warn";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.inlineStyle.forbidRaw">;
+    properties: z.ZodArray<z.ZodString, "many">;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.inlineStyle.forbidRaw";
+    severity: "error" | "info" | "warn";
+    properties: string[];
+}, {
+    kind: "jsx.inlineStyle.forbidRaw";
+    severity: "error" | "info" | "warn";
+    properties: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.importPath.prefer">;
+    from: z.ZodString;
+    to: z.ZodString;
+    imported: z.ZodOptional<z.ZodString>;
+    because: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.importPath.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    imported?: string | undefined;
+    because?: string | undefined;
+}, {
+    kind: "jsx.importPath.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    imported?: string | undefined;
+    because?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"jsx.component.prefer">;
+    from: z.ZodString;
+    to: z.ZodString;
+    because: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "jsx.component.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    because?: string | undefined;
+}, {
+    kind: "jsx.component.prefer";
+    from: string;
+    to: string;
+    severity: "error" | "info" | "warn";
+    because?: string | undefined;
+}>]>;
+declare const componentGovernanceRecordSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"capability">;
+    capability: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "capability";
+    capability: string;
+}, {
+    kind: "capability";
+    capability: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"prop.value.avoid">;
+    prop: z.ZodString;
+    value: z.ZodUnknown;
+    because: z.ZodString;
+    suggest: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "prop.value.avoid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    suggest?: string | undefined;
+}, {
+    kind: "prop.value.avoid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    suggest?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"prop.value.forbid">;
+    prop: z.ZodString;
+    value: z.ZodUnknown;
+    when: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+    }, {
+        path?: string | undefined;
+    }>>;
+    because: z.ZodString;
+    fix: z.ZodOptional<z.ZodObject<{
+        replaceWith: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        replaceWith?: unknown;
+    }, {
+        replaceWith?: unknown;
+    }>>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "prop.value.forbid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    fix?: {
+        replaceWith?: unknown;
+    } | undefined;
+    when?: {
+        path?: string | undefined;
+    } | undefined;
+}, {
+    kind: "prop.value.forbid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    fix?: {
+        replaceWith?: unknown;
+    } | undefined;
+    when?: {
+        path?: string | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"a11y.requireName">;
+    because: z.ZodString;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "a11y.requireName";
+    severity: "error" | "info" | "warn";
+    because: string;
+}, {
+    kind: "a11y.requireName";
+    severity: "error" | "info" | "warn";
+    because: string;
+}>]>;
+declare const componentGovernanceRecordsSchema: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"capability">;
+    capability: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "capability";
+    capability: string;
+}, {
+    kind: "capability";
+    capability: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"prop.value.avoid">;
+    prop: z.ZodString;
+    value: z.ZodUnknown;
+    because: z.ZodString;
+    suggest: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "prop.value.avoid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    suggest?: string | undefined;
+}, {
+    kind: "prop.value.avoid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    suggest?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"prop.value.forbid">;
+    prop: z.ZodString;
+    value: z.ZodUnknown;
+    when: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+    }, {
+        path?: string | undefined;
+    }>>;
+    because: z.ZodString;
+    fix: z.ZodOptional<z.ZodObject<{
+        replaceWith: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        replaceWith?: unknown;
+    }, {
+        replaceWith?: unknown;
+    }>>;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "prop.value.forbid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    fix?: {
+        replaceWith?: unknown;
+    } | undefined;
+    when?: {
+        path?: string | undefined;
+    } | undefined;
+}, {
+    kind: "prop.value.forbid";
+    prop: string;
+    severity: "error" | "info" | "warn";
+    because: string;
+    value?: unknown;
+    fix?: {
+        replaceWith?: unknown;
+    } | undefined;
+    when?: {
+        path?: string | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"a11y.requireName">;
+    because: z.ZodString;
+    severity: z.ZodEnum<["error", "warn", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "a11y.requireName";
+    severity: "error" | "info" | "warn";
+    because: string;
+}, {
+    kind: "a11y.requireName";
+    severity: "error" | "info" | "warn";
+    because: string;
+}>]>, "many">;
+declare const componentPolicyRecordSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"capability">;
+        capability: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "capability";
+        capability: string;
+    }, {
+        kind: "capability";
+        capability: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"prop.value.avoid">;
+        prop: z.ZodString;
+        value: z.ZodUnknown;
+        because: z.ZodString;
+        suggest: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    }, {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"prop.value.forbid">;
+        prop: z.ZodString;
+        value: z.ZodUnknown;
+        when: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path?: string | undefined;
+        }, {
+            path?: string | undefined;
+        }>>;
+        because: z.ZodString;
+        fix: z.ZodOptional<z.ZodObject<{
+            replaceWith: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            replaceWith?: unknown;
+        }, {
+            replaceWith?: unknown;
+        }>>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    }, {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"a11y.requireName">;
+        because: z.ZodString;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    }, {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    }>]>, "many">;
+    status: z.ZodOptional<z.ZodEnum<["active", "draft", "disabled"]>>;
+}, "strict", z.ZodTypeAny, {
+    rules: ({
+        kind: "capability";
+        capability: string;
+    } | {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    } | {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    } | {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    })[];
+    status?: "active" | "draft" | "disabled" | undefined;
+}, {
+    rules: ({
+        kind: "capability";
+        capability: string;
+    } | {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    } | {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    } | {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    })[];
+    status?: "active" | "draft" | "disabled" | undefined;
+}>;
+declare const componentPolicyOverrideSchema: z.ZodObject<{
+    match: z.ZodObject<{
+        componentKey: z.ZodOptional<z.ZodString>;
+        componentId: z.ZodOptional<z.ZodString>;
+        publicRef: z.ZodOptional<z.ZodString>;
+        importPath: z.ZodOptional<z.ZodString>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        exportName: z.ZodOptional<z.ZodString>;
+        export: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<["one", "all"]>>;
+    }, "strict", z.ZodTypeAny, {
+        path?: string | undefined;
+        scope?: "one" | "all" | undefined;
+        importPath?: string | undefined;
+        componentId?: string | undefined;
+        name?: string | undefined;
+        componentKey?: string | undefined;
+        publicRef?: string | undefined;
+        sourcePath?: string | undefined;
+        exportName?: string | undefined;
+        export?: string | undefined;
+    }, {
+        path?: string | undefined;
+        scope?: "one" | "all" | undefined;
+        importPath?: string | undefined;
+        componentId?: string | undefined;
+        name?: string | undefined;
+        componentKey?: string | undefined;
+        publicRef?: string | undefined;
+        sourcePath?: string | undefined;
+        exportName?: string | undefined;
+        export?: string | undefined;
+    }>;
+    rules: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"capability">;
+        capability: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "capability";
+        capability: string;
+    }, {
+        kind: "capability";
+        capability: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"prop.value.avoid">;
+        prop: z.ZodString;
+        value: z.ZodUnknown;
+        because: z.ZodString;
+        suggest: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    }, {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"prop.value.forbid">;
+        prop: z.ZodString;
+        value: z.ZodUnknown;
+        when: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path?: string | undefined;
+        }, {
+            path?: string | undefined;
+        }>>;
+        because: z.ZodString;
+        fix: z.ZodOptional<z.ZodObject<{
+            replaceWith: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            replaceWith?: unknown;
+        }, {
+            replaceWith?: unknown;
+        }>>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    }, {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"a11y.requireName">;
+        because: z.ZodString;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    }, {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    }>]>, "many">;
+    status: z.ZodOptional<z.ZodEnum<["active", "draft", "disabled"]>>;
+}, "strict", z.ZodTypeAny, {
+    rules: ({
+        kind: "capability";
+        capability: string;
+    } | {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    } | {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    } | {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    })[];
+    match: {
+        path?: string | undefined;
+        scope?: "one" | "all" | undefined;
+        importPath?: string | undefined;
+        componentId?: string | undefined;
+        name?: string | undefined;
+        componentKey?: string | undefined;
+        publicRef?: string | undefined;
+        sourcePath?: string | undefined;
+        exportName?: string | undefined;
+        export?: string | undefined;
+    };
+    status?: "active" | "draft" | "disabled" | undefined;
+}, {
+    rules: ({
+        kind: "capability";
+        capability: string;
+    } | {
+        kind: "prop.value.avoid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        suggest?: string | undefined;
+    } | {
+        kind: "prop.value.forbid";
+        prop: string;
+        severity: "error" | "info" | "warn";
+        because: string;
+        value?: unknown;
+        fix?: {
+            replaceWith?: unknown;
+        } | undefined;
+        when?: {
+            path?: string | undefined;
+        } | undefined;
+    } | {
+        kind: "a11y.requireName";
+        severity: "error" | "info" | "warn";
+        because: string;
+    })[];
+    match: {
+        path?: string | undefined;
+        scope?: "one" | "all" | undefined;
+        importPath?: string | undefined;
+        componentId?: string | undefined;
+        name?: string | undefined;
+        componentKey?: string | undefined;
+        publicRef?: string | undefined;
+        sourcePath?: string | undefined;
+        exportName?: string | undefined;
+        export?: string | undefined;
+    };
+    status?: "active" | "draft" | "disabled" | undefined;
+}>;
+declare const canonicalSourceSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"npm">;
+    specifier: z.ZodString;
+    implementationPath: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "npm";
+    specifier: string;
+    implementationPath?: string | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}, {
+    kind: "npm";
+    specifier: string;
+    implementationPath?: string | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"directory">;
+    path: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "directory";
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}, {
+    path: string;
+    kind: "directory";
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"registry">;
+    registryId: z.ZodString;
+    registryHash: z.ZodOptional<z.ZodString>;
+    receiptPath: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    installPath: z.ZodEffects<z.ZodString, string, string>;
+    importPath: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    severity: z.ZodOptional<z.ZodEnum<["error", "warn", "info"]>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "registry";
+    registryId: string;
+    receiptPath: string;
+    installPath: string;
+    severity?: "error" | "info" | "warn" | undefined;
+    importPath?: string | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+    registryHash?: string | undefined;
+}, {
+    kind: "registry";
+    registryId: string;
+    installPath: string;
+    severity?: "error" | "info" | "warn" | undefined;
+    importPath?: string | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+    registryHash?: string | undefined;
+    receiptPath?: string | undefined;
+}>]>;
+declare const governanceConfigSchema: z.ZodObject<{
+    extends: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    severity: z.ZodOptional<z.ZodEnum<["error", "warn", "info"]>>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+    audit: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    runners: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>;
+    canonicalSources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"npm">;
+        specifier: z.ZodString;
+        implementationPath: z.ZodOptional<z.ZodString>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "npm";
+        specifier: string;
+        implementationPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        kind: "npm";
+        specifier: string;
+        implementationPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"directory">;
+        path: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "directory";
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        path: string;
+        kind: "directory";
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry">;
+        registryId: z.ZodString;
+        registryHash: z.ZodOptional<z.ZodString>;
+        receiptPath: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+        installPath: z.ZodEffects<z.ZodString, string, string>;
+        importPath: z.ZodOptional<z.ZodString>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        severity: z.ZodOptional<z.ZodEnum<["error", "warn", "info"]>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "registry";
+        registryId: string;
+        receiptPath: string;
+        installPath: string;
+        severity?: "error" | "info" | "warn" | undefined;
+        importPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        registryHash?: string | undefined;
+    }, {
+        kind: "registry";
+        registryId: string;
+        installPath: string;
+        severity?: "error" | "info" | "warn" | undefined;
+        importPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        registryHash?: string | undefined;
+        receiptPath?: string | undefined;
+    }>]>, "many">>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    scales: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodDefault<z.ZodLiteral<"scale">>;
+        name: z.ZodOptional<z.ZodString>;
+        unit: z.ZodEnum<["px", "rem"]>;
+        values: z.ZodArray<z.ZodNumber, "many">;
+        rootFontSizePx: z.ZodOptional<z.ZodNumber>;
+        emBasePx: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        values: number[];
+        kind: "scale";
+        unit: "px" | "rem";
+        name?: string | undefined;
+        rootFontSizePx?: number | undefined;
+        emBasePx?: number | undefined;
+    }, {
+        values: number[];
+        unit: "px" | "rem";
+        kind?: "scale" | undefined;
+        name?: string | undefined;
+        rootFontSizePx?: number | undefined;
+        emBasePx?: number | undefined;
+    }>>>;
+    styles: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"style.rawColors.forbid">;
+        except: z.ZodArray<z.ZodString, "many">;
+        prefer: z.ZodEnum<["token", "css-variable"]>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "style.rawColors.forbid";
+        severity: "error" | "info" | "warn";
+        except: string[];
+        prefer: "token" | "css-variable";
+    }, {
+        kind: "style.rawColors.forbid";
+        severity: "error" | "info" | "warn";
+        except: string[];
+        prefer: "token" | "css-variable";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"style.rawDimensions.forbid">;
+        appliesTo: z.ZodArray<z.ZodString, "many">;
+        prefer: z.ZodEnum<["token", "css-variable"]>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "style.rawDimensions.forbid";
+        severity: "error" | "info" | "warn";
+        prefer: "token" | "css-variable";
+        appliesTo: string[];
+    }, {
+        kind: "style.rawDimensions.forbid";
+        severity: "error" | "info" | "warn";
+        prefer: "token" | "css-variable";
+        appliesTo: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"style.rawSpacing.mustMatchScale">;
+        scale: z.ZodString;
+        appliesTo: z.ZodArray<z.ZodString, "many">;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "style.rawSpacing.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+        appliesTo: string[];
+    }, {
+        kind: "style.rawSpacing.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+        appliesTo: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"style.fontSize.mustMatchScale">;
+        scale: z.ZodString;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "style.fontSize.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+    }, {
+        kind: "style.fontSize.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"style.cssVars.mustBeDefined">;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "style.cssVars.mustBeDefined";
+        severity: "error" | "info" | "warn";
+    }, {
+        kind: "style.cssVars.mustBeDefined";
+        severity: "error" | "info" | "warn";
+    }>]>, "many">>;
+    jsx: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"jsx.unknownProps.forbid">;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "jsx.unknownProps.forbid";
+        severity: "error" | "info" | "warn";
+    }, {
+        kind: "jsx.unknownProps.forbid";
+        severity: "error" | "info" | "warn";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"jsx.inlineStyle.forbidRaw">;
+        properties: z.ZodArray<z.ZodString, "many">;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "jsx.inlineStyle.forbidRaw";
+        severity: "error" | "info" | "warn";
+        properties: string[];
+    }, {
+        kind: "jsx.inlineStyle.forbidRaw";
+        severity: "error" | "info" | "warn";
+        properties: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"jsx.importPath.prefer">;
+        from: z.ZodString;
+        to: z.ZodString;
+        imported: z.ZodOptional<z.ZodString>;
+        because: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "jsx.importPath.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        imported?: string | undefined;
+        because?: string | undefined;
+    }, {
+        kind: "jsx.importPath.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        imported?: string | undefined;
+        because?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"jsx.component.prefer">;
+        from: z.ZodString;
+        to: z.ZodString;
+        because: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<["error", "warn", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "jsx.component.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        because?: string | undefined;
+    }, {
+        kind: "jsx.component.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        because?: string | undefined;
+    }>]>, "many">>;
+    tailwind: z.ZodOptional<z.ZodObject<{
+        palette: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        palette: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        palette: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    agent: z.ZodOptional<z.ZodObject<{
+        repairOrder: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        repairOrder: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        repairOrder: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        rules: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"capability">;
+            capability: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "capability";
+            capability: string;
+        }, {
+            kind: "capability";
+            capability: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"prop.value.avoid">;
+            prop: z.ZodString;
+            value: z.ZodUnknown;
+            because: z.ZodString;
+            suggest: z.ZodOptional<z.ZodString>;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        }, {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"prop.value.forbid">;
+            prop: z.ZodString;
+            value: z.ZodUnknown;
+            when: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                path?: string | undefined;
+            }, {
+                path?: string | undefined;
+            }>>;
+            because: z.ZodString;
+            fix: z.ZodOptional<z.ZodObject<{
+                replaceWith: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                replaceWith?: unknown;
+            }, {
+                replaceWith?: unknown;
+            }>>;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        }, {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"a11y.requireName">;
+            because: z.ZodString;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        }, {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        }>]>, "many">;
+        status: z.ZodOptional<z.ZodEnum<["active", "draft", "disabled"]>>;
+    }, "strict", z.ZodTypeAny, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        status?: "active" | "draft" | "disabled" | undefined;
+    }, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        status?: "active" | "draft" | "disabled" | undefined;
+    }>>>;
+    overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        match: z.ZodObject<{
+            componentKey: z.ZodOptional<z.ZodString>;
+            componentId: z.ZodOptional<z.ZodString>;
+            publicRef: z.ZodOptional<z.ZodString>;
+            importPath: z.ZodOptional<z.ZodString>;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            exportName: z.ZodOptional<z.ZodString>;
+            export: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<["one", "all"]>>;
+        }, "strict", z.ZodTypeAny, {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        }, {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        }>;
+        rules: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"capability">;
+            capability: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "capability";
+            capability: string;
+        }, {
+            kind: "capability";
+            capability: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"prop.value.avoid">;
+            prop: z.ZodString;
+            value: z.ZodUnknown;
+            because: z.ZodString;
+            suggest: z.ZodOptional<z.ZodString>;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        }, {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"prop.value.forbid">;
+            prop: z.ZodString;
+            value: z.ZodUnknown;
+            when: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                path?: string | undefined;
+            }, {
+                path?: string | undefined;
+            }>>;
+            because: z.ZodString;
+            fix: z.ZodOptional<z.ZodObject<{
+                replaceWith: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                replaceWith?: unknown;
+            }, {
+                replaceWith?: unknown;
+            }>>;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        }, {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"a11y.requireName">;
+            because: z.ZodString;
+            severity: z.ZodEnum<["error", "warn", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        }, {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        }>]>, "many">;
+        status: z.ZodOptional<z.ZodEnum<["active", "draft", "disabled"]>>;
+    }, "strict", z.ZodTypeAny, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        match: {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        };
+        status?: "active" | "draft" | "disabled" | undefined;
+    }, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        match: {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        };
+        status?: "active" | "draft" | "disabled" | undefined;
+    }>, "many">>;
+    ci: z.ZodOptional<z.ZodObject<{
+        failOnWarnings: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        failOnWarnings: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        failOnWarnings: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    components?: Record<string, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        status?: "active" | "draft" | "disabled" | undefined;
+    }> | undefined;
+    severity?: "error" | "info" | "warn" | undefined;
+    rules?: Record<string, unknown> | undefined;
+    scales?: Record<string, {
+        values: number[];
+        kind: "scale";
+        unit: "px" | "rem";
+        name?: string | undefined;
+        rootFontSizePx?: number | undefined;
+        emBasePx?: number | undefined;
+    }> | undefined;
+    styles?: ({
+        kind: "style.rawColors.forbid";
+        severity: "error" | "info" | "warn";
+        except: string[];
+        prefer: "token" | "css-variable";
+    } | {
+        kind: "style.rawDimensions.forbid";
+        severity: "error" | "info" | "warn";
+        prefer: "token" | "css-variable";
+        appliesTo: string[];
+    } | {
+        kind: "style.rawSpacing.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+        appliesTo: string[];
+    } | {
+        kind: "style.fontSize.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+    } | {
+        kind: "style.cssVars.mustBeDefined";
+        severity: "error" | "info" | "warn";
+    })[] | undefined;
+    jsx?: ({
+        kind: "jsx.unknownProps.forbid";
+        severity: "error" | "info" | "warn";
+    } | {
+        kind: "jsx.inlineStyle.forbidRaw";
+        severity: "error" | "info" | "warn";
+        properties: string[];
+    } | {
+        kind: "jsx.importPath.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        imported?: string | undefined;
+        because?: string | undefined;
+    } | {
+        kind: "jsx.component.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        because?: string | undefined;
+    })[] | undefined;
+    tailwind?: z.objectOutputType<{
+        palette: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    overrides?: {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        match: {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        };
+        status?: "active" | "draft" | "disabled" | undefined;
+    }[] | undefined;
+    extends?: string[] | undefined;
+    agents?: Record<string, z.objectOutputType<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">> | undefined;
+    audit?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    runners?: Record<string, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    canonicalSources?: ({
+        kind: "npm";
+        specifier: string;
+        implementationPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | {
+        path: string;
+        kind: "directory";
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | {
+        kind: "registry";
+        registryId: string;
+        receiptPath: string;
+        installPath: string;
+        severity?: "error" | "info" | "warn" | undefined;
+        importPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        registryHash?: string | undefined;
+    })[] | undefined;
+    presets?: string[] | undefined;
+    agent?: z.objectOutputType<{
+        repairOrder: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    ci?: z.objectOutputType<{
+        failOnWarnings: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    components?: Record<string, {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        status?: "active" | "draft" | "disabled" | undefined;
+    }> | undefined;
+    severity?: "error" | "info" | "warn" | undefined;
+    rules?: Record<string, unknown> | undefined;
+    scales?: Record<string, {
+        values: number[];
+        unit: "px" | "rem";
+        kind?: "scale" | undefined;
+        name?: string | undefined;
+        rootFontSizePx?: number | undefined;
+        emBasePx?: number | undefined;
+    }> | undefined;
+    styles?: ({
+        kind: "style.rawColors.forbid";
+        severity: "error" | "info" | "warn";
+        except: string[];
+        prefer: "token" | "css-variable";
+    } | {
+        kind: "style.rawDimensions.forbid";
+        severity: "error" | "info" | "warn";
+        prefer: "token" | "css-variable";
+        appliesTo: string[];
+    } | {
+        kind: "style.rawSpacing.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+        appliesTo: string[];
+    } | {
+        kind: "style.fontSize.mustMatchScale";
+        severity: "error" | "info" | "warn";
+        scale: string;
+    } | {
+        kind: "style.cssVars.mustBeDefined";
+        severity: "error" | "info" | "warn";
+    })[] | undefined;
+    jsx?: ({
+        kind: "jsx.unknownProps.forbid";
+        severity: "error" | "info" | "warn";
+    } | {
+        kind: "jsx.inlineStyle.forbidRaw";
+        severity: "error" | "info" | "warn";
+        properties: string[];
+    } | {
+        kind: "jsx.importPath.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        imported?: string | undefined;
+        because?: string | undefined;
+    } | {
+        kind: "jsx.component.prefer";
+        from: string;
+        to: string;
+        severity: "error" | "info" | "warn";
+        because?: string | undefined;
+    })[] | undefined;
+    tailwind?: z.objectInputType<{
+        palette: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }, {
+            allow?: string[] | undefined;
+            deny?: string[] | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    overrides?: {
+        rules: ({
+            kind: "capability";
+            capability: string;
+        } | {
+            kind: "prop.value.avoid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            suggest?: string | undefined;
+        } | {
+            kind: "prop.value.forbid";
+            prop: string;
+            severity: "error" | "info" | "warn";
+            because: string;
+            value?: unknown;
+            fix?: {
+                replaceWith?: unknown;
+            } | undefined;
+            when?: {
+                path?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "a11y.requireName";
+            severity: "error" | "info" | "warn";
+            because: string;
+        })[];
+        match: {
+            path?: string | undefined;
+            scope?: "one" | "all" | undefined;
+            importPath?: string | undefined;
+            componentId?: string | undefined;
+            name?: string | undefined;
+            componentKey?: string | undefined;
+            publicRef?: string | undefined;
+            sourcePath?: string | undefined;
+            exportName?: string | undefined;
+            export?: string | undefined;
+        };
+        status?: "active" | "draft" | "disabled" | undefined;
+    }[] | undefined;
+    extends?: string[] | undefined;
+    agents?: Record<string, z.objectInputType<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">> | undefined;
+    audit?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    runners?: Record<string, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    canonicalSources?: ({
+        kind: "npm";
+        specifier: string;
+        implementationPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | {
+        path: string;
+        kind: "directory";
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | {
+        kind: "registry";
+        registryId: string;
+        installPath: string;
+        severity?: "error" | "info" | "warn" | undefined;
+        importPath?: string | undefined;
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        registryHash?: string | undefined;
+        receiptPath?: string | undefined;
+    })[] | undefined;
+    presets?: string[] | undefined;
+    agent?: z.objectInputType<{
+        repairOrder: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    ci?: z.objectInputType<{
+        failOnWarnings: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+type ScaleGovernanceRecord = z.infer<typeof scaleGovernanceRecordSchema>;
+type GlobalStyleGovernanceRecord = z.infer<typeof globalStyleGovernanceRecordSchema>;
+type GlobalJsxGovernanceRecord = z.infer<typeof globalJsxGovernanceRecordSchema>;
+type GlobalGovernanceRecord = z.infer<typeof globalGovernanceRecordSchema>;
+type ComponentGovernanceRecord = z.infer<typeof componentGovernanceRecordSchema>;
+type ComponentPolicyRecord = z.infer<typeof componentPolicyRecordSchema>;
+type ComponentPolicyOverride = z.infer<typeof componentPolicyOverrideSchema>;
+type CanonicalSource = z.infer<typeof canonicalSourceSchema>;
+interface GovernanceConfig {
+    extends?: string[];
+    severity?: GovernanceSeverity;
+    rules?: Record<string, unknown>;
+    agents?: Record<string, {
+        rules?: Record<string, unknown>;
+    }>;
+    audit?: Record<string, unknown>;
+    runners?: Record<string, Record<string, unknown>>;
+    canonicalSources?: CanonicalSource[];
+    presets?: string[];
+    scales?: Record<string, ScaleGovernanceRecord>;
+    styles?: GlobalStyleGovernanceRecord[];
+    jsx?: GlobalJsxGovernanceRecord[];
+    tailwind?: {
+        palette?: {
+            allow?: string[];
+            deny?: string[];
+        };
+        [key: string]: unknown;
+    };
+    agent?: {
+        repairOrder?: string[];
+        [key: string]: unknown;
+    };
+    components?: Record<string, ComponentPolicyRecord>;
+    overrides?: ComponentPolicyOverride[];
+    ci?: {
+        failOnWarnings?: boolean;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+type SeverityOption = {
+    severity?: GovernanceSeverity;
+};
+type PropContext = {
+    path?: string;
+};
+type NonNullish<T> = T extends null | undefined ? never : T;
+type GovernancePropValue<T> = NonNullish<T> extends string ? string extends NonNullish<T> ? string : NonNullish<T> : NonNullish<T> extends number ? number extends NonNullish<T> ? number : NonNullish<T> : NonNullish<T> extends boolean ? boolean extends NonNullish<T> ? boolean : NonNullish<T> : NonNullish<T>;
+type PropKey<TProps> = Extract<keyof TProps, string>;
+interface PropGovernanceOptions<TValue> extends SeverityOption {
+    because?: string;
+    suggest?: string;
+    when?: PropContext;
+    fix?: {
+        replaceWith: GovernancePropValue<TValue>;
+    };
+}
+interface PropGovernanceBuilder<TValue> {
+    avoid(value: GovernancePropValue<TValue>, options?: Omit<PropGovernanceOptions<TValue>, "fix" | "when">): ComponentGovernanceRecord;
+    forbid(value: GovernancePropValue<TValue>, options?: PropGovernanceOptions<TValue>): ComponentGovernanceRecord;
+}
+interface AccessibilityGovernanceBuilder {
+    requireName(options?: SeverityOption & {
+        because?: string;
+    }): ComponentGovernanceRecord;
+}
+interface ComponentGovernanceBuilder<TProps> {
+    capability(capability: string): ComponentGovernanceRecord;
+    prop<TKey extends PropKey<TProps>>(prop: TKey): PropGovernanceBuilder<TProps[TKey]>;
+    accessibility(): AccessibilityGovernanceBuilder;
+}
+interface GovernedFragmentDefinition<TProps = unknown, TComponent extends FragmentComponent<TProps> = FragmentComponent<TProps>> {
+    component: TComponent;
+    meta: FragmentMeta;
+    guidance: FragmentGuidance;
+    props?: Record<string, PropDefinition>;
+    relations?: ComponentRelation[];
+    examples?: FragmentExample[];
+    composition?: {
+        pattern?: "compound" | "simple" | "controlled" | "wrapper";
+        subComponents?: string[];
+        requiredChildren?: string[];
+        commonPatterns?: string[];
+    };
+    contract?: FragmentContract;
+    _provenance?: FragmentProvenance;
+    govern?: (g: ComponentGovernanceBuilder<TProps>) => ComponentGovernanceRecord[];
+    governance?: ComponentGovernanceRecord[];
+}
+type ResolvedGovernedFragmentDefinition<TProps = unknown, TComponent extends FragmentComponent<TProps> = FragmentComponent<TProps>> = GovernedFragmentDefinition<TProps, TComponent> & {
+    governance: ComponentGovernanceRecord[];
+};
+declare function normalizeGovernanceConfig<TConfig extends {
+    govern?: GovernanceConfig;
+}>(config: TConfig): TConfig;
+declare const g: {
+    scale: {
+        px(values: readonly number[]): ScaleGovernanceRecord;
+        rem(values: readonly number[]): ScaleGovernanceRecord;
+    };
+    styles: {
+        rawColors(): {
+            forbid(options?: {
+                except?: string[];
+                prefer?: "token" | "css-variable";
+                severity?: GovernanceSeverity;
+            }): GlobalStyleGovernanceRecord;
+        };
+        rawSpacing(): {
+            mustMatchScale(scale: string, options?: SeverityOption & {
+                appliesTo?: string[];
+            }): GlobalStyleGovernanceRecord;
+        };
+        fontSize(): {
+            mustMatchScale(scale: string, options?: SeverityOption): GlobalStyleGovernanceRecord;
+        };
+        cssVars(): {
+            mustBeDefined(options?: SeverityOption): GlobalStyleGovernanceRecord;
+        };
+    };
+    jsx: {
+        unknownProps(): {
+            forbid(options?: SeverityOption): GlobalJsxGovernanceRecord;
+        };
+        inlineStyle(): {
+            forbidRaw(properties: readonly string[], options?: SeverityOption): GlobalJsxGovernanceRecord;
+        };
+        importPath(): {
+            prefer(from: string, to: string, options?: SeverityOption & {
+                imported?: string;
+                because?: string;
+            }): GlobalJsxGovernanceRecord;
+        };
+        component(): {
+            prefer(from: string, to: string, options?: SeverityOption & {
+                because?: string;
+            }): GlobalJsxGovernanceRecord;
+        };
+    };
+    component: ComponentGovernanceBuilder<Record<string, unknown>>;
+};
+
+export { type FragmentContract as $, type AIMetadata as A, type BlockDefinition as B, type CompiledBlock as C, type CompiledTokenData as D, type CompiledTokenEntry as E, type FragmentDefinition as F, type GovernanceSeverity as G, type ComponentGovernanceBuilder as H, type ComponentGovernanceRecord as I, type ComponentRef as J, type ComponentRelation as K, type CompositionMetadata as L, type ContractCanonicalMappingInput as M, type ContractComponentInput as N, type ContractPolicyInput as O, type ContractPreimage as P, type ContractPropMappingInput as Q, type ResolvedGovernedFragmentDefinition as R, type StorybookFilterConfig as S, type TokenConfig as T, type ContractTokenInput as U, type VariantRenderOptions as V, type ContractWaiverInput as W, type ControlType as X, type DesignSystemConfig as Y, type DiffResult as Z, type FigmaPropMapping as _, type FragmentDefinitionV2 as a, type ImportEntry as a$, type FragmentExample as a0, type FragmentGenerated as a1, type FragmentGuidance as a2, type FragmentMeta as a3, type FragmentProvenance as a4, type FragmentUsage as a5, type FragmentVariant as a6, type GlobalGovernanceRecord as a7, type GlobalJsxGovernanceRecord as a8, type GlobalStyleGovernanceRecord as a9, type TokenSourceConfig as aA, type TokenSourceFormat as aB, type VerifyRequest as aC, type VerifyResult as aD, type Viewport as aE, componentGovernanceRecordSchema as aF, componentGovernanceRecordsSchema as aG, contractComponentsFromFragments as aH, contractPolicyFromGovernanceConfig as aI, diffContractDomains as aJ, g as aK, globalGovernanceRecordSchema as aL, globalJsxGovernanceRecordSchema as aM, globalStyleGovernanceRecordSchema as aN, governanceConfigSchema as aO, governanceConfigWithLocalCanonical as aP, governanceSeveritySchema as aQ, localCanonicalContractMappings as aR, normalizeGovernanceConfig as aS, projectContractPreimage as aT, scaleGovernanceRecordSchema as aU, type AIMetadata$1 as aV, type ComponentRelation$1 as aW, type FragmentContract$1 as aX, type FragmentGenerated$1 as aY, type FragmentMeta$1 as aZ, type FragmentUsage$1 as a_, type GovernancePropValue as aa, type InspectConfig as ab, type LocalCanonicalDeclaration as ac, type LocalCanonicalResolveRule as ad, type Manifest as ae, type ObservedComponentUsage as af, type ObservedUsageProp as ag, type PlayFunction as ah, type PlayFunctionContext as ai, type PropDefinition as aj, type PropGovernanceBuilder as ak, type PropGovernanceOptions as al, type PropKey as am, type PropType as an, type RecipeDefinition as ao, type RegistryOptions as ap, type RepoRelativePath as aq, type ScaleGovernanceRecord as ar, type Screenshot as as, type ScreenshotConfig as at, type ScreenshotMetadata as au, type ServiceConfig as av, type SnapshotConfig as aw, type SnippetPolicyConfig as ax, type Theme as ay, type ThemeSeeds as az, type CompiledFragment as b, type PerformanceData as b0, type PerformanceSummary as b1, type PropDefinition$1 as b2, type Theme$1 as b3, type VerifyResult$1 as b4, type ContractDomain as c, type ContractCatalogInput as d, type GovernedFragmentDefinition as e, type GovernanceConfig as f, type FragmentsConfig as g, type FragmentComponent as h, type FigmaStringMapping as i, type FigmaBooleanMapping as j, type FigmaEnumMapping as k, type FigmaInstanceMapping as l, type FigmaChildrenMapping as m, type FigmaTextContentMapping as n, type RelationshipType as o, type VariantLoader as p, type CanonicalSource as q, type AccessibilityGovernanceBuilder as r, type AppConfig as s, type BaselineInfo as t, type BoundingBox as u, CONTRACT_DOMAINS as v, CONTRACT_PREIMAGE_SCHEMA as w, type CanonicalMappingStatus as x, type CompiledFragmentsFile as y, type CompiledRecipe as z };