agent-inbox 0.2.2 → 0.2.4

package/test/load.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import { SqliteStorage } from "../src/storage/sqlite.js";
+import { MessageRouter } from "../src/router/message-router.js";
+import { TraceabilityLayer } from "../src/traceability/traceability.js";
+import { PushNotifier } from "../src/push/notifier.js";
+import type { Storage } from "../src/storage/interface.js";
+
+/**
+ * Load tests verifying the file-growth and write-amplification fixes.
+ *
+ * These tests run larger volumes (1k-10k messages) so they're slower than
+ * the unit suite but still finish in seconds. They assert on counts of
+ * side-effects (writes, rows, file size) — not wall-clock time — so they
+ * are deterministic.
+ */
+
+interface CallCounts {
+  putMessage: number;
+  setMessageConversationId: number;
+  putConversation: number;
+  touchConversation: number;
+  addParticipant: number;
+  addTurn: number;
+}
+
+function instrumentStorage(inner: Storage): { storage: Storage; counts: CallCounts } {
+  const counts: CallCounts = {
+    putMessage: 0,
+    setMessageConversationId: 0,
+    putConversation: 0,
+    touchConversation: 0,
+    addParticipant: 0,
+    addTurn: 0,
+  };
+  const storage = new Proxy(inner, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      if (prop in counts) {
+        return (...args: unknown[]) => {
+          counts[prop as keyof CallCounts]++;
+          return (value as Function).apply(target, args);
+        };
+      }
+      return (value as Function).bind(target);
+    },
+  });
+  return { storage, counts };
+}
+
+describe("load: inbox file caps stay bounded under heavy writes", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "inbox-load-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should stay near maxEntries (soft cap ~1.1×) after 10000 writes", async () => {
+    const cap = 500;
+    const storage = new InMemoryStorage();
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    const notifier = new PushNotifier(
+      { inboxDir: tmpDir, maxEntriesPerInbox: cap, maxBytesPerInbox: 0 },
+      storage,
+      events
+    );
+
+    for (let i = 0; i < 10_000; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i}`,
+      });
+    }
+
+    const filePath = notifier.agentInboxPath("bob");
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.length > 0);
+    expect(lines.length).toBeLessThanOrEqual(Math.ceil(cap * 1.1));
+    expect(lines.length).toBeGreaterThanOrEqual(cap);
+  });
+
+  it("should stay near maxBytes (soft cap ~1.1×) after 10000 writes", async () => {
+    const cap = 64 * 1024;
+    const storage = new InMemoryStorage();
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    const notifier = new PushNotifier(
+      { inboxDir: tmpDir, maxEntriesPerInbox: 0, maxBytesPerInbox: cap },
+      storage,
+      events
+    );
+
+    for (let i = 0; i < 10_000; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i} ${"x".repeat(50)}`,
+      });
+    }
+
+    const size = fs.statSync(notifier.agentInboxPath("bob")).size;
+    expect(size).toBeLessThanOrEqual(Math.ceil(cap * 1.1));
+  });
+
+  it("would grow unboundedly with caps disabled (control)", async () => {
+    const storage = new InMemoryStorage();
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    const notifier = new PushNotifier(
+      { inboxDir: tmpDir, maxEntriesPerInbox: 0, maxBytesPerInbox: 0 },
+      storage,
+      events
+    );
+
+    const N = 2000;
+    for (let i = 0; i < N; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i}`,
+      });
+    }
+
+    const raw = fs.readFileSync(notifier.agentInboxPath("bob"), "utf-8");
+    const lines = raw.split("\n").filter((l) => l.length > 0);
+    expect(lines).toHaveLength(N);
+  });
+});
+
+describe("load: traceability does not amplify writes", () => {
+  it("should call setMessageConversationId once per message and never re-putMessage", async () => {
+    const inner = new InMemoryStorage();
+    const { storage, counts } = instrumentStorage(inner);
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    new TraceabilityLayer(storage, events);
+
+    const N = 1000;
+    for (let i = 0; i < N; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i}`,
+        threadTag: "load-test",
+      });
+    }
+
+    // Router does the only putMessage. Traceability now uses the targeted
+    // setMessageConversationId path, so total putMessage calls === N.
+    expect(counts.putMessage).toBe(N);
+    expect(counts.setMessageConversationId).toBe(N);
+  });
+
+  it("should call touchConversation per message instead of full putConversation", async () => {
+    const inner = new InMemoryStorage();
+    const { storage, counts } = instrumentStorage(inner);
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    new TraceabilityLayer(storage, events);
+
+    const N = 1000;
+    for (let i = 0; i < N; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i}`,
+        threadTag: "load-test",
+      });
+    }
+
+    // Exactly one putConversation (the create), then N touchConversation bumps.
+    expect(counts.putConversation).toBe(1);
+    expect(counts.touchConversation).toBe(N);
+  });
+
+  it("should keep participant row count stable for a long-lived broadcast conversation", async () => {
+    const storage = new SqliteStorage({ path: ":memory:" });
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    new TraceabilityLayer(storage, events);
+
+    const recipients = Array.from({ length: 10 }, (_, i) => `agent-${i}`);
+    const N = 1000;
+
+    for (let i = 0; i < N; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: recipients,
+        payload: `msg-${i}`,
+        threadTag: "broadcast",
+      });
+    }
+
+    const conversations = storage.listConversations("default");
+    expect(conversations).toHaveLength(1);
+
+    // alice + 10 recipients = 11 participants — must not balloon with N.
+    expect(conversations[0].participants).toHaveLength(11);
+
+    // Sanity: turns table grows linearly with messages (expected — that's the audit log).
+    expect(storage.getTurns(conversations[0].id)).toHaveLength(N);
+
+    storage.close();
+  });
+});
+
+describe("load: SQLite stays bounded", () => {
+  let dbPath: string;
+
+  beforeEach(() => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "inbox-sqlite-load-"));
+    dbPath = path.join(tmp, "inbox.db");
+  });
+  afterEach(() => {
+    const dir = path.dirname(dbPath);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("should keep DB file growth bounded under heavy load", async () => {
+    const storage = new SqliteStorage({ path: dbPath });
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    new TraceabilityLayer(storage, events);
+
+    const recipients = Array.from({ length: 10 }, (_, i) => `agent-${i}`);
+    const N = 5000;
+
+    for (let i = 0; i < N; i++) {
+      await router.routeMessage({
+        from: "alice",
+        to: recipients,
+        payload: `msg-${i}`,
+        threadTag: "broadcast",
+      });
+    }
+
+    // After close, WAL checkpoints into the main DB. The fix's main impact
+    // is on write *churn* (no per-message participant resyncs); this is a
+    // smoke test that the on-disk size scales reasonably with the data.
+    storage.close();
+    const size = fs.statSync(dbPath).size;
+    // 5000 messages × 11 recipients ≈ 55k recipient rows + 5k turns + FTS.
+    // 4 KiB per logical message is a generous ceiling.
+    expect(size).toBeLessThan(N * 4096);
+  }, 30_000); // generous timeout: this asserts bounded size, not speed
+
+  it("pruneMessagesOlderThan should remove old data and reduce row counts", async () => {
+    const storage = new SqliteStorage({ path: ":memory:" });
+    const events = new EventEmitter();
+    const router = new MessageRouter(storage, events, "default");
+    new TraceabilityLayer(storage, events);
+
+    const N = 1000;
+    for (let i = 0; i < N; i++) {
+      const old = i < N / 2;
+      const ts = old ? "2024-01-01T00:00:00Z" : "2026-12-01T00:00:00Z";
+      const msg = await router.routeMessage({
+        from: "alice",
+        to: "bob",
+        payload: `msg-${i}`,
+        threadTag: "load",
+      });
+      // Backdate by overriding via storage to simulate aged messages
+      const stored = storage.getMessage(msg.id)!;
+      stored.created_at = ts;
+      storage.putMessage(stored);
+    }
+
+    const removed = storage.pruneMessagesOlderThan("2025-01-01T00:00:00Z");
+    expect(removed).toBe(N / 2);
+
+    // Recent half remains
+    const conv = storage.listConversations("default")[0];
+    expect(storage.getTurns(conv.id)).toHaveLength(N / 2);
+
+    storage.close();
+  });
+});

package/test/mail/address-book.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { AddressBook } from "../../src/mail/address-book.js";
+
+function book(): AddressBook {
+  return new AddressBook({
+    localDomains: ["example.com", "agents.example.com"],
+    mappings: [
+      { agentId: "alice", address: "alice@example.com" },
+      { agentId: "bob", address: "bob@example.com" },
+    ],
+    catchAllAgentId: undefined,
+  });
+}
+
+describe("AddressBook", () => {
+  it("reports the primary domain", () => {
+    expect(book().primaryDomain()).toBe("example.com");
+  });
+
+  it("recognizes owned domains and subdomains", () => {
+    const b = book();
+    expect(b.ownsDomain("example.com")).toBe(true);
+    expect(b.ownsDomain("mail.example.com")).toBe(true);
+    expect(b.ownsDomain("agents.example.com")).toBe(true);
+    expect(b.ownsDomain("notexample.com")).toBe(false);
+    expect(b.ownsDomain("other.org")).toBe(false);
+  });
+
+  it("resolves a known inbound mailbox to its agent", () => {
+    expect(book().resolveInbound("bob@example.com")).toEqual({
+      agentId: "bob",
+      scope: undefined,
+    });
+  });
+
+  it("is case-insensitive on the mailbox", () => {
+    expect(book().resolveInbound("ALICE@Example.com")?.agentId).toBe("alice");
+  });
+
+  it("extracts scope from plus-addressing", () => {
+    expect(book().resolveInbound("alice+urgent@example.com")).toEqual({
+      agentId: "alice",
+      scope: "urgent",
+    });
+  });
+
+  it("returns undefined for a foreign domain", () => {
+    expect(book().resolveInbound("alice@other.org")).toBeUndefined();
+  });
+
+  it("returns undefined for an unknown mailbox without catch-all", () => {
+    expect(book().resolveInbound("ghost@example.com")).toBeUndefined();
+  });
+
+  it("routes unknown mailboxes to catch-all when configured", () => {
+    const b = new AddressBook({
+      localDomains: ["example.com"],
+      mappings: [],
+      catchAllAgentId: "triage",
+    });
+    expect(b.resolveInbound("anyone@example.com")).toEqual({
+      agentId: "triage",
+      scope: undefined,
+    });
+  });
+
+  it("resolves a mapped agent's from-address", () => {
+    expect(book().resolveFrom("alice")).toEqual({ address: "alice@example.com" });
+  });
+
+  it("falls back to agentId@primaryDomain for an unmapped agent", () => {
+    expect(book().resolveFrom("ghost")).toEqual({
+      address: "ghost@example.com",
+    });
+  });
+
+  it("ignores malformed addresses", () => {
+    expect(book().resolveInbound("not-an-email")).toBeUndefined();
+    expect(book().resolveInbound("@example.com")).toBeUndefined();
+    expect(book().resolveInbound("foo@")).toBeUndefined();
+  });
+
+  it("rejects addresses with multiple @ (consistent with parseAddress)", () => {
+    expect(book().resolveInbound("a@b@example.com")).toBeUndefined();
+    expect(book().resolveInbound("alice@example.com@evil.com")).toBeUndefined();
+  });
+
+  it("records duplicate-address mapping conflicts and keeps the first", () => {
+    const b = new AddressBook({
+      localDomains: ["example.com"],
+      mappings: [
+        { agentId: "alice", address: "shared@example.com" },
+        { agentId: "bob", address: "shared@example.com" },
+      ],
+    });
+    expect(b.resolveInbound("shared@example.com")?.agentId).toBe("alice");
+    expect(b.conflicts).toHaveLength(1);
+    expect(b.conflicts[0]).toContain("shared@example.com");
+  });
+
+  it("does not flag a repeated identical (agent,address) pair as a conflict", () => {
+    const b = new AddressBook({
+      localDomains: ["example.com"],
+      mappings: [
+        { agentId: "alice", address: "alice@example.com" },
+        { agentId: "alice", address: "alice@example.com" },
+      ],
+    });
+    expect(b.conflicts).toHaveLength(0);
+  });
+});

package/test/mail/attachment-store-contract.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared AttachmentStore contract — both backends (SQLite BLOB + filesystem)
+ * must satisfy the same behavior, so they are interchangeable behind the
+ * opaque `contentRef`. Mirrors the mail-transport contract pattern.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import Database from "better-sqlite3";
+import type { AttachmentStore } from "../../src/mail/types.js";
+import { SqliteAttachmentStore } from "../../src/mail/attachment-store.js";
+import { FsAttachmentStore } from "../../src/mail/fs-attachment-store.js";
+
+interface Harness {
+  store: AttachmentStore;
+  cleanup: () => Promise<void> | void;
+}
+
+function runAttachmentStoreContract(
+  name: string,
+  makeHarness: () => Promise<Harness>
+): void {
+  describe(`AttachmentStore contract: ${name}`, () => {
+    let h: Harness;
+    beforeEach(async () => {
+      h = await makeHarness();
+    });
+    afterEach(async () => {
+      await h.cleanup();
+    });
+
+    it("round-trips stored bytes by ref", async () => {
+      const bytes = Buffer.from("contract bytes");
+      const ref = await h.store.put(bytes, { contentType: "text/plain" });
+      expect((await h.store.get(ref)).equals(bytes)).toBe(true);
+    });
+
+    it("produces sha256-based content-addressed refs", async () => {
+      const ref = await h.store.put(Buffer.from("x"), { contentType: "text/plain" });
+      expect(ref).toMatch(/^sha256:[0-9a-f]{64}$/);
+    });
+
+    it("dedups identical bytes to the same ref", async () => {
+      const a = await h.store.put(Buffer.from("same"), { contentType: "text/plain" });
+      const b = await h.store.put(Buffer.from("same"), { contentType: "text/plain" });
+      expect(a).toBe(b);
+    });
+
+    it("gives different refs for different bytes", async () => {
+      const a = await h.store.put(Buffer.from("one"), { contentType: "text/plain" });
+      const b = await h.store.put(Buffer.from("two"), { contentType: "text/plain" });
+      expect(a).not.toBe(b);
+    });
+
+    it("throws on a missing ref", async () => {
+      await expect(h.store.get("sha256:" + "a".repeat(64))).rejects.toThrow(/not found/);
+    });
+
+    it("rejects a malformed ref on get and delete (both backends)", async () => {
+      await expect(h.store.get("garbage")).rejects.toThrow(/Invalid attachment ref/);
+      await expect(h.store.get("sha256:../../etc/passwd")).rejects.toThrow(/Invalid attachment ref/);
+      await expect(h.store.delete("sha256:short")).rejects.toThrow(/Invalid attachment ref/);
+    });
+
+    it("deletes by ref", async () => {
+      const ref = await h.store.put(Buffer.from("gone"), { contentType: "text/plain" });
+      await h.store.delete(ref);
+      await expect(h.store.get(ref)).rejects.toThrow(/not found/);
+    });
+
+    it("round-trips arbitrary binary content exactly", async () => {
+      const bytes = Buffer.from([0x00, 0xff, 0x7f, 0x80, 0x01, 0x00]);
+      const ref = await h.store.put(bytes, { contentType: "application/octet-stream" });
+      expect((await h.store.get(ref)).equals(bytes)).toBe(true);
+    });
+  });
+}
+
+runAttachmentStoreContract("SqliteAttachmentStore", async () => {
+  const db = new Database(":memory:");
+  return { store: new SqliteAttachmentStore(db), cleanup: () => db.close() };
+});
+
+runAttachmentStoreContract("FsAttachmentStore", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "att-contract-"));
+  return {
+    store: new FsAttachmentStore(dir),
+    cleanup: () => fs.rm(dir, { recursive: true, force: true }),
+  };
+});

package/test/mail/attachment-store.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import { SqliteAttachmentStore } from "../../src/mail/attachment-store.js";
+
+describe("SqliteAttachmentStore", () => {
+  let db: Database.Database;
+  let store: SqliteAttachmentStore;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    store = new SqliteAttachmentStore(db);
+  });
+
+  afterEach(() => db.close());
+
+  it("stores and retrieves bytes by ref", async () => {
+    const bytes = Buffer.from("hello attachment");
+    const ref = await store.put(bytes, { contentType: "text/plain" });
+    const got = await store.get(ref);
+    expect(got.equals(bytes)).toBe(true);
+  });
+
+  it("produces content-addressed (sha256:) refs", async () => {
+    const ref = await store.put(Buffer.from("x"), { contentType: "text/plain" });
+    expect(ref).toMatch(/^sha256:[0-9a-f]{64}$/);
+  });
+
+  it("dedups identical bytes to the same ref and single row", async () => {
+    const a = await store.put(Buffer.from("same"), { contentType: "text/plain" });
+    const b = await store.put(Buffer.from("same"), { contentType: "text/plain" });
+    expect(a).toBe(b);
+    const count = db
+      .prepare("SELECT COUNT(*) AS n FROM mail_attachments")
+      .get() as { n: number };
+    expect(count.n).toBe(1);
+  });
+
+  it("gives different refs for different bytes", async () => {
+    const a = await store.put(Buffer.from("one"), { contentType: "text/plain" });
+    const b = await store.put(Buffer.from("two"), { contentType: "text/plain" });
+    expect(a).not.toBe(b);
+  });
+
+  it("deletes by ref", async () => {
+    const ref = await store.put(Buffer.from("gone"), { contentType: "text/plain" });
+    await store.delete(ref);
+    await expect(store.get(ref)).rejects.toThrow(/not found/);
+  });
+
+  it("throws on missing ref", async () => {
+    await expect(store.get("sha256:" + "0".repeat(64))).rejects.toThrow(/not found/);
+  });
+
+  it("persists filename and size metadata", async () => {
+    const bytes = Buffer.from("with-meta");
+    const ref = await store.put(bytes, {
+      contentType: "application/pdf",
+      filename: "doc.pdf",
+    });
+    const row = db
+      .prepare(
+        "SELECT content_type, filename, size_bytes FROM mail_attachments WHERE ref = ?"
+      )
+      .get(ref) as { content_type: string; filename: string; size_bytes: number };
+    expect(row.content_type).toBe("application/pdf");
+    expect(row.filename).toBe("doc.pdf");
+    expect(row.size_bytes).toBe(bytes.length);
+  });
+});

package/test/mail/destination.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import {
+  classifyDestination,
+  findDomainConflicts,
+  UnknownDestinationError,
+  type DestinationContext,
+} from "../../src/router/destination.js";
+
+function ctx(overrides: Partial<DestinationContext> = {}): DestinationContext {
+  return {
+    isLocalAgent: (id) => ["alice", "bob"].includes(id),
+    federationPeers: [{ systemId: "system-2" }],
+    mailDomains: ["example.com"],
+    ...overrides,
+  };
+}
+
+describe("classifyDestination", () => {
+  it("classifies a bare id as local", () => {
+    expect(classifyDestination("alice", ctx())).toEqual({
+      class: "local",
+      agentId: "alice",
+    });
+  });
+
+  it("classifies an unknown bare id as local (no domain to disambiguate)", () => {
+    // No @ means there is no domain to route on — it is a local-namespace id.
+    expect(classifyDestination("charlie", ctx())).toEqual({
+      class: "local",
+      agentId: "charlie",
+    });
+  });
+
+  it("classifies a configured federation peer system as federation", () => {
+    const d = classifyDestination("bob@system-2", ctx());
+    expect(d.class).toBe("federation");
+    if (d.class === "federation") {
+      expect(d.address).toEqual({ agent: "bob", system: "system-2" });
+    }
+  });
+
+  it("classifies a configured mail domain as mail", () => {
+    expect(classifyDestination("bob@example.com", ctx())).toEqual({
+      class: "mail",
+      email: "bob@example.com",
+    });
+  });
+
+  it("matches subdomains of a configured mail domain", () => {
+    expect(classifyDestination("bob@mail.example.com", ctx())).toEqual({
+      class: "mail",
+      email: "bob@mail.example.com",
+    });
+  });
+
+  it("does not match a domain that merely shares a suffix string", () => {
+    // notexample.com must NOT match example.com
+    expect(() => classifyDestination("bob@notexample.com", ctx())).toThrow(
+      UnknownDestinationError
+    );
+  });
+
+  it("throws UnknownDestinationError for an unlisted domain", () => {
+    expect(() => classifyDestination("bob@gmail.com", ctx())).toThrow(
+      UnknownDestinationError
+    );
+  });
+
+  it("lets a federation peer's declared domain win over mail config", () => {
+    // corp.internal is claimed by BOTH a peer and mail config — federation wins.
+    const c = ctx({
+      federationPeers: [{ systemId: "system-2", domains: ["corp.internal"] }],
+      mailDomains: ["example.com", "corp.internal"],
+    });
+    const d = classifyDestination("team@corp.internal", c);
+    expect(d.class).toBe("federation");
+  });
+
+  it("routes a dotted federation domain that is not in mail config", () => {
+    const c = ctx({
+      federationPeers: [{ systemId: "hub", domains: ["team.corp.internal"] }],
+      mailDomains: ["example.com"],
+    });
+    expect(classifyDestination("svc@team.corp.internal", c).class).toBe(
+      "federation"
+    );
+  });
+
+  it("strips a trailing /scope from a mail address", () => {
+    expect(classifyDestination("bob@example.com/work", ctx())).toEqual({
+      class: "mail",
+      email: "bob@example.com",
+    });
+  });
+
+  it("is case-insensitive on domain matching", () => {
+    expect(classifyDestination("bob@Example.COM", ctx()).class).toBe("mail");
+  });
+});
+
+describe("findDomainConflicts", () => {
+  it("reports domains claimed by both a peer and mail config", () => {
+    const conflicts = findDomainConflicts(
+      ctx({
+        federationPeers: [{ systemId: "s", domains: ["corp.internal", "ok.net"] }],
+        mailDomains: ["example.com", "corp.internal"],
+      })
+    );
+    expect(conflicts).toEqual(["corp.internal"]);
+  });
+
+  it("returns empty when there is no overlap", () => {
+    expect(findDomainConflicts(ctx())).toEqual([]);
+  });
+});