@warpgogol/werkstatt-shared 0.14.1 → 0.15.0

package/src/{share/semantic → semantic}/tests/extract.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   extractEmail,
   extractListFacts,
+  extractLists,
   extractParagraphs,
   extractPostalAddress,
   mergePeople,
@@ -82,6 +83,88 @@ describe("extractListFacts", () => {
   });
 });
 
+describe("extractLists", () => {
+  it("extracts a single bullet list with dash marker", () => {
+    const result = extractLists("- Item 1\n- Item 2\n- Item 3");
+    expect(result).toEqual([{ marker: "-", items: ["Item 1", "Item 2", "Item 3"] }]);
+  });
+
+  it("extracts a single bullet list with asterisk marker", () => {
+    const result = extractLists("* Item 1\n* Item 2");
+    expect(result).toEqual([{ marker: "*", items: ["Item 1", "Item 2"] }]);
+  });
+
+  it("extracts a single bullet list with plus marker", () => {
+    const result = extractLists("+ Item 1\n+ Item 2");
+    expect(result).toEqual([{ marker: "+", items: ["Item 1", "Item 2"] }]);
+  });
+
+  it("extracts an ordered list with digit marker", () => {
+    const result = extractLists("1. First\n2. Second\n3. Third");
+    expect(result).toEqual([{ marker: "digit", items: ["First", "Second", "Third"] }]);
+  });
+
+  it("groups consecutive list lines into a single list", () => {
+    const md = "- Alpha\n- Beta\n- Gamma";
+    const result = extractLists(md);
+    expect(result).toHaveLength(1);
+    expect(result[0].items).toHaveLength(3);
+  });
+
+  it("terminates list on blank line", () => {
+    const md = "- Item 1\n- Item 2\n\nProse text";
+    const result = extractLists(md);
+    expect(result).toHaveLength(1);
+    expect(result[0].items).toEqual(["Item 1", "Item 2"]);
+  });
+
+  it("terminates list on non-list line", () => {
+    const md = "- Item 1\n- Item 2\nSome prose line";
+    const result = extractLists(md);
+    expect(result).toHaveLength(1);
+    expect(result[0].items).toEqual(["Item 1", "Item 2"]);
+  });
+
+  it("separates lists broken by prose", () => {
+    const md = "- List 1 item\n\nSome prose\n\n- List 2 item";
+    const result = extractLists(md);
+    expect(result).toHaveLength(2);
+    expect(result[0].items).toEqual(["List 1 item"]);
+    expect(result[1].items).toEqual(["List 2 item"]);
+  });
+
+  it("skips lines inside fenced code blocks", () => {
+    const md = "- Real item\n\n```text\n- Not a list item\n- Also not\n```\n\n- Another real item";
+    const result = extractLists(md);
+    expect(result).toHaveLength(2);
+    expect(result[0].items).toEqual(["Real item"]);
+    expect(result[1].items).toEqual(["Another real item"]);
+  });
+
+  it("skips indented (nested) list lines — they do not start a new list", () => {
+    const md = "- Top level\n  - Nested item\n  - Another nested\n- Top level 2";
+    const result = extractLists(md);
+    expect(result).toHaveLength(1);
+    expect(result[0].items).toEqual(["Top level", "Top level 2"]);
+  });
+
+  it("returns empty array for empty input", () => {
+    expect(extractLists("")).toEqual([]);
+  });
+
+  it("returns empty array for prose with no lists", () => {
+    expect(extractLists("Just some prose. No lists here.")).toEqual([]);
+  });
+
+  it("separates lists with different marker types", () => {
+    const md = "- Dash item\n* Star item";
+    const result = extractLists(md);
+    expect(result).toHaveLength(2);
+    expect(result[0].marker).toBe("-");
+    expect(result[1].marker).toBe("*");
+  });
+});
+
 describe("extractEmail", () => {
   it("extracts email from text", () => {
     expect(extractEmail("Contact us at info@example.com today")).toBe("info@example.com");

package/src/semantic/tests/freshness.pbt.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import fc from "fast-check";
+import {
+  calculateAgeDays,
+  isAssessmentStale,
+  isItemStale,
+  DEFAULT_FRESHNESS_WINDOW_DAYS,
+} from "../freshness.ts";
+
+const validTimestamp = fc.integer({ min: 0, max: Date.now() });
+const validDateFromTs = (ts: number) => new Date(ts);
+
+describe("calculateAgeDays — property-based (AC-7)", () => {
+  it("is pure and deterministic — same input always produces same output", () => {
+    fc.assert(
+      fc.property(validTimestamp, validTimestamp, (observedTs, referenceTs) => {
+        const observed = validDateFromTs(observedTs);
+        const reference = validDateFromTs(referenceTs);
+        const a = calculateAgeDays(observed.toISOString(), reference);
+        const b = calculateAgeDays(observed.toISOString(), reference);
+        expect(a).toBe(b);
+      }),
+      { numRuns: 50 },
+    );
+  });
+
+  it("returns non-negative age when reference >= observed", () => {
+    fc.assert(
+      fc.property(
+        validTimestamp,
+        fc.integer({ min: 0, max: 365 * 10 }),
+        (observedTs, daysAfter) => {
+          const observed = validDateFromTs(observedTs);
+          const reference = new Date(observed.getTime() + daysAfter * 86400000);
+          const age = calculateAgeDays(observed.toISOString(), reference);
+          expect(age).toBeGreaterThanOrEqual(0);
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("returns negative age when reference < observed", () => {
+    fc.assert(
+      fc.property(
+        validTimestamp.filter((ts) => ts > 365 * 10 * 86400000),
+        fc.integer({ min: 1, max: 365 * 10 }),
+        (observedTs, daysBefore) => {
+          const observed = validDateFromTs(observedTs);
+          const reference = new Date(observed.getTime() - daysBefore * 86400000);
+          const age = calculateAgeDays(observed.toISOString(), reference);
+          expect(age).toBeLessThan(0);
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("returns Number.MAX_SAFE_INTEGER for invalid date strings", () => {
+    fc.assert(
+      fc.property(
+        fc.string().filter((s) => isNaN(new Date(s).getTime())),
+        (invalid) => {
+          expect(calculateAgeDays(invalid)).toBe(Number.MAX_SAFE_INTEGER);
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+});
+
+describe("isAssessmentStale", () => {
+  it("returns true when age exceeds maxAgeDays", () => {
+    const reference = new Date("2026-09-12T00:00:00Z");
+    const assessment = {
+      observedAt: "2026-06-01T00:00:00Z",
+      freshness: { maxAgeDays: 90 },
+    };
+    expect(isAssessmentStale(assessment, reference)).toBe(true);
+  });
+
+  it("returns false when age is within maxAgeDays", () => {
+    const reference = new Date("2026-09-12T00:00:00Z");
+    const assessment = {
+      observedAt: "2026-08-01T00:00:00Z",
+      freshness: { maxAgeDays: 90 },
+    };
+    expect(isAssessmentStale(assessment, reference)).toBe(false);
+  });
+});
+
+describe("isItemStale", () => {
+  it("returns false when retrievedAt is missing", () => {
+    expect(isItemStale({}, DEFAULT_FRESHNESS_WINDOW_DAYS)).toBe(false);
+  });
+
+  it("returns true when age exceeds maxAgeDays", () => {
+    const reference = new Date("2026-09-12T00:00:00Z");
+    const item = { retrievedAt: "2026-01-01T00:00:00Z" };
+    expect(isItemStale(item, 180, reference)).toBe(true);
+  });
+
+  it("returns false when age is within maxAgeDays", () => {
+    const reference = new Date("2026-09-12T00:00:00Z");
+    const item = { retrievedAt: "2026-08-01T00:00:00Z" };
+    expect(isItemStale(item, 180, reference)).toBe(false);
+  });
+});

package/src/{share/tests/image-sitemap.test.ts → semantic/tests/image-sitemap-0150.test.ts}

@@ -5,7 +5,7 @@ import {
   isHtmlRedirectPage,
   isSyntheticPreviewUrl,
   type SitemapImageEntry,
-} from "../semantic/image-sitemap.ts";
+} from "../image-sitemap.ts";
 
 const SITE = "https://example.org";
 

package/src/{share → semantic}/tests/jsonld-service.test.ts

@@ -12,8 +12,8 @@
 */
 
 import { describe, expect, it } from "vitest";
-import { buildJsonLd } from "../semantic/jsonld.ts";
-import type { SemanticPageModel, SemanticOrganization } from "../semantic/models.ts";
+import { buildJsonLd } from "../jsonld.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../models.ts";
 
 function makeOrg(): SemanticOrganization {
   return {

package/src/{share → semantic}/tests/jsonld-video.test.ts

@@ -1,7 +1,7 @@
 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";
+import { buildVideoObjectNodes } from "../jsonld/video.ts";
+import { createJsonLdContext } from "../jsonld/context.ts";
+import type { SemanticPageModel, VideoSeoData } from "../models.ts";
 
 /*
 <MODULE_CONTRACT>

package/src/{share → semantic}/tests/jsonld-webpage.test.ts

@@ -8,9 +8,9 @@
 */
 
 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";
+import { buildWebPageNode } from "../jsonld/webpage.ts";
+import { createJsonLdContext } from "../jsonld/context.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../models.ts";
 
 function makeModel(overrides: Partial<SemanticPageModel> = {}): SemanticPageModel {
   const org: SemanticOrganization = {

package/src/{share → semantic}/tests/llms-0789.test.ts

@@ -12,8 +12,8 @@
 */
 
 import { test, expect } from "vitest";
-import { buildLlmsIndex } from "../semantic/llms.ts";
-import type { SemanticSiteModel } from "../semantic/models.ts";
+import { buildLlmsIndex } from "../llms.ts";
+import type { SemanticSiteModel } from "../models.ts";
 
 function makeSite(overrides: Partial<SemanticSiteModel> = {}): SemanticSiteModel {
   return {

package/src/{share/semantic → semantic}/tests/llms.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import { buildLlmsFull, buildLlmsIndex } from "../llms.ts";
 import { makePage } from "./helpers.ts";
 import type { SemanticSiteModel } from "../models.ts";
+import type { SemanticClaimProvenance } from "../business-projection.ts";
 
 function makeSite(overrides: Partial<SemanticSiteModel> = {}): SemanticSiteModel {
   const page = makePage();
@@ -115,4 +116,49 @@ describe("buildLlmsFull", () => {
     const result = buildLlmsFull(site);
     expect(result).toContain("## Organization facts");
   });
+
+  it("includes claims section when claims are present", () => {
+    const claims: SemanticClaimProvenance[] = [
+      {
+        id: "c1",
+        claimClass: "factual",
+        claimKind: "fact",
+        statement: "We are certified",
+        verificationLevel: "N2",
+        confidence: "high",
+        evidence: [{ id: "ev1", kind: "certificate", label: "ISO 27001", sha256: "abc123" }],
+      },
+    ];
+    const site = makeSite({ claims });
+    const result = buildLlmsFull(site);
+    expect(result).toContain("## Claims");
+    expect(result).toContain("### We are certified");
+    expect(result).toContain("- Class: factual");
+    expect(result).toContain("- Verification: N2");
+    expect(result).toContain("- Confidence: high");
+    expect(result).toContain("- Evidence:");
+    expect(result).toContain("certificate: ISO 27001");
+    expect(result).toContain("sha256: abc123");
+  });
+
+  it("omits claims section when no claims", () => {
+    const site = makeSite();
+    const result = buildLlmsFull(site);
+    expect(result).not.toContain("## Claims");
+  });
+
+  it("shows Evidence: none when claim has no evidence", () => {
+    const claims: SemanticClaimProvenance[] = [
+      {
+        id: "c1",
+        claimClass: "factual",
+        claimKind: "fact",
+        statement: "Unevidenced claim",
+        evidence: [],
+      },
+    ];
+    const site = makeSite({ claims });
+    const result = buildLlmsFull(site);
+    expect(result).toContain("- Evidence: none");
+  });
 });

package/src/{share → semantic}/tests/organization-jsonld.test.ts

@@ -8,9 +8,9 @@
 */
 
 import { describe, expect, it } from "vitest";
-import { buildOrganizationNode } from "../semantic/jsonld/organization.ts";
-import { createJsonLdContext } from "../semantic/jsonld/context.ts";
-import type { SemanticPageModel, SemanticOrganization } from "../semantic/models.ts";
+import { buildOrganizationNode } from "../jsonld/organization.ts";
+import { createJsonLdContext } from "../jsonld/context.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../models.ts";
 
 function makeOrgWithPrices(
   prices: Array<{ id: string; label: string; amount: string; currency?: string }>,

package/src/{share/tests/output-projection.test.ts → semantic/tests/output-projection-0143.test.ts}

@@ -6,7 +6,7 @@
 */
 
 import { test, expect } from "vitest";
-import { resolvePageOutput } from "../semantic/output-projection.ts";
+import { resolvePageOutput } from "../output-projection.ts";
 
 test("content defaults apply when no semanticType is given", () => {
   const result = resolvePageOutput(undefined, {});

package/src/{share/tests/price-marker-resolver.test.ts → semantic/tests/price-marker-resolver-0767.test.ts}

@@ -12,8 +12,8 @@ import {
   OFFERING_URI_PREFIX,
   PRICE_MARKER_RE,
   type DerivedPriceEntry,
-} from "../semantic/price-marker-resolver.ts";
-import { loadDerivedPrices } from "../semantic/derived-prices-loader.ts";
+} from "../price-marker-resolver.ts";
+import { loadDerivedPrices } from "../../node/semantic/derived-prices-loader.ts";
 
 const fixturePrices: Record<string, DerivedPriceEntry[]> = {
   [`${OFFERING_URI_PREFIX}referral-fee`]: [

package/src/{share/semantic → semantic}/tests/price-marker-resolver.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from "vitest";
 import {
-  AMOUNT_MARKER_RE,
   OFFERING_URI_PREFIX,
   PRICE_MARKER_RE,
   formatSourcePrice,
@@ -43,7 +42,10 @@ describe("resolvePriceMarkersForSemantic", () => {
         chargeRef: "monthly",
         targetCurrency: "USD",
         amount: { value: "15", currency: "USD" },
-        trace: { source: { amount: "10", currency: "EUR" }, rate: { value: "0.9", pair: "EUR/USD" } },
+        trace: {
+          source: { amount: "10", currency: "EUR" },
+          rate: { value: "0.9", pair: "EUR/USD" },
+        },
       },
     ],
   };

package/src/semantic/tests/project-claims.pbt.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import fc from "fast-check";
+import { projectClaims } from "../business-projection.ts";
+
+describe("projectClaims — property-based (AC-4)", () => {
+  it("is deterministic — same input always produces same output", () => {
+    fc.assert(
+      fc.property(
+        fc.array(
+          fc.record({
+            id: fc.string({ minLength: 1 }),
+            status: fc.constant("published"),
+            statement: fc.string(),
+            claimClass: fc.string(),
+            claimKind: fc.string(),
+          }),
+        ),
+        (claims) => {
+          const a = projectClaims(claims, undefined);
+          const b = projectClaims(claims, undefined);
+          expect(a).toEqual(b);
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("only returns claims with status === published", () => {
+    fc.assert(
+      fc.property(
+        fc.array(
+          fc.record({
+            id: fc.string({ minLength: 1 }),
+            status: fc.oneof(fc.constant("published"), fc.constant("draft"), fc.constant("archived")),
+            statement: fc.string(),
+            claimClass: fc.string(),
+            claimKind: fc.string(),
+          }),
+        ),
+        (claims) => {
+          const result = projectClaims(claims, undefined);
+          for (const c of result) {
+            expect(c.id).toBeTruthy();
+          }
+          const publishedIds = claims.filter((c) => c.status === "published" && c.id).map((c) => c.id);
+          expect(result.map((c) => c.id).sort()).toEqual(publishedIds.sort());
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("returns empty array for empty or undefined input", () => {
+    fc.assert(
+      fc.property(fc.oneof(fc.constant(undefined), fc.constant([])), (input) => {
+        expect(projectClaims(input, undefined)).toEqual([]);
+      }),
+    );
+  });
+});

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { splitSentences } from "@warpgogol/werkstatt-shared/share/semantic";
+import { splitSentences } from "@warpgogol/werkstatt-shared/semantic";
 
 describe("splitSentences", () => {
   it("splits simple English sentences", () => {

package/src/{share → semantic}/tests/twin-path.test.ts

@@ -18,7 +18,7 @@
 */
 
 import { test, expect } from "vitest";
-import { markdownTwinRelPath, markdownTwinUrlPath } from "../semantic/ids.ts";
+import { markdownTwinRelPath, markdownTwinUrlPath } from "../ids.ts";
 
 const supportedLangs = ["de", "en"] as const;
 

package/src/signing/index.ts

@@ -0,0 +1,13 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>Barrel export for @warpgogol/werkstatt-shared/signing sub-path. Re-exports the Ed25519 signing core (key generation, sign/verify, signing types) sunk from @warpgogol/werkstatt-engine per RFC-1104.</purpose>
+  <non-goals>Does not re-export engine signing commands (signing-commands.ts stays in engine).</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1104: initial barrel — signing core sunk from werkstatt-engine.</item>
+</CHANGE_SUMMARY>
+*/
+
+export * from "./types.ts";
+export * from "./key.ts";
+export * from "./sign.ts";

package/src/signing/key.ts

@@ -0,0 +1,139 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0921: Shared Ed25519 key management — generation, loading, saving, and encoding helpers.</purpose>
+
+
+<non-goals>
+  <item>Does not implement signing or verification — those live in sign.ts.</item>
+  <item>Does not manage key publication or key rotation — domain-specific concerns belong in consumers.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0921: initial signing key management module.</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>
+*/
+
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { createPrivateKey, createPublicKey } from "node:crypto";
+import * as ed from "@noble/ed25519";
+import type { KeyEncoding, SigningKeyPair } from "./types.ts";
+
+export async function generateKeyPair(): Promise<SigningKeyPair> {
+  const privateKey = ed.utils.randomSecretKey();
+  const publicKey = await getPublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+
+export async function getPublicKey(privateKey: Uint8Array): Promise<Uint8Array> {
+  return ed.getPublicKeyAsync(privateKey);
+}
+
+export async function loadPrivateKey(
+  source: { pem: string } | { hex: string } | { filePath: string; encoding: KeyEncoding },
+): Promise<Uint8Array> {
+  if ("pem" in source) {
+    return fromPem(source.pem);
+  }
+  if ("hex" in source) {
+    return fromHex(source.hex);
+  }
+  const raw = (await fs.readFile(source.filePath, "utf8")).trim();
+  if (source.encoding === "pem") {
+    return fromPem(raw);
+  }
+  return fromHex(raw);
+}
+
+export async function loadPublicKey(
+  source: { pem: string } | { hex: string } | { filePath: string; encoding: KeyEncoding },
+): Promise<Uint8Array> {
+  if ("pem" in source) {
+    return fromPem(source.pem);
+  }
+  if ("hex" in source) {
+    return fromHex(source.hex);
+  }
+  const raw = (await fs.readFile(source.filePath, "utf8")).trim();
+  if (source.encoding === "pem") {
+    return fromPem(raw);
+  }
+  return fromHex(raw);
+}
+
+export async function saveKeyPair(
+  keyPair: SigningKeyPair,
+  outputDir: string,
+  encoding: KeyEncoding,
+): Promise<{ privateKeyPath: string; publicKeyPath: string }> {
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const privateKeyPath = path.join(outputDir, `signing.key${encoding === "pem" ? ".pem" : ""}`);
+  const publicKeyPath = path.join(outputDir, `signing.key.pub${encoding === "pem" ? ".pem" : ""}`);
+
+  if (encoding === "pem") {
+    await fs.writeFile(privateKeyPath, toPem(keyPair.privateKey, "private"), "utf8");
+    await fs.writeFile(publicKeyPath, toPem(keyPair.publicKey, "public"), "utf8");
+  } else {
+    await fs.writeFile(privateKeyPath, toHex(keyPair.privateKey), "utf8");
+    await fs.writeFile(publicKeyPath, toHex(keyPair.publicKey), "utf8");
+  }
+
+  return { privateKeyPath, publicKeyPath };
+}
+
+export function toHex(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("hex");
+}
+
+export function fromHex(hex: string): Uint8Array {
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+
+export function toPem(bytes: Uint8Array, type: "private" | "public"): string {
+  const label = type === "private" ? "PRIVATE KEY" : "PUBLIC KEY";
+  const base64 = Buffer.from(bytes).toString("base64");
+  const lines = base64.match(/.{1,64}/g) ?? [base64];
+  return `-----BEGIN ${label}-----\n${lines.join("\n")}\n-----END ${label}-----\n`;
+}
+
+export function fromPem(pem: string): Uint8Array {
+  const base64 = pem
+    .replace(/-----BEGIN [A-Z ]+-----/g, "")
+    .replace(/-----END [A-Z ]+-----/g, "")
+    .replace(/\s+/g, "");
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+
+export function privateKeyPemToBytes(pem: string): Uint8Array {
+  const key = createPrivateKey(pem);
+  if (key.asymmetricKeyType !== "ed25519") {
+    throw new Error(
+      `Wrong private key type: ${key.asymmetricKeyType ?? "unknown"}. Expected ed25519.`,
+    );
+  }
+  const jwk = key.export({ format: "jwk" }) as { d: string };
+  return new Uint8Array(Buffer.from(jwk.d, "base64url"));
+}
+
+export function publicKeyPemToBytes(pem: string): Uint8Array {
+  const key = createPublicKey(pem);
+  if (key.asymmetricKeyType !== "ed25519") {
+    throw new Error(
+      `Wrong public key type: ${key.asymmetricKeyType ?? "unknown"}. Expected ed25519.`,
+    );
+  }
+  const jwk = key.export({ format: "jwk" }) as { x: string };
+  return new Uint8Array(Buffer.from(jwk.x, "base64url"));
+}
+
+export function keyExists(filePath: string): boolean {
+  return existsSync(filePath);
+}