@usefragments/core 1.5.1 → 1.6.0

package/dist/{chunk-AOG4FTV6.js → chunk-WVFNDPM4.js}

@@ -475,6 +475,66 @@ var CODES = [
     lifecycle: "experimental",
     fixAvailable: true,
     evidenceRequired: true
+  }),
+  code({
+    code: "FUI9004",
+    ruleId: "config/unconsumed-key",
+    category: "system",
+    defaultSeverity: "moderate",
+    title: "Config key is not consumed",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
+  }),
+  code({
+    code: "FUI9005",
+    ruleId: "config/orphan-scale",
+    category: "system",
+    defaultSeverity: "moderate",
+    title: "Governance scale is not referenced",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
+  }),
+  code({
+    code: "FUI9006",
+    ruleId: "config/unmatched-exclude",
+    category: "system",
+    defaultSeverity: "moderate",
+    title: "Rule exclude matched no scanned file",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
+  }),
+  code({
+    code: "FUI9007",
+    ruleId: "config/colliding-record",
+    category: "system",
+    defaultSeverity: "moderate",
+    title: "Governance record was dropped as a duplicate",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
+  }),
+  code({
+    code: "FUI9008",
+    ruleId: "config/overridden-record-severity",
+    category: "system",
+    defaultSeverity: "moderate",
+    title: "Rule override outranks a record's authored severity",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
+  }),
+  code({
+    code: "FUI9009",
+    ruleId: "contract/unreadable-token-source",
+    category: "system",
+    defaultSeverity: "critical",
+    title: "Contract token source cannot be read",
+    lifecycle: "experimental",
+    fixAvailable: false,
+    evidenceRequired: false
   })
 ];
 var byCode = new Map(
@@ -555,6 +615,9 @@ function projectFactIdentityV1(kind, identity) {
 }
 
 // src/facts/builders.ts
+function policyExcludeField(exclude) {
+  return exclude?.length ? { exclude: exclude.map((entry) => ({ ...entry })) } : {};
+}
 function makeComponentMetadataFact(input) {
   return {
     id: factId("component", { componentId: input.componentId }),
@@ -750,7 +813,8 @@ function makeStyleRawColorForbiddenFact(input) {
     kind: "style_raw_color_forbidden",
     except: [...input.except],
     prefer: input.prefer,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeStyleRawDimensionForbiddenFact(input) {
@@ -759,7 +823,8 @@ function makeStyleRawDimensionForbiddenFact(input) {
     kind: "style_raw_dimension_forbidden",
     appliesTo: [...input.appliesTo],
     prefer: input.prefer,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeStylePropertyScaleFact(input) {
@@ -768,7 +833,8 @@ function makeStylePropertyScaleFact(input) {
     kind: "style_property_scale",
     property: input.property,
     scale: input.scale,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeStyleFontSizeScaleFact(input) {
@@ -776,14 +842,16 @@ function makeStyleFontSizeScaleFact(input) {
     id: factId("style_font_size_scale", {}),
     kind: "style_font_size_scale",
     scale: input.scale,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeStyleCssVarsMustBeDefinedFact(input) {
   return {
     id: factId("style_css_vars_must_be_defined", {}),
     kind: "style_css_vars_must_be_defined",
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeContractTokenFact(input) {
@@ -798,7 +866,8 @@ function makeJsxUnknownPropsForbiddenFact(input) {
   return {
     id: factId("jsx_unknown_props_forbidden", {}),
     kind: "jsx_unknown_props_forbidden",
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeJsxInlineStyleForbiddenRawFact(input) {
@@ -806,7 +875,8 @@ function makeJsxInlineStyleForbiddenRawFact(input) {
     id: factId("jsx_inline_style_forbidden_raw", { property: input.property }),
     kind: "jsx_inline_style_forbidden_raw",
     property: input.property,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeJsxImportPathPreferredFact(input) {
@@ -828,7 +898,8 @@ function makeJsxImportPathPreferredFact(input) {
         ...input.bridge,
         implementationFiles: [...input.bridge.implementationFiles]
       }
-    } : {}
+    } : {},
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeJsxComponentPreferredFact(input) {
@@ -841,7 +912,8 @@ function makeJsxComponentPreferredFact(input) {
     from: input.from,
     to: input.to,
     because: input.because,
-    severity: input.severity
+    severity: input.severity,
+    ...policyExcludeField(input.exclude)
   };
 }
 function makeTokenDefinitionFact(input) {
@@ -962,7 +1034,8 @@ function makeUsageInlineStyleFact(input) {
     nodeId: input.nodeId,
     property: input.property,
     valueKind: input.valueKind,
-    value: input.value
+    value: input.value,
+    ...input.valueFrom ? { valueFrom: input.valueFrom } : {}
   };
 }
 function makeUsageTextChildFact(input) {
@@ -1074,7 +1147,8 @@ function makeStyleDeclarationFact(input) {
     property: input.property,
     value: input.value,
     location: input.location,
-    ...input.declaredTokenSource ? { declaredTokenSource: true } : {}
+    ...input.declaredTokenSource ? { declaredTokenSource: true } : {},
+    ...input.valueFrom ? { valueFrom: input.valueFrom } : {}
   };
 }
 function makeStyleUnsupportedFact(input) {
@@ -1168,6 +1242,10 @@ function matchesGlob(path, pattern) {
   return new RegExp(`^${expanded}$`).test(path);
 }
 var FactIndex = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
   facts = /* @__PURE__ */ new Map();
   idsByKind = /* @__PURE__ */ new Map();
   idsByComponent = /* @__PURE__ */ new Map();
@@ -1179,8 +1257,9 @@ var FactIndex = class {
     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 ${describeFactForConflict(existing)}, skipping ${describeFactForConflict(fact)}`
+        this.options.onConflict?.(
+          `FactIndex: conflicting facts for id ${fact.id} \u2014 keeping ${describeFactForConflict(existing)}, skipping ${describeFactForConflict(fact)}`,
+          { kept: existing, skipped: fact }
         );
       }
       return;
@@ -1400,81 +1479,143 @@ function describeFactForConflict(fact) {
 }
 
 // src/governance.ts
+import { z as z2 } from "zod";
+
+// src/policy-exclude.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 policyExcludeSchema = z.array(
+  z.union([
+    z.string().min(1),
+    z.object({
+      glob: z.string().min(1),
+      reason: z.string().min(1).optional()
+    })
+  ])
+);
+function normalizePolicyExcludes(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      if (entry.length > 0) out.push({ glob: entry });
+      continue;
+    }
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    if (typeof record.glob !== "string" || record.glob.length === 0) continue;
+    out.push({
+      glob: record.glob,
+      ...typeof record.reason === "string" && record.reason.length > 0 ? { reason: record.reason } : {}
+    });
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizeExcludePath(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function excludeGlobToRegExp(glob) {
+  const source = normalizeExcludePath(glob).split("**").map(
+    (part) => part.split("*").map((segment) => segment.replace(/[|\\{}()[\]^$+?.]/g, "\\$&")).join("[^/]*")
+  ).join(".*");
+  return new RegExp(`^${source}$`);
+}
+function policyExcludeMatchesPath(exclude, filePath) {
+  return excludeGlobToRegExp(exclude.glob).test(normalizeExcludePath(filePath));
+}
+function matchPolicyExclude(excludes, filePath) {
+  if (!excludes?.length) return void 0;
+  const normalized = normalizeExcludePath(filePath);
+  return excludes.find((exclude) => excludeGlobToRegExp(exclude.glob).test(normalized));
+}
+function describePolicyExclude(scope, exclude) {
+  return `${scope} exclude matched ${exclude.glob}${exclude.reason ? ` \u2014 ${exclude.reason}` : ""}`;
+}
+
+// src/governance.ts
+var governanceSeveritySchema = z2.enum(["error", "warn", "info"]);
+var recordExcludeSchema = policyExcludeSchema.optional();
+var scaleGovernanceRecordSchema = z2.object({
+  kind: z2.literal("scale").default("scale"),
+  name: z2.string().min(1).optional(),
+  unit: z2.enum(["px", "rem"]),
+  values: z2.array(z2.number()),
+  rootFontSizePx: z2.number().positive().optional(),
+  emBasePx: z2.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 styleRawColorsForbidRecordSchema = z2.object({
+  kind: z2.literal("style.rawColors.forbid"),
+  except: z2.array(z2.string()),
+  prefer: z2.enum(["token", "css-variable"]),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-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 styleRawDimensionsForbidRecordSchema = z2.object({
+  kind: z2.literal("style.rawDimensions.forbid"),
+  appliesTo: z2.array(z2.string().min(1)),
+  prefer: z2.enum(["token", "css-variable"]),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-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 styleRawSpacingMustMatchScaleRecordSchema = z2.object({
+  kind: z2.literal("style.rawSpacing.mustMatchScale"),
+  scale: z2.string().min(1),
+  appliesTo: z2.array(z2.string().min(1)),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-var styleFontSizeMustMatchScaleRecordSchema = z.object({
-  kind: z.literal("style.fontSize.mustMatchScale"),
-  scale: z.string().min(1),
-  severity: governanceSeveritySchema
+var styleFontSizeMustMatchScaleRecordSchema = z2.object({
+  kind: z2.literal("style.fontSize.mustMatchScale"),
+  scale: z2.string().min(1),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-var styleCssVarsMustBeDefinedRecordSchema = z.object({
-  kind: z.literal("style.cssVars.mustBeDefined"),
-  severity: governanceSeveritySchema
+var styleCssVarsMustBeDefinedRecordSchema = z2.object({
+  kind: z2.literal("style.cssVars.mustBeDefined"),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-var globalStyleGovernanceRecordSchema = z.discriminatedUnion("kind", [
+var globalStyleGovernanceRecordSchema = z2.discriminatedUnion("kind", [
   styleRawColorsForbidRecordSchema,
   styleRawDimensionsForbidRecordSchema,
   styleRawSpacingMustMatchScaleRecordSchema,
   styleFontSizeMustMatchScaleRecordSchema,
   styleCssVarsMustBeDefinedRecordSchema
 ]);
-var jsxUnknownPropsForbidRecordSchema = z.object({
-  kind: z.literal("jsx.unknownProps.forbid"),
-  severity: governanceSeveritySchema
+var jsxUnknownPropsForbidRecordSchema = z2.object({
+  kind: z2.literal("jsx.unknownProps.forbid"),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-var jsxInlineStyleForbidRawRecordSchema = z.object({
-  kind: z.literal("jsx.inlineStyle.forbidRaw"),
-  properties: z.array(z.string().min(1)),
-  severity: governanceSeveritySchema
+var jsxInlineStyleForbidRawRecordSchema = z2.object({
+  kind: z2.literal("jsx.inlineStyle.forbidRaw"),
+  properties: z2.array(z2.string().min(1)),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-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 jsxImportPathPreferRecordSchema = z2.object({
+  kind: z2.literal("jsx.importPath.prefer"),
+  from: z2.string().min(1),
+  to: z2.string().min(1),
+  imported: z2.string().min(1).optional(),
+  because: z2.string().optional(),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-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 jsxComponentPreferRecordSchema = z2.object({
+  kind: z2.literal("jsx.component.prefer"),
+  from: z2.string().min(1),
+  to: z2.string().min(1),
+  because: z2.string().optional(),
+  severity: governanceSeveritySchema,
+  exclude: recordExcludeSchema
 });
-var globalJsxGovernanceRecordSchema = z.discriminatedUnion("kind", [
+var globalJsxGovernanceRecordSchema = z2.discriminatedUnion("kind", [
   jsxUnknownPropsForbidRecordSchema,
   jsxInlineStyleForbidRawRecordSchema,
   jsxImportPathPreferRecordSchema,
   jsxComponentPreferRecordSchema
 ]);
-var globalGovernanceRecordSchema = z.discriminatedUnion("kind", [
+var globalGovernanceRecordSchema = z2.discriminatedUnion("kind", [
   scaleGovernanceRecordSchema,
   styleRawColorsForbidRecordSchema,
   styleRawDimensionsForbidRecordSchema,
@@ -1486,99 +1627,99 @@ var globalGovernanceRecordSchema = z.discriminatedUnion("kind", [
   jsxImportPathPreferRecordSchema,
   jsxComponentPreferRecordSchema
 ]);
-var componentCapabilityRecordSchema = z.object({
-  kind: z.literal("capability"),
-  capability: z.string().min(1)
+var componentCapabilityRecordSchema = z2.object({
+  kind: z2.literal("capability"),
+  capability: z2.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(),
+var propValueAvoidRecordSchema = z2.object({
+  kind: z2.literal("prop.value.avoid"),
+  prop: z2.string().min(1),
+  value: z2.unknown(),
+  because: z2.string(),
+  suggest: z2.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(),
+var propValueForbidRecordSchema = z2.object({
+  kind: z2.literal("prop.value.forbid"),
+  prop: z2.string().min(1),
+  value: z2.unknown(),
+  when: z2.object({ path: z2.string().min(1).optional() }).optional(),
+  because: z2.string(),
+  fix: z2.object({ replaceWith: z2.unknown() }).optional(),
   severity: governanceSeveritySchema
 });
-var a11yRequireNameRecordSchema = z.object({
-  kind: z.literal("a11y.requireName"),
-  because: z.string(),
+var a11yRequireNameRecordSchema = z2.object({
+  kind: z2.literal("a11y.requireName"),
+  because: z2.string(),
   severity: governanceSeveritySchema
 });
-var componentGovernanceRecordSchema = z.discriminatedUnion("kind", [
+var componentGovernanceRecordSchema = z2.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()
+var componentGovernanceRecordsSchema = z2.array(componentGovernanceRecordSchema);
+var componentPolicyMatchSchema = z2.object({
+  componentKey: z2.string().min(1).optional(),
+  componentId: z2.string().min(1).optional(),
+  publicRef: z2.string().min(1).optional(),
+  importPath: z2.string().min(1).optional(),
+  sourcePath: z2.string().min(1).optional(),
+  path: z2.string().min(1).optional(),
+  exportName: z2.string().min(1).optional(),
+  export: z2.string().min(1).optional(),
+  name: z2.string().min(1).optional(),
+  scope: z2.enum(["one", "all"]).optional()
 }).strict();
-var componentPolicyRecordSchema = z.object({
+var componentPolicyRecordSchema = z2.object({
   rules: componentGovernanceRecordsSchema,
-  status: z.enum(["active", "draft", "disabled"]).optional()
+  status: z2.enum(["active", "draft", "disabled"]).optional()
 }).strict();
-var componentPolicyOverrideSchema = z.object({
+var componentPolicyOverrideSchema = z2.object({
   match: componentPolicyMatchSchema,
   rules: componentGovernanceRecordsSchema,
-  status: z.enum(["active", "draft", "disabled"]).optional()
+  status: z2.enum(["active", "draft", "disabled"]).optional()
 }).strict();
-var canonicalSourcePathSchema = z.string().min(1).superRefine((value, ctx) => {
+var canonicalSourcePathSchema = z2.string().min(1).superRefine((value, ctx) => {
   const error = portableRepoPathError(value);
   if (error) {
-    ctx.addIssue({ code: z.ZodIssueCode.custom, message: error });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, message: error });
   }
 });
-var canonicalSourceRegistryHashSchema = z.string().regex(/^[0-9a-f]{64}$/);
-var canonicalBridgeModuleSpecifierSchema = z.string().min(1).superRefine((value, ctx) => {
+var canonicalSourceRegistryHashSchema = z2.string().regex(/^[0-9a-f]{64}$/);
+var canonicalBridgeModuleSpecifierSchema = z2.string().min(1).superRefine((value, ctx) => {
   const normalized = value.replace(/\\/gu, "/");
   if (normalized.startsWith("/") || /^[A-Za-z]:\//u.test(normalized)) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: "Canonical bridge moduleSpecifier must be a portable import specifier"
     });
   }
   if (normalized.split("/").includes("..")) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: "Canonical bridge moduleSpecifier must not traverse outside the project"
     });
   }
 });
-var canonicalBridgeV1Schema = z.object({
-  underlying: z.object({
-    packageName: z.string().min(1),
-    exportName: z.string().min(1)
+var canonicalBridgeV1Schema = z2.object({
+  underlying: z2.object({
+    packageName: z2.string().min(1),
+    exportName: z2.string().min(1)
   }).strict(),
-  local: z.object({
-    componentKey: z.string().min(1),
+  local: z2.object({
+    componentKey: z2.string().min(1),
     moduleSpecifier: canonicalBridgeModuleSpecifierSchema,
-    exportName: z.string().min(1),
-    implementationFiles: z.array(canonicalSourcePathSchema).min(1)
+    exportName: z2.string().min(1),
+    implementationFiles: z2.array(canonicalSourcePathSchema).min(1)
   }).strict(),
-  decision: z.object({
-    state: z.literal("confirmed"),
-    source: z.enum(["authored", "migration"])
+  decision: z2.object({
+    state: z2.literal("confirmed"),
+    source: z2.enum(["authored", "migration"])
   }).strict()
 }).strict();
-var canonicalBridgesV1Schema = z.array(canonicalBridgeV1Schema).superRefine((bridges, ctx) => {
+var canonicalBridgesV1Schema = z2.array(canonicalBridgeV1Schema).superRefine((bridges, ctx) => {
   const underlying = /* @__PURE__ */ new Map();
   const componentKeys = /* @__PURE__ */ new Map();
   for (const [index, bridge] of bridges.entries()) {
@@ -1586,7 +1727,7 @@ var canonicalBridgesV1Schema = z.array(canonicalBridgeV1Schema).superRefine((bri
     const previousUnderlying = underlying.get(underlyingKey);
     if (previousUnderlying !== void 0) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: `Duplicate confirmed bridge target for ${bridge.underlying.packageName}#${bridge.underlying.exportName} (also at canonicalBridges.${previousUnderlying})`,
         path: [index, "underlying"]
       });
@@ -1596,7 +1737,7 @@ var canonicalBridgesV1Schema = z.array(canonicalBridgeV1Schema).superRefine((bri
     const previousComponent = componentKeys.get(bridge.local.componentKey);
     if (previousComponent !== void 0) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: `Local component key overlaps canonicalBridges.${previousComponent}`,
         path: [index, "local", "componentKey"]
       });
@@ -1605,65 +1746,81 @@ var canonicalBridgesV1Schema = z.array(canonicalBridgeV1Schema).superRefine((bri
     }
   }
 });
-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()
+var canonicalSourceSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("npm"),
+    specifier: z2.string().min(1),
+    implementationPath: z2.string().min(1).optional(),
+    include: z2.array(z2.string().min(1)).optional(),
+    exclude: z2.array(z2.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()
+  z2.object({
+    kind: z2.literal("directory"),
+    path: z2.string().min(1),
+    include: z2.array(z2.string().min(1)).optional(),
+    exclude: z2.array(z2.string().min(1)).optional()
   }),
-  z.object({
-    kind: z.literal("registry"),
-    registryId: z.string().min(1),
+  z2.object({
+    kind: z2.literal("registry"),
+    registryId: z2.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(),
+    importPath: z2.string().min(1).optional(),
+    include: z2.array(z2.string().min(1)).optional(),
+    exclude: z2.array(z2.string().min(1)).optional(),
     severity: governanceSeveritySchema.optional()
   })
 ]);
-var governanceConfigSchema = z.object({
-  extends: z.array(z.string()).optional(),
+var governanceConfigSchema = z2.object({
+  extends: z2.array(z2.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()
+  rules: z2.record(z2.string(), z2.unknown()).optional(),
+  agents: z2.record(
+    z2.string(),
+    z2.object({
+      rules: z2.record(z2.string(), z2.unknown()).optional()
     }).passthrough()
   ).optional(),
-  audit: z.object({}).passthrough().optional(),
-  runners: z.record(z.string(), z.object({}).passthrough()).optional(),
-  canonicalSources: z.array(canonicalSourceSchema).optional(),
+  audit: z2.object({}).passthrough().optional(),
+  runners: z2.record(z2.string(), z2.object({}).passthrough()).optional(),
+  canonicalSources: z2.array(canonicalSourceSchema).optional(),
   canonicalBridges: canonicalBridgesV1Schema.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()
+  presets: z2.array(z2.string()).optional(),
+  scales: z2.record(z2.string(), scaleGovernanceRecordSchema).optional(),
+  styles: z2.array(globalStyleGovernanceRecordSchema).optional(),
+  jsx: z2.array(globalJsxGovernanceRecordSchema).optional(),
+  tailwind: z2.object({
+    palette: z2.object({
+      allow: z2.array(z2.string().min(1)).optional(),
+      deny: z2.array(z2.string().min(1)).optional()
     }).optional()
   }).passthrough().optional(),
-  agent: z.object({
-    repairOrder: z.array(z.string().min(1)).optional()
+  agent: z2.object({
+    repairOrder: z2.array(z2.string().min(1)).optional()
   }).passthrough().optional(),
-  components: z.record(componentPolicyRecordSchema).optional(),
-  overrides: z.array(componentPolicyOverrideSchema).optional(),
-  ci: z.object({
-    failOnWarnings: z.boolean().optional()
+  components: z2.record(componentPolicyRecordSchema).optional(),
+  overrides: z2.array(componentPolicyOverrideSchema).optional(),
+  ci: z2.object({
+    failOnWarnings: z2.boolean().optional(),
+    failOnInert: z2.boolean().optional()
   }).passthrough().optional()
 }).strict();
+var PRESET_SOURCED_RULE = /* @__PURE__ */ Symbol.for("@usefragments/core:preset-sourced-rule");
+function markPresetSourcedRules(rules) {
+  if (!rules) return rules;
+  const out = {};
+  for (const [ruleId, entry] of Object.entries(rules)) {
+    out[ruleId] = entry && typeof entry === "object" && !Array.isArray(entry) ? Object.defineProperty({ ...entry }, PRESET_SOURCED_RULE, {
+      value: true,
+      enumerable: false
+    }) : entry;
+  }
+  return out;
+}
+function isPresetSourcedRule(entry) {
+  return !!entry && typeof entry === "object" && entry[PRESET_SOURCED_RULE] === true;
+}
 function createComponentGovernanceBuilder() {
   return {
     capability(capability) {
@@ -1841,7 +1998,56 @@ var g = {
   component: createComponentGovernanceBuilder()
 };
 
+// src/rules/families.ts
+var RULE_FAMILY_MEMBERS = {
+  "tokens/hardcoded-values": [
+    "styles/no-raw-color",
+    "styles/no-raw-spacing",
+    "styles/no-raw-typography",
+    "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"]
+};
+var RULE_FAMILY_IDS = new Set(Object.keys(RULE_FAMILY_MEMBERS));
+function isRuleFamilyId(ruleId) {
+  return RULE_FAMILY_IDS.has(ruleId);
+}
+function ruleFamilyMembers(ruleId) {
+  return RULE_FAMILY_MEMBERS[ruleId] ?? [ruleId];
+}
+
 // src/facts/compile.ts
+function recordExclude(record) {
+  const exclude = normalizePolicyExcludes(record.exclude);
+  return exclude ? { exclude } : {};
+}
+function unionExcludesBySharedFactId(facts) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const exclude = fact.exclude;
+    if (!exclude?.length) continue;
+    const merged = byId.get(fact.id) ?? [];
+    for (const entry of exclude) {
+      if (!merged.some((seen) => seen.glob === entry.glob && seen.reason === entry.reason)) {
+        merged.push(entry);
+      }
+    }
+    byId.set(fact.id, merged);
+  }
+  if (byId.size === 0) return facts;
+  return facts.map((fact) => {
+    const merged = byId.get(fact.id);
+    if (!merged) return fact;
+    return { ...fact, exclude: merged.map((entry) => ({ ...entry })) };
+  });
+}
 function compileGlobalGovernanceFacts(govern) {
   if (!govern) return [];
   const out = [];
@@ -1868,7 +2074,8 @@ function compileGlobalGovernanceFacts(govern) {
             makeStyleRawColorForbiddenFact({
               except: style.except,
               prefer: style.prefer,
-              severity: style.severity
+              severity: style.severity,
+              ...recordExclude(style)
             })
           );
           break;
@@ -1877,7 +2084,8 @@ function compileGlobalGovernanceFacts(govern) {
             makeStyleRawDimensionForbiddenFact({
               appliesTo: style.appliesTo,
               prefer: style.prefer,
-              severity: style.severity
+              severity: style.severity,
+              ...recordExclude(style)
             })
           );
           break;
@@ -1887,16 +2095,28 @@ function compileGlobalGovernanceFacts(govern) {
               makeStylePropertyScaleFact({
                 property,
                 scale: style.scale,
-                severity: style.severity
+                severity: style.severity,
+                ...recordExclude(style)
               })
             );
           }
           break;
         case "style.fontSize.mustMatchScale":
-          out.push(makeStyleFontSizeScaleFact({ scale: style.scale, severity: style.severity }));
+          out.push(
+            makeStyleFontSizeScaleFact({
+              scale: style.scale,
+              severity: style.severity,
+              ...recordExclude(style)
+            })
+          );
           break;
         case "style.cssVars.mustBeDefined":
-          out.push(makeStyleCssVarsMustBeDefinedFact({ severity: style.severity }));
+          out.push(
+            makeStyleCssVarsMustBeDefinedFact({
+              severity: style.severity,
+              ...recordExclude(style)
+            })
+          );
           break;
       }
     }
@@ -1905,14 +2125,20 @@ function compileGlobalGovernanceFacts(govern) {
     for (const jsx of govern.jsx) {
       switch (jsx.kind) {
         case "jsx.unknownProps.forbid":
-          out.push(makeJsxUnknownPropsForbiddenFact({ severity: jsx.severity }));
+          out.push(
+            makeJsxUnknownPropsForbiddenFact({
+              severity: jsx.severity,
+              ...recordExclude(jsx)
+            })
+          );
           break;
         case "jsx.inlineStyle.forbidRaw":
           for (const property of jsx.properties) {
             out.push(
               makeJsxInlineStyleForbiddenRawFact({
                 property,
-                severity: jsx.severity
+                severity: jsx.severity,
+                ...recordExclude(jsx)
               })
             );
           }
@@ -1924,7 +2150,8 @@ function compileGlobalGovernanceFacts(govern) {
               to: jsx.to,
               imported: jsx.imported,
               because: jsx.because,
-              severity: jsx.severity
+              severity: jsx.severity,
+              ...recordExclude(jsx)
             })
           );
           break;
@@ -1934,7 +2161,8 @@ function compileGlobalGovernanceFacts(govern) {
               from: asComponentId(jsx.from),
               to: asComponentId(jsx.to),
               because: jsx.because,
-              severity: jsx.severity
+              severity: jsx.severity,
+              ...recordExclude(jsx)
             })
           );
           break;
@@ -1959,6 +2187,38 @@ function compileGlobalGovernanceFacts(govern) {
       })
     );
   }
+  compileTailwindAndRuleConfigFacts(govern, out);
+  return unionExcludesBySharedFactId(out);
+}
+function projectSupersededImportPathPreferences(govern) {
+  const bridges = govern?.canonicalBridges ?? [];
+  if (bridges.length === 0 || !govern?.jsx) return [];
+  const out = [];
+  for (const record of govern.jsx) {
+    if (record.kind !== "jsx.importPath.prefer") continue;
+    const bridge = bridges.find((candidate) => importPathRecordOverlapsBridge(record, candidate));
+    if (!bridge) continue;
+    out.push({
+      from: record.from,
+      ...record.imported !== void 0 ? { imported: record.imported } : {},
+      to: record.to,
+      packageName: bridge.underlying.packageName,
+      underlyingExportName: bridge.underlying.exportName,
+      localExportName: bridge.local.exportName
+    });
+  }
+  return out;
+}
+function importPathRecordOverlapsBridge(record, bridge) {
+  if (!ownedImportMatchesRoot(record.from, bridge.underlying.packageName)) return false;
+  if (ownedImportsEqual(record.from, bridge.underlying.packageName)) {
+    return record.imported === void 0 || record.imported === bridge.underlying.exportName;
+  }
+  const subpath = record.from.slice(bridge.underlying.packageName.length + 1);
+  const leaf = subpath.split("/").at(-1);
+  return leaf === bridge.underlying.exportName && (record.imported === void 0 || record.imported === "default" || record.imported === bridge.underlying.exportName);
+}
+function compileTailwindAndRuleConfigFacts(govern, out) {
   const tailwindPalette = govern.tailwind?.palette;
   const forbiddenPaletteSeverity = ruleSeverity(
     govern.rules?.["tailwind/forbidden-palette"],
@@ -1988,23 +2248,7 @@ function compileGlobalGovernanceFacts(govern) {
     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 [];
@@ -2306,6 +2550,13 @@ export {
   ownedComponentIdsEqual,
   matchesGlob,
   FactIndex,
+  policyExcludeSchema,
+  normalizePolicyExcludes,
+  normalizeExcludePath,
+  excludeGlobToRegExp,
+  policyExcludeMatchesPath,
+  matchPolicyExclude,
+  describePolicyExclude,
   governanceSeveritySchema,
   scaleGovernanceRecordSchema,
   globalStyleGovernanceRecordSchema,
@@ -2315,12 +2566,19 @@ export {
   componentGovernanceRecordsSchema,
   canonicalBridgeV1Schema,
   governanceConfigSchema,
+  markPresetSourcedRules,
+  isPresetSourcedRule,
   resolveComponentGovernance,
   normalizeGovernanceConfig,
   g,
+  RULE_FAMILY_MEMBERS,
+  RULE_FAMILY_IDS,
+  isRuleFamilyId,
+  ruleFamilyMembers,
   compileGlobalGovernanceFacts,
+  projectSupersededImportPathPreferences,
   compileComponentFacts,
   bridgeSourceViolation,
   bridgeSourceViolations
 };
-//# sourceMappingURL=chunk-AOG4FTV6.js.map
+//# sourceMappingURL=chunk-WVFNDPM4.js.map