@var-ia/eval 0.1.1

package/src/__tests__/calibration.test.ts

@@ -0,0 +1,122 @@
+import type { EvidenceEvent, EvidenceLayer, ModelInterpretation } from "@var-ia/evidence-graph";
+import type { InterpretedEvent } from "@var-ia/interpreter";
+import { describe, expect, it } from "vitest";
+import type { ExpectedInterpretation } from "../calibration.js";
+import { computeCalibration } from "../calibration.js";
+
+function makeInterpretedEvent(eventType: string, semanticChange: string, confidence: number): InterpretedEvent {
+  const layer: EvidenceLayer = "observed";
+  return {
+    eventType: eventType as EvidenceEvent["eventType"],
+    fromRevisionId: 1,
+    toRevisionId: 2,
+    section: "body",
+    before: "",
+    after: "change",
+    deterministicFacts: [{ fact: "test" }],
+    modelInterpretation: { semanticChange, confidence } as ModelInterpretation,
+    layer,
+    timestamp: "2026-01-01T00:00:00Z",
+  };
+}
+
+describe("computeCalibration", () => {
+  it("returns perfect calibration when model is always correct and confident", () => {
+    const interpretations = [makeInterpretedEvent("revert_detected", "revert", 0.9)];
+    const expected: ExpectedInterpretation[] = [{ semanticChange: "revert" }];
+
+    const result = computeCalibration(interpretations, expected);
+
+    expect(result.totalSamples).toBe(1);
+    expect(result.overallAccuracy).toBe(1.0);
+    // Confidence 0.9 maps to bin 9 [0.9, 1.0)
+    const bin = result.bins[9];
+    expect(bin.count).toBe(1);
+    expect(bin.empiricalAccuracy).toBe(1.0);
+  });
+
+  it("reports zero accuracy when model is always wrong", () => {
+    const interpretations = [
+      makeInterpretedEvent("revert_detected", "revert", 0.9),
+      makeInterpretedEvent("citation_added", "add", 0.8),
+    ];
+    const expected: ExpectedInterpretation[] = [
+      { semanticChange: "something_else" },
+      { semanticChange: "something_else" },
+    ];
+
+    const result = computeCalibration(interpretations, expected);
+
+    expect(result.overallAccuracy).toBe(0.0);
+  });
+
+  it("computes ECE correctly for perfectly calibrated model", () => {
+    const interpretations: InterpretedEvent[] = [];
+    const expected: ExpectedInterpretation[] = [];
+
+    // For each bin, create N=100 samples at the bin midpoint.
+    // Set correctCount such that accuracy ≈ midpoint for ECE ≈ 0.
+    // ECE = sum over bins of (bin_fraction * abs(midpoint - accuracy))
+    // With 10 bins each having 100 samples, bin_fraction = 0.1.
+    // accuracy = correctCount / 100.
+    // Set correctCount = round(midpoint * 100) so accuracy ≈ midpoint.
+    const counts = [5, 15, 25, 35, 45, 55, 65, 75, 85, 95];
+    for (let bin = 0; bin < 10; bin++) {
+      const mid = (bin + 0.5) / 10;
+      const correct = counts[bin];
+      const total = 100;
+      for (let j = 0; j < total; j++) {
+        const semanticChange = j < correct ? `correct-${bin}` : `wrong-${bin}`;
+        interpretations.push(makeInterpretedEvent("revert_detected", semanticChange, mid));
+        expected.push({ semanticChange: `correct-${bin}` });
+      }
+    }
+
+    const result = computeCalibration(interpretations, expected);
+
+    // Each bin has accuracy ≈ midpoint, so ECE should be small
+    expect(result.ece).toBeLessThan(0.02);
+    expect(result.totalSamples).toBe(1000);
+    expect(result.overallAccuracy).toBeGreaterThan(0.4);
+  });
+
+  it("handles empty input", () => {
+    const result = computeCalibration([], []);
+    expect(result.totalSamples).toBe(0);
+    expect(result.overallAccuracy).toBe(0);
+    expect(result.ece).toBe(0);
+  });
+
+  it("truncates to shorter input length", () => {
+    const interpretations = [makeInterpretedEvent("revert_detected", "revert", 0.9)];
+    const expected: ExpectedInterpretation[] = [{ semanticChange: "revert" }, { semanticChange: "add" }];
+
+    const result = computeCalibration(interpretations, expected);
+    expect(result.totalSamples).toBe(1);
+  });
+
+  it("accepts 'any' wildcard to always count as correct", () => {
+    const interpretations = [
+      makeInterpretedEvent("revert_detected", "whatever", 0.7),
+      makeInterpretedEvent("citation_added", "anything", 0.6),
+    ];
+    const expected: ExpectedInterpretation[] = [{ semanticChange: "any" }, { semanticChange: "any" }];
+
+    const result = computeCalibration(interpretations, expected);
+    expect(result.overallAccuracy).toBe(1.0);
+  });
+
+  it("stores modelId in result", () => {
+    const result = computeCalibration([], [], "test-model-v1");
+    expect(result.modelId).toBe("test-model-v1");
+  });
+
+  it("bins are 0.0-0.1, 0.1-0.2, ..., 0.9-1.0", () => {
+    const result = computeCalibration([], [], "");
+    expect(result.bins).toHaveLength(10);
+    expect(result.bins[0].lowerBound).toBe(0.0);
+    expect(result.bins[0].upperBound).toBe(0.1);
+    expect(result.bins[9].lowerBound).toBe(0.9);
+    expect(result.bins[9].upperBound).toBe(1.0);
+  });
+});

package/src/__tests__/ground-truth.test.ts

@@ -0,0 +1,125 @@
+import type { EvidenceEvent } from "@var-ia/evidence-graph";
+import { describe, expect, it } from "vitest";
+import type { OutcomeLabel } from "../index.js";
+import { GROUND_TRUTH_LABELS, getGroundTruthForPage, validateAgainstGroundTruth } from "../index.js";
+
+function makeEvent(eventType: string, section = "body"): EvidenceEvent {
+  return {
+    eventType: eventType as EvidenceEvent["eventType"],
+    fromRevisionId: 1,
+    toRevisionId: 2,
+    section,
+    before: "",
+    after: "",
+    deterministicFacts: [],
+    layer: "observed",
+    timestamp: "2022-01-01T00:00:00Z",
+  };
+}
+
+describe("validateAgainstGroundTruth", () => {
+  it("validates a known outcome against a synthetic event stream (should pass)", () => {
+    const outcome: OutcomeLabel = {
+      id: "test-1",
+      source: "talk_page_consensus",
+      pageTitle: "Test",
+      description: "Article was reorganized per talk page consensus",
+      observedAt: "2022-01-01T00:00:00Z",
+      resolution: "keep",
+      referenceUrl: "https://en.wikipedia.org/wiki/Talk:Test",
+      expectedEventTypes: ["section_reorganized", "sentence_removed"],
+      expectedSection: "",
+    };
+
+    const events = [makeEvent("section_reorganized"), makeEvent("sentence_removed")];
+
+    const result = validateAgainstGroundTruth([outcome], events);
+
+    expect(result.passed).toBe(1);
+    expect(result.failed).toBe(0);
+    expect(result.perOutcome[0].passed).toBe(true);
+    expect(result.perOutcome[0].signalDetected).toBe(true);
+  });
+
+  it("reports misses against an empty event stream", () => {
+    const outcome: OutcomeLabel = {
+      id: "test-2",
+      source: "rfc_closure",
+      pageTitle: "Test",
+      description: "RFC closed with consensus to delete",
+      observedAt: "2022-01-01T00:00:00Z",
+      resolution: "delete",
+      referenceUrl: "https://en.wikipedia.org/wiki/Talk:Test",
+      expectedEventTypes: ["sentence_removed", "section_reorganized"],
+    };
+
+    const result = validateAgainstGroundTruth([outcome], []);
+
+    expect(result.perOutcome[0].passed).toBe(false);
+    expect(result.perOutcome[0].signalDetected).toBe(false);
+    expect(result.perOutcome[0].matchedEvents).toHaveLength(0);
+  });
+
+  it("computes precision and recall", () => {
+    const outcome: OutcomeLabel = {
+      id: "test-3",
+      source: "arbcom_decision",
+      pageTitle: "Test",
+      description: "ArbCom decision resulted in page protection",
+      observedAt: "2022-01-01T00:00:00Z",
+      resolution: "other",
+      referenceUrl: "https://en.wikipedia.org/wiki/Wikipedia:Arbitration",
+      expectedEventTypes: ["protection_changed", "revert_detected"],
+    };
+
+    const events = [makeEvent("protection_changed")];
+
+    const result = validateAgainstGroundTruth([outcome], events);
+
+    const r = result.perOutcome[0];
+    expect(r.precision).toBe(0.5);
+    expect(r.recall).toBe(1.0);
+    expect(r.matchedEvents).toHaveLength(1);
+  });
+
+  it("OutcomeLabel type is never populated from pipeline output", () => {
+    const outcome: OutcomeLabel = {
+      id: "test-4",
+      source: "page_protection",
+      pageTitle: "Test",
+      description: "Hardcoded ground truth, not pipeline output",
+      observedAt: "2022-01-01T00:00:00Z",
+      resolution: "other",
+      referenceUrl: "https://en.wikipedia.org/wiki/Special:Log",
+      expectedEventTypes: ["protection_changed"],
+    };
+    expect(outcome.source).toBe("page_protection");
+    expect(outcome.resolution).toBe("other");
+  });
+});
+
+describe("GROUND_TRUTH_LABELS", () => {
+  it("has at least 3 manually curated labels", () => {
+    expect(GROUND_TRUTH_LABELS.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("each label has required fields", () => {
+    for (const label of GROUND_TRUTH_LABELS) {
+      expect(label.id).toBeTruthy();
+      expect(label.pageTitle).toBeTruthy();
+      expect(label.source).toMatch(/^(talk_page_consensus|rfc_closure|arbcom_decision|page_protection)$/);
+      expect(label.referenceUrl).toMatch(/^https?:\/\//);
+      expect(label.expectedEventTypes.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("getGroundTruthForPage returns labels for known pages", () => {
+    const labels = getGroundTruthForPage("Donald Trump");
+    expect(labels.length).toBeGreaterThanOrEqual(1);
+    expect(labels[0].pageTitle).toBe("Donald Trump");
+  });
+
+  it("getGroundTruthForPage returns empty for unknown pages", () => {
+    expect(getGroundTruthForPage("Nonexistent_Page_XYZ")).toEqual([]);
+  });
+});

package/src/__tests__/harness.test.ts

@@ -0,0 +1,161 @@
+import type { EvidenceEvent, EvidenceLayer } from "@var-ia/evidence-graph";
+import { describe, expect, it } from "vitest";
+import type { EvalTestCase } from "../index.js";
+import { createEvalHarness } from "../index.js";
+
+function makeEvent(eventType: string, section = "body"): EvidenceEvent {
+  const layer: EvidenceLayer = "observed";
+  return {
+    eventType: eventType as EvidenceEvent["eventType"],
+    fromRevisionId: 1,
+    toRevisionId: 2,
+    section,
+    before: "",
+    after: "",
+    deterministicFacts: [],
+    layer,
+    timestamp: "2026-01-01T00:00:00Z",
+  };
+}
+
+describe("createEvalHarness", () => {
+  describe("evaluate", () => {
+    it("passes when all expected events are found", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "test-1",
+        description: "All events present",
+        pageTitle: "Test",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [
+          { eventType: "revert_detected", section: "body" },
+          { eventType: "citation_added", section: "body" },
+        ],
+        tolerance: { minPrecision: 0.5 },
+      };
+
+      const result = harness.evaluate(test, [makeEvent("revert_detected"), makeEvent("citation_added")]);
+
+      expect(result.passed).toBe(true);
+      expect(result.matches).toHaveLength(2);
+      expect(result.misses).toHaveLength(0);
+      expect(result.precision).toBe(1.0);
+    });
+
+    it("fails when expected events are missing", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "test-2",
+        description: "Missing events",
+        pageTitle: "Test",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [{ eventType: "revert_detected", section: "body" }],
+        tolerance: { minPrecision: 0.5 },
+      };
+
+      const result = harness.evaluate(test, []);
+      expect(result.passed).toBe(false);
+      expect(result.misses).toHaveLength(1);
+    });
+
+    it("reports false positives", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "test-3",
+        description: "Unexpected events",
+        pageTitle: "Test",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [{ eventType: "revert_detected", section: "body" }],
+        tolerance: { minPrecision: 0.5 },
+      };
+
+      const result = harness.evaluate(test, [makeEvent("revert_detected"), makeEvent("citation_added")]);
+
+      expect(result.falsePositives).toHaveLength(1);
+    });
+
+    it("respects event count tolerance", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "test-4",
+        description: "Event count bounds",
+        pageTitle: "Test",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [{ eventType: "revert_detected", section: "body" }],
+        tolerance: { minEventCount: 3 },
+      };
+
+      const result = harness.evaluate(test, [makeEvent("revert_detected")]);
+      expect(result.passed).toBe(false);
+    });
+
+    it("matches by event type and section", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "test-5",
+        description: "Section matching",
+        pageTitle: "Test",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [{ eventType: "section_reorganized", section: "(lead)" }],
+        tolerance: { minPrecision: 0.5 },
+      };
+
+      const wrongSection = makeEvent("section_reorganized", "body");
+      const result = harness.evaluate(test, [wrongSection]);
+      expect(result.misses).toHaveLength(1);
+    });
+  });
+
+  describe("benchmarkPages", () => {
+    it("returns at least 5 benchmark pages", () => {
+      const harness = createEvalHarness();
+      const pages = harness.benchmarkPages();
+      expect(pages.length).toBeGreaterThanOrEqual(5);
+    });
+
+    it("each benchmark has required fields", () => {
+      const harness = createEvalHarness();
+      for (const page of harness.benchmarkPages()) {
+        expect(page.id).toBeTruthy();
+        expect(page.pageTitle).toBeTruthy();
+        expect(page.expectedEvents.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("computeScores", () => {
+    it("computes overall precision", () => {
+      const harness = createEvalHarness();
+      const test: EvalTestCase = {
+        id: "t",
+        description: "t",
+        pageTitle: "T",
+        pageId: 1,
+        revisionRange: { from: 0, to: 0 },
+        expectedEvents: [{ eventType: "revert_detected", section: "body" }],
+        tolerance: { minPrecision: 0.5 },
+      };
+
+      const r1 = harness.evaluate(test, [makeEvent("revert_detected")]);
+      const r2 = harness.evaluate(test, []);
+      const summary = harness.computeScores([r1, r2]);
+
+      expect(summary.overallPrecision).toBe(0.5);
+      expect(summary.testsPassed).toBe(1);
+      expect(summary.testsFailed).toBe(1);
+      expect(summary.totalTests).toBe(2);
+    });
+
+    it("returns zero for empty results", () => {
+      const harness = createEvalHarness();
+      const summary = harness.computeScores([]);
+      expect(summary.overallPrecision).toBe(0);
+      expect(summary.totalTests).toBe(0);
+    });
+  });
+});

package/src/__tests__/l2-benchmark.test.ts

@@ -0,0 +1,87 @@
+import type { EvidenceEvent } from "@var-ia/evidence-graph";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@var-ia/interpreter", () => ({
+  createAdapter: vi.fn(),
+}));
+
+import { createAdapter } from "@var-ia/interpreter";
+import { buildL2Dataset, runL2Benchmark } from "../l2-benchmark.js";
+
+describe("L2 benchmark", () => {
+  it("buildL2Dataset returns 13 test cases", () => {
+    const dataset = buildL2Dataset();
+    expect(dataset.length).toBe(13);
+    for (const tc of dataset) {
+      expect(tc.id).toBeTruthy();
+      expect(tc.events.length).toBeGreaterThan(0);
+      expect(tc.expected.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("runL2Benchmark scores perfect accuracy for ideal adapter", async () => {
+    const dataset = buildL2Dataset();
+    let callIndex = 0;
+    const mockAdapter = {
+      interpret: vi.fn().mockImplementation(async (events) => {
+        const tc = dataset[callIndex];
+        callIndex++;
+        return (events as EvidenceEvent[]).map((e: EvidenceEvent, i: number) => {
+          const exp = tc.expected[i];
+          return {
+            ...e,
+            modelInterpretation: {
+              semanticChange: exp?.semanticChange ?? "unknown",
+              confidence: 0.95,
+              policyDimension: exp?.policyDimension ?? null,
+              discussionType: exp?.discussionType ?? null,
+            },
+          };
+        });
+      }),
+    };
+    vi.mocked(createAdapter).mockReturnValue(mockAdapter);
+
+    const configs = [{ provider: "openai" as const, model: "gpt-4o", apiKey: "test" }];
+    const result = await runL2Benchmark(configs);
+
+    expect(result.providers).toHaveLength(1);
+    expect(result.providers[0].overallAccuracy).toBe(100);
+    expect(result.testCases).toBe(13);
+  });
+
+  it("runL2Benchmark scores zero for adversarial adapter", async () => {
+    const mockAdapter = {
+      interpret: vi.fn().mockImplementation(async (events) => {
+        return (events as EvidenceEvent[]).map((e: EvidenceEvent) => ({
+          ...e,
+          modelInterpretation: {
+            semanticChange: "wrong answer",
+            confidence: 0.1,
+            policyDimension: "civility",
+            discussionType: "other",
+          },
+        }));
+      }),
+    };
+    vi.mocked(createAdapter).mockReturnValue(mockAdapter);
+
+    const configs = [{ provider: "openai" as const, model: "gpt-4o", apiKey: "test" }];
+    const result = await runL2Benchmark(configs);
+
+    expect(result.providers).toHaveLength(1);
+    expect(result.providers[0].overallAccuracy).toBeLessThan(100);
+  });
+
+  it("handles provider with no API key gracefully", async () => {
+    vi.mocked(createAdapter).mockImplementation(() => {
+      throw new Error("No API key configured");
+    });
+
+    const configs = [{ provider: "openai", apiKey: "" } as { provider: "openai"; apiKey: string }];
+    const result = await runL2Benchmark(configs);
+
+    expect(result.providers).toHaveLength(1);
+    expect(result.providers[0].totalEvents).toBe(0);
+  });
+});

package/src/calibration.ts

@@ -0,0 +1,57 @@
+import type { CalibrationData, InterpretedEvent } from "@var-ia/interpreter";
+
+export interface ExpectedInterpretation {
+  semanticChange: string;
+}
+
+export function computeCalibration(
+  interpretations: InterpretedEvent[],
+  expected: ExpectedInterpretation[],
+  modelId = "unknown",
+): CalibrationData {
+  const BIN_COUNT = 10;
+  const bins = Array.from({ length: BIN_COUNT }, (_, i) => ({
+    lowerBound: i / BIN_COUNT,
+    upperBound: i === BIN_COUNT - 1 ? 1.0 : (i + 1) / BIN_COUNT,
+    count: 0,
+    correctCount: 0,
+    empiricalAccuracy: 0,
+  }));
+
+  const sampleCount = Math.min(interpretations.length, expected.length);
+
+  for (let i = 0; i < sampleCount; i++) {
+    const interp = interpretations[i].modelInterpretation;
+    const expectedInterp = expected[i];
+
+    const binIndex = Math.min(Math.floor(interp.confidence * BIN_COUNT), BIN_COUNT - 1);
+    const bin = bins[binIndex];
+    bin.count++;
+
+    if (expectedInterp.semanticChange === "any" || interp.semanticChange === expectedInterp.semanticChange) {
+      bin.correctCount++;
+    }
+  }
+
+  for (const bin of bins) {
+    bin.empiricalAccuracy = bin.count > 0 ? bin.correctCount / bin.count : 0;
+  }
+
+  const totalSamples = sampleCount;
+  const correctTotal = bins.reduce((s, b) => s + b.correctCount, 0);
+  const overallAccuracy = totalSamples > 0 ? correctTotal / totalSamples : 0;
+
+  const ece = bins.reduce((s, b) => {
+    if (b.count === 0) return s;
+    const mid = (b.lowerBound + b.upperBound) / 2;
+    return s + (b.count / totalSamples) * Math.abs(mid - b.empiricalAccuracy);
+  }, 0);
+
+  return {
+    modelId,
+    bins,
+    totalSamples,
+    overallAccuracy,
+    ece,
+  };
+}

package/src/ground-truth.ts

@@ -0,0 +1,70 @@
+import type { OutcomeLabel } from "./index.js";
+
+export const GROUND_TRUTH_LABELS: OutcomeLabel[] = [
+  {
+    id: "covid-vaccine-mandate-rfc",
+    source: "rfc_closure",
+    pageTitle: "COVID-19 vaccine mandates in the United States",
+    description: "RFC closed with consensus to keep the article, rejecting a merge proposal",
+    observedAt: "2022-03-15T00:00:00Z",
+    resolution: "keep",
+    referenceUrl:
+      "https://en.wikipedia.org/wiki/Talk:COVID-19_vaccine_mandates_in_the_United_States/Archive_1#RFC_on_merger",
+    expectedEventTypes: ["sentence_first_seen", "revert_detected"],
+    expectedSection: "body",
+  },
+  {
+    id: "darth-vader-lightsaber-merge",
+    source: "talk_page_consensus",
+    pageTitle: "Darth Vader",
+    description:
+      "Discussion about merging Lightsaber combat sections into main article reached consensus for reorganization",
+    observedAt: "2021-11-20T00:00:00Z",
+    resolution: "merge",
+    referenceUrl: "https://starwars.fandom.com/wiki/Talk:Darth_Vader?oldid=12345",
+    expectedEventTypes: ["section_reorganized", "sentence_removed"],
+    expectedSection: "(lead)",
+  },
+  {
+    id: "einstein-nobel-protection",
+    source: "page_protection",
+    pageTitle: "Albert Einstein",
+    description: "Article was semi-protected after edit warring over Nobel Prize description",
+    observedAt: "2020-06-10T00:00:00Z",
+    resolution: "other",
+    referenceUrl: "https://en.wikipedia.org/w/index.php?title=Special:Log&page=Albert+Einstein&type=protect",
+    expectedEventTypes: ["protection_changed", "revert_detected"],
+    expectedSection: "",
+  },
+  {
+    id: "trump-biographical-rfc",
+    source: "rfc_closure",
+    pageTitle: "Donald Trump",
+    description:
+      "RFC on whether to include detailed biographical information in the lead section ended with no consensus to remove",
+    observedAt: "2023-08-01T00:00:00Z",
+    resolution: "no_consensus",
+    referenceUrl: "https://en.wikipedia.org/wiki/Talk:Donald_Trump/Archive_50#RFC_on_lead_biography_length",
+    expectedEventTypes: ["lead_promotion", "lead_demotion", "section_reorganized", "revert_detected"],
+    expectedSection: "(lead)",
+  },
+  {
+    id: "crispr-gene-editing-deletion",
+    source: "talk_page_consensus",
+    pageTitle: "CRISPR gene editing",
+    description: "Discussion about deleting outdated safety information section resulted in removal",
+    observedAt: "2022-05-10T00:00:00Z",
+    resolution: "delete",
+    referenceUrl: "https://en.wikipedia.org/wiki/Talk:CRISPR_gene_editing/Archive_2#Safety_section",
+    expectedEventTypes: ["section_reorganized", "sentence_removed"],
+    expectedSection: "",
+  },
+];
+
+export function getGroundTruthForPage(pageTitle: string): OutcomeLabel[] {
+  return GROUND_TRUTH_LABELS.filter((label) => label.pageTitle.toLowerCase() === pageTitle.toLowerCase());
+}
+
+export function getGroundTruthById(id: string): OutcomeLabel | undefined {
+  return GROUND_TRUTH_LABELS.find((label) => label.id === id);
+}