@@ -69,6 +69,35 @@ function authenticator() {
   });
 }
 
+describe('Passkey action errors', () => {
+  it('hides an unknown Add failure and updates the fallback when localization changes', async () => {
+    serveAccounts();
+    const view = await renderWithClerk(
+      <MosaicProvider
+        localization={{ messages: { userProfilePasskeys: { saveError: 'Could not add this passkey.' } } }}
+      >
+        <UserProfilePasskeysSection />
+      </MosaicProvider>,
+    );
+    const current = view.clerk.user;
+    if (!current) {
+      throw new Error('Expected the signed-in user');
+    }
+    vi.spyOn(current, 'createPasskey').mockRejectedValue(new Error('Private authenticator details'));
+    await userEvent.setup().click(screen.getByRole('button', { name: 'Add passkey' }));
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('Could not add this passkey.'));
+    expect(screen.queryByText('Private authenticator details')).toBeNull();
+    view.rerender(
+      <MosaicProvider
+        localization={{ messages: { userProfilePasskeys: { saveError: 'Impossible de créer cette clé.' } } }}
+      >
+        <UserProfilePasskeysSection />
+      </MosaicProvider>,
+    );
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('Impossible de créer cette clé.'));
+  });
+});
+
 describe('Changing the active passkey account', () => {
   it('clears the previous account Add error after a user switch', async () => {
     serveAccounts();
 
@@ -422,17 +422,25 @@ describe('Removing a passkey', () => {
     expect(fapi.client.sessions[0]?.user.passkeys).toEqual([]);
   });
 
-  it('keeps confirmation open on verification-required errors and retries manually', async () => {
+  it('keeps confirmation open on localized verification-required errors and retries manually', async () => {
     const fapi = servePasskeys();
-    await renderWithClerk(<UserProfilePasskeysSection />);
+    await renderWithClerk(
+      <MosaicProvider
+        localization={{
+          messages: { errors: { session_reverification_required: 'Veuillez confirmer votre identité.' } },
+        }}
+      >
+        <UserProfilePasskeysSection />
+      </MosaicProvider>,
+    );
     const removal = holdRequests('post', '/v1/me/passkeys/pk_1');
     const user = userEvent.setup();
     await user.click(screen.getByRole('button', { name: 'Manage Laptop' }));
     await user.click(screen.getByRole('menuitem', { name: 'Remove passkey' }));
     await user.click(screen.getByRole('button', { name: 'Remove' }));
     await waitFor(() => expect(removal.requests).toHaveLength(1));
     removal.fail('session_reverification_required');
-    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('session_reverification_required'));
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('Veuillez confirmer votre identité.'));
     expect(screen.getByRole('alertdialog')).toBeVisible();
     expect(screen.queryByLabelText('Password')).toBeNull();
     expect(removal.requests).toHaveLength(1);
 
@@ -1,14 +1,16 @@
 import { screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { http, HttpResponse } from 'msw';
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { fapiUrl, serveFapi, worker } from '../../../__tests__/feature/fake-fapi';
 import { fapiClient, fapiEnvironment, fapiPasskey, fapiSession, fapiUser } from '../../../__tests__/feature/fapi';
 import { renderWithClerk } from '../../../__tests__/feature/render';
 import { MosaicProvider } from '../../../mosaic-provider';
 import { UserProfilePasskeysSection } from '../user-profile-passkeys-section/user-profile-passkeys-section';
 
+afterEach(() => vi.restoreAllMocks());
+
 function servePasskeys() {
   const environment = fapiEnvironment();
   environment.user_settings.attributes.passkey.enabled = true;
@@ -21,6 +23,31 @@ function servePasskeys() {
 }
 
 describe('Validating a passkey name', () => {
+  it('uses the localized Form fallback for an unknown rename failure and preserves the draft', async () => {
+    servePasskeys();
+    const { clerk } = await renderWithClerk(
+      <MosaicProvider localization={{ messages: { form: { error: 'Impossible de sauvegarder.' } } }}>
+        <UserProfilePasskeysSection />
+      </MosaicProvider>,
+    );
+    const passkey = clerk.user?.passkeys[0];
+    if (!passkey) {
+      throw new Error('Expected the signed-in passkey');
+    }
+    vi.spyOn(passkey, 'update').mockRejectedValue(new Error('Private native failure'));
+    const user = userEvent.setup();
+    await user.click(screen.getByRole('button', { name: 'Manage Laptop' }));
+    await user.click(screen.getByRole('menuitem', { name: 'Rename' }));
+    const input = screen.getByRole('textbox', { name: 'Passkey name' });
+    await user.type(input, ' renamed');
+    await user.click(screen.getByRole('button', { name: 'Save' }));
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('Impossible de sauvegarder.'));
+    expect(screen.queryByText('Private native failure')).toBeNull();
+    expect(input).toHaveValue('Laptop renamed');
+    expect(screen.getByRole('dialog')).toBeVisible();
+    expect(input).not.toHaveAttribute('aria-invalid', 'true');
+  });
+
   it('marks localized server name errors on the field and clears them when the draft changes', async () => {
     servePasskeys();
     worker.use(
 
@@ -1,6 +1,8 @@
-import { useMessages } from '../../../localization';
+import type { ErrorDescription } from '../../../localization';
+import { useErrorText, useMessages } from '../../../localization';
 import { setup } from '../../../machine/setup';
 import { useMachine } from '../../../machine/use-machine';
+import { toLocalizableError } from '../../../utils/errors';
 import type { UserProfilePasskeysModel } from './user-profile-passkeys-section.model';
 
 type PasskeysControllerInput = Pick<
@@ -10,18 +12,17 @@ type PasskeysControllerInput = Pick<
 
 interface Context {
   run: () => Promise<unknown>;
-  error: string | undefined;
-  fallbackErrorMessage: string;
+  error: ErrorDescription | undefined;
 }
 
-type Event = { type: 'ADD'; run: () => Promise<unknown>; fallbackErrorMessage: string };
+type Event = { type: 'ADD'; run: () => Promise<unknown> };
 
 const { createMachine, assign, fromPromise } = setup<Context, Event>();
 
 const machine = createMachine({
   id: 'createPasskey',
   initial: 'idle',
-  context: { run: () => Promise.resolve(), error: undefined, fallbackErrorMessage: '' },
+  context: { run: () => Promise.resolve(), error: undefined },
   states: {
     idle: {
       on: {
@@ -30,7 +31,6 @@ const machine = createMachine({
           actions: assign((_, event) => ({
             run: event.run,
             error: undefined,
-            fallbackErrorMessage: event.fallbackErrorMessage,
           })),
         },
       },
@@ -40,10 +40,7 @@ const machine = createMachine({
         onDone: { target: 'idle' },
         onError: {
           target: 'idle',
-          actions: assign((context, event) => ({
-            error:
-              event.error instanceof Error && event.error.message ? event.error.message : context.fallbackErrorMessage,
-          })),
+          actions: assign((_, event) => ({ error: toLocalizableError(event.error) })),
         },
       }),
     },
@@ -58,12 +55,13 @@ export function useUserProfilePasskeysSectionController({
   onRemove,
 }: PasskeysControllerInput) {
   const messages = useMessages('userProfilePasskeys');
+  const errorText = useErrorText();
   const [snapshot, send] = useMachine(machine);
   return {
     passkeys,
     isAdding: snapshot.value === 'creating',
-    addError: snapshot.context.error,
-    onAdd: onAdd ? () => send({ type: 'ADD', run: onAdd, fallbackErrorMessage: messages.saveError }) : undefined,
+    addError: snapshot.context.error ? errorText(snapshot.context.error, messages.saveError) : undefined,
+    onAdd: onAdd ? () => send({ type: 'ADD', run: onAdd }) : undefined,
     onRename,
     validateName,
     onRemove,
 
@@ -1,11 +1,11 @@
 import { formatRelative } from '@clerk/shared/date';
-import { isClerkAPIResponseError, isClerkRuntimeError } from '@clerk/shared/error';
 import { useClerk, useSession, useUser } from '@clerk/shared/react';
 import type { EnvironmentResource, PasskeyResource, UserResource } from '@clerk/shared/types';
 
 import { FormSubmitError } from '../../../components/form';
 import { getMosaicEnvironment, useMosaicEnvironment } from '../../../hooks/use-mosaic-environment';
-import { fill, useErrorText, useLocale, useMessages } from '../../../localization';
+import { fill, useLocale, useMessages } from '../../../localization';
+import { save, SaveError } from '../../../utils/errors';
 import type {
   UserProfilePasskey,
   UserProfilePasskeyNameValidator,
@@ -87,7 +87,6 @@ export function useUserProfilePasskeysModel(): UserProfilePasskeysModel {
   const environment = useMosaicEnvironment();
   const locale = useLocale();
   const messages = useMessages('userProfilePasskeys');
-  const errorText = useErrorText();
   const validateName: UserProfilePasskeyNameValidator = name =>
     new TextEncoder().encode(name).length > 256 ? { type: 'error', message: messages.nameTooLongError } : undefined;
 
@@ -115,30 +114,13 @@ export function useUserProfilePasskeysModel(): UserProfilePasskeysModel {
       clerk.session?.id !== sessionId ||
       getPasskeysProjection(current, currentEnvironment, clerk.isSatellite).status === 'hidden'
     ) {
-      throw new FormSubmitError({ message: messages.accountUnavailableError });
+      throw new SaveError({
+        global: { code: 'passkey_account_unavailable', message: messages.accountUnavailableError },
+      });
     }
     return current;
   };
 
-  function actionError(error: unknown): Error {
-    if (isClerkAPIResponseError(error)) {
-      const first = error.errors[0];
-      return new Error(
-        errorText({
-          code: first?.code,
-          paramName: first?.meta?.paramName,
-          message: first?.longMessage || first?.message || messages.saveError,
-        }),
-      );
-    }
-    return new Error(
-      errorText({
-        code: isClerkRuntimeError(error) ? error.code : undefined,
-        message: error instanceof Error && error.message ? error.message : messages.saveError,
-      }),
-    );
-  }
-
   function formatPasskeyDate(date: Date): string {
     const relative = formatRelative({ date, relativeTo: new Date() });
     if (!relative) {
@@ -170,13 +152,11 @@ export function useUserProfilePasskeysModel(): UserProfilePasskeysModel {
       ? async () => {
           const current = currentUser();
           if (clerk.isSatellite) {
-            throw new Error(messages.accountUnavailableError);
-          }
-          try {
-            await current.createPasskey();
-          } catch (error) {
-            throw actionError(error);
+            throw new SaveError({
+              global: { code: 'passkey_account_unavailable', message: messages.accountUnavailableError },
+            });
           }
+          await save(() => current.createPasskey());
         }
       : undefined,
     onRename: async (id, name) => {
@@ -188,39 +168,14 @@ export function useUserProfilePasskeysModel(): UserProfilePasskeysModel {
       if (feedback) {
         throw new FormSubmitError<UserProfileRenamePasskeyValues>({ fields: { name: feedback.message } });
       }
-      try {
-        await passkey.update({ name });
-      } catch (error) {
-        if (!isClerkAPIResponseError(error)) {
-          throw new FormSubmitError({ message: actionError(error).message });
-        }
-        const fields: { name?: string } = {};
-        let message: string | undefined;
-        for (const item of error.errors) {
-          const text = errorText({
-            code: item.code,
-            paramName: item.meta?.paramName,
-            message: item.longMessage || item.message || messages.saveError,
-          });
-          if (item.meta?.paramName === 'name') {
-            fields.name ??= text;
-          } else {
-            message ??= text;
-          }
-        }
-        throw new FormSubmitError<UserProfileRenamePasskeyValues>({ message, fields });
-      }
+      await save(() => passkey.update({ name }), ['name']);
     },
     onRemove: async id => {
       const passkey = currentUser().passkeys.find(candidate => candidate.id === id);
       if (!passkey) {
-        throw new Error(messages.unavailableError);
-      }
-      try {
-        await passkey.delete();
-      } catch (error) {
-        throw actionError(error);
+        throw new SaveError({ global: { code: 'passkey_unavailable', message: messages.unavailableError } });
       }
+      await save(() => passkey.delete());
     },
   };
 }