@@ -11,3 +11,4 @@ Fixes for the embedded `<SignIn />` and `<SignUp />` components:
 - When the automatic sign-in after an embedded registration cannot be performed, the reason is reported in the browser console as well as the server log.
 - `<SignUp />` renders `RICH_TEXT` flow components (for example the terms of service text), which were previously dropped, leaving the submit button jammed against the last field.
 - The Next.js `<SignUp />` forwards all remaining props to the underlying form (`showTitle`, `showSubtitle`, `showLogo`, `onComplete`, `onFlowChange`, class names, ...), so for instance `showTitle={false}` now works when a registration flow renders its own heading.
+- After a server-side validation error (for example a rejected password), `<SignUp />` now keeps the values the user entered and the submit button stays enabled, so the user can correct the field and resubmit. Previously the form's validation errors were recorded under keys no input could clear, which left the button disabled permanently. Form validation also runs against the value being typed instead of the previous one.
@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* eslint-disable sort-keys, @typescript-eslint/typedef, @typescript-eslint/explicit-function-return-type, testing-library/no-container, testing-library/no-node-access */
+
+import {act, cleanup, fireEvent, render, waitFor} from '@testing-library/react';
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import BaseSignUp from './BaseSignUp';
+
+const mockColors = {
+  text: {primary: '#000', secondary: '#666'},
+  background: {surface: '#fff', disabled: '#eee', body: {main: '#fff'}},
+  border: '#ccc',
+  action: {
+    hover: '#f0f0f0',
+    active: '#e0e0e0',
+    selected: '#d0d0d0',
+    disabled: '#bbb',
+    disabledBackground: '#f5f5f5',
+    focus: '#0066cc',
+    hoverOpacity: 0.08,
+    selectedOpacity: 0.12,
+    disabledOpacity: 0.38,
+    focusOpacity: 0.12,
+    activatedOpacity: 0.12,
+  },
+  primary: {main: '#0066cc', contrastText: '#fff'},
+  secondary: {main: '#666', contrastText: '#fff'},
+  error: {main: '#d32f2f', contrastText: '#fff'},
+  success: {main: '#2e7d32', contrastText: '#fff'},
+  warning: {main: '#ed6c02', contrastText: '#fff'},
+  info: {main: '#0288d1', contrastText: '#fff'},
+};
+
+const mockTypography = {
+  fontFamily: 'Arial, sans-serif',
+  fontSizes: {xs: '0.75rem', sm: '0.875rem', md: '1rem', lg: '1.125rem', xl: '1.25rem', '2xl': '1.5rem', '3xl': '1.875rem'},
+  fontWeights: {normal: 400, medium: 500, semibold: 600, bold: 700},
+  lineHeights: {tight: 1.25, normal: 1.5, relaxed: 1.75},
+};
+
+const mockTheme = {
+  colors: mockColors,
+  typography: mockTypography,
+  spacing: {unit: 8},
+  borderRadius: {small: '2px', medium: '4px', large: '8px'},
+  shadows: {small: '0 1px 2px rgba(0,0,0,0.1)', medium: '0 2px 4px rgba(0,0,0,0.1)', large: '0 4px 8px rgba(0,0,0,0.1)'},
+  cssVariables: {},
+  vars: {
+    colors: {
+      ...mockColors,
+      action: {...mockColors.action, hoverOpacity: '0.08', selectedOpacity: '0.12', disabledOpacity: '0.38', focusOpacity: '0.12', activatedOpacity: '0.12'},
+    },
+    spacing: {unit: '8px'},
+    borderRadius: {small: '2px', medium: '4px', large: '8px'},
+    shadows: {small: '0 1px 2px rgba(0,0,0,0.1)', medium: '0 2px 4px rgba(0,0,0,0.1)', large: '0 4px 8px rgba(0,0,0,0.1)'},
+    typography: {
+      ...mockTypography,
+      fontWeights: {normal: '400', medium: '500', semibold: '600', bold: '700'},
+      lineHeights: {tight: '1.25', normal: '1.5', relaxed: '1.75'},
+    },
+  },
+};
+
+vi.mock('../../../../../contexts/Theme/useTheme', () => ({
+  default: () => ({theme: mockTheme, colorScheme: 'light', direction: 'ltr'}),
+}));
+
+vi.mock('../../../../../hooks/useTranslation', () => ({
+  default: () => ({t: (key: string) => key, currentLanguage: 'en', setLanguage: vi.fn(), availableLanguages: ['en']}),
+}));
+
+vi.mock('../../../../../contexts/Asgardeo/useAsgardeo', () => ({
+  default: () => ({}),
+}));
+
+/**
+ * The registration step exactly as the identity server returns it: inputs are keyed by `identifier`,
+ * there is no `name` in the config.
+ */
+const registrationStep = (additionalData?: Record<string, unknown>): any => ({
+  flowId: 'flow-1',
+  flowStatus: 'INCOMPLETE',
+  flowType: 'REGISTRATION',
+  type: 'VIEW',
+  data: {
+    ...(additionalData ? {additionalData} : {}),
+    components: [
+      {
+        id: 'form_1',
+        type: 'FORM',
+        components: [
+          {
+            id: 'input_username',
+            type: 'INPUT',
+            variant: 'TEXT',
+            config: {identifier: 'http://wso2.org/claims/username', type: 'text', label: 'Username', required: true},
+          },
+          {
+            id: 'input_password',
+            type: 'INPUT',
+            variant: 'PASSWORD',
+            config: {identifier: 'password', type: 'password', label: 'Password', required: true},
+          },
+          {id: 'button_submit', type: 'BUTTON', variant: 'PRIMARY', config: {type: 'submit', text: 'Continue'}},
+        ],
+      },
+    ],
+  },
+});
+
+const SERVER_ERROR = 'Password does not meet the required format.';
+
+describe('BaseSignUp (v1) after a server-side validation error', () => {
+  afterEach(() => cleanup());
+
+  it('keeps the entered values and lets the user resubmit', async () => {
+    const onSubmit = vi
+      .fn()
+      .mockResolvedValueOnce(registrationStep({error: SERVER_ERROR}))
+      .mockResolvedValueOnce(registrationStep());
+
+    const {container} = render(
+      <BaseSignUp isInitialized onInitialize={vi.fn().mockResolvedValue(registrationStep())} onSubmit={onSubmit} />,
+    );
+
+    const submit = await waitFor(() => {
+      const button = container.querySelector('form button[type="submit"]') as HTMLButtonElement | null;
+      expect(button).not.toBeNull();
+      return button as HTMLButtonElement;
+    });
+    const username = container.querySelector('input[name="http://wso2.org/claims/username"]') as HTMLInputElement;
+    const password = container.querySelector('input[name="password"]') as HTMLInputElement;
+
+    expect(submit.disabled).toBe(false);
+
+    fireEvent.change(username, {target: {value: 'sdk-test@example.com'}});
+    fireEvent.change(password, {target: {value: 'weak'}});
+    await act(async () => {
+      fireEvent.click(submit);
+    });
+
+    // The server rejected the password: the message is shown, the values stay, and the form is still usable.
+    await waitFor(() => expect(container.textContent).toContain(SERVER_ERROR));
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+    expect(onSubmit.mock.calls[0][0].inputs).toEqual({
+      'http://wso2.org/claims/username': 'sdk-test@example.com',
+      password: 'weak',
+    });
+    expect(username.value).toBe('sdk-test@example.com');
+    expect(password.value).toBe('weak');
+    expect(submit.disabled).toBe(false);
+
+    // Correct the password and resubmit.
+    fireEvent.change(password, {target: {value: 'Str0ng!Passw0rd'}});
+    expect(submit.disabled).toBe(false);
+    await act(async () => {
+      fireEvent.click(submit);
+    });
+
+    expect(onSubmit).toHaveBeenCalledTimes(2);
+    expect(onSubmit.mock.calls[1][0].inputs).toEqual({
+      'http://wso2.org/claims/username': 'sdk-test@example.com',
+      password: 'Str0ng!Passw0rd',
+    });
+  });
+
+  it('validates the value being typed, not the previous one', async () => {
+    const {container} = render(
+      <BaseSignUp isInitialized onInitialize={vi.fn().mockResolvedValue(registrationStep())} onSubmit={vi.fn()} />,
+    );
+
+    const username = await waitFor(() => {
+      const input = container.querySelector('input[name="http://wso2.org/claims/username"]') as HTMLInputElement | null;
+      expect(input).not.toBeNull();
+      return input as HTMLInputElement;
+    });
+    const submit = container.querySelector('form button[type="submit"]') as HTMLButtonElement;
+
+    // Emptying a required field must disable submit immediately, and filling it must re-enable it immediately.
+    fireEvent.change(username, {target: {value: 'a'}});
+    fireEvent.change(username, {target: {value: ''}});
+    expect(submit.disabled).toBe(true);
+    expect(container.textContent).toContain('validations.required.field.error');
+
+    fireEvent.change(username, {target: {value: 'sdk-test@example.com'}});
+    expect(submit.disabled).toBe(false);
+    expect(container.textContent).not.toContain('validations.required.field.error');
+  });
+});
@@ -311,20 +311,16 @@ const BaseSignUpContent: FC<BaseSignUpProps> = ({
             const config: any = component.config || {};
             fields.push({
               initialValue: config.defaultValue || '',
-              name: config.name || component.id,
+              // Must match the key the input adapters read/write values under, otherwise validation
+              // errors are recorded for names no input can ever clear and the submit button locks up.
+              name: config.identifier || config.name || component.id,
               required: config.required || false,
+              // Format and policy rules (email syntax, password strength) are enforced by the identity
+              // server, which reports failures in `additionalData.error`; only presence is checked here.
               validator: (value: string) => {
                 if (config.required && (!value || value.trim() === '')) {
                   return t('validations.required.field.error');
                 }
-                // Add email validation if it's an email field
-                if (config.type === 'email' && value && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
-                  return t('field.email.invalid');
-                }
-                // Add password strength validation if it's a password field
-                if (config.type === 'password' && value && value.length < 8) {
-                  return t('field.password.weak');
-                }
                 return null;
               },
             });
@@ -358,6 +354,7 @@ const BaseSignUpContent: FC<BaseSignUpProps> = ({
     errors: formErrors,
     isValid: isFormValid,
     setValue: setFormValue,
+    setValues: setFormValues,
     setTouched: setFormTouched,
     validateForm,
     reset: resetForm,
@@ -376,14 +373,33 @@ const BaseSignUpContent: FC<BaseSignUpProps> = ({
       });
 
       resetForm();
-
-      Object.keys(initialValues).forEach((key: any) => {
-        setFormValue(key, initialValues[key]);
-      });
+      // Populate defaults without running the on-change validation: a freshly rendered step must not
+      // start out with "required" errors that disable the submit button before the user has typed.
+      setFormValues(initialValues);
     },
-    [extractFormFields, resetForm, setFormValue],
+    [extractFormFields, resetForm, setFormValues],
   );
 
+  /**
+   * Whether two flow responses render the same set of input fields (e.g. the same step re-rendered
+   * with a validation error), in which case the values the user already entered are kept.
+   */
+  const rendersSameFields: (a: EmbeddedFlowExecuteResponse | null, b: EmbeddedFlowExecuteResponse) => boolean =
+    useCallback(
+      (a: EmbeddedFlowExecuteResponse | null, b: EmbeddedFlowExecuteResponse): boolean => {
+        const names: (response: EmbeddedFlowExecuteResponse | null) => string = (
+          response: EmbeddedFlowExecuteResponse | null,
+        ): string =>
+          extractFormFields(response?.data?.components || [])
+            .map((field: FormField) => field.name)
+            .sort()
+            .join('|');
+
+        return names(a) === names(b);
+      },
+      [extractFormFields],
+    );
+
   /**
    * Handle input value changes.
    */
@@ -626,8 +642,15 @@ const BaseSignUpContent: FC<BaseSignUpProps> = ({
           return;
         }
 
+        // Keep what the user typed when the same step comes back (typically with a validation error),
+        // so they can correct a single field instead of filling in the whole form again.
+        const sameStep: boolean = rendersSameFields(currentFlow, response);
+
         setCurrentFlow(response);
-        setupFormFields(response);
+
+        if (!sameStep) {
+          setupFormFields(response);
+        }
 
         // Surface server-side validation failures (e.g. password policy) that arrive with an INCOMPLETE flow.
         const flowError: unknown = response.data?.additionalData?.['error'];