@metamask-previews/passkey-controller 1.0.0-preview-53e60e1a5 → 1.0.0-preview-4e0ae1bc9

package/dist/PasskeyController.mjs

@@ -9,16 +9,15 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PasskeyController_instances, _PasskeyController_ceremonyManager, _PasskeyController_rpID, _PasskeyController_rpName, _PasskeyController_expectedOrigin, _PasskeyController_userName, _PasskeyController_userDisplayName, _PasskeyController_requireEnrolled, _PasskeyController_getChallengeFromClientData, _PasskeyController_verifyAuthenticationResponse;
+var _PasskeyController_instances, _PasskeyController_ceremonyManager, _PasskeyController_expectedRPIDs, _PasskeyController_rpId, _PasskeyController_rpName, _PasskeyController_expectedOrigin, _PasskeyController_userName, _PasskeyController_userDisplayName, _PasskeyController_requireEnrolled, _PasskeyController_getChallengeFromClientData, _PasskeyController_verifyAuthenticationResponse;
 import { BaseController } from "@metamask/base-controller";
 import { areUint8ArraysEqual, stringToBytes } from "@metamask/utils";
-import { randomBytes } from "@noble/ciphers/webcrypto";
 import { WEBAUTHN_TIMEOUT_MS, CeremonyManager } from "./ceremony-manager.mjs";
 import { controllerName, PasskeyControllerErrorCode, PasskeyControllerErrorMessage } from "./constants.mjs";
 import { PasskeyControllerError } from "./errors.mjs";
-import { deriveKeyFromAuthenticationResponse, deriveKeyFromRegistrationResponse } from "./key-derivation.mjs";
+import { deriveKeyFromAuthenticationResponse } from "./key-derivation.mjs";
 import { createModuleLogger, projectLogger } from "./logger.mjs";
-import { decryptWithKey, encryptWithKey } from "./utils/crypto.mjs";
+import { decryptWithKey, encryptWithKey, randomBytesToBase64URL } from "./utils/crypto.mjs";
 import { base64URLToBytes, bytesToBase64URL } from "./utils/encoding.mjs";
 import { COSEALG } from "./webauthn/constants.mjs";
 import { decodeClientDataJSON } from "./webauthn/decode-client-data-json.mjs";
@@ -52,32 +51,27 @@ export const passkeyControllerSelectors = {
     selectIsPasskeyEnrolled: (state) => state.passkeyRecord !== null,
 };
 /**
- * Passkey-based protection for the vault encryption key (WebAuthn).
- *
- * Uses PRF-backed derivation when available; otherwise uses the credential
- * `userHandle`.
+ * Controller that enrolls a WebAuthn passkey and uses it to protect and unlock
+ * the vault encryption key.
  */
 export class PasskeyController extends BaseController {
     /**
-     * Constructs a new {@link PasskeyController}.
+     * Creates a passkey controller with WebAuthn relying-party settings.
      *
-     * @param args - The constructor arguments.
-     * @param args.messenger - The messenger suited for this controller.
-     * @param args.state - Initial state. Missing properties are filled in with
-     *   defaults from {@link getDefaultPasskeyControllerState}.
-     * @param args.rpID - WebAuthn Relying Party ID (typically the eTLD+1 of the
-     *   client origin, or `localhost` in dev).
-     * @param args.rpName - Human-readable Relying Party name shown by the OS
-     *   passkey UI.
-     * @param args.expectedOrigin - One or more acceptable origins for the
-     *   `clientDataJSON.origin` check (e.g. `chrome-extension://...`).
-     * @param args.userName - Optional `user.name` shown by the OS passkey UI.
-     *   Defaults to `rpName` so client builds (Stable, Flask, etc.) can
-     *   differentiate without changes here.
-     * @param args.userDisplayName - Optional `user.displayName` shown by the OS
-     *   passkey UI. Defaults to `rpName`.
+     * @param args - Constructor options.
+     * @param args.messenger - Controller messenger.
+     * @param args.state - Partial initial state; merged with {@link getDefaultPasskeyControllerState}.
+     * @param args.expectedRPID - Relying party ID(s) for verification (SHA-256 hash match in
+     *   authenticator data). Pass a string or array of strings; an empty array skips RP ID
+     *   allowlist checks in {@link verifyRegistrationResponse} / {@link verifyAuthenticationResponse}.
+     * @param args.rpId - When set, included as `rp.id` on registration options and `rpId` on
+     *   authentication options. When omitted, those fields are left unset (client default RP ID).
+     * @param args.rpName - Relying party name shown in the platform passkey UI.
+     * @param args.expectedOrigin - Allowed value(s) for the WebAuthn client origin.
+     * @param args.userName - Optional passkey user name; defaults to `rpName`.
+     * @param args.userDisplayName - Optional display name; defaults to `rpName`.
      */
-    constructor({ messenger, state = {}, rpID, rpName, expectedOrigin, userName, userDisplayName, }) {
+    constructor({ messenger, state = {}, rpId, expectedRPID, rpName, expectedOrigin, userName, userDisplayName, }) {
         super({
             messenger,
             metadata: passkeyControllerMetadata,
@@ -86,47 +80,54 @@ export class PasskeyController extends BaseController {
         });
         _PasskeyController_instances.add(this);
         _PasskeyController_ceremonyManager.set(this, new CeremonyManager());
-        _PasskeyController_rpID.set(this, void 0);
+        _PasskeyController_expectedRPIDs.set(this, void 0);
+        _PasskeyController_rpId.set(this, void 0);
         _PasskeyController_rpName.set(this, void 0);
         _PasskeyController_expectedOrigin.set(this, void 0);
         _PasskeyController_userName.set(this, void 0);
         _PasskeyController_userDisplayName.set(this, void 0);
-        __classPrivateFieldSet(this, _PasskeyController_rpID, rpID, "f");
+        const expectedRPIDs = Array.isArray(expectedRPID)
+            ? expectedRPID
+            : [expectedRPID];
+        __classPrivateFieldSet(this, _PasskeyController_expectedRPIDs, [...expectedRPIDs], "f");
+        __classPrivateFieldSet(this, _PasskeyController_rpId, rpId, "f");
         __classPrivateFieldSet(this, _PasskeyController_rpName, rpName, "f");
         __classPrivateFieldSet(this, _PasskeyController_expectedOrigin, expectedOrigin, "f");
         __classPrivateFieldSet(this, _PasskeyController_userName, userName ?? rpName, "f");
         __classPrivateFieldSet(this, _PasskeyController_userDisplayName, userDisplayName ?? rpName, "f");
     }
     /**
-     * Checks if the passkey is enrolled.
+     * Whether a passkey is enrolled and vault key material is stored.
      *
-     * @returns Whether the passkey is enrolled.
+     * @returns `true` if enrolled, otherwise `false`.
      */
     isPasskeyEnrolled() {
         return passkeyControllerSelectors.selectIsPasskeyEnrolled(this.state);
     }
     /**
-     * Registration options for enrolling a passkey.
-     *
-     * Call before {@link protectVaultKeyWithPasskey}.
+     * Builds WebAuthn credential creation options for passkey enrollment.
      *
-     * @param creationOptionsConfig - Optional configuration.
-     * @param creationOptionsConfig.prfAvailable - Omit PRF when `false`. Default `true`.
-     * @returns Options for `navigator.credentials.create()`.
+     * @param creationOptionsConfig - Optional creation behavior.
+     * @param creationOptionsConfig.prfAvailable - Request the PRF extension unless `false`. Defaults to `true`.
+     * @returns Public key credential creation options for `navigator.credentials.create()`.
      */
     generateRegistrationOptions(creationOptionsConfig) {
+        if (this.isPasskeyEnrolled()) {
+            throw new PasskeyControllerError(PasskeyControllerErrorMessage.AlreadyEnrolled, { code: PasskeyControllerErrorCode.AlreadyEnrolled });
+        }
         const includePrf = creationOptionsConfig?.prfAvailable !== false;
-        const prfSalt = includePrf
-            ? bytesToBase64URL(randomBytes(32).slice())
-            : undefined;
-        const userHandle = bytesToBase64URL(randomBytes(64).slice());
-        const challenge = bytesToBase64URL(randomBytes(32).slice());
+        const prfSalt = includePrf ? randomBytesToBase64URL(32) : undefined;
+        const userHandle = randomBytesToBase64URL(64);
+        const challenge = randomBytesToBase64URL(32);
         const extensions = {};
         if (prfSalt) {
             extensions.prf = { eval: { first: prfSalt } };
         }
         const options = {
-            rp: { name: __classPrivateFieldGet(this, _PasskeyController_rpName, "f"), id: __classPrivateFieldGet(this, _PasskeyController_rpID, "f") },
+            rp: {
+                name: __classPrivateFieldGet(this, _PasskeyController_rpName, "f"),
+                id: __classPrivateFieldGet(this, _PasskeyController_rpId, "f"),
+            },
             user: {
                 id: userHandle,
                 name: __classPrivateFieldGet(this, _PasskeyController_userName, "f"),
@@ -150,30 +151,72 @@ export class PasskeyController extends BaseController {
         };
         __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").saveRegistrationCeremony(challenge, {
             userHandle,
-            prfSalt: prfSalt ?? '',
+            prfSalt,
             challenge,
             createdAt: Date.now(),
         });
         return options;
     }
     /**
-     * WebAuthn request options for authenticating with the enrolled passkey.
+     * Builds WebAuthn credential request options for the post-registration
+     * authentication step (between `create` and {@link protectVaultKeyWithPasskey}).
      *
-     * Call before {@link retrieveVaultKeyWithPasskey},
-     * {@link verifyPasskeyAuthentication}, or {@link renewVaultKeyProtection}.
+     * @param params - Input for the pending registration ceremony.
+     * @param params.registrationResponse - Result of `navigator.credentials.create()`.
+     * @returns Public key credential request options for `navigator.credentials.get()`.
+     */
+    generatePostRegistrationAuthenticationOptions(params) {
+        // get registration ceremony
+        const { registrationResponse } = params;
+        const regChallenge = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_getChallengeFromClientData).call(this, registrationResponse.response.clientDataJSON);
+        const registrationCeremony = __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").getRegistrationCeremony(regChallenge);
+        if (!registrationCeremony) {
+            log('No active passkey registration ceremony for challenge');
+            throw new PasskeyControllerError(PasskeyControllerErrorMessage.NoRegistrationCeremony, { code: PasskeyControllerErrorCode.NoRegistrationCeremony });
+        }
+        // build auth options
+        const challenge = randomBytesToBase64URL(32);
+        const extensions = {};
+        if (registrationCeremony.prfSalt) {
+            extensions.prf = { eval: { first: registrationCeremony.prfSalt } };
+        }
+        const options = {
+            challenge,
+            rpId: __classPrivateFieldGet(this, _PasskeyController_rpId, "f"),
+            allowCredentials: [
+                {
+                    id: registrationResponse.id,
+                    type: 'public-key',
+                    transports: registrationResponse.response.transports,
+                },
+            ],
+            userVerification: 'preferred',
+            hints: ['client-device', 'hybrid'],
+            timeout: WEBAUTHN_TIMEOUT_MS,
+            extensions,
+        };
+        // save auth ceremony
+        __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").saveAuthenticationCeremony(challenge, {
+            challenge,
+            createdAt: Date.now(),
+        });
+        return options;
+    }
+    /**
+     * Builds WebAuthn credential request options for the enrolled passkey.
      *
-     * @returns Options for `navigator.credentials.get()`.
+     * @returns Public key credential request options for `navigator.credentials.get()`.
      */
     generateAuthenticationOptions() {
         const record = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_requireEnrolled).call(this);
-        const challenge = bytesToBase64URL(randomBytes(32).slice());
+        const challenge = randomBytesToBase64URL(32);
         const extensions = {};
         if (record.keyDerivation.method === 'prf') {
             extensions.prf = { eval: { first: record.keyDerivation.prfSalt } };
         }
         const options = {
             challenge,
-            rpId: __classPrivateFieldGet(this, _PasskeyController_rpID, "f"),
+            rpId: __classPrivateFieldGet(this, _PasskeyController_rpId, "f"),
             allowCredentials: [
                 {
                     id: record.credential.id,
@@ -193,15 +236,20 @@ export class PasskeyController extends BaseController {
         return options;
     }
     /**
-     * Completes enrollment and binds the vault key to the new passkey.
+     * Verifies registration and post-registration authentication, then stores the
+     * vault key encrypted under the new passkey.
      *
-     * @param params - Protection parameters.
-     * @param params.registrationResponse - Credential from `navigator.credentials.create()`.
-     * @param params.vaultKey - Vault encryption key to protect.
+     * @param params - Enrollment completion inputs.
+     * @param params.registrationResponse - Result of `navigator.credentials.create()`.
+     * @param params.authenticationResponse - Result of `navigator.credentials.get()` after {@link generatePostRegistrationAuthenticationOptions}.
+     * @param params.vaultKey - Vault encryption key to encrypt and persist.
      */
     async protectVaultKeyWithPasskey(params) {
-        const { registrationResponse, vaultKey } = params;
-        // get challenge
+        if (this.isPasskeyEnrolled()) {
+            throw new PasskeyControllerError(PasskeyControllerErrorMessage.AlreadyEnrolled, { code: PasskeyControllerErrorCode.AlreadyEnrolled });
+        }
+        const { registrationResponse, authenticationResponse, vaultKey } = params;
+        // get registration ceremony
         const challenge = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_getChallengeFromClientData).call(this, registrationResponse.response.clientDataJSON);
         const registrationCeremony = __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").getRegistrationCeremony(challenge);
         if (!registrationCeremony) {
@@ -214,7 +262,7 @@ export class PasskeyController extends BaseController {
                 response: registrationResponse,
                 expectedChallenge: registrationCeremony.challenge,
                 expectedOrigin: __classPrivateFieldGet(this, _PasskeyController_expectedOrigin, "f"),
-                expectedRPID: __classPrivateFieldGet(this, _PasskeyController_rpID, "f"),
+                expectedRPIDs: __classPrivateFieldGet(this, _PasskeyController_expectedRPIDs, "f"),
                 requireUserVerification: false,
             }).catch((error) => {
                 log('Error verifying passkey registration response', error);
@@ -227,19 +275,36 @@ export class PasskeyController extends BaseController {
                 log('Passkey registration verification returned unverified or missing registration info');
                 throw new PasskeyControllerError(PasskeyControllerErrorMessage.RegistrationVerificationFailed, { code: PasskeyControllerErrorCode.RegistrationVerificationFailed });
             }
-            // derive key
-            const { encKey, keyDerivation } = deriveKeyFromRegistrationResponse(registrationResponse, registrationCeremony, registrationInfo.credentialId);
-            // encrypt vault key
+            // verify authentication response
+            const credential = {
+                id: registrationInfo.credentialId,
+                publicKey: bytesToBase64URL(registrationInfo.publicKey),
+                counter: registrationInfo.counter,
+                transports: registrationInfo.transports,
+                aaguid: registrationInfo.aaguid,
+            };
+            const { newCounter } = await __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_verifyAuthenticationResponse).call(this, authenticationResponse, credential);
+            // determine key derivation method
+            const prfFirst = authenticationResponse.clientExtensionResults?.prf?.results?.first;
+            const authHasPrfOutput = typeof prfFirst === 'string' && prfFirst.length > 0;
+            const keyDerivation = authHasPrfOutput && registrationCeremony.prfSalt
+                ? { method: 'prf', prfSalt: registrationCeremony.prfSalt }
+                : { method: 'userHandle' };
+            if (keyDerivation.method === 'userHandle' &&
+                authenticationResponse.response.userHandle !==
+                    registrationCeremony.userHandle) {
+                log('Post-registration assertion userHandle does not match registration ceremony');
+                throw new PasskeyControllerError(PasskeyControllerErrorMessage.AuthenticationVerificationFailed, { code: PasskeyControllerErrorCode.AuthenticationVerificationFailed });
+            }
+            // derive key and encrypt vault key
+            const encKey = deriveKeyFromAuthenticationResponse(authenticationResponse, { credential, keyDerivation });
             const { ciphertext, iv } = encryptWithKey(vaultKey, encKey);
             // persist passkey record
             this.update((state) => {
                 state.passkeyRecord = {
                     credential: {
-                        id: registrationInfo.credentialId,
-                        publicKey: bytesToBase64URL(registrationInfo.publicKey),
-                        counter: registrationInfo.counter,
-                        transports: registrationInfo.transports,
-                        aaguid: registrationInfo.aaguid,
+                        ...credential,
+                        counter: Math.max(newCounter, credential.counter),
                     },
                     encryptedVaultKey: { ciphertext, iv },
                     keyDerivation,
@@ -247,26 +312,32 @@ export class PasskeyController extends BaseController {
             });
         }
         finally {
+            // delete registration ceremony
             __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").deleteRegistrationCeremony(challenge);
         }
     }
     /**
-     * Returns the decrypted vault encryption key from the passkey authentication
-     * response.
+     * Verifies an authentication assertion and returns the decrypted vault key.
      *
-     * @param authenticationResponse - Credential from `navigator.credentials.get()`.
-     * @returns The vault encryption key.
+     * @param authenticationResponse - Result of `navigator.credentials.get()`.
+     * @returns The plaintext vault encryption key.
      */
     async retrieveVaultKeyWithPasskey(authenticationResponse) {
-        // verify authentication response
-        await __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_verifyAuthenticationResponse).call(this, authenticationResponse);
-        // derive key (#verifyAuthenticationResponse guarantees enrolled)
         const passkeyRecord = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_requireEnrolled).call(this);
+        // verify authentication response and update counter
+        const { newCounter } = await __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_verifyAuthenticationResponse).call(this, authenticationResponse, passkeyRecord.credential);
+        this.update((state) => {
+            if (!state.passkeyRecord) {
+                throw new PasskeyControllerError(PasskeyControllerErrorMessage.NotEnrolled, { code: PasskeyControllerErrorCode.NotEnrolled });
+            }
+            state.passkeyRecord.credential.counter = Math.max(newCounter, state.passkeyRecord.credential.counter);
+        });
+        // derive key
         const encKey = deriveKeyFromAuthenticationResponse(authenticationResponse, passkeyRecord);
         // decrypt vault key
-        let vaultKey;
         try {
-            vaultKey = decryptWithKey(passkeyRecord.encryptedVaultKey.ciphertext, passkeyRecord.encryptedVaultKey.iv, encKey);
+            const vaultKey = decryptWithKey(passkeyRecord.encryptedVaultKey.ciphertext, passkeyRecord.encryptedVaultKey.iv, encKey);
+            return vaultKey;
         }
         catch (cause) {
             log('Error decrypting vault key with passkey', cause instanceof Error ? cause : new Error(String(cause)));
@@ -275,18 +346,15 @@ export class PasskeyController extends BaseController {
                 cause: cause instanceof Error ? cause : new Error(String(cause)),
             });
         }
-        return vaultKey;
     }
     /**
-     * Returns whether passkey authentication succeeds for this credential (same
-     * work as {@link retrieveVaultKeyWithPasskey} without exposing the vault key).
+     * Checks whether the given authentication assertion is valid for the enrolled passkey.
      *
-     * Returns `false` only when the failure is a {@link PasskeyControllerError}
-     * with a defined `code`. Unexpected errors (e.g. malformed `clientDataJSON`,
-     * internal bugs) are rethrown.
+     * On failure, returns `false` for {@link PasskeyControllerError} with a `code`;
+     * other errors propagate.
      *
-     * @param authenticationResponse - Credential from `navigator.credentials.get()`.
-     * @returns `true` if authentication succeeds, otherwise `false`.
+     * @param authenticationResponse - Result of `navigator.credentials.get()`.
+     * @returns `true` if verification succeeds, otherwise `false`.
      */
     async verifyPasskeyAuthentication(authenticationResponse) {
         try {
@@ -301,19 +369,17 @@ export class PasskeyController extends BaseController {
         }
     }
     /**
-     * Updates the vault encryption key for the same passkey (e.g. after a password change).
+     * Re-wraps the vault key after rotation. Updates persisted `encryptedVaultKey` on success.
      *
-     * Caller MUST first verify the assertion via {@link verifyPasskeyAuthentication}
-     * or {@link retrieveVaultKeyWithPasskey}. This method does not re-verify
-     * because the ceremony is single-use (deleted on verify) and the signature
-     * counter is advanced (replay would be rejected). Authentication here is
-     * enforced by the prior verification plus the `oldVaultKey` match below.
+     * Does not verify WebAuthn or ceremony state—call only after your layer has authenticated
+     * the user (passkey `get()` + verified assertion, or verified password). On passkey paths,
+     * pass the same `authenticationResponse` you just verified (e.g. from
+     * {@link retrieveVaultKeyWithPasskey} / {@link verifyPasskeyAuthentication}).
      *
-     * @param params - Renewal parameters.
-     * @param params.authenticationResponse - Credential from `navigator.credentials.get()`,
-     *   already verified by the caller.
+     * @param params - Re-wrap inputs.
+     * @param params.authenticationResponse - Used to derive the wrapping key.
      * @param params.oldVaultKey - Expected current vault key.
-     * @param params.newVaultKey - New vault key to protect.
+     * @param params.newVaultKey - New vault key to encrypt under the passkey.
      */
     async renewVaultKeyProtection(params) {
         const { authenticationResponse } = params;
@@ -351,7 +417,8 @@ export class PasskeyController extends BaseController {
         });
     }
     /**
-     * Unenrolls the passkey, removing the protected vault key material.
+     * Clears enrolled passkey state and in-flight ceremonies. Call only after the same
+     * auth gate as renewal (verified passkey assertion or password).
      */
     removePasskey() {
         this.update(() => getDefaultPasskeyControllerState());
@@ -371,7 +438,7 @@ export class PasskeyController extends BaseController {
         super.destroy();
     }
 }
-_PasskeyController_ceremonyManager = new WeakMap(), _PasskeyController_rpID = new WeakMap(), _PasskeyController_rpName = new WeakMap(), _PasskeyController_expectedOrigin = new WeakMap(), _PasskeyController_userName = new WeakMap(), _PasskeyController_userDisplayName = new WeakMap(), _PasskeyController_instances = new WeakSet(), _PasskeyController_requireEnrolled = function _PasskeyController_requireEnrolled() {
+_PasskeyController_ceremonyManager = new WeakMap(), _PasskeyController_expectedRPIDs = new WeakMap(), _PasskeyController_rpId = new WeakMap(), _PasskeyController_rpName = new WeakMap(), _PasskeyController_expectedOrigin = new WeakMap(), _PasskeyController_userName = new WeakMap(), _PasskeyController_userDisplayName = new WeakMap(), _PasskeyController_instances = new WeakSet(), _PasskeyController_requireEnrolled = function _PasskeyController_requireEnrolled() {
     const record = this.state.passkeyRecord;
     if (!record) {
         throw new PasskeyControllerError(PasskeyControllerErrorMessage.NotEnrolled, {
@@ -383,34 +450,33 @@ _PasskeyController_ceremonyManager = new WeakMap(), _PasskeyController_rpID = ne
     return decodeClientDataJSON(clientDataJSON).challenge;
 }, _PasskeyController_verifyAuthenticationResponse = 
 /**
- * Verifies an authentication response for the enrolled passkey.
+ * Validates a WebAuthn authentication response against stored credential data.
  *
- * @param authenticationResponse - Authentication result JSON.
+ * @param authenticationResponse - Parsed authentication response from the client.
+ * @param credential - Credential identifiers and public key material for verification.
+ * @returns Updated authenticator signature counter.
  */
-async function _PasskeyController_verifyAuthenticationResponse(authenticationResponse) {
-    let challenge;
+async function _PasskeyController_verifyAuthenticationResponse(authenticationResponse, credential) {
+    // get challenge
+    const challenge = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_getChallengeFromClientData).call(this, authenticationResponse.response.clientDataJSON);
+    // get authentication ceremony
+    const authenticationCeremony = __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").getAuthenticationCeremony(challenge);
+    if (!authenticationCeremony) {
+        log('No active passkey authentication ceremony for challenge');
+        throw new PasskeyControllerError(PasskeyControllerErrorMessage.NoAuthenticationCeremony, { code: PasskeyControllerErrorCode.NoAuthenticationCeremony });
+    }
     try {
-        // get challenge
-        challenge = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_getChallengeFromClientData).call(this, authenticationResponse.response.clientDataJSON);
-        // get passkey record
-        const record = __classPrivateFieldGet(this, _PasskeyController_instances, "m", _PasskeyController_requireEnrolled).call(this);
-        // get authentication ceremony
-        const authenticationCeremony = __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").getAuthenticationCeremony(challenge);
-        if (!authenticationCeremony) {
-            log('No active passkey authentication ceremony for challenge');
-            throw new PasskeyControllerError(PasskeyControllerErrorMessage.NoAuthenticationCeremony, { code: PasskeyControllerErrorCode.NoAuthenticationCeremony });
-        }
         // verify authentication response
         const result = await verifyAuthenticationResponse({
             response: authenticationResponse,
             expectedChallenge: authenticationCeremony.challenge,
             expectedOrigin: __classPrivateFieldGet(this, _PasskeyController_expectedOrigin, "f"),
-            expectedRPID: __classPrivateFieldGet(this, _PasskeyController_rpID, "f"),
+            expectedRPIDs: __classPrivateFieldGet(this, _PasskeyController_expectedRPIDs, "f"),
             credential: {
-                id: record.credential.id,
-                publicKey: base64URLToBytes(record.credential.publicKey),
-                counter: record.credential.counter,
-                transports: record.credential.transports,
+                id: credential.id,
+                publicKey: base64URLToBytes(credential.publicKey),
+                counter: credential.counter,
+                transports: credential.transports,
             },
             // UV optional for device compatibility; vault key remains password-gated.
             requireUserVerification: false,
@@ -427,19 +493,11 @@ async function _PasskeyController_verifyAuthenticationResponse(authenticationRes
                 code: PasskeyControllerErrorCode.AuthenticationVerificationFailed,
             });
         }
-        // persist passkey record with updated counter without clobbering concurrent updates
-        this.update((state) => {
-            if (!state.passkeyRecord) {
-                throw new PasskeyControllerError(PasskeyControllerErrorMessage.NotEnrolled, { code: PasskeyControllerErrorCode.NotEnrolled });
-            }
-            const latest = state.passkeyRecord;
-            latest.credential.counter = Math.max(result.authenticationInfo.newCounter, latest.credential.counter);
-        });
+        return { newCounter: result.authenticationInfo.newCounter };
     }
     finally {
-        if (challenge) {
-            __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").deleteAuthenticationCeremony(challenge);
-        }
+        // delete authentication ceremony
+        __classPrivateFieldGet(this, _PasskeyController_ceremonyManager, "f").deleteAuthenticationCeremony(challenge);
     }
 };
 //# sourceMappingURL=PasskeyController.mjs.map