goldenmatch 0.1.0

package/tests/unit/lineage.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildLineage,
+  lineageToJson,
+  lineageFromJson,
+} from "../../src/core/lineage.js";
+import { runDedupePipeline } from "../../src/core/pipeline.js";
+import {
+  makeConfig,
+  makeMatchkeyConfig,
+  makeMatchkeyField,
+} from "../../src/core/types.js";
+import type { Row } from "../../src/core/types.js";
+
+function buildTinyDedupeResult() {
+  const rows: Row[] = [
+    { email: "a@x.com", name: "Alice Brown" },
+    { email: "a@x.com", name: "Alice B." },
+    { email: "b@x.com", name: "Bob Smith" },
+  ];
+  const mk = makeMatchkeyConfig({
+    name: "email_exact",
+    type: "exact",
+    fields: [
+      makeMatchkeyField({
+        field: "email",
+        transforms: ["lowercase"],
+        scorer: "exact",
+      }),
+    ],
+  });
+  const config = makeConfig({ matchkeys: [mk] });
+  return runDedupePipeline(rows, config);
+}
+
+describe("buildLineage", () => {
+  it("produces one edge per cluster in the DedupeResult", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result);
+    // There is at least one multi-member cluster -> at least one edge.
+    expect(bundle.edges.length).toBeGreaterThan(0);
+    expect(bundle.recordCount).toBe(bundle.edges.length);
+  });
+
+  it("edges carry cluster_id, source_row_ids, golden_row_id, and field provenance", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result);
+    const edge = bundle.edges[0]!;
+    expect(typeof edge.clusterId).toBe("number");
+    expect(Array.isArray(edge.sourceRowIds)).toBe(true);
+    expect(edge.sourceRowIds.length).toBeGreaterThanOrEqual(2);
+    expect(typeof edge.goldenRowId).toBe("number");
+    // Field provenance should include non-internal fields like email and name.
+    const keys = Object.keys(edge.fieldProvenance);
+    expect(keys.length).toBeGreaterThan(0);
+    for (const k of keys) {
+      const entry = edge.fieldProvenance[k]!;
+      expect(typeof entry.sourceRowId).toBe("number");
+      expect(typeof entry.strategy).toBe("string");
+      expect(typeof entry.confidence).toBe("number");
+    }
+  });
+
+  it("does not emit provenance entries for internal __-prefixed keys", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result);
+    for (const edge of bundle.edges) {
+      for (const k of Object.keys(edge.fieldProvenance)) {
+        expect(k.startsWith("__")).toBe(false);
+      }
+    }
+  });
+
+  it("defaultStrategy override propagates into field provenance", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result, { defaultStrategy: "first_non_null" });
+    const edge = bundle.edges[0];
+    if (edge) {
+      const anyEntry = Object.values(edge.fieldProvenance)[0];
+      if (anyEntry) expect(anyEntry.strategy).toBe("first_non_null");
+    }
+  });
+
+  it("does not render naturalLanguage by default", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result);
+    for (const edge of bundle.edges) {
+      expect(edge.naturalLanguage).toBeUndefined();
+    }
+  });
+
+  it("renders natural language when naturalLanguage: true", () => {
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result, { naturalLanguage: true });
+    expect(bundle.edges.length).toBeGreaterThan(0);
+    const edge = bundle.edges[0]!;
+    expect(edge.naturalLanguage).toBeDefined();
+    expect(edge.naturalLanguage).toMatch(/Cluster \d+/);
+    expect(edge.naturalLanguage).toMatch(/merged \d+ source records/);
+    expect(edge.naturalLanguage).toMatch(/golden row -?\d+/);
+    // Strongest contribution should mention a real field name — our fixture
+    // has `email` and `name` columns, and internal __ keys are filtered out.
+    expect(edge.naturalLanguage).toMatch(/Strongest contribution: (email|name)/);
+  });
+
+  it("naturalLanguage reports zero-field edges gracefully", () => {
+    // Force an edge through buildLineage where no non-internal fields exist
+    // on the golden record would be contrived; instead validate the template
+    // shape for the normal path, and ensure the helper doesn't crash when
+    // invoked on an edge with an empty provenance map (regression guard).
+    const result = buildTinyDedupeResult();
+    const bundle = buildLineage(result, { naturalLanguage: true });
+    for (const edge of bundle.edges) {
+      expect(typeof edge.naturalLanguage).toBe("string");
+      expect((edge.naturalLanguage as string).length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("lineageToJson / lineageFromJson", () => {
+  it("round-trips a lineage bundle", () => {
+    const result = buildTinyDedupeResult();
+    const original = buildLineage(result);
+    const json = lineageToJson(original);
+    const parsed = lineageFromJson(json);
+    expect(parsed.edges.length).toBe(original.edges.length);
+    expect(parsed.recordCount).toBe(original.recordCount);
+    expect(parsed.timestamp).toBe(original.timestamp);
+  });
+
+  it("lineageFromJson throws on malformed input", () => {
+    expect(() => lineageFromJson("{}")).toThrow(/Invalid lineage bundle/);
+    expect(() => lineageFromJson("null")).toThrow(/Invalid lineage bundle/);
+  });
+});

package/tests/unit/match-one.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { matchOne, findExactMatchesOne } from "../../src/core/match-one.js";
+import { makeMatchkeyConfig, makeMatchkeyField } from "../../src/core/types.js";
+import type { Row } from "../../src/core/types.js";
+
+function r(rowId: number, name: string, email?: string): Row {
+  return { __row_id__: rowId, name, ...(email !== undefined ? { email } : {}) };
+}
+
+describe("matchOne", () => {
+  it("returns matches sorted by descending score, above threshold", () => {
+    const record: Row = { name: "John Smith" };
+    const rows: Row[] = [
+      r(0, "John Smith"),
+      r(1, "Jon Smith"),
+      r(2, "Zxqwer Zxqwer"),
+    ];
+    const mk = makeMatchkeyConfig({
+      name: "name",
+      type: "weighted",
+      threshold: 0.7,
+      fields: [
+        makeMatchkeyField({
+          field: "name",
+          scorer: "jaro_winkler",
+          transforms: ["lowercase"],
+        }),
+      ],
+    });
+    const hits = matchOne(record, rows, mk);
+    expect(hits.length).toBeGreaterThanOrEqual(2);
+    // Sorted: first hit is the exact match on row 0 (score 1.0).
+    expect(hits[0]!.rowId).toBe(0);
+    expect(hits[0]!.score).toBeCloseTo(1.0, 5);
+    // All hits respect threshold.
+    for (const h of hits) expect(h.score).toBeGreaterThanOrEqual(0.7);
+    // Very different row not included.
+    expect(hits.some((h) => h.rowId === 2)).toBe(false);
+  });
+
+  it("returns empty array on empty dataset", () => {
+    const mk = makeMatchkeyConfig({
+      name: "n",
+      type: "weighted",
+      fields: [makeMatchkeyField({ field: "name", scorer: "jaro_winkler" })],
+    });
+    const hits = matchOne({ name: "Alice" }, [], mk);
+    expect(hits).toEqual([]);
+  });
+
+  it("returns empty when nothing is above threshold", () => {
+    const record: Row = { name: "Alice Brown" };
+    const rows: Row[] = [r(0, "Zoltan Xiong"), r(1, "Yuri Nakamura")];
+    const mk = makeMatchkeyConfig({
+      name: "n",
+      type: "weighted",
+      threshold: 0.95,
+      fields: [makeMatchkeyField({ field: "name", scorer: "jaro_winkler" })],
+    });
+    const hits = matchOne(record, rows, mk);
+    expect(hits).toEqual([]);
+  });
+
+  it("threshold defaults to 0 when unset (returns all rows)", () => {
+    const record: Row = { name: "Alice" };
+    const rows: Row[] = [r(0, "Alice"), r(1, "Zoltan")];
+    // Construct without a threshold so matchOne's default-of-0 kicks in.
+    const mkNoThreshold = {
+      name: "n",
+      type: "weighted",
+      fields: [makeMatchkeyField({ field: "name", scorer: "jaro_winkler" })],
+    } as unknown as Parameters<typeof matchOne>[2];
+    const hits = matchOne(record, rows, mkNoThreshold);
+    expect(hits.length).toBe(2);
+  });
+});
+
+describe("findExactMatchesOne", () => {
+  it("finds exact composite-key matches only, with score 1.0", () => {
+    const record: Row = { email: "alice@example.com" };
+    const rows: Row[] = [
+      { __row_id__: 0, email: "alice@example.com" },
+      { __row_id__: 1, email: "Alice@Example.com" }, // matches after lowercase
+      { __row_id__: 2, email: "bob@example.com" },
+    ];
+    const mk = makeMatchkeyConfig({
+      name: "email_exact",
+      type: "exact",
+      fields: [
+        makeMatchkeyField({
+          field: "email",
+          transforms: ["lowercase"],
+          scorer: "exact",
+        }),
+      ],
+    });
+    const hits = findExactMatchesOne(record, rows, mk);
+    const ids = hits.map((h) => h.rowId).sort();
+    expect(ids).toEqual([0, 1]);
+    for (const h of hits) expect(h.score).toBe(1.0);
+  });
+
+  it("returns empty array when probe has null transform for any field", () => {
+    const record: Row = { email: null };
+    const rows: Row[] = [{ __row_id__: 0, email: "alice@example.com" }];
+    const mk = makeMatchkeyConfig({
+      name: "email_exact",
+      type: "exact",
+      fields: [makeMatchkeyField({ field: "email", transforms: [], scorer: "exact" })],
+    });
+    const hits = findExactMatchesOne(record, rows, mk);
+    expect(hits).toEqual([]);
+  });
+
+  it("skips rows where any field transforms to null", () => {
+    const record: Row = { email: "alice@example.com" };
+    const rows: Row[] = [
+      { __row_id__: 0, email: null },
+      { __row_id__: 1, email: "alice@example.com" },
+    ];
+    const mk = makeMatchkeyConfig({
+      name: "email_exact",
+      type: "exact",
+      fields: [makeMatchkeyField({ field: "email", scorer: "exact" })],
+    });
+    const hits = findExactMatchesOne(record, rows, mk);
+    expect(hits.map((h) => h.rowId)).toEqual([1]);
+  });
+});

package/tests/unit/matchkey.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import {
+  computeMatchkeyValue,
+  computeMatchkeys,
+  addRowIds,
+  addSourceColumn,
+} from "../../src/core/index.js";
+import type { MatchkeyConfig, Row } from "../../src/core/index.js";
+
+describe("computeMatchkeyValue", () => {
+  it("single field", () => {
+    const row: Row = { email: "john@example.com" };
+    const mk: MatchkeyConfig = {
+      name: "email",
+      type: "exact",
+      fields: [{ field: "email", transforms: ["lowercase"], scorer: "exact", weight: 1.0 }],
+    };
+    expect(computeMatchkeyValue(row, mk)).toBe("john@example.com");
+  });
+
+  it("multiple fields joined with ||", () => {
+    const row: Row = { first: "John", last: "Smith" };
+    const mk: MatchkeyConfig = {
+      name: "name",
+      type: "exact",
+      fields: [
+        { field: "first", transforms: [], scorer: "exact", weight: 1.0 },
+        { field: "last", transforms: [], scorer: "exact", weight: 1.0 },
+      ],
+    };
+    expect(computeMatchkeyValue(row, mk)).toBe("John||Smith");
+  });
+
+  it("null field returns null matchkey", () => {
+    const row: Row = { email: null };
+    const mk: MatchkeyConfig = {
+      name: "email",
+      type: "exact",
+      fields: [{ field: "email", transforms: [], scorer: "exact", weight: 1.0 }],
+    };
+    expect(computeMatchkeyValue(row, mk)).toBe(null);
+  });
+
+  it("applies transform chain", () => {
+    const row: Row = { email: "  JOHN@X.COM  " };
+    const mk: MatchkeyConfig = {
+      name: "email",
+      type: "exact",
+      fields: [
+        { field: "email", transforms: ["lowercase", "strip"], scorer: "exact", weight: 1.0 },
+      ],
+    };
+    expect(computeMatchkeyValue(row, mk)).toBe("john@x.com");
+  });
+});
+
+describe("computeMatchkeys", () => {
+  it("adds __mk_{name}__ columns", () => {
+    const rows: Row[] = [{ email: "a@x.com" }, { email: "b@x.com" }];
+    const mks: MatchkeyConfig[] = [
+      {
+        name: "email_mk",
+        type: "exact",
+        fields: [{ field: "email", transforms: [], scorer: "exact", weight: 1.0 }],
+      },
+    ];
+    const out = computeMatchkeys(rows, mks);
+    expect(out[0]!.__mk_email_mk__).toBe("a@x.com");
+    expect(out[1]!.__mk_email_mk__).toBe("b@x.com");
+  });
+});
+
+describe("addRowIds", () => {
+  it("adds sequential __row_id__ starting at 0", () => {
+    const rows: Row[] = [{ a: 1 }, { a: 2 }];
+    const out = addRowIds(rows);
+    expect(out[0]!.__row_id__).toBe(0);
+    expect(out[1]!.__row_id__).toBe(1);
+  });
+
+  it("supports offset", () => {
+    const rows: Row[] = [{ a: 1 }, { a: 2 }];
+    const out = addRowIds(rows, 10);
+    expect(out[0]!.__row_id__).toBe(10);
+    expect(out[1]!.__row_id__).toBe(11);
+  });
+});
+
+describe("addSourceColumn", () => {
+  it("adds __source__ to every row", () => {
+    const rows: Row[] = [{ a: 1 }, { a: 2 }];
+    const out = addSourceColumn(rows, "crm");
+    for (const r of out) {
+      expect(r.__source__).toBe("crm");
+    }
+  });
+});

package/tests/unit/mcp-server.test.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect } from "vitest";
+import { TOOLS, handleTool } from "../../src/node/mcp/server.js";
+
+describe("MCP server — TOOLS metadata", () => {
+  it("exports a non-empty array of tool definitions", () => {
+    expect(Array.isArray(TOOLS)).toBe(true);
+    expect(TOOLS.length).toBeGreaterThan(0);
+  });
+
+  it("each tool has name, description, inputSchema", () => {
+    for (const tool of TOOLS) {
+      expect(typeof tool.name).toBe("string");
+      expect(tool.name.length).toBeGreaterThan(0);
+      expect(typeof tool.description).toBe("string");
+      expect(tool.description.length).toBeGreaterThan(0);
+      expect(tool.inputSchema).toBeTypeOf("object");
+      expect(tool.inputSchema).not.toBeNull();
+    }
+  });
+
+  it("every tool name is unique", () => {
+    const names = TOOLS.map((t) => t.name);
+    const unique = new Set(names);
+    expect(unique.size).toBe(names.length);
+  });
+
+  it("includes core tools (dedupe, score_strings, profile, etc.)", () => {
+    const names = new Set(TOOLS.map((t) => t.name));
+    for (const expected of [
+      "dedupe",
+      "match",
+      "score_strings",
+      "explain_pair",
+      "profile",
+      "list_scorers",
+      "list_transforms",
+      "list_strategies",
+      "server_info",
+    ]) {
+      expect(names.has(expected)).toBe(true);
+    }
+  });
+});
+
+describe("MCP server — handleTool dispatcher", () => {
+  it("score_strings with jaro_winkler scores John~Jon near 0.94", async () => {
+    const result = (await handleTool("score_strings", {
+      a: "John",
+      b: "Jon",
+      scorer: "jaro_winkler",
+    })) as { score: number; scorer: string };
+    expect(result).toMatchObject({ scorer: "jaro_winkler" });
+    expect(typeof result.score).toBe("number");
+    expect(result.score).toBeGreaterThan(0.9);
+    expect(result.score).toBeLessThanOrEqual(1.0);
+  });
+
+  it("score_strings with missing scorer defaults to jaro_winkler", async () => {
+    const result = (await handleTool("score_strings", {
+      a: "x",
+      b: "y",
+    })) as { score: number; scorer: string };
+    expect(result.scorer).toBe("jaro_winkler");
+    expect(typeof result.score).toBe("number");
+  });
+
+  it("explain_pair returns an NL explanation", async () => {
+    const result = (await handleTool("explain_pair", {
+      row_a: { name: "John Smith", email: "j@x.com" },
+      row_b: { name: "Jon Smith", email: "j@x.com" },
+      fields: [
+        { field: "name", scorer: "jaro_winkler", weight: 1.0 },
+        { field: "email", scorer: "exact", weight: 1.0 },
+      ],
+    })) as {
+      score: number;
+      confidence: number;
+      explanation: string;
+      field_scores: unknown;
+    };
+    expect(typeof result.score).toBe("number");
+    // confidence may be numeric or categorical ("high"/"medium"/"low")
+    expect(["number", "string"]).toContain(typeof result.confidence);
+    expect(typeof result.explanation).toBe("string");
+    expect(result.explanation.length).toBeGreaterThan(0);
+    expect(result.field_scores).toBeDefined();
+  });
+
+  it("profile returns column profiles via { rows } -> requires path; use find_fuzzy_matches path flow via file is out of scope here", async () => {
+    // Note: profile tool takes a `path`. Rows-based profile is only via /profile REST.
+    // Verify that profile without a valid path returns an error object (not throws).
+    const result = (await handleTool("profile", { path: "nonexistent_file_xyz.csv" })) as {
+      error?: string;
+    };
+    expect(typeof result).toBe("object");
+    expect(result).not.toBeNull();
+    // Either error shape or some profile shape; not a crash.
+    expect(result.error ?? "").not.toBe(undefined);
+  });
+
+  it("list_scorers returns an array of scorer names", async () => {
+    const result = (await handleTool("list_scorers", {})) as { scorers: string[] };
+    expect(Array.isArray(result.scorers)).toBe(true);
+    expect(result.scorers.length).toBeGreaterThan(0);
+    expect(result.scorers).toContain("jaro_winkler");
+  });
+
+  it("list_transforms returns array", async () => {
+    const result = (await handleTool("list_transforms", {})) as { transforms: string[] };
+    expect(Array.isArray(result.transforms)).toBe(true);
+    expect(result.transforms.length).toBeGreaterThan(0);
+  });
+
+  it("list_strategies returns array", async () => {
+    const result = (await handleTool("list_strategies", {})) as { strategies: string[] };
+    expect(Array.isArray(result.strategies)).toBe(true);
+    expect(result.strategies.length).toBeGreaterThan(0);
+  });
+
+  it("server_info returns metadata with tool_count", async () => {
+    const result = (await handleTool("server_info", {})) as {
+      name: string;
+      tool_count: number;
+    };
+    expect(result.name).toBe("goldenmatch-js");
+    expect(result.tool_count).toBe(TOOLS.length);
+  });
+
+  it("unknown tool returns { error } rather than throwing", async () => {
+    const result = (await handleTool("nonexistent_tool_xyz", {})) as { error: string };
+    expect(typeof result).toBe("object");
+    expect(typeof result.error).toBe("string");
+    expect(result.error).toMatch(/unknown/i);
+  });
+
+  it("path traversal via '..' is rejected (error, not crash)", async () => {
+    const result = (await handleTool("read_file", {
+      file_path: "../../../etc/passwd",
+      path: "../../../etc/passwd",
+    })) as { error?: string };
+    expect(typeof result).toBe("object");
+    expect(typeof result.error).toBe("string");
+    expect(result.error).toMatch(/outside|not a|no such|enoent/i);
+  });
+
+  it("absolute path outside cwd is rejected", async () => {
+    // Pick a path guaranteed to be outside cwd on both Windows and POSIX.
+    const outsidePath =
+      process.platform === "win32" ? "C:\\Windows\\System32\\drivers\\etc\\hosts" : "/etc/passwd";
+    const result = (await handleTool("read_file", { path: outsidePath })) as {
+      error?: string;
+    };
+    expect(typeof result).toBe("object");
+    expect(typeof result.error).toBe("string");
+    expect(result.error).toMatch(/outside|enoent|no such|not found/i);
+  });
+
+  it("write_csv with non-array rows returns error (not crash)", async () => {
+    const result = (await handleTool("write_csv", {
+      path: "some_output.csv",
+      rows: "not-an-array",
+    })) as { error?: string };
+    expect(typeof result).toBe("object");
+    expect(typeof result.error).toBe("string");
+  });
+
+  it("score_pair with missing rows returns error", async () => {
+    const result = (await handleTool("score_pair", {
+      fields: [{ field: "name" }],
+    })) as { error?: string };
+    expect(typeof result.error).toBe("string");
+  });
+
+  it("score_pair with valid inputs returns a score", async () => {
+    const result = (await handleTool("score_pair", {
+      row_a: { name: "John" },
+      row_b: { name: "Jon" },
+      fields: [{ field: "name", scorer: "jaro_winkler", weight: 1.0 }],
+    })) as { score: number; field_count: number };
+    expect(typeof result.score).toBe("number");
+    expect(result.field_count).toBe(1);
+  });
+});

package/tests/unit/memory.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { MemoryStore, MemoryLearner } from "../../src/core/index.js";
+import type { Correction, MatchkeyConfig } from "../../src/core/index.js";
+
+function makeCorrection(
+  rowIdA: number,
+  rowIdB: number,
+  verdict: "match" | "no_match",
+  score: number,
+): Correction {
+  return {
+    rowIdA,
+    rowIdB,
+    verdict,
+    feature: "overall",
+    score,
+    timestamp: Date.now(),
+    trust: 0.9,
+    source: "test",
+  };
+}
+
+describe("MemoryStore", () => {
+  it("add + list + count", () => {
+    const store = new MemoryStore();
+    expect(store.count()).toBe(0);
+    store.add(makeCorrection(1, 2, "match", 0.9));
+    store.add(makeCorrection(3, 4, "no_match", 0.3));
+    expect(store.count()).toBe(2);
+    expect(store.list().length).toBe(2);
+  });
+
+  it("listMatches and listNonMatches", () => {
+    const store = new MemoryStore();
+    store.add(makeCorrection(1, 2, "match", 0.9));
+    store.add(makeCorrection(3, 4, "no_match", 0.3));
+    expect(store.listMatches().length).toBe(1);
+    expect(store.listNonMatches().length).toBe(1);
+  });
+
+  it("clear resets the store", () => {
+    const store = new MemoryStore();
+    store.add(makeCorrection(1, 2, "match", 0.9));
+    store.clear();
+    expect(store.count()).toBe(0);
+  });
+
+  it("upsert with higher trust replaces existing", () => {
+    const store = new MemoryStore();
+    const c1: Correction = {
+      rowIdA: 1,
+      rowIdB: 2,
+      verdict: "match",
+      feature: "name",
+      score: 0.9,
+      timestamp: 1000,
+      trust: 0.5,
+      source: "a",
+    };
+    const c2: Correction = { ...c1, trust: 0.9, source: "b", timestamp: 2000 };
+    store.upsert(c1);
+    store.upsert(c2);
+    expect(store.count()).toBe(1);
+    expect(store.list()[0]!.source).toBe("b");
+  });
+});
+
+describe("MemoryLearner", () => {
+  it("tunes threshold when given >= 10 corrections with mixed verdicts", () => {
+    const baseline: MatchkeyConfig = {
+      name: "m",
+      type: "weighted",
+      threshold: 0.85,
+      fields: [{ field: "name", transforms: [], scorer: "jaro_winkler", weight: 1.0 }],
+    };
+    const corrections: Correction[] = [];
+    // 10 positives with score > 0.8, 10 negatives with score < 0.7
+    for (let i = 0; i < 10; i++) {
+      corrections.push(makeCorrection(i, i + 100, "match", 0.85));
+      corrections.push(makeCorrection(i + 200, i + 300, "no_match", 0.4));
+    }
+    const learner = new MemoryLearner();
+    const params = learner.learn(corrections, baseline);
+    expect(params.correctionCount).toBe(20);
+    expect(params.threshold).not.toBeUndefined();
+    // Optimal threshold should be somewhere between 0.4 and 0.85
+    expect(params.threshold!).toBeGreaterThanOrEqual(0.5);
+    expect(params.threshold!).toBeLessThanOrEqual(0.95);
+  });
+
+  it("returns no threshold when fewer than 10 corrections", () => {
+    const baseline: MatchkeyConfig = {
+      name: "m",
+      type: "weighted",
+      threshold: 0.85,
+      fields: [{ field: "name", transforms: [], scorer: "jaro_winkler", weight: 1.0 }],
+    };
+    const corrections = [makeCorrection(1, 2, "match", 0.9)];
+    const learner = new MemoryLearner();
+    const params = learner.learn(corrections, baseline);
+    expect(params.threshold).toBeUndefined();
+  });
+
+  it("returns no threshold when all verdicts are the same", () => {
+    const baseline: MatchkeyConfig = {
+      name: "m",
+      type: "weighted",
+      threshold: 0.85,
+      fields: [{ field: "name", transforms: [], scorer: "jaro_winkler", weight: 1.0 }],
+    };
+    const corrections: Correction[] = [];
+    for (let i = 0; i < 15; i++) {
+      corrections.push(makeCorrection(i, i + 100, "match", 0.9));
+    }
+    const learner = new MemoryLearner();
+    const params = learner.learn(corrections, baseline);
+    expect(params.threshold).toBeUndefined();
+  });
+});