@usefragments/core 1.2.0 → 1.3.0

package/src/rules/utils.ts

@@ -18,6 +18,57 @@ import type {
   UsagePropResolvedFact,
   UsageTextChildFact,
 } from "../facts/index.js";
+import type { FindingFix } from "./types.js";
+
+export interface FixProof {
+  symbols: readonly string[];
+  editKind: FindingFix["kind"];
+  valuePreserving: boolean;
+}
+
+export interface FixEmission<F extends FindingFix = FindingFix> {
+  fix: F;
+  downgradeReason?: string;
+}
+
+/**
+ * Gate token-substitution fixes on explicit proof. Callers attach any returned
+ * downgradeReason to the finding attributes so machine consumers can explain
+ * why a suggestion was not auto-applicable.
+ */
+export function emitFix<F extends FindingFix>(
+  fix: F,
+  proof: FixProof,
+  ix: FactIndex
+): FixEmission<F> {
+  const reasons: string[] = [];
+  if (proof.editKind !== fix.kind) reasons.push("edit kind does not match proof");
+  if (!proof.valuePreserving) reasons.push("value-preservation proof missing");
+  if (proof.symbols.length === 0) reasons.push("token-symbol proof missing");
+
+  const missingSymbols = proof.symbols.filter((symbol) => !ix.tokens.symbolExists(symbol));
+  if (missingSymbols.length > 0) {
+    reasons.push(`absent token symbol: ${missingSymbols.join(", ")}`);
+  }
+
+  const inapplicableSymbols = proof.symbols.filter((symbol) => {
+    const definition = ix.tokens.definitionForSymbol(symbol);
+    return definition !== undefined && !isApplicableTokenReference(definition.referenceFormat);
+  });
+  if (inapplicableSymbols.length > 0) {
+    reasons.push(`token reference is not directly applicable: ${inapplicableSymbols.join(", ")}`);
+  }
+
+  return {
+    fix: { ...fix, deterministic: reasons.length === 0 },
+    ...(reasons.length > 0 ? { downgradeReason: reasons.join("; ") } : {}),
+  };
+}
+
+/** Extract authored token symbols from a replacement string, preserving order. */
+export function tokenSymbolsInText(value: string): string[] {
+  return [...new Set(value.match(/\$[A-Za-z0-9_-]+|--[A-Za-z0-9_-]+/g) ?? [])];
+}
 
 export interface LengthScale {
   unit: "px" | "rem";

package/src/schemas/index.ts

@@ -8,6 +8,15 @@ import {
   severitySchema,
 } from "../severity.js";
 import type { LegacySeverityLevel, Severity } from "../severity.js";
+import type { EvidenceGrade } from "../evidence.js";
+
+const evidenceGradeSchema: z.ZodType<EvidenceGrade> = z.enum([
+  "none",
+  "runtime_advisory",
+  "provenance_bound",
+  "source_backed",
+  "receipt_backed",
+]);
 
 export { legacySeverityLevelSchema, severityLevelSchema, severitySchema };
 export type { LegacySeverityLevel, Severity, SeverityLevel } from "../severity.js";
@@ -108,6 +117,7 @@ export const findingSchema = z.object({
   fingerprint: z.string(),
   location: factLocationSchema,
   evidence: z.array(factEvidenceSchema).min(1),
+  evidenceGrade: evidenceGradeSchema.optional(),
   fix: findingFixSchema.optional(),
   attributes: z.record(z.unknown()).optional(),
   /**
@@ -224,6 +234,7 @@ export const agentFindingSchema = z.object({
   severity: severitySchema,
   level: severityLevelSchema,
   message: z.string(),
+  evidenceGrade: evidenceGradeSchema.optional(),
   evidence: z.array(factEvidenceSchema),
   plan: agentPlanSchema,
 });
@@ -238,10 +249,34 @@ export const agentIntegritySchema = z.object({
   reasons: z.array(z.string()),
 });
 
-export const agentFormatSchema = z.object({
+const agentRunProvenanceSchema = z.object({
+  runId: z.string().regex(/^run_[a-f0-9]{12}$/),
+  fcid: z.string().min(1),
+  baselineId: z.string().min(1).optional(),
+  scope: z.object({
+    method: z.enum([
+      "three-dot",
+      "tree-diff",
+      "status",
+      "fallback-full",
+      "explicit",
+      "full",
+    ]),
+    gitOk: z.boolean(),
+  }),
+  engineVersion: z.string().min(1),
+  scopeHash: z.string().regex(/^[a-f0-9]{64}$/),
+  inputFilesHash: z.string().regex(/^[a-f0-9]{64}$/),
+});
+
+const agentRunVerdictSchema = z.object({
+  exitCode: z.union([z.literal(0), z.literal(1)]),
+  reasons: z.array(z.string()),
+  gatingFindingCount: z.number().int().nonnegative(),
+});
+
+const agentFormatBaseSchema = z.object({
   schemaVersion: z.literal(AGENT_FORMAT_SCHEMA_VERSION),
-  passed: z.boolean(),
-  score: z.number(),
   summary: z.string(),
   integrity: agentIntegritySchema,
   fix_first: z.array(agentFindingSchema),
@@ -258,7 +293,45 @@ export const agentFormatSchema = z.object({
   }),
   findings: z.array(findingSchema).optional(),
   suppressions: z.array(suppressionDirectiveSchema).optional(),
+  provenance: agentRunProvenanceSchema.optional(),
+  verdict: agentRunVerdictSchema.optional(),
 });
+
+export const agentFormatSchema = z.union([
+  agentFormatBaseSchema.extend({
+    passed: z.boolean(),
+    score: z.number(),
+    status: z.never().optional(),
+    reasons: z.never().optional(),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z.number().int().positive(),
+    }),
+  }),
+  agentFormatBaseSchema.extend({
+    passed: z.literal(false),
+    score: z.never().optional(),
+    status: z.literal("indeterminate"),
+    reasons: z.tuple([z.literal("zero_rules_loaded")]),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z.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: z.literal(true),
+    score: z.never().optional(),
+    status: z.literal("indeterminate"),
+    reasons: z.tuple([z.literal("zero_rules_loaded")]),
+    integrity: agentIntegritySchema.extend({
+      rulesLoaded: z.literal(0),
+    }),
+    provenance: agentRunProvenanceSchema,
+    verdict: agentRunVerdictSchema.extend({ exitCode: z.literal(0) }),
+  }),
+]);
 export type AgentFormat = z.infer<typeof agentFormatSchema>;
 
 export const agentErrorEnvelopeSchema = z.object({
@@ -268,6 +341,10 @@ export const agentErrorEnvelopeSchema = z.object({
     code: z.string().min(1),
     message: z.string().min(1),
   }),
+  provenance: agentRunProvenanceSchema.optional(),
+  verdict: agentRunVerdictSchema.optional(),
+  cloudReport: z.enum(["reported", "failed", "skipped"]).optional(),
+  notices: z.array(z.string()).optional(),
 });
 export type AgentErrorEnvelope = z.infer<typeof agentErrorEnvelopeSchema>;
 
@@ -285,6 +362,7 @@ export function normalizeFinding(
 ): Finding {
   return {
     ...input,
+    evidenceGrade: input.evidenceGrade ?? "source_backed",
     level: input.level ?? severityLevel(input.severity),
   };
 }

package/src/token-types.ts

@@ -59,6 +59,12 @@ export interface DesignToken {
   /** Source file where this token was defined */
   sourceFile: string;
 
+  /** Authored reference form, when the parser can prove it from the source. */
+  referenceFormat?: "css-var" | "scss-var" | "scss-map" | "dtcg";
+
+  /** Authored spellings preserved before normalization (for example `$x` and `--x`). */
+  sourceNames?: string[];
+
   /** Line number in source file */
   lineNumber?: number;
 

package/src/tokens/__tests__/source-names.test.ts

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+import { FactIndex, makeTokenDefinitionFact } from "../../facts/index.js";
+import { parseDesignTokenContent } from "../design-token-parser.js";
+
+const tokenFile = fileURLToPath(
+  new URL("../../../../../libs/ui/src/tokens/_variables.scss", import.meta.url)
+);
+
+describe("SCSS source-name provenance", () => {
+  it("preserves both authored spellings through parser, facts, and rule-time lookup", () => {
+    const parsed = parseDesignTokenContent(readFileSync(tokenFile, "utf8"), {
+      filePath: tokenFile,
+    });
+    const token = parsed.tokens.find((candidate) => candidate.name === "--fui-space-2");
+
+    expect(token?.sourceNames).toEqual(expect.arrayContaining(["--fui-space-2", "$fui-space-2"]));
+
+    const ix = new FactIndex();
+    ix.addMany(
+      parsed.tokens.map((candidate) =>
+        makeTokenDefinitionFact({
+          name: candidate.name,
+          value: candidate.resolvedValue,
+          category: candidate.category === "spacing" ? "spacing" : "other",
+          referenceFormat: candidate.referenceFormat,
+          sourceNames: candidate.sourceNames,
+        })
+      )
+    );
+
+    expect(ix.tokens.symbolExists("$fui-space-2")).toBe(true);
+    expect(ix.tokens.symbolExists("--fui-space-2")).toBe(true);
+    expect(ix.tokens.symbolExists("$fui-space-99")).toBe(false);
+    expect(ix.tokens.definitionForSymbol("$fui-space-2")?.sourceNames).toEqual(
+      expect.arrayContaining(["--fui-space-2", "$fui-space-2"])
+    );
+  });
+});

package/src/tokens/design-token-parser.test.ts

@@ -67,15 +67,34 @@ describe("parseDesignTokenContent — DTCG/JSON format dispatch (#10)", () => {
 describe("parseDesignTokenContent — SCSS $-variable format dispatch (#32)", () => {
   it("parses SCSS $vars, normalizing $name to --name", () => {
     const content = "$fui-color-accent: #fff;\n$fui-space-2: 8px;";
-    const tokens = names(content, "tokens.scss");
-    expect(tokens).toContain("--fui-color-accent");
-    expect(tokens).toContain("--fui-space-2");
+    const tokens = parseDesignTokenContent(content, { filePath: "tokens.scss" }).tokens;
+    expect(tokens).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "--fui-color-accent",
+          referenceFormat: "scss-var",
+        }),
+        expect.objectContaining({ name: "--fui-space-2", referenceFormat: "scss-var" }),
+      ])
+    );
   });
 
   it("dedupes a file declaring BOTH --fui-x and $fui-x to one --fui-x", () => {
     const content = ":root {\n  --fui-x: red;\n}\n$fui-x: red;";
-    const tokens = names(content, "tokens.scss");
-    expect(tokens.filter((n) => n === "--fui-x")).toHaveLength(1);
+    const tokens = parseDesignTokenContent(content, { filePath: "tokens.scss" }).tokens.filter(
+      (token) => token.name === "--fui-x"
+    );
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0].referenceFormat).toBe("scss-var");
+  });
+
+  it("marks a CSS-only declaration in SCSS as css-var", () => {
+    const content = ":root {\n  --fui-color-accent: red;\n}";
+    const token = parseDesignTokenContent(content, { filePath: "tokens.scss" }).tokens.find(
+      (candidate) => candidate.name === "--fui-color-accent"
+    );
+
+    expect(token?.referenceFormat).toBe("css-var");
   });
 
   it("surfaces a NON-SILENT warning for a comment-only SCSS file (#32)", () => {

package/src/tokens/design-token-parser.ts

@@ -193,21 +193,51 @@ function parsedOutputToDesignTokens(output: TokenParseOutput, filePath: string):
  * and `$fui-x` yields one `--fui-x`.
  */
 function scssOutputToDesignTokens(output: TokenParseOutput, filePath: string): DesignToken[] {
-  const names = new Set<string>();
-  const tokens: DesignToken[] = [];
+  const tokensByName = new Map<
+    string,
+    {
+      parsed: ParsedToken;
+      referenceFormat: "css-var" | "scss-var";
+      sourceNames: Set<string>;
+    }
+  >();
   for (const cat of Object.values(output.categories)) {
     for (const t of cat) {
-      const cssName = t.name.startsWith("$") ? `--${t.name.slice(1)}` : t.name;
-      if (!cssName.startsWith("--") || names.has(cssName)) continue;
-      names.add(cssName);
-      tokens.push(designTokenFromParsed(cssName, t, filePath));
+      const isScssVariable = t.name.startsWith("$");
+      const cssName = isScssVariable ? `--${t.name.slice(1)}` : t.name;
+      if (!cssName.startsWith("--")) continue;
+
+      const existing = tokensByName.get(cssName);
+      if (!existing) {
+        tokensByName.set(cssName, {
+          parsed: t,
+          referenceFormat: isScssVariable ? "scss-var" : "css-var",
+          sourceNames: new Set([t.name]),
+        });
+      } else {
+        existing.sourceNames.add(t.name);
+        if (isScssVariable) {
+          existing.parsed = t;
+          existing.referenceFormat = "scss-var";
+        }
+      }
     }
   }
-  return tokens;
+  return [...tokensByName].map(([name, token]) =>
+    designTokenFromParsed(name, token.parsed, filePath, token.referenceFormat, [
+      ...token.sourceNames,
+    ])
+  );
 }
 
 /** Build a `DesignToken` from a sibling-parser `ParsedToken` under a CSS name. */
-function designTokenFromParsed(name: string, parsed: ParsedToken, filePath: string): DesignToken {
+function designTokenFromParsed(
+  name: string,
+  parsed: ParsedToken,
+  filePath: string,
+  referenceFormat?: DesignToken["referenceFormat"],
+  sourceNames?: string[]
+): DesignToken {
   return {
     name,
     rawValue: parsed.value ?? "",
@@ -220,6 +250,8 @@ function designTokenFromParsed(name: string, parsed: ParsedToken, filePath: stri
     level: 1,
     referenceChain: [],
     sourceFile: filePath,
+    referenceFormat,
+    ...(sourceNames?.length ? { sourceNames } : {}),
     theme: "default",
     selector: ":root",
     description: parsed.description,

package/dist/chunk-BQQTMGLA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/schemas/index.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport {\n  legacySeverityLevelSchema,\n  severityFromLevel,\n  severityLevel,\n  severityLevelSchema,\n  severitySchema,\n} from \"../severity.js\";\nimport type { LegacySeverityLevel, Severity } from \"../severity.js\";\n\nexport { legacySeverityLevelSchema, severityLevelSchema, severitySchema };\nexport type { LegacySeverityLevel, Severity, SeverityLevel } from \"../severity.js\";\n\nexport const factLocationSchema = z.object({\n  file: z.string(),\n  line: z.number().int().nonnegative(),\n  column: z.number().int().nonnegative(),\n  endLine: z.number().int().nonnegative().optional(),\n  endColumn: z.number().int().nonnegative().optional(),\n});\nexport type FactLocation = z.infer<typeof factLocationSchema>;\n\nexport const findingReplacePropValueFixSchema = z.object({\n  kind: z.literal(\"replacePropValue\"),\n  title: z.string(),\n  prop: z.string(),\n  value: z.unknown(),\n  deterministic: z.boolean().optional(),\n});\n\nexport const findingReplaceStyleValueFixSchema = z.object({\n  kind: z.literal(\"replaceStyleValue\"),\n  title: z.string(),\n  property: z.string(),\n  value: z.string(),\n  deterministic: z.boolean().optional(),\n});\n\nexport const findingReplaceImportFixSchema = z.object({\n  kind: z.literal(\"replaceImport\"),\n  title: z.string(),\n  from: z.string(),\n  to: z.string(),\n  deterministic: z.boolean().optional(),\n});\n\nexport const findingReplaceComponentFixSchema = z.object({\n  kind: z.literal(\"replaceComponent\"),\n  title: z.string(),\n  from: z.string(),\n  to: z.string(),\n  deterministic: z.boolean().optional(),\n});\n\nexport const findingReplaceClassTokenFixSchema = z.object({\n  kind: z.literal(\"replaceClassToken\"),\n  title: z.string(),\n  from: z.string(),\n  to: z.string().nullable(),\n  utility: z.string(),\n  deterministic: z.boolean().optional(),\n});\n\nexport const findingFixSchema = z.discriminatedUnion(\"kind\", [\n  findingReplacePropValueFixSchema,\n  findingReplaceStyleValueFixSchema,\n  findingReplaceImportFixSchema,\n  findingReplaceComponentFixSchema,\n  findingReplaceClassTokenFixSchema,\n]);\nexport type FindingFix = z.infer<typeof findingFixSchema>;\nexport type FindingReplacePropValueFix = z.infer<typeof findingReplacePropValueFixSchema>;\nexport type FindingReplaceStyleValueFix = z.infer<typeof findingReplaceStyleValueFixSchema>;\nexport type FindingReplaceImportFix = z.infer<typeof findingReplaceImportFixSchema>;\nexport type FindingReplaceComponentFix = z.infer<typeof findingReplaceComponentFixSchema>;\nexport type FindingReplaceClassTokenFix = z.infer<typeof findingReplaceClassTokenFixSchema>;\n\nexport interface FactEvidence {\n  factId: string;\n  fact: {\n    kind: string;\n    location?: FactLocation;\n  };\n}\n\nexport const factEvidenceSchema: z.ZodType<FactEvidence> = z.object({\n  factId: z.string(),\n  fact: z\n    .object({\n      kind: z.string(),\n      location: factLocationSchema.optional(),\n    })\n    .passthrough(),\n});\n\nexport const findingSchema = z.object({\n  ruleId: z.string(),\n  ruleVersion: z.string(),\n  severity: severitySchema,\n  level: severityLevelSchema,\n  code: z\n    .string()\n    .regex(/^FUI\\d{4}$/)\n    .optional(),\n  helpUrl: z.string().url().optional(),\n  message: z.string(),\n  fingerprint: z.string(),\n  location: factLocationSchema,\n  evidence: z.array(factEvidenceSchema).min(1),\n  fix: findingFixSchema.optional(),\n  attributes: z.record(z.unknown()).optional(),\n  /**\n   * Product area this finding's file resolved to (topology layer). Optional —\n   * absent when the repo has no `topology` config. See `topology/resolve-area`.\n   */\n  area: z\n    .object({\n      areaId: z.string(),\n      areaName: z.string(),\n      criticality: z.enum([\"low\", \"medium\", \"high\", \"revenue\", \"regulated\"]),\n      owners: z.array(z.string()),\n      matchedGlob: z.string(),\n    })\n    .optional(),\n});\nexport type Finding = z.infer<typeof findingSchema>;\n\nexport const violationSchema = z.object({\n  nodeId: z.string(),\n  nodeType: z.string(),\n  rule: z.string(),\n  severity: severitySchema,\n  level: severityLevelSchema.optional(),\n  code: z\n    .string()\n    .regex(/^FUI\\d{4}$/)\n    .optional(),\n  helpUrl: z.string().url().optional(),\n  message: z.string(),\n  path: z.string().optional(),\n  suggestion: z.string().optional(),\n  prop: z.string().optional(),\n  filePath: z.string().optional(),\n  line: z.number().int().nonnegative().optional(),\n  column: z.number().int().nonnegative().optional(),\n  rawValue: z.string().optional(),\n  extra: z.record(z.unknown()).optional(),\n});\nexport type Violation = z.infer<typeof violationSchema>;\n\nexport const fixSchema = z.object({\n  nodeId: z.string(),\n  prop: z.string().optional(),\n  action: z.enum([\"remove\", \"replace\", \"add\"]),\n  value: z.unknown().optional(),\n  description: z.string(),\n});\nexport type Fix = z.infer<typeof fixSchema>;\n\nexport const validatorResultSchema = z.object({\n  validator: z.string(),\n  severity: severitySchema,\n  passed: z.boolean(),\n  violations: z.array(violationSchema),\n  findings: z.array(findingSchema).optional(),\n  suggestions: z.array(fixSchema).optional(),\n});\nexport type ValidatorResult = z.infer<typeof validatorResultSchema>;\n\nexport const governanceVerdictMetadataSchema = z.object({\n  runner: z.string(),\n  policyVersion: z.string().optional(),\n  duration: z.number().nonnegative(),\n  nodeCount: z.number().int().nonnegative(),\n  componentTypes: z.array(z.string()),\n});\nexport type GovernanceVerdictMetadata = z.infer<typeof governanceVerdictMetadataSchema>;\n\nexport const governanceVerdictSchema = z.object({\n  verdict: z.enum([\"pass\", \"warn\", \"fail\"]).optional(),\n  passed: z.boolean(),\n  score: z.number(),\n  results: z.array(validatorResultSchema),\n  metadata: governanceVerdictMetadataSchema,\n});\nexport type GovernanceVerdict = z.infer<typeof governanceVerdictSchema>;\n\nexport const suppressionDirectiveSchema = z.object({\n  ruleId: z.string().optional(),\n  reason: z.string().min(1),\n  expiresAt: z.string().datetime().optional(),\n  expiresOn: z\n    .string()\n    .regex(/^\\d{4}-\\d{2}-\\d{2}$/)\n    .optional(),\n  scope: z.enum([\"line\", \"block\", \"file\"]).default(\"line\"),\n  code: z\n    .string()\n    .regex(/^FUI\\d{4}$/)\n    .optional(),\n});\nexport type SuppressionDirective = z.infer<typeof suppressionDirectiveSchema>;\n\nexport const agentPlanSchema = z.object({\n  tool: z.enum([\n    \"design_system/list_primitives\",\n    \"design_system/conform\",\n    \"design_system/prove_compliant\",\n  ]),\n  args: z.record(z.unknown()),\n  confidence: z.number().min(0).max(1),\n});\n\nexport const agentFindingSchema = z.object({\n  code: z\n    .string()\n    .regex(/^FUI\\d{4}$/)\n    .optional(),\n  ruleId: z.string(),\n  filePath: z.string(),\n  line: z.number().int().nonnegative(),\n  col: z.number().int().nonnegative(),\n  severity: severitySchema,\n  level: severityLevelSchema,\n  message: z.string(),\n  evidence: z.array(factEvidenceSchema),\n  plan: agentPlanSchema,\n});\n\nexport const AGENT_FORMAT_SCHEMA_VERSION = \"typestyle.agent.v2\" as const;\n\nexport const agentIntegritySchema = z.object({\n  rulesLoaded: z.number().int().nonnegative(),\n  status: z.enum([\"healthy\", \"degraded\", \"inert\"]),\n  healthy: z.boolean(),\n  inert: z.boolean(),\n  reasons: z.array(z.string()),\n});\n\nexport const agentFormatSchema = z.object({\n  schemaVersion: z.literal(AGENT_FORMAT_SCHEMA_VERSION),\n  passed: z.boolean(),\n  score: z.number(),\n  summary: z.string(),\n  integrity: agentIntegritySchema,\n  fix_first: z.array(agentFindingSchema),\n  remaining: z.array(agentFindingSchema),\n  suppression_template: z.object({\n    directive: z.string(),\n    requiredFields: z.array(z.string()),\n    example: z.string(),\n  }),\n  budget: z.object({\n    iteration: z.number().int().nonnegative(),\n    maxIterations: z.number().int().positive(),\n    scoreDelta: z.number(),\n  }),\n  findings: z.array(findingSchema).optional(),\n  suppressions: z.array(suppressionDirectiveSchema).optional(),\n});\nexport type AgentFormat = z.infer<typeof agentFormatSchema>;\n\nexport const agentErrorEnvelopeSchema = z.object({\n  schemaVersion: z.literal(AGENT_FORMAT_SCHEMA_VERSION),\n  passed: z.literal(false),\n  error: z.object({\n    code: z.string().min(1),\n    message: z.string().min(1),\n  }),\n});\nexport type AgentErrorEnvelope = z.infer<typeof agentErrorEnvelopeSchema>;\n\nexport const agentOutputSchema = z.union([agentFormatSchema, agentErrorEnvelopeSchema]);\nexport type AgentOutput = z.infer<typeof agentOutputSchema>;\n\nexport function normalizeSeverity(severity: Severity | LegacySeverityLevel): Severity {\n  return severitySchema.safeParse(severity).success\n    ? (severity as Severity)\n    : severityFromLevel(legacySeverityLevelSchema.parse(severity));\n}\n\nexport function normalizeFinding(\n  input: Omit<Finding, \"level\"> & { level?: Finding[\"level\"] }\n): Finding {\n  return {\n    ...input,\n    level: input.level ?? severityLevel(input.severity),\n  };\n}\n\nexport function normalizeViolation(\n  input: Omit<Violation, \"level\"> & { level?: Violation[\"level\"] }\n): Violation {\n  return {\n    ...input,\n    level: input.level ?? severityLevel(input.severity),\n  };\n}\n"],"mappings":"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","names":[]}