@shelbyb/daywalker-sdk 0.1.0 → 0.1.2

package/dist/config.d.ts

@@ -1,46 +1,21 @@
-import { type SigningKey } from "./signing.js";
-/**
- * Everything a service needs, read from its environment:
- *
- *   DAYWALKER_API_KEY          the service's Daywalker API token (srv_live_…)          required
- *   DAYWALKER_SERVICE_SLUG     the service it validates against (e.g. "sonalyze")       required
- *   DAYWALKER_SIGNING_KEY      Ed25519 private key from `daywalker init`                required for allowlisted tokens
- *   DAYWALKER_SIGNING_KEY_PREVIOUS  old key, still published during a rotation          optional
- *   DAYWALKER_DOMAIN           public hostname that serves /.well-known/daywalker-keys.json
- *                              (defaults to the hostname of APP_URL, NEXTAUTH_URL, …)
- *   DAYWALKER_AUTH_URL         defaults to https://auth.daywalker.dev
- */
-export interface DaywalkerOptions {
-    apiKey?: string;
-    serviceSlug?: string;
-    /** Private key (PEM or base64 DER) or an already loaded key. */
-    signingKey?: string | SigningKey | null;
-    previousSigningKey?: string | SigningKey | null;
-    domain?: string;
-    authUrl?: string;
-    /** Override for tests or custom runtimes. */
-    fetch?: typeof fetch;
-    /** Request timeout in ms (default 5000). */
-    timeoutMs?: number;
-    /** How long a successful validation is cached, in ms (default 60000, 0 disables). */
-    cacheTtlMs?: number;
-    env?: Record<string, string | undefined>;
-}
+import type { DaywalkerConfig, PublicJwk, SigningKey } from "./types.js";
 export interface ResolvedConfig {
     apiKey: string | null;
+    signingKey: string | SigningKey | null;
+    previousSigningKey: string | SigningKey | null;
+    keyId: string | null;
     serviceSlug: string | null;
-    signingKey: SigningKey | null;
-    previousSigningKey: SigningKey | null;
     domain: string | null;
-    /** Where the domain came from, for diagnostics. */
     domainSource: string | null;
+    daywalkerPublicKey: string | PublicJwk | null;
     authUrl: string;
+    cacheTtlMs: number;
+    maxRetries: number;
     problems: string[];
 }
 /**
  * A public hostname from a URL or bare host, or null for anything that can't be fetched over
- * the internet (localhost, 0.0.0.0, IP addresses, single labels). Containers often report their
- * bind address (http://0.0.0.0:3000) as the request origin, which must never be used.
+ * the internet (localhost, 0.0.0.0, IP addresses, single labels).
  */
 export declare function publicHostname(value: string | undefined | null): string | null;
-export declare function resolveConfig(options?: DaywalkerOptions): ResolvedConfig;
+export declare function resolveConfig(options?: DaywalkerConfig): ResolvedConfig;

package/dist/config.js

@@ -1,6 +1,3 @@
-import net from "node:net";
-import { loadSigningKey } from "./signing.js";
-// Platform variables that commonly hold the app's public URL or hostname, in priority order
 const URL_ENV_VARS = [
     "APP_URL",
     "NEXTAUTH_URL",
@@ -8,22 +5,34 @@ const URL_ENV_VARS = [
     "BETTER_AUTH_URL",
     "PUBLIC_URL",
     "SITE_URL",
-    "URL", // Netlify
+    "URL",
     "VERCEL_PROJECT_PRODUCTION_URL",
     "RENDER_EXTERNAL_HOSTNAME",
     "RAILWAY_PUBLIC_DOMAIN",
     "VERCEL_URL",
 ];
 const DOMAIN_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z][a-z0-9-]{0,61}[a-z0-9]$/;
+function isIpAddress(host) {
+    if (host.length > 253)
+        return false;
+    // IPv4
+    if (/^(?:\d{1,3}\.){3}\d{1,3}$/.test(host))
+        return true;
+    // IPv6
+    if (host.includes(":"))
+        return true;
+    return false;
+}
 /**
  * A public hostname from a URL or bare host, or null for anything that can't be fetched over
- * the internet (localhost, 0.0.0.0, IP addresses, single labels). Containers often report their
- * bind address (http://0.0.0.0:3000) as the request origin, which must never be used.
+ * the internet (localhost, 0.0.0.0, IP addresses, single labels).
  */
 export function publicHostname(value) {
     if (!value || !value.trim())
         return null;
     let host = value.trim().toLowerCase();
+    if (host.length > 253)
+        return null;
     try {
         host = new URL(/^[a-z][a-z0-9+.-]*:\/\//.test(host) ? host : `https://${host}`).hostname;
     }
@@ -31,26 +40,13 @@ export function publicHostname(value) {
         return null;
     }
     host = host.replace(/\.$/, "");
-    if (net.isIP(host.replace(/^\[|\]$/g, "")) || host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) {
+    if (host.length > 253 || isIpAddress(host.replace(/^\[|\]$/g, "")) || host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) {
         return null;
     }
     return DOMAIN_PATTERN.test(host) ? host : null;
 }
-function keyFrom(value, name, problems) {
-    if (!value)
-        return null;
-    if (typeof value !== "string")
-        return value;
-    try {
-        return loadSigningKey(value);
-    }
-    catch (err) {
-        problems.push(`${name} could not be loaded: ${err.message}`);
-        return null;
-    }
-}
 export function resolveConfig(options = {}) {
-    const env = options.env ?? process.env;
+    const env = options.env ?? (typeof process !== "undefined" && process.env ? process.env : {});
     const problems = [];
     const apiKey = (options.apiKey ?? env.DAYWALKER_API_KEY ?? "").trim() || null;
     const serviceSlug = (options.serviceSlug ?? env.DAYWALKER_SERVICE_SLUG ?? "").trim().toLowerCase() || null;
@@ -58,8 +54,9 @@ export function resolveConfig(options = {}) {
         problems.push("DAYWALKER_API_KEY is not set");
     if (!serviceSlug)
         problems.push("DAYWALKER_SERVICE_SLUG is not set");
-    const signingKey = keyFrom(options.signingKey ?? env.DAYWALKER_SIGNING_KEY, "DAYWALKER_SIGNING_KEY", problems);
-    const previousSigningKey = keyFrom(options.previousSigningKey ?? env.DAYWALKER_SIGNING_KEY_PREVIOUS, "DAYWALKER_SIGNING_KEY_PREVIOUS", problems);
+    const signingKey = options.signingKey ?? env.DAYWALKER_SIGNING_KEY ?? null;
+    const previousSigningKey = options.previousSigningKey ?? env.DAYWALKER_SIGNING_KEY_PREVIOUS ?? null;
+    const keyId = (options.keyId ?? env.DAYWALKER_KEY_ID ?? "").trim() || null;
     let domain = null;
     let domainSource = null;
     const explicit = options.domain ?? env.DAYWALKER_DOMAIN ?? env.DAYWALKER_SIGNING_DOMAIN;
@@ -71,17 +68,33 @@ export function resolveConfig(options = {}) {
     }
     else {
         for (const name of URL_ENV_VARS) {
-            const host = publicHostname(env[name]);
-            if (host) {
-                domain = host;
-                domainSource = name;
-                break;
+            const val = env[name];
+            if (val) {
+                const host = publicHostname(val);
+                if (host) {
+                    domain = host;
+                    domainSource = name;
+                    break;
+                }
             }
         }
     }
-    if (signingKey && !domain) {
-        problems.push("No public domain found: set DAYWALKER_DOMAIN (requests will be sent unsigned)");
-    }
+    const daywalkerPublicKey = options.daywalkerPublicKey ?? (env.DAYWALKER_PUBLIC_KEY ? env.DAYWALKER_PUBLIC_KEY.trim() : null);
     const authUrl = (options.authUrl ?? env.DAYWALKER_AUTH_URL ?? "https://auth.daywalker.dev").replace(/\/+$/, "");
-    return { apiKey, serviceSlug, signingKey, previousSigningKey, domain, domainSource, authUrl, problems };
+    const cacheTtlMs = options.cacheTtlMs ?? 60_000;
+    const maxRetries = options.maxRetries ?? (options.retry?.maxRetries ?? 3);
+    return {
+        apiKey,
+        signingKey,
+        previousSigningKey,
+        keyId,
+        serviceSlug,
+        domain,
+        domainSource,
+        daywalkerPublicKey,
+        authUrl,
+        cacheTtlMs,
+        maxRetries,
+        problems,
+    };
 }

package/dist/crypto/digest.d.ts

@@ -0,0 +1,17 @@
+/** Default upper bound for body payload digest calculation (10MB). */
+export declare const DEFAULT_MAX_BODY_SIZE_BYTES: number;
+/**
+ * RFC 9530 Digest Fields computation.
+ * Hashes payload with SHA-256 via WebCrypto `crypto.subtle.digest`.
+ * Formats as `sha-256=:<base64-digest>:` (RFC 9651 structured field byte sequence).
+ * Enforces body size limit to mitigate memory exhaustion DoS.
+ */
+export declare function computeContentDigest(body: Uint8Array | string | null | undefined, maxSizeBytes?: number): Promise<string | null>;
+/**
+ * Compute SHA-256 hash returned as base64 string.
+ */
+export declare function sha256Base64(data: Uint8Array | string): Promise<string>;
+/**
+ * Compute SHA-256 hash returned as base64url string (useful for JWK thumbprints).
+ */
+export declare function sha256Base64Url(data: Uint8Array | string): Promise<string>;

package/dist/crypto/digest.js

@@ -0,0 +1,36 @@
+import { bytesToBase64, stringToUtf8 } from "./encoding.js";
+/** Default upper bound for body payload digest calculation (10MB). */
+export const DEFAULT_MAX_BODY_SIZE_BYTES = 10 * 1024 * 1024;
+/**
+ * RFC 9530 Digest Fields computation.
+ * Hashes payload with SHA-256 via WebCrypto `crypto.subtle.digest`.
+ * Formats as `sha-256=:<base64-digest>:` (RFC 9651 structured field byte sequence).
+ * Enforces body size limit to mitigate memory exhaustion DoS.
+ */
+export async function computeContentDigest(body, maxSizeBytes = DEFAULT_MAX_BODY_SIZE_BYTES) {
+    if (body === null || body === undefined) {
+        return null;
+    }
+    const data = typeof body === "string" ? stringToUtf8(body) : body;
+    if (data.byteLength > maxSizeBytes) {
+        throw new Error(`Request body size (${data.byteLength} bytes) exceeds maximum allowed limit (${maxSizeBytes} bytes)`);
+    }
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+    const hashBase64 = bytesToBase64(new Uint8Array(hashBuffer));
+    return `sha-256=:${hashBase64}:`;
+}
+/**
+ * Compute SHA-256 hash returned as base64 string.
+ */
+export async function sha256Base64(data) {
+    const bytes = typeof data === "string" ? stringToUtf8(data) : data;
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return bytesToBase64(new Uint8Array(hashBuffer));
+}
+/**
+ * Compute SHA-256 hash returned as base64url string (useful for JWK thumbprints).
+ */
+export async function sha256Base64Url(data) {
+    const base64 = await sha256Base64(data);
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}

package/dist/crypto/encoding.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Zero-dependency Web standard encoding utilities.
+ * Runs in Node.js 18+, Bun, Deno, Cloudflare Workers, and browser/Edge runtimes.
+ */
+export declare function stringToUtf8(str: string): Uint8Array;
+export declare function utf8ToString(bytes: Uint8Array): string;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function base64ToBytes(b64: string): Uint8Array;
+export declare function bytesToBase64Url(bytes: Uint8Array): string;
+export declare function base64UrlToBytes(b64url: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * Constant-time byte comparison to mitigate microarchitectural timing attacks.
+ */
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Constant-time string comparison helper.
+ */
+export declare function timingSafeEqualString(a: string, b: string): boolean;
+/**
+ * Masks a secret string for safe display/logging (e.g. `srv_...cdef` or `[none]`).
+ */
+export declare function maskSecret(val: string | null | undefined): string;
+/**
+ * Redacts secrets, tokens, keys, and authorization headers from strings.
+ * Used across SDK error handlers and logs to prevent sensitive credential exposure.
+ */
+export declare function redactSecrets(input: string | null | undefined): string;

package/dist/crypto/encoding.js

@@ -0,0 +1,117 @@
+/**
+ * Zero-dependency Web standard encoding utilities.
+ * Runs in Node.js 18+, Bun, Deno, Cloudflare Workers, and browser/Edge runtimes.
+ */
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function stringToUtf8(str) {
+    return encoder.encode(str);
+}
+export function utf8ToString(bytes) {
+    return decoder.decode(bytes);
+}
+export function bytesToBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    let binary = "";
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function base64ToBytes(b64) {
+    const clean = b64.trim().replace(/\s+/g, "");
+    if (typeof Buffer !== "undefined") {
+        const buf = Buffer.from(clean, "base64");
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    const binary = atob(clean);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+export function bytesToBase64Url(bytes) {
+    return bytesToBase64(bytes)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+export function base64UrlToBytes(b64url) {
+    let b64 = b64url.trim().replace(/-/g, "+").replace(/_/g, "/");
+    while (b64.length % 4 !== 0) {
+        b64 += "=";
+    }
+    return base64ToBytes(b64);
+}
+export function bytesToHex(bytes) {
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, "0");
+    }
+    return hex;
+}
+export function hexToBytes(hex) {
+    const clean = hex.trim().replace(/^0x/i, "");
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < clean.length; i += 2) {
+        bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Constant-time byte comparison to mitigate microarchitectural timing attacks.
+ */
+export function timingSafeEqual(a, b) {
+    if (a.byteLength !== b.byteLength)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.byteLength; i++) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}
+/**
+ * Constant-time string comparison helper.
+ */
+export function timingSafeEqualString(a, b) {
+    return timingSafeEqual(stringToUtf8(a), stringToUtf8(b));
+}
+/**
+ * Masks a secret string for safe display/logging (e.g. `srv_...cdef` or `[none]`).
+ */
+export function maskSecret(val) {
+    if (!val || typeof val !== "string")
+        return "[none]";
+    if (val.length <= 8)
+        return "***";
+    return `${val.slice(0, 4)}...${val.slice(-4)}`;
+}
+/**
+ * Redacts secrets, tokens, keys, and authorization headers from strings.
+ * Used across SDK error handlers and logs to prevent sensitive credential exposure.
+ */
+export function redactSecrets(input) {
+    if (!input || typeof input !== "string")
+        return "";
+    let out = input;
+    // Bearer tokens & Authorization headers
+    out = out.replace(/(Bearer\s+)[A-Za-z0-9_\-\.]+/gi, "$1[REDACTED]");
+    // API keys (e.g. srv_live_..., srv_test_..., dw_...)
+    out = out.replace(/\b(srv_(?:live|test)_[a-zA-Z0-9_\-]+)\b/g, (match) => {
+        if (match.length <= 12)
+            return "[REDACTED_KEY]";
+        return `${match.slice(0, 8)}...[REDACTED]`;
+    });
+    out = out.replace(/\b(dw_[a-zA-Z0-9_\-]+)\b/g, "[REDACTED_KEY]");
+    // Standard JWTs (header.payload.signature)
+    out = out.replace(/\beyJ[A-Za-z0-9_\-]{8,}\.eyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\b/g, "[REDACTED_JWT]");
+    // PEM Private keys
+    out = out.replace(/-----BEGIN [A-Z\s]+ PRIVATE KEY-----[\s\S]*?-----END [A-Z\s]+ PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]");
+    // Query parameters in URLs like ?apiKey=... &token=...
+    out = out.replace(/([?&](?:apiKey|api_key|token|signingKey|signing_key|secret)=)[^&\s]+/gi, "$1[REDACTED]");
+    return out;
+}

package/dist/crypto/index.d.ts

@@ -0,0 +1,5 @@
+export { stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, bytesToHex, hexToBytes, timingSafeEqual, timingSafeEqualString, maskSecret, redactSecrets, } from "./encoding.js";
+export { DEFAULT_MAX_BODY_SIZE_BYTES, computeContentDigest, sha256Base64, sha256Base64Url, } from "./digest.js";
+export { calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, } from "./keys.js";
+export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, registerPublicKey, } from "./signatures.js";
+export type { SignedHeaders, SignRequestParams, VerifySignatureParams, VerifySignatureResult, } from "./signatures.js";

package/dist/crypto/index.js

@@ -0,0 +1,4 @@
+export { stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, bytesToHex, hexToBytes, timingSafeEqual, timingSafeEqualString, maskSecret, redactSecrets, } from "./encoding.js";
+export { DEFAULT_MAX_BODY_SIZE_BYTES, computeContentDigest, sha256Base64, sha256Base64Url, } from "./digest.js";
+export { calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, } from "./keys.js";
+export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, registerPublicKey, } from "./signatures.js";

package/dist/crypto/keys.d.ts

@@ -0,0 +1,25 @@
+import type { PublicJwk, SigningKey } from "../types.js";
+/**
+ * Calculate the RFC 7638 JWK thumbprint for an Ed25519 public key.
+ */
+export declare function calculateJwkThumbprint(jwk: {
+    crv: string;
+    kty: string;
+    x: string;
+}): Promise<string>;
+/**
+ * Generate a new Ed25519 keypair using WebCrypto.
+ */
+export declare function generateSigningKey(): Promise<SigningKey>;
+/**
+ * Load and import an Ed25519 private key from various string representations
+ * (PKCS#8 Base64 DER, PKCS#8 PEM, Base64url raw seed, or JSON JWK).
+ */
+export declare function loadSigningKey(raw: string | SigningKey): Promise<SigningKey>;
+/**
+ * Load an Ed25519 public key from JWK, PEM, Base64 SPKI, or Base64url raw public key.
+ */
+export declare function loadPublicKey(raw: string | PublicJwk | CryptoKey): Promise<{
+    publicKey: CryptoKey;
+    publicJwk: PublicJwk;
+}>;

package/dist/crypto/keys.js

@@ -0,0 +1,236 @@
+import { base64ToBytes, base64UrlToBytes, bytesToBase64, bytesToBase64Url, } from "./encoding.js";
+import { sha256Base64Url } from "./digest.js";
+// PKCS#8 prefix for Ed25519 private keys (16 bytes)
+// 30 2e 02 01 00 30 05 06 03 2b 65 70 04 22 04 20
+const ED25519_PKCS8_PREFIX = new Uint8Array([
+    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20,
+]);
+// SPKI prefix for Ed25519 public keys (12 bytes)
+// 30 2a 30 05 06 03 2b 65 70 03 21 00
+const ED25519_SPKI_PREFIX = new Uint8Array([
+    0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
+]);
+/**
+ * Calculate the RFC 7638 JWK thumbprint for an Ed25519 public key.
+ */
+export async function calculateJwkThumbprint(jwk) {
+    const canonical = JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x });
+    return sha256Base64Url(canonical);
+}
+/**
+ * Generate a new Ed25519 keypair using WebCrypto.
+ */
+export async function generateSigningKey() {
+    const keyPair = (await globalThis.crypto.subtle.generateKey("Ed25519", true, [
+        "sign",
+        "verify",
+    ]));
+    const jwk = (await globalThis.crypto.subtle.exportKey("jwk", keyPair.privateKey));
+    const pkcs8Buffer = await globalThis.crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+    const privateKeyPkcs8Base64 = bytesToBase64(new Uint8Array(pkcs8Buffer));
+    const kid = await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: jwk.x });
+    const publicJwk = {
+        kty: "OKP",
+        crv: "Ed25519",
+        x: jwk.x,
+        kid,
+        use: "sig",
+        alg: "EdDSA",
+    };
+    return {
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+        publicJwk,
+        privateKeyPkcs8Base64,
+    };
+}
+/**
+ * Load and import an Ed25519 private key from various string representations
+ * (PKCS#8 Base64 DER, PKCS#8 PEM, Base64url raw seed, or JSON JWK).
+ */
+export async function loadSigningKey(raw) {
+    if (typeof raw !== "string") {
+        return raw;
+    }
+    const trimmed = raw.trim();
+    // If raw string is JSON JWK
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.kty === "OKP" && parsed.crv === "Ed25519" && parsed.d) {
+                const privateKey = await globalThis.crypto.subtle.importKey("jwk", parsed, "Ed25519", true, ["sign"]);
+                const jwk = (await globalThis.crypto.subtle.exportKey("jwk", privateKey));
+                const kid = parsed.kid || (await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: jwk.x }));
+                const publicJwk = {
+                    kty: "OKP",
+                    crv: "Ed25519",
+                    x: jwk.x,
+                    kid,
+                    use: "sig",
+                    alg: "EdDSA",
+                };
+                const publicKey = await globalThis.crypto.subtle.importKey("jwk", { kty: "OKP", crv: "Ed25519", x: jwk.x }, "Ed25519", true, ["verify"]);
+                const pkcs8Buffer = await globalThis.crypto.subtle.exportKey("pkcs8", privateKey);
+                return {
+                    privateKey,
+                    publicKey,
+                    publicJwk,
+                    privateKeyPkcs8Base64: bytesToBase64(new Uint8Array(pkcs8Buffer)),
+                };
+            }
+        }
+        catch {
+            // Continue to binary/PEM parsing
+        }
+    }
+    // Handle PEM or Base64 / Base64url
+    let cleaned = trimmed
+        .replace(/-----BEGIN [A-Z0-9_-]+ PRIVATE KEY-----/gi, "")
+        .replace(/-----END [A-Z0-9_-]+ PRIVATE KEY-----/gi, "")
+        .replace(/\\n/g, "")
+        .replace(/\s+/g, "");
+    let keyBytes;
+    try {
+        keyBytes = cleaned.includes("-") || cleaned.includes("_")
+            ? base64UrlToBytes(cleaned)
+            : base64ToBytes(cleaned);
+    }
+    catch {
+        throw new Error("Invalid base64 encoding in signing key");
+    }
+    // If 32 bytes raw seed, wrap into standard PKCS#8 DER
+    if (keyBytes.length === 32) {
+        const pkcs8 = new Uint8Array(ED25519_PKCS8_PREFIX.length + 32);
+        pkcs8.set(ED25519_PKCS8_PREFIX, 0);
+        pkcs8.set(keyBytes, ED25519_PKCS8_PREFIX.length);
+        keyBytes = pkcs8;
+    }
+    let privateKey;
+    try {
+        privateKey = await globalThis.crypto.subtle.importKey("pkcs8", keyBytes, "Ed25519", true, ["sign"]);
+    }
+    catch (err) {
+        throw new Error(`Failed to import Ed25519 private key: ${err.message}`);
+    }
+    const jwk = (await globalThis.crypto.subtle.exportKey("jwk", privateKey));
+    const kid = await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: jwk.x });
+    const publicJwk = {
+        kty: "OKP",
+        crv: "Ed25519",
+        x: jwk.x,
+        kid,
+        use: "sig",
+        alg: "EdDSA",
+    };
+    const publicKey = await globalThis.crypto.subtle.importKey("jwk", { kty: "OKP", crv: "Ed25519", x: jwk.x }, "Ed25519", true, ["verify"]);
+    return {
+        privateKey,
+        publicKey,
+        publicJwk,
+        privateKeyPkcs8Base64: bytesToBase64(keyBytes),
+    };
+}
+/**
+ * Load an Ed25519 public key from JWK, PEM, Base64 SPKI, or Base64url raw public key.
+ */
+export async function loadPublicKey(raw) {
+    if (typeof raw === "object" && "type" in raw && raw.type === "public") {
+        const exported = (await globalThis.crypto.subtle.exportKey("jwk", raw));
+        const kid = exported.kid || (await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: exported.x }));
+        return {
+            publicKey: raw,
+            publicJwk: {
+                kty: "OKP",
+                crv: "Ed25519",
+                x: exported.x,
+                kid,
+                use: "sig",
+                alg: "EdDSA",
+            },
+        };
+    }
+    if (typeof raw === "object" && "kty" in raw && raw.kty === "OKP" && raw.crv === "Ed25519") {
+        const kid = raw.kid || (await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: raw.x }));
+        const publicKey = await globalThis.crypto.subtle.importKey("jwk", { kty: "OKP", crv: "Ed25519", x: raw.x }, "Ed25519", true, ["verify"]);
+        return {
+            publicKey,
+            publicJwk: {
+                kty: "OKP",
+                crv: "Ed25519",
+                x: raw.x,
+                kid,
+                use: "sig",
+                alg: "EdDSA",
+            },
+        };
+    }
+    if (typeof raw !== "string") {
+        throw new Error("Invalid public key format");
+    }
+    const trimmed = raw.trim();
+    // Try parsing as JSON JWK or JWKS
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const jwkCandidate = parsed.keys ? parsed.keys[0] : parsed;
+            if (jwkCandidate && jwkCandidate.kty === "OKP" && jwkCandidate.crv === "Ed25519") {
+                return loadPublicKey(jwkCandidate);
+            }
+        }
+        catch {
+            // Continue
+        }
+    }
+    // Handle PEM / Base64 / Base64url
+    let cleaned = trimmed
+        .replace(/-----BEGIN [A-Z0-9_-]+ PUBLIC KEY-----/gi, "")
+        .replace(/-----END [A-Z0-9_-]+ PUBLIC KEY-----/gi, "")
+        .replace(/\\n/g, "")
+        .replace(/\s+/g, "");
+    let keyBytes;
+    try {
+        keyBytes = cleaned.includes("-") || cleaned.includes("_")
+            ? base64UrlToBytes(cleaned)
+            : base64ToBytes(cleaned);
+    }
+    catch {
+        throw new Error("Invalid base64 encoding in public key");
+    }
+    // If 32 bytes raw public key (x coord), import as JWK directly
+    if (keyBytes.length === 32) {
+        const x = bytesToBase64Url(keyBytes);
+        const kid = await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x });
+        const publicKey = await globalThis.crypto.subtle.importKey("jwk", { kty: "OKP", crv: "Ed25519", x }, "Ed25519", true, ["verify"]);
+        return {
+            publicKey,
+            publicJwk: {
+                kty: "OKP",
+                crv: "Ed25519",
+                x,
+                kid,
+                use: "sig",
+                alg: "EdDSA",
+            },
+        };
+    }
+    // Try SPKI format
+    try {
+        const publicKey = await globalThis.crypto.subtle.importKey("spki", keyBytes, "Ed25519", true, ["verify"]);
+        const jwk = (await globalThis.crypto.subtle.exportKey("jwk", publicKey));
+        const kid = await calculateJwkThumbprint({ crv: "Ed25519", kty: "OKP", x: jwk.x });
+        return {
+            publicKey,
+            publicJwk: {
+                kty: "OKP",
+                crv: "Ed25519",
+                x: jwk.x,
+                kid,
+                use: "sig",
+                alg: "EdDSA",
+            },
+        };
+    }
+    catch (err) {
+        throw new Error(`Failed to import public key: ${err.message}`);
+    }
+}