@warpgogol/werkstatt-shared 0.8.0 → 0.8.2

package/src/share/semantic/page-utils.ts

@@ -11,18 +11,12 @@
   <item>Unified single blocksToMarkdown signature (was duplicated with different signatures in app).</item>
   <item>Added slugify export and markdown answer-block extraction utilities.</item>
   <item>RFC-0372: toSemanticAnswerBlocks now returns SemanticBlock[] with blockType: "prose".</item>
+  <item>RFC-0915: replaced slugify import from extract.ts with slugId from canonical slug module.</item>
 </CHANGE_SUMMARY>
 */
 
 import type { SemanticBlock } from "./models.ts";
-import { slugify } from "./extract.ts";
-
-export { slugify };
-
-/**
- * Creates a URL-friendly slug from a string.
- * Re-exports from extract.ts to keep page-utils self-contained for consumers.
- */
+import { slugId } from "../slug/index.ts";
 
 /**
  * Extracts structured answer blocks from markdown body text.
@@ -99,7 +93,7 @@ export function toSemanticAnswerBlocks(
     const hasMultipleParagraphs = /\n[ \t]*\n/.test(block.content.trim());
     if (hasTable || hasMultipleParagraphs) {
       return {
-        id: slugify(block.heading),
+        id: slugId(block.heading),
         blockType: "prose",
         heading: block.heading,
         summary: block.content.trim(),
@@ -115,7 +109,7 @@ export function toSemanticAnswerBlocks(
       !firstLine.startsWith("-") && !firstLine.startsWith("*") && !firstLine.startsWith("#");
 
     return {
-      id: slugify(block.heading),
+      id: slugId(block.heading),
       blockType: "prose",
       heading: block.heading,
       summary: isSummary ? firstLine : undefined,

package/src/share/semantic/tests/split-sentences.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { splitSentences } from "@warpgogol/werkstatt-shared/share/semantic";
+
+describe("splitSentences", () => {
+  it("splits simple English sentences", () => {
+    const result = splitSentences("Hello world. This is a test. Goodbye!", "en");
+    expect(result).toHaveLength(3);
+    expect(result[0]).toBe("Hello world.");
+    expect(result[1]).toBe("This is a test.");
+    expect(result[2]).toBe("Goodbye!");
+  });
+
+  it("handles German abbreviations", () => {
+    const result = splitSentences("Das ist z.B. ein Test. Das ist ein weiterer Satz.", "de");
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Das ist z.B. ein Test.");
+    expect(result[1]).toBe("Das ist ein weiterer Satz.");
+  });
+
+  it("handles English abbreviations", () => {
+    const result = splitSentences("Use e.g. this pattern. It works well.", "en");
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Use e.g. this pattern.");
+    expect(result[1]).toBe("It works well.");
+  });
+
+  it("handles Ukrainian text", () => {
+    const result = splitSentences("Це перше речення. Це друге речення.", "uk");
+    expect(result).toHaveLength(2);
+  });
+
+  it("returns empty array for empty input", () => {
+    expect(splitSentences("", "en")).toEqual([]);
+    expect(splitSentences("   ", "en")).toEqual([]);
+  });
+
+  it("handles single sentence without terminal punctuation", () => {
+    const result = splitSentences("Just some text without ending", "en");
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBe("Just some text without ending");
+  });
+
+  it("does not split on decimal numbers", () => {
+    const result = splitSentences("The price is 3.50 euros. That is cheap.", "en");
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("The price is 3.50 euros.");
+    expect(result[1]).toBe("That is cheap.");
+  });
+
+  it("does not split on URLs in Ukrainian text", () => {
+    const result = splitSentences(
+      "Дивіться https://my.raceresult.com/317721/results для деталей. Це друге речення.",
+      "uk",
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Дивіться https://my.raceresult.com/317721/results для деталей.");
+    expect(result[1]).toBe("Це друге речення.");
+  });
+
+  it("does not split on URLs in German text", () => {
+    const result = splitSentences(
+      "Siehe https://my.raceresult.com/317721/results für Details. Das ist ein zweiter Satz.",
+      "de",
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Siehe https://my.raceresult.com/317721/results für Details.");
+    expect(result[1]).toBe("Das ist ein zweiter Satz.");
+  });
+
+  it("splits at period before German umlaut", () => {
+    const result = splitSentences(
+      "Die Version wird festgehalten. Änderungen erfolgen gemäß § 15.",
+      "de",
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Die Version wird festgehalten.");
+    expect(result[1]).toBe("Änderungen erfolgen gemäß § 15.");
+  });
+
+  it("does not split at numbered list markers", () => {
+    const result = splitSentences(
+      "1. Vorlage eines konkreten Angebots durch das Studio; 2. ausdrücklicher Annahme des Angebots durch den Kunden; 3. Auftragsbestätigung durch das Studio zustande.",
+      "de",
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  it("handles spaced German abbreviation z. B.", () => {
+    const result = splitSentences(
+      "Das Studio kann nicht wesentliche Prozesse (z. B. Werkzeuge) ändern. Der wesentliche Leistungsumfang kann nicht einseitig geändert werden.",
+      "de",
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBe("Das Studio kann nicht wesentliche Prozesse (z. B. Werkzeuge) ändern.");
+    expect(result[1]).toBe("Der wesentliche Leistungsumfang kann nicht einseitig geändert werden.");
+  });
+});

package/src/share/slug/heading-slugger.ts

@@ -0,0 +1,26 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Canonical heading anchor slug generation with stateful deduplication (RFC-0915, DNA-88). Wraps github-slugger.</purpose>
+<non-goals>
+  <item>Do not handle URL slug generation — use slugUrl for that.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0915: wraps github-slugger as canonical heading slugger, replacing direct imports in werkstatt-site.</item>
+</CHANGE_SUMMARY>
+*/
+
+import GithubSlugger from "github-slugger";
+
+/**
+ * Stateful heading slug generator with deduplication.
+ * First "Fazit" → "fazit", second → "fazit-1".
+ * Wraps github-slugger for canonical heading anchor generation.
+ */
+export class HeadingSlugger {
+  private readonly slugger = new GithubSlugger();
+
+  slug(text: string): string {
+    return this.slugger.slug(text);
+  }
+}

package/src/share/slug/index.ts

@@ -0,0 +1,15 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Canonical slug generation public API barrel (RFC-0915, DNA-88). Sole entry point for all slug generation in the monorepo.</purpose>
+<non-goals>
+  <item>Do not re-export strategy classes — consumers use slugUrl/slugId/HeadingSlugger only.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0915: created canonical slug module barrel.</item>
+</CHANGE_SUMMARY>
+*/
+
+export { slugUrl } from "./slug-url.ts";
+export { slugId } from "./slug-id.ts";
+export { HeadingSlugger } from "./heading-slugger.ts";

package/src/share/slug/slug-id.ts

@@ -0,0 +1,22 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Canonical semantic block ID slug generation (RFC-0915, DNA-88). Replaces custom NFKD slugify() in extract.ts.</purpose>
+<non-goals>
+  <item>Do not handle locale-aware URL slugs — use slugUrl for that.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0915: replaces custom NFKD-based slugify() in semantic/extract.ts with @sindresorhus/slugify wrapper.</item>
+</CHANGE_SUMMARY>
+*/
+
+import slugify from "@sindresorhus/slugify";
+
+/**
+ * Generates a semantic block ID from text.
+ * Uses @sindresorhus/slugify for robust Unicode handling.
+ * Returns "entity" if the input produces an empty slug.
+ */
+export function slugId(text: string): string {
+  return slugify(text) || "entity";
+}

package/src/share/slug/slug-url.ts

@@ -0,0 +1,24 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Canonical locale-aware URL slug generation (RFC-0915, DNA-88).</purpose>
+<non-goals>
+  <item>Do not handle heading anchor deduplication — use HeadingSlugger for that.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0915: extracted from werkstatt-site/src/domain/geo/slug.ts as canonical URL slug function.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { resolveSlugStrategy } from "./strategies.ts";
+
+/**
+ * Generates a locale-aware Latin URL slug from text.
+ * Uses German umlaut replacements for lang="de",
+ * Cyrillic transliteration for lang="uk",
+ * and default @sindresorhus/slugify for other/undefined langs.
+ * Returns "entity" if the input produces an empty slug.
+ */
+export function slugUrl(text: string, lang?: string): string {
+  return resolveSlugStrategy(lang).slug(text) || "entity";
+}

package/src/share/slug/strategies.ts

@@ -0,0 +1,68 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Canonical slug generation strategies for locale-aware URL slug derivation (RFC-0915, DNA-88).</purpose>
+<non-goals>
+  <item>Do not expose strategy classes directly — consumers use slugUrl() from slug-url.ts.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0915: extracted from werkstatt-site/src/domain/geo/slug.ts as canonical slug strategies.</item>
+</CHANGE_SUMMARY>
+*/
+
+import slugify from "@sindresorhus/slugify";
+import CyrillicToTranslit from "cyrillic-to-translit-js";
+
+export interface SlugStrategy {
+  slug(name: string): string;
+}
+
+interface CyrillicTranslit {
+  transform(value: string): string;
+}
+
+interface CyrillicTranslitConstructor {
+  new (options: { preset: "uk" }): CyrillicTranslit;
+}
+
+const germanReplacements: Array<[string, string]> = [
+  ["ä", "ae"],
+  ["ö", "oe"],
+  ["ü", "ue"],
+  ["ß", "ss"],
+  ["Ä", "Ae"],
+  ["Ö", "Oe"],
+  ["Ü", "Ue"],
+];
+
+class GermanSlugStrategy implements SlugStrategy {
+  slug(name: string): string {
+    return slugify(name, { customReplacements: germanReplacements });
+  }
+}
+
+class UkrainianSlugStrategy implements SlugStrategy {
+  private readonly translit = new (CyrillicToTranslit as unknown as CyrillicTranslitConstructor)({
+    preset: "uk",
+  });
+  slug(name: string): string {
+    return slugify(this.translit.transform(name));
+  }
+}
+
+class DefaultSlugStrategy implements SlugStrategy {
+  slug(name: string): string {
+    return slugify(name);
+  }
+}
+
+const slugStrategies = new Map<string, SlugStrategy>([
+  ["de", new GermanSlugStrategy()],
+  ["uk", new UkrainianSlugStrategy()],
+]);
+
+const defaultStrategy = new DefaultSlugStrategy();
+
+export function resolveSlugStrategy(lang?: string): SlugStrategy {
+  return (lang ? slugStrategies.get(lang) : undefined) ?? defaultStrategy;
+}

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

@@ -0,0 +1,84 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>RFC-0915: unit tests for canonical slug module output compatibility.</purpose>
+  <keywords>RFC-0915, slug, slugUrl, slugId, HeadingSlugger, DNA-88</keywords>
+  <responsibilities>
+    <item>Verify slugUrl locale-aware output for DE, UK, and default locales.</item>
+    <item>Verify slugId semantic block ID output and empty fallback.</item>
+    <item>Verify HeadingSlugger deduplication behavior.</item>
+  </responsibilities>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY><item>RFC-0915: initial unit tests for canonical slug module.</item></CHANGE_SUMMARY>
+*/
+
+import { test, expect, describe } from "vitest";
+import { slugUrl, slugId, HeadingSlugger } from "../index.ts";
+
+describe("slugUrl", () => {
+  test("German umlauts are expanded", () => {
+    expect(slugUrl("München", "de")).toBe("muenchen");
+    expect(slugUrl("Köln", "de")).toBe("koeln");
+    expect(slugUrl("Düsseldorf", "de")).toBe("duesseldorf");
+    expect(slugUrl("ß", "de")).toBe("ss");
+  });
+
+  test("Ukrainian Cyrillic is transliterated", () => {
+    expect(slugUrl("Київ", "uk")).toBe("kyiv");
+    expect(slugUrl("Львів", "uk")).toBe("lviv");
+  });
+
+  test("Default locale passes through", () => {
+    expect(slugUrl("Hello World")).toBe("hello-world");
+    expect(slugUrl("Berlin", "en")).toBe("berlin");
+    expect(slugUrl("New York", "en")).toBe("new-york");
+  });
+
+  test("Returns entity for empty input", () => {
+    expect(slugUrl("")).toBe("entity");
+    expect(slugUrl("!!!", "de")).toBe("entity");
+  });
+
+  test("Is idempotent", () => {
+    const once = slugUrl("Frankfurt am Main", "de");
+    expect(slugUrl(once, "de")).toBe(once);
+  });
+});
+
+describe("slugId", () => {
+  test("Generates kebab-case ID from heading", () => {
+    expect(slugId("Fazit")).toBe("fazit");
+    expect(slugId("Preisvergleich")).toBe("preisvergleich");
+    expect(slugId("FAQ & Antworten")).toBe("faq-and-antworten");
+  });
+
+  test("Returns entity for empty input", () => {
+    expect(slugId("")).toBe("entity");
+    expect(slugId("!!!")).toBe("entity");
+  });
+});
+
+describe("HeadingSlugger", () => {
+  test("First occurrence has no suffix", () => {
+    const slugger = new HeadingSlugger();
+    expect(slugger.slug("Fazit")).toBe("fazit");
+  });
+
+  test("Second occurrence gets -1 suffix", () => {
+    const slugger = new HeadingSlugger();
+    slugger.slug("Fazit");
+    expect(slugger.slug("Fazit")).toBe("fazit-1");
+  });
+
+  test("Third occurrence gets -2 suffix", () => {
+    const slugger = new HeadingSlugger();
+    slugger.slug("Fazit");
+    slugger.slug("Fazit");
+    expect(slugger.slug("Fazit")).toBe("fazit-2");
+  });
+
+  test("Different headings do not collide", () => {
+    const slugger = new HeadingSlugger();
+    expect(slugger.slug("Preis")).toBe("preis");
+    expect(slugger.slug("Fazit")).toBe("fazit");
+  });
+});

package/src/share/tests/build-page-price-markers.test.ts

@@ -69,6 +69,7 @@ describe("buildSemanticPageModelWith with price markers", () => {
         description: "Test description",
         blocks: [
           {
+            id: "hero",
             type: "hero",
             props: {
               header: {
@@ -102,6 +103,7 @@ describe("buildSemanticPageModelWith with price markers", () => {
         description: "Test description",
         blocks: [
           {
+            id: "hero",
             type: "hero",
             props: {
               header: {
@@ -134,6 +136,7 @@ describe("buildSemanticPageModelWith with price markers", () => {
       description: "A page without price markers",
       blocks: [
         {
+          id: "hero",
           type: "hero",
           props: {
             header: {

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

@@ -0,0 +1,143 @@
+import { describe, it, expect } from "vitest";
+import { buildVideoObjectNodes } from "../semantic/jsonld/video.ts";
+import { createJsonLdContext } from "../semantic/jsonld/context.ts";
+import type { SemanticPageModel, VideoSeoData } from "../semantic/models.ts";
+
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-0912: Tests for buildVideoObjectNodes — the JSON-LD builder that emits
+    VideoObject nodes from SemanticBlock.video data on opted-in content video blocks.
+  </purpose>
+</MODULE_CONTRACT>
+*/
+
+function makeMinimalPage(overrides: Partial<SemanticPageModel> = {}): SemanticPageModel {
+  return {
+    url: "https://example.com/uk/demo",
+    type: "article",
+    lang: "uk",
+    title: "Demo Page",
+    description: "A demo page",
+    blocks: [],
+    organization: { name: "Test Org", description: "Test", url: "https://example.com" },
+    ...overrides,
+  } as unknown as SemanticPageModel;
+}
+
+const sampleVideoSeo: VideoSeoData = {
+  seo: {
+    name: "Demo Video",
+    description: "A demonstration of the platform",
+    uploadDate: "2026-01-15T00:00:00Z",
+  },
+  manifest: {
+    posterUrl: "https://example.com/_video/uk/demo/poster.webp",
+    contentUrl: "https://example.com/_video/uk/demo/progressive.h264.mp4",
+    durationSec: 120,
+  },
+};
+
+describe("buildVideoObjectNodes", () => {
+  it("returns empty array when no blocks have video data", () => {
+    const page = makeMinimalPage({
+      blocks: [{ id: "block-1", heading: "Intro" }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+    expect(nodes).toHaveLength(0);
+  });
+
+  it("emits a VideoObject node for a block with video data", () => {
+    const page = makeMinimalPage({
+      blocks: [{ id: "video-section", heading: "Demo", video: sampleVideoSeo }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+
+    expect(nodes).toHaveLength(1);
+    const node = nodes[0]!;
+    expect(node["@type"]).toBe("VideoObject");
+    expect(node.name).toBe("Demo Video");
+    expect(node.description).toBe("A demonstration of the platform");
+    expect(node.uploadDate).toBe("2026-01-15T00:00:00Z");
+    expect(node.thumbnailUrl).toBe("https://example.com/_video/uk/demo/poster.webp");
+    expect(node.contentUrl).toBe("https://example.com/_video/uk/demo/progressive.h264.mp4");
+  });
+
+  it("includes ISO 8601 duration when durationSec is present", () => {
+    const page = makeMinimalPage({
+      blocks: [{ id: "v1", heading: "Demo", video: sampleVideoSeo }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+
+    expect(nodes[0]!.duration).toBe("PT2M0S");
+  });
+
+  it("omits duration when durationSec is absent", () => {
+    const videoWithoutDuration: VideoSeoData = {
+      seo: sampleVideoSeo.seo,
+      manifest: {
+        posterUrl: sampleVideoSeo.manifest.posterUrl,
+        contentUrl: sampleVideoSeo.manifest.contentUrl,
+      },
+    };
+    const page = makeMinimalPage({
+      blocks: [{ id: "v1", heading: "Demo", video: videoWithoutDuration }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+
+    expect(nodes[0]!.duration).toBeUndefined();
+  });
+
+  it("emits multiple nodes for multiple video blocks", () => {
+    const page = makeMinimalPage({
+      blocks: [
+        { id: "v1", heading: "Demo 1", video: sampleVideoSeo },
+        {
+          id: "v2",
+          heading: "Demo 2",
+          video: {
+            seo: { name: "Second", description: "Second video", uploadDate: "2026-02-01" },
+            manifest: {
+              posterUrl: "https://example.com/_video/uk/demo2/poster.webp",
+              contentUrl: "https://example.com/_video/uk/demo2/progressive.h264.mp4",
+              durationSec: 3661,
+            },
+          },
+        },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0]!.name).toBe("Demo Video");
+    expect(nodes[1]!.name).toBe("Second");
+    expect(nodes[1]!.duration).toBe("PT1H1M1S");
+  });
+
+  it("generates unique @id per video block", () => {
+    const page = makeMinimalPage({
+      blocks: [
+        { id: "v1", heading: "Demo 1", video: sampleVideoSeo },
+        {
+          id: "v2",
+          heading: "Demo 2",
+          video: {
+            ...sampleVideoSeo,
+            seo: { name: "Second", description: "d", uploadDate: "2026-02-01" },
+          },
+        },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildVideoObjectNodes(ctx);
+
+    expect(nodes[0]!["@id"]).not.toBe(nodes[1]!["@id"]);
+    expect(nodes[0]!["@id"]).toContain("v1");
+    expect(nodes[1]!["@id"]).toContain("v2");
+  });
+});

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

@@ -0,0 +1,69 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>Test that buildWebPageNode emits correct speakable cssSelector matching the rendered section-header__subheading class.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>Initial test for speakable cssSelector referencing section-header__subheading (not section-header__lead).</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, expect, it } from "vitest";
+import { buildWebPageNode } from "../semantic/jsonld/webpage.ts";
+import { createJsonLdContext } from "../semantic/jsonld/context.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../semantic/models.ts";
+
+function makeModel(overrides: Partial<SemanticPageModel> = {}): SemanticPageModel {
+  const org: SemanticOrganization = {
+    name: "Test Org",
+    description: "Test organization",
+    url: "https://example.com",
+  };
+  return {
+    type: "home",
+    lang: "de",
+    url: "https://example.com/de",
+    title: "Test Page",
+    description: "Test description",
+    breadcrumbs: [],
+    blocks: [],
+    organization: org,
+    ...overrides,
+  };
+}
+
+describe("buildWebPageNode speakable cssSelector", () => {
+  it("references section-header__subheading (not section-header__lead) when page has lead", () => {
+    const model = makeModel({
+      lead: "Test lead text",
+      blocks: [{ id: "block-1", heading: "Section heading" }],
+    });
+    const context = createJsonLdContext(model);
+    const node = buildWebPageNode(context);
+    const speakable = node.speakable as { cssSelector: string[] };
+    expect(speakable).toBeDefined();
+    expect(speakable.cssSelector).toContain("h1");
+    expect(speakable.cssSelector).toContain(".section-header__subheading");
+    expect(speakable.cssSelector).not.toContain(".section-header__lead");
+  });
+
+  it("emits only h1 selector when page has no lead", () => {
+    const model = makeModel({
+      blocks: [{ id: "block-1", heading: "Section heading" }],
+    });
+    const context = createJsonLdContext(model);
+    const node = buildWebPageNode(context);
+    const speakable = node.speakable as { cssSelector: string[] };
+    expect(speakable).toBeDefined();
+    expect(speakable.cssSelector).toEqual(["h1"]);
+  });
+
+  it("omits speakable when no blocks have headings", () => {
+    const model = makeModel({
+      lead: "Test lead text",
+      blocks: [{ id: "block-1", heading: "" }],
+    });
+    const context = createJsonLdContext(model);
+    const node = buildWebPageNode(context);
+    expect(node.speakable).toBeUndefined();
+  });
+});

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

@@ -72,3 +72,55 @@ describe("RFC-0745: buildOrganizationNode makesOffer priceCurrency", () => {
     expect(makesOffer[1].priceCurrency).toBe("EUR");
   });
 });
+
+describe("buildOrganizationNode priceRange", () => {
+  it("emits priceRange as min–max with currency when multiple prices exist", () => {
+    const org = makeOrgWithPrices([
+      { id: "monthly", label: "Monthly", amount: "70.00", currency: "EUR" },
+      { id: "yearly", label: "Yearly", amount: "700.00", currency: "EUR" },
+      { id: "setup", label: "Setup", amount: "200.00", currency: "EUR" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    expect(node.priceRange).toBe("70–700 EUR");
+  });
+
+  it("emits single-amount priceRange when all prices are equal", () => {
+    const org = makeOrgWithPrices([
+      { id: "monthly", label: "Monthly", amount: "70.00", currency: "EUR" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    expect(node.priceRange).toBe("70 EUR");
+  });
+
+  it("omits priceRange when no prices exist", () => {
+    const org: SemanticOrganization = {
+      name: "Test Org",
+      description: "Test organization",
+      url: "https://example.com",
+    };
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    expect(node.priceRange).toBeUndefined();
+  });
+
+  it("omits priceRange when price amounts are non-numeric", () => {
+    const org = makeOrgWithPrices([
+      { id: "custom", label: "Custom", amount: "auf Anfrage", currency: "EUR" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    expect(node.priceRange).toBe("");
+  });
+
+  it("emits priceRange without currency when prices lack currency", () => {
+    const org = makeOrgWithPrices([
+      { id: "monthly", label: "Monthly", amount: "70.00" },
+      { id: "setup", label: "Setup", amount: "200.00" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    expect(node.priceRange).toBe("70–200");
+  });
+});