goldenmatch 0.1.0

package/tests/unit/cross-encoder-model.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  CrossEncoderModel,
+  rerankPair,
+  rerankTopPairs,
+  _resetCrossEncoderModelCache,
+} from "../../src/core/index.js";
+import type { MatchkeyConfig, Row, ScoredPair } from "../../src/core/index.js";
+
+describe("CrossEncoderModel", () => {
+  beforeEach(() => {
+    _resetCrossEncoderModelCache();
+    // Silence the expected "cross-encoder failed" console.warn noise.
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("throws a clear error when @huggingface/transformers is not installed", async () => {
+    const model = new CrossEncoderModel();
+    await expect(model.score("a", "b")).rejects.toThrow(
+      /@huggingface\/transformers/,
+    );
+  });
+
+  it("the same error is raised on subsequent calls (cache does not lock into a rejected promise)", async () => {
+    const model = new CrossEncoderModel();
+    await expect(model.score("a", "b")).rejects.toThrow(
+      /@huggingface\/transformers/,
+    );
+    // Second call should still reject with a fresh load attempt.
+    await expect(model.score("a", "b")).rejects.toThrow(
+      /@huggingface\/transformers/,
+    );
+  });
+});
+
+describe("rerankPair with reranker option", () => {
+  beforeEach(() => {
+    _resetCrossEncoderModelCache();
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("reranker='cross-encoder' falls back to LLM path when package missing", async () => {
+    // No apiKey, no env var, no transformers package -> fallback returns NaN.
+    const env = (globalThis as { process?: { env?: Record<string, string | undefined> } })
+      .process?.env;
+    const savedOpen = env?.OPENAI_API_KEY;
+    const savedAnt = env?.ANTHROPIC_API_KEY;
+    if (env) {
+      delete env.OPENAI_API_KEY;
+      delete env.ANTHROPIC_API_KEY;
+    }
+    try {
+      const score = await rerankPair(
+        { name: "John", email: "john@x.com" },
+        { name: "Jon", email: "jon@x.com" },
+        ["name", "email"],
+        { reranker: "cross-encoder" },
+      );
+      // Fallback path returns NaN without apiKey.
+      expect(Number.isNaN(score)).toBe(true);
+    } finally {
+      if (env) {
+        if (savedOpen !== undefined) env.OPENAI_API_KEY = savedOpen;
+        if (savedAnt !== undefined) env.ANTHROPIC_API_KEY = savedAnt;
+      }
+    }
+  });
+
+  it("reranker='cross-encoder' with apiKey falls back to LLM and produces a number", async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: async () => "",
+      json: async () => ({
+        choices: [{ message: { content: JSON.stringify({ score: 0.77 }) } }],
+        usage: { prompt_tokens: 10, completion_tokens: 4 },
+      }),
+    } as Response);
+
+    const score = await rerankPair(
+      { name: "John" },
+      { name: "Jon" },
+      ["name"],
+      { reranker: "cross-encoder", apiKey: "sk-test", maxRetries: 0 },
+    );
+    expect(typeof score).toBe("number");
+    // Fallback exercised the LLM path -> fetch was called.
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(score).toBeCloseTo(0.77, 6);
+  });
+
+  it("reranker='llm' (default) uses the LLM path", async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: async () => "",
+      json: async () => ({
+        choices: [{ message: { content: JSON.stringify({ score: 0.91 }) } }],
+        usage: { prompt_tokens: 10, completion_tokens: 4 },
+      }),
+    } as Response);
+
+    const score = await rerankPair(
+      { name: "John" },
+      { name: "Jon" },
+      ["name"],
+      { reranker: "llm", apiKey: "sk-test", maxRetries: 0 },
+    );
+    expect(typeof score).toBe("number");
+    expect(score).toBeCloseTo(0.91, 6);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("rerankTopPairs with reranker='cross-encoder' fallback", () => {
+  const mk: MatchkeyConfig = {
+    name: "name_match",
+    type: "weighted",
+    threshold: 0.85,
+    fields: [{ field: "name", transforms: [], scorer: "jaro_winkler", weight: 1 }],
+  };
+
+  const rows: Row[] = [
+    { __row_id__: 0, name: "Alice" },
+    { __row_id__: 1, name: "Alyce" },
+  ];
+
+  beforeEach(() => {
+    _resetCrossEncoderModelCache();
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("falls back to LLM per-pair when cross-encoder load fails", async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: async () => "",
+      json: async () => ({
+        choices: [{ message: { content: JSON.stringify({ score: 1.0 }) } }],
+        usage: { prompt_tokens: 10, completion_tokens: 4 },
+      }),
+    } as Response);
+
+    const pairs: ScoredPair[] = [{ idA: 0, idB: 1, score: 0.9 }];
+    const out = await rerankTopPairs(pairs, rows, mk, {
+      reranker: "cross-encoder",
+      apiKey: "sk-test",
+      maxRetries: 0,
+    });
+    expect(out.length).toBe(1);
+    // (1 - 0.5) * 0.9 + 0.5 * 1.0 = 0.95
+    expect(out[0]!.score).toBeCloseTo(0.95, 6);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("passes pairs through unchanged when cross-encoder load fails and no apiKey", async () => {
+    const env = (globalThis as { process?: { env?: Record<string, string | undefined> } })
+      .process?.env;
+    const savedOpen = env?.OPENAI_API_KEY;
+    const savedAnt = env?.ANTHROPIC_API_KEY;
+    if (env) {
+      delete env.OPENAI_API_KEY;
+      delete env.ANTHROPIC_API_KEY;
+    }
+    try {
+      const pairs: ScoredPair[] = [{ idA: 0, idB: 1, score: 0.9 }];
+      const out = await rerankTopPairs(pairs, rows, mk, {
+        reranker: "cross-encoder",
+      });
+      // No backend available -> original scores survive (>= threshold).
+      expect(out.length).toBe(1);
+      expect(out[0]!.score).toBeCloseTo(0.9, 6);
+    } finally {
+      if (env) {
+        if (savedOpen !== undefined) env.OPENAI_API_KEY = savedOpen;
+        if (savedAnt !== undefined) env.ANTHROPIC_API_KEY = savedAnt;
+      }
+    }
+  });
+});

package/tests/unit/cross-encoder.test.ts

@@ -0,0 +1,173 @@
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+} from "vitest";
+import { rerankPair, rerankTopPairs } from "../../src/core/index.js";
+import type {
+  MatchkeyConfig,
+  Row,
+  ScoredPair,
+} from "../../src/core/index.js";
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+function mockOpenAIChat(score: number) {
+  return {
+    ok: true,
+    status: 200,
+    text: async () => "",
+    json: async () => ({
+      choices: [{ message: { content: JSON.stringify({ score }) } }],
+      usage: { prompt_tokens: 50, completion_tokens: 8 },
+    }),
+  } as Response;
+}
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  vi.stubGlobal("fetch", fetchMock);
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("rerankPair", () => {
+  it("returns parsed 0..1 score on success", async () => {
+    fetchMock.mockResolvedValueOnce(mockOpenAIChat(0.92));
+    const score = await rerankPair(
+      { name: "Bob Smith" },
+      { name: "Robert Smith" },
+      ["name"],
+      { apiKey: "sk-test", maxRetries: 0 },
+    );
+    expect(score).toBeCloseTo(0.92, 6);
+  });
+
+  it("returns NaN when no apiKey provided", async () => {
+    // Ensure env var not set.
+    const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env;
+    const savedOpen = env?.OPENAI_API_KEY;
+    const savedAnt = env?.ANTHROPIC_API_KEY;
+    if (env) {
+      delete env.OPENAI_API_KEY;
+      delete env.ANTHROPIC_API_KEY;
+    }
+    try {
+      const score = await rerankPair({ a: 1 }, { a: 1 }, ["a"], {});
+      expect(Number.isNaN(score)).toBe(true);
+    } finally {
+      if (env) {
+        if (savedOpen !== undefined) env.OPENAI_API_KEY = savedOpen;
+        if (savedAnt !== undefined) env.ANTHROPIC_API_KEY = savedAnt;
+      }
+    }
+  });
+
+  it("returns NaN on HTTP failure", async () => {
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      text: async () => "unauthorized",
+      json: async () => ({}),
+    } as Response);
+    const score = await rerankPair({}, {}, [], {
+      apiKey: "sk-test",
+      maxRetries: 0,
+    });
+    expect(Number.isNaN(score)).toBe(true);
+  });
+});
+
+describe("rerankTopPairs", () => {
+  const mk: MatchkeyConfig = {
+    name: "name_match",
+    type: "weighted",
+    threshold: 0.85,
+    fields: [{ field: "name", transforms: [], scorer: "jaro_winkler", weight: 1 }],
+  };
+
+  const rows: Row[] = [
+    { __row_id__: 0, name: "Alice" },
+    { __row_id__: 1, name: "Alyce" },
+    { __row_id__: 2, name: "Bob" },
+    { __row_id__: 3, name: "Robert" },
+  ];
+
+  it("filters pairs to within band [threshold-band, 1.0] and caps at topN", async () => {
+    // Band default 0.1 → only pairs >= 0.75 are candidates.
+    const pairs: ScoredPair[] = [
+      { idA: 0, idB: 1, score: 0.95 },
+      { idA: 2, idB: 3, score: 0.80 },
+      { idA: 0, idB: 2, score: 0.50 }, // below band - not reranked
+    ];
+    // Mock 1 LLM response (topN=1)
+    fetchMock.mockResolvedValueOnce(mockOpenAIChat(1.0));
+
+    const out = await rerankTopPairs(pairs, rows, mk, {
+      apiKey: "sk-test",
+      maxRetries: 0,
+      topN: 1,
+      band: 0.1,
+    });
+
+    // Only one fetch (capped at topN=1)
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    // Output should drop pairs below threshold
+    // - (0,1): combined=0.5*0.95+0.5*1.0=0.975 -> kept
+    // - (2,3): not reranked, original 0.80 < threshold 0.85 -> dropped
+    // - (0,2): not reranked, 0.50 < 0.85 -> dropped
+    const ids = out.map((p) => `${p.idA}-${p.idB}`);
+    expect(ids).toContain("0-1");
+    expect(ids).not.toContain("0-2");
+    expect(ids).not.toContain("2-3");
+  });
+
+  it("returns input unchanged when no apiKey", async () => {
+    const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env;
+    const savedOpen = env?.OPENAI_API_KEY;
+    const savedAnt = env?.ANTHROPIC_API_KEY;
+    if (env) {
+      delete env.OPENAI_API_KEY;
+      delete env.ANTHROPIC_API_KEY;
+    }
+    try {
+      const pairs: ScoredPair[] = [{ idA: 0, idB: 1, score: 0.9 }];
+      const out = await rerankTopPairs(pairs, rows, mk, {});
+      expect(out).toBe(pairs);
+    } finally {
+      if (env) {
+        if (savedOpen !== undefined) env.OPENAI_API_KEY = savedOpen;
+        if (savedAnt !== undefined) env.ANTHROPIC_API_KEY = savedAnt;
+      }
+    }
+  });
+
+  it("on HTTP failure pair keeps original score", async () => {
+    // Borderline pair: 0.86 (just above threshold 0.85). LLM call will fail.
+    const pairs: ScoredPair[] = [{ idA: 0, idB: 1, score: 0.86 }];
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      text: async () => "boom",
+      json: async () => ({}),
+    } as Response);
+
+    const out = await rerankTopPairs(pairs, rows, mk, {
+      apiKey: "sk-test",
+      maxRetries: 0,
+    });
+    // Pair kept with original score (0.86 >= threshold 0.85)
+    expect(out.length).toBe(1);
+    expect(out[0]!.score).toBeCloseTo(0.86, 6);
+  });
+
+  it("empty input -> empty output", async () => {
+    const out = await rerankTopPairs([], rows, mk, { apiKey: "sk-test" });
+    expect(out).toEqual([]);
+  });
+});

package/tests/unit/db-connectors.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { createPostgresConnector } from "../../src/node/db/postgres.js";
+import { createDuckDBConnector } from "../../src/node/backends/duckdb.js";
+
+describe("createPostgresConnector", () => {
+  it("throws clear install message when 'pg' is not installed", () => {
+    // pg is an optional peer dep; not in this dev env.
+    try {
+      const c = createPostgresConnector({ host: "localhost" });
+      // If pg happens to be installed, just validate the shape.
+      expect(typeof c.connect).toBe("function");
+      expect(typeof c.query).toBe("function");
+      expect(typeof c.close).toBe("function");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      expect(msg).toMatch(/pg/);
+      expect(msg).toMatch(/install/i);
+    }
+  });
+});
+
+describe("createDuckDBConnector", () => {
+  it("throws clear install message when '@duckdb/node-api' is not installed", async () => {
+    try {
+      const c = await createDuckDBConnector();
+      // If installed, validate connector shape.
+      expect(typeof c.readTable).toBe("function");
+      expect(typeof c.writeTable).toBe("function");
+      expect(typeof c.close).toBe("function");
+      c.close();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      expect(msg).toMatch(/@duckdb\/node-api/);
+      expect(msg).toMatch(/install/i);
+    }
+  });
+});

package/tests/unit/domain.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { detectDomain, extractFeatures } from "../../src/core/domain.js";
+import type { Row } from "../../src/core/types.js";
+
+describe("detectDomain", () => {
+  it("classifies electronics-like columns as 'product'", () => {
+    const profile = detectDomain(["brand", "model", "sku", "price"]);
+    expect(profile.name).toBe("product");
+    expect(profile.confidence).toBeGreaterThan(0);
+    expect(profile.featureColumns).toContain("brand");
+    expect(profile.featureColumns).toContain("model");
+  });
+
+  it("classifies person columns as 'person'", () => {
+    const profile = detectDomain(["first_name", "last_name", "email", "phone"]);
+    expect(profile.name).toBe("person");
+    expect(profile.confidence).toBeGreaterThan(0);
+  });
+
+  it("classifies bibliographic columns as 'bibliographic'", () => {
+    const profile = detectDomain(["title", "authors", "year", "venue"]);
+    expect(profile.name).toBe("bibliographic");
+    expect(profile.confidence).toBeGreaterThan(0);
+  });
+
+  it("returns 'generic' when no signatures match", () => {
+    const profile = detectDomain(["foo", "bar", "baz"]);
+    expect(profile.name).toBe("generic");
+    expect(profile.confidence).toBe(0);
+    expect(profile.featureColumns).toEqual([]);
+  });
+
+  it("reports text columns (description, title, notes, body)", () => {
+    const profile = detectDomain(["title", "description", "notes", "brand"]);
+    // All three TEXT_NAME_RE hits show up in textColumns regardless of winner.
+    for (const col of ["title", "description", "notes"]) {
+      expect(profile.textColumns).toContain(col);
+    }
+  });
+});
+
+describe("extractFeatures", () => {
+  it("adds __brand__/__model__/__version__ columns for product rows with signal", () => {
+    const rows: Row[] = [
+      { brand: "Apple", model: "iPhone-12", description: "A product" },
+      { brand: "Samsung", model: "SGH-M220", description: "Phone" },
+    ];
+    const profile = detectDomain(Object.keys(rows[0]!));
+    const { rows: enriched, lowConfidenceIds } = extractFeatures(rows, profile);
+    expect(enriched.length).toBe(2);
+    expect(enriched[0]!["__brand__"]).toBe("apple");
+    expect(enriched[0]!["__model__"]).toBe("IPHONE12");
+    expect(enriched[1]!["__brand__"]).toBe("samsung");
+    // Both rows have brand + model => not in lowConfidenceIds.
+    expect(lowConfidenceIds).not.toContain(0);
+    expect(lowConfidenceIds).not.toContain(1);
+  });
+
+  it("reports low-confidence rows when features can't be extracted", () => {
+    const rows: Row[] = [
+      { brand: null, model: null, description: "foo bar" },
+      { brand: null, model: null, description: null },
+    ];
+    const profile = detectDomain(["brand", "model", "description"]);
+    const { lowConfidenceIds } = extractFeatures(rows, profile, 0.5);
+    // Both rows have 0/3 features extracted -> confidence 0 < 0.5.
+    expect(lowConfidenceIds).toContain(0);
+    expect(lowConfidenceIds).toContain(1);
+  });
+
+  it("generic domain: returns rows unchanged and no low-confidence ids", () => {
+    const rows: Row[] = [{ foo: "a" }, { foo: "b" }];
+    const profile = detectDomain(["foo"]);
+    const { rows: out, lowConfidenceIds } = extractFeatures(rows, profile);
+    expect(out.length).toBe(2);
+    expect(lowConfidenceIds).toEqual([]);
+    // No underscore columns injected.
+    expect(Object.keys(out[0]!)).toEqual(["foo"]);
+  });
+});

package/tests/unit/embedder.test.ts

@@ -0,0 +1,151 @@
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+} from "vitest";
+import { Embedder, getEmbedder, EmbedderError } from "../../src/core/index.js";
+import { _clearEmbedderCache } from "../../src/core/embedder.js";
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+function vec(...nums: number[]): Float32Array {
+  return new Float32Array(nums);
+}
+
+function mockOpenAIResponse(embeddings: number[][], totalTokens = 10) {
+  return {
+    ok: true,
+    status: 200,
+    text: async () => "",
+    json: async () => ({
+      data: embeddings.map((embedding) => ({ embedding })),
+      usage: { total_tokens: totalTokens },
+    }),
+  } as Response;
+}
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  vi.stubGlobal("fetch", fetchMock);
+  _clearEmbedderCache();
+  // Avoid accidental env apiKey leakage between tests.
+  delete (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env?.OPENAI_API_KEY;
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("Embedder.cosineSimilarity", () => {
+  it("known orthogonal vectors -> 0", () => {
+    const e = new Embedder({ apiKey: "sk-test" });
+    expect(e.cosineSimilarity(vec(1, 0, 0), vec(0, 1, 0))).toBe(0);
+  });
+
+  it("identical vectors -> 1", () => {
+    const e = new Embedder({ apiKey: "sk-test" });
+    expect(e.cosineSimilarity(vec(1, 2, 3), vec(1, 2, 3))).toBeCloseTo(1, 6);
+  });
+
+  it("zero vector -> 0", () => {
+    const e = new Embedder({ apiKey: "sk-test" });
+    expect(e.cosineSimilarity(vec(0, 0), vec(1, 1))).toBe(0);
+  });
+});
+
+describe("Embedder.cosineSimilarityMatrix", () => {
+  it("returns NxN matrix with diagonal of 1", () => {
+    const e = new Embedder({ apiKey: "sk-test" });
+    const embeddings = [vec(1, 0, 0), vec(0, 1, 0), vec(1, 0, 0)];
+    const matrix = e.cosineSimilarityMatrix(embeddings);
+    expect(matrix.length).toBe(3);
+    expect(matrix[0]!.length).toBe(3);
+    for (let i = 0; i < 3; i++) {
+      expect(matrix[i]![i]).toBe(1);
+    }
+    // Symmetric off-diagonals
+    expect(matrix[0]![1]).toBeCloseTo(matrix[1]![0]!, 9);
+    // 0 and 2 are identical
+    expect(matrix[0]![2]).toBeCloseTo(1, 6);
+  });
+});
+
+describe("Embedder.embedBatch — unique-text dedup", () => {
+  it("dedupes identical texts before calling API", async () => {
+    fetchMock.mockResolvedValueOnce(
+      mockOpenAIResponse([
+        [1, 0, 0],
+        [0, 1, 0],
+      ]),
+    );
+    const e = new Embedder({ apiKey: "sk-test" });
+    const result = await e.embedBatch(["foo", "bar", "foo", "foo"]);
+
+    // Only one API call
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    // Body should contain only unique inputs ["foo","bar"]
+    const callArgs = fetchMock.mock.calls[0];
+    const body = JSON.parse((callArgs![1] as RequestInit).body as string);
+    expect(body.input).toEqual(["foo", "bar"]);
+
+    // 4 outputs in original order
+    expect(result.embeddings.length).toBe(4);
+    // foo positions (0, 2, 3) share the same embedding object identity
+    expect(result.embeddings[0]).toBe(result.embeddings[2]);
+    expect(result.embeddings[0]).toBe(result.embeddings[3]);
+  });
+});
+
+describe("Embedder.embedOne", () => {
+  it("returns single Float32Array", async () => {
+    fetchMock.mockResolvedValueOnce(mockOpenAIResponse([[3, 4]]));
+    const e = new Embedder({ apiKey: "sk-test" });
+    const v = await e.embedOne("hello");
+    expect(v).toBeInstanceOf(Float32Array);
+    expect(v.length).toBe(2);
+  });
+});
+
+describe("Embedder error handling", () => {
+  it("throws EmbedderError when no apiKey and no env var", async () => {
+    const e = new Embedder({ provider: "openai" });
+    // Make sure there's truly no apiKey.
+    await expect(e.embedBatch(["hello"])).rejects.toThrow(EmbedderError);
+  });
+
+  it("throws EmbedderError when API returns non-2xx", async () => {
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      text: async () => "unauthorized",
+      json: async () => ({}),
+    } as Response);
+    const e = new Embedder({ apiKey: "sk-test", maxRetries: 0 });
+    await expect(e.embedBatch(["hi"])).rejects.toThrow(EmbedderError);
+  });
+});
+
+describe("getEmbedder caching", () => {
+  it("returns same instance for same provider+model", () => {
+    _clearEmbedderCache();
+    const a = getEmbedder({ apiKey: "sk-test", model: "text-embedding-3-small" });
+    const b = getEmbedder({ apiKey: "sk-test", model: "text-embedding-3-small" });
+    expect(a).toBe(b);
+  });
+
+  it("returns different instance for different model", () => {
+    _clearEmbedderCache();
+    const a = getEmbedder({ apiKey: "sk-test", model: "text-embedding-3-small" });
+    const b = getEmbedder({ apiKey: "sk-test", model: "text-embedding-3-large" });
+    expect(a).not.toBe(b);
+  });
+
+  it("accepts string shorthand for model", () => {
+    _clearEmbedderCache();
+    const a = getEmbedder("text-embedding-3-small");
+    expect(a).toBeInstanceOf(Embedder);
+  });
+});