@warpgogol/werkstatt-shared 0.13.0 → 0.14.1

package/src/share/semantic/extract.ts

@@ -68,8 +68,32 @@ const SENTENCE_ABBREVIATIONS: Record<string, string[]> = {
     "u.",
     "vgl.",
     "bspw.",
+    "zzgl.",
+    "inkl.",
+    "exkl.",
+    "bzw.",
+    "ggf.",
+    "ggfls.",
+    "sog.",
+    "o.Ä.",
+  ],
+  uk: [
+    "т.д.",
+    "т.п.",
+    "п.",
+    "ст.",
+    "див.",
+    "пор.",
+    "напр.",
+    "ім.",
+    "о.",
+    "вкл.",
+    "тис.",
+    "млн.",
+    "млрд.",
+    "грн.",
+    "№",
   ],
-  uk: ["т.д.", "т.п.", "п.", "ст.", "див.", "пор.", "напр.", "ім.", "о."],
   en: ["e.g.", "i.e.", "etc.", "vs.", "Mr.", "Mrs.", "Dr.", "Inc.", "Ltd."],
 };
 

package/src/share/semantic/jsonld/tests/article.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { buildArticleNode } from "../article.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildArticleNode", () => {
+  it("returns null when page has no datePublished", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildArticleNode(ctx)).toBeNull();
+  });
+
+  it("builds Article/BlogPosting node with datePublished", () => {
+    const page = makePage({ datePublished: "2024-01-15" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toEqual(["Article", "BlogPosting"]);
+    expect(node!.datePublished).toBe("2024-01-15");
+    expect(node!.dateModified).toBe("2024-01-15");
+    expect(node!.headline).toBe("Test Heading");
+    expect(node!.inLanguage).toBe("de");
+    expect(node!.publisher).toEqual({ "@id": ctx.ids.organization });
+  });
+
+  it("uses dateModified when provided", () => {
+    const page = makePage({ datePublished: "2024-01-15", dateModified: "2024-06-01" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.dateModified).toBe("2024-06-01");
+  });
+
+  it("emits author as Person when author string is present", () => {
+    const page = makePage({ datePublished: "2024-01-15", author: "Jane Doe" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.author).toEqual({ "@type": "Person", name: "Jane Doe" });
+  });
+
+  it("emits structured author from authorRecord", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      authorRecord: { name: "Jane Doe", contactUrl: "https://example.com/contact" },
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.author).toEqual({
+      "@type": "Person",
+      name: "Jane Doe",
+      url: "https://example.com/contact",
+    });
+  });
+
+  it("emits keywords as comma-separated string", () => {
+    const page = makePage({ datePublished: "2024-01-15", keywords: ["foo", "bar"] });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.keywords).toBe("foo, bar");
+  });
+
+  it("emits image from primaryImage", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      primaryImage: { url: "https://example.com/img.jpg" },
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.image).toBe("https://example.com/img.jpg");
+  });
+
+  it("uses page URL as mainEntityOfPage for ratgeber depth-1", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      surfaceId: "ratgeber",
+      depth: 1,
+      url: "https://example.com/de/ratgeber/article/",
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.mainEntityOfPage).toBe("https://example.com/de/ratgeber/article/");
+  });
+
+  it("uses webpage @id as mainEntityOfPage for non-ratgeber pages", () => {
+    const page = makePage({ datePublished: "2024-01-15" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.mainEntityOfPage).toEqual({ "@id": ctx.webpageId });
+  });
+});

package/src/share/semantic/jsonld/tests/breadcrumb.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { buildBreadcrumbNode } from "../breadcrumb.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildBreadcrumbNode", () => {
+  it("returns null when only one breadcrumb", () => {
+    const page = makePage({
+      breadcrumbs: [{ name: "Home", url: "https://example.com/de/" }],
+    });
+    const ctx = createJsonLdContext(page);
+    expect(buildBreadcrumbNode(ctx)).toBeNull();
+  });
+
+  it("builds BreadcrumbList with multiple crumbs", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "About", url: "https://example.com/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("BreadcrumbList");
+    expect(node!.itemListElement).toHaveLength(2);
+    expect(node as Record<string, unknown>).toMatchObject({
+      itemListElement: [
+        { position: 1, name: "Home" },
+        { position: 2, name: "About" },
+      ],
+    });
+  });
+
+  it("resolves relative crumb URLs against page URL", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "/de/" },
+        { name: "About", url: "/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0].item).toBe("https://example.com/de/");
+    expect(items[1].item).toBe("https://example.com/de/about/");
+  });
+
+  it("assigns position-scoped @id to each crumb", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "About", url: "https://example.com/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0]["@id"]).toBe(`${ctx.breadcrumbId}/1`);
+    expect(items[1]["@id"]).toBe(`${ctx.breadcrumbId}/2`);
+  });
+});

package/src/share/semantic/jsonld/tests/collection-list.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { buildCollectionListNode } from "../collection-list.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildCollectionListNode", () => {
+  it("returns null when page is not collection type", () => {
+    const page = makePage({ type: "content" });
+    const ctx = createJsonLdContext(page);
+    expect(buildCollectionListNode(ctx)).toBeNull();
+  });
+
+  it("returns null when collection has no items", () => {
+    const page = makePage({ type: "collection", collectionItems: [] });
+    const ctx = createJsonLdContext(page);
+    expect(buildCollectionListNode(ctx)).toBeNull();
+  });
+
+  it("builds ItemList for collection page with items", () => {
+    const page = makePage({
+      type: "collection",
+      collectionItems: [
+        { url: "https://example.com/de/industry-a/", name: "Industry A" },
+        { url: "https://example.com/de/industry-b/", name: "Industry B" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildCollectionListNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("ItemList");
+    expect(node!.itemListElement).toHaveLength(2);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0]).toMatchObject({
+      position: 1,
+      url: "https://example.com/de/industry-a/",
+      name: "Industry A",
+    });
+  });
+});

package/src/share/semantic/jsonld/tests/faq.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { buildFaqNodes, buildFaqPageNode } from "../faq.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildFaqPageNode", () => {
+  it("returns null when no faqEntries", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqPageNode(ctx)).toBeNull();
+  });
+
+  it("returns null when faqEntries is empty", () => {
+    const page = makePage({ faqEntries: [] });
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqPageNode(ctx)).toBeNull();
+  });
+
+  it("builds FAQPage with Question nodes", () => {
+    const page = makePage({
+      faqEntries: [
+        { id: "q1", question: "What is this?", answer: "A test." },
+        { id: "q2", question: "How much?", answer: "Free." },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildFaqPageNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("FAQPage");
+    expect(node!.mainEntity).toHaveLength(2);
+    const entities = (node as Record<string, unknown[]>).mainEntity as Record<string, unknown>[];
+    expect(entities[0]).toEqual({
+      "@type": "Question",
+      name: "What is this?",
+      acceptedAnswer: { "@type": "Answer", text: "A test." },
+    });
+  });
+});
+
+describe("buildFaqNodes", () => {
+  it("suppresses FAQPage on ratgeber depth-1 article pages", () => {
+    const page = makePage({
+      surfaceId: "ratgeber",
+      depth: 1,
+      faqEntries: [{ id: "q1", question: "Q?", answer: "A." }],
+    });
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqNodes(ctx)).toEqual([]);
+  });
+
+  it("emits FAQPage for non-ratgeber pages with FAQ entries", () => {
+    const page = makePage({
+      faqEntries: [{ id: "q1", question: "Q?", answer: "A." }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildFaqNodes(ctx);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]["@type"]).toBe("FAQPage");
+  });
+});

package/src/share/semantic/jsonld/tests/initiative.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { buildInitiativeNodes, buildInitiativesListNode } from "../initiative.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildInitiativeNodes", () => {
+  it("returns empty array when no initiatives", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildInitiativeNodes(ctx)).toEqual([]);
+  });
+
+  it("builds Thing/Project nodes for each initiative", () => {
+    const page = makePage({
+      initiatives: [
+        { id: "i1", name: "Project Alpha", summary: "First project" },
+        { id: "i2", name: "Project Beta", summary: "Second project" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildInitiativeNodes(ctx);
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0]["@type"]).toEqual(["Thing", "Project"]);
+    expect(nodes[0].name).toBe("Project Alpha");
+    expect(nodes[0].description).toBe("First project");
+    expect(nodes[1].name).toBe("Project Beta");
+  });
+});
+
+describe("buildInitiativesListNode", () => {
+  it("returns null when no initiatives", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildInitiativesListNode(ctx)).toBeNull();
+  });
+
+  it("builds ItemList with positioned initiatives", () => {
+    const page = makePage({
+      initiatives: [
+        { id: "i1", name: "Project Alpha", summary: "First" },
+        { id: "i2", name: "Project Beta", summary: "Second" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildInitiativesListNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("ItemList");
+    expect(node!.itemListElement).toHaveLength(2);
+    expect(node as Record<string, unknown>).toMatchObject({
+      itemListElement: [
+        { position: 1, name: "Project Alpha" },
+        { position: 2, name: "Project Beta" },
+      ],
+    });
+  });
+});

package/src/share/semantic/jsonld/tests/organization.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { buildOrganizationNode } from "../organization.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildOrganizationNode", () => {
+  it("builds Organization node with default schemaType", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node["@type"]).toEqual(["Organization", "NGO"]);
+    expect(node["@id"]).toBe(ctx.ids.organization);
+    expect(node.name).toBe("Warpgogol");
+    expect(node.description).toBe("Digital infrastructure for nonprofits");
+    expect(node.url).toBe("https://example.com");
+  });
+
+  it("uses custom schemaType when provided", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.schemaType = ["Organization", "ProfessionalService"];
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node["@type"]).toEqual(["Organization", "ProfessionalService"]);
+  });
+
+  it("emits legalName, email, foundingYear, registration when present", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.legalName = "Warpgogol GmbH";
+    page.organization.email = "info@example.com";
+    page.organization.foundingYear = "2020";
+    page.organization.registration = "HRB 12345";
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.legalName).toBe("Warpgogol GmbH");
+    expect(node.email).toBe("info@example.com");
+    expect(node.foundingDate).toBe("2020");
+    expect(node.identifier).toBe("HRB 12345");
+  });
+
+  it("emits address when present", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.address = {
+      streetAddress: "Test Str. 1",
+      postalCode: "12345",
+      addressLocality: "Berlin",
+      addressCountry: "DE",
+    };
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.address).toEqual({
+      "@type": "PostalAddress",
+      streetAddress: "Test Str. 1",
+      postalCode: "12345",
+      addressLocality: "Berlin",
+      addressCountry: "DE",
+    });
+  });
+
+  it("emits contactPoints when present", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.contactPoints = [
+      { contactType: "customer service", email: "support@example.com" },
+    ];
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.contactPoint).toHaveLength(1);
+    expect((node.contactPoint as unknown[])[0]).toMatchObject({
+      "@type": "ContactPoint",
+      contactType: "customer service",
+      email: "support@example.com",
+    });
+  });
+
+  it("emits sameAs links", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.sameAs = ["https://twitter.com/example", "https://github.com/example"];
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.sameAs).toEqual(["https://twitter.com/example", "https://github.com/example"]);
+  });
+
+  it("emits logo and image", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.logo = "https://example.com/logo.png";
+    page.organization.image = "https://example.com/image.png";
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.logo).toEqual({ "@type": "ImageObject", url: "https://example.com/logo.png" });
+    expect(node.image).toBe("https://example.com/image.png");
+  });
+
+  it("emits founders as Person references", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.founders = [{ name: "Jane Doe" }];
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.founder).toEqual([{ "@id": ctx.ids.person("Jane Doe") }]);
+  });
+
+  it("emits areaServed when present", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.areaServed = ["Berlin", "Brandenburg"];
+    const ctx = createJsonLdContext(page);
+    const node = buildOrganizationNode(ctx);
+    expect(node.areaServed).toEqual(["Berlin", "Brandenburg"]);
+  });
+});

package/src/share/semantic/jsonld/tests/person.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { buildPersonNodes } from "../person.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildPersonNodes", () => {
+  it("returns empty array when no people, founders, or boardMembers", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildPersonNodes(ctx)).toEqual([]);
+  });
+
+  it("builds Person nodes from page.people", () => {
+    const page = makePage({
+      people: [{ name: "Jane Doe", role: "CEO", description: "A leader" }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildPersonNodes(ctx);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]["@type"]).toBe("Person");
+    expect(nodes[0].name).toBe("Jane Doe");
+    expect(nodes[0].jobTitle).toBe("CEO");
+    expect(nodes[0].description).toBe("A leader");
+    expect(nodes[0].worksFor).toEqual({ "@id": ctx.ids.organization });
+  });
+
+  it("merges founders, boardMembers, and people with deduplication by name", () => {
+    const page = makePage({
+      organization: makePage().organization,
+      people: [{ name: "Jane Doe", role: "CEO" }],
+    });
+    page.organization.founders = [{ name: "Jane Doe", role: "Founder" }];
+    page.organization.boardMembers = [{ name: "John Smith", role: "Board Member" }];
+    const ctx = createJsonLdContext(page);
+    const nodes = buildPersonNodes(ctx);
+    expect(nodes).toHaveLength(2);
+    const names = nodes.map((n) => n.name);
+    expect(names).toContain("Jane Doe");
+    expect(names).toContain("John Smith");
+  });
+
+  it("emits extended fields (address, knowsAbout, affiliation)", () => {
+    const page = makePage({
+      people: [
+        {
+          name: "Jane Doe",
+          address: { addressLocality: "Berlin", addressCountry: "DE" },
+          knowsAbout: ["AI", "Cloud"],
+          affiliation: { name: "Warpgogol", url: "https://example.com" },
+        },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildPersonNodes(ctx);
+    expect(nodes[0].address).toEqual({
+      "@type": "PostalAddress",
+      addressLocality: "Berlin",
+      addressCountry: "DE",
+    });
+    expect(nodes[0].knowsAbout).toEqual(["AI", "Cloud"]);
+    expect(nodes[0].affiliation).toEqual({
+      "@type": "Organization",
+      name: "Warpgogol",
+      url: "https://example.com",
+    });
+  });
+
+  it("emits birthDate, deathDate, image, sameAs, profileUrl", () => {
+    const page = makePage({
+      people: [
+        {
+          name: "Jane Doe",
+          birthDate: "1980",
+          deathDate: "2024",
+          image: "https://example.com/jane.jpg",
+          sameAs: ["https://linkedin.com/in/jane"],
+          profileUrl: "https://example.com/de/team/jane/",
+        },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildPersonNodes(ctx);
+    expect(nodes[0].birthDate).toBe("1980");
+    expect(nodes[0].deathDate).toBe("2024");
+    expect(nodes[0].image).toBe("https://example.com/jane.jpg");
+    expect(nodes[0].sameAs).toEqual(["https://linkedin.com/in/jane"]);
+    expect(nodes[0].url).toBe("https://example.com/de/team/jane/");
+  });
+});

package/src/share/semantic/jsonld/tests/service.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { buildServiceNodes } from "../service.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildServiceNodes", () => {
+  it("returns org-level Service nodes for non-surface pages", () => {
+    const page = makePage({
+      organization: makePage().organization,
+    });
+    page.organization.services = [
+      { id: "s1", name: "Hosting", description: "Managed hosting" },
+      { id: "s2", name: "Security" },
+    ];
+    const ctx = createJsonLdContext(page);
+    const nodes = buildServiceNodes(ctx);
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0]["@type"]).toBe("Service");
+    expect(nodes[0].name).toBe("Hosting");
+    expect(nodes[0].description).toBe("Managed hosting");
+    expect(nodes[0].provider).toEqual({ "@id": ctx.ids.organization });
+  });
+
+  it("emits industry-specific Service node when industryService is present", () => {
+    const page = makePage({
+      surfaceId: "website-local",
+      depth: 1,
+      industryService: {
+        serviceType: "Web Development",
+        audience: "Nonprofits",
+        description: "Custom web development",
+        areaServed: "Berlin",
+      },
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildServiceNodes(ctx);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]["@type"]).toBe("Service");
+    expect(nodes[0].serviceType).toBe("Web Development");
+    expect(nodes[0].audience).toEqual({ "@type": "Audience", name: "Nonprofits" });
+    expect(nodes[0].areaServed).toEqual({ "@type": "City", name: "Berlin" });
+  });
+
+  it("suppresses Service nodes for surface pages without industryService at prohibited depths", () => {
+    const page = makePage({
+      surfaceId: "website-local",
+      depth: 0,
+    });
+    const ctx = createJsonLdContext(page);
+    expect(buildServiceNodes(ctx)).toEqual([]);
+  });
+
+  it("emits org-level Service nodes for surface depth-1 without industryService", () => {
+    const page = makePage({
+      surfaceId: "website-local",
+      depth: 1,
+      organization: makePage().organization,
+    });
+    page.organization.services = [{ id: "s1", name: "Consulting" }];
+    const ctx = createJsonLdContext(page);
+    const nodes = buildServiceNodes(ctx);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].name).toBe("Consulting");
+  });
+});

package/src/share/semantic/jsonld/tests/shared.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { dedupeGraph } from "../shared.ts";
+import type { JsonLdNode } from "../types.ts";
+
+describe("dedupeGraph", () => {
+  it("returns empty array for empty input", () => {
+    expect(dedupeGraph([])).toEqual([]);
+  });
+
+  it("removes duplicate nodes by @id", () => {
+    const nodes: JsonLdNode[] = [
+      { "@id": "org-1", "@type": "Organization", name: "Org" },
+      { "@id": "org-1", "@type": "Organization", name: "Duplicate" },
+      { "@id": "org-2", "@type": "Organization", name: "Other" },
+    ];
+    const result = dedupeGraph(nodes);
+    expect(result).toHaveLength(2);
+    expect(result[0]["@id"]).toBe("org-1");
+    expect(result[0].name).toBe("Org");
+    expect(result[1]["@id"]).toBe("org-2");
+  });
+
+  it("preserves first occurrence of duplicates", () => {
+    const nodes: JsonLdNode[] = [
+      { "@id": "a", value: "first" },
+      { "@id": "a", value: "second" },
+    ];
+    const result = dedupeGraph(nodes);
+    expect(result).toHaveLength(1);
+    expect(result[0].value).toBe("first");
+  });
+
+  it("keeps nodes without @id", () => {
+    const nodes: JsonLdNode[] = [
+      { "@type": "Thing", name: "No ID" },
+      { "@type": "Thing", name: "Also No ID" },
+    ];
+    const result = dedupeGraph(nodes);
+    expect(result).toHaveLength(2);
+  });
+});