velocious 1.0.474 → 1.0.475

package/build/src/sync/device-identity.js

@@ -0,0 +1,454 @@
+// @ts-check
+const ECDSA_P256_SHA256_ALGORITHM = "ECDSA-P256-SHA256";
+const ECDSA_P256_SHA256_SIGNATURE_PREFIX = "ecdsa-p256-sha256-";
+/**
+ * JSON Web Key used by the sync signing helpers.
+ * @typedef {JsonWebKey} SyncJsonWebKey
+ */
+/**
+ * Backend-signed device certificate payload.
+ * @typedef {object} DeviceCertificatePayload
+ * @property {string} actorDeviceId - Device id allowed to sign mutations.
+ * @property {string} actorUserId - User id represented by the device.
+ * @property {string} certificateId - Certificate id.
+ * @property {SyncJsonWebKey} devicePublicKey - Device public key peers/backends use to verify mutations.
+ * @property {string} expiresAt - ISO timestamp after which the certificate is invalid.
+ * @property {string} issuedAt - ISO timestamp when the backend issued the certificate.
+ */
+/**
+ * Backend-signed device certificate envelope.
+ * @typedef {object} DeviceCertificate
+ * @property {"ECDSA-P256-SHA256"} algorithm - Signature algorithm.
+ * @property {DeviceCertificatePayload} certificate - Certificate payload.
+ * @property {string} signature - Backend signature over the certificate payload.
+ */
+/**
+ * Sync mutation payload signed by a device.
+ * @typedef {object} SyncMutation
+ * @property {string} actorDeviceId - Device that signed the mutation.
+ * @property {string} actorUserId - User represented by the signing device.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [attributes] - Model attributes for CRUD mutations.
+ * @property {string | number | null} [baseVersion] - Base server/client version.
+ * @property {string} clientMutationId - Device-local idempotency id.
+ * @property {string} [command] - Domain command name for command mutations.
+ * @property {string} model - Sync model/resource name.
+ * @property {string} occurredAt - ISO timestamp when the mutation occurred.
+ * @property {string} offlineGrantId - Offline grant id authorizing the mutation.
+ * @property {string} operation - CRUD operation or command operation.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [payload] - Domain command payload.
+ * @property {string} policyHash - Sync policy hash the mutation was checked against.
+ */
+/**
+ * Device-signed mutation envelope.
+ * @typedef {object} SignedSyncMutation
+ * @property {"ECDSA-P256-SHA256"} algorithm - Signature algorithm.
+ * @property {DeviceCertificate} deviceCertificate - Backend-signed device certificate.
+ * @property {SyncMutation} mutation - Mutation payload.
+ * @property {string} signature - Device signature over the mutation envelope.
+ */
+/**
+ * Generates an ECDSA P-256 keypair exported as JWKs.
+ * @returns {Promise<{privateKey: SyncJsonWebKey, publicKey: SyncJsonWebKey}>} - Exported keypair.
+ */
+export async function generateSyncSigningKeyPair() {
+    const keyPair = await cryptoSubtle().generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]);
+    return {
+        privateKey: await cryptoSubtle().exportKey("jwk", keyPair.privateKey),
+        publicKey: await cryptoSubtle().exportKey("jwk", keyPair.publicKey)
+    };
+}
+/**
+ * Creates a backend-signed device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPrivateKey - Backend private signing key.
+ * @param {DeviceCertificatePayload} args.certificate - Certificate payload.
+ * @returns {Promise<DeviceCertificate>} - Signed certificate.
+ */
+export async function createDeviceCertificate({ backendPrivateKey, certificate }) {
+    const normalizedCertificate = normalizeDeviceCertificatePayload(certificate);
+    return {
+        algorithm: ECDSA_P256_SHA256_ALGORITHM,
+        certificate: normalizedCertificate,
+        signature: await signStableJson({
+            privateKey: backendPrivateKey,
+            value: deviceCertificateSignatureValue(normalizedCertificate)
+        })
+    };
+}
+/**
+ * Verifies a backend-signed device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key.
+ * @param {DeviceCertificate} args.certificate - Signed certificate.
+ * @param {Date} [args.now] - Verification time. Defaults to current time.
+ * @returns {Promise<DeviceCertificatePayload>} - Verified certificate payload.
+ */
+export async function verifyDeviceCertificate({ backendPublicKey, certificate, now = new Date() }) {
+    const normalizedCertificate = normalizeDeviceCertificate(certificate);
+    const verified = await verifyStableJsonSignature({
+        publicKey: backendPublicKey,
+        signature: normalizedCertificate.signature,
+        value: deviceCertificateSignatureValue(normalizedCertificate.certificate)
+    });
+    if (!verified)
+        throw new Error("Device certificate signature did not match");
+    assertNotExpired({ expiresAt: normalizedCertificate.certificate.expiresAt, label: "Device certificate", now });
+    return normalizedCertificate.certificate;
+}
+/**
+ * Creates a device-signed mutation envelope.
+ * @param {object} args - Arguments.
+ * @param {DeviceCertificate} args.deviceCertificate - Backend-signed device certificate.
+ * @param {SyncJsonWebKey} args.devicePrivateKey - Device private signing key.
+ * @param {SyncMutation} args.mutation - Mutation payload.
+ * @returns {Promise<SignedSyncMutation>} - Signed mutation.
+ */
+export async function createSignedMutation({ deviceCertificate, devicePrivateKey, mutation }) {
+    const normalizedDeviceCertificate = normalizeDeviceCertificate(deviceCertificate);
+    const normalizedMutation = normalizeSyncMutation(mutation);
+    assertMutationMatchesCertificate({ certificate: normalizedDeviceCertificate.certificate, mutation: normalizedMutation });
+    return {
+        algorithm: ECDSA_P256_SHA256_ALGORITHM,
+        deviceCertificate: normalizedDeviceCertificate,
+        mutation: normalizedMutation,
+        signature: await signStableJson({
+            privateKey: devicePrivateKey,
+            value: signedMutationSignatureValue({
+                deviceCertificate: normalizedDeviceCertificate,
+                mutation: normalizedMutation
+            })
+        })
+    };
+}
+/**
+ * Verifies a signed sync mutation and its device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify the device certificate.
+ * @param {Date} [args.now] - Verification time. Defaults to current time.
+ * @param {SignedSyncMutation} args.signedMutation - Signed mutation envelope.
+ * @returns {Promise<SyncMutation>} - Verified mutation payload.
+ */
+export async function verifySignedMutation({ backendPublicKey, now = new Date(), signedMutation }) {
+    const normalizedSignedMutation = normalizeSignedSyncMutation(signedMutation);
+    const certificatePayload = await verifyDeviceCertificate({
+        backendPublicKey,
+        certificate: normalizedSignedMutation.deviceCertificate,
+        now
+    });
+    assertMutationMatchesCertificate({ certificate: certificatePayload, mutation: normalizedSignedMutation.mutation });
+    const verified = await verifyStableJsonSignature({
+        publicKey: certificatePayload.devicePublicKey,
+        signature: normalizedSignedMutation.signature,
+        value: signedMutationSignatureValue({
+            deviceCertificate: normalizedSignedMutation.deviceCertificate,
+            mutation: normalizedSignedMutation.mutation
+        })
+    });
+    if (!verified)
+        throw new Error("Sync mutation signature did not match");
+    return normalizedSignedMutation.mutation;
+}
+/**
+ * Returns the replay/idempotency key for a signed mutation.
+ * @param {{mutation: {actorDeviceId?: unknown, actorUserId?: unknown, clientMutationId?: unknown}}} signedMutation - Signed mutation-like object.
+ * @returns {string} - Idempotency key.
+ */
+export function mutationIdempotencyKey(signedMutation) {
+    const mutation = signedMutation.mutation;
+    return [
+        requiredString(mutation.actorUserId, "actorUserId"),
+        requiredString(mutation.actorDeviceId, "actorDeviceId"),
+        requiredString(mutation.clientMutationId, "clientMutationId")
+    ].join(":");
+}
+/**
+ * Builds the stable value signed by backend device certificates.
+ * @param {DeviceCertificatePayload} certificate - Certificate payload.
+ * @returns {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} - Stable signature value.
+ */
+function deviceCertificateSignatureValue(certificate) {
+    return {
+        algorithm: ECDSA_P256_SHA256_ALGORITHM,
+        certificate: /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({ label: "certificate", value: certificate }))
+    };
+}
+/**
+ * Builds the stable value signed by sync mutations.
+ * @param {object} args - Arguments.
+ * @param {DeviceCertificate} args.deviceCertificate - Device certificate.
+ * @param {SyncMutation} args.mutation - Mutation payload.
+ * @returns {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} - Stable signature value.
+ */
+function signedMutationSignatureValue({ deviceCertificate, mutation }) {
+    return {
+        algorithm: ECDSA_P256_SHA256_ALGORITHM,
+        deviceCertificate: /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({ label: "deviceCertificate", value: deviceCertificate })),
+        mutation: /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({ label: "mutation", value: mutation }))
+    };
+}
+/**
+ * Signs a deterministic JSON value with ECDSA P-256/SHA-256.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.privateKey - Private JWK.
+ * @param {unknown} args.value - Value to sign.
+ * @returns {Promise<string>} - Prefixed base64url signature.
+ */
+async function signStableJson({ privateKey, value }) {
+    const key = await cryptoSubtle().importKey("jwk", privateKey, { name: "ECDSA", namedCurve: "P-256" }, false, ["sign"]);
+    const signature = await cryptoSubtle().sign({ hash: "SHA-256", name: "ECDSA" }, key, /** @type {BufferSource} */ (utf8(stableJsonStringify(value))));
+    return `${ECDSA_P256_SHA256_SIGNATURE_PREFIX}${base64UrlEncode(new Uint8Array(signature))}`;
+}
+/**
+ * Verifies a deterministic JSON value with ECDSA P-256/SHA-256.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.publicKey - Public JWK.
+ * @param {string} args.signature - Prefixed base64url signature.
+ * @param {unknown} args.value - Value to verify.
+ * @returns {Promise<boolean>} - Whether the signature matches.
+ */
+async function verifyStableJsonSignature({ publicKey, signature, value }) {
+    const key = await cryptoSubtle().importKey("jwk", publicKey, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    const signatureBytes = base64UrlDecode(signatureWithoutPrefix(signature));
+    return await cryptoSubtle().verify({ hash: "SHA-256", name: "ECDSA" }, key, /** @type {BufferSource} */ (signatureBytes), /** @type {BufferSource} */ (utf8(stableJsonStringify(value))));
+}
+/**
+ * Normalizes a signed device certificate envelope.
+ * @param {DeviceCertificate} certificate - Signed certificate.
+ * @returns {DeviceCertificate} - Normalized certificate.
+ */
+function normalizeDeviceCertificate(certificate) {
+    if (!certificate || typeof certificate !== "object" || Array.isArray(certificate))
+        throw new Error("Expected device certificate object");
+    if (certificate.algorithm !== ECDSA_P256_SHA256_ALGORITHM)
+        throw new Error(`Unsupported device certificate algorithm '${String(certificate.algorithm)}'`);
+    return {
+        algorithm: certificate.algorithm,
+        certificate: normalizeDeviceCertificatePayload(certificate.certificate),
+        signature: normalizeSignature(certificate.signature, "device certificate signature")
+    };
+}
+/**
+ * Normalizes a device certificate payload.
+ * @param {DeviceCertificatePayload} certificate - Certificate payload.
+ * @returns {DeviceCertificatePayload} - Normalized certificate payload.
+ */
+function normalizeDeviceCertificatePayload(certificate) {
+    if (!certificate || typeof certificate !== "object" || Array.isArray(certificate))
+        throw new Error("Expected device certificate payload object");
+    return {
+        actorDeviceId: requiredString(certificate.actorDeviceId, "actorDeviceId"),
+        actorUserId: requiredString(certificate.actorUserId, "actorUserId"),
+        certificateId: requiredString(certificate.certificateId, "certificateId"),
+        devicePublicKey: normalizeJwk(certificate.devicePublicKey, "devicePublicKey"),
+        expiresAt: isoDateString(new Date(requiredString(certificate.expiresAt, "expiresAt")), "expiresAt"),
+        issuedAt: isoDateString(new Date(requiredString(certificate.issuedAt, "issuedAt")), "issuedAt")
+    };
+}
+/**
+ * Normalizes a signed sync mutation envelope.
+ * @param {SignedSyncMutation} signedMutation - Signed mutation.
+ * @returns {SignedSyncMutation} - Normalized signed mutation.
+ */
+function normalizeSignedSyncMutation(signedMutation) {
+    if (!signedMutation || typeof signedMutation !== "object" || Array.isArray(signedMutation))
+        throw new Error("Expected signed sync mutation object");
+    if (signedMutation.algorithm !== ECDSA_P256_SHA256_ALGORITHM)
+        throw new Error(`Unsupported sync mutation algorithm '${String(signedMutation.algorithm)}'`);
+    return {
+        algorithm: signedMutation.algorithm,
+        deviceCertificate: normalizeDeviceCertificate(signedMutation.deviceCertificate),
+        mutation: normalizeSyncMutation(signedMutation.mutation),
+        signature: normalizeSignature(signedMutation.signature, "sync mutation signature")
+    };
+}
+/**
+ * Normalizes a sync mutation payload.
+ * @param {SyncMutation} mutation - Mutation payload.
+ * @returns {SyncMutation} - Normalized mutation payload.
+ */
+function normalizeSyncMutation(mutation) {
+    if (!mutation || typeof mutation !== "object" || Array.isArray(mutation))
+        throw new Error("Expected sync mutation object");
+    /** @type {SyncMutation} */
+    const normalized = {
+        actorDeviceId: requiredString(mutation.actorDeviceId, "actorDeviceId"),
+        actorUserId: requiredString(mutation.actorUserId, "actorUserId"),
+        clientMutationId: requiredString(mutation.clientMutationId, "clientMutationId"),
+        model: requiredString(mutation.model, "model"),
+        occurredAt: isoDateString(new Date(requiredString(mutation.occurredAt, "occurredAt")), "occurredAt"),
+        offlineGrantId: requiredString(mutation.offlineGrantId, "offlineGrantId"),
+        operation: requiredString(mutation.operation, "operation"),
+        policyHash: requiredString(mutation.policyHash, "policyHash")
+    };
+    if (mutation.attributes !== undefined)
+        normalized.attributes = deterministicJsonObject({ label: "attributes", value: mutation.attributes });
+    if (mutation.baseVersion !== undefined)
+        normalized.baseVersion = /** @type {string | number | null} */ (deterministicJson({ label: "baseVersion", value: mutation.baseVersion }));
+    if (mutation.command !== undefined)
+        normalized.command = requiredString(mutation.command, "command");
+    if (mutation.payload !== undefined)
+        normalized.payload = deterministicJsonObject({ label: "payload", value: mutation.payload });
+    return normalized;
+}
+/**
+ * Asserts that mutation actor fields match the certificate actor.
+ * @param {object} args - Arguments.
+ * @param {DeviceCertificatePayload} args.certificate - Device certificate payload.
+ * @param {SyncMutation} args.mutation - Mutation payload.
+ * @returns {void} - No return value.
+ */
+function assertMutationMatchesCertificate({ certificate, mutation }) {
+    if (mutation.actorDeviceId !== certificate.actorDeviceId || mutation.actorUserId !== certificate.actorUserId) {
+        throw new Error("Sync mutation actor does not match device certificate");
+    }
+}
+/**
+ * Asserts a timestamp is not expired.
+ * @param {object} args - Arguments.
+ * @param {string} args.expiresAt - Expiry timestamp.
+ * @param {string} args.label - Error label.
+ * @param {Date} args.now - Verification time.
+ * @returns {void} - No return value.
+ */
+function assertNotExpired({ expiresAt, label, now }) {
+    if (Number.isNaN(now.getTime()))
+        throw new Error("Invalid sync verification time");
+    if (new Date(expiresAt).getTime() <= now.getTime())
+        throw new Error(`${label} expired`);
+}
+/**
+ * Normalizes a JSON Web Key object.
+ * @param {SyncJsonWebKey} key - JWK.
+ * @param {string} label - Key label.
+ * @returns {SyncJsonWebKey} - Normalized JWK.
+ */
+function normalizeJwk(key, label) {
+    const normalized = deterministicJsonObject({ label, value: key });
+    return /** @type {SyncJsonWebKey} */ (normalized);
+}
+/**
+ * Normalizes a prefixed signature string.
+ * @param {unknown} signature - Signature value.
+ * @param {string} label - Error label.
+ * @returns {string} - Signature string.
+ */
+function normalizeSignature(signature, label) {
+    if (typeof signature !== "string" || !signature.startsWith(ECDSA_P256_SHA256_SIGNATURE_PREFIX))
+        throw new Error(`Expected ${label}`);
+    return signature;
+}
+/**
+ * Removes the signature prefix.
+ * @param {string} signature - Prefixed signature.
+ * @returns {string} - Base64url signature body.
+ */
+function signatureWithoutPrefix(signature) {
+    return signature.slice(ECDSA_P256_SHA256_SIGNATURE_PREFIX.length);
+}
+/**
+ * Requires a non-empty string field.
+ * @param {unknown} value - Value.
+ * @param {string} name - Field name.
+ * @returns {string} - String value.
+ */
+function requiredString(value, name) {
+    if (typeof value !== "string" || value.length < 1)
+        throw new Error(`Expected sync ${name}`);
+    return value;
+}
+/**
+ * Normalizes a Date to an ISO timestamp.
+ * @param {Date} date - Date value.
+ * @param {string} label - Field label.
+ * @returns {string} - ISO timestamp.
+ */
+function isoDateString(date, label) {
+    if (Number.isNaN(date.getTime()))
+        throw new Error(`Invalid sync ${label}`);
+    return date.toISOString();
+}
+/**
+ * Returns encoded UTF-8 bytes for a string.
+ * @param {string} value - String value.
+ * @returns {Uint8Array} - UTF-8 bytes.
+ */
+function utf8(value) {
+    return new TextEncoder().encode(value);
+}
+/**
+ * Returns WebCrypto subtle API.
+ * @returns {SubtleCrypto} - SubtleCrypto implementation.
+ */
+function cryptoSubtle() {
+    if (!globalThis.crypto?.subtle)
+        throw new Error("WebCrypto subtle API is required for sync signing");
+    return globalThis.crypto.subtle;
+}
+/**
+ * Base64url-encodes bytes.
+ * @param {Uint8Array} bytes - Bytes.
+ * @returns {string} - Base64url string.
+ */
+function base64UrlEncode(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+/**
+ * Base64url-decodes bytes.
+ * @param {string} value - Base64url string.
+ * @returns {Uint8Array} - Bytes.
+ */
+function base64UrlDecode(value) {
+    const base64 = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+    const binary = atob(base64);
+    return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+/**
+ * Stable JSON stringifier with sorted object keys.
+ * @param {unknown} value - Value.
+ * @returns {string} - JSON string.
+ */
+function stableJsonStringify(value) {
+    return JSON.stringify(deterministicJson({ label: "root", value }));
+}
+/**
+ * Normalizes a value as a JSON object.
+ * @param {object} args - Arguments.
+ * @param {string} args.label - Diagnostic label.
+ * @param {unknown} args.value - Value.
+ * @returns {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} - JSON object.
+ */
+function deterministicJsonObject({ label, value }) {
+    const normalized = deterministicJson({ label, value });
+    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized))
+        throw new Error(`Expected sync ${label} object`);
+    return /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */ (normalized);
+}
+/**
+ * Normalizes deterministic JSON with sorted object keys.
+ * @param {object} args - Arguments.
+ * @param {string} args.label - Diagnostic label.
+ * @param {unknown} args.value - Value.
+ * @returns {import("../configuration-types.js").FrontendModelSyncJsonValue} - Normalized JSON value.
+ */
+function deterministicJson({ label, value }) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry, index) => deterministicJson({ label: `${label}/${index}`, value: entry }));
+    if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+        /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */
+        const normalized = {};
+        for (const key of Object.keys(value).sort()) {
+            const childValue = /** @type {Record<string, unknown>} */ (value)[key];
+            if (childValue === undefined)
+                continue;
+            normalized[key] = deterministicJson({ label: `${label}/${key}`, value: childValue });
+        }
+        return normalized;
+    }
+    throw new Error(`Sync ${label} must be deterministic JSON`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-identity.js","sourceRoot":"","sources":["../../../src/sync/device-identity.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst ECDSA_P256_SHA256_ALGORITHM = \"ECDSA-P256-SHA256\"\nconst ECDSA_P256_SHA256_SIGNATURE_PREFIX = \"ecdsa-p256-sha256-\"\n\n/**\n * JSON Web Key used by the sync signing helpers.\n * @typedef {JsonWebKey} SyncJsonWebKey\n */\n\n/**\n * Backend-signed device certificate payload.\n * @typedef {object} DeviceCertificatePayload\n * @property {string} actorDeviceId - Device id allowed to sign mutations.\n * @property {string} actorUserId - User id represented by the device.\n * @property {string} certificateId - Certificate id.\n * @property {SyncJsonWebKey} devicePublicKey - Device public key peers/backends use to verify mutations.\n * @property {string} expiresAt - ISO timestamp after which the certificate is invalid.\n * @property {string} issuedAt - ISO timestamp when the backend issued the certificate.\n */\n\n/**\n * Backend-signed device certificate envelope.\n * @typedef {object} DeviceCertificate\n * @property {\"ECDSA-P256-SHA256\"} algorithm - Signature algorithm.\n * @property {DeviceCertificatePayload} certificate - Certificate payload.\n * @property {string} signature - Backend signature over the certificate payload.\n */\n\n/**\n * Sync mutation payload signed by a device.\n * @typedef {object} SyncMutation\n * @property {string} actorDeviceId - Device that signed the mutation.\n * @property {string} actorUserId - User represented by the signing device.\n * @property {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} [attributes] - Model attributes for CRUD mutations.\n * @property {string | number | null} [baseVersion] - Base server/client version.\n * @property {string} clientMutationId - Device-local idempotency id.\n * @property {string} [command] - Domain command name for command mutations.\n * @property {string} model - Sync model/resource name.\n * @property {string} occurredAt - ISO timestamp when the mutation occurred.\n * @property {string} offlineGrantId - Offline grant id authorizing the mutation.\n * @property {string} operation - CRUD operation or command operation.\n * @property {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} [payload] - Domain command payload.\n * @property {string} policyHash - Sync policy hash the mutation was checked against.\n */\n\n/**\n * Device-signed mutation envelope.\n * @typedef {object} SignedSyncMutation\n * @property {\"ECDSA-P256-SHA256\"} algorithm - Signature algorithm.\n * @property {DeviceCertificate} deviceCertificate - Backend-signed device certificate.\n * @property {SyncMutation} mutation - Mutation payload.\n * @property {string} signature - Device signature over the mutation envelope.\n */\n\n/**\n * Generates an ECDSA P-256 keypair exported as JWKs.\n * @returns {Promise<{privateKey: SyncJsonWebKey, publicKey: SyncJsonWebKey}>} - Exported keypair.\n */\nexport async function generateSyncSigningKeyPair() {\n  const keyPair = await cryptoSubtle().generateKey(\n    {name: \"ECDSA\", namedCurve: \"P-256\"},\n    true,\n    [\"sign\", \"verify\"]\n  )\n\n  return {\n    privateKey: await cryptoSubtle().exportKey(\"jwk\", keyPair.privateKey),\n    publicKey: await cryptoSubtle().exportKey(\"jwk\", keyPair.publicKey)\n  }\n}\n\n/**\n * Creates a backend-signed device certificate.\n * @param {object} args - Arguments.\n * @param {SyncJsonWebKey} args.backendPrivateKey - Backend private signing key.\n * @param {DeviceCertificatePayload} args.certificate - Certificate payload.\n * @returns {Promise<DeviceCertificate>} - Signed certificate.\n */\nexport async function createDeviceCertificate({backendPrivateKey, certificate}) {\n  const normalizedCertificate = normalizeDeviceCertificatePayload(certificate)\n\n  return {\n    algorithm: ECDSA_P256_SHA256_ALGORITHM,\n    certificate: normalizedCertificate,\n    signature: await signStableJson({\n      privateKey: backendPrivateKey,\n      value: deviceCertificateSignatureValue(normalizedCertificate)\n    })\n  }\n}\n\n/**\n * Verifies a backend-signed device certificate.\n * @param {object} args - Arguments.\n * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key.\n * @param {DeviceCertificate} args.certificate - Signed certificate.\n * @param {Date} [args.now] - Verification time. Defaults to current time.\n * @returns {Promise<DeviceCertificatePayload>} - Verified certificate payload.\n */\nexport async function verifyDeviceCertificate({backendPublicKey, certificate, now = new Date()}) {\n  const normalizedCertificate = normalizeDeviceCertificate(certificate)\n  const verified = await verifyStableJsonSignature({\n    publicKey: backendPublicKey,\n    signature: normalizedCertificate.signature,\n    value: deviceCertificateSignatureValue(normalizedCertificate.certificate)\n  })\n\n  if (!verified) throw new Error(\"Device certificate signature did not match\")\n  assertNotExpired({expiresAt: normalizedCertificate.certificate.expiresAt, label: \"Device certificate\", now})\n\n  return normalizedCertificate.certificate\n}\n\n/**\n * Creates a device-signed mutation envelope.\n * @param {object} args - Arguments.\n * @param {DeviceCertificate} args.deviceCertificate - Backend-signed device certificate.\n * @param {SyncJsonWebKey} args.devicePrivateKey - Device private signing key.\n * @param {SyncMutation} args.mutation - Mutation payload.\n * @returns {Promise<SignedSyncMutation>} - Signed mutation.\n */\nexport async function createSignedMutation({deviceCertificate, devicePrivateKey, mutation}) {\n  const normalizedDeviceCertificate = normalizeDeviceCertificate(deviceCertificate)\n  const normalizedMutation = normalizeSyncMutation(mutation)\n\n  assertMutationMatchesCertificate({certificate: normalizedDeviceCertificate.certificate, mutation: normalizedMutation})\n\n  return {\n    algorithm: ECDSA_P256_SHA256_ALGORITHM,\n    deviceCertificate: normalizedDeviceCertificate,\n    mutation: normalizedMutation,\n    signature: await signStableJson({\n      privateKey: devicePrivateKey,\n      value: signedMutationSignatureValue({\n        deviceCertificate: normalizedDeviceCertificate,\n        mutation: normalizedMutation\n      })\n    })\n  }\n}\n\n/**\n * Verifies a signed sync mutation and its device certificate.\n * @param {object} args - Arguments.\n * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify the device certificate.\n * @param {Date} [args.now] - Verification time. Defaults to current time.\n * @param {SignedSyncMutation} args.signedMutation - Signed mutation envelope.\n * @returns {Promise<SyncMutation>} - Verified mutation payload.\n */\nexport async function verifySignedMutation({backendPublicKey, now = new Date(), signedMutation}) {\n  const normalizedSignedMutation = normalizeSignedSyncMutation(signedMutation)\n  const certificatePayload = await verifyDeviceCertificate({\n    backendPublicKey,\n    certificate: normalizedSignedMutation.deviceCertificate,\n    now\n  })\n\n  assertMutationMatchesCertificate({certificate: certificatePayload, mutation: normalizedSignedMutation.mutation})\n\n  const verified = await verifyStableJsonSignature({\n    publicKey: certificatePayload.devicePublicKey,\n    signature: normalizedSignedMutation.signature,\n    value: signedMutationSignatureValue({\n      deviceCertificate: normalizedSignedMutation.deviceCertificate,\n      mutation: normalizedSignedMutation.mutation\n    })\n  })\n\n  if (!verified) throw new Error(\"Sync mutation signature did not match\")\n\n  return normalizedSignedMutation.mutation\n}\n\n/**\n * Returns the replay/idempotency key for a signed mutation.\n * @param {{mutation: {actorDeviceId?: unknown, actorUserId?: unknown, clientMutationId?: unknown}}} signedMutation - Signed mutation-like object.\n * @returns {string} - Idempotency key.\n */\nexport function mutationIdempotencyKey(signedMutation) {\n  const mutation = signedMutation.mutation\n\n  return [\n    requiredString(mutation.actorUserId, \"actorUserId\"),\n    requiredString(mutation.actorDeviceId, \"actorDeviceId\"),\n    requiredString(mutation.clientMutationId, \"clientMutationId\")\n  ].join(\":\")\n}\n\n/**\n * Builds the stable value signed by backend device certificates.\n * @param {DeviceCertificatePayload} certificate - Certificate payload.\n * @returns {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} - Stable signature value.\n */\nfunction deviceCertificateSignatureValue(certificate) {\n  return {\n    algorithm: ECDSA_P256_SHA256_ALGORITHM,\n    certificate: /** @type {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({label: \"certificate\", value: certificate}))\n  }\n}\n\n/**\n * Builds the stable value signed by sync mutations.\n * @param {object} args - Arguments.\n * @param {DeviceCertificate} args.deviceCertificate - Device certificate.\n * @param {SyncMutation} args.mutation - Mutation payload.\n * @returns {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} - Stable signature value.\n */\nfunction signedMutationSignatureValue({deviceCertificate, mutation}) {\n  return {\n    algorithm: ECDSA_P256_SHA256_ALGORITHM,\n    deviceCertificate: /** @type {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({label: \"deviceCertificate\", value: deviceCertificate})),\n    mutation: /** @type {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} */ (deterministicJsonObject({label: \"mutation\", value: mutation}))\n  }\n}\n\n/**\n * Signs a deterministic JSON value with ECDSA P-256/SHA-256.\n * @param {object} args - Arguments.\n * @param {SyncJsonWebKey} args.privateKey - Private JWK.\n * @param {unknown} args.value - Value to sign.\n * @returns {Promise<string>} - Prefixed base64url signature.\n */\nasync function signStableJson({privateKey, value}) {\n  const key = await cryptoSubtle().importKey(\"jwk\", privateKey, {name: \"ECDSA\", namedCurve: \"P-256\"}, false, [\"sign\"])\n  const signature = await cryptoSubtle().sign({hash: \"SHA-256\", name: \"ECDSA\"}, key, /** @type {BufferSource} */ (utf8(stableJsonStringify(value))))\n\n  return `${ECDSA_P256_SHA256_SIGNATURE_PREFIX}${base64UrlEncode(new Uint8Array(signature))}`\n}\n\n/**\n * Verifies a deterministic JSON value with ECDSA P-256/SHA-256.\n * @param {object} args - Arguments.\n * @param {SyncJsonWebKey} args.publicKey - Public JWK.\n * @param {string} args.signature - Prefixed base64url signature.\n * @param {unknown} args.value - Value to verify.\n * @returns {Promise<boolean>} - Whether the signature matches.\n */\nasync function verifyStableJsonSignature({publicKey, signature, value}) {\n  const key = await cryptoSubtle().importKey(\"jwk\", publicKey, {name: \"ECDSA\", namedCurve: \"P-256\"}, false, [\"verify\"])\n  const signatureBytes = base64UrlDecode(signatureWithoutPrefix(signature))\n\n  return await cryptoSubtle().verify({hash: \"SHA-256\", name: \"ECDSA\"}, key, /** @type {BufferSource} */ (signatureBytes), /** @type {BufferSource} */ (utf8(stableJsonStringify(value))))\n}\n\n/**\n * Normalizes a signed device certificate envelope.\n * @param {DeviceCertificate} certificate - Signed certificate.\n * @returns {DeviceCertificate} - Normalized certificate.\n */\nfunction normalizeDeviceCertificate(certificate) {\n  if (!certificate || typeof certificate !== \"object\" || Array.isArray(certificate)) throw new Error(\"Expected device certificate object\")\n  if (certificate.algorithm !== ECDSA_P256_SHA256_ALGORITHM) throw new Error(`Unsupported device certificate algorithm '${String(certificate.algorithm)}'`)\n\n  return {\n    algorithm: certificate.algorithm,\n    certificate: normalizeDeviceCertificatePayload(certificate.certificate),\n    signature: normalizeSignature(certificate.signature, \"device certificate signature\")\n  }\n}\n\n/**\n * Normalizes a device certificate payload.\n * @param {DeviceCertificatePayload} certificate - Certificate payload.\n * @returns {DeviceCertificatePayload} - Normalized certificate payload.\n */\nfunction normalizeDeviceCertificatePayload(certificate) {\n  if (!certificate || typeof certificate !== \"object\" || Array.isArray(certificate)) throw new Error(\"Expected device certificate payload object\")\n\n  return {\n    actorDeviceId: requiredString(certificate.actorDeviceId, \"actorDeviceId\"),\n    actorUserId: requiredString(certificate.actorUserId, \"actorUserId\"),\n    certificateId: requiredString(certificate.certificateId, \"certificateId\"),\n    devicePublicKey: normalizeJwk(certificate.devicePublicKey, \"devicePublicKey\"),\n    expiresAt: isoDateString(new Date(requiredString(certificate.expiresAt, \"expiresAt\")), \"expiresAt\"),\n    issuedAt: isoDateString(new Date(requiredString(certificate.issuedAt, \"issuedAt\")), \"issuedAt\")\n  }\n}\n\n/**\n * Normalizes a signed sync mutation envelope.\n * @param {SignedSyncMutation} signedMutation - Signed mutation.\n * @returns {SignedSyncMutation} - Normalized signed mutation.\n */\nfunction normalizeSignedSyncMutation(signedMutation) {\n  if (!signedMutation || typeof signedMutation !== \"object\" || Array.isArray(signedMutation)) throw new Error(\"Expected signed sync mutation object\")\n  if (signedMutation.algorithm !== ECDSA_P256_SHA256_ALGORITHM) throw new Error(`Unsupported sync mutation algorithm '${String(signedMutation.algorithm)}'`)\n\n  return {\n    algorithm: signedMutation.algorithm,\n    deviceCertificate: normalizeDeviceCertificate(signedMutation.deviceCertificate),\n    mutation: normalizeSyncMutation(signedMutation.mutation),\n    signature: normalizeSignature(signedMutation.signature, \"sync mutation signature\")\n  }\n}\n\n/**\n * Normalizes a sync mutation payload.\n * @param {SyncMutation} mutation - Mutation payload.\n * @returns {SyncMutation} - Normalized mutation payload.\n */\nfunction normalizeSyncMutation(mutation) {\n  if (!mutation || typeof mutation !== \"object\" || Array.isArray(mutation)) throw new Error(\"Expected sync mutation object\")\n\n  /** @type {SyncMutation} */\n  const normalized = {\n    actorDeviceId: requiredString(mutation.actorDeviceId, \"actorDeviceId\"),\n    actorUserId: requiredString(mutation.actorUserId, \"actorUserId\"),\n    clientMutationId: requiredString(mutation.clientMutationId, \"clientMutationId\"),\n    model: requiredString(mutation.model, \"model\"),\n    occurredAt: isoDateString(new Date(requiredString(mutation.occurredAt, \"occurredAt\")), \"occurredAt\"),\n    offlineGrantId: requiredString(mutation.offlineGrantId, \"offlineGrantId\"),\n    operation: requiredString(mutation.operation, \"operation\"),\n    policyHash: requiredString(mutation.policyHash, \"policyHash\")\n  }\n\n  if (mutation.attributes !== undefined) normalized.attributes = deterministicJsonObject({label: \"attributes\", value: mutation.attributes})\n  if (mutation.baseVersion !== undefined) normalized.baseVersion = /** @type {string | number | null} */ (deterministicJson({label: \"baseVersion\", value: mutation.baseVersion}))\n  if (mutation.command !== undefined) normalized.command = requiredString(mutation.command, \"command\")\n  if (mutation.payload !== undefined) normalized.payload = deterministicJsonObject({label: \"payload\", value: mutation.payload})\n\n  return normalized\n}\n\n/**\n * Asserts that mutation actor fields match the certificate actor.\n * @param {object} args - Arguments.\n * @param {DeviceCertificatePayload} args.certificate - Device certificate payload.\n * @param {SyncMutation} args.mutation - Mutation payload.\n * @returns {void} - No return value.\n */\nfunction assertMutationMatchesCertificate({certificate, mutation}) {\n  if (mutation.actorDeviceId !== certificate.actorDeviceId || mutation.actorUserId !== certificate.actorUserId) {\n    throw new Error(\"Sync mutation actor does not match device certificate\")\n  }\n}\n\n/**\n * Asserts a timestamp is not expired.\n * @param {object} args - Arguments.\n * @param {string} args.expiresAt - Expiry timestamp.\n * @param {string} args.label - Error label.\n * @param {Date} args.now - Verification time.\n * @returns {void} - No return value.\n */\nfunction assertNotExpired({expiresAt, label, now}) {\n  if (Number.isNaN(now.getTime())) throw new Error(\"Invalid sync verification time\")\n  if (new Date(expiresAt).getTime() <= now.getTime()) throw new Error(`${label} expired`)\n}\n\n/**\n * Normalizes a JSON Web Key object.\n * @param {SyncJsonWebKey} key - JWK.\n * @param {string} label - Key label.\n * @returns {SyncJsonWebKey} - Normalized JWK.\n */\nfunction normalizeJwk(key, label) {\n  const normalized = deterministicJsonObject({label, value: key})\n\n  return /** @type {SyncJsonWebKey} */ (normalized)\n}\n\n/**\n * Normalizes a prefixed signature string.\n * @param {unknown} signature - Signature value.\n * @param {string} label - Error label.\n * @returns {string} - Signature string.\n */\nfunction normalizeSignature(signature, label) {\n  if (typeof signature !== \"string\" || !signature.startsWith(ECDSA_P256_SHA256_SIGNATURE_PREFIX)) throw new Error(`Expected ${label}`)\n\n  return signature\n}\n\n/**\n * Removes the signature prefix.\n * @param {string} signature - Prefixed signature.\n * @returns {string} - Base64url signature body.\n */\nfunction signatureWithoutPrefix(signature) {\n  return signature.slice(ECDSA_P256_SHA256_SIGNATURE_PREFIX.length)\n}\n\n/**\n * Requires a non-empty string field.\n * @param {unknown} value - Value.\n * @param {string} name - Field name.\n * @returns {string} - String value.\n */\nfunction requiredString(value, name) {\n  if (typeof value !== \"string\" || value.length < 1) throw new Error(`Expected sync ${name}`)\n\n  return value\n}\n\n/**\n * Normalizes a Date to an ISO timestamp.\n * @param {Date} date - Date value.\n * @param {string} label - Field label.\n * @returns {string} - ISO timestamp.\n */\nfunction isoDateString(date, label) {\n  if (Number.isNaN(date.getTime())) throw new Error(`Invalid sync ${label}`)\n\n  return date.toISOString()\n}\n\n/**\n * Returns encoded UTF-8 bytes for a string.\n * @param {string} value - String value.\n * @returns {Uint8Array} - UTF-8 bytes.\n */\nfunction utf8(value) {\n  return new TextEncoder().encode(value)\n}\n\n/**\n * Returns WebCrypto subtle API.\n * @returns {SubtleCrypto} - SubtleCrypto implementation.\n */\nfunction cryptoSubtle() {\n  if (!globalThis.crypto?.subtle) throw new Error(\"WebCrypto subtle API is required for sync signing\")\n\n  return globalThis.crypto.subtle\n}\n\n/**\n * Base64url-encodes bytes.\n * @param {Uint8Array} bytes - Bytes.\n * @returns {string} - Base64url string.\n */\nfunction base64UrlEncode(bytes) {\n  let binary = \"\"\n\n  for (const byte of bytes) binary += String.fromCharCode(byte)\n\n  return btoa(binary).replaceAll(\"+\", \"-\").replaceAll(\"/\", \"_\").replaceAll(\"=\", \"\")\n}\n\n/**\n * Base64url-decodes bytes.\n * @param {string} value - Base64url string.\n * @returns {Uint8Array} - Bytes.\n */\nfunction base64UrlDecode(value) {\n  const base64 = value.replaceAll(\"-\", \"+\").replaceAll(\"_\", \"/\").padEnd(Math.ceil(value.length / 4) * 4, \"=\")\n  const binary = atob(base64)\n\n  return Uint8Array.from(binary, (char) => char.charCodeAt(0))\n}\n\n/**\n * Stable JSON stringifier with sorted object keys.\n * @param {unknown} value - Value.\n * @returns {string} - JSON string.\n */\nfunction stableJsonStringify(value) {\n  return JSON.stringify(deterministicJson({label: \"root\", value}))\n}\n\n/**\n * Normalizes a value as a JSON object.\n * @param {object} args - Arguments.\n * @param {string} args.label - Diagnostic label.\n * @param {unknown} args.value - Value.\n * @returns {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} - JSON object.\n */\nfunction deterministicJsonObject({label, value}) {\n  const normalized = deterministicJson({label, value})\n\n  if (!normalized || typeof normalized !== \"object\" || Array.isArray(normalized)) throw new Error(`Expected sync ${label} object`)\n\n  return /** @type {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} */ (normalized)\n}\n\n/**\n * Normalizes deterministic JSON with sorted object keys.\n * @param {object} args - Arguments.\n * @param {string} args.label - Diagnostic label.\n * @param {unknown} args.value - Value.\n * @returns {import(\"../configuration-types.js\").FrontendModelSyncJsonValue} - Normalized JSON value.\n */\nfunction deterministicJson({label, value}) {\n  if (value === null || typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") return value\n\n  if (Array.isArray(value)) return value.map((entry, index) => deterministicJson({label: `${label}/${index}`, value: entry}))\n\n  if (value && typeof value === \"object\" && Object.getPrototypeOf(value) === Object.prototype) {\n    /** @type {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} */\n    const normalized = {}\n\n    for (const key of Object.keys(value).sort()) {\n      const childValue = /** @type {Record<string, unknown>} */ (value)[key]\n\n      if (childValue === undefined) continue\n      normalized[key] = deterministicJson({label: `${label}/${key}`, value: childValue})\n    }\n\n    return normalized\n  }\n\n  throw new Error(`Sync ${label} must be deterministic JSON`)\n}\n"]}