From 846ebc942c579db2ebacdc0de6c76980ede8c799 Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Tue, 23 Sep 2025 11:22:45 +0200
Subject: [PATCH 1/7] Add first version of conditional create

---
 packages/web-core/src/services/WebAuthnService.ts | 15 ++++++++++++---
 .../app/(no-auth)/login/PasswordForm.tsx          |  3 ++-
 playground/connect-next/app/(no-auth)/page.tsx    | 12 ++++++++----
 3 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/packages/web-core/src/services/WebAuthnService.ts b/packages/web-core/src/services/WebAuthnService.ts
index ea4bb441..350c7f8d 100644
--- a/packages/web-core/src/services/WebAuthnService.ts
+++ b/packages/web-core/src/services/WebAuthnService.ts
@@ -2,7 +2,7 @@
 /// <reference types="user-agent-data-types" /> <- add this line
 import type { ClientCapabilities } from '@corbado/types';
 import type { CredentialRequestOptionsJSON } from '@corbado/webauthn-json';
-import { create, get } from '@corbado/webauthn-json';
+import { get } from '@corbado/webauthn-json';
 import type { CredentialCreationOptionsJSON } from '@corbado/webauthn-json/src/webauthn-json/basic/json';
 import FingerprintJS from '@fingerprintjs/fingerprintjs';
 import { detectIncognito } from 'detectincognitojs';
@@ -39,10 +39,19 @@ export class WebAuthnService {
   async createPasskeyRaw(serializedChallenge: string): Promise<string> {
     const abortController = this.abortOngoingOperation();
     const challenge = JSON.parse(serializedChallenge);
-    challenge.signal = abortController.signal;
     this.#abortController = abortController;
 
-    const signedChallenge = await create(challenge);
+    console.log('createPasskeyRaw challenge', challenge);
+
+    const publicKey = PublicKeyCredential.parseCreationOptionsFromJSON(challenge.publicKey);
+    console.log('createPasskeyRaw publicKey', publicKey);
+    const credential = (await navigator.credentials.create({
+      publicKey,
+      signal: abortController.signal,
+      mediation: challenge.mediation,
+    } as any)) as PublicKeyCredential;
+    const signedChallenge = credential.toJSON();
+
     return JSON.stringify(signedChallenge);
   }
 
diff --git a/playground/connect-next/app/(no-auth)/login/PasswordForm.tsx b/playground/connect-next/app/(no-auth)/login/PasswordForm.tsx
index 85458313..d10edea5 100644
--- a/playground/connect-next/app/(no-auth)/login/PasswordForm.tsx
+++ b/playground/connect-next/app/(no-auth)/login/PasswordForm.tsx
@@ -35,7 +35,7 @@ export const PasswordForm = ({ onClick, initialUserProvidedIdentifier, initialEr
           name='email'
           type='email'
           placeholder='user@acme.com'
-          autoComplete='email'
+          autoComplete='username'
           required
           className='mt-1 block w-full appearance-none rounded-md border border-gray-300 px-3 py-2 placeholder-gray-400 shadow-sm focus:border-black focus:outline-none focus:ring-black sm:text-sm'
           value={username}
@@ -53,6 +53,7 @@ export const PasswordForm = ({ onClick, initialUserProvidedIdentifier, initialEr
           id='password'
           name='password'
           type='password'
+          autoComplete='current-password'
           required
           className='mt-1 block w-full appearance-none rounded-md border border-gray-300 px-3 py-2 placeholder-gray-400 shadow-sm focus:border-black focus:outline-none focus:ring-black sm:text-sm'
           value={password}
diff --git a/playground/connect-next/app/(no-auth)/page.tsx b/playground/connect-next/app/(no-auth)/page.tsx
index 99005811..14deca36 100644
--- a/playground/connect-next/app/(no-auth)/page.tsx
+++ b/playground/connect-next/app/(no-auth)/page.tsx
@@ -14,7 +14,7 @@ export default function SignupPage() {
   const [password, setPassword] = useState('');
   const [message, setMessage] = useState('');
 
-  const handleSignup = async (e: FormEvent<HTMLButtonElement>) => {
+  const handleSignup = async (e: FormEvent<HTMLFormElement>) => {
     e.preventDefault();
     const username = generateRandomString(10);
 
@@ -58,7 +58,10 @@ export default function SignupPage() {
           <h3 className='text-xl font-semibold'>Sign Up</h3>
           <p className='text-sm text-gray-500'>Create an account with your email, phone and password</p>
         </div>
-        <form className='flex flex-col space-y-4 bg-gray-50 px-4 py-8 sm:px-8'>
+        <form
+          className='flex flex-col space-y-4 bg-gray-50 px-4 py-8 sm:px-8'
+          onSubmit={handleSignup}
+        >
           <div>
             <label
               htmlFor='email'
@@ -71,7 +74,7 @@ export default function SignupPage() {
               name='email'
               type='email'
               placeholder='Email'
-              autoComplete='email'
+              autoComplete='username'
               required
               className='mt-1 block w-full appearance-none rounded-md border border-gray-300 px-3 py-2 placeholder-gray-400 shadow-sm focus:border-black focus:outline-none focus:ring-black sm:text-sm'
               value={email}
@@ -90,6 +93,7 @@ export default function SignupPage() {
               name='password'
               type='password'
               placeholder='Password'
+              autoComplete='new-password'
               required
               className='mt-1 block w-full appearance-none rounded-md border border-gray-300 px-3 py-2 placeholder-gray-400 shadow-sm focus:border-black focus:outline-none focus:ring-black sm:text-sm'
               value={password}
@@ -118,7 +122,7 @@ export default function SignupPage() {
           </div>
           {message && <div className='text-center text-red-700'>{message}</div>}
           <Button
-            onClick={handleSignup}
+            type='submit'
             className='w-full'
             size='lg'
           >

From e7a06fa0fd787fbd30dea26e27555818624dede6 Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Wed, 24 Sep 2025 12:02:20 +0200
Subject: [PATCH 2/7] Connect conditional-create to FAPI

---
 .../components/append/AppendInitScreen.tsx    |  39 +++++-
 .../connect-react/src/types/situations.ts     |   1 +
 packages/web-core/openapi/spec_v2.yaml        |   3 +
 packages/web-core/src/api/v2/api.ts           |   6 +
 .../web-core/src/services/ConnectService.ts   |  47 ++++----
 .../web-core/src/services/WebAuthnService.ts  | 111 ++++++++++++------
 6 files changed, 142 insertions(+), 65 deletions(-)

diff --git a/packages/connect-react/src/components/append/AppendInitScreen.tsx b/packages/connect-react/src/components/append/AppendInitScreen.tsx
index 8a6916ea..8c93b39d 100644
--- a/packages/connect-react/src/components/append/AppendInitScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendInitScreen.tsx
@@ -132,10 +132,21 @@ const AppendInitScreen = () => {
       }
 
       setAttestationOptions(startAppendRes.val.attestationOptions);
-      statefulLoader.current.finish();
-
       log.debug('startAppendRes', startAppendRes, flags);
+
+      if (startAppendRes.val.conditionalAppend) {
+        console.log('starting conditional-append');
+        const handledByConditionalCreate = await handleConditionalCreate(startAppendRes.val.attestationOptions);
+        if (handledByConditionalCreate) {
+          statefulLoader.current.finish();
+          return;
+        }
+        console.log('finished conditional-append');
+      }
+
+      statefulLoader.current.finish();
       if (startAppendRes.val.autoAppend || flags.hasSupportForAutomaticAppend()) {
+        console.log('starting auto-append');
         await handleSubmit(startAppendRes.val.attestationOptions, false);
       }
     };
@@ -184,7 +195,25 @@ const AppendInitScreen = () => {
         aaguidIcon: res.val.passkeyOperation.aaguidDetails?.iconLight,
       });
     },
-    [config, getConnectService, appendLoading, skipping],
+    [getConnectService, appendLoading, skipping],
+  );
+
+  const handleConditionalCreate = useCallback(
+    async (attestationOptions: string) => {
+      const res = await getConnectService().completeAppend(attestationOptions, true);
+      if (res.err) {
+        await handleSituation(AppendSituationCode.ClientPasskeyOperationErrorSilent, res.val);
+        return false;
+      }
+
+      navigateToScreen(AppendScreenType.Success, {
+        aaguidName: res.val.passkeyOperation.aaguidDetails?.name,
+        aaguidIcon: res.val.passkeyOperation.aaguidDetails?.iconLight,
+      });
+
+      return true;
+    },
+    [getConnectService],
   );
 
   const handleSituation = async (situationCode: AppendSituationCode, error?: ConnectError) => {
@@ -222,6 +251,10 @@ const AppendInitScreen = () => {
       case AppendSituationCode.ExplicitSkipByUser:
         await handleSkip(situationCode, true);
         break;
+      case AppendSituationCode.ClientPasskeyOperationErrorSilent:
+        void handleErrorSoft(situationCode, false, false, error);
+        setAppendLoading(false);
+        break;
     }
   };
 
diff --git a/packages/connect-react/src/types/situations.ts b/packages/connect-react/src/types/situations.ts
index 075ec587..8c88bdd4 100644
--- a/packages/connect-react/src/types/situations.ts
+++ b/packages/connect-react/src/types/situations.ts
@@ -27,6 +27,7 @@ export enum AppendSituationCode {
   DeniedByPasskeyIntel,
   ExplicitSkipByUser,
   ClientPasskeyOperationCancelledSilent,
+  ClientPasskeyOperationErrorSilent,
 }
 
 export enum PasskeyListSituationCode {
diff --git a/packages/web-core/openapi/spec_v2.yaml b/packages/web-core/openapi/spec_v2.yaml
index f6892816..850d130c 100644
--- a/packages/web-core/openapi/spec_v2.yaml
+++ b/packages/web-core/openapi/spec_v2.yaml
@@ -1486,6 +1486,7 @@ components:
         - variant
         - isRestrictedBrowser
         - autoAppend
+        - conditionalAppend
       properties:
         attestationOptions:
           type: string
@@ -1499,6 +1500,8 @@ components:
           type: boolean
         autoAppend:
           type: boolean
+        conditionalAppend:
+          type: boolean
 
     connectAppendFinishReq:
       type: object
diff --git a/packages/web-core/src/api/v2/api.ts b/packages/web-core/src/api/v2/api.ts
index 1fd5b511..71a73316 100644
--- a/packages/web-core/src/api/v2/api.ts
+++ b/packages/web-core/src/api/v2/api.ts
@@ -442,6 +442,12 @@ export interface ConnectAppendStartRsp {
      * @memberof ConnectAppendStartRsp
      */
     'autoAppend': boolean;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof ConnectAppendStartRsp
+     */
+    'conditionalAppend': boolean;
 }
 
 export const ConnectAppendStartRspVariantEnum = {
diff --git a/packages/web-core/src/services/ConnectService.ts b/packages/web-core/src/services/ConnectService.ts
index d50ab26a..45065cd0 100644
--- a/packages/web-core/src/services/ConnectService.ts
+++ b/packages/web-core/src/services/ConnectService.ts
@@ -413,27 +413,6 @@ export class ConnectService {
     return Ok(appendData);
   }
 
-  async append(appendTokenValue: string, loadedMs: number): Promise<Result<ConnectAppendFinishRsp, ConnectError>> {
-    const existingProcess = await this.#getExistingProcess(() => this.appendInit(new AbortController()));
-    if (!existingProcess) {
-      return Err(new ConnectError(ConnectErrorType.MissingInit));
-    }
-
-    const resStart = await this.wrapWithErr(() =>
-      this.#connectApi.connectAppendStart({ appendTokenValue: appendTokenValue, loadedMs }),
-    );
-    if (resStart.err) {
-      return resStart;
-    }
-
-    const platformRes = await this.#webAuthnCreatePasskey(resStart.val.attestationOptions);
-    if (platformRes.err) {
-      return platformRes;
-    }
-
-    return this.wrapWithErr(() => this.#connectApi.connectAppendFinish({ attestationResponse: platformRes.val }));
-  }
-
   async startAppend(
     appendTokenValue: string,
     loadedMs: number,
@@ -453,13 +432,16 @@ export class ConnectService {
     );
   }
 
-  async completeAppend(attestationOptions: string): Promise<Result<ConnectAppendFinishRsp, ConnectError>> {
+  async completeAppend(
+    attestationOptions: string,
+    conditional = false,
+  ): Promise<Result<ConnectAppendFinishRsp, ConnectError>> {
     const existingProcess = await this.#getExistingProcess(() => this.appendInit(new AbortController()));
     if (!existingProcess) {
       return Err(new ConnectError(ConnectErrorType.MissingInit));
     }
 
-    const res = await this.#webAuthnCreatePasskey(attestationOptions);
+    const res = await this.#webAuthnCreatePasskey(attestationOptions, conditional);
     if (res.err) {
       return res;
     }
@@ -771,18 +753,29 @@ export class ConnectService {
     const started = Date.now();
     try {
       const res = await this.#webAuthnService.loginRaw(serializedChallenge, isConditional, onConditionalLoginStart);
-      return Ok(res);
+      if (res.message) {
+        void this.recordEventLoginErrorUnexpected(res.message);
+      }
+
+      return Ok(res.response);
     } catch (e) {
       const runtime = Date.now() - started;
       return Err(ConnectError.fromFrontendError(e, runtime));
     }
   }
 
-  async #webAuthnCreatePasskey(serializedChallenge: string): Promise<Result<string, ConnectError>> {
+  async #webAuthnCreatePasskey(
+    serializedChallenge: string,
+    conditional: boolean,
+  ): Promise<Result<string, ConnectError>> {
     const started = Date.now();
     try {
-      const res = await this.#webAuthnService.createPasskeyRaw(serializedChallenge);
-      return Ok(res);
+      const res = await this.#webAuthnService.createPasskeyRaw(serializedChallenge, conditional);
+      if (res.message) {
+        void this.recordEventAppendErrorUnexpected(res.message);
+      }
+
+      return Ok(res.response);
     } catch (e) {
       const runtime = Date.now() - started;
       return Err(ConnectError.fromFrontendError(e, runtime));
diff --git a/packages/web-core/src/services/WebAuthnService.ts b/packages/web-core/src/services/WebAuthnService.ts
index 350c7f8d..2236a4ae 100644
--- a/packages/web-core/src/services/WebAuthnService.ts
+++ b/packages/web-core/src/services/WebAuthnService.ts
@@ -1,9 +1,7 @@
 /// <reference types="web-bluetooth" />
 /// <reference types="user-agent-data-types" /> <- add this line
 import type { ClientCapabilities } from '@corbado/types';
-import type { CredentialRequestOptionsJSON } from '@corbado/webauthn-json';
-import { get } from '@corbado/webauthn-json';
-import type { CredentialCreationOptionsJSON } from '@corbado/webauthn-json/src/webauthn-json/basic/json';
+import { parseCreationOptionsFromJSON, parseRequestOptionsFromJSON } from '@corbado/webauthn-json/browser-ponyfill';
 import FingerprintJS from '@fingerprintjs/fingerprintjs';
 import { detectIncognito } from 'detectincognitojs';
 import log from 'loglevel';
@@ -15,6 +13,11 @@ import { CorbadoError } from '../utils';
 import type { ClientStateEntry } from './ClientStateService';
 import { ClientStateService } from './ClientStateService';
 
+export type ResponseWithMessage = {
+  response: string;
+  message?: string;
+};
+
 /**
  * AuthenticatorService handles all interactions with webAuthn platform authenticators.
  * Currently, this includes the creation of passkeys and the login with existing passkeys.
@@ -25,8 +28,8 @@ export class WebAuthnService {
 
   async createPasskey(serializedChallenge: string): Promise<Result<string, CorbadoError>> {
     try {
-      const res = await this.createPasskeyRaw(serializedChallenge);
-      return Ok(res);
+      const res = await this.createPasskeyRaw(serializedChallenge, false);
+      return Ok(res.response);
     } catch (e) {
       if (e instanceof DOMException) {
         return Err(CorbadoError.fromDOMException(e));
@@ -36,23 +39,42 @@ export class WebAuthnService {
     }
   }
 
-  async createPasskeyRaw(serializedChallenge: string): Promise<string> {
+  async createPasskeyRaw(attestationOptions: string, conditional: boolean): Promise<ResponseWithMessage> {
+    let message;
     const abortController = this.abortOngoingOperation();
-    const challenge = JSON.parse(serializedChallenge);
+    const attestationOptionsJSON = JSON.parse(attestationOptions);
     this.#abortController = abortController;
 
-    console.log('createPasskeyRaw challenge', challenge);
+    let publicKey: PublicKeyCredentialCreationOptions | undefined;
+    if (PublicKeyCredential.parseCreationOptionsFromJSON) {
+      publicKey = PublicKeyCredential.parseCreationOptionsFromJSON(attestationOptionsJSON.publicKey);
+    } else {
+      message = 'parseCreationOptionsFromJSON not available';
+      publicKey = parseCreationOptionsFromJSON(attestationOptionsJSON).publicKey;
+    }
+
+    if (!publicKey) {
+      throw new Error('No publicKey in assertionOptions');
+    }
 
-    const publicKey = PublicKeyCredential.parseCreationOptionsFromJSON(challenge.publicKey);
-    console.log('createPasskeyRaw publicKey', publicKey);
-    const credential = (await navigator.credentials.create({
+    let mediation: CredentialMediationRequirement | undefined;
+    if (conditional) {
+      mediation = 'conditional';
+    }
+
+    const options = {
       publicKey,
       signal: abortController.signal,
-      mediation: challenge.mediation,
-    } as any)) as PublicKeyCredential;
-    const signedChallenge = credential.toJSON();
+      mediation,
+    } as never;
+
+    console.log('create options', options);
+    const credential = (await navigator.credentials.create(options)) as PublicKeyCredential;
 
-    return JSON.stringify(signedChallenge);
+    return {
+      response: JSON.stringify(credential.toJSON()),
+      message,
+    };
   }
 
   async login(
@@ -62,7 +84,7 @@ export class WebAuthnService {
   ): Promise<Result<string, CorbadoError>> {
     try {
       const res = await this.loginRaw(serializedChallenge, conditional, onConditionalLoginStart);
-      return Ok(res);
+      return Ok(res.response);
     } catch (e) {
       if (e instanceof DOMException) {
         return Err(CorbadoError.fromDOMException(e));
@@ -73,24 +95,43 @@ export class WebAuthnService {
   }
 
   async loginRaw(
-    serializedChallenge: string,
+    assertionOptions: string,
     conditional: boolean,
     onConditionalLoginStart?: (ac: AbortController) => void,
-  ): Promise<string> {
+  ): Promise<ResponseWithMessage> {
+    let message: string | undefined;
     const abortController = this.abortOngoingOperation();
-
-    const challenge: CredentialRequestOptionsJSON = JSON.parse(serializedChallenge);
-
-    challenge.signal = abortController.signal;
+    const assertionOptionsJSON = JSON.parse(assertionOptions);
     this.#abortController = abortController;
     onConditionalLoginStart?.(abortController);
 
+    let publicKey: PublicKeyCredentialRequestOptions | undefined;
+    if (PublicKeyCredential.parseRequestOptionsFromJSON) {
+      publicKey = PublicKeyCredential.parseRequestOptionsFromJSON(assertionOptionsJSON.publicKey);
+    } else {
+      publicKey = parseRequestOptionsFromJSON(assertionOptionsJSON).publicKey;
+      message = 'parseRequestOptionsFromJSON not available';
+    }
+
+    if (!publicKey) {
+      throw new Error('No publicKey in assertionOptions');
+    }
+
+    let mediation: CredentialMediationRequirement | undefined;
     if (conditional) {
-      challenge.mediation = 'conditional';
+      mediation = 'conditional';
     }
 
-    const signedChallenge = await get(challenge);
-    return JSON.stringify(signedChallenge);
+    const credential = (await navigator.credentials.get({
+      publicKey,
+      mediation,
+      signal: abortController.signal,
+    })) as PublicKeyCredential;
+
+    return {
+      response: JSON.stringify(credential.toJSON()),
+      message,
+    };
   }
 
   async getClientInformation(maybeClientHandle: ClientStateEntry<string> | undefined): Promise<ClientInformation> {
@@ -135,12 +176,12 @@ export class WebAuthnService {
   }
 
   static async doesBrowserSupportPasskeys(): Promise<boolean | undefined> {
-    if (!window.PublicKeyCredential) {
+    if (!PublicKeyCredential) {
       return undefined;
     }
 
     try {
-      return await window.PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+      return await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
     } catch (e) {
       log.debug('Error checking passkey availability', e);
       return;
@@ -148,12 +189,12 @@ export class WebAuthnService {
   }
 
   static async doesBrowserSupportConditionalUI(): Promise<boolean | undefined> {
-    if (!window.PublicKeyCredential) {
+    if (!PublicKeyCredential) {
       return undefined;
     }
 
     try {
-      return await window.PublicKeyCredential.isConditionalMediationAvailable();
+      return await PublicKeyCredential.isConditionalMediationAvailable();
     } catch (e) {
       log.debug('Error checking conditional UI availability', e);
       return;
@@ -221,7 +262,7 @@ export class WebAuthnService {
   }
 
   static async getClientCapabilities(): Promise<ClientCapabilities | undefined> {
-    if (!window.PublicKeyCredential) {
+    if (!PublicKeyCredential) {
       log.debug('PublicKeyCredential is not supported on this browser');
       return;
     }
@@ -229,7 +270,7 @@ export class WebAuthnService {
     try {
       // We will ignore the type check as getClientCapabilities does not exist in the stable authn version and types
       // @ts-ignore
-      return await window.PublicKeyCredential.getClientCapabilities();
+      return await PublicKeyCredential.getClientCapabilities();
     } catch (e) {
       log.debug('Error using getClientCapabilities: ', e);
       return;
@@ -237,18 +278,18 @@ export class WebAuthnService {
   }
 
   static challengeFromAttestationOptions(attestationOptions: string): string {
-    const typed: CredentialCreationOptionsJSON = JSON.parse(attestationOptions);
+    const typed = JSON.parse(attestationOptions);
     return typed.publicKey.challenge;
   }
 
   static challengeFromAssertionOptions(assertionOptions: string): string | undefined {
-    const typed: CredentialRequestOptionsJSON = JSON.parse(assertionOptions);
+    const typed = JSON.parse(assertionOptions);
     return typed.publicKey?.challenge;
   }
 
   static async signalAllAcceptedCredentials(rpId: string, userId: string, credentialIds: string[]): Promise<void> {
     // @ts-ignore
-    if (!window.PublicKeyCredential || !window.PublicKeyCredential.signalAllAcceptedCredentials) {
+    if (!PublicKeyCredential || !PublicKeyCredential.signalAllAcceptedCredentials) {
       return undefined;
     }
 
@@ -271,7 +312,7 @@ export class WebAuthnService {
 
   static async signalUnknownCredential(rpId: string, credentialId: string): Promise<void> {
     // @ts-ignore
-    if (!window.PublicKeyCredential || !window.PublicKeyCredential.signalUnknownCredential) {
+    if (!PublicKeyCredential || !PublicKeyCredential.signalUnknownCredential) {
       return undefined;
     }
 

From ef54442331d16c23d4f06c344c77d3d9b21a70c1 Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Wed, 24 Sep 2025 19:48:28 +0200
Subject: [PATCH 3/7] Stop conditional creation after 5s

---
 .../append/AppendAfterErrorScreen.tsx         |  2 +-
 .../components/append/AppendInitScreen.tsx    | 24 ++++++++++-----
 .../passkeyList/PasskeyListScreen.tsx         |  2 +-
 packages/web-core/openapi/spec_v2.yaml        |  7 +++++
 packages/web-core/src/api/v2/api.ts           | 24 +++++++++++++++
 .../web-core/src/models/connect/append.ts     |  1 +
 .../web-core/src/services/ConnectService.ts   |  6 ++--
 .../web-core/src/services/WebAuthnService.ts  | 30 ++++++++++++-------
 8 files changed, 73 insertions(+), 23 deletions(-)

diff --git a/packages/connect-react/src/components/append/AppendAfterErrorScreen.tsx b/packages/connect-react/src/components/append/AppendAfterErrorScreen.tsx
index 0cc328ca..8d31d6fe 100644
--- a/packages/connect-react/src/components/append/AppendAfterErrorScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendAfterErrorScreen.tsx
@@ -24,7 +24,7 @@ const AppendAfterErrorScreen = ({ attestationOptions }: { attestationOptions: st
 
     setLoading(true);
     setErrorMessage(undefined);
-    const res = await getConnectService().completeAppend(attestationOptions);
+    const res = await getConnectService().completeAppend(attestationOptions, 'manual');
     if (res.err) {
       if (res.val.type === ConnectErrorType.ExcludeCredentialsMatch) {
         return handleSituation(AppendSituationCode.ClientExcludeCredentialsMatch, res.val);
diff --git a/packages/connect-react/src/components/append/AppendInitScreen.tsx b/packages/connect-react/src/components/append/AppendInitScreen.tsx
index 8c93b39d..f28e65a9 100644
--- a/packages/connect-react/src/components/append/AppendInitScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendInitScreen.tsx
@@ -12,6 +12,7 @@ import { StatefulLoader } from '../../utils/statefulLoader';
 import AppendBenefits from './append-init/AppendBenetifs';
 import AppendInitLoaded2 from './append-init/AppendInitLoaded2';
 import AppendInitLoading from './append-init/AppendInitLoading';
+import { AppendCompletionType } from '@corbado/web-core/dist/models/connect/append';
 
 export enum AppendInitState {
   SilentLoading,
@@ -147,7 +148,7 @@ const AppendInitScreen = () => {
       statefulLoader.current.finish();
       if (startAppendRes.val.autoAppend || flags.hasSupportForAutomaticAppend()) {
         console.log('starting auto-append');
-        await handleSubmit(startAppendRes.val.attestationOptions, false);
+        await handleSubmit(startAppendRes.val.attestationOptions, 'auto');
       }
     };
 
@@ -164,7 +165,7 @@ const AppendInitScreen = () => {
   }, []);
 
   const handleSubmit = useCallback(
-    async (attestationOptions: string, showErrorIfCancelled: boolean) => {
+    async (attestationOptions: string, completionType: AppendCompletionType) => {
       if (appendLoading || skipping) {
         return;
       }
@@ -172,17 +173,17 @@ const AppendInitScreen = () => {
       setAppendLoading(true);
       setErrorMessage(undefined);
 
-      const res = await getConnectService().completeAppend(attestationOptions);
+      const res = await getConnectService().completeAppend(attestationOptions, completionType);
       if (res.err) {
         if (res.val.type === ConnectErrorType.ExcludeCredentialsMatch) {
           return handleSituation(AppendSituationCode.ClientExcludeCredentialsMatch, res.val);
         }
 
         if (res.val.type === ConnectErrorType.Cancel) {
-          if (showErrorIfCancelled) {
-            return handleSituation(AppendSituationCode.ClientPasskeyOperationCancelled, res.val);
-          } else {
+          if (completionType === 'auto') {
             return handleSituation(AppendSituationCode.ClientPasskeyOperationCancelledSilent, res.val);
+          } else {
+            return handleSituation(AppendSituationCode.ClientPasskeyOperationCancelled, res.val);
           }
         }
 
@@ -200,7 +201,7 @@ const AppendInitScreen = () => {
 
   const handleConditionalCreate = useCallback(
     async (attestationOptions: string) => {
-      const res = await getConnectService().completeAppend(attestationOptions, true);
+      const res = await getConnectService().completeAppend(attestationOptions, 'conditional');
       if (res.err) {
         await handleSituation(AppendSituationCode.ClientPasskeyOperationErrorSilent, res.val);
         return false;
@@ -283,7 +284,14 @@ const AppendInitScreen = () => {
             void onReadMoreClick();
             setAppendInitState(AppendInitState.ShowBenefits);
           }}
-          handleSubmit={() => void handleSubmit(attestationOptions, true)}
+          handleSubmit={() => {
+            let completionType: AppendCompletionType = 'manual';
+            if (errorMessage) {
+              completionType = 'manual-retry';
+            }
+
+            void handleSubmit(attestationOptions, completionType);
+          }}
           handleSkip={() => onSkip()}
         />
       );
diff --git a/packages/connect-react/src/components/passkeyList/PasskeyListScreen.tsx b/packages/connect-react/src/components/passkeyList/PasskeyListScreen.tsx
index 64419823..0a082d63 100644
--- a/packages/connect-react/src/components/passkeyList/PasskeyListScreen.tsx
+++ b/packages/connect-react/src/components/passkeyList/PasskeyListScreen.tsx
@@ -130,7 +130,7 @@ const PasskeyListScreen = () => {
       return handleSituation(PasskeyListSituationCode.CboApiPasskeysNotSupported);
     }
 
-    const res = await getConnectService().completeAppend(startAppendRes.val.attestationOptions);
+    const res = await getConnectService().completeAppend(startAppendRes.val.attestationOptions, 'manual');
     if (res.err) {
       if (res.val.type === ConnectErrorType.Cancel) {
         return handleSituation(PasskeyListSituationCode.ClientPasskeyOperationCancelled, res.val);
diff --git a/packages/web-core/openapi/spec_v2.yaml b/packages/web-core/openapi/spec_v2.yaml
index 850d130c..e1b59224 100644
--- a/packages/web-core/openapi/spec_v2.yaml
+++ b/packages/web-core/openapi/spec_v2.yaml
@@ -1507,9 +1507,12 @@ components:
       type: object
       required:
         - attestationResponse
+        - completionType
       properties:
         attestationResponse:
           type: string
+        completionType:
+          $ref: "#/components/schemas/appendCompletionType"
 
     connectAppendFinishRsp:
       type: object
@@ -2376,6 +2379,10 @@ components:
         error:
           $ref: "#/components/schemas/requestError"
 
+    appendCompletionType:
+      type: string
+      enum: ["auto", "conditional", "manual", "manual-retry"]
+
   responses:
     "200":
       description: Operation succeeded
diff --git a/packages/web-core/src/api/v2/api.ts b/packages/web-core/src/api/v2/api.ts
index 71a73316..5ec6d54c 100644
--- a/packages/web-core/src/api/v2/api.ts
+++ b/packages/web-core/src/api/v2/api.ts
@@ -48,6 +48,22 @@ export interface AaguidDetails {
      */
     'iconDark': string;
 }
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+
+export const AppendCompletionType = {
+    Auto: 'auto',
+    Conditional: 'conditional',
+    Manual: 'manual',
+    ManualRetry: 'manual-retry'
+} as const;
+
+export type AppendCompletionType = typeof AppendCompletionType[keyof typeof AppendCompletionType];
+
+
 /**
  * 
  * @export
@@ -299,7 +315,15 @@ export interface ConnectAppendFinishReq {
      * @memberof ConnectAppendFinishReq
      */
     'attestationResponse': string;
+    /**
+     * 
+     * @type {AppendCompletionType}
+     * @memberof ConnectAppendFinishReq
+     */
+    'completionType': AppendCompletionType;
 }
+
+
 /**
  * 
  * @export
diff --git a/packages/web-core/src/models/connect/append.ts b/packages/web-core/src/models/connect/append.ts
index e69de29b..3c4cfdc7 100644
--- a/packages/web-core/src/models/connect/append.ts
+++ b/packages/web-core/src/models/connect/append.ts
@@ -0,0 +1 @@
+export type AppendCompletionType = 'manual' | 'manual-retry' | 'auto' | 'conditional';
diff --git a/packages/web-core/src/services/ConnectService.ts b/packages/web-core/src/services/ConnectService.ts
index 45065cd0..f80b6a35 100644
--- a/packages/web-core/src/services/ConnectService.ts
+++ b/packages/web-core/src/services/ConnectService.ts
@@ -38,6 +38,7 @@ import { ConnectError, ConnectErrorType } from '../utils';
 import type { LastLogin } from './ClientStateService';
 import { ClientStateService } from './ClientStateService';
 import { WebAuthnService } from './WebAuthnService';
+import { AppendCompletionType } from '../models/connect/append';
 
 const packageVersion = process.env.FE_LIBRARY_VERSION;
 
@@ -434,20 +435,21 @@ export class ConnectService {
 
   async completeAppend(
     attestationOptions: string,
-    conditional = false,
+    completionType: AppendCompletionType,
   ): Promise<Result<ConnectAppendFinishRsp, ConnectError>> {
     const existingProcess = await this.#getExistingProcess(() => this.appendInit(new AbortController()));
     if (!existingProcess) {
       return Err(new ConnectError(ConnectErrorType.MissingInit));
     }
 
+    const conditional = completionType === 'conditional';
     const res = await this.#webAuthnCreatePasskey(attestationOptions, conditional);
     if (res.err) {
       return res;
     }
 
     const finishRes = await this.wrapWithErr(() =>
-      this.#connectApi.connectAppendFinish({ attestationResponse: res.val }),
+      this.#connectApi.connectAppendFinish({ attestationResponse: res.val, completionType }),
     );
     if (finishRes.ok) {
       const latestLogin = finishRes.val.passkeyOperation as LastLogin;
diff --git a/packages/web-core/src/services/WebAuthnService.ts b/packages/web-core/src/services/WebAuthnService.ts
index 2236a4ae..cb952b60 100644
--- a/packages/web-core/src/services/WebAuthnService.ts
+++ b/packages/web-core/src/services/WebAuthnService.ts
@@ -57,19 +57,27 @@ export class WebAuthnService {
       throw new Error('No publicKey in assertionOptions');
     }
 
-    let mediation: CredentialMediationRequirement | undefined;
+    let credential: PublicKeyCredential;
     if (conditional) {
-      mediation = 'conditional';
-    }
-
-    const options = {
-      publicKey,
-      signal: abortController.signal,
-      mediation,
-    } as never;
+      const p1 = await navigator.credentials.create({
+        publicKey,
+        signal: abortController.signal,
+        mediation: 'conditional',
+      } as never);
+      const p2 = new Promise<null>(resolve => setTimeout(() => resolve(null), 5000));
+
+      const result = await Promise.race([p1, p2]);
+      if (!result) {
+        throw new Error('Timeout after 5000ms');
+      }
 
-    console.log('create options', options);
-    const credential = (await navigator.credentials.create(options)) as PublicKeyCredential;
+      credential = result as PublicKeyCredential;
+    } else {
+      credential = (await navigator.credentials.create({
+        publicKey,
+        signal: abortController.signal,
+      } as never)) as PublicKeyCredential;
+    }
 
     return {
       response: JSON.stringify(credential.toJSON()),

From 1049a2969f06ce5f88971ecc8ce787780d48bd8a Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Wed, 24 Sep 2025 19:53:18 +0200
Subject: [PATCH 4/7] Prettier

---
 .../connect-react/src/components/append/AppendInitScreen.tsx    | 2 +-
 packages/web-core/src/services/ConnectService.ts                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/connect-react/src/components/append/AppendInitScreen.tsx b/packages/connect-react/src/components/append/AppendInitScreen.tsx
index f28e65a9..fe30efcc 100644
--- a/packages/connect-react/src/components/append/AppendInitScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendInitScreen.tsx
@@ -1,5 +1,6 @@
 import type { ConnectError } from '@corbado/web-core';
 import { ConnectErrorType } from '@corbado/web-core';
+import type { AppendCompletionType } from '@corbado/web-core/dist/models/connect/append';
 import log from 'loglevel';
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 
@@ -12,7 +13,6 @@ import { StatefulLoader } from '../../utils/statefulLoader';
 import AppendBenefits from './append-init/AppendBenetifs';
 import AppendInitLoaded2 from './append-init/AppendInitLoaded2';
 import AppendInitLoading from './append-init/AppendInitLoading';
-import { AppendCompletionType } from '@corbado/web-core/dist/models/connect/append';
 
 export enum AppendInitState {
   SilentLoading,
diff --git a/packages/web-core/src/services/ConnectService.ts b/packages/web-core/src/services/ConnectService.ts
index f80b6a35..7509d3ff 100644
--- a/packages/web-core/src/services/ConnectService.ts
+++ b/packages/web-core/src/services/ConnectService.ts
@@ -29,6 +29,7 @@ import type {
   ConnectManageListRsp,
 } from '../api/v2';
 import { CorbadoConnectApi, PasskeyEventType } from '../api/v2';
+import type { AppendCompletionType } from '../models/connect/append';
 import { ConnectFlags } from '../models/connect/connectFlags';
 import { ConnectInvitation } from '../models/connect/connectInvitation';
 import { ConnectProcess } from '../models/connect/connectProcess';
@@ -38,7 +39,6 @@ import { ConnectError, ConnectErrorType } from '../utils';
 import type { LastLogin } from './ClientStateService';
 import { ClientStateService } from './ClientStateService';
 import { WebAuthnService } from './WebAuthnService';
-import { AppendCompletionType } from '../models/connect/append';
 
 const packageVersion = process.env.FE_LIBRARY_VERSION;
 

From db149029811bee3da2f42a9b5972d4bd5c7e2386 Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Wed, 24 Sep 2025 20:09:49 +0200
Subject: [PATCH 5/7] Redirects for already logged-in users in connect-next
 playground

---
 .../web-core/src/services/WebAuthnService.ts  | 31 ++++++++++---------
 .../app/(no-auth)/login/ConventionalLogin.tsx |  4 +++
 .../connect-next/app/(no-auth)/page.tsx       |  9 +++++-
 3 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/packages/web-core/src/services/WebAuthnService.ts b/packages/web-core/src/services/WebAuthnService.ts
index cb952b60..7de85a63 100644
--- a/packages/web-core/src/services/WebAuthnService.ts
+++ b/packages/web-core/src/services/WebAuthnService.ts
@@ -59,17 +59,14 @@ export class WebAuthnService {
 
     let credential: PublicKeyCredential;
     if (conditional) {
-      const p1 = await navigator.credentials.create({
-        publicKey,
-        signal: abortController.signal,
-        mediation: 'conditional',
-      } as never);
-      const p2 = new Promise<null>(resolve => setTimeout(() => resolve(null), 5000));
-
-      const result = await Promise.race([p1, p2]);
-      if (!result) {
-        throw new Error('Timeout after 5000ms');
-      }
+      const result = await WebAuthnService.raceWithTimeout(
+        navigator.credentials.create({
+          publicKey,
+          signal: abortController.signal,
+          mediation: 'conditional',
+        } as never),
+        5000,
+      );
 
       credential = result as PublicKeyCredential;
     } else {
@@ -309,9 +306,7 @@ export class WebAuthnService {
         allAcceptedCredentialIds: credentialIds,
       });
 
-      const p2 = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after 2000ms`)), 2000));
-
-      await Promise.race([p1, p2]);
+      await WebAuthnService.raceWithTimeout(p1, 2000);
     } catch (e) {
       log.debug('Error calling signalAllAcceptedCredentials', e);
       return;
@@ -335,4 +330,12 @@ export class WebAuthnService {
       return;
     }
   }
+
+  static async raceWithTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
+    const timeout = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error(`timeout of ${ms}ms reached`)), ms),
+    );
+
+    return Promise.race<T>([p, timeout]);
+  }
 }
diff --git a/playground/connect-next/app/(no-auth)/login/ConventionalLogin.tsx b/playground/connect-next/app/(no-auth)/login/ConventionalLogin.tsx
index 3e3afed9..bfe8bfdb 100644
--- a/playground/connect-next/app/(no-auth)/login/ConventionalLogin.tsx
+++ b/playground/connect-next/app/(no-auth)/login/ConventionalLogin.tsx
@@ -46,6 +46,10 @@ export const ConventionalLogin = ({ initialUserProvidedIdentifier, initialError
       }
     } catch (e) {
       if (e instanceof Error) {
+        if (e.name === 'UserAlreadyAuthenticatedException') {
+          router.push('/profile');
+        }
+
         return e.message;
       }
 
diff --git a/playground/connect-next/app/(no-auth)/page.tsx b/playground/connect-next/app/(no-auth)/page.tsx
index 14deca36..8520dacb 100644
--- a/playground/connect-next/app/(no-auth)/page.tsx
+++ b/playground/connect-next/app/(no-auth)/page.tsx
@@ -37,7 +37,14 @@ export default function SignupPage() {
       console.log(resLogin);
       router.push('/post-login?post-signup=true');
     } catch (err) {
-      console.error('Error during signup:', err);
+      if (err instanceof Error) {
+        if (err.name === 'UserAlreadyAuthenticatedException') {
+          router.push('/profile');
+          return;
+        }
+      }
+
+      console.error('Unhandled error during signup:', err);
     }
   };
 

From 74256804204c268ef93b5f504f648f119810b810 Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Thu, 25 Sep 2025 10:26:28 +0200
Subject: [PATCH 6/7] Replace console.log

---
 .../connect-react/src/components/append/AppendInitScreen.tsx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/packages/connect-react/src/components/append/AppendInitScreen.tsx b/packages/connect-react/src/components/append/AppendInitScreen.tsx
index fe30efcc..8d7050b2 100644
--- a/packages/connect-react/src/components/append/AppendInitScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendInitScreen.tsx
@@ -136,13 +136,14 @@ const AppendInitScreen = () => {
       log.debug('startAppendRes', startAppendRes, flags);
 
       if (startAppendRes.val.conditionalAppend) {
-        console.log('starting conditional-append');
+        log.debug('starting conditional create');
         const handledByConditionalCreate = await handleConditionalCreate(startAppendRes.val.attestationOptions);
+        log.debug('handledByConditionalCreate', handledByConditionalCreate);
+
         if (handledByConditionalCreate) {
           statefulLoader.current.finish();
           return;
         }
-        console.log('finished conditional-append');
       }
 
       statefulLoader.current.finish();

From b8bc5f8eb37806d84ae5a0ba02ff7f143cabcf0e Mon Sep 17 00:00:00 2001
From: Martin Kellner <martin.kellner@corbado.com>
Date: Thu, 25 Sep 2025 13:06:36 +0200
Subject: [PATCH 7/7] Fix old browser compat

---
 .../components/append/AppendInitScreen.tsx    |  3 +-
 .../web-core/src/services/WebAuthnService.ts  | 48 ++++++++-----------
 .../src/utils/errors/connectErrors.ts         |  1 +
 3 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/packages/connect-react/src/components/append/AppendInitScreen.tsx b/packages/connect-react/src/components/append/AppendInitScreen.tsx
index 8d7050b2..e4e03262 100644
--- a/packages/connect-react/src/components/append/AppendInitScreen.tsx
+++ b/packages/connect-react/src/components/append/AppendInitScreen.tsx
@@ -205,7 +205,8 @@ const AppendInitScreen = () => {
       const res = await getConnectService().completeAppend(attestationOptions, 'conditional');
       if (res.err) {
         await handleSituation(AppendSituationCode.ClientPasskeyOperationErrorSilent, res.val);
-        return false;
+
+        return res.val.type === ConnectErrorType.RaceTimeout;
       }
 
       navigateToScreen(AppendScreenType.Success, {
diff --git a/packages/web-core/src/services/WebAuthnService.ts b/packages/web-core/src/services/WebAuthnService.ts
index 7de85a63..a2ff7a6c 100644
--- a/packages/web-core/src/services/WebAuthnService.ts
+++ b/packages/web-core/src/services/WebAuthnService.ts
@@ -1,7 +1,7 @@
 /// <reference types="web-bluetooth" />
 /// <reference types="user-agent-data-types" /> <- add this line
 import type { ClientCapabilities } from '@corbado/types';
-import { parseCreationOptionsFromJSON, parseRequestOptionsFromJSON } from '@corbado/webauthn-json/browser-ponyfill';
+import { create, get } from '@corbado/webauthn-json';
 import FingerprintJS from '@fingerprintjs/fingerprintjs';
 import { detectIncognito } from 'detectincognitojs';
 import log from 'loglevel';
@@ -9,7 +9,7 @@ import type { Result } from 'ts-results';
 import { Err, Ok } from 'ts-results';
 
 import type { ClientInformation, ClientStateMeta, JavaScriptHighEntropy } from '../api/v2';
-import { CorbadoError } from '../utils';
+import { ConnectError, ConnectErrorType, CorbadoError } from '../utils';
 import type { ClientStateEntry } from './ClientStateService';
 import { ClientStateService } from './ClientStateService';
 
@@ -40,23 +40,20 @@ export class WebAuthnService {
   }
 
   async createPasskeyRaw(attestationOptions: string, conditional: boolean): Promise<ResponseWithMessage> {
-    let message;
     const abortController = this.abortOngoingOperation();
     const attestationOptionsJSON = JSON.parse(attestationOptions);
     this.#abortController = abortController;
 
-    let publicKey: PublicKeyCredentialCreationOptions | undefined;
-    if (PublicKeyCredential.parseCreationOptionsFromJSON) {
-      publicKey = PublicKeyCredential.parseCreationOptionsFromJSON(attestationOptionsJSON.publicKey);
-    } else {
-      message = 'parseCreationOptionsFromJSON not available';
-      publicKey = parseCreationOptionsFromJSON(attestationOptionsJSON).publicKey;
-    }
-
-    if (!publicKey) {
-      throw new Error('No publicKey in assertionOptions');
+    if (!PublicKeyCredential.parseCreationOptionsFromJSON) {
+      attestationOptionsJSON.signal = abortController.signal;
+      const signedChallenge = await create(attestationOptionsJSON);
+      return {
+        response: JSON.stringify(signedChallenge),
+        message: 'parseCreationOptionsFromJSON not available',
+      };
     }
 
+    const publicKey = PublicKeyCredential.parseCreationOptionsFromJSON(attestationOptionsJSON.publicKey);
     let credential: PublicKeyCredential;
     if (conditional) {
       const result = await WebAuthnService.raceWithTimeout(
@@ -78,7 +75,7 @@ export class WebAuthnService {
 
     return {
       response: JSON.stringify(credential.toJSON()),
-      message,
+      message: '',
     };
   }
 
@@ -104,24 +101,19 @@ export class WebAuthnService {
     conditional: boolean,
     onConditionalLoginStart?: (ac: AbortController) => void,
   ): Promise<ResponseWithMessage> {
-    let message: string | undefined;
     const abortController = this.abortOngoingOperation();
     const assertionOptionsJSON = JSON.parse(assertionOptions);
     this.#abortController = abortController;
     onConditionalLoginStart?.(abortController);
-
-    let publicKey: PublicKeyCredentialRequestOptions | undefined;
-    if (PublicKeyCredential.parseRequestOptionsFromJSON) {
-      publicKey = PublicKeyCredential.parseRequestOptionsFromJSON(assertionOptionsJSON.publicKey);
-    } else {
-      publicKey = parseRequestOptionsFromJSON(assertionOptionsJSON).publicKey;
-      message = 'parseRequestOptionsFromJSON not available';
-    }
-
-    if (!publicKey) {
-      throw new Error('No publicKey in assertionOptions');
+    if (!PublicKeyCredential.parseRequestOptionsFromJSON) {
+      const signedChallenge = await get(assertionOptionsJSON);
+      return {
+        response: JSON.stringify(signedChallenge),
+        message: 'parseRequestOptionsFromJSON not available',
+      };
     }
 
+    const publicKey = PublicKeyCredential.parseRequestOptionsFromJSON(assertionOptionsJSON.publicKey);
     let mediation: CredentialMediationRequirement | undefined;
     if (conditional) {
       mediation = 'conditional';
@@ -135,7 +127,7 @@ export class WebAuthnService {
 
     return {
       response: JSON.stringify(credential.toJSON()),
-      message,
+      message: '',
     };
   }
 
@@ -333,7 +325,7 @@ export class WebAuthnService {
 
   static async raceWithTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
     const timeout = new Promise<never>((_, reject) =>
-      setTimeout(() => reject(new Error(`timeout of ${ms}ms reached`)), ms),
+      setTimeout(() => reject(new ConnectError(ConnectErrorType.RaceTimeout, `timeout of ${ms}ms reached`)), ms),
     );
 
     return Promise.race<T>([p, timeout]);
diff --git a/packages/web-core/src/utils/errors/connectErrors.ts b/packages/web-core/src/utils/errors/connectErrors.ts
index d8b8d40d..b3bb7d3a 100644
--- a/packages/web-core/src/utils/errors/connectErrors.ts
+++ b/packages/web-core/src/utils/errors/connectErrors.ts
@@ -8,6 +8,7 @@ export enum ConnectErrorType {
   InvalidState,
   SecurityError,
   ExcludeCredentialsMatch,
+  RaceTimeout,
 }
 
 export class ConnectError {