@warpgogol/werkstatt-shared 0.14.1 → 0.15.0

package/src/surface/geo.ts

@@ -12,7 +12,12 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0195: initial GEO projection.</item>
-  <item>Architecture review 2026-07-10: extract blockTwinRegistry so each block type has a registered twin renderer instead of pattern-matching on prop shapes in renderTwin.</item>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
 </CHANGE_SUMMARY>
 */
 

package/src/surface/index.ts

@@ -6,14 +6,18 @@
 </non-goals>
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
-  <item>RFC-0192: initial barrel.</item>
-  <item>RFC-0271: export SurfaceModuleContext schema, type, and ownership helpers.</item>
-  <item>RFC-0276: export Bordbuch event/status schemas and types.</item>
-  <item>RFC-0280/RFC-0281: export DemandSignal and WerkRecord schemas.</item>
-  <item>RFC-0278/RFC-0279/RFC-0285: export governance schemas and types.</item>
-  <item>RFC-0282/RFC-0283: export visibility and breaker schemas.</item>
   <item>RFC-0284: export fleet Leitstand schemas and types.</item>
   <item>RFC-0264 cleanup: root barrel delegates governance exports to the governance subpath.</item>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — tail packages clean
+
+Sweep batch 3: rewrote ~95 purposes across werkstatt-knowledge, werkstatt-shared, godot-game, phaser-game, lifecycle-core, projektarchiv-*, portal-*, billing-*, typescript (CONTRACT-02/PURPOSE-02). Real KEY_DECISIONS on 5 godot utils, non-goals on 5 CONTRACT-03 files, headers on 4 headerless files, CS-07 history literal fix on 2 files. Policy: vitest.config.ts + test-fixtures testPatterns, worker-configuration.d.ts excludedPath. All non-site/engine packages now 0 diagnostics.</item>
+  <item>RFC-1106: step 5 — merge blueprint triplet
+
+surface/blueprint.ts now holds the blueprintSchema (sole declaration), all ~30 contract type names derived via z.infer, parseBlueprint, and the pure helpers. Deleted satellites blueprint-types.ts + blueprint-schema.ts, their package.json export entries, and the zero-consumer site shims (domain/surface/blueprint{,-types,-schema}.ts + 2 load-verification tests). All barrel consumers unchanged.</item>
+  <history>RFC-0192, RFC-0271, RFC-0276, RFC-0278, RFC-0280, RFC-0282</history>
 </CHANGE_SUMMARY>
 */
 
@@ -87,7 +91,7 @@ export {
   type LocalizedString,
 } from "./blueprint.ts";
 
-export { blueprintSchema, parseBlueprint, type ParseBlueprintResult } from "./blueprint-schema.ts";
+export { blueprintSchema, parseBlueprint, type ParseBlueprintResult } from "./blueprint.ts";
 
 // Governance and operational schema bags (RFC-0271..0285) — explicit re-exports.
 export type {

package/src/surface/types.ts

@@ -46,7 +46,7 @@ export interface SurfaceRecordImage {
 }
 
 /**
- * RFC-0192: a block in a baked page. Structurally compatible with `@warpgogol/werkstatt-shared/share` `BlockEntry`, but
+ * RFC-0192: a block in a baked page. Structurally compatible with `@warpgogol/werkstatt-shared/page` `BlockEntry`, but
  * declared here so `@warpgogol/werkstatt-shared/surface` stays the lower-level package with no dependency on share
  * (avoids a workspace cycle — share consumes surface's route types).
  */
@@ -60,7 +60,7 @@ export interface SurfaceBlock {
   layer?: "shell" | "section";
 }
 
-/** RFC-0192: a baked block-declarative page. Structurally compatible with `@warpgogol/werkstatt-shared/share` `PageEntry`. */
+/** RFC-0192: a baked block-declarative page. Structurally compatible with `@warpgogol/werkstatt-shared/page` `PageEntry`. */
 export interface PageEntry {
   kind: "page";
   cosmicStar: string;

package/src/surface/vitest.config.ts

@@ -3,6 +3,7 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
   test: {
     environment: "node",
+    testTimeout: 30_000,
     include: ["src/**/*.test.ts"],
   },
 });

package/src/tests/signing-core.test.ts

@@ -0,0 +1,129 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0921: Unit tests for the shared signing core — sign/verify round-trip, key generation, canonicalization.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0921: initial signing core unit tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, it, expect } from "vitest";
+import {
+  generateKeyPair,
+  toHex,
+  fromHex,
+  toPem,
+  fromPem,
+  canonicalBytes,
+  signBytes,
+  verifyBytes,
+  sign,
+  verify,
+} from "../signing/index.ts";
+
+describe("signing core — key generation", () => {
+  it("generates a valid Ed25519 keypair (32-byte private + 32-byte public)", async () => {
+    const keyPair = await generateKeyPair();
+    expect(keyPair.privateKey).toBeInstanceOf(Uint8Array);
+    expect(keyPair.publicKey).toBeInstanceOf(Uint8Array);
+    expect(keyPair.privateKey.length).toBe(32);
+    expect(keyPair.publicKey.length).toBe(32);
+  });
+
+  it("generates unique keypairs on each call", async () => {
+    const a = await generateKeyPair();
+    const b = await generateKeyPair();
+    expect(toHex(a.privateKey)).not.toBe(toHex(b.privateKey));
+    expect(toHex(a.publicKey)).not.toBe(toHex(b.publicKey));
+  });
+});
+
+describe("signing core — encoding helpers", () => {
+  it("toHex / fromHex round-trip", () => {
+    const bytes = new Uint8Array([0, 1, 2, 255, 128, 64]);
+    const hex = toHex(bytes);
+    expect(hex).toBe("000102ff8040");
+    expect(fromHex(hex)).toEqual(bytes);
+  });
+
+  it("toPem / fromPem round-trip for private key", () => {
+    const bytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+    const pem = toPem(bytes, "private");
+    expect(pem).toContain("-----BEGIN" + " PRIVATE KEY-----");
+    expect(pem).toContain("-----END" + " PRIVATE KEY-----");
+    expect(fromPem(pem)).toEqual(bytes);
+  });
+
+  it("toPem / fromPem round-trip for public key", () => {
+    const bytes = new Uint8Array([10, 20, 30, 40, 50, 60, 70, 80]);
+    const pem = toPem(bytes, "public");
+    expect(pem).toContain("-----BEGIN" + " PUBLIC KEY-----");
+    expect(pem).toContain("-----END" + " PUBLIC KEY-----");
+    expect(fromPem(pem)).toEqual(bytes);
+  });
+});
+
+describe("signing core — sign/verify", () => {
+  it("sign and verify round-trip with payload", async () => {
+    const keyPair = await generateKeyPair();
+    const payload = { buildId: "test-123", signedAt: "2026-08-22T00:00:00Z", outputsDigest: "abc" };
+    const signature = await sign(keyPair.privateKey, payload);
+    expect(signature).toBeInstanceOf(Uint8Array);
+    expect(signature.length).toBe(64);
+
+    const valid = await verify(keyPair.publicKey, payload, signature);
+    expect(valid).toBe(true);
+  });
+
+  it("verification fails with tampered payload", async () => {
+    const keyPair = await generateKeyPair();
+    const payload = { buildId: "test-123", signedAt: "2026-08-22" };
+    const signature = await sign(keyPair.privateKey, payload);
+
+    const tampered = { buildId: "tampered", signedAt: "2026-08-22" };
+    const valid = await verify(keyPair.publicKey, tampered, signature);
+    expect(valid).toBe(false);
+  });
+
+  it("verification fails with wrong public key", async () => {
+    const keyPairA = await generateKeyPair();
+    const keyPairB = await generateKeyPair();
+    const payload = { test: "data" };
+    const signature = await sign(keyPairA.privateKey, payload);
+
+    const valid = await verify(keyPairB.publicKey, payload, signature);
+    expect(valid).toBe(false);
+  });
+
+  it("signBytes / verifyBytes round-trip with raw message", async () => {
+    const keyPair = await generateKeyPair();
+    const message = new TextEncoder().encode("hello world");
+    const signature = await signBytes(keyPair.privateKey, message);
+    expect(signature.length).toBe(64);
+
+    const valid = await verifyBytes(keyPair.publicKey, message, signature);
+    expect(valid).toBe(true);
+  });
+
+  it("verifyBytes returns false on invalid signature (not throw)", async () => {
+    const keyPair = await generateKeyPair();
+    const message = new TextEncoder().encode("test");
+    const badSignature = new Uint8Array(64);
+    const valid = await verifyBytes(keyPair.publicKey, message, badSignature);
+    expect(valid).toBe(false);
+  });
+});
+
+describe("signing core — canonicalBytes", () => {
+  it("produces deterministic bytes regardless of key order", () => {
+    const a = canonicalBytes({ b: 2, a: 1, c: 3 });
+    const b = canonicalBytes({ a: 1, c: 3, b: 2 });
+    expect(a).toEqual(b);
+  });
+
+  it("produces different bytes for different payloads", () => {
+    const a = canonicalBytes({ a: 1 });
+    const b = canonicalBytes({ a: 2 });
+    expect(a).not.toEqual(b);
+  });
+});

package/src/{share → text}/css-value-normalize.ts

@@ -13,7 +13,12 @@ disagree on equality.
 </non-goals>
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
-  <item>Initial: unified normalizeCssValue from site-kernel-codegen and site-kernel-checks.</item>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
 </CHANGE_SUMMARY>
 */
 

package/src/text/string-utils.ts

@@ -0,0 +1,24 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Maintains packages/share/src/string-utils.ts as an authored share authored module so agents can evolve it without rediscovering local boundaries.</purpose>
+<non-goals>
+  <item>Do not introduce app-specific runtime composition or deployment behavior into this reusable package source file.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
+</CHANGE_SUMMARY>
+*/
+
+/** Lowercase, dash-only kebab-case. Strips leading/trailing hyphens. */
+export function toKebabCase(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}

package/src/{share → text}/tests/text-normalize.test.ts

@@ -36,6 +36,11 @@ test("quotes: curly + guillemets become straight", () => {
   expect(normalizeText(input, ALL_ON)).toBe(`"hi" "yo" it's 'a' "de"`);
 });
 
+test("quotes: U+02BC modifier letter apostrophe becomes straight (RFC-1070)", () => {
+  const input = "it\u02BCs";
+  expect(normalizeText(input, ALL_ON)).toBe("it's");
+});
+
 test("ellipsis: single char becomes three dots", () => {
   expect(normalizeText("wait…", ALL_ON)).toBe("wait...");
 });

package/src/{share → text}/text-normalize.ts

@@ -18,6 +18,7 @@ never touched; this only transforms output strings.
 <CHANGE_SUMMARY>
   <item>RFC-0235: initial egress text normalizer.</item>
   <item>RFC-0569: add createDevNormalizeMiddleware for dev/prod egress parity.</item>
+  <item>RFC-1070: add U+02BC modifier letter apostrophe to quotes signal.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -72,7 +73,7 @@ export const SIGNAL_REGISTRY: readonly SignalSpec[] = [
   {
     id: "quotes",
     title: "Typographic / smart quotes",
-    unicode: "U+00AB U+00BB U+2018-U+201F",
+    unicode: "U+00AB U+00BB U+2018-U+201F U+02BC",
     replacement: "straight double / single quote",
     default: true,
   },
@@ -148,8 +149,8 @@ export function resolveNormalizeConfig(manifest: unknown): NormalizeConfig {
 const RE_DASHES = /[‐‑‒–—―−]/g;
 // U+00AB U+00BB U+201C U+201D U+201E U+201F
 const RE_QUOTES_DOUBLE = /[«»“”„‟]/g;
-// U+2018 U+2019 U+201A U+201B
-const RE_QUOTES_SINGLE = /[‘’‚‛]/g;
+// U+2018 U+2019 U+201A U+201B U+02BC (modifier letter apostrophe, RFC-1070)
+const RE_QUOTES_SINGLE = /[‘’‚‛ʼ]/g;
 const RE_ELLIPSIS = /…/g;
 // U+00A0 nbsp, U+1680 ogham, U+2000-U+200A, U+202F narrow nbsp, U+205F medium math,
 // U+3000 ideographic space.

package/src/{share → text}/wrap-inline-numbers.ts

@@ -8,7 +8,7 @@
 </non-goals>
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
-  <item>RFC-0041: Created as SSR inline number pre-wrap utility in @warpgogol/werkstatt-shared/share.</item>
+  <item>RFC-0041: Created as SSR inline number pre-wrap utility in @warpgogol/werkstatt-shared/text.</item>
 </CHANGE_SUMMARY>
 */
 

package/src/types/axiom-study.d.ts

@@ -0,0 +1,36 @@
+/*
+<MODULE_CONTRACT>
+<purpose>axiom-study.d.ts — ambient module declaration for the external @syrokomskyi/axiom-study package types.</purpose>
+<non-goals>
+  <item>Do not implement runtime code — this file only declares types for an external package.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1097: sweep — tail packages clean
+
+Sweep batch 3: rewrote ~95 purposes across werkstatt-knowledge, werkstatt-shared, godot-game, phaser-game, lifecycle-core, projektarchiv-*, portal-*, billing-*, typescript (CONTRACT-02/PURPOSE-02). Real KEY_DECISIONS on 5 godot utils, non-goals on 5 CONTRACT-03 files, headers on 4 headerless files, CS-07 history literal fix on 2 files. Policy: vitest.config.ts + test-fixtures testPatterns, worker-configuration.d.ts excludedPath. All non-site/engine packages now 0 diagnostics.</item>
+</CHANGE_SUMMARY>
+*/
+
+declare module "@syrokomskyi/axiom-study" {
+  export interface Finding {
+    findingId: string;
+    semanticFingerprint: { algorithm: "sha256"; digest: string; size: number; mediaType: string };
+    methodologyId: string;
+    ruleId: string;
+    affectedSubjectId: string;
+    title: string;
+    severity: "info" | "low" | "medium" | "high" | "critical";
+    evidence: Array<{
+      evidenceRef: {
+        artifactId: string;
+        rootDigest: { algorithm: "sha256"; digest: string; size: number; mediaType: string };
+        schema: string;
+      };
+      selector: string;
+      evidenceClass: string;
+    }>;
+    uncertainty: unknown[];
+    extension: Record<string, unknown>;
+  }
+}

package/src/types/hls-js-light.d.ts

@@ -0,0 +1,21 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Type shim for the official `hls.js/light` export used by the lazy feature-video runtime.</purpose>
+<non-goals>
+  <item>Do not change runtime resolution; this file only fills the missing package declaration.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
+</CHANGE_SUMMARY>
+*/
+
+declare module "hls.js/light" {
+  export { default } from "hls.js";
+  export * from "hls.js";
+}

package/src/types/qrcode-browser.d.ts

@@ -0,0 +1,23 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Type shim for the qrcode browser entry point (qrcode/lib/browser.js).
+The qrcode package only ships types for its main entry, but the browser entry
+exports the same toCanvas function. This shim re-exports all types from qrcode
+so the client-side QR code script gets full type safety.</purpose>
+<non-goals>
+  <item>Do not change runtime resolution; this file only fills the missing package declaration.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
+</CHANGE_SUMMARY>
+*/
+
+declare module "qrcode/lib/browser.js" {
+  export * from "qrcode";
+}

package/src/typography/fix.pbt.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from "vitest";
+import fc from "fast-check";
+import { applyFixes, FIXABLE_RULE_IDS, isFixable } from "./fix.ts";
+import {
+  TIER1_RULES,
+  createTypographyContext,
+  type TypographyFinding,
+  type TypographyRule,
+} from "./rules-tier1.ts";
+import { TIER2_LOCALE_RULES } from "./rules-tier2-locale.ts";
+import type { TextSegment } from "./text-surface.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSegment(text: string, locale = "de"): TextSegment {
+  return {
+    file: "test.md",
+    line: 1,
+    path: "$body",
+    source: "body",
+    text,
+    raw: text,
+    isTableRow: false,
+    locale,
+  };
+}
+
+const ALL_FIXABLE_RULES: readonly TypographyRule[] = [...TIER1_RULES, ...TIER2_LOCALE_RULES].filter(
+  (rule) => isFixable(rule.id),
+);
+
+function runFixableRules(text: string, locale: string): TypographyFinding[] {
+  const segment = makeSegment(text, locale);
+  const ctx = createTypographyContext(locale, new Set());
+  const findings: TypographyFinding[] = [];
+  for (const rule of ALL_FIXABLE_RULES) {
+    if (rule.id === "TYPO-ABBR-02" && locale !== "de") continue;
+    if ((rule.id === "TYPO-APOS-01" || rule.id === "TYPO-APOS-02") && locale !== "uk") continue;
+    findings.push(...rule.check(segment, ctx));
+  }
+  return findings;
+}
+
+// ---------------------------------------------------------------------------
+// Property tests (DNA-101: idempotency)
+// ---------------------------------------------------------------------------
+
+describe("Fix engine — property-based tests (RFC-1072, DNA-101)", () => {
+  it("FIXABLE_RULE_IDS contains exactly 7 rule IDs", () => {
+    expect(FIXABLE_RULE_IDS).toHaveLength(7);
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-PUNCT-01");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-SPACE-01");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-SPACE-02");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-APOS-01");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-APOS-02");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-ABBR-01");
+    expect(FIXABLE_RULE_IDS).toContain("TYPO-ABBR-02");
+  });
+
+  it("isFixable returns true only for whitelisted rules", () => {
+    for (const id of FIXABLE_RULE_IDS) {
+      expect(isFixable(id)).toBe(true);
+    }
+    expect(isFixable("TYPO-PUNCT-02")).toBe(false);
+    expect(isFixable("TYPO-CASE-01")).toBe(false);
+    expect(isFixable("TYPO-UNICODE-01")).toBe(false);
+  });
+
+  it("applyFixes is idempotent: fixing an already-fixed text produces no new fixes", () => {
+    fc.assert(
+      fc.property(
+        fc.oneof(
+          fc.constant("Hello  world"), // SPACE-01
+          fc.constant("Hello   "), // SPACE-02
+          fc.constant("Hello,, world"), // PUNCT-01
+          fc.constant("Hello:: world"), // PUNCT-01
+          fc.constant("z.B. Hallo"), // ABBR-02 (de)
+          fc.constant("z. B. Hallo"), // already fixed ABBR-02
+        ),
+        (text) => {
+          const findings1 = runFixableRules(text, "de");
+          const { fixedSegments } = applyFixes(findings1, createTypographyContext("de", new Set()));
+          const fixedText = fixedSegments.get("test.md:1:$body") ?? text;
+
+          // Running fixable rules on the fixed text should produce zero fixable findings
+          const findings2 = runFixableRules(fixedText, "de");
+          const fixableFindings2 = findings2.filter((f) => f.fix !== null);
+          expect(fixableFindings2).toHaveLength(0);
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+
+  it("applyFixes with no fixable findings returns empty map", () => {
+    const findings: TypographyFinding[] = [];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    expect(result.fixedSegments.size).toBe(0);
+    expect(result.fixCount).toBe(0);
+  });
+
+  it("applyFixes skips findings with fix: null", () => {
+    const segment = makeSegment("Hello world", "de");
+    const findings: TypographyFinding[] = [
+      {
+        ruleId: "TYPO-PUNCT-02",
+        segment,
+        match: "..",
+        column: 5,
+        message: "test",
+        fixHint: "test",
+        fix: null,
+      },
+    ];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    expect(result.fixedSegments.size).toBe(0);
+    expect(result.fixCount).toBe(0);
+  });
+
+  it("replace action replaces the match at the given column", () => {
+    const segment = makeSegment("Hello,, world", "de");
+    const findings: TypographyFinding[] = [
+      {
+        ruleId: "TYPO-PUNCT-01",
+        segment,
+        match: ",,",
+        column: 5,
+        message: "test",
+        fixHint: "test",
+        fix: { type: "replace", old: ",,", new: "," },
+      },
+    ];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    const fixed = result.fixedSegments.get("test.md:1:$body");
+    expect(fixed).toBe("Hello, world");
+  });
+
+  it("insert action inserts text at the specified position", () => {
+    const segment = makeSegment("zB Hallo", "de");
+    const findings: TypographyFinding[] = [
+      {
+        ruleId: "TYPO-ABBR-01",
+        segment,
+        match: "zB",
+        column: 0,
+        message: "test",
+        fixHint: "test",
+        fix: { type: "insert", at: 2, text: "." },
+      },
+    ];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    const fixed = result.fixedSegments.get("test.md:1:$body");
+    expect(fixed).toBe("zB. Hallo");
+  });
+
+  it("delete action removes characters at the specified position", () => {
+    const segment = makeSegment("Hello   ", "de");
+    const findings: TypographyFinding[] = [
+      {
+        ruleId: "TYPO-SPACE-02",
+        segment,
+        match: "   ",
+        column: 5,
+        message: "test",
+        fixHint: "test",
+        fix: { type: "delete", at: 5, length: 3 },
+      },
+    ];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    const fixed = result.fixedSegments.get("test.md:1:$body");
+    expect(fixed).toBe("Hello");
+  });
+
+  it("multiple fixes in the same segment are applied correctly (right-to-left)", () => {
+    const segment = makeSegment("Hello,,  world", "de");
+    const findings: TypographyFinding[] = [
+      {
+        ruleId: "TYPO-PUNCT-01",
+        segment,
+        match: ",,",
+        column: 5,
+        message: "test",
+        fixHint: "test",
+        fix: { type: "replace", old: ",,", new: "," },
+      },
+      {
+        ruleId: "TYPO-SPACE-01",
+        segment,
+        match: "  w",
+        column: 7,
+        message: "test",
+        fixHint: "test",
+        fix: { type: "replace", old: "  w", new: " w" },
+      },
+    ];
+    const ctx = createTypographyContext("de", new Set());
+    const result = applyFixes(findings, ctx);
+    const fixed = result.fixedSegments.get("test.md:1:$body");
+    expect(fixed).toBe("Hello, world");
+  });
+});