@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/integration/social-bilibili-pipeline.test.js

@@ -0,0 +1,261 @@
+"use strict";
+
+/**
+ * Integration test — A8 v0.1 Bilibili snapshot → vault pipeline.
+ *
+ * Exercises the full chain WITHOUT any real WebView / OkHttp / Android JNI:
+ *
+ *   Synthetic snapshot JSON (4 kinds)
+ *      ↓
+ *   AdapterRegistry (real) + LocalVault (real, SQLCipher)
+ *      ↓
+ *   adapter.sync({ inputPath }) → _syncViaSnapshot yields raw events
+ *      ↓
+ *   registry.putRawEvent → vault.raw_events
+ *      ↓
+ *   adapter.normalize(raw) → batch
+ *      ↓
+ *   vault.putBatch → events / persons / places / items / topics tables
+ *
+ * Two scenarios:
+ *   A. happy path — 4-kind snapshot ingests; vault yields exact counts;
+ *      KG triples derive; originalId stable across re-sync (idempotency)
+ *   B. partial snapshot — only history + follow; vault gets correct subset
+ *
+ * Win note: bs3mc has a known NODE_MODULE_VERSION mismatch on this dev box
+ * (Node 22.22.2 ABI v127 vs prebuild ABI v140); test passes on CI Linux
+ * which uses the matched prebuild. See memory pdh-plan-a-android-standalone-
+ * design §"bs3mc NODE_MODULE_VERSION mismatch".
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  LocalVault,
+  generateKeyHex,
+  AdapterRegistry,
+} = require("../../lib");
+const {
+  BilibiliAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-bilibili");
+
+function makeRig() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-int-"));
+  const vault = new LocalVault({ path: path.join(dir, "v.db"), key: generateKeyHex() });
+  vault.open();
+  const registry = new AdapterRegistry({ vault });
+  return { vault, registry, dir };
+}
+
+function cleanup(rig) {
+  if (!rig) return;
+  try { rig.vault.close(); } catch (_e) { /* noop */ }
+  try { fs.rmSync(rig.dir, { recursive: true, force: true }); } catch (_e) { /* noop */ }
+}
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-bilibili.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+function sampleSnapshot(opts = {}) {
+  const include = {
+    history: true,
+    favourite: true,
+    dynamic: true,
+    follow: true,
+    ...opts.include,
+  };
+  const events = [];
+  if (include.history) {
+    events.push({
+      kind: "history",
+      id: "BV1abc",
+      capturedAt: 1715000000000,
+      title: "Rust 异步学习",
+      bvid: "BV1abc",
+      avid: 42,
+      duration: 600,
+      uploader: "技术UP主",
+      uploaderMid: 100,
+      part: "01 介绍",
+    });
+  }
+  if (include.favourite) {
+    events.push({
+      kind: "favourite",
+      id: "fav-BV2def",
+      capturedAt: 1714000000000,
+      title: "前端架构",
+      bvid: "BV2def",
+      folderName: "学习",
+      uploader: "码农UP",
+    });
+  }
+  if (include.dynamic) {
+    events.push({
+      kind: "dynamic",
+      id: "dyn-99",
+      capturedAt: 1713000000000,
+      summary: "今天发了一个新视频",
+      dynamicType: "av",
+      rid: "99",
+      authorMid: 200,
+      authorName: "我关注的UP",
+    });
+  }
+  if (include.follow) {
+    events.push({
+      kind: "follow",
+      id: "follow-300",
+      capturedAt: 1712000000000,
+      mid: 300,
+      uname: "美食UP",
+      face: "https://i0.hdslb.com/300.jpg",
+      sign: "好吃的视频",
+    });
+  }
+  return {
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    snapshottedAt: 1716000000000,
+    account: { uid: "12345", displayName: "alice" },
+    events,
+  };
+}
+
+describe("Integration — A8 Bilibili snapshot → vault end-to-end", () => {
+  let rig;
+  afterEach(() => { cleanup(rig); rig = null; });
+
+  it("4 kinds ingest into vault with exact entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+
+    // 3 events (history + favourite + dynamic) + 1 person (follow) +
+    // 2 items (history-video + favourite-video)
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(3);
+    expect(report.entityCounts.persons).toBe(1);
+    expect(report.entityCounts.items).toBe(2);
+
+    // Vault round-trip
+    const events = rig.vault.queryEvents({ limit: 100 });
+    expect(events).toHaveLength(3);
+    const subtypes = events.map((e) => e.subtype).sort();
+    expect(subtypes).toEqual(["browse", "browse", "like"]); // history+dynamic+favourite
+
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+    expect(persons[0].names[0]).toBe("美食UP");
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.name).sort()).toEqual(["Rust 异步学习", "前端架构"]);
+  });
+
+  it("re-sync is idempotent — same snapshot twice does NOT double entities", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+
+    // First sync
+    const report1 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report1.status).toBe("ok");
+
+    // Second sync — same snapshot
+    const report2 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report2.status).toBe("ok");
+
+    // Stable originalId means re-sync de-dups at raw_events layer.
+    // The person/item entities should remain at 1 / 2 respectively
+    // because their IDs derive from bvid / mid (stable). Events can
+    // legitimately double-write because each "browse" is a separate
+    // occurrence — registry doesn't dedup events.
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    // Items with same bvid produce same ID, so item table stays at 2
+    // (UPSERT semantics via primary-key id).
+    expect(items).toHaveLength(2);
+  });
+
+  it("partial snapshot (history + follow only) yields exact subset", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(
+      rig.dir,
+      sampleSnapshot({ include: { favourite: false, dynamic: false } })
+    );
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(1); // history only
+    expect(report.entityCounts.persons).toBe(1); // follow
+    expect(report.entityCounts.items).toBe(1); // history video
+  });
+
+  it("empty events array → ok status with 0 entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(0);
+    expect(report.entityCounts.persons).toBe(0);
+    expect(report.entityCounts.items).toBe(0);
+  });
+
+  it("schemaVersion mismatch surfaces in SyncReport.error (not silent)", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: 99, // wrong
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("error");
+    expect(String(report.error)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("registry queryable by adapter.name after register()", () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    expect(rig.registry.has("social-bilibili")).toBe(true);
+    expect(rig.registry.list().some((m) => m.name === "social-bilibili")).toBe(true);
+  });
+});

package/__tests__/integration/wechat-bootstrap-end-to-end.test.js

@@ -0,0 +1,390 @@
+/**
+ * WeChat Phase 12.6.7-10 end-to-end integration test.
+ *
+ * Exercises the full chain WITHOUT any real adb / Frida / device:
+ *
+ *   env-probe (injected facts)
+ *      ↓
+ *   bootstrap.js (KeyProvider choice + adapter ctor)
+ *      ↓
+ *   AdapterRegistry (real, in-memory)
+ *      ↓
+ *   wechat-accounts.json persistence (real fs, temp dir)
+ *      ↓
+ *   list / unregister flow
+ *
+ * Three scenarios:
+ *   A. md5 happy path — pre-WeChat-8 device:
+ *        probe="md5" → wechatDataPath provided → register OK →
+ *        registry has "wechat" adapter → persisted row chosenKeyProvider="md5"
+ *        → unregister → row removed + registry empty
+ *   B. frida happy path — rooted 8.0+ device:
+ *        probe="frida" + root + frida-server up → register OK →
+ *        chosenKeyProvider="frida" → persisted row reflects choice
+ *   C. unsupported path — 8.0+ without root:
+ *        probe="unsupported" → bootstrap rejects → no registry change,
+ *        no row written, ok:false with reasons surfaced
+ *   D. idempotent re-register — same uin twice:
+ *        first registration with wechatDataPath A, second with B →
+ *        single row remains, wechatDataPath=B (replaces, doesn't dupe)
+ */
+
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const {
+  bootstrapWechatAdapter,
+} = require("../../lib/adapters/wechat/bootstrap");
+const { AdapterRegistry } = require("../../lib/registry");
+const { LocalVault } = require("../../lib/vault");
+const { InMemoryKeyProvider } = require("../../lib/key-providers");
+const { generateKeyHex } = require("../../lib/key-providers");
+
+// Mirror of the hub-side store helpers so the integration test exercises
+// the same persistence shape both desktop + cli wirings use.
+const { readFileSync, writeFileSync, existsSync } = require("node:fs");
+function loadWechatAccounts(filePath) {
+  try {
+    if (!existsSync(filePath)) return [];
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (_e) {
+    return [];
+  }
+}
+function saveWechatAccounts(filePath, accounts) {
+  writeFileSync(filePath, JSON.stringify(accounts, null, 2), {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+}
+
+function mkProbe(overrides = {}) {
+  return {
+    ok: true,
+    suggestedKeyProvider: "md5",
+    reasons: ["WeChat 7.0.22 (< 8.0) — legacy MD5(IMEI+UIN) path supported"],
+    device: { reachable: true, serial: "INTEG_TEST", abi: "arm64-v8a" },
+    root: { detected: false, magiskInstalled: false },
+    frida: { serverRunning: false, port: null },
+    wechat: { installed: true, versionName: "7.0.22", majorVersion: 7 },
+    warnings: [],
+    ...overrides,
+  };
+}
+
+// Replay the wiring's registerWechatAdapter() inline — mirroring the
+// closure on the real hub object — so the integration test exercises
+// the exact code path the IPC/WS layer drives in production.
+async function registerWechatViaHub({ registry, hubDir, opts }) {
+  const r = await bootstrapWechatAdapter(opts);
+  if (!r.ok) return r;
+
+  if (registry.has(r.adapter.name)) registry.unregister(r.adapter.name);
+  registry.register(r.adapter);
+
+  const accountsPath = join(hubDir, "wechat-accounts.json");
+  const accounts = loadWechatAccounts(accountsPath);
+  const next = accounts.filter(
+    (c) => !(c.account && c.account.uin === opts.account.uin),
+  );
+  next.push({
+    account: { uin: opts.account.uin },
+    dbPath: opts.dbPath || null,
+    wechatDataPath: opts.wechatDataPath || null,
+    chosenKeyProvider: r.keyProvider && r.keyProvider.name,
+    registeredAt: Date.now(),
+    lastSyncAt: null,
+  });
+  saveWechatAccounts(accountsPath, next);
+
+  return {
+    ok: true,
+    name: r.adapter.name,
+    chosenKeyProvider: r.keyProvider.name,
+    probe: r.probe,
+  };
+}
+
+async function unregisterWechatViaHub({ registry, hubDir, uin }) {
+  const accountsPath = join(hubDir, "wechat-accounts.json");
+  const accounts = loadWechatAccounts(accountsPath);
+  const target = accounts.find((c) => c.account && c.account.uin === uin);
+  const next = accounts.filter(
+    (c) => !(c.account && c.account.uin === uin),
+  );
+  saveWechatAccounts(accountsPath, next);
+  if (target && registry.has("wechat")) registry.unregister("wechat");
+  return { ok: true, removed: !!target, uin };
+}
+
+function listWechatViaHub({ hubDir }) {
+  return loadWechatAccounts(join(hubDir, "wechat-accounts.json")).map((row) => ({
+    uin: row.account ? row.account.uin : null,
+    dbPath: row.dbPath || null,
+    hasWechatDataPath: !!row.wechatDataPath,
+    chosenKeyProvider: row.chosenKeyProvider || null,
+    registeredAt: row.registeredAt || null,
+  }));
+}
+
+describe("WeChat Phase 12.6.7-10 — end-to-end integration", () => {
+  let hubDir;
+  let dataDir;
+  let registry;
+
+  beforeEach(() => {
+    hubDir = mkdtempSync(join(tmpdir(), "pdh-wechat-integ-"));
+    dataDir = mkdtempSync(join(tmpdir(), "pdh-wechat-data-"));
+
+    // A real registry without vault/sinks — we don't sync, just
+    // register/unregister. Phase 12.6.7 boundary: bootstrap doesn't
+    // touch the registry, the wiring does (replicated above).
+    const vault = new LocalVault({
+      path: join(hubDir, "vault.db"),
+      key: generateKeyHex(),
+    });
+    vault.open();
+    registry = new AdapterRegistry({ vault });
+  });
+
+  afterEach(() => {
+    try { rmSync(hubDir, { recursive: true, force: true }); } catch (_e) {}
+    try { rmSync(dataDir, { recursive: true, force: true }); } catch (_e) {}
+  });
+
+  describe("A. md5 happy path — pre-WeChat-8 device", () => {
+    it("probe → register → adapter in registry + row persisted with md5 provider", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "1234567890" },
+          wechatDataPath: dataDir,
+          _probe: mkProbe(),
+        },
+      });
+
+      // Bootstrap chain succeeded
+      expect(r.ok).toBe(true);
+      expect(r.chosenKeyProvider).toBe("md5");
+      expect(r.name).toBe("wechat");
+      expect(r.probe.suggestedKeyProvider).toBe("md5");
+
+      // Registry picked up the adapter
+      expect(registry.has("wechat")).toBe(true);
+      const adapter = registry.get("wechat");
+      expect(adapter.account.uin).toBe("1234567890");
+
+      // Persistence reflects choice
+      const list = listWechatViaHub({ hubDir });
+      expect(list).toHaveLength(1);
+      expect(list[0]).toMatchObject({
+        uin: "1234567890",
+        chosenKeyProvider: "md5",
+        hasWechatDataPath: true,
+      });
+    });
+
+    it("unregister removes row + drops registry entry", async () => {
+      await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "1234567890" },
+          wechatDataPath: dataDir,
+          _probe: mkProbe(),
+        },
+      });
+      expect(registry.has("wechat")).toBe(true);
+
+      const ur = await unregisterWechatViaHub({
+        registry,
+        hubDir,
+        uin: "1234567890",
+      });
+      expect(ur).toMatchObject({ ok: true, removed: true });
+      expect(registry.has("wechat")).toBe(false);
+      expect(listWechatViaHub({ hubDir })).toEqual([]);
+    });
+  });
+
+  describe("B. frida happy path — rooted 8.0+ device", () => {
+    it("probe='frida' + root yields FridaKeyProvider in persisted row", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "wxid_alice" },
+          _probe: mkProbe({
+            suggestedKeyProvider: "frida",
+            wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+            root: { detected: true, magiskInstalled: true },
+            frida: { serverRunning: true, port: 27042 },
+            reasons: ["WeChat 8.0.50 — Frida hook on libwcdb.so"],
+          }),
+        },
+      });
+      expect(r.ok).toBe(true);
+      expect(r.chosenKeyProvider).toBe("frida");
+      expect(registry.has("wechat")).toBe(true);
+
+      const list = listWechatViaHub({ hubDir });
+      expect(list[0].chosenKeyProvider).toBe("frida");
+      // Frida path doesn't require wechatDataPath
+      expect(list[0].hasWechatDataPath).toBe(false);
+    });
+  });
+
+  describe("C. unsupported path", () => {
+    it("8.0+ without root → no registry change, no row, ok:false with reasons", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "wxid_bob" },
+          _probe: mkProbe({
+            ok: false,
+            suggestedKeyProvider: "unsupported",
+            reasons: [
+              "WeChat 8.0.50 requires root for SQLCipher key extraction",
+            ],
+            wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+            root: { detected: false, magiskInstalled: false },
+          }),
+        },
+      });
+      expect(r.ok).toBe(false);
+      expect(r.reason).toBe("ENV_UNSUPPORTED");
+      expect(r.probe.reasons.join(" ")).toMatch(/requires root/);
+
+      expect(registry.has("wechat")).toBe(false);
+      expect(listWechatViaHub({ hubDir })).toEqual([]);
+    });
+
+    it("md5 path missing wechatDataPath → ok:false MD5_NEEDS_WECHAT_DATA_PATH", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "1234567890" },
+          _probe: mkProbe(),
+          // wechatDataPath intentionally omitted
+        },
+      });
+      expect(r.ok).toBe(false);
+      expect(r.reason).toBe("MD5_NEEDS_WECHAT_DATA_PATH");
+      expect(registry.has("wechat")).toBe(false);
+    });
+  });
+
+  describe("D. idempotent re-register", () => {
+    it("same uin twice → single row, latest wechatDataPath wins", async () => {
+      const dataA = mkdtempSync(join(tmpdir(), "pdh-wechat-dataA-"));
+      const dataB = mkdtempSync(join(tmpdir(), "pdh-wechat-dataB-"));
+      try {
+        await registerWechatViaHub({
+          registry,
+          hubDir,
+          opts: {
+            account: { uin: "1234567890" },
+            wechatDataPath: dataA,
+            _probe: mkProbe(),
+          },
+        });
+        await registerWechatViaHub({
+          registry,
+          hubDir,
+          opts: {
+            account: { uin: "1234567890" },
+            wechatDataPath: dataB,
+            _probe: mkProbe(),
+          },
+        });
+
+        const list = listWechatViaHub({ hubDir });
+        expect(list).toHaveLength(1);
+        expect(list[0].uin).toBe("1234567890");
+        expect(registry.has("wechat")).toBe(true);
+
+        // Adapter's _dbPath is null in both calls (we didn't pass dbPath),
+        // but the persisted row uses the latest wechatDataPath.
+        const raw = readFileSync(
+          join(hubDir, "wechat-accounts.json"),
+          "utf-8",
+        );
+        const persisted = JSON.parse(raw);
+        expect(persisted[0].wechatDataPath).toBe(dataB);
+      } finally {
+        try { rmSync(dataA, { recursive: true, force: true }); } catch (_e) {}
+        try { rmSync(dataB, { recursive: true, force: true }); } catch (_e) {}
+      }
+    });
+
+    it("two distinct uins coexist as separate rows", async () => {
+      await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: { account: { uin: "alice" }, wechatDataPath: dataDir, _probe: mkProbe() },
+      });
+      await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: { account: { uin: "bob" }, wechatDataPath: dataDir, _probe: mkProbe() },
+      });
+
+      const list = listWechatViaHub({ hubDir });
+      expect(list.map((r) => r.uin).sort()).toEqual(["alice", "bob"]);
+      // Single registry slot named "wechat" — second register replaces first
+      // adapter instance, but registry still has exactly one entry. This is
+      // the v0.5 limit: the registry namespaces by adapter.name not by uin.
+      // The persisted accounts file is the source of truth for "which uins
+      // can sync"; bootstrap re-runs at sync time per account.
+      expect(registry.has("wechat")).toBe(true);
+    });
+  });
+
+  describe("override semantics (Phase 12.6.7 §18.10)", () => {
+    it("keyProviderOverride='frida' wins over probe='md5'", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "wxid_force" },
+          keyProviderOverride: "frida",
+          _probe: mkProbe(), // suggests md5
+        },
+      });
+      expect(r.ok).toBe(true);
+      expect(r.chosenKeyProvider).toBe("frida");
+      // Probe transparency: original suggestion still surfaces unchanged
+      expect(r.probe.suggestedKeyProvider).toBe("md5");
+    });
+
+    it("keyProviderOverride='md5' wins over probe='frida'", async () => {
+      const r = await registerWechatViaHub({
+        registry,
+        hubDir,
+        opts: {
+          account: { uin: "1234567890" },
+          wechatDataPath: dataDir,
+          keyProviderOverride: "md5",
+          _probe: mkProbe({
+            suggestedKeyProvider: "frida",
+            wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+            root: { detected: true, magiskInstalled: true },
+            frida: { serverRunning: true, port: 27042 },
+          }),
+        },
+      });
+      expect(r.ok).toBe(true);
+      expect(r.chosenKeyProvider).toBe("md5");
+      expect(r.probe.suggestedKeyProvider).toBe("frida");
+    });
+  });
+});

package/__tests__/registry.test.js

@@ -178,7 +178,9 @@ describe("AdapterRegistry.syncAdapter", () => {
   it("refuses concurrent sync of two adapters in one registry", async () => {
     freshVault();
     const reg = new AdapterRegistry({ vault });
-    reg.register(new MockAdapter({ name: "a", count: 5000 })); // long enough to be in-flight
+    // Use 500 events (not 5000) — still big enough to be mid-flight when
+    // the second syncAdapter() lands, but fits comfortably in 10s.
+    reg.register(new MockAdapter({ name: "a", count: 500 }));
     reg.register(new MockAdapter({ name: "b", count: 5 }));
 
     const p1 = reg.syncAdapter("a");
@@ -194,7 +196,7 @@ describe("AdapterRegistry.syncAdapter", () => {
     // assert no double-sync corruption. The active-sync invariant is
     // additionally enforced by the activeSync flag.
     expect(racedReject == null || /already syncing/.test(racedReject.message)).toBe(true);
-  });
+  }, 30_000);
 });
 
 // ─── KG + RAG sinks ──────────────────────────────────────────────────────