@chainlesschain/personal-data-hub 0.2.1 → 0.2.3

package/__tests__/travel-maps-snapshot.test.js

@@ -0,0 +1,426 @@
+"use strict";
+
+import { describe, it, expect, beforeEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  BaiduMapAdapter,
+  SNAPSHOT_SCHEMA_VERSION: BAIDU_VERSION,
+} = require("../lib/adapters/travel-baidu-map");
+const {
+  TencentMapAdapter,
+  SNAPSHOT_SCHEMA_VERSION: TENCENT_VERSION,
+} = require("../lib/adapters/travel-tencent-map");
+const { validateBatch } = require("../lib/batch");
+
+// §2.5b 地图三联 v0.2 — snapshot-mode tests, mirror of social-weibo-snapshot
+// & social-bilibili-snapshot patterns.
+//
+// Snapshot mode is in-APK Android cc reading JSON written by the
+// {Baidu,Tencent}MapLocalCollector (WebView cookie scrape). Sqlite/device-pull
+// tests remain in travel-adapters.test.js. Three kinds: favourite / search /
+// route — all 3 reuse normalizeTravelRecord via on-the-fly TravelRecord build.
+
+function writeSnapshot(dir, fileName, snapshot) {
+  const p = path.join(dir, fileName);
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("BaiduMapAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "baidu-map-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1", () => {
+    expect(BAIDU_VERSION).toBe(1);
+  });
+
+  it("authenticate(inputPath) ok when readable + mode=snapshot-file", async () => {
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BaiduMapAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate(inputPath) fails when path unreadable", async () => {
+    const a = new BaiduMapAdapter();
+    const res = await a.authenticate({ inputPath: path.join(tmpDir, "missing.json") });
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("INPUT_PATH_UNREADABLE");
+  });
+
+  it("authenticate() with neither inputPath nor dbPath returns NO_INPUT", async () => {
+    const a = new BaiduMapAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("authenticate(dbPath) without account.deviceId returns NO_ACCOUNT_DEVICE_ID", async () => {
+    const a = new BaiduMapAdapter({ dbPath: path.join(tmpDir, "fake.db") });
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_ACCOUNT_DEVICE_ID");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BaiduMapAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("empty events array yields nothing (no crash)", async () => {
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(0);
+  });
+
+  it("favourite + search + route round-trip normalize cleanly", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      vendor: "baidu-map",
+      account: { uid: "12345", displayName: "alice" },
+      events: [
+        {
+          kind: "favourite",
+          id: "fav-R1",
+          capturedAt: now - 1000,
+          name: "公司",
+          address: "厦门市象屿路 93 号",
+          lat: 24.4781,
+          lng: 118.0894,
+          category: "company",
+        },
+        {
+          kind: "search",
+          id: "search-S1",
+          capturedAt: now - 2000,
+          query: "鼓浪屿",
+          city: "厦门",
+        },
+        {
+          kind: "route",
+          id: "route-RT1",
+          capturedAt: now - 3000,
+          from: { name: "厦门北站", lat: 24.6, lng: 118.0 },
+          to: { name: "厦门大学", lat: 24.43, lng: 118.09 },
+          mode: "drive",
+        },
+      ],
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(3);
+
+    const kinds = raws.map((r) => r.kind);
+    expect(kinds).toEqual(["favourite", "search", "route"]);
+
+    // Each originalId namespaced under baidu-map:<kind>:<id>
+    expect(raws[0].originalId).toMatch(/^baidu-map:favourite:/);
+    expect(raws[1].originalId).toMatch(/^baidu-map:search:/);
+    expect(raws[2].originalId).toMatch(/^baidu-map:route:/);
+
+    // Normalize each + validate
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      expect(validateBatch(batch).valid).toBe(true);
+    }
+
+    // Favourite: visit-type trip event + 1 place (to) + carrier merchant
+    const favBatch = a.normalize(raws[0]);
+    expect(favBatch.events.length).toBe(1);
+    expect(favBatch.events[0].subtype).toBe("trip");
+    // The to-place name flows through as the trip's destination
+    // (Place uses singular `name`; aliases array for redundant labels)
+    const favToPlace = favBatch.places.find(
+      (pl) => pl.name === "公司" || (pl.aliases && pl.aliases.includes("公司")),
+    );
+    expect(favToPlace).toBeTruthy();
+
+    // Route: from/to places (2) + carrier merchant
+    const routeBatch = a.normalize(raws[2]);
+    expect(routeBatch.places.length).toBeGreaterThanOrEqual(2);
+
+    // Carrier always "百度地图"
+    const allBatches = raws.map((r) => a.normalize(r));
+    const carriers = allBatches.flatMap((b) =>
+      b.persons.filter((p) => p.names.includes("百度地图")),
+    );
+    expect(carriers.length).toBe(3);
+  });
+
+  it("respects per-kind include opt-out", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "favourite", id: "f1", capturedAt: now, name: "家", lat: 24, lng: 118 },
+        { kind: "search", id: "s1", capturedAt: now, query: "餐厅" },
+        { kind: "route", id: "r1", capturedAt: now, from: { name: "A" }, to: { name: "B" }, mode: "walk" },
+      ],
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { search: false } })) {
+      raws.push(r);
+    }
+    const kinds = raws.map((r) => r.kind);
+    expect(kinds).toEqual(["favourite", "route"]);
+  });
+
+  it("respects opts.limit", async () => {
+    const now = Date.now();
+    const events = Array.from({ length: 5 }, (_, i) => ({
+      kind: "favourite",
+      id: `f${i}`,
+      capturedAt: now - i * 100,
+      name: `place-${i}`,
+      lat: 24,
+      lng: 118,
+    }));
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events,
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
+    expect(raws.length).toBe(2);
+  });
+
+  it("filters out unknown kinds (forward compat)", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "favourite", id: "f1", capturedAt: now, name: "ok", lat: 1, lng: 2 },
+        { kind: "future-kind", id: "x", capturedAt: now },
+        { kind: "trip-summary", id: "ts", capturedAt: now }, // hypothetical future
+      ],
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("favourite");
+  });
+
+  it("snapshottedAt fallback when event capturedAt missing", async () => {
+    const ts = 1700000000000;
+    const p = writeSnapshot(tmpDir, "travel-baidu-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: ts,
+      events: [
+        { kind: "favourite", id: "f1", name: "no time", lat: 1, lng: 2 },
+      ],
+    });
+    const a = new BaiduMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws[0].capturedAt).toBe(ts);
+  });
+
+  it("sync() without inputPath OR dbPath throws", async () => {
+    const a = new BaiduMapAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({})) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/needs opts.inputPath/);
+  });
+
+  it("snapshot mode does NOT require account.deviceId at construction", () => {
+    // The whole point of snapshot mode: stateless adapter, account from snapshot
+    expect(() => new BaiduMapAdapter()).not.toThrow();
+    expect(() => new BaiduMapAdapter({})).not.toThrow();
+  });
+});
+
+describe("TencentMapAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tencent-map-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1", () => {
+    expect(TENCENT_VERSION).toBe(1);
+  });
+
+  it("constructor allows missing account (stateless snapshot mode)", () => {
+    expect(() => new TencentMapAdapter()).not.toThrow();
+    expect(() => new TencentMapAdapter({})).not.toThrow();
+  });
+
+  it("authenticate(inputPath) ok", async () => {
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new TencentMapAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate(dbPath) without deviceId returns NO_ACCOUNT_DEVICE_ID", async () => {
+    const a = new TencentMapAdapter({ dbPath: "/tmp/fake.db" });
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_ACCOUNT_DEVICE_ID");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new TencentMapAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("favourite + route normalize cleanly with carrier=腾讯地图", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      vendor: "tencent-map",
+      account: { uid: "qq-12345", displayName: "alice" },
+      events: [
+        {
+          kind: "favourite",
+          id: "fav-T1",
+          capturedAt: now - 1000,
+          name: "公司",
+          address: "广州市天河区珠江新城",
+          lat: 23.12,
+          lng: 113.32,
+          category: "company",
+        },
+        {
+          kind: "route",
+          id: "route-T1",
+          capturedAt: now - 2000,
+          from: { name: "广州南站", lat: 22.99, lng: 113.27 },
+          to: { name: "天河客运站", lat: 23.16, lng: 113.36 },
+          mode: "transit",
+        },
+      ],
+    });
+    const a = new TencentMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(2);
+
+    expect(raws[0].originalId).toMatch(/^tencent-map:favourite:/);
+    expect(raws[1].originalId).toMatch(/^tencent-map:route:/);
+
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      expect(validateBatch(batch).valid).toBe(true);
+    }
+
+    // Carrier must be 腾讯地图 (not 百度地图 or 高德地图 — paranoid catch
+    // copy-paste regression)
+    const allBatches = raws.map((r) => a.normalize(r));
+    for (const b of allBatches) {
+      const tencentCarrier = b.persons.find((p) => p.names.includes("腾讯地图"));
+      expect(tencentCarrier).toBeTruthy();
+      expect(b.persons.find((p) => p.names.includes("百度地图"))).toBeFalsy();
+      expect(b.persons.find((p) => p.names.includes("高德地图"))).toBeFalsy();
+    }
+
+    // Route mode "transit" maps to bus
+    const routeBatch = a.normalize(raws[1]);
+    const tripEvent = routeBatch.events[0];
+    expect(tripEvent.extra.vehicleType).toBe("bus");
+  });
+
+  it("empty events array yields nothing", async () => {
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new TencentMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(0);
+  });
+
+  it("filters unknown kinds", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "favourite", id: "f1", capturedAt: now, name: "ok", lat: 1, lng: 2 },
+        { kind: "speculative-future", id: "x", capturedAt: now },
+      ],
+    });
+    const a = new TencentMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("favourite");
+  });
+
+  it("snapshottedAt fallback when event capturedAt missing", async () => {
+    const ts = 1700000000000;
+    const p = writeSnapshot(tmpDir, "travel-tencent-map.json", {
+      schemaVersion: 1,
+      snapshottedAt: ts,
+      events: [
+        { kind: "favourite", id: "f1", name: "no time", lat: 1, lng: 2 },
+      ],
+    });
+    const a = new TencentMapAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws[0].capturedAt).toBe(ts);
+  });
+});

package/__tests__/vault-driver-error.test.js

@@ -0,0 +1,74 @@
+/**
+ * Unit tests for formatDriverLoadError — the pure error-translation helper
+ * sitting in front of `require("better-sqlite3-multiple-ciphers")`.
+ *
+ * Why this matters: bs3mc upstream only ships prebuilds for Node LTS ABIs
+ * (108/115/127). Running cc / PDH on Node 23/24/25 throws a cryptic
+ * "NODE_MODULE_VERSION X / requires NODE_MODULE_VERSION Y" stack that
+ * buries the real fix (use Node 22 LTS). This helper translates that into
+ * actionable Chinese guidance. See memory `node_23_native_dep_trap.md`.
+ */
+
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  _internal: { formatDriverLoadError },
+} = require("../lib/vault");
+
+describe("formatDriverLoadError", () => {
+  it("detects ABI mismatch and emits actionable Chinese guidance", () => {
+    const original = new Error(
+      "The module '\\\\?\\C:\\code\\chainlesschain\\node_modules\\better-sqlite3-multiple-ciphers\\build\\Release\\better_sqlite3.node'\n" +
+        "was compiled against a different Node.js version using\n" +
+        "NODE_MODULE_VERSION 140. This version of Node.js requires\n" +
+        "NODE_MODULE_VERSION 127. Please try re-compiling or re-installing\n" +
+        "the module (for instance, using `npm rebuild` or `npm install`).",
+    );
+    const wrapped = formatDriverLoadError(original, "v24.0.1");
+    expect(wrapped.code).toBe("BS3MC_ABI_MISMATCH");
+    expect(wrapped.cause).toBe(original);
+    expect(wrapped.message).toMatch(/Node v24\.0\.1 has ABI 127/);
+    expect(wrapped.message).toMatch(/bs3mc prebuild is ABI 140/);
+    expect(wrapped.message).toMatch(/切 Node 22 LTS/);
+    expect(wrapped.message).toMatch(/nvm install 22\.12\.0/);
+    expect(wrapped.message).toMatch(/npm rebuild better-sqlite3-multiple-ciphers/);
+  });
+
+  it("falls back to generic message when error is not ABI-related", () => {
+    const original = new Error("ENOENT: no such file or directory");
+    const wrapped = formatDriverLoadError(original, "v22.12.0");
+    expect(wrapped.code).toBeUndefined();
+    expect(wrapped.cause).toBe(original);
+    expect(wrapped.message).toMatch(/Failed to load better-sqlite3-multiple-ciphers/);
+    expect(wrapped.message).toMatch(/ENOENT: no such file or directory/);
+  });
+
+  it("handles non-Error throw values (string / null)", () => {
+    const wrapped1 = formatDriverLoadError("plain string", "v22.12.0");
+    expect(wrapped1.message).toMatch(/Original error: plain string/);
+
+    const wrapped2 = formatDriverLoadError(null, "v22.12.0");
+    expect(wrapped2.message).toMatch(/Original error: null/);
+  });
+
+  it("uses process.versions.node when nodeVer omitted", () => {
+    const original = new Error(
+      "NODE_MODULE_VERSION 200. requires NODE_MODULE_VERSION 127.",
+    );
+    const wrapped = formatDriverLoadError(original);
+    expect(wrapped.code).toBe("BS3MC_ABI_MISMATCH");
+    expect(wrapped.message).toContain(process.versions.node);
+  });
+
+  it("preserves ABI numbers from the original error message in the rewritten body", () => {
+    const original = new Error(
+      "NODE_MODULE_VERSION 137. requires NODE_MODULE_VERSION 131.",
+    );
+    const wrapped = formatDriverLoadError(original, "v23.7.0");
+    expect(wrapped.message).toContain("ABI 131");
+    expect(wrapped.message).toContain("ABI 137");
+    expect(wrapped.message).toContain("v23.7.0");
+  });
+});

package/__tests__/wechat-adapter.test.js

@@ -331,6 +331,29 @@ describe("normalizeWeChatContact", () => {
     const b = normalizeWeChatContact({});
     expect(b.persons).toHaveLength(0);
   });
+
+  // sjqz parity audit follow-up (post-Phase 12.6.10) — classify
+  // 公众号 / Official Accounts (gh_*) as merchant subtype so the Ask
+  // flow / EntityResolver can filter them out of human contacts.
+  it("gh_* username → subtype merchant (公众号 / Official Account)", () => {
+    const b = normalizeWeChatContact({
+      username: "gh_abc123def",
+      nickname: "某品牌官方",
+      type: 3,
+    });
+    expect(b.persons).toHaveLength(1);
+    expect(b.persons[0].subtype).toBe("merchant");
+    expect(b.persons[0].identifiers.wechatId).toBe("gh_abc123def");
+  });
+
+  it("regular wxid_* → subtype contact (default)", () => {
+    const b = normalizeWeChatContact({
+      username: "wxid_realfriend",
+      nickname: "好友",
+      type: 1,
+    });
+    expect(b.persons[0].subtype).toBe("contact");
+  });
 });
 
 // ─── WechatAdapter contract + sync flow ──────────────────────────────────
@@ -441,6 +464,101 @@ describe("WechatAdapter.sync with mocked DB reader", () => {
     }
   });
 
+  // sjqz parity audit follow-up — fetchContacts must exclude
+   // @stranger and fake_* by default (vault pollution prevention).
+  it("fetchContacts excludes @stranger and fake_* by default", async () => {
+    // Pure DI smoke — capture the SQL passed to .prepare() to verify the
+    // junk filter is in the query. We mock just enough of better-sqlite3's
+    // shape: db.prepare(sql) → { all(limit) → rows }, exec, pragma.
+    const seenSql = [];
+    const fakeDriver = function Database(_path, _opts) {
+      return {
+        pragma: () => undefined,
+        exec: () => undefined,
+        prepare(sql) {
+          seenSql.push(sql);
+          return {
+            all: () => {
+              if (sql.startsWith("PRAGMA table_info")) {
+                return [
+                  { name: "username" },
+                  { name: "alias" },
+                  { name: "nickname" },
+                  { name: "conRemark" },
+                  { name: "type" },
+                ];
+              }
+              if (sql.startsWith("SELECT count")) return [{ n: 5 }];
+              if (sql.includes("FROM rcontact")) return [];
+              return [];
+            },
+            get: () => ({ n: 5 }),
+          };
+        },
+        close: () => undefined,
+      };
+    };
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "wechat-junkfilt-"));
+    const dbPath = path.join(dir, "EnMicroMsg.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const reader = new WeChatDBReader({
+        dbPath,
+        keyProvider: { getKey: async () => "0".repeat(64) },
+        driver: fakeDriver,
+      });
+      await reader.open();
+      reader.fetchContacts({ limit: 100 });
+      const contactsSql = seenSql.find((s) => s.includes("FROM rcontact"));
+      expect(contactsSql).toBeDefined();
+      expect(contactsSql).toMatch(/NOT LIKE '%@stranger'/);
+      expect(contactsSql).toMatch(/NOT LIKE 'fake_%'/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("fetchContacts with includeJunk:true drops the filter (forensic mode)", async () => {
+    const seenSql = [];
+    const fakeDriver = function Database() {
+      return {
+        pragma: () => undefined,
+        exec: () => undefined,
+        prepare(sql) {
+          seenSql.push(sql);
+          return {
+            all: () => {
+              if (sql.startsWith("PRAGMA table_info")) {
+                return ["username", "alias", "nickname", "conRemark", "type"].map((name) => ({ name }));
+              }
+              if (sql.startsWith("SELECT count")) return [{ n: 5 }];
+              return [];
+            },
+            get: () => ({ n: 5 }),
+          };
+        },
+        close: () => undefined,
+      };
+    };
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "wechat-incljunk-"));
+    const dbPath = path.join(dir, "EnMicroMsg.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const reader = new WeChatDBReader({
+        dbPath,
+        keyProvider: { getKey: async () => "0".repeat(64) },
+        driver: fakeDriver,
+      });
+      await reader.open();
+      reader.fetchContacts({ limit: 100, includeJunk: true });
+      const contactsSql = seenSql.find((s) => s.includes("FROM rcontact"));
+      expect(contactsSql).toBeDefined();
+      expect(contactsSql).not.toMatch(/NOT LIKE/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("idle no-op when DB path missing", async () => {
     const a = new WechatAdapter({
       account: { uin: "self123" },