@chainlesschain/personal-data-hub 0.2.2 → 0.2.4

package/__tests__/social-xiaohongshu-snapshot.test.js

@@ -0,0 +1,232 @@
+"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 {
+  XiaohongshuAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_SNAPSHOT_KINDS,
+} = require("../lib/adapters/social-xiaohongshu");
+const { validateBatch } = require("../lib/batch");
+
+// §A8 v0.2 — snapshot-mode tests, mirror of social-weibo-snapshot.test.js.
+//
+// Snapshot mode is in-APK Android cc reading JSON written by XhsLocalCollector
+// (WebView + OkHttp + X-S signed requests). Sqlite/device-pull tests stay in
+// longtail-adapters.test.js (legacy Phase 13.4 path).
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-xiaohongshu.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("XiaohongshuAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xhs-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1 + 3 VALID_SNAPSHOT_KINDS", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    expect(VALID_SNAPSHOT_KINDS).toEqual(["note", "liked", "follow"]);
+  });
+
+  it("authenticate(inputPath) ok when readable", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new XiaohongshuAdapter();
+    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 XiaohongshuAdapter();
+    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 XiaohongshuAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new XiaohongshuAdapter();
+    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, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new XiaohongshuAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(0);
+  });
+
+  it("note + liked + follow round-trip normalize cleanly", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      account: { uid: "5e8c8f7e000000000abcdef0", numericUid: "12345", displayName: "alice" },
+      events: [
+        {
+          kind: "note",
+          id: "note-N1",
+          capturedAt: now - 1000,
+          title: "今日穿搭",
+          noteId: "N1",
+          desc: "夏日清凉",
+          type: "normal",
+          likedCount: 100,
+          collectedCount: 30,
+          commentCount: 15,
+        },
+        {
+          kind: "liked",
+          id: "liked-N2",
+          capturedAt: now - 2000,
+          title: "好喜欢的菜谱",
+          noteId: "N2",
+          authorNickname: "美食家",
+        },
+        {
+          kind: "follow",
+          id: "follow-USR99",
+          capturedAt: now - 3000,
+          userId: "USR99",
+          nickname: "carol",
+          image: "https://example.com/c.jpg",
+        },
+      ],
+    });
+    const a = new XiaohongshuAdapter();
+    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(["note", "liked", "follow"]);
+
+    expect(raws[0].originalId).toMatch(/^xiaohongshu:note:/);
+    expect(raws[1].originalId).toMatch(/^xiaohongshu:liked:/);
+    expect(raws[2].originalId).toMatch(/^xiaohongshu:follow:/);
+
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      expect(validateBatch(batch).valid).toBe(true);
+    }
+
+    const noteBatch = a.normalize(raws[0]);
+    expect(noteBatch.events[0].subtype).toBe("post");
+    expect(noteBatch.events[0].extra.noteId).toBe("N1");
+    expect(noteBatch.events[0].extra.likedCount).toBe(100);
+    expect(noteBatch.events[0].extra.collectedCount).toBe(30);
+    expect(noteBatch.events[0].extra.commentCount).toBe(15);
+    expect(noteBatch.events[0].extra.type).toBe("normal");
+    expect(noteBatch.events[0].source.capturedBy).toBe("api");
+
+    const likedBatch = a.normalize(raws[1]);
+    expect(likedBatch.events[0].subtype).toBe("like");
+    expect(likedBatch.events[0].extra.authorNickname).toBe("美食家");
+
+    const followBatch = a.normalize(raws[2]);
+    expect(followBatch.events.length).toBe(0);
+    expect(followBatch.persons.length).toBe(1);
+    expect(followBatch.persons[0].names).toEqual(["carol"]);
+    expect(followBatch.persons[0].identifiers["xiaohongshu-uid"]).toEqual(["USR99"]);
+  });
+
+  it("respects per-kind include opt-out", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "note", id: "n1", capturedAt: now, title: "t", noteId: "N1" },
+        { kind: "liked", id: "l1", capturedAt: now, title: "l", noteId: "N2" },
+        { kind: "follow", id: "fl1", capturedAt: now, userId: "U1", nickname: "x" },
+      ],
+    });
+    const a = new XiaohongshuAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { liked: false } })) {
+      raws.push(r);
+    }
+    const kinds = raws.map((r) => r.kind);
+    expect(kinds).toEqual(["note", "follow"]);
+  });
+
+  it("respects opts.limit", async () => {
+    const now = Date.now();
+    const events = Array.from({ length: 5 }, (_, i) => ({
+      kind: "note", id: `n${i}`, capturedAt: now - i * 100, title: `t${i}`, noteId: `N${i}`,
+    }));
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
+    const a = new XiaohongshuAdapter();
+    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, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "note", id: "n1", capturedAt: now, title: "ok", noteId: "N1" },
+        { kind: "future-kind", id: "x", capturedAt: now },
+        { kind: "history", id: "h", capturedAt: now }, // sqlite-only
+      ],
+    });
+    const a = new XiaohongshuAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("note");
+  });
+
+  it("snapshottedAt fallback when event capturedAt missing", async () => {
+    const ts = 1700000000000;
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: ts,
+      events: [
+        { kind: "note", id: "n1", title: "no time", noteId: "N1" },
+      ],
+    });
+    const a = new XiaohongshuAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws[0].capturedAt).toBe(ts);
+  });
+});

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);
+  });
+});