@chainlesschain/personal-data-hub 0.4.3 → 0.4.5

package/__tests__/adapters/netease-music-live.test.js

@@ -0,0 +1,244 @@
+/**
+ * 网易云音乐 LIVE cookie web-API (weapi) fetcher tests.
+ * weapi crypto determinism (fixed secKey) + account/play/playlist parsing +
+ * adapter cookie-mode sync + error mapping. All network via injected fetch.
+ */
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { NeteaseMusicAdapter } = require("../../lib/adapters/netease-music");
+const {
+  NeteaseMusicApiClient,
+  weapiEncrypt,
+  aesEncrypt,
+  rsaEncrypt,
+  modpow,
+} = require("../../lib/adapters/netease-music/api-client");
+const { partitionBatch } = require("../../lib/batch");
+
+const FIXED_SECKEY = "0123456789abcdef"; // 16 chars → deterministic weapi
+const COOKIE = "MUSIC_U=abcdef0123456789; __csrf=zzz";
+
+/** Map endpoint path substrings → JSON bodies; record posted form bodies. */
+function makeFetch(routes, calls) {
+  return async (url, init) => {
+    calls.push({ url, body: init && init.body, headers: (init && init.headers) || {} });
+    const route = routes.find((r) => url.includes(r.match));
+    if (!route) return { ok: false, status: 404, text: async () => "not mapped" };
+    return {
+      ok: route.status ? route.status >= 200 && route.status < 300 : true,
+      status: route.status || 200,
+      text: async () =>
+        typeof route.body === "string" ? route.body : JSON.stringify(route.body),
+    };
+  };
+}
+
+async function collect(iter) {
+  const out = [];
+  for await (const r of iter) out.push(r);
+  return out;
+}
+
+describe("weapi crypto primitives", () => {
+  it("modpow matches BigInt ** % for small values", () => {
+    expect(modpow(4n, 13n, 497n)).toBe(445n); // textbook RSA example
+    expect(modpow(7n, 0n, 13n)).toBe(1n);
+  });
+
+  it("aesEncrypt is deterministic (fixed key + IV) and base64", () => {
+    const a = aesEncrypt("hello", "0CoJUm6Qyw8W8jud");
+    const b = aesEncrypt("hello", "0CoJUm6Qyw8W8jud");
+    expect(a).toBe(b);
+    expect(a).toMatch(/^[A-Za-z0-9+/=]+$/);
+  });
+
+  it("rsaEncrypt yields zero-padded 256-hex", () => {
+    const enc = rsaEncrypt("test", "010001", "e0b5");
+    expect(enc).toHaveLength(256);
+    expect(enc).toMatch(/^[0-9a-f]{256}$/);
+  });
+
+  it("weapiEncrypt produces stable { params, encSecKey } for a fixed secKey", () => {
+    const a = weapiEncrypt({ uid: 1 }, FIXED_SECKEY);
+    const b = weapiEncrypt({ uid: 1 }, FIXED_SECKEY);
+    expect(a).toEqual(b);
+    expect(a.encSecKey).toHaveLength(256);
+    expect(a.params).toMatch(/^[A-Za-z0-9+/=]+$/);
+  });
+});
+
+describe("NeteaseMusicApiClient.fetchSnapshot — live (mocked fetch)", () => {
+  it("resolves account, play record, playlists into snapshot-shaped events", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        {
+          match: "/weapi/w/nuser/account/get",
+          body: { code: 200, profile: { userId: 42, nickname: "听歌的人" }, account: { id: 42 } },
+        },
+        {
+          match: "/weapi/v1/play/record",
+          body: {
+            code: 200,
+            weekData: [
+              { playCount: 50, song: { id: 186016, name: "晴天", ar: [{ name: "周杰伦" }], al: { name: "叶惠美" } } },
+            ],
+          },
+        },
+        {
+          match: "/weapi/user/playlist",
+          body: {
+            code: 200,
+            playlist: [{ id: 999, name: "我喜欢的音乐", trackCount: 200, creator: { nickname: "听歌的人" } }],
+          },
+        },
+      ],
+      calls,
+    );
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    const result = await client.fetchSnapshot(COOKIE);
+    expect(result.account).toEqual({ uid: "42", nickname: "听歌的人" });
+    expect(result.events).toHaveLength(2);
+    const play = result.events.find((e) => e.kind === "play");
+    expect(play).toMatchObject({ songId: "186016", song: "晴天", artist: "周杰伦", album: "叶惠美", playCount: 50 });
+    const pl = result.events.find((e) => e.kind === "playlist");
+    expect(pl).toMatchObject({ playlistId: "999", name: "我喜欢的音乐", trackCount: 200, creator: "听歌的人" });
+    // every POST is form-encoded weapi (params + encSecKey) with the cookie.
+    for (const c of calls) {
+      expect(c.body).toMatch(/^params=.+&encSecKey=.+$/);
+      expect(c.headers.Cookie).toBe(COOKIE);
+      expect(c.headers["Content-Type"]).toContain("x-www-form-urlencoded");
+    }
+  });
+
+  it("multi-artist joined with ' / '; falls back to allData when weekData empty", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        { match: "account/get", body: { code: 200, profile: { userId: 7 } } },
+        {
+          match: "play/record",
+          body: {
+            code: 200,
+            weekData: [],
+            allData: [{ playCount: 3, song: { id: 1, name: "S", ar: [{ name: "A" }, { name: "B" }], al: { name: "Al" } } }],
+          },
+        },
+        { match: "user/playlist", body: { code: 200, playlist: [] } },
+      ],
+      calls,
+    );
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    const result = await client.fetchSnapshot(COOKIE);
+    const play = result.events.find((e) => e.kind === "play");
+    expect(play.artist).toBe("A / B");
+  });
+
+  it("include flags skip endpoints", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        { match: "account/get", body: { code: 200, profile: { userId: 7 } } },
+        { match: "user/playlist", body: { code: 200, playlist: [] } },
+      ],
+      calls,
+    );
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    const result = await client.fetchSnapshot(COOKIE, { include: { play: false } });
+    expect(calls.some((c) => c.url.includes("play/record"))).toBe(false);
+    expect(result.events.every((e) => e.kind !== "play")).toBe(true);
+  });
+
+  it("maps API code != 200 to null + lastError (e.g. -460 risk-control)", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [{ match: "account/get", body: { code: -460, message: "Cheating" } }],
+      calls,
+    );
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
+    expect(client.lastError.code).toBe(-460);
+    expect(client.lastError.message).toContain("Cheating");
+  });
+
+  it("account with no userId → null + lastError -7", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "account/get", body: { code: 200, profile: null, account: null } }], calls);
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
+    expect(client.lastError.code).toBe(-7);
+  });
+
+  it("empty cookie → null + lastError -1 (no network)", async () => {
+    const calls = [];
+    const client = new NeteaseMusicApiClient({ fetch: makeFetch([], calls), secKey: FIXED_SECKEY });
+    expect(await client.fetchSnapshot("")).toBeNull();
+    expect(client.lastError.code).toBe(-1);
+    expect(calls).toHaveLength(0);
+  });
+
+  it("HTTP non-2xx → null + lastError with status", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "account/get", status: 502, body: "bad gw" }], calls);
+    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
+    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
+    expect(client.lastError.code).toBe(502);
+  });
+});
+
+describe("NeteaseMusicAdapter — cookie (live) sync mode", () => {
+  it("authenticate accepts a cookie with MUSIC_U; rejects without it", async () => {
+    const a = new NeteaseMusicAdapter();
+    expect((await a.authenticate({ cookie: COOKIE })).mode).toBe("cookie");
+    const bad = await a.authenticate({ cookie: "foo=bar" });
+    expect(bad.ok).toBe(false);
+    expect(bad.reason).toBe("INVALID_COOKIE");
+  });
+
+  it("capabilities/version reflect v0.2 live mode", () => {
+    const a = new NeteaseMusicAdapter();
+    expect(a.version).toBe("0.2.0");
+    expect(a.capabilities).toContain("sync:cookie");
+  });
+
+  it("sync via cookie yields play+playlist raws → valid normalized batch", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        { match: "account/get", body: { code: 200, profile: { userId: 42, nickname: "me" } } },
+        {
+          match: "play/record",
+          body: { code: 200, weekData: [{ playCount: 9, song: { id: 5, name: "夜曲", ar: [{ name: "周杰伦" }], al: { name: "11月的萧邦" } } }] },
+        },
+        { match: "user/playlist", body: { code: 200, playlist: [{ id: 8, name: "练歌", trackCount: 12, creator: { nickname: "me" } }] } },
+      ],
+      calls,
+    );
+    const a = new NeteaseMusicAdapter();
+    const raws = await collect(a.sync({ cookie: COOKIE, fetch, secKey: FIXED_SECKEY }));
+    expect(raws.map((r) => r.kind).sort()).toEqual(["play", "playlist"]);
+    const playRaw = raws.find((r) => r.kind === "play");
+    expect(playRaw.originalId).toBe("netease-music:play:play-5");
+
+    // normalize → vault-valid batch for both kinds.
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      const { invalidReasons } = partitionBatch(batch);
+      expect(invalidReasons).toHaveLength(0);
+    }
+    const playBatch = a.normalize(playRaw);
+    expect(playBatch.items[0].extra.songId).toBe("5");
+    expect(playBatch.events[0].content.title).toContain("夜曲");
+  });
+
+  it("sync via cookie throws (mapped lastError) on risk-control", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "account/get", body: { code: -460, message: "Cheating" } }], calls);
+    const a = new NeteaseMusicAdapter();
+    await expect(collect(a.sync({ cookie: COOKIE, fetch, secKey: FIXED_SECKEY }))).rejects.toThrow(
+      /Cheating|code -460/,
+    );
+  });
+});

package/__tests__/adapters/shopping-base.test.js

@@ -0,0 +1,179 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  normalizeOrderRecord,
+  mapStatusToSubtype,
+  CookieAuth,
+} = require("../../lib/adapters/shopping-base");
+
+describe("normalizeOrderRecord", () => {
+  const ORDER = {
+    vendorId: "jd",
+    orderId: "JD123456",
+    placedAt: 1716383021000,
+    paidAt: 1716383100000,
+    status: "delivered",
+    merchantName: "京东自营旗舰店",
+    totalAmount: { value: 299.9, currency: "CNY" },
+    items: [
+      { name: "机械键盘", quantity: 1, unitPrice: 249.9, sku: "SKU1" },
+      { name: "键帽", quantity: 2, unitPrice: 25 },
+    ],
+    recipient: "张三",
+    shippingAddress: "上海市幸福路1号",
+    trackingNumber: "SF123",
+    extras: { shopId: "S1" },
+  };
+
+  it("throws on missing rec / orderId / merchantName", () => {
+    expect(() => normalizeOrderRecord(null)).toThrow(/rec required/);
+    expect(() => normalizeOrderRecord({})).toThrow(/orderId required/);
+    expect(() => normalizeOrderRecord({ orderId: "X" })).toThrow(
+      /merchantName required/,
+    );
+  });
+
+  it("emits order event with amount out + items text + cross-source link extras", () => {
+    const batch = normalizeOrderRecord(ORDER, {
+      adapterName: "shopping-jd",
+      adapterVersion: "0.5.0",
+    });
+    expect(batch.events).toHaveLength(1);
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("order");
+    expect(ev.occurredAt).toBe(1716383021000);
+    expect(ev.actor).toBe("person-self");
+    expect(ev.content.title).toBe("京东自营旗舰店 订单 JD123456");
+    expect(ev.content.amount).toEqual({
+      value: 299.9,
+      currency: "CNY",
+      direction: "out",
+    });
+    expect(ev.content.text).toBe("机械键盘 x1; 键帽 x2");
+    expect(ev.extra).toMatchObject({
+      vendorId: "jd",
+      orderId: "JD123456",
+      merchantOrderNumber: "JD123456", // Email/Alipay cross-source link key
+      orderStatus: "delivered",
+      itemCount: 2,
+      recipient: "张三",
+      trackingNumber: "SF123",
+      paidAt: 1716383100000,
+      vendorExtras: { shopId: "S1" },
+    });
+    expect(ev.source).toMatchObject({
+      adapter: "shopping-jd",
+      adapterVersion: "0.5.0",
+      originalId: "JD123456",
+      capturedBy: "api",
+    });
+  });
+
+  it("emits merchant person + per-SKU item entities inheriting order currency", () => {
+    const batch = normalizeOrderRecord(ORDER, { adapterName: "shopping-jd" });
+    expect(batch.persons).toHaveLength(1);
+    expect(batch.persons[0]).toMatchObject({
+      subtype: "merchant",
+      names: ["京东自营旗舰店"],
+    });
+    expect(batch.items).toHaveLength(2);
+    expect(batch.items[0]).toMatchObject({
+      type: "item",
+      subtype: "product",
+      name: "机械键盘",
+      merchant: batch.persons[0].id,
+      price: { value: 249.9, currency: "CNY" },
+    });
+    expect(batch.items[0].extra).toMatchObject({ quantity: 1, sku: "SKU1" });
+    // nameless item entries are dropped
+    const withJunk = normalizeOrderRecord(
+      { ...ORDER, items: [{ quantity: 3 }, { name: "ok" }] },
+      {},
+    );
+    expect(withJunk.items).toHaveLength(1);
+  });
+
+  it("refund order → refund subtype with money direction IN", () => {
+    const batch = normalizeOrderRecord(
+      { ...ORDER, status: "refunded" },
+      { adapterName: "shopping-jd" },
+    );
+    expect(batch.events[0].subtype).toBe("refund");
+    expect(batch.events[0].content.amount.direction).toBe("in");
+  });
+
+  it("omits amount when totalAmount missing; occurredAt falls back to now", () => {
+    const before = Date.now();
+    const batch = normalizeOrderRecord({
+      orderId: "X1",
+      merchantName: "店",
+    });
+    expect(batch.events[0].content.amount).toBeUndefined();
+    expect(batch.events[0].occurredAt).toBeGreaterThanOrEqual(before);
+    expect(batch.events[0].extra.orderStatus).toBe("placed");
+  });
+});
+
+describe("mapStatusToSubtype", () => {
+  it("maps refund variants (en + 中文)", () => {
+    expect(mapStatusToSubtype("refunded")).toBe("refund");
+    expect(mapStatusToSubtype("REFUND_PENDING")).toBe("refund");
+    expect(mapStatusToSubtype("退款中")).toBe("refund");
+  });
+
+  it("maps cancel variants (en + 中文)", () => {
+    expect(mapStatusToSubtype("cancelled")).toBe("cancelled");
+    expect(mapStatusToSubtype("closed")).toBe("cancelled");
+    expect(mapStatusToSubtype("已取消")).toBe("cancelled");
+    expect(mapStatusToSubtype("已关闭")).toBe("cancelled");
+  });
+
+  it("everything else (placed/shipped/delivered/blank) → order", () => {
+    expect(mapStatusToSubtype("placed")).toBe("order");
+    expect(mapStatusToSubtype("shipped")).toBe("order");
+    expect(mapStatusToSubtype("delivered")).toBe("order");
+    expect(mapStatusToSubtype(undefined)).toBe("order");
+  });
+});
+
+describe("CookieAuth", () => {
+  it("requires platform; setCookies type-checks", () => {
+    expect(() => new CookieAuth({})).toThrow(/platform required/);
+    const c = new CookieAuth({ platform: "jd" });
+    expect(() => c.setCookies(42)).toThrow(/string required/);
+  });
+
+  it("toHeader returns raw string or null when empty", () => {
+    const c = new CookieAuth({ platform: "jd" });
+    expect(c.toHeader()).toBe(null);
+    c.setCookies("pt_key=abc; pt_pin=u1");
+    expect(c.toHeader()).toBe("pt_key=abc; pt_pin=u1");
+  });
+
+  it("validate: false on empty, true on non-empty, defers to injected validator", async () => {
+    const empty = new CookieAuth({ platform: "jd" });
+    expect(await empty.validate()).toBe(false);
+    const plain = new CookieAuth({ platform: "jd", cookies: "k=v" });
+    expect(await plain.validate()).toBe(true);
+    const probed = new CookieAuth({
+      platform: "jd",
+      cookies: "k=v",
+      validator: async (raw) => raw.includes("pt_key"),
+    });
+    expect(await probed.validate()).toBe(false);
+  });
+
+  it("getCookieValue: case-insensitive, URI-decodes, escapes regex metachars", () => {
+    const c = new CookieAuth({
+      platform: "taobao",
+      cookies: "Name=%E5%BC%A0%E4%B8%89; a.b+c=literal; last=v",
+    });
+    expect(c.getCookieValue("name")).toBe("张三");
+    // dot/plus in cookie name must be treated literally, not as regex
+    expect(c.getCookieValue("a.b+c")).toBe("literal");
+    expect(c.getCookieValue("missing")).toBe(null);
+    expect(c.getCookieValue("")).toBe(null);
+  });
+});

package/__tests__/adapters/social-douyin-adb-aweme-detail.test.js

@@ -0,0 +1,165 @@
+/**
+ * Douyin aweme-detail title resolver tests (real-device-driven 2026-06-11:
+ * web detail endpoint returns aweme_detail{desc,author,duration} with no signing).
+ * fetch injected — no network.
+ */
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+
+const {
+  AwemeDetailClient,
+} = require("../../lib/adapters/social-douyin-adb/aweme-detail-client");
+const {
+  collectWatchHistory,
+} = require("../../lib/adapters/social-douyin-adb/collector");
+const { DouyinAdapter } = require("../../lib/adapters/social-douyin");
+const { partitionBatch } = require("../../lib/batch");
+
+function makeFetch(byAid) {
+  return async (url) => {
+    const m = /aweme_id=(\d+)/.exec(url);
+    const aid = m && m[1];
+    const payload = byAid[aid];
+    if (payload === undefined) return { ok: false, status: 404, text: async () => "nf" };
+    return {
+      ok: payload.status ? payload.status >= 200 && payload.status < 300 : true,
+      status: payload.status || 200,
+      text: async () => (typeof payload.body === "string" ? payload.body : JSON.stringify(payload.body)),
+    };
+  };
+}
+const noSleep = () => Promise.resolve();
+
+describe("AwemeDetailClient.fetchDetail", () => {
+  it("parses aweme_detail → {desc, author, durationMs, createTime}; sends aweme_id + webapp params", async () => {
+    let seenUrl;
+    const fetch = async (url) => {
+      seenUrl = url;
+      return { ok: true, status: 200, text: async () => JSON.stringify({
+        status_code: 0,
+        aweme_detail: { desc: "洋气婆婆和她的土狗儿媳", author: { nickname: "任集" }, duration: 9200, create_time: 1780112750 },
+      }) };
+    };
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    const d = await c.fetchDetail("7645526043227334246");
+    expect(d).toEqual({ awemeId: "7645526043227334246", desc: "洋气婆婆和她的土狗儿媳", author: "任集", durationMs: 9200, createTime: 1780112750 });
+    expect(seenUrl).toContain("aweme_id=7645526043227334246");
+    expect(seenUrl).toContain("device_platform=webapp");
+    expect(seenUrl).toContain("aid=6383");
+  });
+
+  it("status_code != 0 → null + lastError", async () => {
+    const fetch = makeFetch({ 1: { body: { status_code: 8, status_msg: "risk" } } });
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    expect(await c.fetchDetail("1")).toBe(null);
+    expect(c.lastErrorCode).toBe(8);
+  });
+
+  it("missing aweme_detail (deleted/private) → null -5", async () => {
+    const fetch = makeFetch({ 1: { body: { status_code: 0 } } });
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    expect(await c.fetchDetail("1")).toBe(null);
+    expect(c.lastErrorCode).toBe(-5);
+  });
+
+  it("HTTP non-2xx → null with status", async () => {
+    const fetch = makeFetch({ 1: { status: 444, body: "blocked" } });
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    expect(await c.fetchDetail("1")).toBe(null);
+    expect(c.lastErrorCode).toBe(444);
+  });
+});
+
+describe("AwemeDetailClient.resolveMany", () => {
+  it("dedups ids, caps at limit, skips per-id failures", async () => {
+    const calls = [];
+    const fetch = async (url) => {
+      const aid = /aweme_id=(\d+)/.exec(url)[1];
+      calls.push(aid);
+      const ok = { 11: true, 22: true }[aid];
+      return { ok: true, status: 200, text: async () => JSON.stringify(
+        ok ? { status_code: 0, aweme_detail: { desc: "d" + aid, author: { nickname: "a" } } }
+           : { status_code: 0 }, // 33 → no aweme_detail → skipped
+      ) };
+    };
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    const map = await c.resolveMany(["11", "11", "22", "33"], { limit: 10 });
+    expect(calls).toEqual(["11", "22", "33"]); // deduped (one 11)
+    expect([...map.keys()].sort()).toEqual(["11", "22"]); // 33 skipped
+    expect(map.get("11").desc).toBe("d11");
+  });
+
+  it("respects limit (stops early)", async () => {
+    const calls = [];
+    const fetch = async (url) => {
+      calls.push(/aweme_id=(\d+)/.exec(url)[1]);
+      return { ok: true, status: 200, text: async () => JSON.stringify({ status_code: 0, aweme_detail: { desc: "x" } }) };
+    };
+    const c = new AwemeDetailClient({ fetch, sleep: noSleep });
+    await c.resolveMany(["1", "2", "3", "4", "5"], { limit: 2 });
+    expect(calls).toEqual(["1", "2"]);
+  });
+});
+
+describe("collectWatchHistory --resolve-titles integration", () => {
+  it("attaches title/author/duration → normalizeHistory shows real content", async () => {
+    const fs = require("node:fs");
+    const os = require("node:os");
+    const bridge = {
+      invoke: vi.fn(async (m) =>
+        m === "douyin.watch-history"
+          ? {
+              uid: "92585448288",
+              records: [
+                { awemeId: "7645526043227334246", capturedAt: 1780112750000, enterFrom: "homepage_hot" },
+              ],
+            }
+          : (() => { throw new Error("unknown " + m); })(),
+      ),
+    };
+    const detailClient = new AwemeDetailClient({
+      sleep: () => Promise.resolve(),
+      fetch: makeFetch({
+        "7645526043227334246": { body: { status_code: 0, aweme_detail: { desc: "洋气婆婆和她的土狗儿媳", author: { nickname: "任集" }, duration: 9200 } } },
+      }),
+    });
+    const r = await collectWatchHistory(bridge, {
+      stagingDir: os.tmpdir(),
+      now: () => 1781000000000,
+      resolveTitles: true,
+      _detailClient: detailClient,
+    });
+    expect(r.titlesResolved).toBe(1);
+    const snap = JSON.parse(fs.readFileSync(r.snapshotPath, "utf-8"));
+    try {
+      expect(snap.events[0].title).toBe("洋气婆婆和她的土狗儿媳");
+      const a = new DouyinAdapter();
+      const batch = a.normalize({
+        adapter: "social-douyin",
+        kind: "history",
+        originalId: "douyin:history:1",
+        capturedAt: 1780112750000,
+        payload: { ...snap.events[0], account: snap.account },
+      });
+      expect(partitionBatch(batch).invalidReasons).toHaveLength(0);
+      expect(batch.events[0].content.title).toBe("洋气婆婆和她的土狗儿媳");
+      expect(batch.events[0].extra.author).toBe("任集");
+      expect(batch.events[0].extra.duration).toBe(9200);
+      expect(batch.events[0].extra.enterFrom).toBe("homepage_hot");
+    } finally {
+      fs.unlinkSync(r.snapshotPath);
+    }
+  });
+
+  it("without resolveTitles, no network + title stays unresolved", async () => {
+    const os = require("node:os");
+    const fs = require("node:fs");
+    const bridge = { invoke: vi.fn(async () => ({ uid: "1", records: [{ awemeId: "999", capturedAt: 1, enterFrom: "x" }] })) };
+    const r = await collectWatchHistory(bridge, { stagingDir: os.tmpdir(), now: () => 1, resolveTitles: false });
+    expect(r.titlesResolved).toBe(0);
+    const snap = JSON.parse(fs.readFileSync(r.snapshotPath, "utf-8"));
+    fs.unlinkSync(r.snapshotPath);
+    expect(snap.events[0].title).toBeUndefined();
+  });
+});