@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/adapters/system-data-android.test.js

@@ -0,0 +1,387 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  SystemDataAndroidAdapter,
+  SYSTEM_DATA_ANDROID_NAME,
+  SYSTEM_DATA_ANDROID_VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/system-data-android");
+const { assertAdapter } = require("../../lib/adapter-spec");
+const {
+  ENTITY_TYPES,
+  PERSON_SUBTYPES,
+  ITEM_SUBTYPES,
+  CAPTURED_BY,
+} = require("../../lib/constants");
+const { validatePerson, validateItem } = require("../../lib/schemas");
+
+let tmpDir;
+let snapshotPath;
+
+function writeSnapshot(obj) {
+  writeFileSync(snapshotPath, JSON.stringify(obj), "utf-8");
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "sda-test-"));
+  snapshotPath = join(tmpDir, "snapshot.json");
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("SystemDataAndroidAdapter — contract", () => {
+  it("conforms to PersonalDataAdapter contract", () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const r = assertAdapter(adapter);
+    expect(r).toEqual({ ok: true });
+  });
+
+  it("exposes stable name + version + capabilities", () => {
+    const adapter = new SystemDataAndroidAdapter();
+    expect(adapter.name).toBe(SYSTEM_DATA_ANDROID_NAME);
+    expect(adapter.version).toBe(SYSTEM_DATA_ANDROID_VERSION);
+    expect(adapter.extractMode).toBe("device-pull");
+    expect(adapter.dataDisclosure.sensitivity).toBe("medium");
+    expect(adapter.dataDisclosure.legalGate).toBe(false);
+  });
+});
+
+describe("SystemDataAndroidAdapter.authenticate", () => {
+  it("fails when inputPath missing", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const r = await adapter.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("INPUT_PATH_REQUIRED");
+  });
+
+  it("fails when inputPath does not exist", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const r = await adapter.authenticate({ inputPath: join(tmpDir, "does-not-exist.json") });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("INPUT_PATH_UNREADABLE");
+  });
+
+  it("succeeds when inputPath is readable", async () => {
+    writeSnapshot({ schemaVersion: SNAPSHOT_SCHEMA_VERSION, contacts: [], apps: [] });
+    const adapter = new SystemDataAndroidAdapter();
+    const r = await adapter.authenticate({ inputPath: snapshotPath });
+    expect(r).toEqual({ ok: true, mode: "snapshot-file" });
+  });
+});
+
+describe("SystemDataAndroidAdapter.sync + normalize", () => {
+  it("rejects mismatched snapshot schemaVersion", async () => {
+    writeSnapshot({ schemaVersion: 99, contacts: [], apps: [] });
+    const adapter = new SystemDataAndroidAdapter();
+    await expect(async () => {
+      // eslint-disable-next-line no-unused-vars
+      for await (const _ of adapter.sync({ inputPath: snapshotPath })) {
+        // drain
+      }
+    }).rejects.toThrow(/schemaVersion mismatch/);
+  });
+
+  it("yields contact + app raws and normalizes each into a valid entity", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: 1_700_000_000_000,
+      contacts: [
+        {
+          lookupKey: "0r1-3A2B",
+          displayName: "妈妈",
+          phones: ["+8613800138000"],
+          emails: [],
+          starred: true,
+          organization: "家庭",
+        },
+      ],
+      apps: [
+        {
+          packageName: "com.tencent.mm",
+          label: "微信",
+          versionName: "8.0.45",
+          versionCode: 2200,
+          firstInstallTime: 1_650_000_000_000,
+          lastUpdateTime: 1_700_000_000_000,
+          isSystem: false,
+        },
+      ],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+
+    // Every yielded raw must carry originalId so registry.putRawEvent's NOT
+    // NULL constraint doesn't surface as invalidCount=rawCount (real-device
+    // bug 2026-05-21). Capture all raws to assert structure first.
+    const rawsSeen = [];
+    for await (const r of adapter.sync({ inputPath: snapshotPath })) {
+      rawsSeen.push(r);
+    }
+    expect(rawsSeen[0].originalId).toBe("android-contact:0r1-3A2B");
+    expect(rawsSeen[1].originalId).toBe("android-app:com.tencent.mm");
+
+    const persons = [];
+    const items = [];
+    for await (const raw of adapter.sync({ inputPath: snapshotPath })) {
+      const batch = adapter.normalize(raw);
+      persons.push(...batch.persons);
+      items.push(...batch.items);
+    }
+
+    expect(persons).toHaveLength(1);
+    const p = persons[0];
+    expect(p.id).toBe("person-android-0r1-3A2B");
+    expect(p.type).toBe(ENTITY_TYPES.PERSON);
+    expect(p.subtype).toBe(PERSON_SUBTYPES.CONTACT);
+    expect(p.names).toEqual(["妈妈"]);
+    expect(p.identifiers).toEqual({ phone: ["+8613800138000"] });
+    expect(p.extra).toEqual({ starred: true });
+    expect(p.relation).toBe("家庭");
+    expect(p.source.adapter).toBe(SYSTEM_DATA_ANDROID_NAME);
+    expect(p.source.capturedBy).toBe(CAPTURED_BY.API);
+    expect(p.source.capturedAt).toBe(1_700_000_000_000);
+    const pv = validatePerson(p);
+    expect(pv).toEqual({ valid: true, errors: [] });
+
+    expect(items).toHaveLength(1);
+    const i = items[0];
+    expect(i.id).toBe("item-android-app-com.tencent.mm");
+    expect(i.type).toBe(ENTITY_TYPES.ITEM);
+    expect(i.subtype).toBe(ITEM_SUBTYPES.OTHER);
+    expect(i.name).toBe("微信");
+    expect(i.category).toBe("user-app");
+    expect(i.extra.kind).toBe("installed_app");
+    expect(i.extra.packageName).toBe("com.tencent.mm");
+    expect(i.extra.versionCode).toBe(2200);
+    expect(i.extra.firstInstallTime).toBe(1_650_000_000_000);
+    expect(i.extra.isSystem).toBe(false);
+    const iv = validateItem(i);
+    expect(iv).toEqual({ valid: true, errors: [] });
+  });
+
+  it("dedupes by stable lookupKey — same key across syncs returns same id", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      contacts: [{ lookupKey: "abc", displayName: "Alice", phones: [], emails: [] }],
+      apps: [],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+    const ids = [];
+    for (let pass = 0; pass < 2; pass++) {
+      for await (const raw of adapter.sync({ inputPath: snapshotPath })) {
+        const batch = adapter.normalize(raw);
+        if (batch.persons[0]) ids.push(batch.persons[0].id);
+      }
+    }
+    expect(ids).toEqual(["person-android-abc", "person-android-abc"]);
+  });
+
+  it("falls back to displayName when lookupKey missing", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      contacts: [{ displayName: "Bob", phones: [], emails: [] }],
+      apps: [],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+    let id;
+    for await (const raw of adapter.sync({ inputPath: snapshotPath })) {
+      id = adapter.normalize(raw).persons[0]?.id;
+    }
+    expect(id).toBe("person-android-Bob");
+  });
+
+  it("honors include filter — apps only", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      contacts: [{ lookupKey: "k", displayName: "X", phones: [], emails: [] }],
+      apps: [
+        { packageName: "com.x", label: "X", versionName: "1", versionCode: 1, isSystem: false },
+      ],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+    const kinds = [];
+    for await (const raw of adapter.sync({
+      inputPath: snapshotPath,
+      include: { contacts: false, apps: true },
+    })) {
+      kinds.push(raw.kind);
+    }
+    expect(kinds).toEqual(["app"]);
+  });
+
+  it("honors limit option", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      contacts: [
+        { lookupKey: "a", displayName: "A", phones: [], emails: [] },
+        { lookupKey: "b", displayName: "B", phones: [], emails: [] },
+        { lookupKey: "c", displayName: "C", phones: [], emails: [] },
+      ],
+      apps: [],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+    let count = 0;
+    for await (const _raw of adapter.sync({ inputPath: snapshotPath, limit: 2 })) {
+      count += 1;
+    }
+    expect(count).toBe(2);
+  });
+});
+
+describe("SystemDataAndroidAdapter — degenerate snapshots", () => {
+  it("anonymous contact gets placeholder name", () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const batch = adapter.normalize({
+      kind: "contact",
+      capturedAt: 1_700_000_000_000,
+      payload: { lookupKey: "x" },
+    });
+    expect(batch.persons[0].names).toEqual(["(无名联系人)"]);
+  });
+
+  it("system app gets category 'system-app'", () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const batch = adapter.normalize({
+      kind: "app",
+      capturedAt: 1_700_000_000_000,
+      payload: { packageName: "com.android.settings", label: "Settings", isSystem: true },
+    });
+    expect(batch.items[0].category).toBe("system-app");
+    expect(batch.items[0].extra.isSystem).toBe(true);
+  });
+
+  it("throws on unknown raw.kind", () => {
+    const adapter = new SystemDataAndroidAdapter();
+    expect(() =>
+      adapter.normalize({ kind: "mystery", capturedAt: 1, payload: {} })
+    ).toThrow(/unknown raw.kind/);
+  });
+});
+
+// ─── Bridge-direct mode (A8 follow-up) ────────────────────────────────
+//
+// When `cc-android-bridge` is loaded inside in-APK cc, the adapter can pull
+// directly from ContentResolver / PackageManager instead of waiting for the
+// UI to write a snapshot file. These tests inject a mock bridge to exercise
+// the new path without a real device.
+
+describe("SystemDataAndroidAdapter — bridge-direct sync", () => {
+  function makeBridge({ contacts = [], apps = [], throws = null } = {}) {
+    return {
+      caps: () => ({ available: true, reason: "test" }),
+      invoke: async (method) => {
+        if (throws) throw throws;
+        if (method === "contacts.query") return { contacts };
+        if (method === "app.list") return { apps };
+        throw new Error("unexpected method " + method);
+      },
+    };
+  }
+
+  it("useBridge=true pulls contacts and apps via bridge.invoke", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const bridge = makeBridge({
+      contacts: [
+        { lookupKey: "ck-1", displayName: "妈妈", phones: ["13800000001"] },
+        { lookupKey: "ck-2", displayName: "同事" },
+      ],
+      apps: [
+        { packageName: "com.tencent.mm", label: "微信", versionName: "8.0", isSystem: false },
+      ],
+    });
+    adapter._deps.bridgeProvider = () => bridge;
+
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true })) out.push(r);
+    expect(out).toHaveLength(3);
+    expect(out[0].kind).toBe("contact");
+    expect(out[0].payload.displayName).toBe("妈妈");
+    expect(out[2].kind).toBe("app");
+    expect(out[2].payload.packageName).toBe("com.tencent.mm");
+  });
+
+  it("auto-engages bridge when inputPath omitted AND bridge.available", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () => makeBridge({
+      contacts: [{ lookupKey: "auto", displayName: "Auto" }],
+    });
+    const out = [];
+    for await (const r of adapter.sync({})) out.push(r);
+    expect(out).toHaveLength(1);
+    expect(out[0].payload.displayName).toBe("Auto");
+  });
+
+  it("respects include.contacts=false in bridge mode", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () => makeBridge({
+      contacts: [{ displayName: "should be skipped" }],
+      apps: [{ packageName: "com.kept" }],
+    });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true, include: { contacts: false } })) {
+      out.push(r);
+    }
+    expect(out).toHaveLength(1);
+    expect(out[0].kind).toBe("app");
+  });
+
+  it("limit caps bridge yields", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    const many = Array.from({ length: 10 }, (_, i) => ({ displayName: `c${i}` }));
+    adapter._deps.bridgeProvider = () => makeBridge({ contacts: many });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true, limit: 3 })) out.push(r);
+    expect(out).toHaveLength(3);
+  });
+
+  it("throws when useBridge=true but bridge missing", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () => null;
+    const it = adapter.sync({ useBridge: true });
+    await expect(it.next()).rejects.toThrow(/cc-android-bridge is not loaded/);
+  });
+
+  it("propagates bridge.invoke errors", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({ throws: new Error("ANDROID_BRIDGE_NOT_AVAILABLE: not-on-android") });
+    const it = adapter.sync({ useBridge: true });
+    await expect(it.next()).rejects.toThrow(/ANDROID_BRIDGE_NOT_AVAILABLE/);
+  });
+
+  it("accepts bare array response from bridge (contacts as Array)", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () => ({
+      caps: () => ({ available: true }),
+      invoke: async (method) => {
+        if (method === "contacts.query") return [{ displayName: "Bare" }];
+        if (method === "app.list") return [];
+        return [];
+      },
+    });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true })) out.push(r);
+    expect(out).toHaveLength(1);
+    expect(out[0].payload.displayName).toBe("Bare");
+  });
+
+  it("inputPath snapshot mode still works when bridgeProvider returns null", async () => {
+    writeSnapshot({
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: 1_700_000_000_000,
+      contacts: [{ lookupKey: "snap", displayName: "From Snapshot" }],
+      apps: [],
+    });
+    const adapter = new SystemDataAndroidAdapter();
+    const out = [];
+    for await (const r of adapter.sync({ inputPath: snapshotPath })) out.push(r);
+    expect(out).toHaveLength(1);
+    expect(out[0].payload.displayName).toBe("From Snapshot");
+  });
+});

package/__tests__/adapters/wechat-bootstrap.test.js

@@ -0,0 +1,240 @@
+/**
+ * Phase 12.6.7 — bootstrapWechatAdapter unit tests.
+ *
+ * Validates the decision matrix that ties env-probe → KeyProvider →
+ * WechatAdapter. All exec calls are stubbed via `_probe` injection so
+ * tests stay fully hermetic (no adb, no Frida binding, no real device).
+ */
+"use strict";
+
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import wechatModule from "../../lib/adapters/wechat/bootstrap.js";
+const { bootstrapWechatAdapter } = wechatModule;
+
+function mkProbe(overrides = {}) {
+  const base = {
+    ok: true,
+    suggestedKeyProvider: "md5",
+    reasons: ["WeChat 7.0.22 (< 8.0) — legacy MD5(IMEI+UIN) path supported"],
+    device: { reachable: true, serial: "SERIAL123", abi: "arm64-v8a" },
+    root: { detected: false, magiskInstalled: false },
+    frida: { serverRunning: false, port: null },
+    wechat: { installed: true, versionName: "7.0.22", majorVersion: 7 },
+    warnings: [],
+  };
+  return { ...base, ...overrides };
+}
+
+function mkWechatDataPath() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pdh-wechat-bootstrap-"));
+  return dir;
+}
+
+describe("bootstrapWechatAdapter — input validation", () => {
+  it("throws when account.uin missing (including bare opts)", async () => {
+    await expect(bootstrapWechatAdapter()).rejects.toThrow(/account\.uin/);
+    await expect(bootstrapWechatAdapter({})).rejects.toThrow(/account\.uin/);
+    await expect(
+      bootstrapWechatAdapter({ account: {} }),
+    ).rejects.toThrow(/account\.uin/);
+  });
+});
+
+describe("bootstrapWechatAdapter — md5 path", () => {
+  it("returns ok with MD5KeyProvider when probe suggests md5 + wechatDataPath provided", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.adapter).toBeDefined();
+    expect(r.adapter.account.uin).toBe("1234567890");
+    expect(r.keyProvider).toBeDefined();
+    expect(r.keyProvider.name).toBe("md5");
+    expect(r.probe.suggestedKeyProvider).toBe("md5");
+  });
+
+  it("returns MD5_NEEDS_WECHAT_DATA_PATH when md5 chosen but wechatDataPath missing", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("MD5_NEEDS_WECHAT_DATA_PATH");
+    expect(r.probe).toBeDefined();
+    expect(r.message).toMatch(/wechatDataPath/);
+  });
+
+  it("propagates dbPath to the adapter constructor", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const dbPath = path.join(wechatDataPath, "MicroMsg.db");
+    fs.writeFileSync(dbPath, "stub", "utf-8");
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      dbPath,
+      wechatDataPath,
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.adapter._dbPath).toBe(dbPath);
+  });
+});
+
+describe("bootstrapWechatAdapter — frida path", () => {
+  it("returns ok with FridaKeyProvider when probe suggests frida", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      _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.keyProvider).toBeDefined();
+    expect(r.keyProvider.name).toBe("frida");
+    expect(r.adapter).toBeDefined();
+  });
+
+  it("forwards fridaOpts.deviceId / packageName / timeoutMs", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      fridaOpts: {
+        deviceId: "EMULATOR_ID",
+        packageName: "com.tencent.mm.beta",
+        timeoutMs: 12_345,
+      },
+      _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.keyProvider._deviceId).toBe("EMULATOR_ID");
+    expect(r.keyProvider._packageName).toBe("com.tencent.mm.beta");
+    expect(r.keyProvider._timeoutMs).toBe(12_345);
+  });
+
+  it("falls back to probe.device.serial when fridaOpts.deviceId not provided", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      _probe: mkProbe({
+        suggestedKeyProvider: "frida",
+        device: { reachable: true, serial: "FROM_PROBE", abi: "arm64-v8a" },
+        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.keyProvider._deviceId).toBe("FROM_PROBE");
+  });
+});
+
+describe("bootstrapWechatAdapter — unsupported / unknown", () => {
+  it("returns ENV_UNSUPPORTED with probe reasons when nothing viable", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe({
+        ok: false,
+        suggestedKeyProvider: "unsupported",
+        reasons: ["WeChat 8.0.50 requires root for SQLCipher key extraction"],
+      }),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("ENV_UNSUPPORTED");
+    expect(r.message).toMatch(/root/);
+    expect(r.probe).toBeDefined();
+  });
+
+  it("returns UNKNOWN_KEY_PROVIDER when override is not md5/frida", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      keyProviderOverride: "magic-pony",
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("UNKNOWN_KEY_PROVIDER");
+  });
+});
+
+describe("bootstrapWechatAdapter — override", () => {
+  it("keyProviderOverride='frida' picks frida even when probe suggests md5", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_force" },
+      keyProviderOverride: "frida",
+      _probe: mkProbe(), // suggests "md5"
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider.name).toBe("frida");
+    expect(r.probe.suggestedKeyProvider).toBe("md5"); // probe transparent
+  });
+
+  it("keyProviderOverride='md5' picks md5 even when probe suggests frida", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      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.keyProvider.name).toBe("md5");
+  });
+});
+
+describe("bootstrapWechatAdapter — adapter ctor errors", () => {
+  it("returns ADAPTER_CTOR_FAILED when WechatAdapter throws", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    function Boom() {
+      throw new Error("ctor boom");
+    }
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      _probe: mkProbe(),
+      _WechatAdapter: Boom,
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("ADAPTER_CTOR_FAILED");
+    expect(r.message).toBe("ctor boom");
+  });
+});
+
+describe("bootstrapWechatAdapter — test seams", () => {
+  it("uses injected _md5Provider verbatim", async () => {
+    const stubProvider = { name: "md5", getKey: async () => "deadbeef" };
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe(),
+      _md5Provider: stubProvider,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider).toBe(stubProvider);
+  });
+
+  it("uses injected _fridaProvider verbatim", async () => {
+    const stubProvider = { name: "frida", getKey: async () => "feedface".repeat(8) };
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abc" },
+      keyProviderOverride: "frida",
+      _probe: mkProbe(),
+      _fridaProvider: stubProvider,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider).toBe(stubProvider);
+  });
+});