@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

package/__tests__/mobile-extractor.test.js

@@ -1,288 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const os = require("node:os");
-const { AndroidExtractor, iOSBackupReader } = require("../lib/mobile-extractor");
-
-// ─── AndroidExtractor — mocked execFn ────────────────────────────────────
-
-function mockExec(scriptMap) {
-  // scriptMap: { "args joined by space": { stdout: "...", stderr: "..." }
-  // | () => Promise<{stdout, stderr}> }
-  return async (cmd, args) => {
-    const key = args.join(" ");
-    if (key in scriptMap) {
-      const v = scriptMap[key];
-      return typeof v === "function" ? await v() : v;
-    }
-    // Allow prefix matches for convenience
-    for (const k of Object.keys(scriptMap)) {
-      if (key.startsWith(k)) {
-        const v = scriptMap[k];
-        return typeof v === "function" ? await v() : v;
-      }
-    }
-    throw new Error(`mockExec: no script for: ${cmd} ${key}`);
-  };
-}
-
-describe("AndroidExtractor", () => {
-  it("listDevices parses adb output", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "devices -l": {
-          stdout:
-            "List of devices attached\n" +
-            "ABCDEF123  device  product:redmi  model:Redmi_24115RA8EC  device:redmi\n" +
-            "OFFLINE99  offline\n",
-          stderr: "",
-        },
-      }),
-    });
-    const devices = await ext.listDevices();
-    expect(devices).toHaveLength(2);
-    expect(devices[0].serial).toBe("ABCDEF123");
-    expect(devices[0].state).toBe("device");
-    expect(devices[0].model).toBe("Redmi_24115RA8EC");
-    expect(devices[1].state).toBe("offline");
-  });
-
-  it("isDeviceReady checks state", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "devices -l": {
-          stdout: "List of devices attached\nABCDEF123  device  product:p\n",
-          stderr: "",
-        },
-      }),
-    });
-    expect(await ext.isDeviceReady("ABCDEF123")).toBe(true);
-    expect(await ext.isDeviceReady("BAD-SERIAL")).toBe(false);
-  });
-
-  it("probeRoot detects Magisk + selinux", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "-s ABC shell which su": { stdout: "/system/bin/magisk\n" },
-        "-s ABC shell which magisk": { stdout: "/system/bin/magisk\n" },
-        "-s ABC shell getenforce": { stdout: "Enforcing\n" },
-      }),
-    });
-    const probe = await ext.probeRoot("ABC");
-    expect(probe.rooted).toBe(true);
-    expect(probe.su).toBe("magisk-su");
-    expect(probe.magiskInstalled).toBe(true);
-    expect(probe.selinux).toBe("enforcing");
-  });
-
-  it("probeRoot non-rooted device", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "-s ABC shell which su": { stdout: "" },
-        "-s ABC shell which magisk": { stdout: "" },
-        "-s ABC shell getenforce": { stdout: "Enforcing\n" },
-      }),
-    });
-    const probe = await ext.probeRoot("ABC");
-    expect(probe.rooted).toBe(false);
-    expect(probe.su).toBeNull();
-  });
-
-  it("listPackages filters user-installed by default", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "-s ABC shell pm list packages -3": {
-          stdout: "package:com.tencent.mm\npackage:com.taobao.taobao\n",
-        },
-      }),
-    });
-    const pkgs = await ext.listPackages("ABC");
-    expect(pkgs).toEqual(["com.tencent.mm", "com.taobao.taobao"]);
-  });
-
-  it("pull creates dest dir + invokes adb pull", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ax-"));
-    let pulled = false;
-    const ext = new AndroidExtractor({
-      execFn: async (cmd, args) => {
-        if (args[2] === "pull") {
-          pulled = true;
-          // Simulate adb pull writing to dest
-          fs.writeFileSync(args[4], "fake-pulled-content");
-          return { stdout: "1 file pulled", stderr: "" };
-        }
-        throw new Error("unexpected adb call");
-      },
-    });
-    const dest = path.join(dir, "sub/file.bin");
-    await ext.pull("ABC", "/sdcard/x.bin", dest);
-    expect(pulled).toBe(true);
-    expect(fs.existsSync(dest)).toBe(true);
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("pullFromAppPrivate uses su cat + temp + cleanup", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ax-"));
-    const calls = [];
-    const ext = new AndroidExtractor({
-      execFn: async (cmd, args) => {
-        calls.push(args.join(" "));
-        if (args[2] === "shell" && args[3].startsWith("su -c 'cat")) {
-          return { stdout: "", stderr: "" };
-        }
-        if (args[2] === "pull") {
-          fs.writeFileSync(args[4], "decrypted-db-bytes");
-          return { stdout: "", stderr: "" };
-        }
-        if (args[2] === "shell" && args[3].startsWith("rm -f")) {
-          return { stdout: "", stderr: "" };
-        }
-        throw new Error("unexpected adb call: " + args.join(" "));
-      },
-    });
-    const dest = path.join(dir, "EnMicroMsg.db");
-    await ext.pullFromAppPrivate("ABC", "com.tencent.mm", "/data/data/com.tencent.mm/MicroMsg/x/EnMicroMsg.db", dest);
-    expect(fs.existsSync(dest)).toBe(true);
-    // Verify su cat happened + cleanup rm happened
-    expect(calls.some((c) => c.includes("su -c 'cat"))).toBe(true);
-    expect(calls.some((c) => c.includes("rm -f"))).toBe(true);
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("lsAppPrivate parses ls -1 output", async () => {
-    const ext = new AndroidExtractor({
-      execFn: mockExec({
-        "-s ABC shell su -c 'ls -1 \"/data/data/com.tencent.mm\"'": {
-          stdout: "MicroMsg\nshared_prefs\nfiles\ncache\n",
-        },
-      }),
-    });
-    const ls = await ext.lsAppPrivate("ABC", "/data/data/com.tencent.mm");
-    expect(ls).toContain("MicroMsg");
-    expect(ls).toContain("shared_prefs");
-  });
-});
-
-// ─── iOSBackupReader — fixture-driven ────────────────────────────────────
-
-describe("iOSBackupReader", () => {
-  let dir;
-
-  function makeBackup({ encrypted = false } = {}) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), "ios-bk-"));
-    fs.writeFileSync(
-      path.join(dir, "Manifest.plist"),
-      `<?xml version="1.0"?><plist version="1.0"><dict>
-<key>IsEncrypted</key>${encrypted ? "<true/>" : "<false/>"}
-</dict></plist>`,
-    );
-    fs.writeFileSync(
-      path.join(dir, "Info.plist"),
-      `<?xml version="1.0"?><plist version="1.0"><dict>
-<key>Device Name</key><string>Test iPhone</string>
-<key>Product Type</key><string>iPhone15,2</string>
-<key>Product Version</key><string>18.0</string>
-</dict></plist>`,
-    );
-    // Empty SQLite Manifest.db — mock driver below skips it
-    fs.writeFileSync(path.join(dir, "Manifest.db"), Buffer.from("SQLite format 3\0"));
-    return dir;
-  }
-
-  afterEach(() => {
-    if (dir) {
-      try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
-    }
-    dir = null;
-  });
-
-  it("constructor rejects missing dir", () => {
-    expect(() => new iOSBackupReader({ backupDir: "/nonexistent/path/xx" })).toThrow();
-    expect(() => new iOSBackupReader({})).toThrow(/backupDir/);
-  });
-
-  it("encrypted backup throws (Phase 7.5b TODO)", async () => {
-    const backupDir = makeBackup({ encrypted: true });
-    const reader = new iOSBackupReader({
-      backupDir,
-      dbDriverFn: () => {
-        throw new Error("driver should not be called when encrypted");
-      },
-    });
-    await expect(reader.open()).rejects.toThrow(/encrypted/);
-  });
-
-  it("open() reads Info.plist + opens Manifest.db", async () => {
-    const backupDir = makeBackup({ encrypted: false });
-    // Mock SQLite driver
-    const mockDb = {
-      prepare: () => ({ all: () => [], get: () => undefined }),
-      close: () => {},
-    };
-    const mockDriver = () => mockDb;
-    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
-    const r = await reader.open();
-    expect(r.encrypted).toBe(false);
-    expect(r.info["Device Name"]).toBe("Test iPhone");
-    expect(r.info["Product Version"]).toBe("18.0");
-    reader.close();
-  });
-
-  it("listFiles passes WHERE clauses based on opts", async () => {
-    const backupDir = makeBackup({ encrypted: false });
-    let lastSql, lastParams;
-    const mockDriver = () => ({
-      prepare: (sql) => ({
-        all: (...params) => {
-          lastSql = sql;
-          lastParams = params;
-          return [{ fileID: "abc", domain: "HomeDomain", relativePath: "Library/Notes/notes.sqlite", flags: 1 }];
-        },
-      }),
-      close: () => {},
-    });
-    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
-    await reader.open();
-    const files = reader.listFiles({ domain: "HomeDomain", limit: 10 });
-    expect(files).toHaveLength(1);
-    expect(lastSql).toContain("WHERE domain = ?");
-    expect(lastParams).toContain("HomeDomain");
-    reader.close();
-  });
-
-  it("resolveFileOnDisk shards by first 2 chars", async () => {
-    const backupDir = makeBackup({ encrypted: false });
-    const mockDriver = () => ({
-      prepare: () => ({ all: () => [], get: () => undefined }),
-      close: () => {},
-    });
-    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
-    await reader.open();
-    const p = reader.resolveFileOnDisk("abcd1234567890");
-    expect(p).toBe(path.join(backupDir, "ab", "abcd1234567890"));
-    reader.close();
-  });
-
-  it("copyOut copies the sharded file to localPath", async () => {
-    const backupDir = makeBackup({ encrypted: false });
-    // Create a fake sharded file
-    const fileID = "abc1234";
-    const shardedDir = path.join(backupDir, "ab");
-    fs.mkdirSync(shardedDir, { recursive: true });
-    fs.writeFileSync(path.join(shardedDir, fileID), "test-content");
-
-    const mockDriver = () => ({
-      prepare: () => ({ all: () => [], get: () => undefined }),
-      close: () => {},
-    });
-    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
-    await reader.open();
-    const local = path.join(backupDir, "out", "extracted.bin");
-    reader.copyOut(fileID, local);
-    expect(fs.readFileSync(local, "utf-8")).toBe("test-content");
-    reader.close();
-  });
-});

package/__tests__/mock-adapter.test.js

@@ -1,93 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { MockAdapter } = require("../lib/mock-adapter");
-const { validate } = require("../lib/schemas");
-const { assertAdapter } = require("../lib/adapter-spec");
-
-describe("MockAdapter", () => {
-  it("satisfies the PersonalDataAdapter contract", () => {
-    expect(assertAdapter(new MockAdapter()).ok).toBe(true);
-  });
-
-  it("yields exactly `count` raw events", async () => {
-    const a = new MockAdapter({ count: 7 });
-    const raws = [];
-    for await (const r of a.sync()) raws.push(r);
-    expect(raws.length).toBe(7);
-    expect(raws[0].adapter).toBe("mock");
-    expect(raws[0].originalId).toMatch(/^mock-raw-/);
-    expect(raws[0].capturedAt).toBeGreaterThan(1_000_000_000_000);
-  });
-
-  it("respects sinceWatermark by skipping seen items", async () => {
-    const a = new MockAdapter({ count: 10 });
-    const skipped = [];
-    for await (const r of a.sync({ sinceWatermark: 4 })) skipped.push(r);
-    expect(skipped.length).toBe(6); // 10 - 4
-    expect(skipped[0].payload.index).toBe(4);
-  });
-
-  it("respects maxEvents", async () => {
-    const a = new MockAdapter({ count: 50 });
-    const got = [];
-    for await (const r of a.sync({ maxEvents: 5 })) got.push(r);
-    expect(got.length).toBe(5);
-  });
-
-  it("normalize produces valid UnifiedSchema entities (v0, v1, v2 variants)", async () => {
-    const a = new MockAdapter({ count: 6, seed: 42 });
-    for await (const r of a.sync()) {
-      const batch = a.normalize(r);
-      expect(batch.events.length).toBeGreaterThanOrEqual(1);
-      for (const e of batch.events) expect(validate(e).valid).toBe(true);
-      for (const p of batch.persons) expect(validate(p).valid).toBe(true);
-    }
-  });
-
-  it("healthCheck honors shouldFailHealth flag", async () => {
-    const a = new MockAdapter();
-    expect((await a.healthCheck()).ok).toBe(true);
-    a.shouldFailHealth = true;
-    const r = await a.healthCheck();
-    expect(r.ok).toBe(false);
-    expect(r.reason).toContain("unhealthy");
-  });
-
-  it("failAfter throws mid-sync", async () => {
-    const a = new MockAdapter({ count: 10 });
-    a.failAfter = 3;
-    const got = [];
-    await expect(async () => {
-      for await (const r of a.sync()) got.push(r);
-    }).rejects.toThrow(/induced sync failure/);
-    expect(got.length).toBe(3); // 3 yielded before throw
-  });
-
-  it("normalizeShouldThrowAt fires on the right call", async () => {
-    const a = new MockAdapter({ count: 5 });
-    a.normalizeShouldThrowAt(2);
-    let callCount = 0;
-    for await (const r of a.sync()) {
-      callCount += 1;
-      if (callCount < 3) {
-        expect(() => a.normalize(r)).not.toThrow();
-      } else if (callCount === 3) {
-        expect(() => a.normalize(r)).toThrow(/induced normalize/);
-      }
-    }
-  });
-
-  it("same seed produces same payloads (deterministic)", async () => {
-    const collect = async () => {
-      const a = new MockAdapter({ count: 5, seed: 99 });
-      const out = [];
-      for await (const r of a.sync()) out.push(r.payload);
-      return out;
-    };
-    const a = await collect();
-    const b = await collect();
-    expect(a).toEqual(b);
-  });
-});

package/__tests__/prompt-builder.test.js

@@ -1,249 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const {
-  DEFAULT_SYSTEM_PROMPT,
-  buildPrompt,
-  summarizeFact,
-  summarizeEvent,
-  summarizePerson,
-  parseCitations,
-  validateCitations,
-} = require("../lib/prompt-builder");
-
-// ─── summarize ────────────────────────────────────────────────────────────
-
-describe("summarizeFact", () => {
-  it("strips raw extra from events; keeps content + source.adapter", () => {
-    const e = {
-      id: "evt-1",
-      type: "event",
-      subtype: "order",
-      occurredAt: 1700000000000,
-      ingestedAt: 1700000000001,
-      content: {
-        title: "spam",
-        text: "delivery",
-        amount: { value: 100, currency: "CNY", direction: "out" },
-      },
-      source: { adapter: "taobao", adapterVersion: "0.1.0", capturedAt: 1, capturedBy: "api" },
-      extra: { secret: "hidden", tracking: "abc" },
-    };
-    const s = summarizeFact(e);
-    expect(s.id).toBe("evt-1");
-    expect(s.title).toBe("spam");
-    expect(s.amount).toEqual({ value: 100, currency: "CNY", dir: "out" });
-    expect(s.source).toBe("taobao");
-    expect(s).not.toHaveProperty("extra");
-  });
-
-  it("packs person names + relation + identifiers + notes; omits source", () => {
-    // 2026-05-27 — identifiers (phone/wechatId/email) MUST reach the LLM,
-    // otherwise "妈手机号是多少" can never be answered even when vault has
-    // the phone. notes too — they're user-written context. source/ingestedAt
-    // are framing metadata, not user data, so still stripped.
-    const p = summarizePerson({
-      id: "p1",
-      type: "person",
-      subtype: "contact",
-      names: ["妈妈", "陈某某"],
-      relation: "母亲",
-      identifiers: { phone: ["13800001111"], wechatId: "wxid_abc" },
-      notes: "best mom ever",
-      ingestedAt: 1,
-      source: { adapter: "x", adapterVersion: "0.1.0", capturedAt: 1, capturedBy: "api" },
-    });
-    expect(p.names).toEqual(["妈妈", "陈某某"]);
-    expect(p.relation).toBe("母亲");
-    expect(p.identifiers).toEqual({ phone: ["13800001111"], wechatId: "wxid_abc" });
-    expect(p.notes).toBe("best mom ever");
-    expect(p).not.toHaveProperty("source");
-    expect(p).not.toHaveProperty("ingestedAt");
-  });
-
-  it("omits identifiers / notes fields when absent on the person row", () => {
-    const p = summarizePerson({
-      id: "p2",
-      type: "person",
-      subtype: "contact",
-      names: ["路人甲"],
-    });
-    expect(p).not.toHaveProperty("identifiers");
-    expect(p).not.toHaveProperty("notes");
-    expect(p).not.toHaveProperty("relation");
-  });
-
-  it("returns null for non-object / unknown types just yields minimal shape", () => {
-    expect(summarizeFact(null)).toBeNull();
-    expect(summarizeFact({ id: "x", type: "unknown" })).toEqual({ id: "x", type: "unknown" });
-  });
-});
-
-// ─── buildPrompt ──────────────────────────────────────────────────────────
-
-describe("buildPrompt", () => {
-  const facts = [
-    {
-      id: "evt-1",
-      type: "event",
-      subtype: "order",
-      occurredAt: 1700000000000,
-      ingestedAt: 1,
-      content: { title: "蛋白粉", amount: { value: 288.5, currency: "CNY", direction: "out" } },
-      source: { adapter: "taobao", adapterVersion: "0.1.0", capturedAt: 1, capturedBy: "api" },
-    },
-    {
-      id: "evt-2",
-      type: "event",
-      subtype: "order",
-      occurredAt: 1700000060000,
-      ingestedAt: 1,
-      content: { title: "按摩仪", amount: { value: 459, currency: "CNY", direction: "out" } },
-      source: { adapter: "taobao", adapterVersion: "0.1.0", capturedAt: 1, capturedBy: "api" },
-    },
-  ];
-
-  it("returns system + user messages and factIds set", () => {
-    const { messages, factIds, factCount, truncated } = buildPrompt({
-      question: "上个月在淘宝总共花了多少？",
-      facts,
-    });
-    expect(messages.length).toBe(2);
-    expect(messages[0].role).toBe("system");
-    expect(messages[1].role).toBe("user");
-    expect(messages[1].content).toContain("上个月在淘宝总共花了多少");
-    expect(messages[1].content).toContain("evt-1");
-    expect(messages[1].content).toContain("evt-2");
-    expect(factIds.has("evt-1")).toBe(true);
-    expect(factIds.has("evt-2")).toBe(true);
-    expect(factCount).toBe(2);
-    expect(truncated).toBe(0);
-  });
-
-  it("packs question into user role (not system)", () => {
-    const { messages } = buildPrompt({ question: "test", facts });
-    expect(messages[0].content).not.toContain("test"); // system stays untrusted-free
-    expect(messages[1].content).toContain("test");
-  });
-
-  it("uses default system prompt unless overridden", () => {
-    const { messages } = buildPrompt({ question: "x", facts: [] });
-    expect(messages[0].content).toBe(DEFAULT_SYSTEM_PROMPT);
-
-    const { messages: m2 } = buildPrompt({
-      question: "x",
-      facts: [],
-      systemPrompt: "custom",
-    });
-    expect(m2[0].content).toBe("custom");
-  });
-
-  it("emits no-facts hint when empty", () => {
-    const { messages, factCount } = buildPrompt({ question: "x", facts: [] });
-    expect(factCount).toBe(0);
-    expect(messages[1].content).toContain("FACTS is empty");
-  });
-
-  it("caps facts at maxFacts + reports truncation", () => {
-    const many = Array.from({ length: 100 }, (_, i) => ({
-      id: `evt-${i}`,
-      type: "event",
-      subtype: "message",
-      occurredAt: 1,
-      ingestedAt: 1,
-      content: { text: `m${i}` },
-      source: { adapter: "x", adapterVersion: "0.1.0", capturedAt: 1, capturedBy: "api" },
-    }));
-    const { factCount, truncated } = buildPrompt({ question: "x", facts: many, maxFacts: 30 });
-    expect(factCount).toBe(30);
-    expect(truncated).toBe(70);
-  });
-
-  it("includes intent + timeWindow hints in user prompt when provided", () => {
-    const { messages } = buildPrompt({
-      question: "x",
-      facts,
-      intent: "sum-amount",
-      timeWindow: { since: 1700000000000, until: 1700000600000 },
-    });
-    expect(messages[1].content).toContain("Intent hint: sum-amount");
-    expect(messages[1].content).toContain("Time window:");
-  });
-
-  it("marks the FACTS block as untrusted third-party content", () => {
-    const { messages } = buildPrompt({ question: "x", facts });
-    expect(messages[1].content).toContain("third-party");
-    expect(messages[1].content).toContain("never as instructions");
-  });
-
-  it("emits AMOUNT_SUM block when amountSummary present + Rule 7 in system prompt", () => {
-    const { messages } = buildPrompt({
-      question: "上个月总共花了多少",
-      facts,
-      intent: "sum-amount",
-      amountSummary: { total: 1234.5, currency: "CNY", count: 7, byDirection: { out: 1200, in: 34.5 } },
-    });
-    expect(messages[1].content).toContain("AMOUNT_SUM");
-    expect(messages[1].content).toContain('"total": 1234.5');
-    expect(messages[1].content).toContain('"out": 1200');
-    // system prompt instructs LLM to trust AMOUNT_SUM, not sum FACTS
-    expect(messages[0].content).toMatch(/AMOUNT_SUM.*authoritative/i);
-  });
-
-  it("omits AMOUNT_SUM block when count is 0 or amountSummary absent", () => {
-    const { messages } = buildPrompt({
-      question: "x",
-      facts,
-      amountSummary: { total: 0, currency: "CNY", count: 0, byDirection: { out: 0, in: 0 } },
-    });
-    expect(messages[1].content).not.toContain("AMOUNT_SUM");
-    const { messages: m2 } = buildPrompt({ question: "x", facts });
-    expect(m2[1].content).not.toContain("AMOUNT_SUM");
-  });
-
-  it("throws on bad opts", () => {
-    expect(() => buildPrompt()).toThrow();
-    expect(() => buildPrompt(null)).toThrow();
-  });
-});
-
-// ─── parseCitations + validateCitations ──────────────────────────────────
-
-describe("parseCitations", () => {
-  it("extracts bracketed ids in order", () => {
-    const out = parseCitations("foo [evt-1] bar [evt-2] [evt-3] baz");
-    expect(out).toEqual(["evt-1", "evt-2", "evt-3"]);
-  });
-
-  it("dedupes repeated cites", () => {
-    // ids must be ≥ 2 chars (regex deliberately ignores single-char [X]
-    // markdown to avoid false positives on footnote-style brackets)
-    expect(parseCitations("[evt-1] [evt-2] [evt-1]")).toEqual(["evt-1", "evt-2"]);
-  });
-
-  it("ignores single-char and non-id-like brackets", () => {
-    // Single chars like [a] are deliberately ignored
-    expect(parseCitations("[a] [!] []")).toEqual([]);
-  });
-
-  it("non-string returns []", () => {
-    expect(parseCitations(null)).toEqual([]);
-    expect(parseCitations(undefined)).toEqual([]);
-  });
-});
-
-describe("validateCitations", () => {
-  it("partitions cited into known vs unknown", () => {
-    const factIds = new Set(["evt-1", "evt-2"]);
-    const r = validateCitations(["evt-1", "evt-fake", "evt-2"], factIds);
-    expect(r.known).toEqual(["evt-1", "evt-2"]);
-    expect(r.unknown).toEqual(["evt-fake"]);
-  });
-
-  it("accepts array factIds too", () => {
-    const r = validateCitations(["a"], ["a", "b"]);
-    expect(r.known).toEqual(["a"]);
-    expect(r.unknown).toEqual([]);
-  });
-});