velocious 1.0.473 → 1.0.475

package/build/src/sync/offline-grant.js

@@ -0,0 +1,292 @@
+// @ts-check
+const OFFLINE_GRANT_SIGNATURE_ALGORITHM = "HS256";
+const OFFLINE_GRANT_SIGNATURE_PREFIX = "hmac-sha256-";
+/**
+ * Signed offline grant envelope.
+ * @typedef {object} SignedOfflineGrant
+ * @property {"HS256"} algorithm - Signature algorithm.
+ * @property {OfflineGrant} grant - Signed grant payload.
+ * @property {string} keyId - Signing key id.
+ * @property {string} signature - Hex HMAC signature with a hmac-sha256 prefix.
+ */
+/**
+ * Backend-issued offline grant payload.
+ * @typedef {object} OfflineGrant
+ * @property {string} deviceId - Device id allowed to use the grant.
+ * @property {string} expiresAt - ISO timestamp after which replay must reject the grant.
+ * @property {string} grantId - Stable grant id.
+ * @property {string} issuedAt - ISO timestamp when the backend issued the grant.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} resources - Sync manifest/materialized resource metadata.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} scopes - Materialized grant scopes.
+ * @property {string} userId - Actor user id allowed to use the grant.
+ */
+/**
+ * Offline grant signing key.
+ * @typedef {object} OfflineGrantSigningKey
+ * @property {boolean} [current] - Whether this is the active key for new grants.
+ * @property {string} id - Public key id included in signed grant envelopes.
+ * @property {string} secret - Private HMAC secret. Never expose this to clients.
+ */
+/**
+ * Creates a signed offline grant envelope.
+ * @param {object} args - Arguments.
+ * @param {OfflineGrant} args.grant - Grant payload.
+ * @param {OfflineGrantSigningKey} args.signingKey - Current signing key.
+ * @returns {Promise<SignedOfflineGrant>} - Signed grant envelope.
+ */
+export async function createOfflineGrant({ grant, signingKey }) {
+    const normalizedGrant = normalizeOfflineGrant(grant);
+    const normalizedSigningKey = normalizeOfflineGrantSigningKey(signingKey);
+    const signatureInput = offlineGrantSignatureInput({
+        algorithm: OFFLINE_GRANT_SIGNATURE_ALGORITHM,
+        grant: normalizedGrant,
+        keyId: normalizedSigningKey.id
+    });
+    return {
+        algorithm: OFFLINE_GRANT_SIGNATURE_ALGORITHM,
+        grant: normalizedGrant,
+        keyId: normalizedSigningKey.id,
+        signature: await hmacSha256Hex({ message: signatureInput, secret: normalizedSigningKey.secret })
+    };
+}
+/**
+ * Verifies a signed offline grant and returns the trusted grant payload.
+ * @param {object} args - Arguments.
+ * @param {Date} [args.now] - Verification time. Defaults to current time.
+ * @param {SignedOfflineGrant} args.signedGrant - Signed grant envelope.
+ * @param {OfflineGrantSigningKey[]} args.signingKeys - Candidate verification keys.
+ * @returns {Promise<OfflineGrant>} - Verified grant payload.
+ */
+export async function verifyOfflineGrant({ now = new Date(), signedGrant, signingKeys }) {
+    const normalizedSignedGrant = normalizeSignedOfflineGrant(signedGrant);
+    if (normalizedSignedGrant.algorithm !== OFFLINE_GRANT_SIGNATURE_ALGORITHM) {
+        throw new Error(`Unsupported offline grant signature algorithm '${normalizedSignedGrant.algorithm}'`);
+    }
+    const signingKey = signingKeys
+        .map((key) => normalizeOfflineGrantSigningKey(key))
+        .find((key) => key.id === normalizedSignedGrant.keyId);
+    if (!signingKey)
+        throw new Error(`No offline grant signing key for key id '${normalizedSignedGrant.keyId}'`);
+    const expectedSignature = await hmacSha256Hex({
+        message: offlineGrantSignatureInput(normalizedSignedGrant),
+        secret: signingKey.secret
+    });
+    if (expectedSignature !== normalizedSignedGrant.signature) {
+        throw new Error("Offline grant signature did not match");
+    }
+    if (Number.isNaN(now.getTime()))
+        throw new Error("Invalid offline grant verification time");
+    if (new Date(normalizedSignedGrant.grant.expiresAt).getTime() <= now.getTime())
+        throw new Error("Offline grant expired");
+    return normalizedSignedGrant.grant;
+}
+/**
+ * Builds a signed grant from bootstrap request inputs.
+ * @param {object} args - Arguments.
+ * @param {string} args.deviceId - Device id.
+ * @param {string | undefined} [args.grantId] - Optional deterministic grant id for tests/custom callers.
+ * @param {number | undefined} [args.grantTtlMs] - Grant TTL in milliseconds.
+ * @param {Date} args.now - Issue time.
+ * @param {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} args.resources - Resource sync manifest.
+ * @param {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} args.scopes - Grant scopes.
+ * @param {OfflineGrantSigningKey} args.signingKey - Current signing key.
+ * @param {string} args.userId - Actor user id.
+ * @returns {Promise<SignedOfflineGrant>} - Signed grant.
+ */
+export async function createOfflineGrantFromBootstrap({ deviceId, grantId, grantTtlMs, now, resources, scopes, signingKey, userId }) {
+    const issuedAt = isoDateString(now, "issuedAt");
+    const ttlMs = grantTtlMs === undefined ? 24 * 60 * 60 * 1000 : grantTtlMs;
+    if (!Number.isInteger(ttlMs) || ttlMs <= 0)
+        throw new Error("Offline grant TTL must be a positive integer number of milliseconds");
+    return await createOfflineGrant({
+        grant: {
+            deviceId,
+            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+            grantId: grantId || randomGrantId(),
+            issuedAt,
+            resources,
+            scopes,
+            userId
+        },
+        signingKey
+    });
+}
+/**
+ * Normalizes signed grant signature input.
+ * @param {{algorithm: "HS256", grant: OfflineGrant, keyId: string}} signedGrant - Grant signature fields.
+ * @returns {string} - Stable signature input.
+ */
+function offlineGrantSignatureInput(signedGrant) {
+    return stableJsonStringify({
+        algorithm: signedGrant.algorithm,
+        grant: signedGrant.grant,
+        keyId: signedGrant.keyId
+    });
+}
+/**
+ * Normalizes a signed offline grant envelope.
+ * @param {SignedOfflineGrant} signedGrant - Signed grant.
+ * @returns {SignedOfflineGrant} - Normalized signed grant.
+ */
+function normalizeSignedOfflineGrant(signedGrant) {
+    if (!signedGrant || typeof signedGrant !== "object" || Array.isArray(signedGrant))
+        throw new Error("Expected signed offline grant object");
+    if (signedGrant.algorithm !== OFFLINE_GRANT_SIGNATURE_ALGORITHM)
+        throw new Error(`Unsupported offline grant signature algorithm '${String(signedGrant.algorithm)}'`);
+    if (typeof signedGrant.keyId !== "string" || signedGrant.keyId.length < 1)
+        throw new Error("Expected offline grant key id");
+    if (typeof signedGrant.signature !== "string" || !signedGrant.signature.match(/^hmac-sha256-[a-f0-9]{64}$/))
+        throw new Error("Expected offline grant signature");
+    return {
+        algorithm: signedGrant.algorithm,
+        grant: normalizeOfflineGrant(signedGrant.grant),
+        keyId: signedGrant.keyId,
+        signature: signedGrant.signature
+    };
+}
+/**
+ * Normalizes an offline grant payload.
+ * @param {OfflineGrant} grant - Grant payload.
+ * @returns {OfflineGrant} - Normalized grant payload.
+ */
+function normalizeOfflineGrant(grant) {
+    if (!grant || typeof grant !== "object" || Array.isArray(grant))
+        throw new Error("Expected offline grant object");
+    return {
+        deviceId: requiredString(grant.deviceId, "deviceId"),
+        expiresAt: isoDateString(new Date(requiredString(grant.expiresAt, "expiresAt")), "expiresAt"),
+        grantId: requiredString(grant.grantId, "grantId"),
+        issuedAt: isoDateString(new Date(requiredString(grant.issuedAt, "issuedAt")), "issuedAt"),
+        resources: deterministicJsonObject({ label: "resources", value: grant.resources }),
+        scopes: deterministicJsonObject({ label: "scopes", value: grant.scopes }),
+        userId: requiredString(grant.userId, "userId")
+    };
+}
+/**
+ * Normalizes an offline grant signing key.
+ * @param {OfflineGrantSigningKey} signingKey - Signing key.
+ * @returns {OfflineGrantSigningKey} - Normalized signing key.
+ */
+export function normalizeOfflineGrantSigningKey(signingKey) {
+    if (!signingKey || typeof signingKey !== "object" || Array.isArray(signingKey))
+        throw new Error("Expected offline grant signing key object");
+    return {
+        current: signingKey.current === true,
+        id: requiredString(signingKey.id, "signingKey.id"),
+        secret: requiredString(signingKey.secret, "signingKey.secret")
+    };
+}
+/**
+ * Returns the current key used to sign new grants.
+ * @param {OfflineGrantSigningKey[]} signingKeys - Configured signing keys.
+ * @returns {OfflineGrantSigningKey} - Current signing key.
+ */
+export function currentOfflineGrantSigningKey(signingKeys) {
+    const normalizedKeys = signingKeys.map((key) => normalizeOfflineGrantSigningKey(key));
+    const currentKeys = normalizedKeys.filter((key) => key.current === true);
+    if (normalizedKeys.length < 1)
+        throw new Error("At least one offline grant signing key is required");
+    if (currentKeys.length > 1)
+        throw new Error("Only one offline grant signing key can be current");
+    return currentKeys[0] || normalizedKeys[0];
+}
+/**
+ * Signs a message using HMAC-SHA256 and returns a prefixed hex signature.
+ * @param {object} args - Arguments.
+ * @param {string} args.message - Message to sign.
+ * @param {string} args.secret - HMAC secret.
+ * @returns {Promise<string>} - Prefixed hex signature.
+ */
+async function hmacSha256Hex({ message, secret }) {
+    const cryptoProvider = globalThis.crypto;
+    if (!cryptoProvider?.subtle)
+        throw new Error("WebCrypto subtle API is required for offline grant signing");
+    const key = await cryptoProvider.subtle.importKey("raw", new TextEncoder().encode(secret), { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
+    const signature = await cryptoProvider.subtle.sign("HMAC", key, new TextEncoder().encode(message));
+    return `${OFFLINE_GRANT_SIGNATURE_PREFIX}${hex(new Uint8Array(signature))}`;
+}
+/**
+ * Converts bytes to lower-case hex.
+ * @param {Uint8Array} bytes - Bytes.
+ * @returns {string} - Hex string.
+ */
+function hex(bytes) {
+    return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * 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 offline grant ${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 offline grant ${label}`);
+    return date.toISOString();
+}
+/**
+ * Generates a fallback random grant id.
+ * @returns {string} - Grant id.
+ */
+function randomGrantId() {
+    return globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : `grant-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+/**
+ * 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 offline grant ${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(`Offline grant ${label} must be deterministic JSON`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offline-grant.js","sourceRoot":"","sources":["../../../src/sync/offline-grant.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst OFFLINE_GRANT_SIGNATURE_ALGORITHM = \"HS256\"\nconst OFFLINE_GRANT_SIGNATURE_PREFIX = \"hmac-sha256-\"\n\n/**\n * Signed offline grant envelope.\n * @typedef {object} SignedOfflineGrant\n * @property {\"HS256\"} algorithm - Signature algorithm.\n * @property {OfflineGrant} grant - Signed grant payload.\n * @property {string} keyId - Signing key id.\n * @property {string} signature - Hex HMAC signature with a hmac-sha256 prefix.\n */\n\n/**\n * Backend-issued offline grant payload.\n * @typedef {object} OfflineGrant\n * @property {string} deviceId - Device id allowed to use the grant.\n * @property {string} expiresAt - ISO timestamp after which replay must reject the grant.\n * @property {string} grantId - Stable grant id.\n * @property {string} issuedAt - ISO timestamp when the backend issued the grant.\n * @property {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} resources - Sync manifest/materialized resource metadata.\n * @property {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} scopes - Materialized grant scopes.\n * @property {string} userId - Actor user id allowed to use the grant.\n */\n\n/**\n * Offline grant signing key.\n * @typedef {object} OfflineGrantSigningKey\n * @property {boolean} [current] - Whether this is the active key for new grants.\n * @property {string} id - Public key id included in signed grant envelopes.\n * @property {string} secret - Private HMAC secret. Never expose this to clients.\n */\n\n/**\n * Creates a signed offline grant envelope.\n * @param {object} args - Arguments.\n * @param {OfflineGrant} args.grant - Grant payload.\n * @param {OfflineGrantSigningKey} args.signingKey - Current signing key.\n * @returns {Promise<SignedOfflineGrant>} - Signed grant envelope.\n */\nexport async function createOfflineGrant({grant, signingKey}) {\n  const normalizedGrant = normalizeOfflineGrant(grant)\n  const normalizedSigningKey = normalizeOfflineGrantSigningKey(signingKey)\n  const signatureInput = offlineGrantSignatureInput({\n    algorithm: OFFLINE_GRANT_SIGNATURE_ALGORITHM,\n    grant: normalizedGrant,\n    keyId: normalizedSigningKey.id\n  })\n\n  return {\n    algorithm: OFFLINE_GRANT_SIGNATURE_ALGORITHM,\n    grant: normalizedGrant,\n    keyId: normalizedSigningKey.id,\n    signature: await hmacSha256Hex({message: signatureInput, secret: normalizedSigningKey.secret})\n  }\n}\n\n/**\n * Verifies a signed offline grant and returns the trusted grant payload.\n * @param {object} args - Arguments.\n * @param {Date} [args.now] - Verification time. Defaults to current time.\n * @param {SignedOfflineGrant} args.signedGrant - Signed grant envelope.\n * @param {OfflineGrantSigningKey[]} args.signingKeys - Candidate verification keys.\n * @returns {Promise<OfflineGrant>} - Verified grant payload.\n */\nexport async function verifyOfflineGrant({now = new Date(), signedGrant, signingKeys}) {\n  const normalizedSignedGrant = normalizeSignedOfflineGrant(signedGrant)\n\n  if (normalizedSignedGrant.algorithm !== OFFLINE_GRANT_SIGNATURE_ALGORITHM) {\n    throw new Error(`Unsupported offline grant signature algorithm '${normalizedSignedGrant.algorithm}'`)\n  }\n\n  const signingKey = signingKeys\n    .map((key) => normalizeOfflineGrantSigningKey(key))\n    .find((key) => key.id === normalizedSignedGrant.keyId)\n\n  if (!signingKey) throw new Error(`No offline grant signing key for key id '${normalizedSignedGrant.keyId}'`)\n\n  const expectedSignature = await hmacSha256Hex({\n    message: offlineGrantSignatureInput(normalizedSignedGrant),\n    secret: signingKey.secret\n  })\n\n  if (expectedSignature !== normalizedSignedGrant.signature) {\n    throw new Error(\"Offline grant signature did not match\")\n  }\n\n  if (Number.isNaN(now.getTime())) throw new Error(\"Invalid offline grant verification time\")\n  if (new Date(normalizedSignedGrant.grant.expiresAt).getTime() <= now.getTime()) throw new Error(\"Offline grant expired\")\n\n  return normalizedSignedGrant.grant\n}\n\n/**\n * Builds a signed grant from bootstrap request inputs.\n * @param {object} args - Arguments.\n * @param {string} args.deviceId - Device id.\n * @param {string | undefined} [args.grantId] - Optional deterministic grant id for tests/custom callers.\n * @param {number | undefined} [args.grantTtlMs] - Grant TTL in milliseconds.\n * @param {Date} args.now - Issue time.\n * @param {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} args.resources - Resource sync manifest.\n * @param {Record<string, import(\"../configuration-types.js\").FrontendModelSyncJsonValue>} args.scopes - Grant scopes.\n * @param {OfflineGrantSigningKey} args.signingKey - Current signing key.\n * @param {string} args.userId - Actor user id.\n * @returns {Promise<SignedOfflineGrant>} - Signed grant.\n */\nexport async function createOfflineGrantFromBootstrap({deviceId, grantId, grantTtlMs, now, resources, scopes, signingKey, userId}) {\n  const issuedAt = isoDateString(now, \"issuedAt\")\n  const ttlMs = grantTtlMs === undefined ? 24 * 60 * 60 * 1000 : grantTtlMs\n\n  if (!Number.isInteger(ttlMs) || ttlMs <= 0) throw new Error(\"Offline grant TTL must be a positive integer number of milliseconds\")\n\n  return await createOfflineGrant({\n    grant: {\n      deviceId,\n      expiresAt: new Date(now.getTime() + ttlMs).toISOString(),\n      grantId: grantId || randomGrantId(),\n      issuedAt,\n      resources,\n      scopes,\n      userId\n    },\n    signingKey\n  })\n}\n\n/**\n * Normalizes signed grant signature input.\n * @param {{algorithm: \"HS256\", grant: OfflineGrant, keyId: string}} signedGrant - Grant signature fields.\n * @returns {string} - Stable signature input.\n */\nfunction offlineGrantSignatureInput(signedGrant) {\n  return stableJsonStringify({\n    algorithm: signedGrant.algorithm,\n    grant: signedGrant.grant,\n    keyId: signedGrant.keyId\n  })\n}\n\n/**\n * Normalizes a signed offline grant envelope.\n * @param {SignedOfflineGrant} signedGrant - Signed grant.\n * @returns {SignedOfflineGrant} - Normalized signed grant.\n */\nfunction normalizeSignedOfflineGrant(signedGrant) {\n  if (!signedGrant || typeof signedGrant !== \"object\" || Array.isArray(signedGrant)) throw new Error(\"Expected signed offline grant object\")\n  if (signedGrant.algorithm !== OFFLINE_GRANT_SIGNATURE_ALGORITHM) throw new Error(`Unsupported offline grant signature algorithm '${String(signedGrant.algorithm)}'`)\n  if (typeof signedGrant.keyId !== \"string\" || signedGrant.keyId.length < 1) throw new Error(\"Expected offline grant key id\")\n  if (typeof signedGrant.signature !== \"string\" || !signedGrant.signature.match(/^hmac-sha256-[a-f0-9]{64}$/)) throw new Error(\"Expected offline grant signature\")\n\n  return {\n    algorithm: signedGrant.algorithm,\n    grant: normalizeOfflineGrant(signedGrant.grant),\n    keyId: signedGrant.keyId,\n    signature: signedGrant.signature\n  }\n}\n\n/**\n * Normalizes an offline grant payload.\n * @param {OfflineGrant} grant - Grant payload.\n * @returns {OfflineGrant} - Normalized grant payload.\n */\nfunction normalizeOfflineGrant(grant) {\n  if (!grant || typeof grant !== \"object\" || Array.isArray(grant)) throw new Error(\"Expected offline grant object\")\n\n  return {\n    deviceId: requiredString(grant.deviceId, \"deviceId\"),\n    expiresAt: isoDateString(new Date(requiredString(grant.expiresAt, \"expiresAt\")), \"expiresAt\"),\n    grantId: requiredString(grant.grantId, \"grantId\"),\n    issuedAt: isoDateString(new Date(requiredString(grant.issuedAt, \"issuedAt\")), \"issuedAt\"),\n    resources: deterministicJsonObject({label: \"resources\", value: grant.resources}),\n    scopes: deterministicJsonObject({label: \"scopes\", value: grant.scopes}),\n    userId: requiredString(grant.userId, \"userId\")\n  }\n}\n\n/**\n * Normalizes an offline grant signing key.\n * @param {OfflineGrantSigningKey} signingKey - Signing key.\n * @returns {OfflineGrantSigningKey} - Normalized signing key.\n */\nexport function normalizeOfflineGrantSigningKey(signingKey) {\n  if (!signingKey || typeof signingKey !== \"object\" || Array.isArray(signingKey)) throw new Error(\"Expected offline grant signing key object\")\n\n  return {\n    current: signingKey.current === true,\n    id: requiredString(signingKey.id, \"signingKey.id\"),\n    secret: requiredString(signingKey.secret, \"signingKey.secret\")\n  }\n}\n\n/**\n * Returns the current key used to sign new grants.\n * @param {OfflineGrantSigningKey[]} signingKeys - Configured signing keys.\n * @returns {OfflineGrantSigningKey} - Current signing key.\n */\nexport function currentOfflineGrantSigningKey(signingKeys) {\n  const normalizedKeys = signingKeys.map((key) => normalizeOfflineGrantSigningKey(key))\n  const currentKeys = normalizedKeys.filter((key) => key.current === true)\n\n  if (normalizedKeys.length < 1) throw new Error(\"At least one offline grant signing key is required\")\n  if (currentKeys.length > 1) throw new Error(\"Only one offline grant signing key can be current\")\n\n  return currentKeys[0] || normalizedKeys[0]\n}\n\n/**\n * Signs a message using HMAC-SHA256 and returns a prefixed hex signature.\n * @param {object} args - Arguments.\n * @param {string} args.message - Message to sign.\n * @param {string} args.secret - HMAC secret.\n * @returns {Promise<string>} - Prefixed hex signature.\n */\nasync function hmacSha256Hex({message, secret}) {\n  const cryptoProvider = globalThis.crypto\n\n  if (!cryptoProvider?.subtle) throw new Error(\"WebCrypto subtle API is required for offline grant signing\")\n\n  const key = await cryptoProvider.subtle.importKey(\n    \"raw\",\n    new TextEncoder().encode(secret),\n    {hash: \"SHA-256\", name: \"HMAC\"},\n    false,\n    [\"sign\"]\n  )\n  const signature = await cryptoProvider.subtle.sign(\"HMAC\", key, new TextEncoder().encode(message))\n\n  return `${OFFLINE_GRANT_SIGNATURE_PREFIX}${hex(new Uint8Array(signature))}`\n}\n\n/**\n * Converts bytes to lower-case hex.\n * @param {Uint8Array} bytes - Bytes.\n * @returns {string} - Hex string.\n */\nfunction hex(bytes) {\n  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, \"0\")).join(\"\")\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 offline grant ${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 offline grant ${label}`)\n\n  return date.toISOString()\n}\n\n/**\n * Generates a fallback random grant id.\n * @returns {string} - Grant id.\n */\nfunction randomGrantId() {\n  return globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : `grant-${Date.now()}-${Math.random().toString(16).slice(2)}`\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 offline grant ${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)) {\n    return value.map((entry, index) => deterministicJson({label: `${label}/${index}`, value: entry}))\n  }\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(`Offline grant ${label} must be deterministic JSON`)\n}\n"]}