@chainlesschain/personal-data-hub 0.4.29 → 0.4.30

package/__tests__/audio-ximalaya-snapshot.test.js

@@ -1,279 +0,0 @@
-"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 {
-  XimalayaAdapter,
-  SNAPSHOT_SCHEMA_VERSION,
-  VALID_KINDS,
-  extractList,
-  trackItemToRecord,
-  albumItemToRecord,
-} = require("../lib/adapters/audio-ximalaya");
-const { assertAdapter } = require("../lib/adapter-spec");
-const { validateBatch } = require("../lib/batch");
-
-// 喜马拉雅 (Ximalaya) — 听书/播客; mirrors music-kugou's play/favorite/subscribe
-// shape. signing injected (signProvider). pure-Node.
-
-function writeSnapshot(dir, snapshot) {
-  const p = path.join(dir, "audio-ximalaya.json");
-  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
-  return p;
-}
-
-describe("XimalayaAdapter snapshot mode", () => {
-  let tmpDir;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xmly-snap-"));
-  });
-
-  it("exports schema constants", () => {
-    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
-    expect(VALID_KINDS).toEqual(["play", "favorite", "subscribe"]);
-  });
-
-  it("authenticate(inputPath) ok when readable", async () => {
-    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: Date.now(), events: [] });
-    const a = new XimalayaAdapter();
-    const res = await a.authenticate({ inputPath: p });
-    expect(res.ok).toBe(true);
-    expect(res.mode).toBe("snapshot-file");
-  });
-
-  it("authenticate() no input → NO_INPUT", async () => {
-    const a = new XimalayaAdapter();
-    const res = await a.authenticate({});
-    expect(res.ok).toBe(false);
-    expect(res.reason).toBe("NO_INPUT");
-  });
-
-  it("sync() without input throws with signProvider hint", async () => {
-    const a = new XimalayaAdapter();
-    let threw = null;
-    try {
-      for await (const _r of a.sync({})) { /* drain */ }
-    } catch (err) {
-      threw = err;
-    }
-    expect(String(threw.message)).toMatch(/signProvider/);
-  });
-
-  it("rejects schemaVersion mismatch", async () => {
-    const p = writeSnapshot(tmpDir, { schemaVersion: 9, snapshottedAt: Date.now(), events: [] });
-    const a = new XimalayaAdapter();
-    let threw = null;
-    try {
-      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
-    } catch (err) {
-      threw = err;
-    }
-    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
-  });
-
-  it("play (收听节目) → MEDIA event + MEDIA item", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1, snapshottedAt: now,
-      account: { userId: "u1", name: "alice" },
-      events: [
-        { kind: "play", id: "t1", trackId: "98765", title: "第1集 三体广播剧",
-          anchor: "729声工场", album: "三体", durationSec: 1800, capturedAt: now - 1000 },
-      ],
-    });
-    const a = new XimalayaAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws.length).toBe(1);
-    expect(raws[0].originalId).toBe("ximalaya:play:t1");
-    const batch = a.normalize(raws[0]);
-    expect(validateBatch(batch).valid).toBe(true);
-    expect(batch.events[0].subtype).toBe("media");
-    expect(batch.events[0].content.title).toContain("收听: 第1集 三体广播剧 - 729声工场");
-    expect(batch.items[0].subtype).toBe("media");
-    expect(batch.items[0].name).toBe("第1集 三体广播剧 - 729声工场");
-    expect(batch.events[0].extra.album).toBe("三体");
-  });
-
-  it("favorite → LIKE event", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1, snapshottedAt: now,
-      events: [{ kind: "favorite", id: "f1", trackId: "555", title: "收藏的播客", anchor: "主播X" }],
-    });
-    const a = new XimalayaAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    const batch = a.normalize(raws[0]);
-    expect(validateBatch(batch).valid).toBe(true);
-    expect(batch.events[0].subtype).toBe("like");
-    expect(batch.events[0].content.title).toContain("收藏: 收藏的播客");
-  });
-
-  it("subscribe → TOPIC (album)", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1, snapshottedAt: now,
-      events: [{ kind: "subscribe", id: "s1", albumId: "30001", album: "得到·精英日课",
-        trackCount: 365, anchor: "罗振宇" }],
-    });
-    const a = new XimalayaAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    const batch = a.normalize(raws[0]);
-    expect(validateBatch(batch).valid).toBe(true);
-    expect(batch.events.length).toBe(0);
-    expect(batch.topics.length).toBe(1);
-    expect(batch.topics[0].id).toBe("topic-ximalaya-album-30001");
-    expect(batch.topics[0].name).toBe("得到·精英日课");
-    expect(batch.topics[0].extra.trackCount).toBe(365);
-  });
-
-  it("respects include opt-out + limit", async () => {
-    const now = Date.now();
-    const events = [
-      { kind: "play", id: "p1", trackId: "1", title: "a", capturedAt: now },
-      { kind: "favorite", id: "f1", trackId: "2", title: "b" },
-      { kind: "subscribe", id: "s1", albumId: "3", album: "c" },
-    ];
-    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
-    const a = new XimalayaAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p, include: { favorite: false, subscribe: false } })) raws.push(r);
-    expect(raws.length).toBe(1);
-    expect(raws[0].kind).toBe("play");
-  });
-
-  it("filters unknown kinds", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1, snapshottedAt: now,
-      events: [
-        { kind: "play", id: "p1", trackId: "1", title: "a", capturedAt: now },
-        { kind: "comment", id: "c1" },
-      ],
-    });
-    const a = new XimalayaAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws.length).toBe(1);
-  });
-
-  it("advertises capabilities + passes assertAdapter", () => {
-    const a = new XimalayaAdapter();
-    expect(a.capabilities).toContain("sync:snapshot");
-    expect(a.capabilities).toContain("sync:cookie-api");
-    expect(assertAdapter(a).ok).toBe(true);
-  });
-});
-
-describe("XimalayaAdapter cookie-api mode", () => {
-  it("authenticate(cookie) ok with cookies (userId optional)", async () => {
-    const a = new XimalayaAdapter({ account: { cookies: "1&_token=ok" } });
-    const res = await a.authenticate();
-    expect(res.ok).toBe(true);
-    expect(res.mode).toBe("cookie");
-  });
-
-  it("fetches plays/favorites/subscribes and normalizes", async () => {
-    const byUrl = (url) => {
-      if (url.includes("/history")) {
-        return { data: { list: [{ trackId: 98765, title: "第1集", nickname: "声工场", albumTitle: "三体", duration: 1800, startedAt: 1700000000000 }] } };
-      }
-      if (url.includes("/favorite")) {
-        return { data: { tracks: [{ track_id: 555, track_title: "播客A", anchor_name: "主播X" }] } };
-      }
-      if (url.includes("/subscribe")) {
-        return { data: { albums: [{ albumId: 30001, albumTitle: "精英日课", includeTrackCount: 365, nickname: "罗振宇" }] } };
-      }
-      return {};
-    };
-    const fetchFn = async (opts) => byUrl(opts.url);
-    const a = new XimalayaAdapter({ account: { userId: "u1", cookies: "1&_token=ok" }, fetchFn });
-    const raws = [];
-    for await (const r of a.sync({})) raws.push(r);
-    expect(raws.map((r) => r.kind).sort()).toEqual(["favorite", "play", "subscribe"]);
-
-    const play = raws.find((r) => r.kind === "play");
-    const pb = a.normalize(play);
-    expect(validateBatch(pb).valid).toBe(true);
-    expect(pb.events[0].content.title).toContain("收听: 第1集 - 声工场");
-    expect(pb.items[0].name).toBe("第1集 - 声工场");
-
-    const sub = raws.find((r) => r.kind === "subscribe");
-    const sb = a.normalize(sub);
-    expect(sb.topics[0].name).toBe("精英日课");
-    expect(sb.topics[0].extra.trackCount).toBe(365);
-  });
-
-  it("invokes signProvider, passes sign to fetchFn", async () => {
-    let seen = null;
-    const signProvider = async () => "SIG";
-    const fetchFn = async (opts) => {
-      seen = opts.sign;
-      return {};
-    };
-    const a = new XimalayaAdapter({ account: { cookies: "x=1" }, fetchFn, signProvider });
-    for await (const _r of a.sync({ include: { favorite: false, subscribe: false } })) { /* drain */ }
-    expect(seen).toBe("SIG");
-  });
-
-  it("paginates plays until short page", async () => {
-    const all = Array.from({ length: 45 }, (_, i) => ({ trackId: i + 1, title: `t${i}`, startedAt: 1700000000000 }));
-    const seenPages = [];
-    const fetchFn = async (opts) => {
-      if (!opts.url.includes("/history")) return {};
-      const page = opts.query.page;
-      seenPages.push(page);
-      return { list: all.slice((page - 1) * 30, page * 30) };
-    };
-    const a = new XimalayaAdapter({ account: { cookies: "x=1" }, fetchFn });
-    const raws = [];
-    for await (const r of a.sync({ include: { favorite: false, subscribe: false } })) raws.push(r);
-    expect(raws.length).toBe(45);
-    expect(seenPages).toEqual([1, 2]);
-  });
-
-  it("extractList + item mappers tolerate shapes", () => {
-    expect(extractList({ list: [1] })).toEqual([1]);
-    expect(extractList({ data: { tracks: [2] } })).toEqual([2]);
-    expect(extractList({ data: { albums: [3] } })).toEqual([3]);
-    expect(extractList(null)).toEqual([]);
-    expect(trackItemToRecord({ trackId: 7, title: "x" }).trackId).toBe("7");
-    expect(trackItemToRecord({})).toBe(null);
-    expect(albumItemToRecord({ albumId: 9, albumTitle: "A" }).album).toBe("A");
-    expect(albumItemToRecord({})).toBe(null);
-  });
-
-  it("uses opts.*Url overrides", async () => {
-    const seen = [];
-    const fetchFn = async (opts) => {
-      seen.push(opts.url);
-      return {};
-    };
-    const a = new XimalayaAdapter({
-      account: { cookies: "x=1" },
-      fetchFn,
-      playsUrl: "https://x/p",
-      favoritesUrl: "https://x/f",
-      subscribesUrl: "https://x/s",
-    });
-    for await (const _r of a.sync({})) { /* drain */ }
-    expect(seen).toEqual(["https://x/p", "https://x/f", "https://x/s"]);
-  });
-
-  it("default fetchFn throws legible error", async () => {
-    const a = new XimalayaAdapter({ account: { cookies: "x=1" } });
-    let threw = null;
-    try {
-      for await (const _r of a.sync({})) { /* drain */ }
-    } catch (err) {
-      threw = err;
-    }
-    expect(String(threw.message)).toMatch(/no fetchFn configured/);
-  });
-});

package/__tests__/batch.test.js

@@ -1,133 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { emptyBatch, mergeBatches, validateBatch, partitionBatch } = require("../lib/batch");
-const { newId } = require("../lib/ids");
-
-const source = () => ({
-  adapter: "test",
-  adapterVersion: "0.1.0",
-  capturedAt: Date.now(),
-  capturedBy: "api",
-});
-
-const goodEvent = () => ({
-  id: newId(),
-  type: "event",
-  subtype: "order",
-  occurredAt: Date.now(),
-  ingestedAt: Date.now(),
-  content: { title: "X" },
-  source: source(),
-});
-
-const goodPerson = () => ({
-  id: newId(),
-  type: "person",
-  subtype: "merchant",
-  names: ["美团"],
-  ingestedAt: Date.now(),
-  source: source(),
-});
-
-const badEvent = () => ({
-  // missing required occurredAt + source + content
-  id: newId(),
-  type: "event",
-  subtype: "order",
-  ingestedAt: Date.now(),
-});
-
-describe("emptyBatch", () => {
-  it("returns shape with all 5 entity arrays", () => {
-    const b = emptyBatch();
-    expect(b).toEqual({ events: [], persons: [], places: [], items: [], topics: [] });
-  });
-});
-
-describe("mergeBatches", () => {
-  it("concatenates all 5 arrays", () => {
-    const a = { ...emptyBatch(), events: [goodEvent()], persons: [goodPerson()] };
-    const b = { ...emptyBatch(), events: [goodEvent()] };
-    const merged = mergeBatches(a, b);
-    expect(merged.events.length).toBe(2);
-    expect(merged.persons.length).toBe(1);
-    expect(merged.places.length).toBe(0);
-  });
-
-  it("tolerates missing arrays in either input", () => {
-    const merged = mergeBatches({}, { persons: [goodPerson()] });
-    expect(merged.persons.length).toBe(1);
-    expect(merged.events.length).toBe(0);
-  });
-});
-
-describe("validateBatch", () => {
-  it("returns valid=true for an all-good batch", () => {
-    const r = validateBatch({ events: [goodEvent(), goodEvent()], persons: [goodPerson()] });
-    expect(r.valid).toBe(true);
-    expect(r.entityCount).toBe(3);
-    expect(r.errorCount).toBe(0);
-  });
-
-  it("collects all errors instead of throwing", () => {
-    const r = validateBatch({ events: [goodEvent(), badEvent(), badEvent()] });
-    expect(r.valid).toBe(false);
-    expect(r.entityCount).toBe(3);
-    expect(r.errorCount).toBe(2);
-    expect(r.errors.every((e) => e.kind === "events")).toBe(true);
-    expect(r.errors[0]).toHaveProperty("index");
-    expect(r.errors[0].errors.length).toBeGreaterThan(0);
-  });
-
-  it("rejects non-array entity buckets", () => {
-    const r = validateBatch({ events: "not-an-array" });
-    expect(r.valid).toBe(false);
-    expect(r.errors[0].errors[0]).toMatch(/array/);
-  });
-
-  it("rejects non-object batch", () => {
-    expect(validateBatch(null).valid).toBe(false);
-    expect(validateBatch("string").valid).toBe(false);
-  });
-
-  it("accepts batch with only some entity types populated", () => {
-    const r = validateBatch({ persons: [goodPerson()] });
-    expect(r.valid).toBe(true);
-    expect(r.entityCount).toBe(1);
-  });
-});
-
-describe("partitionBatch", () => {
-  it("separates valid from invalid into distinct sub-batches", () => {
-    const gE = goodEvent();
-    const bE = badEvent();
-    const gP = goodPerson();
-
-    const { valid, invalid, invalidReasons } = partitionBatch({
-      events: [gE, bE],
-      persons: [gP],
-    });
-
-    expect(valid.events).toEqual([gE]);
-    expect(valid.persons).toEqual([gP]);
-    expect(invalid.events).toEqual([bE]);
-    expect(invalid.persons).toEqual([]);
-    expect(invalidReasons.length).toBe(1);
-    expect(invalidReasons[0].kind).toBe("events");
-    expect(invalidReasons[0].id).toBe(bE.id);
-  });
-
-  it("returns empty invalid sub-batch when all rows are valid", () => {
-    const { valid, invalid, invalidReasons } = partitionBatch({
-      events: [goodEvent()],
-      persons: [goodPerson()],
-    });
-    expect(invalid.events).toEqual([]);
-    expect(invalid.persons).toEqual([]);
-    expect(invalidReasons).toEqual([]);
-    expect(valid.events.length).toBe(1);
-    expect(valid.persons.length).toBe(1);
-  });
-});

package/__tests__/bridges-cc-kg.test.js

@@ -1,231 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { CcKgSink, HUB_TO_CC_TYPE } = require("../lib/bridges/cc-kg-sink");
-
-// ─── Fake cc KG (mirrors the real addEntity/addRelation signature) ──────
-
-function makeFakeKg() {
-  const entities = new Map();
-  const relations = [];
-  return {
-    addEntity(_db, cfg) {
-      if (!cfg || !cfg.id || !cfg.name || !cfg.type) {
-        throw new Error("missing required fields");
-      }
-      if (entities.has(cfg.id)) {
-        throw new Error(`Entity already exists: ${cfg.id}`);
-      }
-      entities.set(cfg.id, { ...cfg });
-      return cfg;
-    },
-    addRelation(_db, cfg) {
-      if (!entities.has(cfg.sourceId)) throw new Error(`source not found: ${cfg.sourceId}`);
-      if (!entities.has(cfg.targetId)) throw new Error(`target not found: ${cfg.targetId}`);
-      relations.push({ ...cfg });
-      return cfg;
-    },
-    entities,
-    relations,
-  };
-}
-
-const t = (subject, predicate, opts) => {
-  const out = { subject, predicate };
-  if (opts && opts.object) out.object = opts.object;
-  else if (opts && opts.literal !== undefined) out.literal = opts.literal;
-  return out;
-};
-
-// ─── Tests ──────────────────────────────────────────────────────────────
-
-describe("CcKgSink construction", () => {
-  it("requires addEntity + addRelation", () => {
-    expect(() => new CcKgSink()).toThrow();
-    expect(() => new CcKgSink({ addRelation: () => {} })).toThrow(/addEntity/);
-    expect(() => new CcKgSink({ addEntity: () => {} })).toThrow(/addRelation/);
-  });
-});
-
-describe("CcKgSink.write entity creation", () => {
-  it("creates entities from rdf:type + has-name triples", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    const r = await sink.write([
-      t("p1", "rdf:type", { literal: "person" }),
-      t("p1", "subtype", { literal: "contact" }),
-      t("p1", "has-name", { literal: "妈妈" }),
-      t("p1", "has-name", { literal: "陈某某" }),
-      t("p1", "id:phone", { literal: "13800001111" }),
-    ]);
-    expect(r.entitiesUpserted).toBe(1);
-    const e = cc.entities.get("p1");
-    expect(e.type).toBe("Person");
-    expect(e.name).toBe("妈妈"); // first name wins
-    expect(e.properties.subtype).toBe("contact");
-    expect(e.properties.hubKind).toBe("person");
-    expect(e.properties.aliases).toEqual(["陈某某"]);
-    expect(e.properties["id:phone"]).toBe("13800001111");
-  });
-
-  it("maps hub place → cc Concept with hubKind", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([
-      t("pl1", "rdf:type", { literal: "place" }),
-      t("pl1", "has-name", { literal: "妈妈家" }),
-      t("pl1", "located-at", { literal: "24.5,118.1" }),
-    ]);
-    const e = cc.entities.get("pl1");
-    expect(e.type).toBe("Concept");
-    expect(e.properties.hubKind).toBe("place");
-    expect(e.properties["located-at"]).toBe("24.5,118.1");
-  });
-
-  it("maps hub item / topic → cc Concept", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([
-      t("i1", "rdf:type", { literal: "item" }),
-      t("i1", "has-name", { literal: "蛋白粉" }),
-      t("t1", "rdf:type", { literal: "topic" }),
-      t("t1", "has-name", { literal: "母亲健康" }),
-    ]);
-    expect(cc.entities.get("i1").type).toBe("Concept");
-    expect(cc.entities.get("i1").properties.hubKind).toBe("item");
-    expect(cc.entities.get("t1").type).toBe("Concept");
-    expect(cc.entities.get("t1").properties.hubKind).toBe("topic");
-  });
-
-  it("falls back to subject id when no has-name (uses Event subject as name)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([
-      t("evt-x", "rdf:type", { literal: "event" }),
-      t("evt-x", "subtype", { literal: "order" }),
-    ]);
-    expect(cc.entities.get("evt-x").name).toBe("evt-x");
-    expect(cc.entities.get("evt-x").type).toBe("Event");
-  });
-
-  it("treats 'already exists' as upsert success (no error)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([
-      t("p1", "rdf:type", { literal: "person" }),
-      t("p1", "has-name", { literal: "alice" }),
-    ]);
-    // Second write of same subject — cc throws "already exists"
-    const r = await sink.write([
-      t("p1", "rdf:type", { literal: "person" }),
-      t("p1", "has-name", { literal: "alice" }),
-    ]);
-    expect(r.entitiesUpserted).toBe(0);
-    expect(r.errors.length).toBe(0); // already-exists treated as upsert hit
-  });
-
-  it("captures unknown predicates under __extra", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([
-      t("evt-x", "rdf:type", { literal: "event" }),
-      t("evt-x", "weird-predicate", { literal: "foo" }),
-    ]);
-    expect(cc.entities.get("evt-x").properties.__extra).toEqual({ "weird-predicate": "foo" });
-  });
-
-  it("collects upstream errors (e.g. missing required field)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({
-      addEntity: () => { throw new Error("upstream DB exploded"); },
-      addRelation: cc.addRelation,
-    });
-    const r = await sink.write([t("p1", "rdf:type", { literal: "person" })]);
-    expect(r.entitiesUpserted).toBe(0);
-    expect(r.errors.length).toBe(1);
-    expect(r.errors[0].error).toContain("upstream DB exploded");
-  });
-});
-
-describe("CcKgSink.write relation creation", () => {
-  it("adds relations between created entities", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    const r = await sink.write([
-      t("evt-1", "rdf:type", { literal: "event" }),
-      t("evt-1", "subtype", { literal: "payment" }),
-      t("p1", "rdf:type", { literal: "person" }),
-      t("p1", "has-name", { literal: "mom" }),
-      t("evt-1", "by", { object: "p1" }),
-      t("evt-1", "involves", { object: "p1" }),
-    ]);
-    expect(r.entitiesUpserted).toBe(2);
-    expect(r.relationsAdded).toBe(2);
-    expect(cc.relations).toContainEqual({ sourceId: "evt-1", targetId: "p1", relationType: "by" });
-    expect(cc.relations).toContainEqual({ sourceId: "evt-1", targetId: "p1", relationType: "involves" });
-  });
-
-  it("skips relation when endpoint not in KG (no dangling refs)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    const r = await sink.write([
-      t("evt-1", "rdf:type", { literal: "event" }),
-      // p-missing was never declared with rdf:type
-      t("evt-1", "by", { object: "p-missing" }),
-    ]);
-    expect(r.relationsAdded).toBe(0);
-    expect(r.errors.length).toBe(1);
-    expect(r.errors[0].error).toContain("endpoint not in KG");
-  });
-
-  it("rejects unknown predicates (defensive — don't poison cc KG)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    await sink.write([t("e", "rdf:type", { literal: "event" })]);
-    await sink.write([t("p", "rdf:type", { literal: "person" })]);
-    const r = await sink.write([t("e", "frobnicate", { object: "p" })]);
-    expect(r.relationsAdded).toBe(0);
-    expect(r.errors[0].error).toBe("unknown predicate");
-  });
-
-  it("tolerates duplicate-relation errors as success", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({
-      addEntity: cc.addEntity,
-      addRelation: () => { throw new Error("Relation already exists"); },
-    });
-    await sink.write([
-      t("e", "rdf:type", { literal: "event" }),
-      t("p", "rdf:type", { literal: "person" }),
-    ]);
-    const r = await sink.write([t("e", "by", { object: "p" })]);
-    // Even though addRelation throws "already exists", sink treats as success.
-    expect(r.errors.length).toBe(0);
-  });
-});
-
-describe("CcKgSink edge cases", () => {
-  it("returns zeros for empty input", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    const r = await sink.write([]);
-    expect(r).toEqual({ entitiesUpserted: 0, relationsAdded: 0, errors: [] });
-  });
-
-  it("ignores malformed triples (missing subject/predicate)", async () => {
-    const cc = makeFakeKg();
-    const sink = new CcKgSink({ addEntity: cc.addEntity, addRelation: cc.addRelation });
-    const r = await sink.write([{ predicate: "rdf:type", literal: "person" }, null, undefined]);
-    expect(r.entitiesUpserted).toBe(0);
-    expect(cc.entities.size).toBe(0);
-  });
-
-  it("HUB_TO_CC_TYPE exposes the documented mapping", () => {
-    expect(HUB_TO_CC_TYPE.person).toBe("Person");
-    expect(HUB_TO_CC_TYPE.event).toBe("Event");
-    expect(HUB_TO_CC_TYPE.place).toBe("Concept");
-    expect(HUB_TO_CC_TYPE.item).toBe("Concept");
-    expect(HUB_TO_CC_TYPE.topic).toBe("Concept");
-  });
-});