@usefragments/core 1.7.1 → 1.9.0

package/dist/{chunk-WNMWKUYG.js → chunk-DGHZQTLH.js}

@@ -1,7 +1,3 @@
-import {
-  normalizeFinding,
-  normalizeViolation
-} from "./chunk-ZHS52OT4.js";
 import {
   authorOwnedImport,
   canonicalizeOwnedComponentId,
@@ -13,6 +9,13 @@ import {
 import {
   portableRepoPathError
 } from "./chunk-EIYNNS77.js";
+import {
+  legacySeverityLevelSchema,
+  severityFromLevel,
+  severityLevel,
+  severityLevelSchema,
+  severitySchema
+} from "./chunk-V4VQB57N.js";
 
 // src/rules/fix-availability.ts
 var RULE_FIX_AVAILABLE = {
@@ -2419,6 +2422,296 @@ function compileComponentGovernanceRecord(componentId2, record) {
   }
 }
 
+// src/schemas/index.ts
+import { z as z3 } from "zod";
+var evidenceGradeSchema = z3.enum([
+  "none",
+  "runtime_advisory",
+  "provenance_bound",
+  "source_backed",
+  "receipt_backed"
+]);
+var factLocationSchema = z3.object({
+  file: z3.string(),
+  line: z3.number().int().nonnegative(),
+  column: z3.number().int().nonnegative(),
+  endLine: z3.number().int().nonnegative().optional(),
+  endColumn: z3.number().int().nonnegative().optional()
+});
+var findingReplacePropValueFixSchema = z3.object({
+  kind: z3.literal("replacePropValue"),
+  title: z3.string(),
+  prop: z3.string(),
+  value: z3.unknown(),
+  deterministic: z3.boolean().optional()
+});
+var findingReplaceStyleValueFixSchema = z3.object({
+  kind: z3.literal("replaceStyleValue"),
+  title: z3.string(),
+  property: z3.string(),
+  value: z3.string(),
+  deterministic: z3.boolean().optional()
+});
+var findingReplaceImportFixSchema = z3.object({
+  kind: z3.literal("replaceImport"),
+  title: z3.string(),
+  from: z3.string(),
+  to: z3.string(),
+  deterministic: z3.boolean().optional()
+});
+var findingReplaceComponentFixSchema = z3.object({
+  kind: z3.literal("replaceComponent"),
+  title: z3.string(),
+  from: z3.string(),
+  to: z3.string(),
+  deterministic: z3.boolean().optional()
+});
+var findingReplaceClassTokenFixSchema = z3.object({
+  kind: z3.literal("replaceClassToken"),
+  title: z3.string(),
+  from: z3.string(),
+  to: z3.string().nullable(),
+  utility: z3.string(),
+  deterministic: z3.boolean().optional()
+});
+var findingFixSchema = z3.discriminatedUnion("kind", [
+  findingReplacePropValueFixSchema,
+  findingReplaceStyleValueFixSchema,
+  findingReplaceImportFixSchema,
+  findingReplaceComponentFixSchema,
+  findingReplaceClassTokenFixSchema
+]);
+var factEvidenceSchema = z3.object({
+  factId: z3.string(),
+  fact: z3.object({
+    kind: z3.string(),
+    location: factLocationSchema.optional()
+  }).passthrough()
+});
+var findingSchema = z3.object({
+  ruleId: z3.string(),
+  ruleVersion: z3.string(),
+  severity: severitySchema,
+  level: severityLevelSchema,
+  code: z3.string().regex(/^FUI\d{4}$/).optional(),
+  helpUrl: z3.string().url().optional(),
+  message: z3.string(),
+  fingerprint: z3.string(),
+  /**
+   * Fingerprint this finding carried before a fingerprint-identity migration.
+   * Emitted only by migrated rules during the grace window so baseline
+   * records keyed on the legacy hash keep matching instead of churning.
+   */
+  previousFingerprint: z3.string().optional(),
+  location: factLocationSchema,
+  evidence: z3.array(factEvidenceSchema).min(1),
+  evidenceGrade: evidenceGradeSchema.optional(),
+  fix: findingFixSchema.optional(),
+  attributes: z3.record(z3.unknown()).optional(),
+  /**
+   * Product area this finding's file resolved to (topology layer). Optional —
+   * absent when the repo has no `topology` config. See `topology/resolve-area`.
+   */
+  area: z3.object({
+    areaId: z3.string(),
+    areaName: z3.string(),
+    criticality: z3.enum(["low", "medium", "high", "revenue", "regulated"]),
+    owners: z3.array(z3.string()),
+    matchedGlob: z3.string()
+  }).optional()
+});
+var violationSchema = z3.object({
+  nodeId: z3.string(),
+  nodeType: z3.string(),
+  rule: z3.string(),
+  severity: severitySchema,
+  level: severityLevelSchema.optional(),
+  code: z3.string().regex(/^FUI\d{4}$/).optional(),
+  helpUrl: z3.string().url().optional(),
+  message: z3.string(),
+  path: z3.string().optional(),
+  suggestion: z3.string().optional(),
+  prop: z3.string().optional(),
+  filePath: z3.string().optional(),
+  line: z3.number().int().nonnegative().optional(),
+  column: z3.number().int().nonnegative().optional(),
+  rawValue: z3.string().optional(),
+  extra: z3.record(z3.unknown()).optional()
+});
+var fixSchema = z3.object({
+  nodeId: z3.string(),
+  prop: z3.string().optional(),
+  action: z3.enum(["remove", "replace", "add"]),
+  value: z3.unknown().optional(),
+  description: z3.string()
+});
+var validatorResultSchema = z3.object({
+  validator: z3.string(),
+  severity: severitySchema,
+  passed: z3.boolean(),
+  violations: z3.array(violationSchema),
+  findings: z3.array(findingSchema).optional(),
+  suggestions: z3.array(fixSchema).optional()
+});
+var governanceVerdictMetadataSchema = z3.object({
+  runner: z3.string(),
+  policyVersion: z3.string().optional(),
+  duration: z3.number().nonnegative(),
+  nodeCount: z3.number().int().nonnegative(),
+  componentTypes: z3.array(z3.string())
+});
+var governanceVerdictSchema = z3.object({
+  verdict: z3.enum(["pass", "warn", "fail"]).optional(),
+  passed: z3.boolean(),
+  score: z3.number(),
+  results: z3.array(validatorResultSchema),
+  metadata: governanceVerdictMetadataSchema
+});
+var suppressionDirectiveSchema = z3.object({
+  ruleId: z3.string().optional(),
+  reason: z3.string().min(1),
+  expiresAt: z3.string().datetime().optional(),
+  expiresOn: z3.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  scope: z3.enum(["line", "block", "file"]).default("line"),
+  code: z3.string().regex(/^FUI\d{4}$/).optional()
+});
+var agentPlanSchema = z3.object({
+  tool: z3.enum([
+    "design_system/list_primitives",
+    "design_system/conform",
+    "design_system/prove_compliant"
+  ]),
+  args: z3.record(z3.unknown()),
+  confidence: z3.number().min(0).max(1)
+});
+var agentFindingSchema = z3.object({
+  code: z3.string().regex(/^FUI\d{4}$/).optional(),
+  ruleId: z3.string(),
+  filePath: z3.string(),
+  line: z3.number().int().nonnegative(),
+  col: z3.number().int().nonnegative(),
+  severity: severitySchema,
+  level: severityLevelSchema,
+  message: z3.string(),
+  evidenceGrade: evidenceGradeSchema.optional(),
+  evidence: z3.array(factEvidenceSchema),
+  plan: agentPlanSchema
+});
+var AGENT_FORMAT_SCHEMA_VERSION = "typestyle.agent.v2";
+var agentIntegritySchema = z3.object({
+  rulesLoaded: z3.number().int().nonnegative(),
+  status: z3.enum(["healthy", "degraded", "inert"]),
+  healthy: z3.boolean(),
+  inert: z3.boolean(),
+  reasons: z3.array(z3.string())
+});
+var agentRunProvenanceSchema = z3.object({
+  runId: z3.string().regex(/^run_[a-f0-9]{12}$/),
+  fcid: z3.string().min(1),
+  baselineId: z3.string().min(1).optional(),
+  scope: z3.object({
+    method: z3.enum(["three-dot", "tree-diff", "status", "fallback-full", "explicit", "full"]),
+    gitOk: z3.boolean()
+  }),
+  engineVersion: z3.string().min(1),
+  scopeHash: z3.string().regex(/^[a-f0-9]{64}$/),
+  inputsHash: z3.string().regex(/^[a-f0-9]{64}$/).optional(),
+  inputFilesHash: z3.string().regex(/^[a-f0-9]{64}$/)
+});
+var agentRunVerdictSchema = z3.object({
+  exitCode: z3.union([z3.literal(0), z3.literal(1)]),
+  reasons: z3.array(z3.string()),
+  gatingFindingCount: z3.number().int().nonnegative()
+});
+var agentFormatBaseSchema = z3.object({
+  schemaVersion: z3.literal(AGENT_FORMAT_SCHEMA_VERSION),
+  summary: z3.string(),
+  integrity: agentIntegritySchema,
+  fix_first: z3.array(agentFindingSchema),
+  remaining: z3.array(agentFindingSchema),
+  suppression_template: z3.object({
+    directive: z3.string(),
+    requiredFields: z3.array(z3.string()),
+    example: z3.string()
+  }),
+  budget: z3.object({
+    iteration: z3.number().int().nonnegative(),
+    maxIterations: z3.number().int().positive(),
+    scoreDelta: z3.number()
+  }),
+  findings: z3.array(findingSchema).optional(),
+  suppressions: z3.array(suppressionDirectiveSchema).optional(),
+  provenance: agentRunProvenanceSchema.optional(),
+  verdict: agentRunVerdictSchema.optional()
+});
+var agentFormatSchema = z3.union([
+  agentFormatBaseSchema.extend({
+    passed: z3.boolean(),
+    score: z3.number(),
+    status: z3.never().optional(),
+    reasons: z3.never().optional(),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z3.number().int().positive()
+    })
+  }),
+  agentFormatBaseSchema.extend({
+    passed: z3.literal(false),
+    score: z3.never().optional(),
+    status: z3.literal("indeterminate"),
+    reasons: z3.tuple([z3.literal("zero_rules_loaded")]),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z3.literal(0)
+    })
+  }),
+  // A finalized Run can explicitly allow inert governance. Preserve the
+  // indeterminate integrity truth while making `passed` match that Run's sole
+  // verdict; requiring Run pins prevents generic zero-rule envelopes from
+  // accidentally becoming green.
+  agentFormatBaseSchema.extend({
+    passed: z3.literal(true),
+    score: z3.never().optional(),
+    status: z3.literal("indeterminate"),
+    reasons: z3.tuple([z3.literal("zero_rules_loaded")]),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z3.literal(0)
+    }),
+    provenance: agentRunProvenanceSchema,
+    verdict: agentRunVerdictSchema.extend({ exitCode: z3.literal(0) })
+  })
+]);
+var agentErrorEnvelopeSchema = z3.object({
+  schemaVersion: z3.literal(AGENT_FORMAT_SCHEMA_VERSION),
+  passed: z3.literal(false),
+  error: z3.object({
+    code: z3.string().min(1),
+    message: z3.string().min(1)
+  }),
+  provenance: agentRunProvenanceSchema.optional(),
+  verdict: agentRunVerdictSchema.optional(),
+  cloudReport: z3.enum(["reported", "failed", "skipped"]).optional(),
+  notices: z3.array(z3.string()).optional()
+});
+var agentOutputSchema = z3.union([agentFormatSchema, agentErrorEnvelopeSchema]);
+function normalizeSeverity(severity) {
+  return severitySchema.safeParse(severity).success ? severity : severityFromLevel(legacySeverityLevelSchema.parse(severity));
+}
+function normalizeFinding(input) {
+  const code2 = input.code === void 0 ? byRuleId.get(input.ruleId) : void 0;
+  return {
+    ...input,
+    code: input.code ?? code2?.code,
+    helpUrl: input.helpUrl ?? code2?.explainUrl,
+    evidenceGrade: input.evidenceGrade ?? "source_backed",
+    level: input.level ?? severityLevel(input.severity)
+  };
+}
+function normalizeViolation(input) {
+  return {
+    ...input,
+    level: input.level ?? severityLevel(input.severity)
+  };
+}
+
 // src/codes/source-finding-bridge.ts
 function bridgeSourceViolation(input) {
   const ruleId = input.canonicalRuleId ?? input.violation.rule;
@@ -2591,6 +2884,31 @@ export {
   projectSupersededImportPathPreferences,
   compileComponentFacts,
   bridgeSourceViolation,
-  bridgeSourceViolations
+  bridgeSourceViolations,
+  factLocationSchema,
+  findingReplacePropValueFixSchema,
+  findingReplaceStyleValueFixSchema,
+  findingReplaceImportFixSchema,
+  findingReplaceComponentFixSchema,
+  findingReplaceClassTokenFixSchema,
+  findingFixSchema,
+  factEvidenceSchema,
+  findingSchema,
+  violationSchema,
+  fixSchema,
+  validatorResultSchema,
+  governanceVerdictMetadataSchema,
+  governanceVerdictSchema,
+  suppressionDirectiveSchema,
+  agentPlanSchema,
+  agentFindingSchema,
+  AGENT_FORMAT_SCHEMA_VERSION,
+  agentIntegritySchema,
+  agentFormatSchema,
+  agentErrorEnvelopeSchema,
+  agentOutputSchema,
+  normalizeSeverity,
+  normalizeFinding,
+  normalizeViolation
 };
-//# sourceMappingURL=chunk-WNMWKUYG.js.map
+//# sourceMappingURL=chunk-DGHZQTLH.js.map