goldenmatch 0.1.0

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

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import type { Server } from "node:http";
+import { startApiServer } from "../../src/node/api/server.js";
+
+let server: Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = startApiServer({ port: 0, host: "127.0.0.1" });
+  // Wait for listen to complete.
+  await new Promise<void>((resolveFn) => {
+    if (server.listening) {
+      resolveFn();
+      return;
+    }
+    server.once("listening", () => resolveFn());
+  });
+  const addr = server.address();
+  const port =
+    typeof addr === "object" && addr !== null && "port" in addr ? addr.port : 8000;
+  baseUrl = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  if (server) {
+    await new Promise<void>((resolveFn, rejectFn) => {
+      server.close((err) => (err ? rejectFn(err) : resolveFn()));
+    });
+  }
+});
+
+describe("REST API server", () => {
+  it("GET /health returns 200 with status ok", async () => {
+    const res = await fetch(baseUrl + "/health");
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { status: string };
+    expect(body.status).toBe("ok");
+  });
+
+  it("POST /dedupe returns DedupeResult-like shape", async () => {
+    const res = await fetch(baseUrl + "/dedupe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        rows: [
+          { email: "a@x.com", name: "Alice" },
+          { email: "a@x.com", name: "A." },
+          { email: "b@x.com", name: "Bob" },
+        ],
+        exact: ["email"],
+      }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      stats: { total_records: number; total_clusters: number };
+      golden_records: unknown[];
+      dupes: unknown[];
+      unique: unknown[];
+    };
+    expect(body.stats.total_records).toBe(3);
+    expect(typeof body.stats.total_clusters).toBe("number");
+    expect(Array.isArray(body.golden_records)).toBe(true);
+    expect(Array.isArray(body.dupes)).toBe(true);
+    expect(Array.isArray(body.unique)).toBe(true);
+  });
+
+  it("POST /match returns matched/unmatched", async () => {
+    const res = await fetch(baseUrl + "/match", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        target: [{ email: "a@x.com", name: "Alice" }],
+        reference: [
+          { email: "a@x.com", name: "A." },
+          { email: "z@x.com", name: "Zack" },
+        ],
+        exact: ["email"],
+      }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { matched: unknown[]; unmatched: unknown[] };
+    expect(Array.isArray(body.matched)).toBe(true);
+    expect(Array.isArray(body.unmatched)).toBe(true);
+  });
+
+  it("POST /score returns numeric score", async () => {
+    const res = await fetch(baseUrl + "/score", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ a: "John", b: "Jon", scorer: "jaro_winkler" }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { score: number; scorer: string };
+    expect(body.scorer).toBe("jaro_winkler");
+    expect(typeof body.score).toBe("number");
+    expect(body.score).toBeGreaterThan(0.9);
+  });
+
+  it("POST /explain returns PairExplanation shape", async () => {
+    const res = await fetch(baseUrl + "/explain", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        row_a: { name: "John Smith" },
+        row_b: { name: "Jon Smith" },
+        fields: [{ field: "name", scorer: "jaro_winkler", weight: 1.0 }],
+      }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      score: number;
+      confidence: number;
+      explanation: string;
+      field_scores: unknown;
+    };
+    expect(typeof body.score).toBe("number");
+    // confidence may be numeric or categorical ("high"/"medium"/"low")
+    expect(["number", "string"]).toContain(typeof body.confidence);
+    expect(typeof body.explanation).toBe("string");
+  });
+
+  it("POST /profile returns column profiles", async () => {
+    const res = await fetch(baseUrl + "/profile", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        rows: [
+          { email: "a@x.com", age: 20 },
+          { email: "b@x.com", age: 30 },
+          { email: "c@x.com", age: 40 },
+        ],
+      }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      row_count: number;
+      columns: Array<{ name: string; inferred_type: string }>;
+    };
+    expect(body.row_count).toBe(3);
+    expect(Array.isArray(body.columns)).toBe(true);
+    expect(body.columns.length).toBeGreaterThan(0);
+  });
+
+  it("POST /clusters returns clusters object", async () => {
+    const res = await fetch(baseUrl + "/clusters", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        rows: [
+          { email: "a@x.com", name: "Alice" },
+          { email: "a@x.com", name: "A." },
+          { email: "b@x.com", name: "Bob" },
+        ],
+        exact: ["email"],
+      }),
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      cluster_count: number;
+      clusters: Array<{ cluster_id: number; members: number[] }>;
+    };
+    expect(typeof body.cluster_count).toBe("number");
+    expect(Array.isArray(body.clusters)).toBe(true);
+  });
+
+  it("GET /reviews returns { pending: [] }", async () => {
+    const res = await fetch(baseUrl + "/reviews");
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { pending: unknown[] };
+    expect(Array.isArray(body.pending)).toBe(true);
+  });
+
+  it("invalid JSON body returns 500 with error", async () => {
+    const res = await fetch(baseUrl + "/dedupe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{not valid json",
+    });
+    expect([400, 500]).toContain(res.status);
+    const body = (await res.json()) as { error: string };
+    expect(typeof body.error).toBe("string");
+  });
+
+  it("unknown route returns 404", async () => {
+    const res = await fetch(baseUrl + "/no-such-route");
+    expect(res.status).toBe(404);
+    const body = (await res.json()) as { error: string };
+    expect(typeof body.error).toBe("string");
+  });
+
+  it("POST /reviews/decide with missing id returns error", async () => {
+    const res = await fetch(baseUrl + "/reviews/decide", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    // Missing id -> handler throws -> 500 with error. If id exists but missing -> 404.
+    expect([400, 404, 500]).toContain(res.status);
+    const body = (await res.json()) as { error: string };
+    expect(typeof body.error).toBe("string");
+  });
+
+  it("POST /reviews/decide with unknown id returns 404", async () => {
+    const res = await fetch(baseUrl + "/reviews/decide", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: "never-enqueued", accept: true }),
+    });
+    expect(res.status).toBe(404);
+    const body = (await res.json()) as { error: string };
+    expect(typeof body.error).toBe("string");
+  });
+
+  it("enqueue + decide round-trip works", async () => {
+    const enq = await fetch(baseUrl + "/reviews/enqueue", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id_a: 1,
+        id_b: 2,
+        score: 0.8,
+        row_a: { name: "A" },
+        row_b: { name: "A." },
+      }),
+    });
+    expect(enq.status).toBe(200);
+    const enqBody = (await enq.json()) as { item: { id: string } };
+    expect(typeof enqBody.item.id).toBe("string");
+
+    const dec = await fetch(baseUrl + "/reviews/decide", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: enqBody.item.id, accept: true }),
+    });
+    expect(dec.status).toBe(200);
+    const decBody = (await dec.json()) as { decided: { status: string } };
+    expect(decBody.decided.status).toBe("accepted");
+  });
+});

package/tests/unit/api.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { dedupe, match, scoreStrings, scorePairRecord } from "../../src/core/index.js";
+import type { MatchkeyField, Row } from "../../src/core/index.js";
+
+describe("dedupe() — shorthand API", () => {
+  it("with exact catches identical emails", () => {
+    const rows: Row[] = [
+      { email: "a@x.com", name: "Alice" },
+      { email: "a@x.com", name: "A." },
+      { email: "b@x.com", name: "Bob" },
+    ];
+    const result = dedupe(rows, { exact: ["email"] });
+    expect(result.stats.totalRecords).toBe(3);
+    expect(result.dupes.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("with fuzzy catches similar names", () => {
+    const rows: Row[] = [
+      { name: "John Smith", zip: "111" },
+      { name: "Jon Smith", zip: "111" },
+      { name: "Zeke Xavier", zip: "222" },
+    ];
+    const result = dedupe(rows, {
+      fuzzy: { name: 1.0 },
+      blocking: ["zip"],
+      threshold: 0.7,
+    });
+    expect(result.stats.totalRecords).toBe(3);
+    expect(result.scoredPairs.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe("match() — cross-dataset", () => {
+  it("finds matches across datasets", () => {
+    const target: Row[] = [{ email: "a@x.com" }];
+    const reference: Row[] = [{ email: "a@x.com" }, { email: "b@x.com" }];
+    const result = match(target, reference, { exact: ["email"] });
+    expect(result.matched.length).toBe(1);
+  });
+});
+
+describe("scoreStrings()", () => {
+  it("exact identical", () => {
+    expect(scoreStrings("hello", "hello", "exact")).toBe(1.0);
+  });
+
+  it("jaro_winkler default", () => {
+    const s = scoreStrings("John", "John");
+    expect(s).toBe(1.0);
+  });
+
+  it("returns 0-1 range", () => {
+    const s = scoreStrings("foo", "bar");
+    expect(s).toBeGreaterThanOrEqual(0);
+    expect(s).toBeLessThanOrEqual(1);
+  });
+
+  it("levenshtein", () => {
+    expect(scoreStrings("abc", "abc", "levenshtein")).toBe(1.0);
+  });
+
+  it("token_sort reorders", () => {
+    expect(scoreStrings("a b", "b a", "token_sort")).toBe(1.0);
+  });
+});
+
+describe("scorePairRecord()", () => {
+  it("scores two row objects across fields", () => {
+    const rowA: Row = { name: "John", city: "NYC" };
+    const rowB: Row = { name: "John", city: "NYC" };
+    const fields: MatchkeyField[] = [
+      { field: "name", transforms: [], scorer: "jaro_winkler", weight: 1.0 },
+      { field: "city", transforms: [], scorer: "exact", weight: 1.0 },
+    ];
+    expect(scorePairRecord(rowA, rowB, fields)).toBe(1.0);
+  });
+});

package/tests/unit/autoconfig.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import { autoConfigureRows } from "../../src/core/autoconfig.js";
+import type { Row } from "../../src/core/types.js";
+
+// Small synthetic person dataset.
+function makePeople(n: number): Row[] {
+  const first = ["John", "Jane", "Bob", "Alice", "Carol", "David", "Eve", "Frank"];
+  const last = ["Smith", "Jones", "Brown", "Miller", "Davis", "Wilson", "Moore", "Taylor"];
+  const cities = ["Boston", "Seattle", "Austin", "Denver"];
+  const rows: Row[] = [];
+  for (let i = 0; i < n; i++) {
+    rows.push({
+      __row_id__: i,
+      first_name: first[i % first.length]!,
+      last_name: last[i % last.length]!,
+      email: `user${i}@example.com`,
+      phone: `555-010-${String(1000 + i).padStart(4, "0")}`,
+      zip: String(10000 + (i % 50)),
+      city: cities[i % cities.length]!,
+    });
+  }
+  return rows;
+}
+
+describe("autoConfigureRows", () => {
+  it("picks exact matchkeys on email/phone and produces a weighted matchkey", () => {
+    const rows = makePeople(40);
+    const cfg = autoConfigureRows(rows);
+    const names = (cfg.matchkeys ?? []).map((m) => m.name);
+    // Exact matchkeys for identifier columns.
+    expect(names).toContain("exact_email");
+    // Phone column has phone-shaped values and is near-unique -> exact allowed.
+    expect(names).toContain("exact_phone");
+    // There should be a weighted matchkey for fuzzy fields.
+    expect(names).toContain("weighted_identity");
+  });
+
+  it("zip and geo columns do NOT back exact matchkeys (blocking signal only)", () => {
+    const rows = makePeople(40);
+    const cfg = autoConfigureRows(rows);
+    const names = (cfg.matchkeys ?? []).map((m) => m.name);
+    expect(names).not.toContain("exact_zip");
+    expect(names).not.toContain("exact_city");
+  });
+
+  it("exact matchkey skipped for columns with cardinality_ratio < 0.01", () => {
+    // 200 rows, one constant id-like column with only 1 distinct value.
+    const rows: Row[] = [];
+    for (let i = 0; i < 200; i++) {
+      rows.push({
+        __row_id__: i,
+        email: `user${i}@example.com`,
+        account_id: "ACME-123", // constant -> cardinality ratio 1/200 = 0.005
+      });
+    }
+    const cfg = autoConfigureRows(rows);
+    const names = (cfg.matchkeys ?? []).map((m) => m.name);
+    expect(names).not.toContain("exact_account_id");
+  });
+
+  it("skips blocking on columns with >20% null rate", () => {
+    // zip is mostly null, city has values -> blocking should prefer city
+    const rows: Row[] = [];
+    for (let i = 0; i < 30; i++) {
+      rows.push({
+        __row_id__: i,
+        email: `user${i}@example.com`,
+        first_name: `First${i % 5}`,
+        zip: i % 5 === 0 ? String(10000 + i) : null, // 80% null
+        city: i % 3 === 0 ? "Boston" : i % 3 === 1 ? "Austin" : "Denver",
+      });
+    }
+    const cfg = autoConfigureRows(rows);
+    const keyFields = (cfg.blocking?.keys ?? []).map((k) => k.fields[0]);
+    // zip must not be chosen as a blocking key.
+    expect(keyFields).not.toContain("zip");
+  });
+
+  it("skips blocking on columns with cardinality_ratio >= 0.95 (near-unique)", () => {
+    // email is near-unique; don't block on it.
+    const rows: Row[] = [];
+    for (let i = 0; i < 30; i++) {
+      rows.push({
+        __row_id__: i,
+        email: `user${i}@example.com`, // fully unique
+        last_name: `Smith${i % 3}`, // low-cardinality name-ish column
+      });
+    }
+    const cfg = autoConfigureRows(rows);
+    const keyFields = (cfg.blocking?.keys ?? []).map((k) => k.fields[0]);
+    expect(keyFields).not.toContain("email");
+  });
+
+  it("email column detected as exact identifier candidate when cardinality is high", () => {
+    const rows: Row[] = [];
+    for (let i = 0; i < 20; i++) {
+      rows.push({ __row_id__: i, email: `user${i}@x.com` });
+    }
+    const cfg = autoConfigureRows(rows);
+    const names = (cfg.matchkeys ?? []).map((m) => m.name);
+    expect(names).toContain("exact_email");
+  });
+});

package/tests/unit/autofix.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { autoFixRows } from "../../src/core/autofix.js";
+import type { Row } from "../../src/core/types.js";
+
+describe("autoFixRows", () => {
+  it("trims whitespace from string values", () => {
+    const rows: Row[] = [{ name: "  Alice  ", email: " a@x.com" }];
+    const { rows: out, log } = autoFixRows(rows);
+    expect(out[0]!["name"]).toBe("Alice");
+    expect(out[0]!["email"]).toBe("a@x.com");
+    const trimLog = log.find((l) => l.fixType === "trim_whitespace");
+    expect(trimLog).toBeDefined();
+  });
+
+  it("converts empty strings to null", () => {
+    const rows: Row[] = [{ a: "", b: "   " }];
+    const { rows: out } = autoFixRows(rows);
+    expect(out[0]!["a"]).toBeNull();
+    expect(out[0]!["b"]).toBeNull();
+  });
+
+  it("converts common null tokens to null (case-insensitive)", () => {
+    const rows: Row[] = [
+      { a: "N/A", b: "NULL", c: "Unknown", d: "-", e: "n/a" },
+    ];
+    const { rows: out } = autoFixRows(rows);
+    expect(out[0]!["a"]).toBeNull();
+    expect(out[0]!["b"]).toBeNull();
+    expect(out[0]!["c"]).toBeNull();
+    expect(out[0]!["d"]).toBeNull();
+    expect(out[0]!["e"]).toBeNull();
+  });
+
+  it("passes non-string values through unchanged", () => {
+    const rows: Row[] = [{ n: 42, b: true, x: null }];
+    const { rows: out } = autoFixRows(rows);
+    expect(out[0]!["n"]).toBe(42);
+    expect(out[0]!["b"]).toBe(true);
+    expect(out[0]!["x"]).toBeNull();
+  });
+
+  it("leaves internal __ columns untouched", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, __source__: "  sensitive  ", name: "  X  " },
+    ];
+    const { rows: out } = autoFixRows(rows);
+    expect(out[0]!["__row_id__"]).toBe(0);
+    // Internal columns preserved as-is (not trimmed, not nulled).
+    expect(out[0]!["__source__"]).toBe("  sensitive  ");
+    expect(out[0]!["name"]).toBe("X");
+  });
+
+  it("returns a log that aggregates affected rows per column/fix-type", () => {
+    const rows: Row[] = [
+      { a: "  x  ", b: "N/A" },
+      { a: "  y  ", b: "" },
+      { a: "ok", b: "hello" },
+    ];
+    const { log } = autoFixRows(rows);
+    const trimA = log.find(
+      (l) => l.column === "a" && l.fixType === "trim_whitespace",
+    );
+    const nullB = log.find(
+      (l) => l.column === "b" && l.fixType === "null_empty_or_token",
+    );
+    expect(trimA).toBeDefined();
+    expect(trimA!.affectedRows).toBe(2);
+    expect(nullB).toBeDefined();
+    expect(nullB!.affectedRows).toBe(2);
+  });
+});

package/tests/unit/blocker.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildStaticBlocks,
+  buildMultiPassBlocks,
+  buildAdaptiveBlocks,
+  buildBlocks,
+  makeBlockingConfig,
+} from "../../src/core/index.js";
+import type { Row, BlockingConfig } from "../../src/core/index.js";
+
+describe("buildStaticBlocks", () => {
+  it("3 rows with same zip -> 1 block of 3", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "12345" },
+      { __row_id__: 1, zip: "12345" },
+      { __row_id__: 2, zip: "12345" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0]!.rows.length).toBe(3);
+  });
+
+  it("different zips -> no blocks (singletons skipped)", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "11111" },
+      { __row_id__: 1, zip: "22222" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(0);
+  });
+
+  it("applies transforms to block key (lowercase)", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, city: "NYC" },
+      { __row_id__: 1, city: "nyc" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["city"], transforms: ["lowercase"] }],
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0]!.rows.length).toBe(2);
+  });
+
+  it("missing field produces null block key and row is skipped", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "12345" },
+      { __row_id__: 1, zip: null },
+      { __row_id__: 2, zip: "12345" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0]!.rows.length).toBe(2);
+  });
+
+  it("oversized block with skipOversized=true is dropped", () => {
+    const rows: Row[] = Array.from({ length: 10 }, (_, i) => ({
+      __row_id__: i,
+      zip: "12345",
+    }));
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+      maxBlockSize: 5,
+      skipOversized: true,
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(0);
+  });
+
+  it("oversized block with skipOversized=false is kept", () => {
+    const rows: Row[] = Array.from({ length: 10 }, (_, i) => ({
+      __row_id__: i,
+      zip: "12345",
+    }));
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+      maxBlockSize: 5,
+      skipOversized: false,
+    });
+    const blocks = buildStaticBlocks(rows, config);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0]!.rows.length).toBe(10);
+  });
+});
+
+describe("buildMultiPassBlocks", () => {
+  it("runs multiple passes with different keys", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "111", last: "Smith" },
+      { __row_id__: 1, zip: "111", last: "Jones" },
+      { __row_id__: 2, zip: "222", last: "Smith" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "multi_pass",
+      keys: [{ fields: ["zip"], transforms: [] }],
+      passes: [
+        { fields: ["zip"], transforms: [] },
+        { fields: ["last"], transforms: [] },
+      ],
+    });
+    const blocks = buildMultiPassBlocks(rows, config);
+    // Pass 1: zip 111 has 2 rows -> 1 block
+    // Pass 2: last Smith has 2 rows -> 1 block
+    expect(blocks.length).toBe(2);
+  });
+});
+
+describe("buildAdaptiveBlocks", () => {
+  it("auto-split oversized block", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "111", city: "A" },
+      { __row_id__: 1, zip: "111", city: "A" },
+      { __row_id__: 2, zip: "111", city: "B" },
+      { __row_id__: 3, zip: "111", city: "B" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "adaptive",
+      keys: [{ fields: ["zip"], transforms: [] }],
+      maxBlockSize: 3,
+      skipOversized: false,
+    });
+    const blocks = buildAdaptiveBlocks(rows, config);
+    // Should split by city
+    expect(blocks.length).toBeGreaterThanOrEqual(2);
+  });
+});
+
+describe("buildBlocks dispatch", () => {
+  it("static strategy routes correctly", () => {
+    const rows: Row[] = [
+      { __row_id__: 0, zip: "111" },
+      { __row_id__: 1, zip: "111" },
+    ];
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+    });
+    const blocks = buildBlocks(rows, config);
+    expect(blocks.length).toBe(1);
+  });
+
+  it("fewer than 2 rows returns empty", () => {
+    const config: BlockingConfig = makeBlockingConfig({
+      strategy: "static",
+      keys: [{ fields: ["zip"], transforms: [] }],
+    });
+    expect(buildBlocks([], config)).toEqual([]);
+  });
+});