@warpgogol/werkstatt-shared 0.7.0 → 0.8.1

package/src/share/semantic/ids.ts

@@ -8,6 +8,7 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>Moved from app semantic/ids to packages/share/src/semantic/ids.ts — framework-agnostic, reusable across all apps.</item>
+  <item>RFC-0910: add canonicalRootUrl — unprefixed root URL for entity identity (Organization.url, WebSite.url).</item>
 </CHANGE_SUMMARY>
 */
 
@@ -27,6 +28,18 @@ export function toAbsoluteUrl(baseUrl: string, path: string): string {
   return new URL(path, `${baseUrl}/`).toString();
 }
 
+/**
+ * RFC-0910: produce the canonical root URL for entity identity.
+ *
+ * The entity root URL is language-independent — it is always `https://site/`
+ * regardless of the default language. This contrasts with page URLs, which
+ * are language-prefixed for non-default languages and unprefixed for the
+ * default language per RFC-0160.
+ */
+export function canonicalRootUrl(baseUrl: string): string {
+  return new URL("/", `${baseUrl}/`).toString();
+}
+
 export function toPathname(url: string): string {
   return new URL(url).pathname;
 }

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

@@ -97,5 +97,25 @@ export function buildOrganizationNode(context: JsonLdContext): JsonLdNode {
       ? { logo: { "@type": "ImageObject", url: page.organization.logo } }
       : {}),
     ...(page.organization.image ? { image: page.organization.image } : {}),
+    ...(page.organization.offer?.prices?.length
+      ? { priceRange: buildPriceRange(page.organization.offer.prices) }
+      : {}),
   };
 }
+
+function buildPriceRange(prices: Array<{ amount: string; currency?: string }>): string {
+  const numericAmounts = prices
+    .map((p) => Number.parseFloat(p.amount))
+    .filter((n) => !Number.isNaN(n));
+  if (numericAmounts.length === 0) return "";
+  const min = Math.min(...numericAmounts);
+  const max = Math.max(...numericAmounts);
+  const currency = prices.find((p) => p.currency)?.currency;
+  const formatAmount = (n: number) => (Number.isInteger(n) ? String(n) : n.toFixed(2));
+  if (min === max) {
+    return currency ? `${formatAmount(min)} ${currency}` : formatAmount(min);
+  }
+  return currency
+    ? `${formatAmount(min)}–${formatAmount(max)} ${currency}`
+    : `${formatAmount(min)}–${formatAmount(max)}`;
+}

package/src/share/semantic/jsonld/video.ts

@@ -0,0 +1,56 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0912: builds VideoObject JSON-LD nodes from SemanticBlock.video data for opted-in content videos. Reads variant-manifest-derived data populated by buildSemanticPageModelWith.</purpose>
+<non-goals>
+  <item>Do not read the variant manifest directly — buildSemanticPageModelWith populates SemanticBlock.video before buildJsonLd runs.</item>
+  <item>Do not emit VideoObject for blocks without the seo.videoObject opt-in.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0912: initial implementation.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { JsonLdContext } from "./context.ts";
+import type { JsonLdNode } from "./types.ts";
+
+function formatDuration(seconds: number): string {
+  const totalSec = Math.round(seconds);
+  const hours = Math.floor(totalSec / 3600);
+  const minutes = Math.floor((totalSec % 3600) / 60);
+  const secs = totalSec % 60;
+  const parts = ["PT"];
+  if (hours > 0) parts.push(`${hours}H`);
+  if (minutes > 0) parts.push(`${minutes}M`);
+  parts.push(`${secs}S`);
+  return parts.join("");
+}
+
+export function buildVideoObjectNodes(context: JsonLdContext): JsonLdNode[] {
+  const { page, webpageId } = context;
+  const nodes: JsonLdNode[] = [];
+
+  for (const block of page.blocks) {
+    if (!block.video) continue;
+
+    const { seo, manifest } = block.video;
+    const nodeId = `${webpageId.replace("#/schema/webpage", "#/schema/video")}/${block.id}`;
+
+    const node: JsonLdNode = {
+      "@type": "VideoObject",
+      "@id": nodeId,
+      name: seo.name,
+      description: seo.description,
+      uploadDate: seo.uploadDate,
+      thumbnailUrl: manifest.posterUrl,
+      contentUrl: manifest.contentUrl,
+      ...(manifest.durationSec != null
+        ? { duration: formatDuration(manifest.durationSec) }
+        : {}),
+    };
+
+    nodes.push(node);
+  }
+
+  return nodes;
+}

package/src/share/semantic/jsonld/webpage.ts

@@ -90,7 +90,7 @@ export function buildWebPageNode(context: JsonLdContext): JsonLdNode {
       ? {
           speakable: {
             "@type": "SpeakableSpecification",
-            cssSelector: page.lead ? ["h1", ".section-header__lead"] : ["h1"],
+            cssSelector: page.lead ? ["h1", ".section-header__subheading"] : ["h1"],
           },
         }
       : {}),

package/src/share/semantic/jsonld.ts

@@ -8,6 +8,7 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>Added initiative list graph node, breadcrumb fallback, and shared dedupe utility.</item>
+  <item>RFC-0912: added VideoObject node composition for opted-in content video blocks.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -22,12 +23,14 @@ import { buildPersonNodes } from "./jsonld/person.ts";
 import { buildServiceNodes } from "./jsonld/service.ts";
 import { dedupeGraph } from "./jsonld/shared.ts";
 import type { JsonLdDocument } from "./jsonld/types.ts";
+import { buildVideoObjectNodes } from "./jsonld/video.ts";
 import { buildWebPageNode } from "./jsonld/webpage.ts";
 import { buildWebSiteNode } from "./jsonld/website.ts";
 import type { SemanticPageModel } from "./models.ts";
 
 export type { JsonLdDocument } from "./jsonld/types.ts";
 export type { JsonLdContext } from "./jsonld/context.ts";
+export { buildVideoObjectNodes } from "./jsonld/video.ts";
 
 export function buildJsonLd(page: SemanticPageModel): JsonLdDocument {
   const context = createJsonLdContext(page);
@@ -68,6 +71,8 @@ export function buildJsonLd(page: SemanticPageModel): JsonLdDocument {
       ...(collectionListNode ? [collectionListNode] : []),
       ...(articleNode ? [articleNode] : []),
       ...(breadcrumbNode ? [breadcrumbNode] : []),
+      // RFC-0912: VideoObject nodes for opted-in content video blocks.
+      ...buildVideoObjectNodes(context),
       // RFC-0512: extra nodes from team profile pages (SoftwareApplication, CollectionPage).
       ...(page.extraGraphNodes ?? []),
     ]),

package/src/share/semantic/models.ts

@@ -12,6 +12,7 @@
   <item>RFC-0490: Added "collection" to the SemanticPageType closed enum.</item>
   <item>RFC-0508: Added "participant" to the SemanticPageType closed enum.</item>
   <item>RFC-0372: Unified SemanticBlock type replaces SemanticAnswerBlock + SemanticContentBlock; SemanticPageModel.blocks replaces answerBlocks/contentBlocks/bodyText.</item>
+  <item>RFC-0912: Added VideoSeoData type and optional SemanticBlock.video field for opted-in content video structured data.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -59,6 +60,12 @@ export type SemanticBreadcrumb = {
  * Every block in a SemanticPageModel is represented by this single type, regardless of
  * whether it was derived from prose parsing or frontmatter block extraction.
  */
+/** RFC-0912: video SEO data populated by buildSemanticPageModelWith for opted-in content video blocks. */
+export type VideoSeoData = {
+  seo: { name: string; description: string; uploadDate: string };
+  manifest: { posterUrl: string; durationSec?: number; contentUrl: string };
+};
+
 export type SemanticBlock = {
   /** Stable id from frontmatter block.id (required) or slugified heading for prose-derived blocks. */
   id: string;
@@ -77,6 +84,8 @@ export type SemanticBlock = {
   /** Extractor metadata (absent for prose-derived blocks). */
   extractedAt?: string;
   extractorVersion?: string;
+  /** RFC-0912: video SEO data for opted-in content video blocks (seo.videoObject: true). Populated by buildSemanticPageModelWith from the variant manifest. */
+  video?: VideoSeoData;
 };
 
 /* RFC-0142: per-page llms inclusion depth. */

package/src/share/semantic/organization-profile.ts

@@ -8,10 +8,11 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0148: extracted the shared org-profile assembler from the disk + Astro builders.</item>
+  <item>RFC-0910: Organization.url uses canonicalRootUrl (unprefixed root) instead of language-prefixed path.</item>
 </CHANGE_SUMMARY>
 */
 
-import { getBaseUrl, toAbsoluteUrl } from "./ids.ts";
+import { canonicalRootUrl, getBaseUrl, toAbsoluteUrl } from "./ids.ts";
 import type {
   SemanticInitiative,
   SemanticLocation,
@@ -104,7 +105,7 @@ export function buildOrganizationProfile(input: OrganizationProfileInput): Seman
     name: input.brandName,
     legalName: input.legalName,
     description: input.description,
-    url: toAbsoluteUrl(baseUrl, `/${input.lang}/`),
+    url: canonicalRootUrl(baseUrl),
     foundingYear: input.foundingYear,
     email: input.email,
     registration: input.registration,

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