@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/remote-runtime-credential-store.d.ts

@@ -0,0 +1,45 @@
+export interface RemoteRuntimeClientCredential {
+    version: 2;
+    daemonId: string;
+    identityPublicKey: string;
+    serverEncryptionPublicKey: string;
+    clientId: string;
+    grantId: string;
+    clientPublicKey: string;
+    clientPrivateKeyPem: string;
+}
+export interface RemoteRuntimePendingClientCredential {
+    version: 2;
+    state: "pending_enrollment";
+    daemonId: string;
+    identityPublicKey: string;
+    serverEncryptionPublicKey: string;
+    claimId: string;
+    clientId: string;
+    clientPublicKey: string;
+    clientPrivateKeyPem: string;
+}
+export type RemoteRuntimeEnrollmentCredential = {
+    state: "pending";
+    credential: RemoteRuntimePendingClientCredential;
+} | {
+    state: "accepted";
+    credential: RemoteRuntimeClientCredential;
+};
+/**
+ * Protected-file credential adapter used by the headless resident daemon.
+ * The opaque reference, never the private key, is persisted with target data.
+ */
+export declare class FileRemoteRuntimeCredentialStore {
+    private readonly env;
+    constructor(env?: NodeJS.ProcessEnv);
+    save(input: RemoteRuntimeClientCredential): Promise<string>;
+    savePending(input: RemoteRuntimePendingClientCredential): Promise<string>;
+    loadEnrollment(credentialRef: string): Promise<RemoteRuntimeEnrollmentCredential>;
+    finalizePending(credentialRef: string, claimIdInput: string, input: RemoteRuntimeClientCredential): Promise<void>;
+    private saveNew;
+    load(credentialRef: string): Promise<RemoteRuntimeClientCredential>;
+    remove(credentialRef: string): Promise<void>;
+    private readValue;
+}
+export declare function credentialDirectory(env?: NodeJS.ProcessEnv): string;

package/dist/remote-runtime-credential-store.js

@@ -0,0 +1,639 @@
+import { createPrivateKey, createPublicKey, randomBytes, sign, verify, } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+const CREDENTIAL_VERSION = 2;
+const CREDENTIAL_DIRECTORY = "remote-runtime-credentials";
+const CREDENTIAL_REF_PATTERN = /^credential_[A-Za-z0-9_-]{24}$/;
+const OPAQUE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/;
+const MAX_CREDENTIAL_BYTES = 16 * 1024;
+const MAX_PRIVATE_KEY_CHARS = 8 * 1024;
+const CREDENTIAL_DIRECTORY_MODE = 0o700;
+const CREDENTIAL_FILE_MODE = 0o600;
+const CHECK_POSIX_SECURITY = process.platform !== "win32";
+function assertProtectedCredentialStorageSupported() {
+    if (!CHECK_POSIX_SECURITY) {
+        throw new Error("Remote Runtime credential storage requires a verified OS-protected backend; Windows is not supported yet");
+    }
+}
+/**
+ * Protected-file credential adapter used by the headless resident daemon.
+ * The opaque reference, never the private key, is persisted with target data.
+ */
+export class FileRemoteRuntimeCredentialStore {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    async save(input) {
+        assertProtectedCredentialStorageSupported();
+        const credential = validateCredential(input);
+        return await this.saveNew(encodeCredential(credential));
+    }
+    async savePending(input) {
+        assertProtectedCredentialStorageSupported();
+        const credential = validatePendingCredential(input);
+        return await this.saveNew(encodeCredential(credential));
+    }
+    async loadEnrollment(credentialRef) {
+        assertProtectedCredentialStorageSupported();
+        const { ref, value } = await this.readValue(credentialRef);
+        try {
+            if (isRecord(value) && value.state === "pending_enrollment") {
+                return { state: "pending", credential: validatePendingCredential(value) };
+            }
+            return { state: "accepted", credential: validateCredential(value) };
+        }
+        catch (error) {
+            throw new Error(`invalid Remote Runtime credential ${ref}: ${messageOf(error)}`);
+        }
+    }
+    async finalizePending(credentialRef, claimIdInput, input) {
+        assertProtectedCredentialStorageSupported();
+        const ref = validateCredentialRef(credentialRef);
+        const claimId = opaqueId(claimIdInput, "claimId");
+        const credential = validateCredential(input);
+        const encoded = encodeCredential(credential);
+        const directory = credentialDirectory(this.env);
+        const file = credentialFile(directory, ref);
+        await withSecureCredentialDirectory(directory, false, async (guard) => {
+            const value = parseCredentialJson(ref, (await readSecureCredentialFile(file)).toString("utf8"));
+            if (isRecord(value) && value.state === "pending_enrollment") {
+                const pending = validatePendingCredential(value);
+                assertPendingMatchesAccepted(pending, claimId, credential);
+                await replaceSecureCredentialFile(directory, file, encoded);
+                await guard.sync();
+                return;
+            }
+            const accepted = validateCredential(value);
+            if (!sameAcceptedCredential(accepted, credential)) {
+                throw new Error("accepted Runtime credential differs from the enrollment result");
+            }
+        });
+    }
+    async saveNew(encoded) {
+        const directory = credentialDirectory(this.env);
+        let createdFile;
+        try {
+            const credentialRef = await withSecureCredentialDirectory(directory, true, async (guard) => {
+                for (let attempt = 0; attempt < 4; attempt += 1) {
+                    const ref = `credential_${randomBytes(18).toString("base64url")}`;
+                    const file = credentialFile(directory, ref);
+                    if (!(await createSecureCredentialFile(file, encoded)))
+                        continue;
+                    createdFile = file;
+                    await guard.sync();
+                    return ref;
+                }
+                throw new Error("failed to allocate a Remote Runtime credential reference");
+            });
+            createdFile = undefined;
+            return credentialRef;
+        }
+        catch (error) {
+            if (createdFile)
+                await rm(createdFile, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    async load(credentialRef) {
+        const enrollment = await this.loadEnrollment(credentialRef);
+        if (enrollment.state === "pending") {
+            throw new Error(`invalid Remote Runtime credential ${validateCredentialRef(credentialRef)}: enrollment is pending`);
+        }
+        return enrollment.credential;
+    }
+    async remove(credentialRef) {
+        const ref = validateCredentialRef(credentialRef);
+        const directory = credentialDirectory(this.env);
+        try {
+            await withSecureCredentialDirectory(directory, false, async (guard) => {
+                await rm(credentialFile(directory, ref), { force: true });
+                await guard.sync();
+            });
+        }
+        catch (error) {
+            if (hasCode(error, "ENOENT"))
+                return;
+            throw error;
+        }
+    }
+    async readValue(credentialRef) {
+        const ref = validateCredentialRef(credentialRef);
+        const directory = credentialDirectory(this.env);
+        const file = credentialFile(directory, ref);
+        let raw;
+        try {
+            raw = await withSecureCredentialDirectory(directory, false, async () => (await readSecureCredentialFile(file)).toString("utf8"));
+        }
+        catch (error) {
+            throw new Error(`failed to load Remote Runtime credential ${ref}: ${messageOf(error)}`);
+        }
+        return { ref, value: parseCredentialJson(ref, raw) };
+    }
+}
+export function credentialDirectory(env = process.env) {
+    return join(rynxHome(env), CREDENTIAL_DIRECTORY);
+}
+function credentialFile(directory, credentialRef) {
+    return join(directory, `${validateCredentialRef(credentialRef)}.json`);
+}
+async function withSecureCredentialDirectory(directory, create, operation) {
+    if (create) {
+        await mkdir(directory, { recursive: true, mode: CREDENTIAL_DIRECTORY_MODE });
+    }
+    const guard = await openCredentialDirectoryGuard(directory);
+    let result;
+    let operationFailed = false;
+    let operationError;
+    try {
+        result = await operation(guard);
+    }
+    catch (error) {
+        operationFailed = true;
+        operationError = error;
+    }
+    let verificationError;
+    try {
+        await guard.verify();
+    }
+    catch (error) {
+        verificationError = error;
+    }
+    try {
+        await guard.close();
+    }
+    catch (error) {
+        verificationError ??= error;
+    }
+    // A directory-integrity failure wins over an operation error: callers must
+    // never treat a read or write as trustworthy after its parent changed.
+    if (verificationError !== undefined)
+        throw verificationError;
+    if (operationFailed)
+        throw operationError;
+    return result;
+}
+async function openCredentialDirectoryGuard(directory) {
+    if (!CHECK_POSIX_SECURITY) {
+        const initial = await inspectCredentialDirectoryPath(directory);
+        const identity = fileIdentity(initial);
+        return {
+            async verify() {
+                const current = await inspectCredentialDirectoryPath(directory);
+                assertSameFile(identity, current, "credential directory changed during access");
+            },
+            async sync() { },
+            async close() { },
+        };
+    }
+    let handle;
+    try {
+        handle = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        throw new Error(`credential directory must be a non-symlink directory: ${messageOf(error)}`, { cause: error });
+    }
+    let initial;
+    try {
+        initial = await secureCredentialDirectoryHandle(handle, directory);
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+    }
+    const identity = fileIdentity(initial);
+    return {
+        async verify() {
+            await secureCredentialDirectoryHandle(handle, directory, identity);
+        },
+        async sync() {
+            await handle.sync();
+        },
+        async close() {
+            await handle.close();
+        },
+    };
+}
+async function secureCredentialDirectoryHandle(handle, directory, expected) {
+    let stats = await handle.stat({ bigint: true });
+    assertDirectoryMetadata(stats);
+    if (expected)
+        assertSameFile(expected, stats, "credential directory changed during access");
+    stats = await tightenHandlePermissions(handle, stats, CREDENTIAL_DIRECTORY_MODE, "credential directory");
+    assertDirectoryMetadata(stats);
+    if (expected)
+        assertSameFile(expected, stats, "credential directory changed during access");
+    await assertSecurePath(directory, stats, "directory", CREDENTIAL_DIRECTORY_MODE);
+    return stats;
+}
+async function inspectCredentialDirectoryPath(directory) {
+    const stats = await lstat(directory, { bigint: true });
+    assertDirectoryMetadata(stats);
+    assertMode(stats, CREDENTIAL_DIRECTORY_MODE, "credential directory");
+    return stats;
+}
+async function createSecureCredentialFile(file, bytes) {
+    let handle;
+    try {
+        handle = await open(file, constants.O_WRONLY |
+            constants.O_CREAT |
+            constants.O_EXCL |
+            (CHECK_POSIX_SECURITY ? constants.O_NOFOLLOW : 0), CREDENTIAL_FILE_MODE);
+    }
+    catch (error) {
+        if (hasCode(error, "EEXIST"))
+            return false;
+        throw new Error(`failed to create Remote Runtime credential file: ${messageOf(error)}`);
+    }
+    let identity;
+    try {
+        let stats = await secureCredentialFileHandle(handle, file);
+        identity = fileIdentity(stats);
+        if (stats.size !== 0n)
+            throw new Error("new credential file is not empty");
+        await handle.writeFile(bytes);
+        await handle.sync();
+        stats = await secureCredentialFileHandle(handle, file, identity);
+        if (stats.size !== BigInt(bytes.byteLength)) {
+            throw new Error("credential file size changed while saving");
+        }
+        await handle.close();
+        handle = undefined;
+        await assertSecureCredentialPath(file, identity);
+        return true;
+    }
+    catch (error) {
+        if (handle && identity) {
+            try {
+                await secureCredentialFileHandle(handle, file, identity);
+            }
+            catch (verificationError) {
+                error = verificationError;
+            }
+        }
+        await handle?.close().catch(() => undefined);
+        await rm(file, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function replaceSecureCredentialFile(directory, file, bytes) {
+    let temporaryFile;
+    try {
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            const name = `.credential-finalize-${randomBytes(18).toString("base64url")}.tmp`;
+            const candidate = join(directory, name);
+            if (!(await createSecureCredentialFile(candidate, bytes)))
+                continue;
+            temporaryFile = candidate;
+            break;
+        }
+        if (!temporaryFile) {
+            throw new Error("failed to allocate a temporary Runtime credential file");
+        }
+        await rename(temporaryFile, file);
+        temporaryFile = undefined;
+        const persisted = await readSecureCredentialFile(file);
+        if (!persisted.equals(bytes)) {
+            throw new Error("finalized Runtime credential differs from the accepted credential");
+        }
+    }
+    finally {
+        if (temporaryFile)
+            await rm(temporaryFile, { force: true }).catch(() => undefined);
+    }
+}
+async function readSecureCredentialFile(file) {
+    await assertCredentialPathBeforeOpen(file);
+    let handle;
+    try {
+        handle = await open(file, constants.O_RDONLY | (CHECK_POSIX_SECURITY ? constants.O_NOFOLLOW : 0));
+    }
+    catch (error) {
+        throw new Error(`credential file must be a non-symlink regular file: ${messageOf(error)}`, { cause: error });
+    }
+    let identity;
+    let before;
+    let bytes;
+    let operationError;
+    try {
+        before = await secureCredentialFileHandle(handle, file);
+        identity = fileIdentity(before);
+        assertCredentialSize(before.size);
+        bytes = await readBoundedCredential(handle);
+        const after = await secureCredentialFileHandle(handle, file, identity);
+        assertCredentialReadStable(before, after, bytes.byteLength);
+    }
+    catch (error) {
+        operationError = error;
+    }
+    let verificationError;
+    if (identity) {
+        try {
+            await secureCredentialFileHandle(handle, file, identity);
+        }
+        catch (error) {
+            verificationError = error;
+        }
+    }
+    try {
+        await handle.close();
+    }
+    catch (error) {
+        verificationError ??= error;
+    }
+    if (identity) {
+        try {
+            await assertSecureCredentialPath(file, identity);
+        }
+        catch (error) {
+            verificationError ??= error;
+        }
+    }
+    if (verificationError !== undefined)
+        throw verificationError;
+    if (operationError !== undefined)
+        throw operationError;
+    return bytes;
+}
+async function secureCredentialFileHandle(handle, file, expected) {
+    let stats = await handle.stat({ bigint: true });
+    assertCredentialFileMetadata(stats);
+    if (expected)
+        assertSameFile(expected, stats, "credential file changed during access");
+    stats = await tightenHandlePermissions(handle, stats, CREDENTIAL_FILE_MODE, "credential file");
+    assertCredentialFileMetadata(stats);
+    if (expected)
+        assertSameFile(expected, stats, "credential file changed during access");
+    await assertSecurePath(file, stats, "file", CREDENTIAL_FILE_MODE);
+    return stats;
+}
+async function tightenHandlePermissions(handle, stats, expectedMode, label) {
+    if (!CHECK_POSIX_SECURITY || permissionMode(stats) === expectedMode)
+        return stats;
+    try {
+        await handle.chmod(expectedMode);
+    }
+    catch (error) {
+        throw new Error(`failed to secure ${label} permissions: ${messageOf(error)}`);
+    }
+    const tightened = await handle.stat({ bigint: true });
+    if (permissionMode(tightened) !== expectedMode) {
+        throw new Error(`failed to secure ${label} permissions`);
+    }
+    return tightened;
+}
+async function assertCredentialPathBeforeOpen(file) {
+    const stats = await lstat(file, { bigint: true });
+    assertCredentialFileMetadata(stats);
+}
+async function assertSecureCredentialPath(file, expected) {
+    const stats = await lstat(file, { bigint: true });
+    assertCredentialFileMetadata(stats);
+    assertMode(stats, CREDENTIAL_FILE_MODE, "credential file");
+    assertSameFile(expected, stats, "credential file changed during access");
+}
+async function assertSecurePath(path, opened, kind, expectedMode) {
+    const current = await lstat(path, { bigint: true });
+    if (kind === "directory")
+        assertDirectoryMetadata(current);
+    else
+        assertCredentialFileMetadata(current);
+    assertMode(current, expectedMode, `credential ${kind}`);
+    assertSameFile(fileIdentity(opened), current, `credential ${kind} changed during access`);
+}
+async function readBoundedCredential(handle) {
+    const buffer = Buffer.allocUnsafe(MAX_CREDENTIAL_BYTES + 1);
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+        if (bytesRead === 0)
+            break;
+        offset += bytesRead;
+    }
+    if (offset === 0 || offset > MAX_CREDENTIAL_BYTES) {
+        throw new Error(`credential exceeds ${MAX_CREDENTIAL_BYTES} bytes`);
+    }
+    return buffer.subarray(0, offset);
+}
+function assertCredentialReadStable(before, after, bytesRead) {
+    if (before.size !== after.size ||
+        before.mtimeNs !== after.mtimeNs ||
+        before.ctimeNs !== after.ctimeNs ||
+        after.size !== BigInt(bytesRead)) {
+        throw new Error("credential file changed while reading");
+    }
+}
+function assertCredentialSize(size) {
+    if (size === 0n || size > BigInt(MAX_CREDENTIAL_BYTES)) {
+        throw new Error(`credential exceeds ${MAX_CREDENTIAL_BYTES} bytes`);
+    }
+}
+function assertDirectoryMetadata(stats) {
+    if (stats.isSymbolicLink() || !stats.isDirectory()) {
+        throw new Error("credential directory must be a non-symlink directory");
+    }
+    assertCurrentUserOwner(stats, "credential directory");
+}
+function assertCredentialFileMetadata(stats) {
+    if (stats.isSymbolicLink() || !stats.isFile()) {
+        throw new Error("credential file must be a non-symlink regular file");
+    }
+    assertCurrentUserOwner(stats, "credential file");
+}
+function assertCurrentUserOwner(stats, label) {
+    if (typeof process.getuid !== "function")
+        return;
+    if (stats.uid !== BigInt(process.getuid())) {
+        throw new Error(`${label} is not owned by the current user`);
+    }
+}
+function assertMode(stats, expected, label) {
+    if (!CHECK_POSIX_SECURITY)
+        return;
+    if (permissionMode(stats) !== expected) {
+        throw new Error(`${label} permissions are unsafe`);
+    }
+}
+function permissionMode(stats) {
+    return Number(stats.mode & 511n);
+}
+function fileIdentity(stats) {
+    return { dev: stats.dev, ino: stats.ino };
+}
+function assertSameFile(expected, actual, message) {
+    if (actual.dev !== expected.dev || actual.ino !== expected.ino)
+        throw new Error(message);
+}
+function validateCredentialRef(value) {
+    if (typeof value !== "string" || !CREDENTIAL_REF_PATTERN.test(value)) {
+        throw new Error("invalid Remote Runtime credential reference");
+    }
+    return value;
+}
+function validateCredential(value) {
+    if (!isRecord(value) || value.version !== CREDENTIAL_VERSION) {
+        throw new Error("unsupported credential version");
+    }
+    const daemonId = opaqueId(value.daemonId, "daemonId");
+    const clientId = opaqueId(value.clientId, "clientId");
+    const grantId = opaqueId(value.grantId, "grantId");
+    const identityPublicKey = ed25519PublicKey(value.identityPublicKey, "identityPublicKey");
+    const serverEncryptionPublicKey = x25519PublicKey(value.serverEncryptionPublicKey, "serverEncryptionPublicKey");
+    const clientPublicKey = ed25519PublicKey(value.clientPublicKey, "clientPublicKey");
+    const clientPrivateKeyPem = validClientKeyPair(value.clientPrivateKeyPem, clientPublicKey);
+    return {
+        version: 2,
+        daemonId,
+        identityPublicKey,
+        serverEncryptionPublicKey,
+        clientId,
+        grantId,
+        clientPublicKey,
+        clientPrivateKeyPem,
+    };
+}
+function validatePendingCredential(value) {
+    if (!isRecord(value) ||
+        value.version !== CREDENTIAL_VERSION ||
+        value.state !== "pending_enrollment") {
+        throw new Error("unsupported pending credential version");
+    }
+    const daemonId = opaqueId(value.daemonId, "daemonId");
+    const identityPublicKey = ed25519PublicKey(value.identityPublicKey, "identityPublicKey");
+    const serverEncryptionPublicKey = x25519PublicKey(value.serverEncryptionPublicKey, "serverEncryptionPublicKey");
+    const claimId = opaqueId(value.claimId, "claimId");
+    const clientId = opaqueId(value.clientId, "clientId");
+    const clientPublicKey = ed25519PublicKey(value.clientPublicKey, "clientPublicKey");
+    const clientPrivateKeyPem = validClientKeyPair(value.clientPrivateKeyPem, clientPublicKey);
+    return {
+        version: 2,
+        state: "pending_enrollment",
+        daemonId,
+        identityPublicKey,
+        serverEncryptionPublicKey,
+        claimId,
+        clientId,
+        clientPublicKey,
+        clientPrivateKeyPem,
+    };
+}
+function validClientKeyPair(value, clientPublicKey) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_PRIVATE_KEY_CHARS) {
+        throw new Error("clientPrivateKeyPem is invalid");
+    }
+    try {
+        const privateKey = createPrivateKey(value);
+        if (privateKey.asymmetricKeyType !== "ed25519") {
+            throw new Error("client private key must use Ed25519");
+        }
+        const publicKey = createPublicKey({
+            key: Buffer.from(clientPublicKey, "base64url"),
+            format: "der",
+            type: "spki",
+        });
+        const probe = Buffer.from("rynx-remote-runtime-credential-validation-v1", "utf8");
+        const signature = sign(null, probe, privateKey);
+        if (!verify(null, probe, publicKey, signature)) {
+            throw new Error("client public and private keys do not match");
+        }
+    }
+    catch (error) {
+        throw new Error(`client key pair is invalid: ${messageOf(error)}`);
+    }
+    return value;
+}
+function assertPendingMatchesAccepted(pending, claimId, accepted) {
+    if (pending.claimId !== claimId ||
+        pending.daemonId !== accepted.daemonId ||
+        pending.identityPublicKey !== accepted.identityPublicKey ||
+        pending.serverEncryptionPublicKey !== accepted.serverEncryptionPublicKey ||
+        pending.clientId !== accepted.clientId ||
+        pending.clientPublicKey !== accepted.clientPublicKey ||
+        pending.clientPrivateKeyPem !== accepted.clientPrivateKeyPem) {
+        throw new Error("pending Runtime credential differs from the accepted enrollment");
+    }
+}
+function sameAcceptedCredential(left, right) {
+    return (left.version === right.version &&
+        left.daemonId === right.daemonId &&
+        left.identityPublicKey === right.identityPublicKey &&
+        left.serverEncryptionPublicKey === right.serverEncryptionPublicKey &&
+        left.clientId === right.clientId &&
+        left.grantId === right.grantId &&
+        left.clientPublicKey === right.clientPublicKey &&
+        left.clientPrivateKeyPem === right.clientPrivateKeyPem);
+}
+function encodeCredential(credential) {
+    const encoded = Buffer.from(`${JSON.stringify(credential, null, 2)}\n`, "utf8");
+    if (encoded.byteLength > MAX_CREDENTIAL_BYTES) {
+        throw new Error(`credential exceeds ${MAX_CREDENTIAL_BYTES} bytes`);
+    }
+    return encoded;
+}
+function parseCredentialJson(ref, raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`invalid Remote Runtime credential ${ref}: ${messageOf(error)}`);
+    }
+}
+function ed25519PublicKey(value, field) {
+    if (typeof value !== "string" || !/^[A-Za-z0-9_-]{59}$/.test(value)) {
+        throw new Error(`${field} is invalid`);
+    }
+    try {
+        const bytes = Buffer.from(value, "base64url");
+        if (bytes.byteLength !== 44 || bytes.toString("base64url") !== value) {
+            throw new Error("non-canonical key");
+        }
+        const key = createPublicKey({ key: bytes, format: "der", type: "spki" });
+        if (key.asymmetricKeyType !== "ed25519")
+            throw new Error("not Ed25519");
+        return key.export({ format: "der", type: "spki" }).toString("base64url");
+    }
+    catch (error) {
+        throw new Error(`${field} is invalid: ${messageOf(error)}`);
+    }
+}
+function x25519PublicKey(value, field) {
+    if (typeof value !== "string" || !/^[A-Za-z0-9_-]{59}$/.test(value)) {
+        throw new Error(`${field} is invalid`);
+    }
+    try {
+        const bytes = Buffer.from(value, "base64url");
+        if (bytes.byteLength !== 44 || bytes.toString("base64url") !== value) {
+            throw new Error("non-canonical key");
+        }
+        const key = createPublicKey({ key: bytes, format: "der", type: "spki" });
+        if (key.asymmetricKeyType !== "x25519")
+            throw new Error("not X25519");
+        return key.export({ format: "der", type: "spki" }).toString("base64url");
+    }
+    catch (error) {
+        throw new Error(`${field} is invalid: ${messageOf(error)}`);
+    }
+}
+function opaqueId(value, field) {
+    if (typeof value !== "string" || !OPAQUE_ID_PATTERN.test(value)) {
+        throw new Error(`${field} is invalid`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasCode(error, code) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    if ("code" in error && error.code === code)
+        return true;
+    return "cause" in error && hasCode(error.cause, code);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}