@warpgogol/werkstatt-shared 0.2.0

package/src/share/tests/hero-section-numbering-parity.test.ts

@@ -0,0 +1,51 @@
+import { test, expect } from "vitest";
+import { buildPage, type PageEntry } from "../page.ts";
+import { EMPTY_RUNTIME_CONTEXT } from "../runtime-context.ts";
+
+/*
+<MODULE_CONTRACT>
+<purpose>
+  RFC-0263: parity fixture — captures buildPage's hideSectionNumber injection
+  behavior for hero-role blocks (Europa, Phobos) and confirms a non-hero block
+  never receives the prop. Written against the roleByCosmicName-driven
+  implementation (which replaced the UNNUMBERED_HERO_PLANETS literal set) to
+  guard byte-identical output going forward.
+</purpose>
+</MODULE_CONTRACT>
+*/
+
+function fixtureEntry(): PageEntry {
+  return {
+    kind: "page",
+    cosmicStar: "TestStar",
+    title: "Test",
+    description: "Test page",
+    lang: "en",
+    blocks: [
+      { id: "hero-block", type: "Europa", props: { title: "Hero" } }, // cosmic-literals-ignore: fixture cosmicName for the hero-role parity assertion
+      { id: "hero-decision-block", type: "Phobos", props: { title: "Decision hero" } }, // cosmic-literals-ignore: fixture cosmicName for the hero-role parity assertion
+      { id: "problem-block", type: "Callisto", props: { title: "Problem" } }, // cosmic-literals-ignore: fixture cosmicName for the non-hero control assertion
+    ],
+  };
+}
+
+test("buildPage: hero-role blocks (Europa, Phobos) get hideSectionNumber injected", async () => {
+  const entry = fixtureEntry();
+  const ctx = EMPTY_RUNTIME_CONTEXT("en");
+
+  const page = await buildPage(entry, ctx, {
+    resolveImportPath: () => "@warpgogol/werkstatt-site/ui/sections/fixture-section.astro",
+  });
+
+  expect(page.blocks.length).toBe(3);
+
+  const hero = page.blocks.find((b) => b.id === "hero-block");
+  expect(hero?.props).toEqual({ title: "Hero", hideSectionNumber: true });
+
+  const heroDecision = page.blocks.find((b) => b.id === "hero-decision-block");
+  expect(heroDecision?.props).toEqual({ title: "Decision hero", hideSectionNumber: true });
+
+  const problem = page.blocks.find((b) => b.id === "problem-block");
+  expect(problem?.props).toEqual({ title: "Problem" });
+  expect("hideSectionNumber" in (problem?.props ?? {})).toBe(false);
+});

package/src/share/tests/image-sitemap.test.ts

@@ -0,0 +1,101 @@
+import { test, expect } from "vitest";
+import {
+  harvestContentImage,
+  generateImageSitemapXml,
+  isHtmlRedirectPage,
+  isSyntheticPreviewUrl,
+  type SitemapImageEntry,
+} from "../semantic/image-sitemap.ts";
+
+const SITE = "https://example.org";
+
+test("harvests a hero data-content-image and absolutizes the /_astro src", () => {
+  const html = `
+    <link rel="canonical" href="https://example.org/de/about">
+    <img src="/_astro/hero-1.BEybXadf.webp" alt="A photo" class="hero__portrait-image" data-content-image>
+  `;
+  const r = harvestContentImage(html, SITE);
+  expect(r.loc).toBe("https://example.org/de/about");
+  expect(r.imageUrls).toEqual(["https://example.org/_astro/hero-1.BEybXadf.webp"]);
+  expect(r.title).toBe("A photo");
+});
+
+test("harvests the authored x-content-image head signal", () => {
+  const html = `
+    <link rel="canonical" href="https://example.org/">
+    <meta name="x-content-image" content="https://cdn.example.org/lead.webp">
+    <meta property="og:image:alt" content="Lead alt">
+  `;
+  const r = harvestContentImage(html, SITE);
+  expect(r.imageUrls).toEqual(["https://cdn.example.org/lead.webp"]);
+  expect(r.title).toBe("Lead alt");
+});
+
+test("excludes RFC-0150 preview screenshots and og-image fallbacks", () => {
+  expect(isSyntheticPreviewUrl("https://example.org/preview/de/home.png")).toBe(true);
+  expect(isSyntheticPreviewUrl("https://example.org/og-image.png")).toBe(true);
+  expect(isSyntheticPreviewUrl("https://example.org/_astro/hero.abc.webp")).toBe(false);
+
+  const html = `
+    <link rel="canonical" href="https://example.org/">
+    <meta name="x-content-image" content="/preview/de/home.png">
+    <img src="/og-image.png" data-content-image>
+  `;
+  const r = harvestContentImage(html, SITE);
+  expect(r.imageUrls).toEqual([]);
+});
+
+test("reports multiple distinct content images (uniqueness violation surface)", () => {
+  const html = `
+    <link rel="canonical" href="https://example.org/x">
+    <img src="/_astro/a.1.webp" data-content-image>
+    <meta name="x-content-image" content="https://cdn.example.org/b.webp">
+  `;
+  const r = harvestContentImage(html, SITE);
+  expect(r.imageUrls.length).toBe(2);
+});
+
+test("deduplicates the same image referenced twice", () => {
+  const html = `
+    <link rel="canonical" href="https://example.org/x">
+    <img src="/_astro/a.1.webp" data-content-image>
+    <meta name="x-content-image" content="/_astro/a.1.webp">
+  `;
+  const r = harvestContentImage(html, SITE);
+  expect(r.imageUrls).toEqual(["https://example.org/_astro/a.1.webp"]);
+});
+
+test("returns null loc when no canonical link present", () => {
+  const r = harvestContentImage(`<img src="/_astro/a.webp" data-content-image>`, SITE);
+  expect(r.loc).toBe(null);
+});
+
+test("detects meta-refresh stubs but not soft window.location redirects on content pages", () => {
+  expect(isHtmlRedirectPage(`<meta http-equiv="refresh" content="0; url=/de/">`)).toBe(true);
+  // Full content pages carry a soft language redirect (RFC-0159) — NOT a stub.
+  expect(
+    isHtmlRedirectPage(`<main>real content</main><script>window.location.href="/en/"</script>`),
+  ).toBe(false);
+  expect(isHtmlRedirectPage(`<main>real content</main>`)).toBe(false);
+});
+
+test("formats a valid image sitemap with escaping", () => {
+  const entries: SitemapImageEntry[] = [
+    {
+      loc: "https://example.org/a?x=1&y=2",
+      imageUrl: "https://example.org/_astro/a.webp",
+      title: "T & <b>",
+    },
+  ];
+  const xml = generateImageSitemapXml(entries);
+  expect(xml).toMatch(/xmlns:image="http:\/\/www\.google\.com\/schemas\/sitemap-image\/1\.1"/);
+  expect(xml).toMatch(/<image:loc>https:\/\/example\.org\/_astro\/a\.webp<\/image:loc>/);
+  expect(xml).toMatch(/<loc>https:\/\/example\.org\/a\?x=1&amp;y=2<\/loc>/);
+  expect(xml).toMatch(/<image:title>T &amp; &lt;b&gt;<\/image:title>/);
+});
+
+test("empty entries still yields a valid urlset", () => {
+  const xml = generateImageSitemapXml([]);
+  expect(xml).toMatch(/<urlset/);
+  expect(xml).toMatch(/<\/urlset>/);
+});

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

@@ -0,0 +1,282 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>RFC-0492/RFC-0498: JSON-LD test — surface pages emit industry Service node
+  where Service is required (website-local depth-1, website-service depth-1, website-local depth-5)
+  and no Service nodes where Service is prohibited (depth-0, 2, 3, 4). Org-level Service nodes
+  and services ItemList are suppressed for all surface pages.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0492: initial JSON-LD test for industry Service node emission and org-level suppression.</item>
+  <item>RFC-0498: extend tests for website-service depth-1, website-local depth-5, and prohibited depths (0, 2, 3, 4).</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, expect, it } from "vitest";
+import { buildJsonLd } from "../semantic/jsonld.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../semantic/models.ts";
+
+function makeOrg(): SemanticOrganization {
+  return {
+    name: "Test Org",
+    description: "Test organization",
+    url: "https://example.com",
+    services: [
+      { id: "webdesign", name: "Webdesign", description: "Webdesign service" },
+      { id: "seo", name: "SEO", description: "SEO service" },
+    ],
+  };
+}
+
+function makeModel(overrides: Partial<SemanticPageModel> = {}): SemanticPageModel {
+  return {
+    type: "home",
+    lang: "de",
+    url: "https://example.com/de/website/elektriker",
+    title: "Website für Elektriker",
+    description: "Professionelle Websites für Elektriker",
+    breadcrumbs: [],
+    blocks: [],
+    organization: makeOrg(),
+    ...overrides,
+  };
+}
+
+describe("RFC-0492/RFC-0498: JSON-LD Service node for surface pages", () => {
+  it("emits industry-specific Service node for depth-1 website-local page", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 1,
+      industryService: {
+        serviceType: "Website für Elektriker",
+        description: "Professionelle Websites für Elektriker",
+      },
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    expect(serviceNodes.length).toBe(1);
+    const node = serviceNodes[0] as Record<string, unknown>;
+    expect(node["serviceType"]).toBe("Website für Elektriker");
+    expect(node["name"]).toBe("Website für Elektriker");
+  });
+
+  it("suppresses org-level Service nodes for depth-1 website-local page", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 1,
+      industryService: {
+        serviceType: "Website für Elektriker",
+      },
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    // Should have exactly 1 (the industry node), not 2 (org-level services)
+    expect(serviceNodes.length).toBe(1);
+    const node = serviceNodes[0] as Record<string, unknown>;
+    expect(node["serviceType"]).toBe("Website für Elektriker");
+    // Should NOT have org-level service names
+    expect(node["name"]).not.toBe("Webdesign");
+    expect(node["name"]).not.toBe("SEO");
+  });
+
+  it("emits org-level Service nodes for non-surface pages", () => {
+    const model = makeModel({
+      surfaceId: "other-surface",
+      depth: 1,
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    // Should have org-level services (Webdesign, SEO)
+    expect(serviceNodes.length).toBe(2);
+    const names = serviceNodes.map((n) => (n as Record<string, unknown>)["name"]);
+    expect(names).toContain("Webdesign");
+    expect(names).toContain("SEO");
+  });
+
+  it("emits industry-specific Service node for website-service depth-1 page", () => {
+    const model = makeModel({
+      surfaceId: "website-service",
+      depth: 1,
+      industryService: {
+        serviceType: "Website für Elektriker — SEO",
+        description: "Professionelle SEO für Elektriker",
+      },
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    expect(serviceNodes.length).toBe(1);
+    const node = serviceNodes[0] as Record<string, unknown>;
+    expect(node["serviceType"]).toBe("Website für Elektriker — SEO");
+  });
+
+  it("emits industry-specific Service node with areaServed for website-local depth-5 page", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 5,
+      industryService: {
+        serviceType: "Website für Elektriker — SEO",
+        description: "Professionelle SEO für Elektriker",
+        areaServed: "Stuttgart",
+      },
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    expect(serviceNodes.length).toBe(1);
+    const node = serviceNodes[0] as Record<string, unknown>;
+    expect(node["serviceType"]).toBe("Website für Elektriker — SEO");
+    const areaServed = node["areaServed"] as Record<string, unknown>;
+    expect(areaServed).toBeDefined();
+    expect(areaServed["@type"]).toBe("City");
+    expect(areaServed["name"]).toBe("Stuttgart");
+  });
+
+  it("emits no Service nodes for depth-0 website-local page (Service prohibited)", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 0,
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    expect(serviceNodes.length).toBe(0);
+  });
+
+  it("emits no Service nodes for depth-4 website-local page (Service prohibited)", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 4,
+    });
+
+    const doc = buildJsonLd(model);
+    const serviceNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "Service",
+    );
+
+    // RFC-0498: Service is prohibited on depth-4 — no Service nodes at all
+    expect(serviceNodes.length).toBe(0);
+  });
+
+  it("suppresses org-level services ItemList for all surface pages", () => {
+    const model = makeModel({
+      surfaceId: "website-local",
+      depth: 1,
+      industryService: {
+        serviceType: "Website für Elektriker",
+      },
+    });
+
+    const doc = buildJsonLd(model);
+    const itemListNodes = doc["@graph"].filter(
+      (n) => (n as { "@type"?: string | string[] })["@type"] === "ItemList",
+    );
+
+    // The org-level services ItemList should NOT be present
+    const servicesList = itemListNodes.find((n) => {
+      const node = n as Record<string, unknown>;
+      const id = node["@id"] as string | undefined;
+      return id?.includes("services");
+    });
+    expect(servicesList).toBeUndefined();
+  });
+});
+
+describe("ProfilePage mainEntity (Google Search Console fix)", () => {
+  it("sets mainEntity to extraGraphNodes[0] @id for AI-agent profile pages (page.people empty)", () => {
+    const model = makeModel({
+      type: "person",
+      url: "https://example.com/team/ki-agenten/test-bot/",
+      title: "Test Bot",
+      people: [],
+      extraGraphNodes: [
+        {
+          "@type": "SoftwareApplication",
+          "@id": "https://example.com/team/ki-agenten/test-bot/#software",
+          name: "Test Bot",
+        },
+      ],
+    });
+
+    const doc = buildJsonLd(model);
+    const webPageNode = doc["@graph"].find((n) => {
+      const types = (n as Record<string, unknown>)["@type"];
+      if (Array.isArray(types)) return types.includes("ProfilePage");
+      return types === "ProfilePage";
+    }) as Record<string, unknown> | undefined;
+
+    expect(webPageNode).toBeDefined();
+    const mainEntity = webPageNode!["mainEntity"] as Record<string, unknown>;
+    expect(mainEntity).toBeDefined();
+    expect(mainEntity["@id"]).toBe("https://example.com/team/ki-agenten/test-bot/#software");
+  });
+
+  it("sets mainEntity to extraGraphNodes[0] @id for human profile pages with extended Person node", () => {
+    const model = makeModel({
+      type: "person",
+      url: "https://example.com/team/jane-doe/",
+      title: "Jane Doe",
+      people: [{ name: "Jane Doe" }],
+      extraGraphNodes: [
+        {
+          "@type": "Person",
+          "@id": "https://example.com/team/jane-doe/#person",
+          name: "Jane Doe",
+        },
+      ],
+    });
+
+    const doc = buildJsonLd(model);
+    const webPageNode = doc["@graph"].find((n) => {
+      const types = (n as Record<string, unknown>)["@type"];
+      if (Array.isArray(types)) return types.includes("ProfilePage");
+      return types === "ProfilePage";
+    }) as Record<string, unknown> | undefined;
+
+    expect(webPageNode).toBeDefined();
+    const mainEntity = webPageNode!["mainEntity"] as Record<string, unknown>;
+    expect(mainEntity).toBeDefined();
+    expect(mainEntity["@id"]).toBe("https://example.com/team/jane-doe/#person");
+  });
+
+  it("falls back to ids.person when no extraGraphNodes", () => {
+    const model = makeModel({
+      type: "person",
+      url: "https://example.com/team/jane-doe/",
+      title: "Jane Doe",
+      people: [{ name: "Jane Doe" }],
+    });
+
+    const doc = buildJsonLd(model);
+    const webPageNode = doc["@graph"].find((n) => {
+      const types = (n as Record<string, unknown>)["@type"];
+      if (Array.isArray(types)) return types.includes("ProfilePage");
+      return types === "ProfilePage";
+    }) as Record<string, unknown> | undefined;
+
+    expect(webPageNode).toBeDefined();
+    const mainEntity = webPageNode!["mainEntity"] as Record<string, unknown>;
+    expect(mainEntity).toBeDefined();
+    expect(mainEntity["@id"]).toBe("https://example.com/#/schema/person/jane-doe");
+  });
+});

package/src/share/tests/knowledge.test.ts

@@ -0,0 +1,86 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0287: shape + determinism tests for the knowledge envelope formatter.</purpose>
+<keywords>RFC-0287, agent surface, knowledge, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">domain list, envelope shape, determinism, hash stability.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0287: initial knowledge formatter tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import {
+  AGENT_KNOWLEDGE_DOMAINS,
+  isAgentKnowledgeDomain,
+  formatAgentKnowledge,
+} from "../agent/knowledge.ts";
+import { BUSINESS_DOMAIN_VISIBILITY } from "../semantic/business-projection.ts";
+
+test("AGENT_KNOWLEDGE_DOMAINS: matches exactly the `public` BUSINESS_DOMAIN_VISIBILITY keys", () => {
+  const publicDomains = Object.entries(BUSINESS_DOMAIN_VISIBILITY)
+    .filter(([, visibility]) => visibility === "public")
+    .map(([domain]) => domain)
+    .sort();
+  expect([...AGENT_KNOWLEDGE_DOMAINS].sort()).toEqual(publicDomains);
+});
+
+test("isAgentKnowledgeDomain: rejects non-public domains", () => {
+  expect(isAgentKnowledgeDomain("offer")).toBe(true);
+  expect(isAgentKnowledgeDomain("compliance")).toBe(false);
+  expect(isAgentKnowledgeDomain("externalServices")).toBe(false);
+  expect(isAgentKnowledgeDomain("meta")).toBe(false);
+});
+
+test("formatAgentKnowledge: sets the schema tag with @1 version and strips trailing slash", () => {
+  const env = formatAgentKnowledge({
+    domain: "offer",
+    site: "warpgogol-com",
+    baseUrl: "https://warpgogol.com/",
+    languages: { default: "de", supported: ["de", "uk"] },
+    data: { de: { prices: [] } },
+  });
+  expect(env.schema).toBe("gogol.agent.knowledge/offer@1");
+  expect(env.baseUrl).toBe("https://warpgogol.com");
+});
+
+test("formatAgentKnowledge: omits freshness when not supplied, includes it when supplied", () => {
+  const withoutFreshness = formatAgentKnowledge({
+    domain: "company",
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    data: { de: {} },
+  });
+  expect("freshness" in withoutFreshness).toBe(false);
+
+  const withFreshness = formatAgentKnowledge({
+    domain: "company",
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    data: { de: {} },
+    freshness: { lastVerified: "2026-07-01", source: "ckl-claim-ledger", coverage: "domain" },
+  });
+  expect(withFreshness.freshness).toEqual({
+    lastVerified: "2026-07-01",
+    source: "ckl-claim-ledger",
+    coverage: "domain",
+  });
+});
+
+test("formatAgentKnowledge: deterministic across repeated calls", () => {
+  const input = {
+    domain: "faq" as const,
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de", "en"] },
+    data: { de: [{ question: "Q", answer: "A" }] },
+  };
+  const a = formatAgentKnowledge(input);
+  const b = formatAgentKnowledge(input);
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  expect(a.contentHash).toBe(b.contentHash);
+});

package/src/share/tests/ledger.test.ts

@@ -0,0 +1,125 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0217: tests for the claim ledger — event-id identity (incl. value),
+as-of query, lineage assembly, and the two projections.</purpose>
+<keywords>RFC-0217, CKL, ledger, event, lineage, projection, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP><entry key="tests">stableEventId, queryAsOf, buildLineage, projectGraph, projectTemporalSeo, ndjson round-trip.</entry></MODULE_MAP>
+<CHANGE_SUMMARY><item>RFC-0217: initial ledger tests (added in self-review pass).</item></CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import {
+  stableEventId,
+  parseNdjson,
+  serializeEvent,
+  buildLineage,
+  queryAsOf,
+  projectGraph,
+  projectTemporalSeo,
+  type ClaimEvent,
+} from "../knowledge/ledger.ts";
+
+function evt(partial: Partial<ClaimEvent>): ClaimEvent {
+  const subject = partial.subject ?? "business/de/location#residents";
+  const asOf = partial.asOf ?? "2026-01-01";
+  const event = partial.event ?? "genesis";
+  const actor = partial.actor ?? "agent:test";
+  return {
+    id: stableEventId(subject, asOf, event, actor, partial.value),
+    ts: partial.ts ?? `${asOf}T00:00:00Z`,
+    subject,
+    value: partial.value,
+    provenance: partial.provenance ?? "external",
+    asOf,
+    actor,
+    event,
+    ...partial,
+  };
+}
+
+test("stableEventId: identical payload is idempotent", () => {
+  const a = stableEventId("s#f", "2026-01-01", "genesis", "agent:a", "39120");
+  const b = stableEventId("s#f", "2026-01-01", "genesis", "agent:a", "39120");
+  expect(a).toBe(b);
+  expect(a).toMatch(/^evt_[0-9a-f]{16}$/);
+});
+
+test("stableEventId: a different value on the same day/actor/event is a DISTINCT event", () => {
+  const first = stableEventId("s#f", "2026-01-01", "verify-update", "agent:a", "39120");
+  const corrected = stableEventId("s#f", "2026-01-01", "verify-update", "agent:a", "39200");
+  expect(first).not.toBe(corrected);
+});
+
+test("ndjson round-trip preserves a compact event", () => {
+  const e = evt({ value: "39120" });
+  const [parsed] = parseNdjson(`${serializeEvent(e)}\n`);
+  expect(parsed).toEqual(e);
+});
+
+test("parseNdjson ignores blank lines", () => {
+  const e = evt({ value: "1" });
+  expect(parseNdjson(`\n${serializeEvent(e)}\n\n`).length).toBe(1);
+});
+
+test("queryAsOf: returns the most recent event whose asOf precedes the query date", () => {
+  const events = [
+    evt({ asOf: "2025-01-15", value: "38500", event: "genesis" }),
+    evt({ asOf: "2026-06-18", value: "39120", event: "verify-update" }),
+  ];
+  expect(queryAsOf(events, "business/de/location#residents", "2025-06-01")?.value).toBe("38500");
+  expect(queryAsOf(events, "business/de/location#residents", "2026-12-01")?.value).toBe("39120");
+  expect(queryAsOf(events, "business/de/location#residents", "2024-01-01")).toBe(null);
+});
+
+test("buildLineage: history is newest → oldest with the latest as current", () => {
+  const events = [
+    evt({ asOf: "2025-01-15", ts: "2025-01-15T00:00:00Z", value: "38500" }),
+    evt({ asOf: "2026-06-18", ts: "2026-06-18T00:00:00Z", value: "39120" }),
+  ];
+  const lin = buildLineage(events, "business/de/location#residents");
+  expect(lin).toBeTruthy();
+  expect(lin!.current.value).toBe("39120");
+  expect(lin!.history[0].value).toBe("39120");
+  expect(lin!.history[1].value).toBe("38500");
+});
+
+test("buildLineage: null for an unknown subject", () => {
+  expect(buildLineage([evt({ value: "1" })], "business/de/nope#x")).toBe(null);
+});
+
+test("projectGraph: one node per subject, newest event wins, history counted", () => {
+  const events = [
+    evt({ asOf: "2025-01-15", ts: "2025-01-15T00:00:00Z", value: "38500" }),
+    evt({ asOf: "2026-06-18", ts: "2026-06-18T00:00:00Z", value: "39120" }),
+    evt({ subject: "business/de/company#foundingYear", value: "2026", ts: "2026-02-01T00:00:00Z" }),
+  ];
+  const graph = projectGraph(events, "warpgogol-com");
+  expect(graph.nodes.length).toBe(2);
+  const residents = graph.nodes.find((n) => n.subject === "business/de/location#residents")!;
+  expect(residents.currentValue).toBe("39120");
+  expect(residents.historyCount).toBe(2);
+});
+
+test("projectTemporalSeo: datePublished is earliest genesis, dateModified is latest update", () => {
+  const subject = "business/de/location#residents";
+  const events = [
+    evt({ subject, asOf: "2025-01-15", event: "genesis", value: "38500" }),
+    evt({ subject, asOf: "2026-06-18", event: "verify-update", value: "39120" }),
+  ];
+  const map = new Map<string, string[]>([["de/location", [subject]]]);
+  const [seo] = projectTemporalSeo(events, map);
+  expect(seo.datePublished).toBe("2025-01-15");
+  expect(seo.dateModified).toBe("2026-06-18");
+  expect(seo.temporalCoverage).toBe("2025-01-15/2026-06-18");
+});
+
+test("projectTemporalSeo: no temporalCoverage when published equals modified", () => {
+  const subject = "business/de/company#foundingYear";
+  const events = [evt({ subject, asOf: "2026-02-01", event: "genesis", value: "2026" })];
+  const map = new Map<string, string[]>([["de/company", [subject]]]);
+  const [seo] = projectTemporalSeo(events, map);
+  expect(seo.datePublished).toBe("2026-02-01");
+  expect(seo.dateModified).toBe("2026-02-01");
+  expect(seo.temporalCoverage).toBe(undefined);
+});