@shelbyb/daywalker-sdk 0.6.0 → 0.8.0

package/dist/config.d.ts

@@ -12,7 +12,16 @@ export interface ResolvedConfig {
     domain: string | null;
     domainSource: string | null;
     daywalkerPublicKey: string | PublicJwk | PublicJwks | null;
+    /** "auto": offline verification keys come from `${authUrl}/.well-known/jwks.json` (env DAYWALKER_JWKS). */
+    jwks: "auto" | null;
     leaseIssuer: string | null;
+    /** Ephemeral signing keys, when enabled: their lifetime and this process's key slot (null = random). */
+    ephemeralKey: {
+        ttlSeconds: number;
+        instanceId: string | null;
+    } | null;
+    /** Origin clients use to reach this service, for DPoP `htu` checks (env DAYWALKER_PUBLIC_ORIGIN). */
+    publicOrigin: string | null;
     authUrl: string;
     cacheTtlMs: number;
     negativeCacheTtlMs: number;
@@ -22,6 +31,8 @@ export interface ResolvedConfig {
     timeoutMs: number;
     problems: string[];
 }
+/** Default lifetime of an ephemeral signing key (6 hours); it is replaced when a quarter of that is left. */
+export declare const DEFAULT_EPHEMERAL_KEY_TTL_SECONDS = 21600;
 /** Default per-attempt timeout for requests to Daywalker Auth. */
 export declare const DEFAULT_TIMEOUT_MS = 5000;
 /**
@@ -31,7 +42,7 @@ export declare const DEFAULT_TIMEOUT_MS = 5000;
 export declare function publicHostname(value: string | undefined | null): string | null;
 /**
  * Throws unless `value` is an https: URL (http: is allowed only for localhost / 127.0.0.1 / [::1]),
- * so API keys, SDK keys and write keys never travel in cleartext.
+ * so API keys, access tokens, SDK keys and write keys never travel in cleartext.
  */
 export declare function assertSecureUrl(name: string, value: string): void;
 /**

package/dist/config.js

@@ -1,3 +1,5 @@
+/** Default lifetime of an ephemeral signing key (6 hours); it is replaced when a quarter of that is left. */
+export const DEFAULT_EPHEMERAL_KEY_TTL_SECONDS = 21_600;
 /** Default per-attempt timeout for requests to Daywalker Auth. */
 export const DEFAULT_TIMEOUT_MS = 5_000;
 const URL_ENV_VARS = [
@@ -50,7 +52,7 @@ export function publicHostname(value) {
 const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
 /**
  * Throws unless `value` is an https: URL (http: is allowed only for localhost / 127.0.0.1 / [::1]),
- * so API keys, SDK keys and write keys never travel in cleartext.
+ * so API keys, access tokens, SDK keys and write keys never travel in cleartext.
  */
 export function assertSecureUrl(name, value) {
     let url;
@@ -60,6 +62,9 @@ export function assertSecureUrl(name, value) {
     catch {
         throw new Error(`${name} must be an absolute https:// URL (got "${value}")`);
     }
+    if (url.username || url.password) {
+        throw new Error(`${name} must not contain credentials`);
+    }
     if (url.protocol === "https:")
         return;
     if (url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname))
@@ -81,7 +86,7 @@ export function resolveConfig(options = {}) {
     const serviceSlugs = parseServiceSlugs(options.serviceSlugs ?? options.serviceSlug ?? env.DAYWALKER_SERVICE_SLUG);
     const serviceSlug = serviceSlugs[0] ?? null;
     if (!apiKey)
-        problems.push("DAYWALKER_API_KEY is not set");
+        problems.push("DAYWALKER_API_KEY is not set: it is the client credential for the OAuth client credentials grant");
     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;
@@ -108,7 +113,31 @@ export function resolveConfig(options = {}) {
         }
     }
     const daywalkerPublicKey = options.daywalkerPublicKey ?? (env.DAYWALKER_PUBLIC_KEY ? env.DAYWALKER_PUBLIC_KEY.trim() : null);
+    const rawJwks = String(options.jwks ?? env.DAYWALKER_JWKS ?? "").trim().toLowerCase();
+    const jwks = rawJwks === "auto" ? "auto" : null;
+    if (rawJwks && rawJwks !== "auto" && rawJwks !== "off")
+        problems.push(`DAYWALKER_JWKS must be "auto" or "off" (got "${rawJwks.slice(0, 40)}"); JWKS fetching is off`);
     const leaseIssuer = (options.leaseIssuer ?? env.DAYWALKER_LEASE_ISSUER ?? "").trim() || null;
+    let ephemeralKey = null;
+    const ephemeralOption = options.ephemeralKey ?? (/^(1|true|yes)$/i.test(env.DAYWALKER_EPHEMERAL_KEY ?? "") ? true : undefined);
+    if (ephemeralOption) {
+        const o = typeof ephemeralOption === "object" ? ephemeralOption : {};
+        const ttlSeconds = o.ttlSeconds ?? (env.DAYWALKER_KEY_TTL_SECONDS ? Number(env.DAYWALKER_KEY_TTL_SECONDS) : DEFAULT_EPHEMERAL_KEY_TTL_SECONDS);
+        if (!Number.isInteger(ttlSeconds) || ttlSeconds < 3_600 || ttlSeconds > 2_592_000) {
+            throw new Error(`ephemeralKey.ttlSeconds must be a whole number of seconds from 3600 to 2592000 (got ${ttlSeconds})`);
+        }
+        const instanceId = (o.instanceId ?? env.DAYWALKER_INSTANCE_ID ?? "").trim() || null;
+        if (instanceId !== null && !/^[A-Za-z0-9_.-]{1,64}$/.test(instanceId)) {
+            throw new Error("ephemeralKey.instanceId must be 1-64 of A-Z a-z 0-9 . _ -");
+        }
+        ephemeralKey = { ttlSeconds, instanceId };
+    }
+    const rawPublicOrigin = (options.publicOrigin ?? env.DAYWALKER_PUBLIC_ORIGIN ?? "").trim();
+    let publicOrigin = null;
+    if (rawPublicOrigin) {
+        assertSecureUrl("publicOrigin", rawPublicOrigin);
+        publicOrigin = new URL(rawPublicOrigin).origin;
+    }
     const authUrl = (options.authUrl ?? env.DAYWALKER_AUTH_URL ?? "https://auth.daywalker.dev").replace(/\/+$/, "");
     assertSecureUrl("authUrl", authUrl);
     const cacheTtlMs = options.cacheTtlMs ?? 60_000;
@@ -134,7 +163,10 @@ export function resolveConfig(options = {}) {
         domain,
         domainSource,
         daywalkerPublicKey,
+        jwks,
         leaseIssuer,
+        ephemeralKey,
+        publicOrigin,
         authUrl,
         cacheTtlMs,
         negativeCacheTtlMs,

package/dist/crypto/digest.js

@@ -1,3 +1,4 @@
+import { webcrypto } from "./webcrypto.js";
 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;
@@ -15,7 +16,7 @@ export async function computeContentDigest(body, maxSizeBytes = DEFAULT_MAX_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 hashBuffer = await webcrypto.digest("SHA-256", data);
     const hashBase64 = bytesToBase64(new Uint8Array(hashBuffer));
     return `sha-256=:${hashBase64}:`;
 }
@@ -24,7 +25,7 @@ export async function computeContentDigest(body, maxSizeBytes = DEFAULT_MAX_BODY
  */
 export async function sha256Base64(data) {
     const bytes = typeof data === "string" ? stringToUtf8(data) : data;
-    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    const hashBuffer = await webcrypto.digest("SHA-256", bytes);
     return bytesToBase64(new Uint8Array(hashBuffer));
 }
 /**

package/dist/crypto/dpop.d.ts

@@ -1,3 +1,4 @@
+import { SignatureReplayCache, type ReplayStore } from "./signatures.js";
 /**
  * DPoP (RFC 9449) proof-of-possession. Daywalker binds every access and refresh token to a client key and
  * requires a fresh proof on each token request, refresh and validate call.
@@ -10,7 +11,10 @@ export interface DpopKey {
         x: string;
     };
 }
-/** A new in-memory Ed25519 DPoP key. Tokens are bound to it, so keep it for the life of the session. */
+/**
+ * A new in-memory Ed25519 DPoP key. Tokens are bound to it, so keep it for the life of the session. The private
+ * key is non-extractable: nothing (including this SDK) can export it, so a bound token can't be moved elsewhere.
+ */
 export declare function generateDpopKey(): Promise<DpopKey>;
 /**
  * Builds a DPoP proof JWT for one request. `htu` is the URL without query or fragment. Pass the access token
@@ -21,3 +25,36 @@ export declare function createDpopProof(key: DpopKey, params: {
     url: string;
     accessToken?: string;
 }): Promise<string>;
+/** Longest accepted DPoP proof (bytes). A proof is a small JWT; anything bigger is refused unparsed. */
+export declare const MAX_DPOP_PROOF_LENGTH = 4096;
+/** How old (or how far in the future) a proof's `iat` may be. */
+export declare const DPOP_MAX_AGE_SECONDS = 60;
+/** Proof `jti`s seen recently, per process. Pass a shared `ReplayStore` when several instances verify. */
+export declare const globalDpopReplayCache: SignatureReplayCache;
+export interface VerifyDpopProofParams {
+    /** The `DPoP` request header. */
+    proof: string;
+    /** The request method. */
+    method: string;
+    /** The URL the client called (its scheme, host and path must match the proof's `htu`). */
+    url: string;
+    /** The access token presented with `Authorization: DPoP`; the proof's `ath` must be its SHA-256. */
+    accessToken: string;
+    /** The token's `cnf.jkt`: the RFC 7638 thumbprint of the key the token is bound to. */
+    expectedJkt: string;
+    currentTime?: number;
+    /** At most `DPOP_MAX_AGE_SECONDS`. */
+    maxAgeSeconds?: number;
+    replayStore?: ReplayStore;
+}
+/**
+ * Verifies the DPoP proof that must accompany a DPoP-bound (`cnf.jkt`) access token (RFC 9449 §4.3 and
+ * §7.1): `typ: dpop+jwt`, EdDSA or ES256 signed by the public key in its `jwk` header (whose thumbprint must
+ * equal the token's `cnf.jkt`), `htm` / `htu` matching this request, a recent `iat`, an `ath` equal to the
+ * SHA-256 of the access token, and a `jti` never seen before. Without a valid proof a bound token is useless
+ * to whoever copied it.
+ */
+export declare function verifyDpopProof(params: VerifyDpopProofParams): Promise<{
+    valid: boolean;
+    error?: string;
+}>;

package/dist/crypto/dpop.js

@@ -1,9 +1,14 @@
-import { bytesToBase64Url, stringToUtf8 } from "./encoding.js";
+import { webcrypto } from "./webcrypto.js";
+import { base64UrlToBytesStrict, bytesToBase64Url, stringToUtf8, timingSafeEqualString, utf8ToString } from "./encoding.js";
+import { SignatureReplayCache } from "./signatures.js";
 import { sha256Base64Url } from "./digest.js";
-/** A new in-memory Ed25519 DPoP key. Tokens are bound to it, so keep it for the life of the session. */
+/**
+ * A new in-memory Ed25519 DPoP key. Tokens are bound to it, so keep it for the life of the session. The private
+ * key is non-extractable: nothing (including this SDK) can export it, so a bound token can't be moved elsewhere.
+ */
 export async function generateDpopKey() {
-    const pair = (await globalThis.crypto.subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"]));
-    const jwk = (await globalThis.crypto.subtle.exportKey("jwk", pair.publicKey));
+    const pair = (await webcrypto.generateKey({ name: "Ed25519" }, false, ["sign", "verify"]));
+    const jwk = (await webcrypto.exportKey("jwk", pair.publicKey));
     return { privateKey: pair.privateKey, publicJwk: { kty: "OKP", crv: "Ed25519", x: jwk.x } };
 }
 const b64u = (value) => bytesToBase64Url(stringToUtf8(JSON.stringify(value)));
@@ -15,7 +20,7 @@ export async function createDpopProof(key, params) {
     const u = new URL(params.url);
     const header = { typ: "dpop+jwt", alg: "EdDSA", jwk: key.publicJwk };
     const claims = {
-        jti: globalThis.crypto.randomUUID(),
+        jti: webcrypto.randomUUID(),
         htm: params.method.toUpperCase(),
         htu: `${u.origin}${u.pathname}`,
         iat: Math.floor(Date.now() / 1000),
@@ -23,6 +28,119 @@ export async function createDpopProof(key, params) {
     if (params.accessToken)
         claims.ath = await sha256Base64Url(params.accessToken);
     const signingInput = `${b64u(header)}.${b64u(claims)}`;
-    const sig = new Uint8Array(await globalThis.crypto.subtle.sign({ name: "Ed25519" }, key.privateKey, stringToUtf8(signingInput)));
+    const sig = new Uint8Array(await webcrypto.sign({ name: "Ed25519" }, key.privateKey, stringToUtf8(signingInput)));
     return `${signingInput}.${bytesToBase64Url(sig)}`;
 }
+/** Longest accepted DPoP proof (bytes). A proof is a small JWT; anything bigger is refused unparsed. */
+export const MAX_DPOP_PROOF_LENGTH = 4096;
+/** How old (or how far in the future) a proof's `iat` may be. */
+export const DPOP_MAX_AGE_SECONDS = 60;
+/** Proof `jti`s seen recently, per process. Pass a shared `ReplayStore` when several instances verify. */
+export const globalDpopReplayCache = new SignatureReplayCache();
+/** Normalized `htu`: scheme, host and path, no query or fragment (RFC 9449 §4.3). */
+function htuOf(value) {
+    try {
+        const u = new URL(value);
+        if (u.protocol !== "https:" && u.protocol !== "http:")
+            return null;
+        return `${u.protocol}//${u.host}${u.pathname}`;
+    }
+    catch {
+        return null;
+    }
+}
+const B64URL = /^[A-Za-z0-9_-]+$/;
+/** RFC 7638 thumbprint of an Ed25519 or P-256 public JWK, or null for any other (or a private) key. */
+async function proofKey(jwk) {
+    if (!jwk || typeof jwk !== "object" || Array.isArray(jwk))
+        return null;
+    const k = jwk;
+    if ("d" in k || "p" in k || "q" in k)
+        return null; // never a private key
+    if (k.kty === "OKP" && k.crv === "Ed25519" && typeof k.x === "string" && B64URL.test(k.x)) {
+        const key = await webcrypto.importKey("jwk", { kty: "OKP", crv: "Ed25519", x: k.x }, { name: "Ed25519" }, false, ["verify"]);
+        return { key, jkt: await sha256Base64Url(JSON.stringify({ crv: "Ed25519", kty: "OKP", x: k.x })), alg: "EdDSA" };
+    }
+    if (k.kty === "EC" && k.crv === "P-256" && typeof k.x === "string" && typeof k.y === "string" && B64URL.test(k.x) && B64URL.test(k.y)) {
+        const key = await webcrypto.importKey("jwk", { kty: "EC", crv: "P-256", x: k.x, y: k.y }, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+        return { key, jkt: await sha256Base64Url(JSON.stringify({ crv: "P-256", kty: "EC", x: k.x, y: k.y })), alg: "ES256" };
+    }
+    return null;
+}
+/**
+ * Verifies the DPoP proof that must accompany a DPoP-bound (`cnf.jkt`) access token (RFC 9449 §4.3 and
+ * §7.1): `typ: dpop+jwt`, EdDSA or ES256 signed by the public key in its `jwk` header (whose thumbprint must
+ * equal the token's `cnf.jkt`), `htm` / `htu` matching this request, a recent `iat`, an `ath` equal to the
+ * SHA-256 of the access token, and a `jti` never seen before. Without a valid proof a bound token is useless
+ * to whoever copied it.
+ */
+export async function verifyDpopProof(params) {
+    try {
+        const { proof } = params;
+        if (typeof proof !== "string" || proof.length === 0 || proof.length > MAX_DPOP_PROOF_LENGTH) {
+            return { valid: false, error: "Missing or oversized DPoP proof" };
+        }
+        const parts = proof.split(".");
+        if (parts.length !== 3)
+            return { valid: false, error: "DPoP proof is not a JWT" };
+        let header;
+        let claims;
+        let signature;
+        try {
+            header = JSON.parse(utf8ToString(base64UrlToBytesStrict(parts[0])));
+            claims = JSON.parse(utf8ToString(base64UrlToBytesStrict(parts[1])));
+            signature = base64UrlToBytesStrict(parts[2]);
+        }
+        catch {
+            return { valid: false, error: "DPoP proof segments must be canonical base64url JSON" };
+        }
+        if (!header || typeof header !== "object" || Array.isArray(header) || !claims || typeof claims !== "object" || Array.isArray(claims)) {
+            return { valid: false, error: "DPoP proof header and claims must be JSON objects" };
+        }
+        if (header.typ !== "dpop+jwt")
+            return { valid: false, error: "DPoP proof typ must be dpop+jwt" };
+        if (header.crit !== undefined)
+            return { valid: false, error: "Unsupported DPoP crit header" };
+        const key = await proofKey(header.jwk);
+        if (!key)
+            return { valid: false, error: "DPoP proof jwk must be an Ed25519 or P-256 public key" };
+        if (header.alg !== key.alg)
+            return { valid: false, error: `DPoP proof alg must be ${key.alg} for this key` };
+        const signed = stringToUtf8(`${parts[0]}.${parts[1]}`);
+        const ok = key.alg === "EdDSA"
+            ? await webcrypto.verify({ name: "Ed25519" }, key.key, signature, signed)
+            : await webcrypto.verify({ name: "ECDSA", hash: "SHA-256" }, key.key, signature, signed);
+        if (!ok)
+            return { valid: false, error: "DPoP proof signature verification failed" };
+        if (typeof params.expectedJkt !== "string" || !timingSafeEqualString(key.jkt, params.expectedJkt)) {
+            return { valid: false, error: "DPoP proof key does not match the token's cnf.jkt" };
+        }
+        if (typeof claims.htm !== "string" || claims.htm !== params.method.toUpperCase()) {
+            return { valid: false, error: "DPoP proof htm does not match the request method" };
+        }
+        const expectedHtu = htuOf(params.url);
+        if (!expectedHtu || typeof claims.htu !== "string" || htuOf(claims.htu) !== expectedHtu) {
+            return { valid: false, error: "DPoP proof htu does not match the request URL" };
+        }
+        const now = params.currentTime ?? Math.floor(Date.now() / 1000);
+        const maxAge = Math.max(1, Math.min(params.maxAgeSeconds ?? DPOP_MAX_AGE_SECONDS, DPOP_MAX_AGE_SECONDS));
+        if (typeof claims.iat !== "number" || !Number.isFinite(claims.iat) || Math.abs(now - claims.iat) > maxAge) {
+            return { valid: false, error: "DPoP proof iat is missing or outside the accepted window" };
+        }
+        const ath = await sha256Base64Url(params.accessToken);
+        if (typeof claims.ath !== "string" || !timingSafeEqualString(claims.ath, ath)) {
+            return { valid: false, error: "DPoP proof ath does not match the access token" };
+        }
+        if (typeof claims.jti !== "string" || claims.jti.length === 0 || claims.jti.length > 256) {
+            return { valid: false, error: "DPoP proof has no usable jti" };
+        }
+        const store = params.replayStore ?? globalDpopReplayCache;
+        if (!(await store.record(`dpop:${key.jkt}:${claims.jti}`, 2 * maxAge * 1000))) {
+            return { valid: false, error: "DPoP proof replayed (jti already used)" };
+        }
+        return { valid: true };
+    }
+    catch (err) {
+        return { valid: false, error: `DPoP proof verification error: ${err.message}` };
+    }
+}

package/dist/crypto/encoding.js

@@ -70,6 +70,8 @@ export function bytesToHex(bytes) {
 }
 export function hexToBytes(hex) {
     const clean = hex.trim().replace(/^0x/i, "");
+    if (clean.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(clean))
+        throw new Error("Invalid hex string");
     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);

package/dist/crypto/index.d.ts

@@ -1,7 +1,9 @@
 export { stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, base64UrlToBytesStrict, 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, REPLAY_CACHE_MAX_ENTRIES, SignatureReplayCache, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, leaseServices, registerPublicKey, } from "./signatures.js";
+export { calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, importSigningKey, } from "./keys.js";
+export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, REPLAY_CACHE_MAX_ENTRIES, SignatureReplayCache, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, leaseServices, SERVICE_SLUG_PATTERN, API_KEY_PATTERN, } from "./signatures.js";
+export { registerPublicKey, listSigningKeys, revokeSigningKey, keySlotFor, randomInstanceId, INSTANCE_ID_PATTERN, MIN_KEY_TTL_SECONDS, MAX_KEY_TTL_SECONDS, } from "./key-api.js";
+export type { SigningKeyRecord, KeyApiResult } from "./key-api.js";
 export type { SignedHeaders, SignRequestParams, VerifySignatureParams, VerifySignatureResult, ReplayStore, } from "./signatures.js";
-export { generateDpopKey, createDpopProof } from "./dpop.js";
-export type { DpopKey } from "./dpop.js";
+export { generateDpopKey, createDpopProof, verifyDpopProof, globalDpopReplayCache, MAX_DPOP_PROOF_LENGTH, DPOP_MAX_AGE_SECONDS } from "./dpop.js";
+export type { DpopKey, VerifyDpopProofParams } from "./dpop.js";

package/dist/crypto/index.js

@@ -1,5 +1,6 @@
 export { stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, base64UrlToBytesStrict, 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, REPLAY_CACHE_MAX_ENTRIES, SignatureReplayCache, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, leaseServices, registerPublicKey, } from "./signatures.js";
-export { generateDpopKey, createDpopProof } from "./dpop.js";
+export { calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, importSigningKey, } from "./keys.js";
+export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, REPLAY_CACHE_MAX_ENTRIES, SignatureReplayCache, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, leaseServices, SERVICE_SLUG_PATTERN, API_KEY_PATTERN, } from "./signatures.js";
+export { registerPublicKey, listSigningKeys, revokeSigningKey, keySlotFor, randomInstanceId, INSTANCE_ID_PATTERN, MIN_KEY_TTL_SECONDS, MAX_KEY_TTL_SECONDS, } from "./key-api.js";
+export { generateDpopKey, createDpopProof, verifyDpopProof, globalDpopReplayCache, MAX_DPOP_PROOF_LENGTH, DPOP_MAX_AGE_SECONDS } from "./dpop.js";

package/dist/crypto/key-api.d.ts

@@ -0,0 +1,69 @@
+import type { PublicJwk } from "../types.js";
+/** Daywalker's `instanceId` format: one key slot per (domain, instanceId). */
+export declare const INSTANCE_ID_PATTERN: RegExp;
+/** Key lifetime bounds Daywalker accepts for `ttlSeconds` (1 hour to 30 days). */
+export declare const MIN_KEY_TTL_SECONDS = 3600;
+export declare const MAX_KEY_TTL_SECONDS = 2592000;
+/**
+ * The instance slot the SDK registers a key in: one slot per key (`dw-<keyId>`), so registering a key never
+ * demotes another one (Daywalker moves the previous key of the same slot to ROTATING, then revokes it).
+ */
+export declare function keySlotFor(keyId: string): string;
+/** A signing key as Daywalker reports it. */
+export interface SigningKeyRecord {
+    id?: string;
+    keyId: string;
+    domain: string;
+    status: "ACTIVE" | "ROTATING" | "REVOKED";
+    instanceId: string | null;
+    /** Unix seconds, or null when the key doesn't expire. */
+    expiresAt: number | null;
+    createdAt: number | null;
+    lastUsedAt: number | null;
+}
+export interface KeyApiResult {
+    ok: boolean;
+    status: number;
+    /** Daywalker's error code (`KEY_LIMIT_REACHED`, `KEY_ID_CONFLICT`, `domain_not_allowed`, …). */
+    code?: string;
+    error?: string;
+}
+interface KeyApiBase {
+    authUrl?: string;
+    apiKey: string;
+    fetchFn?: typeof fetch;
+}
+/**
+ * Register public key directly with Daywalker Auth via POST /api/v1/keys/register (Push Architecture).
+ * Re-registering the same key is idempotent (200). `instanceId` puts the key in a slot: registering a new key
+ * in an occupied slot moves the old one to ROTATING for 10 minutes, then revokes it; without `instanceId`
+ * the same happens to every other slot-less key of the domain, so the SDK always passes one (`keySlotFor`).
+ * `ttlSeconds` (1 hour to 30 days) or `expiresAt` make the key expire. Errors carry Daywalker's `code`
+ * (`KEY_LIMIT_REACHED`: 20 live keys per domain; `KEY_ID_CONFLICT`; `domain_not_allowed`).
+ */
+export declare function registerPublicKey(params: KeyApiBase & {
+    serviceSlug?: string;
+    domain?: string | null;
+    publicJwk: PublicJwk;
+    instanceId?: string;
+    ttlSeconds?: number;
+    expiresAt?: Date;
+}): Promise<KeyApiResult & {
+    key?: SigningKeyRecord;
+}>;
+/** Lists the signing keys registered for `domain` (GET /api/v1/keys), newest first. */
+export declare function listSigningKeys(params: KeyApiBase & {
+    domain: string;
+}): Promise<KeyApiResult & {
+    keys?: SigningKeyRecord[];
+}>;
+/**
+ * Revokes a signing key now (DELETE /api/v1/keys/{keyId}). Daywalker also ends every OAuth session that was
+ * authenticated with it. Revoking a key that is already revoked succeeds; an unknown key is 404 `key_not_found`.
+ */
+export declare function revokeSigningKey(params: KeyApiBase & {
+    keyId: string;
+}): Promise<KeyApiResult>;
+/** A random instance slot for a process (`dw-i-<random>`), for keys that live only as long as it does. */
+export declare function randomInstanceId(): string;
+export {};