@usefragments/core 1.0.0

package/dist/chunk-243QYRUF.js

@@ -0,0 +1,2145 @@
+import {
+  normalizeFinding,
+  normalizeViolation
+} from "./chunk-R3X7UBHU.js";
+import {
+  authorOwnedImport,
+  canonicalizeOwnedComponentId,
+  canonicalizeOwnedImport,
+  ownedImportEquivalents,
+  projectV1OwnedComponentId,
+  projectV1OwnedImportIdentity
+} from "./chunk-JNBFJ34I.js";
+import {
+  portableRepoPathError
+} from "./chunk-EIYNNS77.js";
+
+// src/codes/codes.ts
+var EXPLAIN_URL_BASE = "https://usefragments.com/errors/";
+function code(entry) {
+  return {
+    ...entry,
+    explainUrl: `${EXPLAIN_URL_BASE}${entry.code}`
+  };
+}
+var CODES = [
+  code({
+    code: "FUI1001",
+    ruleId: "components/non-canonical",
+    category: "canonical-usage",
+    defaultSeverity: "serious",
+    title: "Component should use the canonical primitive",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI1002",
+    ruleId: "components/preferred-component",
+    category: "canonical-usage",
+    defaultSeverity: "serious",
+    title: "Preferred component should be used",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI1003",
+    ruleId: "imports/preferred-path",
+    category: "canonical-usage",
+    defaultSeverity: "moderate",
+    title: "Import should use the preferred path",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI1004",
+    ruleId: "components/prefer-library",
+    category: "canonical-usage",
+    defaultSeverity: "moderate",
+    title: "Library component should be preferred",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI1005",
+    ruleId: "components/allow",
+    category: "canonical-usage",
+    defaultSeverity: "serious",
+    title: "Component is not in the allowed set",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI1006",
+    ruleId: "components/deny",
+    category: "canonical-usage",
+    defaultSeverity: "serious",
+    title: "Component is denied by policy",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2001",
+    ruleId: "tokens/require-design-tokens",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Design token is required",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2002",
+    ruleId: "tokens/allowed-prefixes",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Token prefix is not allowed",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2003",
+    ruleId: "tokens/require-dual-fallback",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Token fallback is required",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2004",
+    ruleId: "styles/no-raw-dimensions",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Raw dimension should use a token",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2005",
+    ruleId: "styles/no-raw-color",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Raw color should use a token",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2006",
+    ruleId: "styles/no-raw-spacing",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Raw spacing should use the scale",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2007",
+    ruleId: "tailwind/arbitrary-color",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind arbitrary color should use a token",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2008",
+    ruleId: "tailwind/arbitrary-spacing",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind arbitrary spacing should use the scale",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2009",
+    ruleId: "tailwind/forbidden-palette",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind palette is forbidden",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2010",
+    ruleId: "tailwind/raw-color-via-token",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind color should use a resolved token",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2011",
+    ruleId: "tailwind/off-scale-spacing-token",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind spacing token is off scale",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2012",
+    ruleId: "tailwind/unknown-class",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Tailwind class is unknown",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2013",
+    ruleId: "brand/enforce-seeds",
+    category: "tokens",
+    defaultSeverity: "serious",
+    title: "Brand seed token is required",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2014",
+    ruleId: "theme/no-theme-coupled-literal",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "Theme-coupled literal should use a semantic token",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI2015",
+    ruleId: "tokens/css-vars-must-be-defined",
+    category: "tokens",
+    defaultSeverity: "moderate",
+    title: "CSS variable is not in the contract vocabulary",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI3001",
+    ruleId: "a11y/required-accessible-name",
+    category: "a11y",
+    defaultSeverity: "serious",
+    title: "Accessible name is required",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI3002",
+    ruleId: "a11y/standard",
+    category: "a11y",
+    defaultSeverity: "serious",
+    title: "Accessibility standard failed",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI5001",
+    ruleId: "components/required-children",
+    category: "composition",
+    defaultSeverity: "serious",
+    title: "Required child component is missing",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI5002",
+    ruleId: "components/canonical-usage",
+    category: "composition",
+    defaultSeverity: "serious",
+    title: "Component should use canonical composition",
+    lifecycle: "deprecated",
+    replacedBy: "FUI1001",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI5003",
+    ruleId: "composition/cardinality",
+    category: "composition",
+    defaultSeverity: "moderate",
+    title: "Too many of a component in one region",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI5004",
+    ruleId: "composition/co-occurrence",
+    category: "composition",
+    defaultSeverity: "moderate",
+    title: "Required companion component is missing from the region",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI6001",
+    ruleId: "props/unknown",
+    category: "props",
+    defaultSeverity: "moderate",
+    title: "Prop is unknown",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI6002",
+    ruleId: "props/invalid-value",
+    category: "props",
+    defaultSeverity: "serious",
+    title: "Prop value is invalid",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI6003",
+    ruleId: "props/banned-pattern",
+    category: "props",
+    defaultSeverity: "serious",
+    title: "Prop pattern is banned",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI6004",
+    ruleId: "components/forbidden-prop-value",
+    category: "props",
+    defaultSeverity: "serious",
+    title: "Prop value is forbidden",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI6005",
+    ruleId: "components/unknown-prop",
+    category: "props",
+    defaultSeverity: "moderate",
+    title: "Component prop is unknown",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8001",
+    ruleId: "safety/block-event-handlers",
+    category: "safety",
+    defaultSeverity: "serious",
+    title: "Event handler prop is blocked",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8002",
+    ruleId: "safety/block-dangerous-props",
+    category: "safety",
+    defaultSeverity: "critical",
+    title: "Dangerous prop is blocked",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8003",
+    ruleId: "safety/block-controlled-props",
+    category: "safety",
+    defaultSeverity: "serious",
+    title: "Controlled prop is blocked",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8004",
+    ruleId: "safety/block-function-props",
+    category: "safety",
+    defaultSeverity: "serious",
+    title: "Function prop is blocked",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8005",
+    ruleId: "safety/block-internal-props",
+    category: "safety",
+    defaultSeverity: "critical",
+    title: "Internal prop is blocked",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI8006",
+    ruleId: "safety/sanitize-hrefs",
+    category: "safety",
+    defaultSeverity: "critical",
+    title: "Href must be sanitized",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI9001",
+    ruleId: "unused-suppression",
+    category: "system",
+    defaultSeverity: "minor",
+    title: "Suppression is unused",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI9002",
+    ruleId: "expired-suppression",
+    category: "system",
+    defaultSeverity: "serious",
+    title: "Suppression is expired",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  }),
+  code({
+    code: "FUI9003",
+    ruleId: "missing-expiry",
+    category: "system",
+    defaultSeverity: "minor",
+    title: "Suppression expiry is missing",
+    lifecycle: "experimental",
+    fixAvailable: true,
+    evidenceRequired: true
+  })
+];
+var byCode = new Map(
+  CODES.map((entry) => [entry.code, entry])
+);
+var byRuleId = new Map(
+  CODES.map((entry) => [entry.ruleId, entry])
+);
+function explainUrlForCode(code2) {
+  return `${EXPLAIN_URL_BASE}${code2}`;
+}
+
+// src/facts/ids.ts
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+var FNV_PRIME = 16777619;
+var FNV_SEED_A = 2166136261;
+var FNV_SEED_B = 2654435761;
+function fnv1a32(input, seed) {
+  let hash = seed >>> 0;
+  for (let i = 0; i < input.length; i++) {
+    const code2 = input.charCodeAt(i);
+    hash ^= code2 & 255;
+    hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    if (code2 > 255) {
+      hash ^= code2 >>> 8 & 255;
+      hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+  }
+  return hash >>> 0;
+}
+function hash64Hex(input) {
+  const a = fnv1a32(input, FNV_SEED_A);
+  const b = fnv1a32(input, FNV_SEED_B);
+  return a.toString(16).padStart(8, "0") + b.toString(16).padStart(8, "0");
+}
+function componentId(packageName, name) {
+  if (!packageName.length || !name.length) {
+    throw new Error("componentId requires a non-empty packageName and name");
+  }
+  return `${authorOwnedImport(packageName)}#${name}`;
+}
+function asComponentId(value) {
+  if (!value.includes("#")) {
+    throw new Error(`componentId must look like "package#Name", got "${value}"`);
+  }
+  return value;
+}
+function factId(kind, identity) {
+  const payload = canonicalJson({ k: kind, i: projectFactIdentityV1(kind, identity) });
+  return `${kind}:${hash64Hex(payload)}`;
+}
+function projectFactIdentityV1(kind, identity) {
+  return Object.fromEntries(
+    Object.entries(identity).map(([key, value]) => {
+      if (key === "componentId" && typeof value === "string") {
+        return [key, projectV1OwnedComponentId(value)];
+      }
+      if (kind === "jsx_component_preferred" && (key === "from" || key === "to") && typeof value === "string") {
+        return [key, projectV1OwnedComponentId(value)];
+      }
+      if (kind === "jsx_import_path_preferred" && (key === "from" || key === "to") && typeof value === "string") {
+        return [key, projectV1OwnedImportIdentity(value)];
+      }
+      if (kind === "usage_import" && key === "source" && typeof value === "string") {
+        return [key, projectV1OwnedImportIdentity(value)];
+      }
+      return [key, value];
+    })
+  );
+}
+
+// src/facts/builders.ts
+function makeComponentMetadataFact(input) {
+  return {
+    id: factId("component", { componentId: input.componentId }),
+    kind: "component",
+    componentId: input.componentId,
+    name: input.name,
+    description: input.description,
+    category: input.category,
+    filePath: input.filePath
+  };
+}
+function makeComponentCapabilityFact(input) {
+  return {
+    id: factId("component_capability", {
+      componentId: input.componentId,
+      capability: input.capability
+    }),
+    kind: "component_capability",
+    componentId: input.componentId,
+    capability: input.capability
+  };
+}
+function makeCanonicalCandidateFact(input) {
+  return {
+    id: factId("canonical_candidate", {
+      componentId: input.componentId,
+      canonical: input.canonical,
+      classifierVersion: input.classifierVersion,
+      vocabVersion: input.vocabVersion
+    }),
+    kind: "canonical_candidate",
+    componentId: input.componentId,
+    canonical: input.canonical,
+    confidence: input.confidence,
+    band: input.band,
+    location: input.location,
+    classifierVersion: input.classifierVersion,
+    vocabVersion: input.vocabVersion,
+    evidence: input.evidence,
+    userConfirmed: input.userConfirmed
+  };
+}
+function makeCanonicalMappingFact(input) {
+  return {
+    id: factId("canonical_mapping", {
+      componentId: input.componentId,
+      canonical: input.canonical
+    }),
+    kind: "canonical_mapping",
+    componentId: input.componentId,
+    canonical: input.canonical,
+    status: input.status,
+    confidence: input.confidence,
+    location: input.location
+  };
+}
+function makeStructuralConfidenceFact(input) {
+  return {
+    id: factId("structural_confidence", {
+      componentId: input.componentId,
+      canonical: input.canonical
+    }),
+    kind: "structural_confidence",
+    componentId: input.componentId,
+    canonical: input.canonical,
+    confidence: input.confidence,
+    signalCount: input.signalCount,
+    location: input.location
+  };
+}
+function makeCanonicalReplacementFact(input) {
+  return {
+    id: factId("canonical_replacement", {
+      componentId: input.componentId,
+      canonical: input.canonical
+    }),
+    kind: "canonical_replacement",
+    componentId: input.componentId,
+    canonical: input.canonical,
+    importPath: input.importPath,
+    componentName: input.componentName,
+    confidence: input.confidence,
+    location: input.location
+  };
+}
+function makePropMetadataFact(input) {
+  return {
+    id: factId("prop_metadata", {
+      componentId: input.componentId,
+      prop: input.prop
+    }),
+    kind: "prop_metadata",
+    componentId: input.componentId,
+    prop: input.prop,
+    type: input.type,
+    values: input.values,
+    required: input.required,
+    default: input.default,
+    description: input.description
+  };
+}
+function makePropValueAvoidedFact(input) {
+  return {
+    id: factId("prop_value_avoided", {
+      componentId: input.componentId,
+      prop: input.prop,
+      value: input.value
+    }),
+    kind: "prop_value_avoided",
+    componentId: input.componentId,
+    prop: input.prop,
+    value: input.value,
+    because: input.because,
+    suggest: input.suggest,
+    severity: input.severity
+  };
+}
+function makePropValueForbiddenFact(input) {
+  return {
+    id: factId("prop_value_forbidden", {
+      componentId: input.componentId,
+      prop: input.prop,
+      value: input.value,
+      pathPattern: input.pathPattern
+    }),
+    kind: "prop_value_forbidden",
+    componentId: input.componentId,
+    prop: input.prop,
+    value: input.value,
+    pathPattern: input.pathPattern,
+    because: input.because,
+    replaceWith: input.replaceWith,
+    severity: input.severity
+  };
+}
+function makeA11yNameRequiredFact(input) {
+  return {
+    id: factId("a11y_name_required", { componentId: input.componentId }),
+    kind: "a11y_name_required",
+    componentId: input.componentId,
+    because: input.because,
+    severity: input.severity
+  };
+}
+function makeScaleFact(input) {
+  return {
+    id: factId("scale", { name: input.name }),
+    kind: "scale",
+    name: input.name,
+    unit: input.unit,
+    ...input.rootFontSizePx === void 0 ? {} : { rootFontSizePx: input.rootFontSizePx },
+    ...input.emBasePx === void 0 ? {} : { emBasePx: input.emBasePx }
+  };
+}
+function makeScaleValueFact(input) {
+  return {
+    id: factId("scale_value", { scale: input.scale, value: input.value }),
+    kind: "scale_value",
+    scale: input.scale,
+    value: input.value
+  };
+}
+function makeStyleRawColorForbiddenFact(input) {
+  return {
+    id: factId("style_raw_color_forbidden", {}),
+    kind: "style_raw_color_forbidden",
+    except: [...input.except],
+    prefer: input.prefer,
+    severity: input.severity
+  };
+}
+function makeStyleRawDimensionForbiddenFact(input) {
+  return {
+    id: factId("style_raw_dimension_forbidden", {}),
+    kind: "style_raw_dimension_forbidden",
+    appliesTo: [...input.appliesTo],
+    prefer: input.prefer,
+    severity: input.severity
+  };
+}
+function makeStylePropertyScaleFact(input) {
+  return {
+    id: factId("style_property_scale", { property: input.property }),
+    kind: "style_property_scale",
+    property: input.property,
+    scale: input.scale,
+    severity: input.severity
+  };
+}
+function makeStyleFontSizeScaleFact(input) {
+  return {
+    id: factId("style_font_size_scale", {}),
+    kind: "style_font_size_scale",
+    scale: input.scale,
+    severity: input.severity
+  };
+}
+function makeStyleCssVarsMustBeDefinedFact(input) {
+  return {
+    id: factId("style_css_vars_must_be_defined", {}),
+    kind: "style_css_vars_must_be_defined",
+    severity: input.severity
+  };
+}
+function makeContractTokenFact(input) {
+  const name = input.name.startsWith("--") ? input.name : `--${input.name}`;
+  return {
+    id: factId("contract_token", { name }),
+    kind: "contract_token",
+    name
+  };
+}
+function makeJsxUnknownPropsForbiddenFact(input) {
+  return {
+    id: factId("jsx_unknown_props_forbidden", {}),
+    kind: "jsx_unknown_props_forbidden",
+    severity: input.severity
+  };
+}
+function makeJsxInlineStyleForbiddenRawFact(input) {
+  return {
+    id: factId("jsx_inline_style_forbidden_raw", { property: input.property }),
+    kind: "jsx_inline_style_forbidden_raw",
+    property: input.property,
+    severity: input.severity
+  };
+}
+function makeJsxImportPathPreferredFact(input) {
+  return {
+    id: factId("jsx_import_path_preferred", {
+      from: input.from,
+      to: input.to,
+      imported: input.imported
+    }),
+    kind: "jsx_import_path_preferred",
+    from: input.from,
+    to: input.to,
+    imported: input.imported,
+    because: input.because,
+    severity: input.severity
+  };
+}
+function makeJsxComponentPreferredFact(input) {
+  return {
+    id: factId("jsx_component_preferred", {
+      from: input.from,
+      to: input.to
+    }),
+    kind: "jsx_component_preferred",
+    from: input.from,
+    to: input.to,
+    because: input.because,
+    severity: input.severity
+  };
+}
+function makeTokenDefinitionFact(input) {
+  return {
+    id: factId("token_definition", { name: input.name }),
+    kind: "token_definition",
+    name: input.name,
+    value: input.value,
+    category: input.category,
+    referenceFormat: input.referenceFormat
+  };
+}
+function makeTailwindPaletteAllowFact(input) {
+  return {
+    id: factId("tailwind_palette_allow", {}),
+    kind: "tailwind_palette_allow",
+    patterns: [...input.patterns],
+    severity: input.severity
+  };
+}
+function makeTailwindPaletteDenyFact(input) {
+  return {
+    id: factId("tailwind_palette_deny", {}),
+    kind: "tailwind_palette_deny",
+    patterns: [...input.patterns],
+    severity: input.severity
+  };
+}
+function makeTailwindUnknownClassEnabledFact(input) {
+  return {
+    id: factId("tailwind_unknown_class_enabled", {}),
+    kind: "tailwind_unknown_class_enabled",
+    severity: input.severity
+  };
+}
+function makeGovernanceRuleConfigFact(input) {
+  return {
+    id: factId("governance_rule_config", { ruleId: input.ruleId }),
+    kind: "governance_rule_config",
+    ruleId: input.ruleId,
+    enabled: input.enabled,
+    severity: input.severity,
+    options: input.options
+  };
+}
+function makeUsageNodeFact(input) {
+  return {
+    // Identity is structural (file + nodePath + element) only — the normalized
+    // semantics (role/interactive) are evidence carried on the fact, never part
+    // of its ID, so adding them never perturbs existing fact identities.
+    id: factId("usage_node", {
+      file: input.file,
+      nodePath: input.nodePath,
+      element: input.element
+    }),
+    kind: "usage_node",
+    file: input.file,
+    nodePath: input.nodePath,
+    element: input.element,
+    ...input.role !== void 0 ? { role: input.role } : {},
+    ...input.interactive ? { interactive: true } : {},
+    location: input.location
+  };
+}
+function makeUsageComponentFact(input) {
+  return {
+    id: factId("usage_component", {
+      nodeId: input.nodeId,
+      componentId: input.componentId
+    }),
+    kind: "usage_component",
+    nodeId: input.nodeId,
+    componentId: input.componentId
+  };
+}
+function makeUsageImportFact(input) {
+  return {
+    id: factId("usage_import", {
+      file: input.file,
+      local: input.local,
+      imported: input.imported,
+      source: input.source
+    }),
+    kind: "usage_import",
+    file: input.file,
+    local: input.local,
+    imported: input.imported,
+    source: input.source,
+    namespace: input.namespace,
+    location: input.location
+  };
+}
+function makeUsagePropResolvedFact(input) {
+  return {
+    id: factId("usage_prop_resolved", { nodeId: input.nodeId, prop: input.prop }),
+    kind: "usage_prop_resolved",
+    nodeId: input.nodeId,
+    prop: input.prop,
+    resolution: input.resolution,
+    value: input.value,
+    location: input.location
+  };
+}
+function makeUsageInlineStyleFact(input) {
+  return {
+    id: factId("usage_inline_style", {
+      nodeId: input.nodeId,
+      property: input.property
+    }),
+    kind: "usage_inline_style",
+    nodeId: input.nodeId,
+    property: input.property,
+    valueKind: input.valueKind,
+    value: input.value
+  };
+}
+function makeUsageTextChildFact(input) {
+  return {
+    id: factId("usage_text_child", { nodeId: input.nodeId, index: input.index }),
+    kind: "usage_text_child",
+    nodeId: input.nodeId,
+    text: input.text,
+    index: input.index
+  };
+}
+function makeClassNameLiteralFact(input) {
+  return {
+    id: factId("classname_literal", {
+      nodeId: input.nodeId,
+      attr: input.attr,
+      origin: input.origin,
+      originPath: input.originPath
+    }),
+    kind: "classname_literal",
+    file: input.file,
+    nodeId: input.nodeId,
+    attr: input.attr,
+    classes: [...input.classes],
+    origin: input.origin,
+    originPath: input.originPath,
+    location: input.location
+  };
+}
+function makeClassNameDynamicFact(input) {
+  return {
+    id: factId("classname_dynamic", {
+      nodeId: input.nodeId,
+      attr: input.attr,
+      reason: input.reason,
+      originPath: input.originPath
+    }),
+    kind: "classname_dynamic",
+    file: input.file,
+    nodeId: input.nodeId,
+    attr: input.attr,
+    reason: input.reason,
+    snippet: input.snippet,
+    originPath: input.originPath,
+    location: input.location
+  };
+}
+function makeTailwindClassFact(input) {
+  return {
+    id: factId("tailwind_class", {
+      nodeId: input.nodeId,
+      originPath: input.originPath
+    }),
+    kind: "tailwind_class",
+    file: input.file,
+    nodeId: input.nodeId,
+    raw: input.raw,
+    originPath: input.originPath,
+    prefix: input.prefix,
+    modifiers: input.modifiers.map((m) => ({ ...m })),
+    important: input.important,
+    negative: input.negative,
+    utility: input.utility,
+    value: { ...input.value },
+    location: input.location
+  };
+}
+function makeThemeDeclarationFact(input) {
+  return {
+    id: factId("theme_declaration", {
+      file: input.file,
+      name: input.name,
+      declarationPath: input.declarationPath
+    }),
+    kind: "theme_declaration",
+    file: input.file,
+    name: input.name,
+    value: input.value,
+    declarationPath: input.declarationPath,
+    inline: input.inline,
+    flavor: input.flavor,
+    location: input.location
+  };
+}
+function makeTailwindTokenResolvedFact(input) {
+  return {
+    id: factId("tailwind_token_resolved", {
+      utility: input.utility,
+      token: input.token
+    }),
+    kind: "tailwind_token_resolved",
+    utility: input.utility,
+    token: input.token,
+    resolved: { ...input.resolved }
+  };
+}
+function makeStyleDeclarationFact(input) {
+  return {
+    id: factId("style_declaration", {
+      file: input.file,
+      selector: input.selector,
+      declarationPath: input.declarationPath,
+      property: input.property
+    }),
+    kind: "style_declaration",
+    file: input.file,
+    selector: input.selector,
+    declarationPath: input.declarationPath,
+    property: input.property,
+    value: input.value,
+    location: input.location,
+    ...input.declaredTokenSource ? { declaredTokenSource: true } : {}
+  };
+}
+function makeStyleUnsupportedFact(input) {
+  return {
+    id: factId("style_unsupported", {
+      file: input.file,
+      source: input.source,
+      syntax: input.syntax,
+      selector: input.selector,
+      declarationPath: input.declarationPath,
+      property: input.property ?? ""
+    }),
+    kind: "style_unsupported",
+    file: input.file,
+    source: input.source,
+    syntax: input.syntax,
+    selector: input.selector,
+    declarationPath: input.declarationPath,
+    property: input.property,
+    reason: input.reason,
+    location: input.location
+  };
+}
+
+// src/package-identity-match.ts
+function ownedImportsEqual(left, right) {
+  if (left === right) return true;
+  if (ownedImportEquivalents(left).includes(right)) return true;
+  return canonicalizeOwnedImport(left) === canonicalizeOwnedImport(right);
+}
+function ownedImportMatchesRoot(imported, configuredRoot) {
+  for (const equivalent of ownedImportEquivalents(configuredRoot)) {
+    if (imported === equivalent || imported.startsWith(`${equivalent}/`)) {
+      return true;
+    }
+  }
+  const canonicalImported = canonicalizeOwnedImport(imported);
+  const canonicalRoot = canonicalizeOwnedImport(configuredRoot);
+  return canonicalImported === canonicalRoot || canonicalImported.startsWith(`${canonicalRoot}/`);
+}
+function ownedComponentIdsEqual(left, right) {
+  return canonicalizeOwnedComponentId(left) === canonicalizeOwnedComponentId(right);
+}
+
+// src/facts/fact-index.ts
+function hasComponentId(fact) {
+  return "componentId" in fact && typeof fact.componentId === "string";
+}
+function logicalComponentId(componentId2) {
+  return canonicalizeOwnedComponentId(componentId2);
+}
+function logicalFactForComparison(fact) {
+  if (fact.kind === "jsx_import_path_preferred") {
+    return {
+      ...fact,
+      from: canonicalizeOwnedImport(fact.from),
+      to: canonicalizeOwnedImport(fact.to)
+    };
+  }
+  if (fact.kind === "jsx_component_preferred") {
+    return {
+      ...fact,
+      from: logicalComponentId(fact.from),
+      to: logicalComponentId(fact.to)
+    };
+  }
+  if (fact.kind === "usage_import") {
+    return { ...fact, source: canonicalizeOwnedImport(fact.source) };
+  }
+  if (hasComponentId(fact)) {
+    return { ...fact, componentId: logicalComponentId(fact.componentId) };
+  }
+  return { ...fact };
+}
+function uniqueByLogicalIdentity(items, keyOf) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyOf(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function matchesGlob(path, pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const expanded = escaped.replace(/\*\*/g, "::DOUBLE::").replace(/\*/g, "[^/]*").replace(/::DOUBLE::/g, ".*");
+  return new RegExp(`^${expanded}$`).test(path);
+}
+var FactIndex = class {
+  facts = /* @__PURE__ */ new Map();
+  idsByKind = /* @__PURE__ */ new Map();
+  idsByComponent = /* @__PURE__ */ new Map();
+  add(fact) {
+    const existing = this.facts.get(fact.id);
+    if (existing) {
+      if (canonicalJson(logicalFactForComparison(existing)) !== canonicalJson(logicalFactForComparison(fact))) {
+        console.warn(
+          `FactIndex: conflicting facts for id ${fact.id} \u2014 keeping first fact, skipping ${describeFactForConflict(fact)}`
+        );
+      }
+      return;
+    }
+    this.facts.set(fact.id, fact);
+    let byKind = this.idsByKind.get(fact.kind);
+    if (!byKind) {
+      byKind = /* @__PURE__ */ new Set();
+      this.idsByKind.set(fact.kind, byKind);
+    }
+    byKind.add(fact.id);
+    if (hasComponentId(fact)) {
+      const componentId2 = logicalComponentId(fact.componentId);
+      let byComponent = this.idsByComponent.get(componentId2);
+      if (!byComponent) {
+        byComponent = /* @__PURE__ */ new Set();
+        this.idsByComponent.set(componentId2, byComponent);
+      }
+      byComponent.add(fact.id);
+    }
+  }
+  addMany(facts) {
+    for (const fact of facts) this.add(fact);
+  }
+  get(id) {
+    return this.facts.get(id);
+  }
+  has(id) {
+    return this.facts.has(id);
+  }
+  size() {
+    return this.facts.size;
+  }
+  all() {
+    return [...this.facts.values()];
+  }
+  byKind(kind) {
+    const ids = this.idsByKind.get(kind);
+    if (!ids) return [];
+    const out = [];
+    for (const id of ids) {
+      const fact = this.facts.get(id);
+      if (fact && fact.kind === kind) out.push(fact);
+    }
+    return out;
+  }
+  /**
+   * Resolve evidence for a list of fact IDs. Throws if any ID is missing —
+   * findings must never reference facts that aren't in the index.
+   */
+  evidence(ids) {
+    const missing = [];
+    const out = [];
+    for (const id of ids) {
+      const fact = this.facts.get(id);
+      if (!fact) {
+        missing.push(id);
+        continue;
+      }
+      out.push({ factId: id, fact });
+    }
+    if (missing.length) {
+      throw new Error(`FactIndex.evidence: missing facts in index: ${missing.join(", ")}`);
+    }
+    return out;
+  }
+  // ---------------------------------------------------------------------
+  // Component queries
+  // ---------------------------------------------------------------------
+  components = {
+    list: () => uniqueByLogicalIdentity(
+      this.byKind("component"),
+      (fact) => canonicalJson({
+        ...logicalFactForComparison(fact),
+        id: void 0
+      })
+    ),
+    byId: (componentId2) => this.byComponentOfKind(componentId2, "component")[0],
+    propsOf: (componentId2) => this.byComponentOfKind(componentId2, "prop_metadata"),
+    propOf: (componentId2, prop) => this.components.propsOf(componentId2).find((p) => p.prop === prop),
+    capabilitiesOf: (componentId2) => this.byComponentOfKind(componentId2, "component_capability")
+  };
+  // ---------------------------------------------------------------------
+  // Policy queries
+  // ---------------------------------------------------------------------
+  policy = {
+    forbiddenPropValues: (componentId2, opts = {}) => {
+      const all = this.byComponentOfKind(
+        componentId2,
+        "prop_value_forbidden"
+      );
+      return all.filter((fact) => {
+        if (opts.prop !== void 0 && fact.prop !== opts.prop) return false;
+        if (opts.value !== void 0 && fact.value !== opts.value) return false;
+        if (opts.path !== void 0 && fact.pathPattern) {
+          if (!matchesGlob(opts.path, fact.pathPattern)) return false;
+        }
+        return true;
+      });
+    },
+    avoidedPropValues: (componentId2, opts = {}) => {
+      const all = this.byComponentOfKind(componentId2, "prop_value_avoided");
+      return all.filter((fact) => {
+        if (opts.prop !== void 0 && fact.prop !== opts.prop) return false;
+        if (opts.value !== void 0 && fact.value !== opts.value) return false;
+        return true;
+      });
+    },
+    a11yNameRequired: (componentId2) => this.byComponentOfKind(componentId2, "a11y_name_required")[0],
+    scales: () => this.byKind("scale"),
+    scale: (name) => this.byKind("scale").find((s) => s.name === name),
+    scaleValues: (name) => this.byKind("scale_value").filter((v) => v.scale === name),
+    rawColorPolicy: () => this.byKind("style_raw_color_forbidden")[0],
+    rawDimensionPolicy: () => this.byKind("style_raw_dimension_forbidden")[0],
+    propertyScale: (property) => this.byKind("style_property_scale").find((p) => p.property === property),
+    fontSizeScale: () => this.byKind("style_font_size_scale")[0],
+    cssVarsMustBeDefined: () => this.byKind("style_css_vars_must_be_defined")[0],
+    tailwindPaletteAllow: () => this.byKind("tailwind_palette_allow")[0],
+    tailwindPaletteDeny: () => this.byKind("tailwind_palette_deny")[0],
+    tailwindUnknownClassEnabled: () => this.byKind("tailwind_unknown_class_enabled")[0],
+    ruleConfig: (ruleId) => this.byKind("governance_rule_config").find((fact) => fact.ruleId === ruleId),
+    jsxUnknownPropsForbidden: () => this.byKind("jsx_unknown_props_forbidden")[0],
+    jsxInlineStyleForbiddenRaw: (opts = {}) => {
+      const all = this.byKind("jsx_inline_style_forbidden_raw");
+      return opts.property === void 0 ? all : all.filter((f) => f.property === opts.property);
+    },
+    jsxImportPathPreferred: (opts = {}) => {
+      const all = uniqueByLogicalIdentity(
+        this.byKind("jsx_import_path_preferred"),
+        (fact) => canonicalJson({
+          from: canonicalizeOwnedImport(fact.from),
+          to: canonicalizeOwnedImport(fact.to),
+          imported: fact.imported,
+          because: fact.because,
+          severity: fact.severity
+        })
+      );
+      return all.filter((fact) => {
+        if (opts.from !== void 0 && !ownedImportsEqual(fact.from, opts.from)) return false;
+        if (opts.imported !== void 0 && fact.imported !== opts.imported) return false;
+        return true;
+      });
+    },
+    jsxComponentPreferred: (opts = {}) => {
+      const all = uniqueByLogicalIdentity(
+        this.byKind("jsx_component_preferred"),
+        (fact) => canonicalJson({
+          from: canonicalizeOwnedComponentId(fact.from),
+          to: canonicalizeOwnedComponentId(fact.to),
+          because: fact.because,
+          severity: fact.severity
+        })
+      );
+      return opts.from === void 0 ? all : all.filter((fact) => ownedComponentIdsEqual(fact.from, opts.from));
+    }
+  };
+  // ---------------------------------------------------------------------
+  // Token registry queries
+  // ---------------------------------------------------------------------
+  tokens = {
+    list: () => this.byKind("token_definition"),
+    byCategory: (category) => this.byKind("token_definition").filter((t) => t.category === category)
+  };
+  // ---------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------
+  byComponentOfKind(componentId2, kind) {
+    const ids = this.idsByComponent.get(logicalComponentId(componentId2));
+    if (!ids) return [];
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const fact = this.facts.get(id);
+      if (fact && fact.kind === kind) {
+        const logicalFact = hasComponentId(fact) ? {
+          ...fact,
+          id: void 0,
+          componentId: logicalComponentId(fact.componentId)
+        } : { ...fact, id: void 0 };
+        const key = canonicalJson(logicalFact);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(fact);
+      }
+    }
+    return out;
+  }
+};
+function describeFactForConflict(fact) {
+  const parts = [`kind=${fact.kind}`];
+  const maybeLocation = "location" in fact ? fact.location : void 0;
+  if (maybeLocation && typeof maybeLocation === "object") {
+    const loc = maybeLocation;
+    if (typeof loc.file === "string") {
+      const line = typeof loc.line === "number" ? `:${loc.line}` : "";
+      const column = typeof loc.column === "number" ? `:${loc.column}` : "";
+      parts.push(`location=${loc.file}${line}${column}`);
+    }
+  }
+  if ("nodePath" in fact && typeof fact.nodePath === "string") {
+    parts.push(`nodePath=${fact.nodePath}`);
+  }
+  if ("element" in fact && typeof fact.element === "string") {
+    parts.push(`element=${fact.element}`);
+  }
+  return parts.join(" ");
+}
+
+// src/governance.ts
+import { z } from "zod";
+var governanceSeveritySchema = z.enum(["error", "warn", "info"]);
+var scaleGovernanceRecordSchema = z.object({
+  kind: z.literal("scale").default("scale"),
+  name: z.string().min(1).optional(),
+  unit: z.enum(["px", "rem"]),
+  values: z.array(z.number()),
+  rootFontSizePx: z.number().positive().optional(),
+  emBasePx: z.number().positive().optional()
+});
+var styleRawColorsForbidRecordSchema = z.object({
+  kind: z.literal("style.rawColors.forbid"),
+  except: z.array(z.string()),
+  prefer: z.enum(["token", "css-variable"]),
+  severity: governanceSeveritySchema
+});
+var styleRawDimensionsForbidRecordSchema = z.object({
+  kind: z.literal("style.rawDimensions.forbid"),
+  appliesTo: z.array(z.string().min(1)),
+  prefer: z.enum(["token", "css-variable"]),
+  severity: governanceSeveritySchema
+});
+var styleRawSpacingMustMatchScaleRecordSchema = z.object({
+  kind: z.literal("style.rawSpacing.mustMatchScale"),
+  scale: z.string().min(1),
+  appliesTo: z.array(z.string().min(1)),
+  severity: governanceSeveritySchema
+});
+var styleFontSizeMustMatchScaleRecordSchema = z.object({
+  kind: z.literal("style.fontSize.mustMatchScale"),
+  scale: z.string().min(1),
+  severity: governanceSeveritySchema
+});
+var styleCssVarsMustBeDefinedRecordSchema = z.object({
+  kind: z.literal("style.cssVars.mustBeDefined"),
+  severity: governanceSeveritySchema
+});
+var globalStyleGovernanceRecordSchema = z.discriminatedUnion("kind", [
+  styleRawColorsForbidRecordSchema,
+  styleRawDimensionsForbidRecordSchema,
+  styleRawSpacingMustMatchScaleRecordSchema,
+  styleFontSizeMustMatchScaleRecordSchema,
+  styleCssVarsMustBeDefinedRecordSchema
+]);
+var jsxUnknownPropsForbidRecordSchema = z.object({
+  kind: z.literal("jsx.unknownProps.forbid"),
+  severity: governanceSeveritySchema
+});
+var jsxInlineStyleForbidRawRecordSchema = z.object({
+  kind: z.literal("jsx.inlineStyle.forbidRaw"),
+  properties: z.array(z.string().min(1)),
+  severity: governanceSeveritySchema
+});
+var jsxImportPathPreferRecordSchema = z.object({
+  kind: z.literal("jsx.importPath.prefer"),
+  from: z.string().min(1),
+  to: z.string().min(1),
+  imported: z.string().min(1).optional(),
+  because: z.string().optional(),
+  severity: governanceSeveritySchema
+});
+var jsxComponentPreferRecordSchema = z.object({
+  kind: z.literal("jsx.component.prefer"),
+  from: z.string().min(1),
+  to: z.string().min(1),
+  because: z.string().optional(),
+  severity: governanceSeveritySchema
+});
+var globalJsxGovernanceRecordSchema = z.discriminatedUnion("kind", [
+  jsxUnknownPropsForbidRecordSchema,
+  jsxInlineStyleForbidRawRecordSchema,
+  jsxImportPathPreferRecordSchema,
+  jsxComponentPreferRecordSchema
+]);
+var globalGovernanceRecordSchema = z.discriminatedUnion("kind", [
+  scaleGovernanceRecordSchema,
+  styleRawColorsForbidRecordSchema,
+  styleRawDimensionsForbidRecordSchema,
+  styleRawSpacingMustMatchScaleRecordSchema,
+  styleFontSizeMustMatchScaleRecordSchema,
+  styleCssVarsMustBeDefinedRecordSchema,
+  jsxUnknownPropsForbidRecordSchema,
+  jsxInlineStyleForbidRawRecordSchema,
+  jsxImportPathPreferRecordSchema,
+  jsxComponentPreferRecordSchema
+]);
+var componentCapabilityRecordSchema = z.object({
+  kind: z.literal("capability"),
+  capability: z.string().min(1)
+});
+var propValueAvoidRecordSchema = z.object({
+  kind: z.literal("prop.value.avoid"),
+  prop: z.string().min(1),
+  value: z.unknown(),
+  because: z.string(),
+  suggest: z.string().optional(),
+  severity: governanceSeveritySchema
+});
+var propValueForbidRecordSchema = z.object({
+  kind: z.literal("prop.value.forbid"),
+  prop: z.string().min(1),
+  value: z.unknown(),
+  when: z.object({ path: z.string().min(1).optional() }).optional(),
+  because: z.string(),
+  fix: z.object({ replaceWith: z.unknown() }).optional(),
+  severity: governanceSeveritySchema
+});
+var a11yRequireNameRecordSchema = z.object({
+  kind: z.literal("a11y.requireName"),
+  because: z.string(),
+  severity: governanceSeveritySchema
+});
+var componentGovernanceRecordSchema = z.discriminatedUnion("kind", [
+  componentCapabilityRecordSchema,
+  propValueAvoidRecordSchema,
+  propValueForbidRecordSchema,
+  a11yRequireNameRecordSchema
+]);
+var componentGovernanceRecordsSchema = z.array(componentGovernanceRecordSchema);
+var componentPolicyMatchSchema = z.object({
+  componentKey: z.string().min(1).optional(),
+  componentId: z.string().min(1).optional(),
+  publicRef: z.string().min(1).optional(),
+  importPath: z.string().min(1).optional(),
+  sourcePath: z.string().min(1).optional(),
+  path: z.string().min(1).optional(),
+  exportName: z.string().min(1).optional(),
+  export: z.string().min(1).optional(),
+  name: z.string().min(1).optional(),
+  scope: z.enum(["one", "all"]).optional()
+}).strict();
+var componentPolicyRecordSchema = z.object({
+  rules: componentGovernanceRecordsSchema,
+  status: z.enum(["active", "draft", "disabled"]).optional()
+}).strict();
+var componentPolicyOverrideSchema = z.object({
+  match: componentPolicyMatchSchema,
+  rules: componentGovernanceRecordsSchema,
+  status: z.enum(["active", "draft", "disabled"]).optional()
+}).strict();
+var canonicalSourcePathSchema = z.string().min(1).superRefine((value, ctx) => {
+  const error = portableRepoPathError(value);
+  if (error) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: error });
+  }
+});
+var canonicalSourceRegistryHashSchema = z.string().regex(/^[0-9a-f]{64}$/);
+var canonicalSourceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("npm"),
+    specifier: z.string().min(1),
+    implementationPath: z.string().min(1).optional(),
+    include: z.array(z.string().min(1)).optional(),
+    exclude: z.array(z.string().min(1)).optional()
+  }),
+  z.object({
+    kind: z.literal("directory"),
+    path: z.string().min(1),
+    include: z.array(z.string().min(1)).optional(),
+    exclude: z.array(z.string().min(1)).optional()
+  }),
+  z.object({
+    kind: z.literal("registry"),
+    registryId: z.string().min(1),
+    registryHash: canonicalSourceRegistryHashSchema.optional(),
+    receiptPath: canonicalSourcePathSchema.default(".fragments/registry-lock.json"),
+    installPath: canonicalSourcePathSchema,
+    importPath: z.string().min(1).optional(),
+    include: z.array(z.string().min(1)).optional(),
+    exclude: z.array(z.string().min(1)).optional(),
+    severity: governanceSeveritySchema.optional()
+  })
+]);
+var governanceConfigSchema = z.object({
+  extends: z.array(z.string()).optional(),
+  severity: governanceSeveritySchema.optional(),
+  rules: z.record(z.string(), z.unknown()).optional(),
+  agents: z.record(
+    z.string(),
+    z.object({
+      rules: z.record(z.string(), z.unknown()).optional()
+    }).passthrough()
+  ).optional(),
+  audit: z.object({}).passthrough().optional(),
+  runners: z.record(z.string(), z.object({}).passthrough()).optional(),
+  canonicalSources: z.array(canonicalSourceSchema).optional(),
+  presets: z.array(z.string()).optional(),
+  scales: z.record(z.string(), scaleGovernanceRecordSchema).optional(),
+  styles: z.array(globalStyleGovernanceRecordSchema).optional(),
+  jsx: z.array(globalJsxGovernanceRecordSchema).optional(),
+  tailwind: z.object({
+    palette: z.object({
+      allow: z.array(z.string().min(1)).optional(),
+      deny: z.array(z.string().min(1)).optional()
+    }).optional()
+  }).passthrough().optional(),
+  agent: z.object({
+    repairOrder: z.array(z.string().min(1)).optional()
+  }).passthrough().optional(),
+  components: z.record(componentPolicyRecordSchema).optional(),
+  overrides: z.array(componentPolicyOverrideSchema).optional(),
+  ci: z.object({
+    failOnWarnings: z.boolean().optional()
+  }).passthrough().optional()
+}).strict();
+function createComponentGovernanceBuilder() {
+  return {
+    capability(capability) {
+      return { kind: "capability", capability };
+    },
+    prop(prop) {
+      return {
+        avoid(value, options = {}) {
+          return {
+            kind: "prop.value.avoid",
+            prop,
+            value,
+            because: options.because ?? "",
+            suggest: options.suggest,
+            severity: options.severity ?? "warn"
+          };
+        },
+        forbid(value, options = {}) {
+          return {
+            kind: "prop.value.forbid",
+            prop,
+            value,
+            when: options.when,
+            because: options.because ?? "",
+            fix: options.fix,
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    accessibility() {
+      return {
+        requireName(options = {}) {
+          return {
+            kind: "a11y.requireName",
+            because: options.because ?? "",
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    }
+  };
+}
+function resolveComponentGovernance(definition) {
+  const builder = createComponentGovernanceBuilder();
+  const records = definition.govern ? definition.govern(builder) : definition.governance ?? [];
+  return componentGovernanceRecordsSchema.parse(records);
+}
+function normalizeGovernanceConfig(config) {
+  if (!config.govern?.scales) {
+    return config;
+  }
+  const scales = Object.fromEntries(
+    Object.entries(config.govern.scales).map(([name, scale]) => {
+      if (!scale || typeof scale !== "object") {
+        return [name, scale];
+      }
+      return [name, { ...scale, name: scale.name ?? name }];
+    })
+  );
+  return {
+    ...config,
+    govern: {
+      ...config.govern,
+      scales
+    }
+  };
+}
+var g = {
+  scale: {
+    px(values) {
+      return { kind: "scale", unit: "px", values: [...values] };
+    },
+    rem(values) {
+      return { kind: "scale", unit: "rem", values: [...values] };
+    }
+  },
+  styles: {
+    rawColors() {
+      return {
+        forbid(options = {}) {
+          return {
+            kind: "style.rawColors.forbid",
+            except: options.except ?? [],
+            prefer: options.prefer ?? "token",
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    rawSpacing() {
+      return {
+        mustMatchScale(scale, options = {}) {
+          return {
+            kind: "style.rawSpacing.mustMatchScale",
+            scale,
+            appliesTo: options.appliesTo ?? [],
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    fontSize() {
+      return {
+        mustMatchScale(scale, options = {}) {
+          return {
+            kind: "style.fontSize.mustMatchScale",
+            scale,
+            severity: options.severity ?? "warn"
+          };
+        }
+      };
+    },
+    cssVars() {
+      return {
+        mustBeDefined(options = {}) {
+          return {
+            kind: "style.cssVars.mustBeDefined",
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    }
+  },
+  jsx: {
+    unknownProps() {
+      return {
+        forbid(options = {}) {
+          return {
+            kind: "jsx.unknownProps.forbid",
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    inlineStyle() {
+      return {
+        forbidRaw(properties, options = {}) {
+          return {
+            kind: "jsx.inlineStyle.forbidRaw",
+            properties: [...properties],
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    importPath() {
+      return {
+        prefer(from, to, options = {}) {
+          return {
+            kind: "jsx.importPath.prefer",
+            from,
+            to,
+            imported: options.imported,
+            because: options.because,
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    },
+    component() {
+      return {
+        prefer(from, to, options = {}) {
+          return {
+            kind: "jsx.component.prefer",
+            from,
+            to,
+            because: options.because,
+            severity: options.severity ?? "error"
+          };
+        }
+      };
+    }
+  },
+  component: createComponentGovernanceBuilder()
+};
+
+// src/facts/compile.ts
+function compileGlobalGovernanceFacts(govern) {
+  if (!govern) return [];
+  const out = [];
+  if (govern.scales) {
+    for (const [name, scale] of Object.entries(govern.scales)) {
+      out.push(
+        makeScaleFact({
+          name,
+          unit: scale.unit,
+          rootFontSizePx: scale.rootFontSizePx,
+          emBasePx: scale.emBasePx
+        })
+      );
+      for (const value of scale.values) {
+        out.push(makeScaleValueFact({ scale: name, value }));
+      }
+    }
+  }
+  if (govern.styles) {
+    for (const style of govern.styles) {
+      switch (style.kind) {
+        case "style.rawColors.forbid":
+          out.push(
+            makeStyleRawColorForbiddenFact({
+              except: style.except,
+              prefer: style.prefer,
+              severity: style.severity
+            })
+          );
+          break;
+        case "style.rawDimensions.forbid":
+          out.push(
+            makeStyleRawDimensionForbiddenFact({
+              appliesTo: style.appliesTo,
+              prefer: style.prefer,
+              severity: style.severity
+            })
+          );
+          break;
+        case "style.rawSpacing.mustMatchScale":
+          for (const property of style.appliesTo) {
+            out.push(
+              makeStylePropertyScaleFact({
+                property,
+                scale: style.scale,
+                severity: style.severity
+              })
+            );
+          }
+          break;
+        case "style.fontSize.mustMatchScale":
+          out.push(makeStyleFontSizeScaleFact({ scale: style.scale, severity: style.severity }));
+          break;
+        case "style.cssVars.mustBeDefined":
+          out.push(makeStyleCssVarsMustBeDefinedFact({ severity: style.severity }));
+          break;
+      }
+    }
+  }
+  if (govern.jsx) {
+    for (const jsx of govern.jsx) {
+      switch (jsx.kind) {
+        case "jsx.unknownProps.forbid":
+          out.push(makeJsxUnknownPropsForbiddenFact({ severity: jsx.severity }));
+          break;
+        case "jsx.inlineStyle.forbidRaw":
+          for (const property of jsx.properties) {
+            out.push(
+              makeJsxInlineStyleForbiddenRawFact({
+                property,
+                severity: jsx.severity
+              })
+            );
+          }
+          break;
+        case "jsx.importPath.prefer":
+          out.push(
+            makeJsxImportPathPreferredFact({
+              from: jsx.from,
+              to: jsx.to,
+              imported: jsx.imported,
+              because: jsx.because,
+              severity: jsx.severity
+            })
+          );
+          break;
+        case "jsx.component.prefer":
+          out.push(
+            makeJsxComponentPreferredFact({
+              from: asComponentId(jsx.from),
+              to: asComponentId(jsx.to),
+              because: jsx.because,
+              severity: jsx.severity
+            })
+          );
+          break;
+      }
+    }
+  }
+  const tailwindPalette = govern.tailwind?.palette;
+  const forbiddenPaletteSeverity = ruleSeverity(
+    govern.rules?.["tailwind/forbidden-palette"],
+    govern.severity ?? "warn"
+  );
+  if (tailwindPalette?.allow?.length) {
+    out.push(
+      makeTailwindPaletteAllowFact({
+        patterns: tailwindPalette.allow,
+        severity: forbiddenPaletteSeverity
+      })
+    );
+  }
+  if (tailwindPalette?.deny?.length) {
+    out.push(
+      makeTailwindPaletteDenyFact({
+        patterns: tailwindPalette.deny,
+        severity: forbiddenPaletteSeverity
+      })
+    );
+  }
+  const unknownClassSeverity = enabledRuleSeverity(
+    govern.rules?.["tailwind/unknown-class"],
+    "info"
+  );
+  if (unknownClassSeverity) {
+    out.push(makeTailwindUnknownClassEnabledFact({ severity: unknownClassSeverity }));
+  }
+  out.push(...compileRuleConfigFacts(govern));
+  return out;
+}
+var RULE_FAMILY_MEMBERS = {
+  "tokens/hardcoded-values": [
+    "styles/no-raw-color",
+    "styles/no-raw-spacing",
+    "tokens/require-dual-fallback",
+    "theme/no-theme-coupled-literal"
+  ],
+  "components/usage": [
+    "components/forbidden-prop-value",
+    "components/preferred-component",
+    "components/unknown-prop",
+    "props/invalid-value"
+  ],
+  "a11y/wcag": ["a11y/required-accessible-name"]
+};
+function compileRuleConfigFacts(govern) {
+  const rules = govern.rules;
+  if (!rules && !govern.canonicalSources?.length) return [];
+  const configs = /* @__PURE__ */ new Map();
+  for (const [ruleId, value] of Object.entries(rules ?? {})) {
+    const family = RULE_FAMILY_MEMBERS[ruleId];
+    if (!family) continue;
+    const config = ruleConfigFromValue(value, govern.severity ?? "warn");
+    for (const memberRuleId of family) configs.set(memberRuleId, config);
+  }
+  for (const [ruleId, value] of Object.entries(rules ?? {})) {
+    configs.set(ruleId, ruleConfigFromValue(value, govern.severity ?? "warn"));
+  }
+  if (govern.canonicalSources?.length && configs.get("components/prefer-library")?.enabled !== false) {
+    const existing = configs.get("components/prefer-library");
+    configs.set("components/prefer-library", {
+      enabled: true,
+      severity: existing?.severity ?? govern.severity ?? "warn",
+      options: {
+        ...existing?.options,
+        canonicalSources: existing?.options?.canonicalSources ?? govern.canonicalSources
+      }
+    });
+  }
+  return [...configs.entries()].map(
+    ([ruleId, config]) => makeGovernanceRuleConfigFact({
+      ruleId,
+      enabled: config.enabled,
+      severity: config.severity,
+      options: config.options
+    })
+  );
+}
+function ruleConfigFromValue(value, fallbackSeverity) {
+  if (value === false) return { enabled: false };
+  if (value === true) return { enabled: true, severity: fallbackSeverity };
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { enabled: true, severity: fallbackSeverity };
+  }
+  const record = value;
+  const options = record.options && typeof record.options === "object" && !Array.isArray(record.options) ? record.options : void 0;
+  return {
+    enabled: record.enabled !== false,
+    severity: parseSeverity(record.severity) ?? fallbackSeverity,
+    options
+  };
+}
+function enabledRuleSeverity(value, fallback) {
+  if (value === true) return fallback;
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  if (record.enabled === false) return null;
+  if (record.enabled !== true) return null;
+  return parseSeverity(record.severity) ?? fallback;
+}
+function ruleSeverity(value, fallback) {
+  if (!value || typeof value !== "object") return fallback;
+  return parseSeverity(value.severity) ?? fallback;
+}
+function parseSeverity(value) {
+  if (value === "warning") return "warn";
+  return value === "error" || value === "warn" || value === "info" ? value : void 0;
+}
+function isResolvedGovernedDefinition(value) {
+  if (!value || typeof value !== "object") return false;
+  return "governance" in value && Array.isArray(value.governance);
+}
+function isGovernedDefinition(value) {
+  if (!value || typeof value !== "object") return false;
+  return "govern" in value || "governance" in value;
+}
+function toComponentFactSource(input) {
+  if (isResolvedGovernedDefinition(input)) {
+    return {
+      meta: input.meta,
+      guidance: input.guidance,
+      props: input.props ?? {},
+      governance: input.governance
+    };
+  }
+  if (isGovernedDefinition(input)) {
+    return {
+      meta: input.meta,
+      guidance: input.guidance,
+      props: input.props ?? {},
+      governance: resolveComponentGovernance(input)
+    };
+  }
+  return {
+    meta: input.meta,
+    guidance: input.guidance ?? input.usage,
+    props: input.props,
+    governance: input.governance,
+    filePath: input.filePath
+  };
+}
+function compileComponentFacts(componentId2, input) {
+  const source = toComponentFactSource(input);
+  const facts = [];
+  facts.push(
+    makeComponentMetadataFact({
+      componentId: componentId2,
+      name: source.meta.name,
+      description: source.meta.description,
+      category: source.meta.category,
+      filePath: source.filePath
+    })
+  );
+  for (const [propName, prop] of Object.entries(source.props ?? {})) {
+    facts.push(
+      makePropMetadataFact({
+        componentId: componentId2,
+        prop: propName,
+        type: prop.type,
+        values: prop.values ? [...prop.values] : void 0,
+        required: prop.required ?? false,
+        default: prop.default,
+        description: prop.description
+      })
+    );
+  }
+  for (const record of source.governance ?? []) {
+    const fact = compileComponentGovernanceRecord(componentId2, record);
+    if (fact) facts.push(fact);
+  }
+  return facts;
+}
+function compileComponentGovernanceRecord(componentId2, record) {
+  switch (record.kind) {
+    case "capability":
+      return makeComponentCapabilityFact({ componentId: componentId2, capability: record.capability });
+    case "prop.value.avoid":
+      return makePropValueAvoidedFact({
+        componentId: componentId2,
+        prop: record.prop,
+        value: record.value,
+        because: record.because,
+        suggest: record.suggest,
+        severity: record.severity
+      });
+    case "prop.value.forbid":
+      return makePropValueForbiddenFact({
+        componentId: componentId2,
+        prop: record.prop,
+        value: record.value,
+        pathPattern: record.when?.path,
+        because: record.because,
+        replaceWith: record.fix?.replaceWith,
+        severity: record.severity
+      });
+    case "a11y.requireName":
+      return makeA11yNameRequiredFact({
+        componentId: componentId2,
+        because: record.because,
+        severity: record.severity
+      });
+  }
+}
+
+// src/codes/source-finding-bridge.ts
+function bridgeSourceViolation(input) {
+  const ruleId = input.canonicalRuleId ?? input.violation.rule;
+  const code2 = byRuleId.get(ruleId);
+  const violation = normalizeViolation({
+    ...input.violation,
+    code: input.violation.code ?? code2?.code,
+    helpUrl: input.violation.helpUrl ?? code2?.explainUrl
+  });
+  const location = locationFromViolation(violation);
+  const fingerprint = hash64Hex(
+    canonicalJson({
+      ruleId,
+      legacyRule: violation.rule,
+      nodeId: violation.nodeId,
+      nodeType: violation.nodeType,
+      prop: violation.prop,
+      path: violation.path,
+      filePath: violation.filePath,
+      line: violation.line,
+      column: violation.column,
+      rawValue: violation.rawValue,
+      message: violation.message
+    })
+  );
+  return {
+    violation,
+    finding: normalizeFinding({
+      ruleId,
+      ruleVersion: "1.0.0",
+      severity: violation.severity,
+      level: violation.level,
+      code: code2?.code,
+      helpUrl: code2?.explainUrl,
+      message: violation.message,
+      fingerprint,
+      location,
+      evidence: [
+        {
+          factId: [
+            "source",
+            input.validator ?? "validator",
+            ruleId,
+            violation.filePath ?? violation.nodeId,
+            violation.line ?? 0,
+            violation.column ?? 0,
+            violation.prop ?? violation.path ?? ""
+          ].join(":"),
+          fact: {
+            kind: "source_violation",
+            location
+          }
+        }
+      ],
+      attributes: {
+        source: "source-validator",
+        validator: input.validator,
+        legacyRule: violation.rule === ruleId ? void 0 : violation.rule,
+        nodeId: violation.nodeId,
+        nodeType: violation.nodeType,
+        prop: violation.prop,
+        path: violation.path,
+        rawValue: violation.rawValue,
+        legacySuggestion: violation.suggestion,
+        ...input.attributes
+      }
+    })
+  };
+}
+function bridgeSourceViolations(violations, options = {}) {
+  const bridged = violations.map(
+    (violation) => bridgeSourceViolation({ ...options, violation })
+  );
+  return {
+    violations: bridged.map((entry) => entry.violation),
+    findings: bridged.map((entry) => entry.finding)
+  };
+}
+function locationFromViolation(violation) {
+  return {
+    file: violation.filePath ?? "<source>",
+    line: violation.line ?? 0,
+    column: violation.column ?? 0
+  };
+}
+
+export {
+  EXPLAIN_URL_BASE,
+  CODES,
+  byCode,
+  byRuleId,
+  explainUrlForCode,
+  canonicalJson,
+  hash64Hex,
+  componentId,
+  asComponentId,
+  factId,
+  makeComponentMetadataFact,
+  makeComponentCapabilityFact,
+  makeCanonicalCandidateFact,
+  makeCanonicalMappingFact,
+  makeStructuralConfidenceFact,
+  makeCanonicalReplacementFact,
+  makePropMetadataFact,
+  makePropValueAvoidedFact,
+  makePropValueForbiddenFact,
+  makeA11yNameRequiredFact,
+  makeScaleFact,
+  makeScaleValueFact,
+  makeStyleRawColorForbiddenFact,
+  makeStylePropertyScaleFact,
+  makeStyleFontSizeScaleFact,
+  makeStyleCssVarsMustBeDefinedFact,
+  makeContractTokenFact,
+  makeJsxUnknownPropsForbiddenFact,
+  makeJsxInlineStyleForbiddenRawFact,
+  makeJsxImportPathPreferredFact,
+  makeJsxComponentPreferredFact,
+  makeTokenDefinitionFact,
+  makeTailwindPaletteAllowFact,
+  makeTailwindPaletteDenyFact,
+  makeTailwindUnknownClassEnabledFact,
+  makeUsageNodeFact,
+  makeUsageComponentFact,
+  makeUsageImportFact,
+  makeUsagePropResolvedFact,
+  makeUsageInlineStyleFact,
+  makeUsageTextChildFact,
+  makeClassNameLiteralFact,
+  makeClassNameDynamicFact,
+  makeTailwindClassFact,
+  makeThemeDeclarationFact,
+  makeTailwindTokenResolvedFact,
+  makeStyleDeclarationFact,
+  makeStyleUnsupportedFact,
+  ownedImportsEqual,
+  ownedImportMatchesRoot,
+  ownedComponentIdsEqual,
+  matchesGlob,
+  FactIndex,
+  governanceSeveritySchema,
+  scaleGovernanceRecordSchema,
+  globalStyleGovernanceRecordSchema,
+  globalJsxGovernanceRecordSchema,
+  globalGovernanceRecordSchema,
+  componentGovernanceRecordSchema,
+  componentGovernanceRecordsSchema,
+  governanceConfigSchema,
+  resolveComponentGovernance,
+  normalizeGovernanceConfig,
+  g,
+  compileGlobalGovernanceFacts,
+  compileComponentFacts,
+  bridgeSourceViolation,
+  bridgeSourceViolations
+};
+//# sourceMappingURL=chunk-243QYRUF.js.map