diff --git a/.yarn/install-state.gz b/.yarn/install-state.gz
index d160bd8c6..1c08c80d5 100644
Binary files a/.yarn/install-state.gz and b/.yarn/install-state.gz differ
diff --git a/PingSampleApp/ios/Podfile.lock b/PingSampleApp/ios/Podfile.lock
index 550a069e3..de6edbef4 100644
--- a/PingSampleApp/ios/Podfile.lock
+++ b/PingSampleApp/ios/Podfile.lock
@@ -228,6 +228,11 @@ PODS:
     - PingBrowser (~> 2.1.0)
     - PingCommons (~> 2.1.0)
     - PingOrchestrate (~> 2.1.0)
+  - PingOneProtect (2.1.0):
+    - PingDavinciPlugin (~> 2.1.0)
+    - PingJourneyPlugin (~> 2.1.0)
+    - PingOneSignals (~> 5.4.0)
+  - PingOneSignals (5.4.0)
   - PingOrchestrate (2.1.0):
     - PingNetwork (~> 2.1.0)
     - PingStorage (~> 2.1.0)
@@ -2925,6 +2930,37 @@ PODS:
     - RNPingCore
     - SocketRocket
     - Yoga
+  - RNPingProtect (1.0.0):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - PingOneProtect (= 2.1.0)
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-ImageManager
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFabric
+    - React-renderercss
+    - React-rendererdebug
+    - React-utils
+    - ReactCodegen
+    - ReactCommon/turbomodule/bridging
+    - ReactCommon/turbomodule/core
+    - RNPingCore
+    - SocketRocket
+    - Yoga
   - RNPingPush (1.0.0):
     - boost
     - DoubleConversion
@@ -3302,6 +3338,7 @@ DEPENDENCIES:
   - "RNPingLogger (from `../../node_modules/@ping-identity/rn-logger`)"
   - "RNPingOath (from `../../node_modules/@ping-identity/rn-oath`)"
   - "RNPingOidc (from `../../node_modules/@ping-identity/rn-oidc`)"
+  - "RNPingProtect (from `../../node_modules/@ping-identity/rn-protect`)"
   - "RNPingPush (from `../../node_modules/@ping-identity/rn-push`)"
   - "RNPingStorage (from `../../node_modules/@ping-identity/rn-storage`)"
   - RNScreens (from `../../node_modules/react-native-screens`)
@@ -3351,6 +3388,8 @@ SPEC REPOS:
     - PingNetwork
     - PingOath
     - PingOidc
+    - PingOneProtect
+    - PingOneSignals
     - PingOrchestrate
     - PingPush
     - PingStorage
@@ -3540,6 +3579,8 @@ EXTERNAL SOURCES:
     :path: "../../node_modules/@ping-identity/rn-oath"
   RNPingOidc:
     :path: "../../node_modules/@ping-identity/rn-oidc"
+  RNPingProtect:
+    :path: "../../node_modules/@ping-identity/rn-protect"
   RNPingPush:
     :path: "../../node_modules/@ping-identity/rn-push"
   RNPingStorage:
@@ -3604,6 +3645,8 @@ SPEC CHECKSUMS:
   PingNetwork: 97b4a783caca3ff9382ecbfe2b6da1cff10ed647
   PingOath: 34d6c81f32c87a4f568fceb48b531cd1be3e9464
   PingOidc: e6d28c4d8c130691872d6aa3b12a1ef498567957
+  PingOneProtect: 4ced7b27c9e26d1ea9b8d29775121efd738d9000
+  PingOneSignals: 3d14d429201435960e062e3481356b9f21fa657f
   PingOrchestrate: 90365995dc6fc5bd14f78ae5c04f07d46d265523
   PingPush: aef2216cade878592b6c7166a90d8b15f1c0b649
   PingStorage: fdaebdd80f4359dc7eb4f780429cc6840ed01cee
@@ -3691,6 +3734,7 @@ SPEC CHECKSUMS:
   RNPingLogger: b7dd73f42b3fea86a56fc7a35999cf4333fbde20
   RNPingOath: 261b44b957975c0c036b1bed6ef953c4767b8fcc
   RNPingOidc: d490892cb09a11c189b2259bca0fecfc09a109fd
+  RNPingProtect: cbfd801e3ce9b326dd190772ff1ba16735d4fe78
   RNPingPush: 3f02ee0f3d971c0d8affdb13b8fcefc4de789de1
   RNPingStorage: 2c45c6d29cfcf8e1ed8ec3e32df1443e29dabd67
   RNScreens: 846d53087db560ed5fbc34feb0643adb5f9602c5
diff --git a/PingSampleApp/ui/davinci/components/atoms/DaVinciErrorList.tsx b/PingSampleApp/ui/davinci/components/atoms/DaVinciErrorList.tsx
index 44f62d24f..fa5440a69 100644
--- a/PingSampleApp/ui/davinci/components/atoms/DaVinciErrorList.tsx
+++ b/PingSampleApp/ui/davinci/components/atoms/DaVinciErrorList.tsx
@@ -27,10 +27,20 @@ export type DaVinciErrorListProps = {
  * @returns User-facing message.
  */
 function describeError(error: DaVinciFieldValidationError): string {
-  if (error.code === 'REQUIRED') {
-    return 'This field is required.';
+  switch (error.code) {
+    case 'REQUIRED':
+      return 'This field is required.';
+    case 'REGEX_ERROR':
+      return error.message;
+    case 'INVALID_LENGTH':
+      return `Password must be between ${error.min} and ${error.max} characters.`;
+    case 'UNIQUE_CHARACTER':
+      return `Password must contain at least ${error.min} unique characters.`;
+    case 'MAX_REPEAT':
+      return `Password cannot repeat a character more than ${error.max} times.`;
+    case 'MIN_CHARACTERS':
+      return `Password must contain at least ${error.min} ${error.character} characters.`;
   }
-  return error.message;
 }
 
 /**
diff --git a/PingSampleApp/ui/davinci/components/molecules/DaVinciLabelField.tsx b/PingSampleApp/ui/davinci/components/molecules/DaVinciLabelField.tsx
index 696b8278c..e4d9dc018 100644
--- a/PingSampleApp/ui/davinci/components/molecules/DaVinciLabelField.tsx
+++ b/PingSampleApp/ui/davinci/components/molecules/DaVinciLabelField.tsx
@@ -6,9 +6,10 @@
  */
 
 import React from 'react';
-import { Text, View } from 'react-native';
+import { View } from 'react-native';
 import type { LabelCollector } from '@ping-identity/rn-davinci';
 import { davinciFieldStyles } from '../../../../src/styles/davinciStyles';
+import RichTextLabel from './RichTextLabel';
 import type { DaVinciCollectorRendererProps } from './types';
 
 /**
@@ -24,9 +25,11 @@ export default function DaVinciLabelField(
   const labelCollector = collector as LabelCollector;
   return (
     <View style={davinciFieldStyles.card}>
-      <Text style={davinciFieldStyles.labelContent}>
-        {labelCollector.content}
-      </Text>
+      <RichTextLabel
+        text={labelCollector.content}
+        richContent={labelCollector.richContent}
+        style={davinciFieldStyles.labelContent}
+      />
     </View>
   );
 }
diff --git a/PingSampleApp/ui/davinci/components/molecules/DaVinciPasswordField.tsx b/PingSampleApp/ui/davinci/components/molecules/DaVinciPasswordField.tsx
index 619aa9e9a..facf607ad 100644
--- a/PingSampleApp/ui/davinci/components/molecules/DaVinciPasswordField.tsx
+++ b/PingSampleApp/ui/davinci/components/molecules/DaVinciPasswordField.tsx
@@ -5,9 +5,12 @@
  * of the MIT license. See the LICENSE file for details.
  */
 
-import React from 'react';
+import React, { useState } from 'react';
 import { View } from 'react-native';
-import type { PasswordCollector } from '@ping-identity/rn-davinci';
+import type {
+  DaVinciFieldValidationError,
+  PasswordCollector,
+} from '@ping-identity/rn-davinci';
 import PingTextInput from '../../../components/atoms/PingTextInput';
 import DaVinciErrorList from '../atoms/DaVinciErrorList';
 import DaVinciPasswordRequirements from './DaVinciPasswordRequirements';
@@ -23,7 +26,10 @@ import type { DaVinciCollectorRendererProps } from './types';
 export default function DaVinciPasswordField(
   props: DaVinciCollectorRendererProps,
 ): React.ReactElement {
-  const { collector, value, onChange } = props;
+  const { collector, value, onChange, onValidate } = props;
+  const [manualErrors, setManualErrors] = useState<
+    DaVinciFieldValidationError[] | null
+  >(null);
   const passwordCollector = collector as PasswordCollector;
   const stringValue = typeof value === 'string' ? value : '';
 
@@ -36,7 +42,17 @@ export default function DaVinciPasswordField(
             : passwordCollector.label
         }
         value={stringValue}
-        onChangeText={onChange}
+        onChangeText={value => {
+          setManualErrors(null);
+          onChange(value);
+        }}
+        onBlur={() => {
+          onValidate(collector.key, stringValue)
+            .then(setManualErrors)
+            .catch(error => {
+              console.warn('[DaVinci] Password validation failed:', error);
+            });
+        }}
         secureTextEntry
         allowPasswordToggle
         autoCapitalize="none"
@@ -48,7 +64,7 @@ export default function DaVinciPasswordField(
           value={stringValue}
         />
       ) : null}
-      <DaVinciErrorList />
+      <DaVinciErrorList errors={manualErrors ?? undefined} />
     </View>
   );
 }
diff --git a/PingSampleApp/ui/davinci/components/molecules/DaVinciPhoneNumberField.tsx b/PingSampleApp/ui/davinci/components/molecules/DaVinciPhoneNumberField.tsx
index 6ca59ccc5..c183b7310 100644
--- a/PingSampleApp/ui/davinci/components/molecules/DaVinciPhoneNumberField.tsx
+++ b/PingSampleApp/ui/davinci/components/molecules/DaVinciPhoneNumberField.tsx
@@ -7,8 +7,12 @@
 
 import React, { useState } from 'react';
 import { View } from 'react-native';
-import type { PhoneNumberCollector } from '@ping-identity/rn-davinci';
+import type {
+  DaVinciFieldValidationError,
+  PhoneNumberCollector,
+} from '@ping-identity/rn-davinci';
 import PingTextInput from '../../../components/atoms/PingTextInput';
+import DaVinciErrorList from '../atoms/DaVinciErrorList';
 import DaVinciFieldLabel from '../atoms/DaVinciFieldLabel';
 import PickerModal from '../atoms/PickerModal';
 import { davinciFieldStyles } from '../../../../src/styles/davinciStyles';
@@ -67,7 +71,7 @@ function countryCodeForDialCode(dialCode: string): string | undefined {
 function resolveValue(
   value: unknown,
   collector: PhoneNumberCollector,
-): { countryCode: string; phoneNumber: string } {
+): { countryCode: string; phoneNumber: string; extension: string } {
   let rawCode =
     value &&
     typeof value === 'object' &&
@@ -89,7 +93,15 @@ function resolveValue(
       ? (value as { phoneNumber: string }).phoneNumber
       : (collector.phoneNumber ?? '');
 
-  return { countryCode: rawCode, phoneNumber };
+  const extension =
+    value &&
+    typeof value === 'object' &&
+    'extension' in value &&
+    typeof (value as { extension: unknown }).extension === 'string'
+      ? (value as { extension: string }).extension
+      : (collector.extension ?? '');
+
+  return { countryCode: rawCode, phoneNumber, extension };
 }
 
 /**
@@ -123,11 +135,14 @@ function triggerLabel(isoCode: string): string {
 export default function DaVinciPhoneNumberField(
   props: DaVinciCollectorRendererProps,
 ): React.ReactElement {
-  const { collector, value, onChange } = props;
+  const { collector, value, onChange, onValidate } = props;
   const phoneCollector = collector as PhoneNumberCollector;
   const current = resolveValue(value, phoneCollector);
 
   const [modalVisible, setModalVisible] = useState(false);
+  const [manualErrors, setManualErrors] = useState<
+    DaVinciFieldValidationError[] | null
+  >(null);
 
   const pickerOptions = COUNTRIES.map(c => ({
     value: c.countryCode,
@@ -150,29 +165,59 @@ export default function DaVinciPhoneNumberField(
             visible={modalVisible}
             onOpen={() => setModalVisible(true)}
             onClose={() => setModalVisible(false)}
-            onSelect={isoCode =>
+            onSelect={isoCode => {
+              setManualErrors(null);
               onChange({
                 countryCode: isoCode,
                 phoneNumber: current.phoneNumber,
-              })
-            }
+                extension: current.extension,
+              });
+            }}
           />
         </View>
         <View style={davinciFieldStyles.phoneNumber}>
           <PingTextInput
             label="Phone number"
             value={current.phoneNumber}
-            onChangeText={text =>
+            onChangeText={text => {
+              setManualErrors(null);
               onChange({
                 countryCode: current.countryCode,
                 phoneNumber: text,
-              })
-            }
+                extension: current.extension,
+              });
+            }}
+            onBlur={() => {
+              onValidate(collector.key, current.phoneNumber)
+                .then(setManualErrors)
+                .catch(error => {
+                  console.warn(
+                    '[DaVinci] Phone number validation failed:',
+                    error,
+                  );
+                });
+            }}
             keyboardType="phone-pad"
             containerStyle={{ marginBottom: 0 }}
           />
         </View>
       </View>
+      {phoneCollector.showExtension ? (
+        <PingTextInput
+          label={phoneCollector.extensionLabel}
+          value={current.extension}
+          onChangeText={extension => {
+            setManualErrors(null);
+            onChange({
+              countryCode: current.countryCode,
+              phoneNumber: current.phoneNumber,
+              extension,
+            });
+          }}
+          keyboardType="phone-pad"
+        />
+      ) : null}
+      <DaVinciErrorList errors={manualErrors ?? undefined} />
     </View>
   );
 }
diff --git a/PingSampleApp/ui/davinci/components/molecules/DaVinciTextField.tsx b/PingSampleApp/ui/davinci/components/molecules/DaVinciTextField.tsx
index b719ad2d0..ff7f5f4e4 100644
--- a/PingSampleApp/ui/davinci/components/molecules/DaVinciTextField.tsx
+++ b/PingSampleApp/ui/davinci/components/molecules/DaVinciTextField.tsx
@@ -5,9 +5,12 @@
  * of the MIT license. See the LICENSE file for details.
  */
 
-import React from 'react';
+import React, { useState } from 'react';
 import { View } from 'react-native';
-import type { TextCollector } from '@ping-identity/rn-davinci';
+import type {
+  DaVinciFieldValidationError,
+  TextCollector,
+} from '@ping-identity/rn-davinci';
 import PingTextInput from '../../../components/atoms/PingTextInput';
 import DaVinciErrorList from '../atoms/DaVinciErrorList';
 import { davinciFieldStyles } from '../../../../src/styles/davinciStyles';
@@ -22,7 +25,10 @@ import type { DaVinciCollectorRendererProps } from './types';
 export default function DaVinciTextField(
   props: DaVinciCollectorRendererProps,
 ): React.ReactElement {
-  const { collector, value, onChange } = props;
+  const { collector, value, onChange, onValidate } = props;
+  const [manualErrors, setManualErrors] = useState<
+    DaVinciFieldValidationError[] | null
+  >(null);
   const textCollector = collector as TextCollector;
   const stringValue = typeof value === 'string' ? value : textCollector.value;
   const isMultiline = stringValue.length > 60;
@@ -36,12 +42,22 @@ export default function DaVinciTextField(
             : textCollector.label
         }
         value={stringValue}
-        onChangeText={onChange}
+        onChangeText={value => {
+          setManualErrors(null);
+          onChange(value);
+        }}
+        onBlur={() => {
+          onValidate(collector.key, stringValue)
+            .then(setManualErrors)
+            .catch(error => {
+              console.warn('[DaVinci] Text validation failed:', error);
+            });
+        }}
         autoCapitalize="none"
         autoCorrect={false}
         multiline={isMultiline}
       />
-      <DaVinciErrorList errors={textCollector.validation?.errors} />
+      <DaVinciErrorList errors={manualErrors ?? undefined} />
     </View>
   );
 }
diff --git a/PingSampleApp/ui/davinci/components/molecules/types.ts b/PingSampleApp/ui/davinci/components/molecules/types.ts
index 087b16248..2e0210f08 100644
--- a/PingSampleApp/ui/davinci/components/molecules/types.ts
+++ b/PingSampleApp/ui/davinci/components/molecules/types.ts
@@ -6,6 +6,7 @@
  */
 
 import type {
+  DaVinciFieldValidationError,
   DaVinciFormValue,
   DaVinciNormalizedCollector,
   IdpCollector,
@@ -35,6 +36,17 @@ export type DaVinciCollectorRendererProps = {
    * Submits the current form. Used by submit buttons and flow links.
    */
   onSubmit: () => void;
+  /**
+   * Validates the current value for a collector.
+   *
+   * @param collectorKey Collector key to validate.
+   * @param value Current rendered value for the collector.
+   * @returns Validation errors for the collector.
+   */
+  onValidate: (
+    collectorKey: string,
+    value: DaVinciFormValue,
+  ) => Promise<DaVinciFieldValidationError[]>;
   /**
    * Immediately advances the flow using a specific {@link FlowCollector} key.
    *
diff --git a/PingSampleApp/ui/davinci/components/organisms/DaVinciClientPanel.tsx b/PingSampleApp/ui/davinci/components/organisms/DaVinciClientPanel.tsx
index a54cee18f..291486db2 100644
--- a/PingSampleApp/ui/davinci/components/organisms/DaVinciClientPanel.tsx
+++ b/PingSampleApp/ui/davinci/components/organisms/DaVinciClientPanel.tsx
@@ -59,6 +59,7 @@ export default function DaVinciClientPanel(
     hasActiveSession,
     isSessionCheckRunning,
     onSubmit,
+    onValidate,
     onFlowAction,
     onIdpAuthorize,
     onPollStatus,
@@ -75,6 +76,7 @@ export default function DaVinciClientPanel(
             form={form}
             loading={loading}
             onSubmit={onSubmit}
+            onValidate={onValidate}
             onFlowAction={onFlowAction}
             onIdpAuthorize={onIdpAuthorize}
             onPollStatus={onPollStatus}
diff --git a/PingSampleApp/ui/davinci/components/organisms/DaVinciContinueNodePanel.tsx b/PingSampleApp/ui/davinci/components/organisms/DaVinciContinueNodePanel.tsx
index f18b64c06..bfe7aaae5 100644
--- a/PingSampleApp/ui/davinci/components/organisms/DaVinciContinueNodePanel.tsx
+++ b/PingSampleApp/ui/davinci/components/organisms/DaVinciContinueNodePanel.tsx
@@ -16,6 +16,8 @@ import type {
   PollingCollector,
   PollingStatus,
   UnsupportedDaVinciField,
+  DaVinciFormValue,
+  DaVinciFieldValidationError,
 } from '@ping-identity/rn-davinci';
 import { commonStyles } from '../../../../src/styles/common';
 import { colors } from '../../../../src/styles/colors';
@@ -43,6 +45,17 @@ export type DaVinciContinueNodePanelProps = {
    * Submits the current form by calling `next` with the planned payload.
    */
   onSubmit: () => void;
+  /**
+   * Validates the current value for a collector.
+   *
+   * @param collectorKey Collector key to validate.
+   * @param value Current rendered value for the collector.
+   * @returns Validation errors for the collector.
+   */
+  onValidate: (
+    collectorKey: string,
+    value: DaVinciFormValue,
+  ) => Promise<DaVinciFieldValidationError[]>;
   /**
    * Submits a flow collector (`SUBMIT_BUTTON`, `ACTION`, `FLOW_BUTTON`,
    * `FLOW_LINK`) by key.
@@ -165,6 +178,7 @@ export default function DaVinciContinueNodePanel(
     form,
     loading,
     onSubmit,
+    onValidate,
     onFlowAction,
     onIdpAuthorize,
     onPollStatus,
@@ -195,6 +209,7 @@ export default function DaVinciContinueNodePanel(
           collector={collector}
           value={values[collector.key]}
           onChange={next => setValue(collector.key, next)}
+          onValidate={onValidate}
           onSubmit={onSubmit}
           onFlowAction={onFlowAction}
           onIdpAuthorize={onIdpAuthorize}
diff --git a/PingSampleApp/ui/davinci/hooks/useDaVinciClientPanelController.ts b/PingSampleApp/ui/davinci/hooks/useDaVinciClientPanelController.ts
index 75dc63d9c..1f37dc387 100644
--- a/PingSampleApp/ui/davinci/hooks/useDaVinciClientPanelController.ts
+++ b/PingSampleApp/ui/davinci/hooks/useDaVinciClientPanelController.ts
@@ -11,7 +11,9 @@ import {
   useDaVinciContext,
   useDaVinciForm,
   type DaVinciError,
+  type DaVinciFieldValidationError,
   type DaVinciFormResult,
+  type DaVinciFormValue,
   type DaVinciNode,
   type IdpCollector,
   type PollingCollector,
@@ -49,6 +51,17 @@ export type UseDaVinciClientPanelControllerResult = {
    * Submits the current form by calling `next` with the planned payload.
    */
   onSubmit: () => void;
+  /**
+   * Validates the current value for a collector.
+   *
+   * @param collectorKey Collector key to validate.
+   * @param value Current rendered value for the collector.
+   * @returns Validation errors for the collector.
+   */
+  onValidate: (
+    collectorKey: string,
+    value: DaVinciFormValue,
+  ) => Promise<DaVinciFieldValidationError[]>;
   /**
    * Submits a flow collector (`SUBMIT_BUTTON`, `ACTION`, `FLOW_BUTTON`,
    * `FLOW_LINK`) by key.
@@ -113,8 +126,17 @@ export function useDaVinciClientPanelController(
 ): UseDaVinciClientPanelControllerResult {
   const { onAuthenticated } = options;
   const davinciContext = useDaVinciContext();
-  const { node, loading, error, start, next, user, logoutUser, pollStatus } =
-    useDaVinci();
+  const {
+    node,
+    loading,
+    error,
+    start,
+    next,
+    validate,
+    user,
+    logoutUser,
+    pollStatus,
+  } = useDaVinci();
   const externalIdpLogger = useMemo(() => logger({ level: 'debug' }), []);
   const externalIdp = useMemo(
     () =>
@@ -209,6 +231,14 @@ export function useDaVinciClientPanelController(
       });
   }, [form, loading, next, onProtectCollect]);
 
+  const onValidate = useCallback(
+    (
+      collectorKey: string,
+      value: DaVinciFormValue,
+    ): Promise<DaVinciFieldValidationError[]> => validate(collectorKey, value),
+    [validate],
+  );
+
   const onIdpAuthorize = useCallback(
     async (collector: IdpCollector): Promise<void> => {
       if (loading) {
@@ -305,6 +335,7 @@ export function useDaVinciClientPanelController(
     hasActiveSession,
     isSessionCheckRunning,
     onSubmit,
+    onValidate,
     onFlowAction,
     onIdpAuthorize,
     onPollStatus,
diff --git a/PingTestRunner/__tests__/integration/davinci.test.ts b/PingTestRunner/__tests__/integration/davinci.test.ts
index 9379866a5..a96dd2b1e 100644
--- a/PingTestRunner/__tests__/integration/davinci.test.ts
+++ b/PingTestRunner/__tests__/integration/davinci.test.ts
@@ -25,6 +25,7 @@ type NativeDaVinciMock = {
   configureDaVinci: jest.Mock;
   start: jest.Mock;
   next: jest.Mock;
+  validate: jest.Mock;
   getSession: jest.Mock;
   refresh: jest.Mock;
   revoke: jest.Mock;
@@ -67,6 +68,7 @@ function makeMock(
       type: 'SuccessNode',
       session: { value: 'session-token' },
     })),
+    validate: jest.fn(async () => []),
     getSession: jest.fn(async () => ({ accessToken: 'mock-access-token' })),
     refresh: jest.fn(async () => ({ accessToken: 'mock-refreshed-token' })),
     revoke: jest.fn(async () => true),
@@ -203,6 +205,7 @@ describe('@ping-identity/rn-davinci — integration', () => {
       const methods = [
         'start',
         'next',
+        'validate',
         'user',
         'refresh',
         'revoke',
@@ -262,6 +265,34 @@ describe('@ping-identity/rn-davinci — integration', () => {
       expect(mock.next).toHaveBeenCalledWith('davinci-id-mock', input);
     });
 
+    it('validate() forwards a single-entry collector payload to native', async () => {
+      const mock = makeMock();
+      const mod = await loadDaVinci(mock);
+      const client = mod.createDaVinciClient(VALID_CONFIG);
+      await client.start();
+      const errors = await client.validate('username', 'alice');
+      expect(errors).toEqual([]);
+      expect(mock.validate).toHaveBeenCalledTimes(1);
+      expect(mock.validate).toHaveBeenCalledWith(
+        'davinci-id-mock',
+        'username',
+        {
+          collectors: [{ key: 'username', value: 'alice' }],
+        },
+      );
+    });
+
+    it('validate() resolves with the validation errors returned by native', async () => {
+      const mock = makeMock({
+        validate: jest.fn(async () => [{ code: 'REQUIRED' }]),
+      });
+      const mod = await loadDaVinci(mock);
+      const client = mod.createDaVinciClient(VALID_CONFIG);
+      await client.start();
+      const errors = await client.validate('username', '');
+      expect(errors).toEqual([{ code: 'REQUIRED' }]);
+    });
+
     it('user() resolves with the active session', async () => {
       const mock = makeMock();
       const mod = await loadDaVinci(mock);
@@ -376,6 +407,22 @@ describe('@ping-identity/rn-davinci — integration', () => {
         name: 'DaVinciError',
       });
     });
+
+    it('validate() propagates native errors as DaVinciError', async () => {
+      const mock = makeMock({
+        validate: jest.fn(async () => {
+          throw new Error('validate failed');
+        }),
+      });
+      const mod = await loadDaVinci(mock);
+      const client = mod.createDaVinciClient(VALID_CONFIG);
+      await client.start();
+      await expect(
+        client.validate('does-not-exist', 'value'),
+      ).rejects.toMatchObject({
+        name: 'DaVinciError',
+      });
+    });
   });
 
   describe('normalizeCollectors()', () => {
@@ -477,7 +524,85 @@ describe('@ping-identity/rn-davinci — integration', () => {
       ]);
     });
 
-    it('PASSWORD — round-trips a string value and surfaces passwordPolicy', async () => {
+    it('SINGLE_CHECKBOX — preserves metadata and round-trips a boolean', async () => {
+      const richContent = {
+        content: 'I agree to the {terms}.',
+        replacements: {
+          terms: {
+            value: 'terms',
+            href: 'https://example.com/terms',
+            type: 'link',
+            target: '_blank',
+          },
+        },
+      };
+      const mod = await loadDaVinci(
+        makeMock({
+          start: jest.fn(async () => ({
+            type: 'ContinueNode',
+            collectors: [
+              {
+                key: 'terms',
+                type: 'SINGLE_CHECKBOX',
+                label: 'Agree to terms',
+                required: true,
+                value: false,
+                appearance: 'CHECKBOX',
+                errorMessage: 'Agreement is required.',
+                richContent,
+                errors: [{ code: 'REQUIRED' }],
+              },
+            ],
+          })),
+        }),
+      );
+      const client = mod.createDaVinciClient(VALID_CONFIG);
+      const node = await client.start();
+      const collectors = mod.normalizeCollectors(node.collectors);
+      expect(collectors[0]).toMatchObject({
+        kind: 'boolean',
+        appearance: 'CHECKBOX',
+        richContent,
+        errors: [{ code: 'REQUIRED' }],
+        errorMessage: 'Agreement is required.',
+      });
+      const plan = mod.buildNextInput(node, { terms: true });
+      expect(plan.input.collectors).toEqual([{ key: 'terms', value: true }]);
+    });
+
+    it('READ_ONLY_TEXT — preserves content and excludes it from payload', async () => {
+      const mod = await loadDaVinci(
+        makeMock({
+          start: jest.fn(async () => ({
+            type: 'ContinueNode',
+            collectors: [
+              {
+                key: 'agreement',
+                type: 'READ_ONLY_TEXT',
+                content: 'Review this agreement.',
+                title: 'Agreement',
+                titleEnabled: true,
+                enabled: true,
+                agreementId: 'agreement-id',
+                useDynamicAgreement: false,
+              },
+            ],
+          })),
+        }),
+      );
+      const client = mod.createDaVinciClient(VALID_CONFIG);
+      const node = await client.start();
+      const collectors = mod.normalizeCollectors(node.collectors);
+      expect(collectors[0]).toMatchObject({
+        type: 'READ_ONLY_TEXT',
+        kind: 'output',
+        content: 'Review this agreement.',
+        title: 'Agreement',
+      });
+      expect(mod.buildNextInput(node, {}).input.collectors).toEqual([]);
+    });
+
+    it('PASSWORD — preserves validation and round-trips a string value', async () => {
       const policy = {
         name: 'Default',
         description: 'Default policy',
@@ -507,6 +632,7 @@ describe('@ping-identity/rn-davinci — integration', () => {
                 required: true,
                 value: '',
                 clearPassword: true,
+                validation: { regex: '^.{8,}$' },
                 passwordPolicy: policy,
               },
             ],
@@ -519,6 +645,7 @@ describe('@ping-identity/rn-davinci — integration', () => {
       expect(collectors[0]).toMatchObject({
         type: 'PASSWORD',
         clearPassword: true,
+        validation: { regex: '^.{8,}$' },
         passwordPolicy: policy,
       });
       const plan = mod.buildNextInput(node, { password: 's3cret' });
@@ -595,13 +722,29 @@ describe('@ping-identity/rn-davinci — integration', () => {
       ]);
     });
 
-    it('LABEL — output_only and excluded from the payload', async () => {
+    it('LABEL — preserves richContent and excludes it from the payload', async () => {
+      const richContent = {
+        content: 'Welcome {name}!',
+        replacements: {
+          name: {
+            value: 'back',
+            href: '',
+            type: 'text',
+            target: '',
+          },
+        },
+      };
       const mod = await loadDaVinci(
         makeMock({
           start: jest.fn(async () => ({
             type: 'ContinueNode',
             collectors: [
-              { key: 'banner', type: 'LABEL', content: 'Welcome back!' },
+              {
+                key: 'banner',
+                type: 'LABEL',
+                content: 'Welcome back!',
+                richContent,
+              },
             ],
           })),
         }),
@@ -612,6 +755,7 @@ describe('@ping-identity/rn-davinci — integration', () => {
       expect(collectors[0]).toMatchObject({
         type: 'LABEL',
         content: 'Welcome back!',
+        richContent,
         executionMode: 'output_only',
       });
       const plan = mod.buildNextInput(node, {});
@@ -684,7 +828,7 @@ describe('@ping-identity/rn-davinci — integration', () => {
       ]);
     });
 
-    it('PHONE_NUMBER — round-trips { countryCode, phoneNumber }', async () => {
+    it('PHONE_NUMBER — round-trips { countryCode, phoneNumber, extension }', async () => {
       const mod = await loadDaVinci(
         makeMock({
           start: jest.fn(async () => ({
@@ -699,6 +843,9 @@ describe('@ping-identity/rn-davinci — integration', () => {
                 validatePhoneNumber: true,
                 countryCode: 'US',
                 phoneNumber: '',
+                extension: '',
+                showExtension: true,
+                extensionLabel: 'Extension',
               },
             ],
           })),
@@ -710,14 +857,24 @@ describe('@ping-identity/rn-davinci — integration', () => {
       expect(collectors[0]).toMatchObject({
         defaultCountryCode: 'US',
         validatePhoneNumber: true,
+        showExtension: true,
+        extensionLabel: 'Extension',
       });
       const plan = mod.buildNextInput(node, {
-        phone: { countryCode: 'GB', phoneNumber: '+447700900123' },
+        phone: {
+          countryCode: 'GB',
+          phoneNumber: '+447700900123',
+          extension: '123',
+        },
       });
       expect(plan.input.collectors).toEqual([
         {
           key: 'phone',
-          value: { countryCode: 'GB', phoneNumber: '+447700900123' },
+          value: {
+            countryCode: 'GB',
+            phoneNumber: '+447700900123',
+            extension: '123',
+          },
         },
       ]);
     });
diff --git a/PingTestRunner/__tests__/integration/native-spec-contracts.test.ts b/PingTestRunner/__tests__/integration/native-spec-contracts.test.ts
index dbf6f0ddf..973919825 100644
--- a/PingTestRunner/__tests__/integration/native-spec-contracts.test.ts
+++ b/PingTestRunner/__tests__/integration/native-spec-contracts.test.ts
@@ -62,22 +62,23 @@ type _BrowserMockedMethods = Pick<BrowserSpec, 'configure' | 'reset' | 'open'>;
 type _DeviceClientMockedMethods = Pick<
   DeviceClientSpec,
   'create' | 'get' | 'update' | 'deleteDevice' | 'dispose'
-  >;
+>;
 // ─── rn-davinci ─────────────────────────────────────────────────────────────
-// jest.setup.js mocks: configureDaVinci, start, next, getSession, refresh,
-//                      revoke, userinfo, logout, dispose
+// jest.setup.js mocks: configureDaVinci, start, next, validate, getSession,
+//                      refresh, revoke, userinfo, logout, dispose
 type _DaVinciMockedMethods = Pick<
   DaVinciSpec,
   | 'configureDaVinci'
   | 'start'
   | 'next'
+  | 'validate'
   | 'getSession'
   | 'refresh'
   | 'revoke'
   | 'userinfo'
   | 'logout'
   | 'dispose'
-  >;
+>;
 
 // ─── rn-device-id ───────────────────────────────────────────────────────────
 // jest.setup.js mocks: getDefaultDeviceId
diff --git a/PingTestRunner/jest.setup.js b/PingTestRunner/jest.setup.js
index 28d7573eb..863465ff9 100644
--- a/PingTestRunner/jest.setup.js
+++ b/PingTestRunner/jest.setup.js
@@ -112,6 +112,13 @@ jest.mock('../packages/davinci/src/NativeRNPingDavinci', () => {
         assertActive('next', id);
         return { type: 'SuccessNode', session: { value: 'session-mock' } };
       }),
+      // Joins the global mock rather than following pollDaVinci's per-test
+      // precedent: validate is exercised broadly (scenario wiring, other
+      // integration suites), matching the majority of methods here.
+      validate: jest.fn(async (id) => {
+        assertActive('validate', id);
+        return [];
+      }),
       getSession: jest.fn(async (id) => {
         assertActive('getSession', id);
         return { accessToken: 'mock-access-token' };
diff --git a/PingTestRunner/scenarios/DaVinciScenario.tsx b/PingTestRunner/scenarios/DaVinciScenario.tsx
index d1493bfbf..8abb940d5 100644
--- a/PingTestRunner/scenarios/DaVinciScenario.tsx
+++ b/PingTestRunner/scenarios/DaVinciScenario.tsx
@@ -361,6 +361,27 @@ function CollectorField({
     );
   }
 
+  if (collector.type === 'SINGLE_CHECKBOX') {
+    return (
+      <Switch
+        testID={testID}
+        value={typeof value === 'boolean' ? value : collector.value}
+        onValueChange={onValueChange}
+      />
+    );
+  }
+
+  if (collector.type === 'READ_ONLY_TEXT') {
+    return (
+      <Text testID={testID}>
+        {collector.titleEnabled && collector.title
+          ? `${collector.title}\n`
+          : ''}
+        {collector.content}
+      </Text>
+    );
+  }
+
   if (collector.type === 'SUBMIT_BUTTON') {
     return (
       <Button
@@ -459,8 +480,9 @@ function CollectorField({
 
   if (collector.type === 'PHONE_NUMBER') {
     const phone =
-      (value as { countryCode?: string; phoneNumber?: string } | undefined) ??
-      {};
+      (value as
+        | { countryCode?: string; phoneNumber?: string; extension?: string }
+        | undefined) ?? {};
     return (
       <View testID={testID}>
         <TextInput
@@ -470,6 +492,7 @@ function CollectorField({
             onValueChange({
               countryCode: t,
               phoneNumber: phone.phoneNumber ?? '',
+              extension: phone.extension ?? collector.extension ?? '',
             })
           }
           placeholder="Country code"
@@ -482,6 +505,7 @@ function CollectorField({
             onValueChange({
               countryCode: phone.countryCode ?? collector.countryCode ?? '',
               phoneNumber: t,
+              extension: phone.extension ?? collector.extension ?? '',
             })
           }
           placeholder="Phone number"
diff --git a/PingTestRunner/scenarios/UseDaVinciScenario.tsx b/PingTestRunner/scenarios/UseDaVinciScenario.tsx
index 2462465e3..e135ea430 100644
--- a/PingTestRunner/scenarios/UseDaVinciScenario.tsx
+++ b/PingTestRunner/scenarios/UseDaVinciScenario.tsx
@@ -309,10 +309,37 @@ function HookCollectorInput({
 }: HookCollectorInputProps): React.JSX.Element | null {
   const testID = `use-davinci-field-${collector.key}`;
 
+  if (collector.kind === 'boolean') {
+    const booleanCollector = collector as {
+      value?: boolean;
+    };
+    return (
+      <Switch
+        testID={testID}
+        value={
+          typeof value === 'boolean' ? value : (booleanCollector.value ?? false)
+        }
+        onValueChange={onValueChange}
+      />
+    );
+  }
+
   if (collector.kind === 'output') {
+    const outputCollector = collector as {
+      content?: string;
+      title?: string;
+      titleEnabled?: boolean;
+    };
+    const outputTestID =
+      collector.type === 'READ_ONLY_TEXT'
+        ? testID
+        : `use-davinci-label-${collector.key}`;
     return (
-      <Text testID={`use-davinci-label-${collector.key}`}>
-        {(collector as { content?: string }).content ?? ''}
+      <Text testID={outputTestID}>
+        {outputCollector.titleEnabled && outputCollector.title
+          ? `${outputCollector.title}\n`
+          : ''}
+        {outputCollector.content ?? ''}
       </Text>
     );
   }
@@ -397,9 +424,11 @@ function HookCollectorInput({
 
   if (collector.kind === 'phone') {
     const phone =
-      (value as { countryCode?: string; phoneNumber?: string } | undefined) ??
-      {};
+      (value as
+        | { countryCode?: string; phoneNumber?: string; extension?: string }
+        | undefined) ?? {};
     const countryCode = (collector as { countryCode?: string }).countryCode;
+    const extension = (collector as { extension?: string }).extension;
     return (
       <View testID={testID}>
         <TextInput
@@ -409,6 +438,7 @@ function HookCollectorInput({
             onValueChange({
               countryCode: t,
               phoneNumber: phone.phoneNumber ?? '',
+              extension: phone.extension ?? extension ?? '',
             })
           }
           placeholder="Country code"
@@ -421,6 +451,7 @@ function HookCollectorInput({
             onValueChange({
               countryCode: phone.countryCode ?? countryCode ?? '',
               phoneNumber: t,
+              extension: phone.extension ?? extension ?? '',
             })
           }
           placeholder="Phone number"
diff --git a/packages/davinci/README.md b/packages/davinci/README.md
index a7b5823c1..f44de9f7c 100644
--- a/packages/davinci/README.md
+++ b/packages/davinci/README.md
@@ -253,6 +253,22 @@ if (form.canSubmit) {
 
 `useDaVinciForm` is headless. It manages normalized collectors and submit planning, but does not render UI and does not auto-run collectors.
 
+#### Validate a collector without advancing the flow
+
+Use `validate(collectorKey, value)` to validate one active collector, such as when a field loses focus. It returns that collector's validation errors without calling `next()`:
+
+```ts
+const { validate } = useDaVinci(client);
+
+const errors = await validate('email', 'not-an-email');
+
+if (errors.length > 0) {
+  // Example: [{ code: 'REGEX_ERROR', message: 'Invalid email' }]
+}
+```
+
+`validate()` applies `value` to the active native collector before checking it. The value remains on the collector and is included in a later `next()` call. An empty array means the value has no validation errors or that the collector has no native validator.
+
 Each normalized collector includes `executionMode` and `requiresUserInput`.
 
 | `executionMode`        | Meaning                                                                                  | `requiresUserInput` default |
@@ -278,29 +294,29 @@ await form.submitFlow('forgot-password');
 
 The following collector types are supported on Android and iOS:
 
-| Collector Type          | Description                                                                            | Input Handling |
-| ----------------------- | -------------------------------------------------------------------------------------- | -------------- |
-| `TEXT`                  | Single-line text input.                                                                | Manual input   |
-| `PASSWORD`              | Masked password input.                                                                 | Manual input   |
-| `PASSWORD_VERIFY`       | Password-confirmation variant of `PASSWORD`.                                           | Manual input   |
-| `SINGLE_SELECT`         | Single-select input.                                                                   | Manual input   |
-| `DROPDOWN`              | Single-select dropdown.                                                                | Manual input   |
-| `RADIO`                 | Single-select radio group.                                                             | Manual input   |
-| `MULTI_SELECT`          | Multi-select input.                                                                    | Manual input   |
-| `COMBOBOX`              | Multi-select combobox.                                                                 | Manual input   |
-| `CHECKBOX`              | Multi-select checkbox group.                                                           | Manual input   |
-| `PHONE_NUMBER`          | Phone number input with country code.                                                  | Manual input   |
-| `DEVICE_REGISTRATION`   | Device picker for registration.                                                        | Manual input   |
-| `DEVICE_AUTHENTICATION` | Device picker for authentication.                                                      | Manual input   |
-| `SUBMIT_BUTTON`         | Triggers form submission immediately.                                                  | Immediate      |
-| `ACTION`                | Action button that advances the flow immediately.                                      | Immediate      |
-| `FLOW_BUTTON`           | Flow button that advances the flow immediately.                                        | Immediate      |
-| `FLOW_LINK`             | Flow link that advances the flow immediately.                                          | Immediate      |
-| `SINGLE_CHECKBOX`       | Single checkbox or toggle (boolean field).                                             | Manual input   |
-| `LABEL`                 | Read-only display content.                                                             | Output-only    |
-| `READ_ONLY_TEXT`        | Read-only text / agreement content.                                                    | Output-only    |
-| `POLLING`               | Async polling collector — see [Polling and QR code flows](#polling-and-qr-code-flows). | Output-only    |
-| `QR_CODE`               | Display-only QR code — see [Polling and QR code flows](#polling-and-qr-code-flows).    | Output-only    |
+| Collector Type          | Description                                                                                                       | Input Handling |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------------- | -------------- |
+| `TEXT`                  | Single-line text input.                                                                                           | Manual input   |
+| `PASSWORD`              | Masked password input with optional server validation and password policy; results are returned after submission. | Manual input   |
+| `PASSWORD_VERIFY`       | Password-confirmation variant with the same validation, policy, and submission-result behavior as `PASSWORD`.     | Manual input   |
+| `SINGLE_SELECT`         | Single-select input.                                                                                              | Manual input   |
+| `DROPDOWN`              | Single-select dropdown.                                                                                           | Manual input   |
+| `RADIO`                 | Single-select radio group.                                                                                        | Manual input   |
+| `MULTI_SELECT`          | Multi-select input.                                                                                               | Manual input   |
+| `COMBOBOX`              | Multi-select combobox.                                                                                            | Manual input   |
+| `CHECKBOX`              | Multi-select checkbox group.                                                                                      | Manual input   |
+| `PHONE_NUMBER`          | Phone input with country code and optional extension, `showExtension`, and `extensionLabel` configuration.        | Manual input   |
+| `DEVICE_REGISTRATION`   | Device picker for registration.                                                                                   | Manual input   |
+| `DEVICE_AUTHENTICATION` | Device picker for authentication.                                                                                 | Manual input   |
+| `SUBMIT_BUTTON`         | Triggers form submission immediately.                                                                             | Immediate      |
+| `ACTION`                | Action button that advances the flow immediately.                                                                 | Immediate      |
+| `FLOW_BUTTON`           | Flow button that advances the flow immediately.                                                                   | Immediate      |
+| `FLOW_LINK`             | Flow link that advances the flow immediately.                                                                     | Immediate      |
+| `SINGLE_CHECKBOX`       | Single checkbox or toggle (boolean field).                                                                        | Manual input   |
+| `LABEL`                 | Read-only display content with optional templated `richContent`.                                                  | Output-only    |
+| `READ_ONLY_TEXT`        | Read-only text / agreement content.                                                                               | Output-only    |
+| `POLLING`               | Async polling collector — see [Polling and QR code flows](#polling-and-qr-code-flows).                            | Output-only    |
+| `QR_CODE`               | Display-only QR code — see [Polling and QR code flows](#polling-and-qr-code-flows).                               | Output-only    |
 
 Integration-dependent collectors (for example, social IdP, FIDO, or PingOne Protect) are
 surfaced in node payloads and require client-side integration before submission
@@ -340,6 +356,7 @@ Stable DaVinci error codes:
 - `DAVINCI_CONFIG_ERROR`
 - `DAVINCI_START_ERROR`
 - `DAVINCI_NEXT_ERROR`
+- `DAVINCI_VALIDATE_ERROR`
 - `DAVINCI_COLLECTOR_APPLY_ERROR`
 - `DAVINCI_SESSION_ERROR`
 - `DAVINCI_LOGOUT_ERROR`
diff --git a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/RNPingDavinciCommon.kt b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/RNPingDavinciCommon.kt
index b575587dd..646c9717a 100644
--- a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/RNPingDavinciCommon.kt
+++ b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/RNPingDavinciCommon.kt
@@ -11,12 +11,18 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.pingidentity.davinci.collector.PollingCollector
 import com.pingidentity.davinci.collector.PollingStatus
+import com.pingidentity.davinci.collector.Validator
+import com.pingidentity.davinci.module.continueNode
+import com.pingidentity.davinci.plugin.Collector
 import com.pingidentity.davinci.user
 import com.pingidentity.logger.Logger
 import com.pingidentity.orchestrate.ContinueNode
+import com.pingidentity.orchestrate.ErrorNode
 import com.pingidentity.orchestrate.Node
 import com.pingidentity.orchestrate.Workflow
 import com.pingidentity.oidc.Token
@@ -152,14 +158,33 @@ internal object RNPingDavinciCommon {
         configured = false
     }
 
+    /**
+     * Update tracked node state for a transition.
+     *
+     * @remarks
+     * When [node] is an [ErrorNode] carrying a retryable continuation (native
+     * `ErrorNode.continueNode()`), that continuation is kept as the active
+     * `ContinueNode` instead of being closed — matching native SDK behavior, where
+     * `validate()` and `next()` are independent operations and a recoverable error
+     * does not discard the in-progress form. The continuation is only closed once a
+     * genuinely different `ContinueNode` (or a terminal `SuccessNode`/`FailureNode`)
+     * displaces it.
+     */
     private fun setNodeState(davinciId: String, node: Node) {
         nodeMap[davinciId] = node
-        val previousContinueNode = if (node is ContinueNode) {
-            continueNodeMap.put(davinciId, node)
+        val retainedContinueNode = when (node) {
+            is ContinueNode -> node
+            is ErrorNode -> node.continueNode()
+            else -> null
+        }
+        val previousContinueNode = if (retainedContinueNode != null) {
+            continueNodeMap.put(davinciId, retainedContinueNode)
         } else {
             continueNodeMap.remove(davinciId)
         }
-        previousContinueNode?.let { runCatching { it.close() } }
+        if (previousContinueNode !== retainedContinueNode) {
+            previousContinueNode?.let { runCatching { it.close() } }
+        }
     }
 
     private fun clearNodeState(davinciId: String) {
@@ -313,10 +338,108 @@ internal object RNPingDavinciCommon {
 
             val nextNode = currentNode.next()
             setNodeState(davinciId, nextNode)
-            promise.resolve(DaVinciNodeMapper.mapNode(nextNode, resolveDaVinciLogger(davinciId)))
+            promise.resolve(
+                DaVinciNodeMapper.mapNode(nextNode, resolveDaVinciLogger(davinciId))
+            )
         }
     }
 
+    /**
+     * Validate one active DaVinci collector without advancing the flow.
+     *
+     * @remarks
+     * This operation mutates the live collector before validating it. Android does not
+     * serialize this call against concurrent [next] or [validate] calls for the same
+     * `davinciId`; this remains a deliberate assumption shared with the existing bridge.
+     *
+     * @param davinciId Native DaVinci instance id.
+     * @param collectorKey Collector key to update and validate.
+     * @param input Single-entry collector mutation payload.
+     * @param promise Promise resolved with encoded validation errors.
+     */
+    fun validate(
+        davinciId: String,
+        collectorKey: String,
+        input: ReadableMap,
+        promise: Promise,
+    ) {
+        val currentNode = continueNodeMap[davinciId]
+        if (currentNode == null) {
+            promise.reject(
+                DaVinciErrorMapper.state(
+                    DaVinciErrorCodes.STATE,
+                    "No active ContinueNode found for davinci id=$davinciId"
+                )
+            )
+            return
+        }
+
+        scope.launchBridge(promise, DaVinciErrorCodes.VALIDATE) {
+            try {
+                DaVinciCollectorValueApplier.apply(currentNode, input)
+            } catch (error: UnsupportedOperationException) {
+                promise.reject(
+                    GenericError(
+                        type = ErrorType.ARGUMENT_ERROR,
+                        error = DaVinciErrorCodes.UNSUPPORTED_COLLECTOR,
+                        message = error.message
+                    ),
+                    error
+                )
+                return@launchBridge
+            } catch (error: IllegalArgumentException) {
+                promise.reject(
+                    GenericError(
+                        type = ErrorType.ARGUMENT_ERROR,
+                        error = DaVinciErrorCodes.COLLECTOR_APPLY,
+                        message = error.message
+                    ),
+                    error
+                )
+                return@launchBridge
+            }
+
+            val collector = checkNotNull(
+                currentNode.actions
+                    .filterIsInstance<Collector<*>>()
+                    .find { it.id() == collectorKey }
+            )
+            val validator = collector as? Validator
+            val errors = validator?.let { DaVinciNodeMapper.encodeValidationErrors(it.validate()) }
+                ?: emptyList<Map<String, Any?>>()
+            promise.resolve(encodeValidationErrorsArray(errors))
+        }
+    }
+
+    /**
+     * Encode validation errors into a bridge array using [Arguments.createArray], not
+     * [Arguments.makeNativeArray] — the latter is declared to return the concrete
+     * `WritableNativeArray` class rather than the `WritableArray` interface, which Robolectric
+     * cannot substitute with a JVM-only test double in unit tests.
+     *
+     * @param errors Encoded validation error maps from [DaVinciNodeMapper.encodeValidationErrors].
+     * @return Bridge array of `{code, ...}` error payloads.
+     */
+    private fun encodeValidationErrorsArray(errors: List<Map<String, Any?>>): WritableArray =
+        Arguments.createArray().apply {
+            errors.forEach { error -> pushMap(encodeValidationErrorMap(error)) }
+        }
+
+    private fun encodeValidationErrorMap(error: Map<String, Any?>): WritableMap =
+        Arguments.createMap().apply {
+            error.forEach { (key, value) ->
+                when (value) {
+                    null -> putNull(key)
+                    is String -> putString(key, value)
+                    is Boolean -> putBoolean(key, value)
+                    is Int -> putInt(key, value)
+                    is Long -> putDouble(key, value.toDouble())
+                    is Double -> putDouble(key, value)
+                    else -> putString(key, value.toString())
+                }
+            }
+        }
+
     /**
      * Resolve active session data for a DaVinci user.
      *
diff --git a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplier.kt b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplier.kt
index 2ca5fcaf0..4d69c80f7 100644
--- a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplier.kt
+++ b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplier.kt
@@ -103,6 +103,7 @@ internal object DaVinciCollectorValueApplier {
                 val map = asStringMap(value)
                 map["countryCode"]?.let { collector.countryCode = it }
                 map["phoneNumber"]?.let { collector.phoneNumber = it }
+                map["extension"]?.let { collector.extension = it }
             }
             is DeviceRegistrationCollector -> {
                 val map = asStringMap(value)
diff --git a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/error/DaVinciErrorCodes.kt b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/error/DaVinciErrorCodes.kt
index bf00c0911..29364fa01 100644
--- a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/error/DaVinciErrorCodes.kt
+++ b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/error/DaVinciErrorCodes.kt
@@ -19,6 +19,8 @@ internal object DaVinciErrorCodes {
     const val START = "DAVINCI_START_ERROR"
     /** Flow progression failure. */
     const val NEXT = "DAVINCI_NEXT_ERROR"
+    /** Standalone collector validation failure. */
+    const val VALIDATE = "DAVINCI_VALIDATE_ERROR"
     /** Collector value application failure. */
     const val COLLECTOR_APPLY = "DAVINCI_COLLECTOR_APPLY_ERROR"
     /** Unsupported collector mutation request. */
diff --git a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapper.kt b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapper.kt
index 23328bb3f..bd61e8ba6 100644
--- a/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapper.kt
+++ b/packages/davinci/android/src/main/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapper.kt
@@ -10,12 +10,16 @@ package com.pingidentity.rndavinci.mapper
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import kotlinx.serialization.json.Json
+import com.pingidentity.davinci.RichContent
 import com.pingidentity.davinci.collector.Device
 import com.pingidentity.davinci.collector.BooleanCollector
 import com.pingidentity.davinci.collector.DeviceAuthenticationCollector
 import com.pingidentity.davinci.collector.DeviceRegistrationCollector
 import com.pingidentity.davinci.collector.FlowCollector
+import com.pingidentity.davinci.collector.InvalidLength
 import com.pingidentity.davinci.collector.LabelCollector
+import com.pingidentity.davinci.collector.MaxRepeat
+import com.pingidentity.davinci.collector.MinCharacters
 import com.pingidentity.davinci.collector.MultiSelectCollector
 import com.pingidentity.davinci.collector.PasswordCollector
 import com.pingidentity.davinci.collector.PasswordPolicy
@@ -23,9 +27,13 @@ import com.pingidentity.davinci.collector.PhoneNumberCollector
 import com.pingidentity.davinci.collector.PollingCollector
 import com.pingidentity.davinci.collector.QRCodeCollector
 import com.pingidentity.davinci.collector.ReadOnlyTextCollector
+import com.pingidentity.davinci.collector.RegexError
+import com.pingidentity.davinci.collector.Required
 import com.pingidentity.davinci.collector.SingleSelectCollector
 import com.pingidentity.davinci.collector.SubmitCollector
 import com.pingidentity.davinci.collector.TextCollector
+import com.pingidentity.davinci.collector.UniqueCharacter
+import com.pingidentity.davinci.collector.ValidationError
 import com.pingidentity.davinci.plugin.Collector
 import com.pingidentity.idp.davinci.IdpCollector
 import com.pingidentity.logger.Logger
@@ -72,7 +80,10 @@ internal object DaVinciNodeMapper {
      * @param logger Optional Ping logger used for non-fatal mapping warnings.
      * @return Serialized node payload.
      */
-    fun mapNode(node: Node, logger: Logger? = null): WritableMap {
+    fun mapNode(
+        node: Node,
+        logger: Logger? = null
+    ): WritableMap {
         return Arguments.makeNativeMap(mapNodePayload(node, logger))
     }
 
@@ -83,7 +94,10 @@ internal object DaVinciNodeMapper {
      * @param logger Optional Ping logger used for non-fatal mapping warnings.
      * @return Serializable node payload map.
      */
-    fun mapNodePayload(node: Node, logger: Logger? = null): Map<String, Any?> {
+    fun mapNodePayload(
+        node: Node,
+        logger: Logger? = null
+    ): Map<String, Any?> {
         val payload = linkedMapOf<String, Any?>()
 
         when (node) {
@@ -123,6 +137,30 @@ internal object DaVinciNodeMapper {
         return payload
     }
 
+    /**
+     * Maps a native [ValidationError] to the stable JS-facing error code contract.
+     *
+     * @param error Native validation error produced by a collector's `validate()`.
+     * @return Serialized `{code, ...}` error payload.
+     */
+    internal fun encodeValidationError(error: ValidationError): Map<String, Any?> = when (error) {
+        is Required -> mapOf("code" to "REQUIRED")
+        is RegexError -> mapOf("code" to "REGEX_ERROR", "message" to error.message)
+        is InvalidLength -> mapOf("code" to "INVALID_LENGTH", "min" to error.min, "max" to error.max)
+        is UniqueCharacter -> mapOf("code" to "UNIQUE_CHARACTER", "min" to error.min)
+        is MaxRepeat -> mapOf("code" to "MAX_REPEAT", "max" to error.max)
+        is MinCharacters -> mapOf("code" to "MIN_CHARACTERS", "character" to error.character, "min" to error.min)
+    }
+
+    /**
+     * Maps a list of native [ValidationError]s captured from a submitted collector.
+     *
+     * @param errors Native validation errors from a collector's `validate()` call.
+     * @return Serialized list of `{code, ...}` error payloads.
+     */
+    internal fun encodeValidationErrors(errors: List<ValidationError>): List<Map<String, Any?>> =
+        errors.map(::encodeValidationError)
+
     /**
      * Serialize all `Collector<*>` instances from a `ContinueNode` into a list.
      * Unknown action types that do not implement `Collector` are skipped gracefully.
@@ -203,7 +241,7 @@ internal object DaVinciNodeMapper {
      * Returns null when the collector type is unknown and should be skipped.
      *
      * @param collector Collector instance.
-     * @param node Parent continue node (used for password policy extraction).
+     * @param node Parent continue node (used to resolve the raw field JSON for `raw`/unregistered-type lookups).
      * @param logger Optional Ping logger for non-fatal mapping warnings.
      * @return Serialized collector map, or null for unknown types.
      */
@@ -221,7 +259,7 @@ internal object DaVinciNodeMapper {
         val payload = when (collector) {
             is IdpCollector -> mapIdpCollector(collector)
             is TextCollector -> mapTextCollector(collector)
-            is PasswordCollector -> mapPasswordCollector(collector, node, logger)
+            is PasswordCollector -> mapPasswordCollector(collector)
             is SubmitCollector -> mapBaseCollector(collector)
             is FlowCollector -> mapBaseCollector(collector)
             is LabelCollector -> mapLabelCollector(collector)
@@ -317,47 +355,25 @@ internal object DaVinciNodeMapper {
      * `clearPassword` controls whether the native collector wipes its in-memory value when
      * the parent node is closed; it does not affect the bridge value emission.
      *
+     * `passwordPolicy` is read through the native `passwordPolicy()` accessor, which resolves
+     * the field-level policy first and falls back to the node-root policy.
+     *
      * @param collector Native password collector.
-     * @param node Parent continue node (used to extract the field-level password policy from raw JSON).
-     * @param logger Optional Ping logger for non-fatal policy-extraction warnings.
      * @return Serialized password collector map.
      */
-    private fun mapPasswordCollector(
-        collector: PasswordCollector,
-        node: ContinueNode,
-        logger: Logger? = null
-    ): Map<String, Any?> {
+    private fun mapPasswordCollector(collector: PasswordCollector): Map<String, Any?> {
         val map = baseCollectorMap(collector)
         map["value"] = ""
         map["clearPassword"] = collector.clearPassword
-        extractPasswordPolicy(collector.key, node, logger)?.let { policy ->
+        collector.validation?.let { validation ->
+            map["validation"] = mapOf("regex" to validation.regex.pattern)
+        }
+        collector.passwordPolicy()?.let { policy ->
             map["passwordPolicy"] = encodePasswordPolicy(policy)
         }
         return map
     }
 
-    /**
-     * Reads passwordPolicy from the raw JSON at
-     * `continueNode.input.form.components.fields[].passwordPolicy` by matching the collector key.
-     *
-     * TODO-SDK-FUTURE-SUPPORT: The SDK's own `passwordPolicy()` method is `//TODO` in 2.0.1 because it reads from the
-     * wrong JSON path (node root instead of the field-level object).
-     */
-    private fun extractPasswordPolicy(
-        collectorKey: String,
-        node: ContinueNode,
-        logger: Logger? = null
-    ): PasswordPolicy? {
-        return try {
-            val fieldJson = findFieldJson(node, collectorKey, logger) ?: return null
-            val policyJson = fieldJson["passwordPolicy"]?.jsonObject ?: return null
-            json.decodeFromJsonElement(PasswordPolicy.serializer(), policyJson)
-        } catch (error: Exception) {
-            logWarning(logger, "Failed to extract password policy for key=$collectorKey", error)
-            null
-        }
-    }
-
     /**
      * Read `node.input.form.components.fields[]` as a JSON array.
      *
@@ -452,13 +468,33 @@ internal object DaVinciNodeMapper {
     }
 
     private fun mapLabelCollector(collector: LabelCollector): Map<String, Any?> {
-        return linkedMapOf(
+        val map = linkedMapOf<String, Any?>(
             "key" to collector.key,
             "type" to "LABEL",
             "content" to collector.content
         )
+        collector.richContent?.let { map["richContent"] = encodeRichContent(it) }
+        return map
     }
 
+    /**
+     * Serialize a native [RichContent] into its bridge payload shape.
+     *
+     * @param rc Native rich-content payload.
+     * @return Serialized `{content, replacements}` map.
+     */
+    private fun encodeRichContent(rc: RichContent): Map<String, Any?> = mapOf(
+        "content" to rc.content,
+        "replacements" to rc.replacements.mapValues { (_, r) ->
+            buildMap {
+                put("value", r.value)
+                put("href", r.href)
+                put("type", r.type)
+                put("target", r.target)
+            }
+        }
+    )
+
     /**
      * Serialize a [PollingCollector] to a payload map.
      *
@@ -541,6 +577,9 @@ internal object DaVinciNodeMapper {
         map["validatePhoneNumber"] = collector.validatePhoneNumber
         map["countryCode"] = collector.countryCode
         map["phoneNumber"] = collector.phoneNumber
+        map["extension"] = collector.extension
+        map["showExtension"] = collector.showExtension
+        map["extensionLabel"] = collector.extensionLabel
         return map
     }
 
@@ -567,19 +606,7 @@ internal object DaVinciNodeMapper {
         map["value"] = collector.value
         map["appearance"] = collector.appearance.value
         map["errorMessage"] = collector.errorMessage
-        collector.richContent?.let { rc ->
-            map["richContent"] = mapOf(
-                "content" to rc.content,
-                "replacements" to rc.replacements.mapValues { (_, r) ->
-                    buildMap {
-                        put("value", r.value)
-                        put("href", r.href)
-                        put("type", r.type)
-                        put("target", r.target)
-                    }
-                }
-            )
-        }
+        collector.richContent?.let { map["richContent"] = encodeRichContent(it) }
         return map
     }
 
diff --git a/packages/davinci/android/src/newarch/java/com/pingidentity/rndavinci/RNPingDavinciModule.kt b/packages/davinci/android/src/newarch/java/com/pingidentity/rndavinci/RNPingDavinciModule.kt
index 0b08d8b2b..94e0db715 100644
--- a/packages/davinci/android/src/newarch/java/com/pingidentity/rndavinci/RNPingDavinciModule.kt
+++ b/packages/davinci/android/src/newarch/java/com/pingidentity/rndavinci/RNPingDavinciModule.kt
@@ -66,6 +66,23 @@ class RNPingDavinciModule(reactContext: ReactApplicationContext) :
     RNPingDavinciCommon.next(davinciId, input, promise)
   }
 
+  /**
+   * Validate one active DaVinci collector without advancing the flow.
+   *
+   * @param davinciId Native DaVinci client id.
+   * @param collectorKey Collector key to update and validate.
+   * @param input Single-entry collector mutation payload.
+   * @param promise Promise resolved with encoded validation errors.
+   */
+  override fun validate(
+    davinciId: String,
+    collectorKey: String,
+    input: ReadableMap,
+    promise: Promise,
+  ) {
+    RNPingDavinciCommon.validate(davinciId, collectorKey, input, promise)
+  }
+
   /**
    * Resolve active user session details.
    *
diff --git a/packages/davinci/android/src/oldarch/java/com/pingidentity/rndavinci/RNPingDavinciClassicModule.kt b/packages/davinci/android/src/oldarch/java/com/pingidentity/rndavinci/RNPingDavinciClassicModule.kt
index 3145a8219..cc854ade4 100644
--- a/packages/davinci/android/src/oldarch/java/com/pingidentity/rndavinci/RNPingDavinciClassicModule.kt
+++ b/packages/davinci/android/src/oldarch/java/com/pingidentity/rndavinci/RNPingDavinciClassicModule.kt
@@ -76,6 +76,24 @@ class RNPingDavinciClassicModule(
     RNPingDavinciCommon.next(davinciId, input, promise)
   }
 
+  /**
+   * Validate one active DaVinci collector without advancing the flow.
+   *
+   * @param davinciId Native DaVinci client id.
+   * @param collectorKey Collector key to update and validate.
+   * @param input Single-entry collector mutation payload.
+   * @param promise Promise resolved with encoded validation errors.
+   */
+  @ReactMethod
+  fun validate(
+    davinciId: String,
+    collectorKey: String,
+    input: ReadableMap,
+    promise: Promise,
+  ) {
+    RNPingDavinciCommon.validate(davinciId, collectorKey, input, promise)
+  }
+
   /**
    * Resolve active user session details.
    *
diff --git a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/RNPingDavinciCommonTest.kt b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/RNPingDavinciCommonTest.kt
index 52e817b3b..26984f3e0 100644
--- a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/RNPingDavinciCommonTest.kt
+++ b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/RNPingDavinciCommonTest.kt
@@ -10,12 +10,16 @@ package com.pingidentity.rndavinci
 import com.facebook.react.bridge.JavaOnlyArray
 import com.facebook.react.bridge.JavaOnlyMap
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.pingidentity.davinci.collector.BooleanCollector
 import com.pingidentity.davinci.collector.PasswordCollector
 import com.pingidentity.davinci.collector.PollingCollector
+import com.pingidentity.davinci.collector.SubmitCollector
+import com.pingidentity.davinci.collector.TextCollector
 import com.pingidentity.davinci.collector.PollingStatus
 import com.pingidentity.davinci.plugin.Collector
 import com.pingidentity.network.HttpRequest
@@ -189,6 +193,191 @@ class RNPingDavinciCommonTest {
         )
     }
 
+    // ---- validation capture and retry state ----
+
+    @Test
+    fun validate_resolvesRequiredAndRegexErrors() {
+        val text = TextCollector().apply {
+            init(buildJsonObject {
+                put("key", "username")
+                put("type", "TEXT")
+                put("label", "Username")
+                put("required", true)
+                put("validation", buildJsonObject {
+                    put("regex", "^valid$")
+                    put("errorMessage", "Invalid username")
+                })
+            })
+        }
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(davinciId, DummyContinueNode(actions = listOf(text)))
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            "username",
+            collectorInput("username", "invalid"),
+            promise
+        )
+
+        val errors = captureResolve(promise) as ReadableArray
+        assertEquals(1, errors.size())
+        assertEquals("REGEX_ERROR", errors.getMap(0)?.getString("code"))
+        assertEquals("Invalid username", errors.getMap(0)?.getString("message"))
+    }
+
+    @Test
+    fun validate_resolvesRequiredErrorForUncheckedBoolean() {
+        val boolean = BooleanCollector().apply {
+            init(buildJsonObject {
+                put("key", "agree")
+                put("type", "BOOLEAN")
+                put("label", "Agree")
+                put("required", true)
+                put("errorMessage", "You must agree.")
+            })
+        }
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(davinciId, DummyContinueNode(actions = listOf(boolean)))
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            "agree",
+            collectorInput("agree", false),
+            promise
+        )
+
+        val errors = captureResolve(promise) as ReadableArray
+        assertEquals(1, errors.size())
+        assertEquals("REQUIRED", errors.getMap(0)?.getString("code"))
+        assertNull(errors.getMap(0)?.getString("message"))
+    }
+
+    @Test
+    fun validate_resolvesEmptyListWhenValueIsValid() {
+        val text = TextCollector().apply {
+            init(buildJsonObject {
+                put("key", "username")
+                put("type", "TEXT")
+                put("label", "Username")
+                put("required", true)
+                put("validation", buildJsonObject { put("regex", "^valid$") })
+            })
+        }
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(davinciId, DummyContinueNode(actions = listOf(text)))
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            "username",
+            collectorInput("username", "valid"),
+            promise
+        )
+
+        assertEquals(0, (captureResolve(promise) as ReadableArray).size())
+    }
+
+    @Test
+    fun validate_rejectsWhenCollectorKeyUnknown() {
+        val text = TextCollector().apply {
+            init(buildJsonObject {
+                put("key", "username")
+                put("type", "TEXT")
+                put("label", "Username")
+            })
+        }
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(davinciId, DummyContinueNode(actions = listOf(text)))
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            "unknown",
+            collectorInput("unknown", "value"),
+            promise
+        )
+
+        val error = captureReject(promise)
+        assertEquals(DaVinciErrorCodes.COLLECTOR_APPLY, error.getString("error"))
+    }
+
+    @Test
+    fun validate_rejectsUnsupportedCollectorType() {
+        val collectorKey = "unsupported-key"
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(
+            davinciId,
+            DummyContinueNode(actions = listOf(UnsupportedTestCollector(collectorKey)))
+        )
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            collectorKey,
+            collectorInput(collectorKey, "value"),
+            promise
+        )
+
+        val error = captureReject(promise)
+        assertEquals(DaVinciErrorCodes.UNSUPPORTED_COLLECTOR, error.getString("error"))
+    }
+
+    @Test
+    fun validate_resolvesEmptyListForCollectorWithoutValidator() {
+        val collector = SubmitCollector()
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        setContinueNode(davinciId, DummyContinueNode(actions = listOf(collector)))
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            davinciId,
+            collector.id(),
+            collectorInput(collector.id(), "value"),
+            promise
+        )
+
+        assertEquals(0, (captureResolve(promise) as ReadableArray).size())
+    }
+
+    @Test
+    fun validate_rejectsStateErrorWhenNoContinueNode() {
+        val promise = TestPromise()
+
+        RNPingDavinciCommon.validate(
+            "no-such-id",
+            "username",
+            collectorInput("username", "value"),
+            promise
+        )
+
+        val error = captureReject(promise)
+        assertEquals(ErrorType.STATE_ERROR.rawValue, error.getString("type"))
+        assertEquals(DaVinciErrorCodes.STATE, error.getString("error"))
+    }
+
+    @Test
+    fun setNodeStateRetainsContinueNodeFromErrorNode() {
+        val davinciId = registerDaVinciHandle(Workflow(WorkflowConfig()))
+        val current = DummyContinueNode(actions = emptyList())
+        setContinueNode(davinciId, current)
+        val error = com.pingidentity.orchestrate.ErrorNode(
+            current.context,
+            buildJsonObject { put("code", "invalid") },
+            "Invalid input"
+        )
+        error.context.flowContext["com.pingidentity.davinci.CONTINUE_NODE"] = current
+
+        invokeSetNodeState(davinciId, error)
+
+        val field = RNPingDavinciCommon::class.java.getDeclaredField("continueNodeMap")
+        field.isAccessible = true
+        @Suppress("UNCHECKED_CAST")
+        val map = field.get(RNPingDavinciCommon) as Map<String, ContinueNode>
+        assertTrue(map[davinciId] === current)
+    }
+
     // ---- next must not close current node before transitioning ----
 
     @Test
@@ -214,6 +403,7 @@ class RNPingDavinciCommonTest {
                 throw sentinel
             }
         }
+        password.continueNode = node
         setContinueNode(davinciId, node)
 
         val nextInput = JavaOnlyMap().apply {
@@ -935,6 +1125,29 @@ class RNPingDavinciCommonTest {
         return reactContext to emitter
     }
 
+    private fun collectorInput(key: String, value: String): JavaOnlyMap = collectorInputMap(key) {
+        putString("value", value)
+    }
+
+    private fun collectorInput(key: String, value: Boolean): JavaOnlyMap = collectorInputMap(key) {
+        putBoolean("value", value)
+    }
+
+    private inline fun collectorInputMap(
+        key: String,
+        valueWriter: JavaOnlyMap.() -> Unit
+    ): JavaOnlyMap = JavaOnlyMap().apply {
+        putArray(
+            "collectors",
+            JavaOnlyArray().apply {
+                pushMap(JavaOnlyMap().apply {
+                    putString("key", key)
+                    valueWriter()
+                })
+            }
+        )
+    }
+
     private fun captureResolve(promise: TestPromise): Any? {
         promise.await()
         return promise.resolvedValue
diff --git a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplierTest.kt b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplierTest.kt
index c5a284e86..3b1dedb71 100644
--- a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplierTest.kt
+++ b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/collector/DaVinciCollectorValueApplierTest.kt
@@ -424,6 +424,26 @@ class DaVinciCollectorValueApplierTest {
         assertEquals("5550001234", collector.phoneNumber)
     }
 
+    @Test
+    fun applyPhoneNumberCollectorSetsExtensionField() {
+        val collector = PhoneNumberCollector()
+        val node = nodeWith(collector)
+        val key = collector.id()
+
+        DaVinciCollectorValueApplier.apply(
+            node,
+            inputWithCollectors(
+                key to deviceMap(
+                    "countryCode" to "+1",
+                    "phoneNumber" to "5550001234",
+                    "extension" to "99"
+                )
+            )
+        )
+
+        assertEquals("99", collector.extension)
+    }
+
     @Test
     fun applyBooleanCollectorSetsTrueValue() {
         val collector = BooleanCollector().apply {
diff --git a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapperTest.kt b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapperTest.kt
index 1d78222f1..122f910ef 100644
--- a/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapperTest.kt
+++ b/packages/davinci/android/src/test/java/com/pingidentity/rndavinci/mapper/DaVinciNodeMapperTest.kt
@@ -11,21 +11,28 @@ import com.pingidentity.davinci.collector.BooleanCollector
 import com.pingidentity.davinci.collector.DeviceAuthenticationCollector
 import com.pingidentity.davinci.collector.DeviceRegistrationCollector
 import com.pingidentity.davinci.collector.FlowCollector
+import com.pingidentity.davinci.collector.InvalidLength
 import com.pingidentity.davinci.collector.LabelCollector
+import com.pingidentity.davinci.collector.MaxRepeat
+import com.pingidentity.davinci.collector.MinCharacters
 import com.pingidentity.davinci.collector.MultiSelectCollector
 import com.pingidentity.davinci.collector.PasswordCollector
 import com.pingidentity.davinci.collector.PhoneNumberCollector
 import com.pingidentity.davinci.collector.PollingCollector
 import com.pingidentity.davinci.collector.QRCodeCollector
 import com.pingidentity.davinci.collector.ReadOnlyTextCollector
+import com.pingidentity.davinci.collector.RegexError
+import com.pingidentity.davinci.collector.Required
 import com.pingidentity.davinci.collector.SingleSelectCollector
 import com.pingidentity.davinci.collector.SubmitCollector
 import com.pingidentity.davinci.collector.TextCollector
+import com.pingidentity.davinci.collector.UniqueCharacter
 import com.pingidentity.davinci.plugin.Collector
 import com.pingidentity.idp.davinci.IdpCollector
 import com.pingidentity.network.HttpRequest
 import com.pingidentity.orchestrate.Action
 import com.pingidentity.orchestrate.ContinueNode
+import com.pingidentity.orchestrate.ContinueNodeAware
 import com.pingidentity.orchestrate.EmptySession
 import com.pingidentity.orchestrate.ErrorNode
 import com.pingidentity.orchestrate.FailureNode
@@ -51,13 +58,17 @@ class DaVinciNodeMapperTest {
         *actions
     )
 
-    private fun makeNode(input: JsonObject, vararg actions: Action) = object : ContinueNode(
-        context = FlowContext(SharedContext(mutableMapOf())),
-        workflow = Workflow(WorkflowConfig()),
-        input = input,
-        actions = listOf(*actions)
-    ) {
-        override fun asRequest(): HttpRequest = throw UnsupportedOperationException()
+    private fun makeNode(input: JsonObject, vararg actions: Action): ContinueNode {
+        val node = object : ContinueNode(
+            context = FlowContext(SharedContext(mutableMapOf())),
+            workflow = Workflow(WorkflowConfig()),
+            input = input,
+            actions = listOf(*actions)
+        ) {
+            override fun asRequest(): HttpRequest = throw UnsupportedOperationException()
+        }
+        actions.filterIsInstance<ContinueNodeAware>().forEach { it.continueNode = node }
+        return node
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -286,6 +297,83 @@ class DaVinciNodeMapperTest {
         assertTrue(c.containsKey("key"))
     }
 
+    @Test
+    fun mapLabelCollectorIncludesRichContentWhenPresent() {
+        val collector = LabelCollector().apply {
+            init(buildJsonObject {
+                put("key", "terms")
+                put("content", "Read the terms")
+                put("richContent", buildJsonObject {
+                    put("content", "Read the {{terms}}")
+                    put("replacements", buildJsonObject {
+                        put("terms", buildJsonObject {
+                            put("value", "terms")
+                            put("href", "https://example.com/terms")
+                            put("type", "link")
+                            put("target", "_blank")
+                        })
+                    })
+                })
+            })
+        }
+        val c = DaVinciNodeMapper.mapNodePayload(makeNode(collector)).asList("collectors")!![0]
+
+        @Suppress("UNCHECKED_CAST")
+        val richContent = c["richContent"] as Map<String, Any?>
+        assertEquals("Read the {{terms}}", richContent["content"])
+        @Suppress("UNCHECKED_CAST")
+        val replacements = richContent["replacements"] as Map<String, Map<String, Any?>>
+        assertEquals("https://example.com/terms", replacements["terms"]!!["href"])
+        assertEquals("_blank", replacements["terms"]!!["target"])
+    }
+
+    @Test
+    fun mapLabelCollectorOmitsRichContentWhenAbsent() {
+        val collector = LabelCollector().apply {
+            init(buildJsonObject {
+                put("key", "terms")
+                put("content", "Read the terms")
+            })
+        }
+        val c = DaVinciNodeMapper.mapNodePayload(makeNode(collector)).asList("collectors")!![0]
+
+        assertFalse(c.containsKey("richContent"))
+    }
+
+    @Test
+    fun mapValidationErrorsIncludesRequiredAndRegex() {
+        assertEquals(
+            mapOf("code" to "REQUIRED"),
+            DaVinciNodeMapper.encodeValidationError(Required)
+        )
+        assertEquals(
+            mapOf("code" to "REGEX_ERROR", "message" to "Invalid value"),
+            DaVinciNodeMapper.encodeValidationError(RegexError("Invalid value"))
+        )
+    }
+
+    @Test
+    fun mapPasswordValidationErrorsIncludesPolicyConstraints() {
+        val errors = DaVinciNodeMapper.encodeValidationErrors(
+            listOf(
+                InvalidLength(8, 64),
+                UniqueCharacter(3),
+                MaxRepeat(2),
+                MinCharacters("digit", 1)
+            )
+        )
+
+        assertEquals(
+            listOf(
+                mapOf("code" to "INVALID_LENGTH", "min" to 8, "max" to 64),
+                mapOf("code" to "UNIQUE_CHARACTER", "min" to 3),
+                mapOf("code" to "MAX_REPEAT", "max" to 2),
+                mapOf("code" to "MIN_CHARACTERS", "character" to "digit", "min" to 1)
+            ),
+            errors
+        )
+    }
+
     // ---- Raw field passthrough tests ----
 
     @Test
@@ -458,6 +546,27 @@ class DaVinciNodeMapperTest {
         assertTrue(c.containsKey("phoneNumber"))
     }
 
+    @Test
+    fun mapPhoneNumberCollectorIncludesExtensionFields() {
+        val collector = PhoneNumberCollector().apply {
+            init(buildJsonObject {
+                put("key", "phone")
+                put("type", "PHONE")
+                put("label", "Phone Number")
+                put("defaultCountryCode", "US")
+                put("validatePhoneNumber", true)
+                put("showExtension", true)
+                put("extensionLabel", "Extension")
+            })
+            extension = "99"
+        }
+        val c = DaVinciNodeMapper.mapNodePayload(makeNode(collector)).asList("collectors")!![0]
+
+        assertEquals("99", c["extension"])
+        assertEquals(true, c["showExtension"])
+        assertEquals("Extension", c["extensionLabel"])
+    }
+
     @Test
     fun mapPhoneNumberCollectorDefaultCountryCodeFallsBackToEmpty() {
         val collector = PhoneNumberCollector().apply {
@@ -571,40 +680,27 @@ class DaVinciNodeMapperTest {
     // ---- Password policy extraction ----
 
     @Test
-    fun mapPasswordCollectorExtractsPasswordPolicyFromFormField() {
+    fun mapPasswordCollectorUsesNativePasswordPolicyAccessor() {
         val collector = PasswordCollector().apply {
             init(buildJsonObject {
                 put("key", "password")
                 put("type", "PASSWORD")
                 put("label", "Password")
-            })
-        }
-        val input = buildJsonObject {
-            put("form", buildJsonObject {
-                put("components", buildJsonObject {
-                    put("fields", buildJsonArray {
-                        add(buildJsonObject {
-                            put("key", "password")
-                            put("type", "PASSWORD")
-                            put("label", "Password")
-                            put("passwordPolicy", buildJsonObject {
-                                put("name", "Standard Policy")
-                                put("minAgeDays", 0)
-                                put("maxAgeDays", 90)
-                                put("maxRepeatedCharacters", 2)
-                                put("minUniqueCharacters", 5)
-                                put("excludesProfileData", false)
-                                put("notSimilarToCurrent", true)
-                                put("excludesCommonlyUsed", true)
-                                put("populationCount", 0)
-                                put("default", true)
-                            })
-                        })
-                    })
+                put("passwordPolicy", buildJsonObject {
+                    put("name", "Standard Policy")
+                    put("minAgeDays", 0)
+                    put("maxAgeDays", 90)
+                    put("maxRepeatedCharacters", 2)
+                    put("minUniqueCharacters", 5)
+                    put("excludesProfileData", false)
+                    put("notSimilarToCurrent", true)
+                    put("excludesCommonlyUsed", true)
+                    put("populationCount", 0)
+                    put("default", true)
                 })
             })
         }
-        val node = makeNode(input, collector)
+        val node = makeNode(collector)
 
         val result = DaVinciNodeMapper.mapNodePayload(node)
         val c = result.asList("collectors")!![0]
@@ -618,6 +714,53 @@ class DaVinciNodeMapperTest {
         assertEquals(true, policy["notSimilarToCurrent"])
     }
 
+    @Test
+    fun mapPasswordCollectorFallsBackToNodeRootPasswordPolicy() {
+        val collector = PasswordCollector().apply {
+            init(buildJsonObject {
+                put("key", "password")
+                put("type", "PASSWORD")
+                put("label", "Password")
+            })
+        }
+        val input = buildJsonObject {
+            put("passwordPolicy", buildJsonObject {
+                put("name", "Global Policy")
+                put("maxAgeDays", 30)
+            })
+        }
+        val node = makeNode(input, collector)
+
+        val result = DaVinciNodeMapper.mapNodePayload(node)
+        val c = result.asList("collectors")!![0]
+
+        @Suppress("UNCHECKED_CAST")
+        val policy = c["passwordPolicy"] as? Map<String, Any?>
+        assertNotNull(policy)
+        assertEquals("Global Policy", policy!!["name"])
+        assertEquals(30L, policy["maxAgeDays"])
+    }
+
+    @Test
+    fun mapPasswordCollectorIncludesValidationRegexWhenPresent() {
+        val collector = PasswordCollector().apply {
+            init(buildJsonObject {
+                put("key", "password")
+                put("type", "PASSWORD")
+                put("label", "Password")
+                put("validation", buildJsonObject {
+                    put("regex", "^.{8,}$")
+                    put("errorMessage", "Password is too short")
+                })
+            })
+        }
+        val c = DaVinciNodeMapper.mapNodePayload(makeNode(collector)).asList("collectors")!![0]
+
+        @Suppress("UNCHECKED_CAST")
+        val validation = c["validation"] as Map<String, Any?>
+        assertEquals("^.{8,}$", validation["regex"])
+    }
+
     @Test
     fun mapPasswordCollectorOmitsPasswordPolicyWhenNotInFormField() {
         val collector = PasswordCollector().apply {
diff --git a/packages/davinci/ios/Collector/DaVinciCollectorValueApplier.swift b/packages/davinci/ios/Collector/DaVinciCollectorValueApplier.swift
index f4a5035c7..3cbd42109 100644
--- a/packages/davinci/ios/Collector/DaVinciCollectorValueApplier.swift
+++ b/packages/davinci/ios/Collector/DaVinciCollectorValueApplier.swift
@@ -37,7 +37,7 @@ enum DaVinciCollectorValueApplier {
   ///
   /// - Parameter input: Bridge input map.
   /// - Returns: Parsed collector mutations.
-  /// - Throws: `DaVinciBridgeError.argument` when payload is malformed.
+  /// - Throws: `DaVinciBridgeError.collectorApply` when payload is malformed.
   static func parseInput(_ input: NSDictionary) throws -> [CollectorMutation] {
     guard let collectors = input["collectors"] as? [Any] else {
       return []
@@ -46,10 +46,10 @@ enum DaVinciCollectorValueApplier {
     var mutations = [CollectorMutation]()
     for (index, item) in collectors.enumerated() {
       guard let entry = item as? NSDictionary else {
-        throw DaVinciBridgeError.argument("Invalid collector entry at index \(index)")
+        throw DaVinciBridgeError.collectorApply("Invalid collector entry at index \(index)")
       }
       guard let key = entry["key"] as? String, !key.isEmpty else {
-        throw DaVinciBridgeError.argument("Missing 'key' in collector entry at index \(index)")
+        throw DaVinciBridgeError.collectorApply("Missing 'key' in collector entry at index \(index)")
       }
       mutations.append(
         CollectorMutation(
@@ -80,7 +80,7 @@ enum DaVinciCollectorValueApplier {
     var isFlowTrigger = false
     for mutation in mutations {
       guard let collector = collectorsByKey[mutation.key] else {
-        throw DaVinciBridgeError.argument("No active collector found for key='\(mutation.key)'")
+        throw DaVinciBridgeError.collectorApply("No active collector found for key='\(mutation.key)'")
       }
       try applyValue(collector, key: mutation.key, value: mutation.value)
       if collector is FlowCollector {
@@ -111,16 +111,19 @@ enum DaVinciCollectorValueApplier {
       if let phoneNumber = map["phoneNumber"] {
         phoneNumberCollector.phoneNumber = phoneNumber
       }
+      if let extensionValue = map["extension"] {
+        phoneNumberCollector.extension = extensionValue
+      }
 
     case let registrationCollector as DeviceRegistrationCollector:
       let map = asStringMap(value)
       guard let deviceType = map["type"] else {
-        throw DaVinciBridgeError.argument(
+        throw DaVinciBridgeError.collectorApply(
           "DeviceRegistrationCollector key='\(key)': value map must include 'type'"
         )
       }
       guard let device = registrationCollector.devices.first(where: { $0.type == deviceType }) else {
-        throw DaVinciBridgeError.argument(
+        throw DaVinciBridgeError.collectorApply(
           "DeviceRegistrationCollector key='\(key)': no device found with type='\(deviceType)'"
         )
       }
@@ -129,7 +132,7 @@ enum DaVinciCollectorValueApplier {
     case let authenticationCollector as DeviceAuthenticationCollector:
       let map = asStringMap(value)
       guard let deviceType = map["type"] else {
-        throw DaVinciBridgeError.argument(
+        throw DaVinciBridgeError.collectorApply(
           "DeviceAuthenticationCollector key='\(key)': value map must include 'type'"
         )
       }
@@ -179,7 +182,7 @@ enum DaVinciCollectorValueApplier {
   ///   - value: Dynamic value.
   ///   - key: Collector key (used in error messages).
   /// - Returns: String value.
-  /// - Throws: `DaVinciBridgeError.argument` when value cannot be represented as a string.
+  /// - Throws: `DaVinciBridgeError.collectorApply` when value cannot be represented as a string.
   private static func asString(_ value: Any?, key: String) throws -> String {
     switch value {
     case let string as String:
@@ -193,7 +196,7 @@ enum DaVinciCollectorValueApplier {
       }
       return number.stringValue
     default:
-      throw DaVinciBridgeError.argument(
+      throw DaVinciBridgeError.collectorApply(
         "Collector key='\(key)' expects a string-compatible value"
       )
     }
@@ -205,7 +208,7 @@ enum DaVinciCollectorValueApplier {
   ///   - value: Dynamic value.
   ///   - key: Collector key (used in error messages).
   /// - Returns: Array of strings.
-  /// - Throws: `DaVinciBridgeError.argument` when value is not an array or contains a non-String element.
+  /// - Throws: `DaVinciBridgeError.collectorApply` when value is not an array or contains a non-String element.
   private static func asStringList(_ value: Any?, key: String) throws -> [String] {
     let elements: [Any]
     if let array = value as? [Any] {
@@ -213,13 +216,13 @@ enum DaVinciCollectorValueApplier {
     } else if let array = value as? NSArray {
       elements = Array(array)
     } else {
-      throw DaVinciBridgeError.argument(
+      throw DaVinciBridgeError.collectorApply(
         "Collector key='\(key)' expects an array of strings"
       )
     }
     return try elements.map { element in
       guard let string = element as? String else {
-        throw DaVinciBridgeError.argument(
+        throw DaVinciBridgeError.collectorApply(
           "Collector key='\(key)' expects an array of strings, got \(type(of: element))"
         )
       }
@@ -235,7 +238,7 @@ enum DaVinciCollectorValueApplier {
   ///   - type: Resolved device type string.
   ///   - key: Collector key (used for error messages).
   /// - Returns: A `Device` decoded from the map fields.
-  /// - Throws: `DaVinciBridgeError.argument` when the JSON cannot be decoded.
+  /// - Throws: `DaVinciBridgeError.collectorApply` when the JSON cannot be decoded.
   private static func makeFallbackDevice(
     from map: [String: String],
     type deviceType: String,
@@ -253,7 +256,7 @@ enum DaVinciCollectorValueApplier {
       let data = try JSONSerialization.data(withJSONObject: json)
       return try JSONDecoder().decode(Device.self, from: data)
     } catch {
-      throw DaVinciBridgeError.argument(
+      throw DaVinciBridgeError.collectorApply(
         "DeviceAuthenticationCollector key='\(key)': failed to construct fallback device"
       )
     }
@@ -265,7 +268,7 @@ enum DaVinciCollectorValueApplier {
   ///   - value: Dynamic value.
   ///   - key: Collector key (used in error messages).
   /// - Returns: Bool value.
-  /// - Throws: `DaVinciBridgeError.argument` when value cannot be represented as a Bool.
+  /// - Throws: `DaVinciBridgeError.collectorApply` when value cannot be represented as a Bool.
   private static func asBoolean(_ value: Any?, key: String) throws -> Bool {
     switch value {
     case let bool as Bool:
@@ -278,7 +281,7 @@ enum DaVinciCollectorValueApplier {
     case let string as String:
       return string.lowercased() == "true"
     default:
-      throw DaVinciBridgeError.argument(
+      throw DaVinciBridgeError.collectorApply(
         "Collector key='\(key)' expects a boolean value"
       )
     }
diff --git a/packages/davinci/ios/Error/DaVinciErrorCodes.swift b/packages/davinci/ios/Error/DaVinciErrorCodes.swift
index 7810f8143..a99bf401d 100644
--- a/packages/davinci/ios/Error/DaVinciErrorCodes.swift
+++ b/packages/davinci/ios/Error/DaVinciErrorCodes.swift
@@ -28,4 +28,5 @@ enum DaVinciErrorCodes: String {
   case missingIntegrationError = "DAVINCI_MISSING_INTEGRATION_ERROR"
   case unknownError = "DAVINCI_UNKNOWN_ERROR"
   case protectCollectError = "DAVINCI_PROTECT_COLLECT_ERROR"
+  case validateError = "DAVINCI_VALIDATE_ERROR"
 }
diff --git a/packages/davinci/ios/Mapper/DaVinciNodeMapper.swift b/packages/davinci/ios/Mapper/DaVinciNodeMapper.swift
index c634bf13c..f5bd1f9c0 100644
--- a/packages/davinci/ios/Mapper/DaVinciNodeMapper.swift
+++ b/packages/davinci/ios/Mapper/DaVinciNodeMapper.swift
@@ -26,7 +26,10 @@ enum DaVinciNodeMapper {
   ///   - node: Native DaVinci node.
   ///   - logger: Optional Ping logger for non-fatal mapping warnings.
   /// - Returns: Serialized node payload.
-  static func mapNode(_ node: Node, logger: Logger? = nil) -> NSDictionary {
+  static func mapNode(
+    _ node: Node,
+    logger: Logger? = nil
+  ) -> NSDictionary {
     return JsonBridgeMapper.encodeJsonObject(mapNodePayload(node, logger: logger))
   }
 
@@ -36,7 +39,10 @@ enum DaVinciNodeMapper {
   ///   - node: Native DaVinci node.
   ///   - logger: Optional Ping logger for non-fatal mapping warnings.
   /// - Returns: Serializable node payload map.
-  static func mapNodePayload(_ node: Node, logger: Logger? = nil) -> [String: Any] {
+  static func mapNodePayload(
+    _ node: Node,
+    logger: Logger? = nil
+  ) -> [String: Any] {
     var payload = [String: Any]()
 
     switch node {
@@ -82,6 +88,35 @@ enum DaVinciNodeMapper {
     return payload
   }
 
+  /// Maps a native `ValidationError` to the stable JS-facing error code contract.
+  ///
+  /// - Parameter error: Native validation error produced by a collector's `validate()`.
+  /// - Returns: Serialized `{code, ...}` error payload.
+  static func encodeValidationError(_ error: ValidationError) -> [String: Any] {
+    switch error {
+    case .required:
+      return ["code": "REQUIRED"]
+    case .regexError(let message):
+      return ["code": "REGEX_ERROR", "message": message]
+    case .invalidLength(let min, let max):
+      return ["code": "INVALID_LENGTH", "min": min, "max": max]
+    case .uniqueCharacter(let min):
+      return ["code": "UNIQUE_CHARACTER", "min": min]
+    case .maxRepeat(let max):
+      return ["code": "MAX_REPEAT", "max": max]
+    case .minCharacters(let character, let min):
+      return ["code": "MIN_CHARACTERS", "character": character, "min": min]
+    }
+  }
+
+  /// Maps a list of native `ValidationError`s captured from a submitted collector.
+  ///
+  /// - Parameter errors: Native validation errors from a collector's `validate()` call.
+  /// - Returns: Serialized list of `{code, ...}` error payloads.
+  static func encodeValidationErrors(_ errors: [ValidationError]) -> [[String: Any]] {
+    return errors.map(encodeValidationError)
+  }
+
   /// Serializes all `Collector` instances from a `ContinueNode` into an array.
   ///
   /// Unknown collector subtypes are skipped gracefully.
@@ -232,7 +267,7 @@ enum DaVinciNodeMapper {
     case let textCollector as TextCollector:
       map = mapTextCollector(textCollector, node: node)
     case let passwordCollector as PasswordCollector:
-      map = mapPasswordCollector(passwordCollector, node: node, logger: logger)
+      map = mapPasswordCollector(passwordCollector, logger: logger)
     case let submitCollector as SubmitCollector:
       map = mapBaseFieldCollector(submitCollector)
     case let flowCollector as FlowCollector:
@@ -353,54 +388,40 @@ enum DaVinciNodeMapper {
   ///   never round-trips the entered password back to JS. This matches the
   ///   `PasswordCollector.value` contract in the public TypeScript types and aligns
   ///   with the Android bridge's emission.
+  ///
+  /// - Note: `passwordPolicy` is read through the native `passwordPolicy()` accessor,
+  ///   which resolves the field-level policy first and falls back to the node-root policy.
   private static func mapPasswordCollector(
     _ collector: PasswordCollector,
-    node: ContinueNode,
     logger: Logger?
   ) -> [String: Any] {
     var map = baseFieldCollectorMap(collector)
     map["value"] = ""
     map["clearPassword"] = collector.clearPassword
-    if let policy = extractPasswordPolicy(collector.key, node: node, logger: logger) {
-      map["passwordPolicy"] = policy
+    if let validation = collector.validation, let regex = validation.regex {
+      map["validation"] = ["regex": regex.pattern]
+    }
+    if let policy = collector.passwordPolicy(), let encoded = encodePasswordPolicy(policy, logger: logger) {
+      map["passwordPolicy"] = encoded
     }
     return map
   }
 
-  /// Reads passwordPolicy from the raw JSON at
-  /// `continueNode.input.form.components.fields[].passwordPolicy` by matching the
-  /// collector key.
+  /// Serializes a native `PasswordPolicy` into its bridge payload shape.
   ///
-  /// The SDK's own `passwordPolicy()` method reads from the node root
-  /// (`continueNode.input["passwordPolicy"]`) which is the wrong path — that is why
-  /// the bridge does the lookup itself.
-  ///
-  /// - Returns: Bridge-encoded password policy dictionary, or `nil` when missing.
-  private static func extractPasswordPolicy(
-    _ collectorKey: String,
-    node: ContinueNode,
-    logger: Logger?
-  ) -> NSDictionary? {
-    guard
-      let field = findFieldJson(collectorKey, node: node, logger: logger),
-      let policyDict = field["passwordPolicy"] as? [String: Any]
-    else {
-      return nil
-    }
-
+  /// - Parameters:
+  ///   - policy: Native password policy value.
+  ///   - logger: Optional Ping logger for non-fatal encoding warnings.
+  /// - Returns: Bridge-encoded password policy dictionary, or `nil` on encoding failure.
+  private static func encodePasswordPolicy(_ policy: PasswordPolicy, logger: Logger?) -> NSDictionary? {
     do {
-      let data = try JSONSerialization.data(withJSONObject: policyDict, options: [])
-      let policy = try JSONDecoder().decode(PasswordPolicy.self, from: data)
       let encoded = try JSONEncoder().encode(policy)
       if let object = try JSONSerialization.jsonObject(with: encoded) as? [String: Any] {
         return JsonBridgeMapper.encodeJsonObject(object)
       }
       return nil
     } catch {
-      logger?.w(
-        "[\(logTag)] Failed to extract password policy for key=\(collectorKey)",
-        error: error
-      )
+      logger?.w("[\(logTag)] Failed to encode password policy", error: error)
       return nil
     }
   }
@@ -410,11 +431,35 @@ enum DaVinciNodeMapper {
   /// - Parameter collector: LabelCollector instance.
   /// - Returns: Serialized label collector map.
   private static func mapLabelCollector(_ collector: LabelCollector) -> [String: Any] {
-    return [
+    var map: [String: Any] = [
       "key": collector.key,
       "type": "LABEL",
       "content": collector.content
     ]
+    if let rc = collector.richContent {
+      map["richContent"] = encodeRichContent(rc)
+    }
+    return map
+  }
+
+  /// Serializes a native `RichContent` into its bridge payload shape.
+  ///
+  /// - Parameter rc: Native rich-content payload.
+  /// - Returns: Serialized `{content, replacements}` map.
+  private static func encodeRichContent(_ rc: RichContent) -> [String: Any] {
+    return [
+      "content": rc.content,
+      "replacements": Dictionary(
+        uniqueKeysWithValues: rc.replacements.map { (k, r) in
+          (k, [
+            "value": r.value,
+            "href": r.href ?? "",
+            "type": r.type,
+            "target": r.target ?? ""
+          ] as [String: Any])
+        }
+      )
+    ]
   }
 
   /// Serializes a `SingleSelectCollector` to a bridge map, including value and options.
@@ -452,6 +497,9 @@ enum DaVinciNodeMapper {
     map["validatePhoneNumber"] = collector.validatePhoneNumber
     map["countryCode"] = collector.countryCode
     map["phoneNumber"] = collector.phoneNumber
+    map["extension"] = collector.extension
+    map["showExtension"] = collector.showExtension
+    map["extensionLabel"] = collector.extensionLabel
     return map
   }
 
@@ -490,19 +538,7 @@ enum DaVinciNodeMapper {
     map["appearance"] = collector.appearance.rawValue
     map["errorMessage"] = collector.errorMessage ?? ""
     if let rc = collector.richContent {
-      map["richContent"] = [
-        "content": rc.content,
-        "replacements": Dictionary(
-          uniqueKeysWithValues: rc.replacements.map { (k, r) in
-            (k, [
-              "value": r.value,
-              "href": r.href ?? "",
-              "type": r.type,
-              "target": r.target ?? ""
-            ] as [String: Any])
-          }
-        )
-      ] as [String: Any]
+      map["richContent"] = encodeRichContent(rc)
     }
     return map
   }
diff --git a/packages/davinci/ios/RNPingDavinci.mm b/packages/davinci/ios/RNPingDavinci.mm
index 97ace6aaf..40ccc99f9 100644
--- a/packages/davinci/ios/RNPingDavinci.mm
+++ b/packages/davinci/ios/RNPingDavinci.mm
@@ -190,6 +190,16 @@ - (void)next:(NSString *)davinciId
   [[self swiftImpl] next:davinciId input:input resolver:resolve rejecter:reject];
 }
 
+/// Bridges `validate(davinciId, collectorKey, input)`.
+- (void)validate:(NSString *)davinciId
+     collectorKey:(NSString *)collectorKey
+            input:(NSDictionary *)input
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+  [[self swiftImpl] validate:davinciId collectorKey:collectorKey input:input resolver:resolve rejecter:reject];
+}
+
 /// Bridges `getSession(davinciId)`.
 - (void)getSession:(NSString *)davinciId
            resolve:(RCTPromiseResolveBlock)resolve
diff --git a/packages/davinci/ios/RNPingDavinciClassic.mm b/packages/davinci/ios/RNPingDavinciClassic.mm
index 2e937d2af..e59444c04 100644
--- a/packages/davinci/ios/RNPingDavinciClassic.mm
+++ b/packages/davinci/ios/RNPingDavinciClassic.mm
@@ -128,6 +128,18 @@ - (void)withSwiftImpl:(void (^)(RNPingDavinciImpl *impl))block
   }];
 }
 
+/// Validates a single collector value without advancing the DaVinci flow.
+RCT_EXPORT_METHOD(validate:(NSString *)davinciId
+                  collectorKey:(NSString *)collectorKey
+                  input:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [self withSwiftImpl:^(RNPingDavinciImpl *impl) {
+    [impl validate:davinciId collectorKey:collectorKey input:input resolver:resolve rejecter:reject];
+  }];
+}
+
 /// Returns session details for a DaVinci client.
 RCT_EXPORT_METHOD(getSession:(NSString *)davinciId
                   resolver:(RCTPromiseResolveBlock)resolve
diff --git a/packages/davinci/ios/RNPingDavinciCommon.swift b/packages/davinci/ios/RNPingDavinciCommon.swift
index 89655419e..57572860a 100644
--- a/packages/davinci/ios/RNPingDavinciCommon.swift
+++ b/packages/davinci/ios/RNPingDavinciCommon.swift
@@ -70,6 +70,8 @@ public final class RNPingDavinciCommon: NSObject {
   public typealias VoidResolver = @Sendable () -> Void
   /// Promise resolver for poll subscription payloads.
   public typealias PollResolver = @Sendable (NSDictionary) -> Void
+  /// Promise resolver for validation error array payloads.
+  public typealias ErrorsResolver = @Sendable (NSArray) -> Void
   /// Promise rejecter closure type used by the DaVinci Swift bridge.
   public typealias PromiseRejecter = @Sendable (String, String, NSError?) -> Void
 
@@ -245,6 +247,94 @@ public final class RNPingDavinciCommon: NSObject {
     }
   }
 
+  /// Validates a single collector value in isolation, without submitting the form via `next()`.
+  ///
+  /// Applies `value` onto the live collector identified by `collectorKey` using the same
+  /// `DaVinciCollectorValueApplier.apply()` machinery `next()` uses, then runs native
+  /// `Validator.validate()` on that collector and returns its errors.
+  ///
+  /// - Remarks: This is a command-query hybrid, not a pure check — applying `value` mutates the
+  ///   live collector backing the in-progress submission, so it becomes part of what a
+  ///   subsequent `next()` call submits even if the caller only intended a speculative preview.
+  ///   An empty result array means either "no validation errors" or "this collector has no
+  ///   `Validator`" — not a positive confirmation the value was checked.
+  ///
+  /// - Note: iOS naturally serializes concurrent bridge calls onto the `@MainActor`, so a
+  ///   `validate()` call cannot race a concurrent `next()`/`validate()` call mutating the same
+  ///   node's collectors. Android has no equivalent guard (`launchBridge` runs on the shared
+  ///   `Dispatchers.Default` pool with no per-`davinciId` mutex/actor) — see the Android
+  ///   `RNPingDavinciCommon.validate` implementation for the documented trade-off.
+  ///
+  /// - Parameters:
+  ///   - davinciId: Native DaVinci instance id.
+  ///   - collectorKey: Key of the collector to validate.
+  ///   - input: Bridge input in the same `{ collectors: [{ key, value }] }` shape `next()`
+  ///     uses, containing exactly the single collector entry to validate.
+  ///   - resolver: Promise resolver called with the collector's validation error array.
+  ///   - rejecter: Promise rejecter called with `GenericError`.
+  @objc
+  public static func validate(
+    _ davinciId: String,
+    collectorKey: String,
+    input: NSDictionary,
+    resolver: @escaping ErrorsResolver,
+    rejecter: @escaping PromiseRejecter
+  ) {
+    let promise = PromiseBridge<NSArray>(resolver: resolver, rejecter: rejecter)
+    let mutations: [DaVinciCollectorValueApplier.CollectorMutation]
+    do {
+      mutations = try DaVinciCollectorValueApplier.parseInput(input)
+    } catch {
+      promise.reject(DaVinciErrorMapper.map(error, code: .validateError))
+      return
+    }
+
+    Task { @MainActor in
+      guard let currentNode = stateStore.activeContinueNode(for: davinciId) else {
+        promise.reject(
+          DaVinciErrorMapper.state(
+            code: .stateError,
+            message: "No active ContinueNode found for davinci id=\(davinciId)"
+          )
+        )
+        return
+      }
+
+      do {
+        _ = try DaVinciCollectorValueApplier.apply(currentNode, mutations: mutations)
+      } catch {
+        promise.reject(DaVinciErrorMapper.map(error, code: .validateError))
+        return
+      }
+
+      // apply() succeeded above, so collectorKey is guaranteed to resolve to a collector
+      // on currentNode — the nil branches below are unreachable in practice.
+      guard let collector = currentNode.collectors.first(where: { $0.id == collectorKey }) else {
+        promise.resolve([] as NSArray)
+        return
+      }
+
+      guard let validator = collector as? Validator else {
+        promise.resolve([] as NSArray)
+        return
+      }
+
+      let validationErrors = validator.validate()
+      let encodedErrors: [[String: Any]]
+      if let booleanCollector = collector as? BooleanCollector,
+         booleanCollector.required,
+         !booleanCollector.value {
+        // TODO-SDK-PARITY: iOS emits REGEX_ERROR for a required unchecked Boolean
+        // when errorMessage is present, while Android emits REQUIRED. Normalize
+        // the bridge contract to the platform-independent REQUIRED error.
+        encodedErrors = [["code": "REQUIRED"]]
+      } else {
+        encodedErrors = DaVinciNodeMapper.encodeValidationErrors(validationErrors)
+      }
+      promise.resolve(encodedErrors as NSArray)
+    }
+  }
+
   /// Resolves active session data for a DaVinci user.
   ///
   /// - Parameters:
@@ -751,20 +841,38 @@ private final class DaVinciStateStore: @unchecked Sendable {
   /// Android bridge: this clears `PasswordCollector.value` and `FlowCollector.value`
   /// before the new node takes over.
   ///
+  /// - Remarks: When `node` is an `ErrorNode` carrying a retryable continuation (native
+  ///   `ErrorNode.continueNode`), that continuation is kept as the active `ContinueNode`
+  ///   instead of being closed — matching native SDK behavior, where `validate()` and
+  ///   `next()` are independent operations and a recoverable error does not discard the
+  ///   in-progress form. The continuation is only closed once a genuinely different
+  ///   `ContinueNode` (or a terminal `SuccessNode`/`FailureNode`) displaces it.
+  ///
   /// - Parameters:
   ///   - davinciId: Native DaVinci instance id.
   ///   - node: Latest node received from the DaVinci workflow.
   func setNode(davinciId: String, node: Node) {
     lock.lock()
     nodeMap[davinciId] = node
+    let retainedContinueNode: ContinueNode?
+    switch node {
+    case let continueNode as ContinueNode:
+      retainedContinueNode = continueNode
+    case let errorNode as ErrorNode:
+      retainedContinueNode = errorNode.continueNode
+    default:
+      retainedContinueNode = nil
+    }
     let previousContinueNode: ContinueNode?
-    if let continueNode = node as? ContinueNode {
-      previousContinueNode = continueNodeMap.updateValue(continueNode, forKey: davinciId)
+    if let retainedContinueNode {
+      previousContinueNode = continueNodeMap.updateValue(retainedContinueNode, forKey: davinciId)
     } else {
       previousContinueNode = continueNodeMap.removeValue(forKey: davinciId)
     }
     lock.unlock()
-    previousContinueNode?.close()
+    if previousContinueNode !== retainedContinueNode {
+      previousContinueNode?.close()
+    }
   }
 
   /// Resolves active continue node for a DaVinci id.
diff --git a/packages/davinci/ios/RNPingDavinciImpl.swift b/packages/davinci/ios/RNPingDavinciImpl.swift
index 5e8af4580..95e639054 100644
--- a/packages/davinci/ios/RNPingDavinciImpl.swift
+++ b/packages/davinci/ios/RNPingDavinciImpl.swift
@@ -24,6 +24,8 @@ public final class RNPingDavinciImpl: NSObject, @unchecked Sendable {
   public typealias VoidResolver = @Sendable () -> Void
   /// Promise resolver for poll subscription payloads.
   public typealias PollResolver = @Sendable (NSDictionary) -> Void
+  /// Promise resolver for validation error array payloads.
+  public typealias ErrorsResolver = @Sendable (NSArray) -> Void
   /// Promise rejecter closure type used by the DaVinci Swift bridge.
   public typealias PromiseRejecter = @Sendable (String, String, NSError?) -> Void
 
@@ -87,6 +89,31 @@ public final class RNPingDavinciImpl: NSObject, @unchecked Sendable {
     RNPingDavinciCommon.next(davinciId, input: input, resolver: resolver, rejecter: rejecter)
   }
 
+  /// Validates a single collector value without submitting the form via `next()`.
+  ///
+  /// - Parameters:
+  ///   - davinciId: Native DaVinci instance id.
+  ///   - collectorKey: Key of the collector to validate.
+  ///   - input: Bridge input in the same `{ collectors: [{ key, value }] }` shape `next()` uses.
+  ///   - resolver: Promise resolver called with the collector's validation error array.
+  ///   - rejecter: Promise rejecter called with `GenericError`.
+  @objc(validate:collectorKey:input:resolver:rejecter:)
+  public func validate(
+    _ davinciId: String,
+    collectorKey: String,
+    input: NSDictionary,
+    resolver: @escaping ErrorsResolver,
+    rejecter: @escaping PromiseRejecter
+  ) {
+    RNPingDavinciCommon.validate(
+      davinciId,
+      collectorKey: collectorKey,
+      input: input,
+      resolver: resolver,
+      rejecter: rejecter
+    )
+  }
+
   /// Resolves session details for an active DaVinci user.
   ///
   /// - Parameters:
diff --git a/packages/davinci/ios/Tests/DaVinciCollectorValueApplierTests.swift b/packages/davinci/ios/Tests/DaVinciCollectorValueApplierTests.swift
index 5850ac656..22b628b4e 100644
--- a/packages/davinci/ios/Tests/DaVinciCollectorValueApplierTests.swift
+++ b/packages/davinci/ios/Tests/DaVinciCollectorValueApplierTests.swift
@@ -52,8 +52,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       "collectors": ["invalid-item"]
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.parseInput(input)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("Invalid collector entry at index 0"))
     }
@@ -66,8 +66,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       ]
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.parseInput(input)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("Missing 'key'"))
     }
@@ -80,8 +80,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       ]
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.parseInput(input)) { error in
-      guard case DaVinciBridgeError.argument = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case DaVinciBridgeError.collectorApply = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
     }
   }
@@ -148,8 +148,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
     ])
     let mutations = [DaVinciCollectorValueApplier.CollectorMutation(key: "unknown", value: "v")]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.apply(node, mutations: mutations)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("No active collector found for key='unknown'"))
     }
@@ -212,6 +212,21 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
     XCTAssertEqual(collector.phoneNumber, "0700000")
   }
 
+  func testApplyPhoneNumberCollectorSetsExtensionField() throws {
+    let collector = makePhoneNumberCollector(key: "phone")
+    let node = makeContinueNode(collectors: [collector])
+    let value: NSDictionary = [
+      "countryCode": "+1", "phoneNumber": "5551234", "extension": "99"
+    ]
+    let mutations = [
+      DaVinciCollectorValueApplier.CollectorMutation(key: "phone", value: value)
+    ]
+    _ = try DaVinciCollectorValueApplier.apply(node, mutations: mutations)
+    XCTAssertEqual(collector.countryCode, "+1")
+    XCTAssertEqual(collector.phoneNumber, "5551234")
+    XCTAssertEqual(collector.extension, "99")
+  }
+
   // MARK: - apply — DeviceRegistrationCollector
 
   func testApplyMutatesDeviceRegistrationCollector() throws {
@@ -233,8 +248,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       DaVinciCollectorValueApplier.CollectorMutation(key: "device", value: NSDictionary())
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.apply(node, mutations: mutations)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("value map must include 'type'"))
     }
@@ -248,8 +263,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       DaVinciCollectorValueApplier.CollectorMutation(key: "device", value: value)
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.apply(node, mutations: mutations)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("no device found with type='FIDO'"))
     }
@@ -288,8 +303,8 @@ final class DaVinciCollectorValueApplierTests: XCTestCase {
       DaVinciCollectorValueApplier.CollectorMutation(key: "auth", value: NSDictionary())
     ]
     XCTAssertThrowsError(try DaVinciCollectorValueApplier.apply(node, mutations: mutations)) { error in
-      guard case let DaVinciBridgeError.argument(message) = error else {
-        return XCTFail("Expected argument error, got \(error)")
+      guard case let DaVinciBridgeError.collectorApply(message) = error else {
+        return XCTFail("Expected collectorApply error, got \(error)")
       }
       XCTAssertTrue(message.contains("value map must include 'type'"))
     }
diff --git a/packages/davinci/ios/Tests/DaVinciNodeMapperTests.swift b/packages/davinci/ios/Tests/DaVinciNodeMapperTests.swift
index 88f2d6c16..4516cb9b1 100644
--- a/packages/davinci/ios/Tests/DaVinciNodeMapperTests.swift
+++ b/packages/davinci/ios/Tests/DaVinciNodeMapperTests.swift
@@ -192,20 +192,15 @@ final class DaVinciNodeMapperTests: XCTestCase {
     XCTAssertEqual(first?["clearPassword"] as? Bool, false)
   }
 
-  func testMapPasswordCollectorIncludesPasswordPolicyFromFormField() {
-    let input: [String: Any] = [
-      "form": [
-        "components": [
-          "fields": [
-            [
-              "key": "password", "type": "PASSWORD", "label": "Password", "required": false,
-              "passwordPolicy": ["name": "strong", "length": ["min": 8, "max": 64]]
-            ]
-          ]
-        ]
-      ]
-    ]
-    let node = makeContinueNode(collectors: [makePasswordCollector(key: "password")], input: input)
+  func testMapPasswordCollectorUsesNativePasswordPolicyAccessor() {
+    // `passwordPolicy()` resolves the field-level policy first — the same JSON the
+    // collector itself was constructed from — rather than a raw-JSON traversal of
+    // node.input.form.components.fields[].
+    let collector = PasswordCollector(with: [
+      "key": "password", "type": "PASSWORD", "label": "Password", "required": false,
+      "passwordPolicy": ["name": "strong", "length": ["min": 8, "max": 64]]
+    ])
+    let node = makeContinueNode(collectors: [collector])
 
     let payload = DaVinciNodeMapper.mapNodePayload(node)
     let first = (payload["collectors"] as? [[String: Any]])?.first
@@ -215,40 +210,29 @@ final class DaVinciNodeMapperTests: XCTestCase {
     XCTAssertEqual(policy?["name"] as? String, "strong")
   }
 
-  func testMapPasswordCollectorOmitsPasswordPolicyWhenAbsentFromFormField() {
-    let input: [String: Any] = [
-      "form": [
-        "components": [
-          "fields": [
-            ["key": "password", "type": "PASSWORD", "label": "Password", "required": false]
-          ]
-        ]
-      ]
-    ]
-    let node = makeContinueNode(collectors: [makePasswordCollector(key: "password")], input: input)
+  func testMapPasswordCollectorFallsBackToNodeRootPasswordPolicy() {
+    // When no field-level policy is present, `passwordPolicy()` falls back to
+    // `continueNode.input["passwordPolicy"]` (node-root scope).
+    let collector = PasswordCollector(with: [
+      "key": "password", "type": "PASSWORD", "label": "Password", "required": false
+    ])
+    let node = makeContinueNode(
+      collectors: [collector],
+      input: ["passwordPolicy": ["name": "Global Policy", "maxAgeDays": 30]]
+    )
+    collector.continueNode = node
 
     let payload = DaVinciNodeMapper.mapNodePayload(node)
     let first = (payload["collectors"] as? [[String: Any]])?.first
+    let policy = first?["passwordPolicy"] as? NSDictionary
 
-    XCTAssertNil(first?["passwordPolicy"])
+    XCTAssertNotNil(policy)
+    XCTAssertEqual(policy?["name"] as? String, "Global Policy")
+    XCTAssertEqual(policy?["maxAgeDays"] as? Int, 30)
   }
 
-  func testMapPasswordCollectorOmitsPasswordPolicyOnDecodeError() {
-    // "length" must be a keyed container but receives a String, so JSONDecoder throws
-    // DecodingError.typeMismatch — the catch block returns nil and policy is omitted.
-    let input: [String: Any] = [
-      "form": [
-        "components": [
-          "fields": [
-            [
-              "key": "password", "type": "PASSWORD", "label": "Password", "required": false,
-              "passwordPolicy": ["length": "not-a-dict"]
-            ]
-          ]
-        ]
-      ]
-    ]
-    let node = makeContinueNode(collectors: [makePasswordCollector(key: "password")], input: input)
+  func testMapPasswordCollectorOmitsPasswordPolicyWhenAbsent() {
+    let node = makeContinueNode(collectors: [makePasswordCollector(key: "password")])
 
     let payload = DaVinciNodeMapper.mapNodePayload(node)
     let first = (payload["collectors"] as? [[String: Any]])?.first
@@ -256,6 +240,54 @@ final class DaVinciNodeMapperTests: XCTestCase {
     XCTAssertNil(first?["passwordPolicy"])
   }
 
+  func testMapPasswordCollectorIncludesValidationRegexWhenPresent() {
+    let node = makeContinueNode(collectors: [
+      PasswordCollector(with: [
+        "key": "password", "type": "PASSWORD", "label": "Password", "required": false,
+        "validation": ["regex": "^.{8,}$", "errorMessage": "Password is too short"]
+      ])
+    ])
+
+    let payload = DaVinciNodeMapper.mapNodePayload(node)
+    let first = (payload["collectors"] as? [[String: Any]])?.first
+    let validation = first?["validation"] as? [String: Any]
+
+    XCTAssertNotNil(validation)
+    XCTAssertNotNil(validation?["regex"])
+  }
+
+  // MARK: - Validation error encoding
+
+  func testMapValidationErrorsIncludesRequiredAndRegex() {
+    let required = DaVinciNodeMapper.encodeValidationError(.required)
+    XCTAssertEqual(required["code"] as? String, "REQUIRED")
+
+    let regex = DaVinciNodeMapper.encodeValidationError(.regexError(message: "Invalid value"))
+    XCTAssertEqual(regex["code"] as? String, "REGEX_ERROR")
+    XCTAssertEqual(regex["message"] as? String, "Invalid value")
+  }
+
+  func testMapPasswordValidationErrorsIncludesPolicyConstraints() {
+    let errors = DaVinciNodeMapper.encodeValidationErrors([
+      .invalidLength(min: 8, max: 64),
+      .uniqueCharacter(min: 3),
+      .maxRepeat(max: 2),
+      .minCharacters(character: "digit", min: 1)
+    ])
+
+    XCTAssertEqual(errors.count, 4)
+    XCTAssertEqual(errors[0]["code"] as? String, "INVALID_LENGTH")
+    XCTAssertEqual(errors[0]["min"] as? Int, 8)
+    XCTAssertEqual(errors[0]["max"] as? Int, 64)
+    XCTAssertEqual(errors[1]["code"] as? String, "UNIQUE_CHARACTER")
+    XCTAssertEqual(errors[1]["min"] as? Int, 3)
+    XCTAssertEqual(errors[2]["code"] as? String, "MAX_REPEAT")
+    XCTAssertEqual(errors[2]["max"] as? Int, 2)
+    XCTAssertEqual(errors[3]["code"] as? String, "MIN_CHARACTERS")
+    XCTAssertEqual(errors[3]["character"] as? String, "digit")
+    XCTAssertEqual(errors[3]["min"] as? Int, 1)
+  }
+
   func testMapSubmitCollectorIncludesBaseFields() {
     let node = makeContinueNode(collectors: [
       SubmitCollector(with: ["key": "submit", "type": "SUBMIT_BUTTON", "label": "Submit", "required": false])
@@ -292,6 +324,48 @@ final class DaVinciNodeMapperTests: XCTestCase {
     XCTAssertEqual(first?["content"] as? String, "Sign In")
   }
 
+  func testMapLabelCollectorIncludesRichContentWhenPresent() {
+    let node = makeContinueNode(collectors: [
+      LabelCollector(with: [
+        "key": "terms",
+        "content": "Read the terms",
+        "richContent": [
+          "content": "Read the {{terms}}",
+          "replacements": [
+            "terms": [
+              "value": "terms",
+              "href": "https://example.com/terms",
+              "type": "link",
+              "target": "_blank"
+            ]
+          ]
+        ]
+      ])
+    ])
+
+    let payload = DaVinciNodeMapper.mapNodePayload(node)
+    let first = (payload["collectors"] as? [[String: Any]])?.first
+    let rc = first?["richContent"] as? [String: Any]
+
+    XCTAssertNotNil(rc)
+    XCTAssertEqual(rc?["content"] as? String, "Read the {{terms}}")
+    let replacements = rc?["replacements"] as? [String: Any]
+    let termsReplacement = replacements?["terms"] as? [String: Any]
+    XCTAssertEqual(termsReplacement?["href"] as? String, "https://example.com/terms")
+    XCTAssertEqual(termsReplacement?["target"] as? String, "_blank")
+  }
+
+  func testMapLabelCollectorOmitsRichContentWhenAbsent() {
+    let node = makeContinueNode(collectors: [
+      LabelCollector(with: ["key": "title", "content": "Sign In"])
+    ])
+
+    let payload = DaVinciNodeMapper.mapNodePayload(node)
+    let first = (payload["collectors"] as? [[String: Any]])?.first
+
+    XCTAssertNil(first?["richContent"])
+  }
+
   func testMapSingleSelectCollectorIncludesOptionsAndValue() {
     let node = makeContinueNode(collectors: [
       SingleSelectCollector(with: [
@@ -349,6 +423,23 @@ final class DaVinciNodeMapperTests: XCTestCase {
     XCTAssertEqual(first?["validatePhoneNumber"] as? Bool, true)
   }
 
+  func testMapPhoneNumberCollectorIncludesExtensionFields() {
+    let collector = PhoneNumberCollector(with: [
+      "key": "phone", "type": "PHONE", "label": "Phone", "required": false,
+      "defaultCountryCode": "+1", "validatePhoneNumber": true,
+      "showExtension": true, "extensionLabel": "Extension"
+    ])
+    collector.extension = "99"
+    let node = makeContinueNode(collectors: [collector])
+
+    let payload = DaVinciNodeMapper.mapNodePayload(node)
+    let first = (payload["collectors"] as? [[String: Any]])?.first
+
+    XCTAssertEqual(first?["extension"] as? String, "99")
+    XCTAssertEqual(first?["showExtension"] as? Bool, true)
+    XCTAssertEqual(first?["extensionLabel"] as? String, "Extension")
+  }
+
   func testMapDeviceRegistrationCollectorIncludesDevices() {
     let node = makeContinueNode(collectors: [
       DeviceRegistrationCollector(with: [
diff --git a/packages/davinci/ios/Tests/RNPingDavinciCommonTests.swift b/packages/davinci/ios/Tests/RNPingDavinciCommonTests.swift
index 533efeb99..d43d644e2 100644
--- a/packages/davinci/ios/Tests/RNPingDavinciCommonTests.swift
+++ b/packages/davinci/ios/Tests/RNPingDavinciCommonTests.swift
@@ -42,6 +42,23 @@ final class RNPingDavinciCommonTests: XCTestCase {
     }
   }
 
+  private final class ErrorsCaptureBox: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storedValue: NSArray?
+
+    func set(_ value: NSArray) {
+      lock.lock()
+      storedValue = value
+      lock.unlock()
+    }
+
+    var value: NSArray? {
+      lock.lock()
+      defer { lock.unlock() }
+      return storedValue
+    }
+  }
+
   private final class StringCaptureBox: @unchecked Sendable {
     private let lock = NSLock()
     private var storedValue: String?
@@ -266,7 +283,7 @@ final class RNPingDavinciCommonTests: XCTestCase {
 
   func testNextRejectsWhenCollectorInputIsMalformed() {
     assertReject(
-      expectedCode: DaVinciErrorCodes.nextError.rawValue,
+      expectedCode: DaVinciErrorCodes.collectorApplyError.rawValue,
       expectedType: .argumentError
     ) { rejecter, resolver in
       RNPingDavinciCommon.next(
@@ -278,6 +295,173 @@ final class RNPingDavinciCommonTests: XCTestCase {
     }
   }
 
+  // MARK: - validate
+
+  func testValidateRejectsWhenNoActiveNode() {
+    assertValidateReject(
+      expectedCode: DaVinciErrorCodes.stateError.rawValue,
+      expectedType: .stateError
+    ) { rejecter, resolver in
+      RNPingDavinciCommon.validate(
+        "missing",
+        collectorKey: "username",
+        input: ["collectors": [["key": "username", "value": "alice"]]],
+        resolver: resolver,
+        rejecter: rejecter
+      )
+    }
+  }
+
+  func testValidateRejectsWithCollectorApplyErrorForUnknownCollectorKey() {
+    let davinciId = "validate-unknown-key"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        TextCollector(with: ["key": "username", "type": "TEXT", "label": "Username", "required": false])
+      ])
+    )
+
+    assertValidateReject(
+      expectedCode: DaVinciErrorCodes.collectorApplyError.rawValue,
+      expectedType: .argumentError
+    ) { rejecter, resolver in
+      RNPingDavinciCommon.validate(
+        davinciId,
+        collectorKey: "unknown",
+        input: ["collectors": [["key": "unknown", "value": "alice"]]],
+        resolver: resolver,
+        rejecter: rejecter
+      )
+    }
+  }
+
+  func testValidateRejectsWithUnsupportedCollectorErrorForUnsupportedCollectorType() {
+    let davinciId = "validate-unsupported-collector"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        LabelCollector(with: ["key": "notice", "type": "LABEL", "content": "Notice"])
+      ])
+    )
+
+    assertValidateReject(
+      expectedCode: DaVinciErrorCodes.unsupportedCollectorError.rawValue,
+      expectedType: .argumentError
+    ) { rejecter, resolver in
+      RNPingDavinciCommon.validate(
+        davinciId,
+        collectorKey: "notice",
+        input: ["collectors": [["key": "notice", "value": "anything"]]],
+        resolver: resolver,
+        rejecter: rejecter
+      )
+    }
+  }
+
+  func testValidateResolvesRequiredErrorForEmptyRequiredField() {
+    let davinciId = "validate-required"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        TextCollector(with: ["key": "username", "type": "TEXT", "label": "Username", "required": true])
+      ])
+    )
+
+    assertValidateResolves(
+      davinciId: davinciId,
+      collectorKey: "username",
+      value: ""
+    ) { errors in
+      XCTAssertEqual(errors.count, 1)
+      XCTAssertEqual(errors.first?["code"] as? String, "REQUIRED")
+    }
+  }
+
+  func testValidateNormalizesRequiredBooleanError() {
+    let davinciId = "validate-boolean-required"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        BooleanCollector(with: [
+          "key": "agree", "type": "BOOLEAN", "label": "Agree", "required": true,
+          "errorMessage": "You must agree."
+        ])
+      ])
+    )
+
+    assertValidateResolves(
+      davinciId: davinciId,
+      collectorKey: "agree",
+      value: false
+    ) { errors in
+      XCTAssertEqual(errors.count, 1)
+      XCTAssertEqual(errors.first?["code"] as? String, "REQUIRED")
+      XCTAssertNil(errors.first?["message"])
+    }
+  }
+
+  func testValidateResolvesRegexErrorForInvalidValue() {
+    let davinciId = "validate-regex"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        TextCollector(with: [
+          "key": "email", "type": "TEXT", "label": "Email", "required": false,
+          "validation": ["regex": "^.+@.+$", "errorMessage": "Invalid email"]
+        ])
+      ])
+    )
+
+    assertValidateResolves(
+      davinciId: davinciId,
+      collectorKey: "email",
+      value: "not-an-email"
+    ) { errors in
+      XCTAssertEqual(errors.count, 1)
+      XCTAssertEqual(errors.first?["code"] as? String, "REGEX_ERROR")
+      XCTAssertEqual(errors.first?["message"] as? String, "Invalid email")
+    }
+  }
+
+  func testValidateResolvesEmptyArrayForValidValue() {
+    let davinciId = "validate-valid"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        TextCollector(with: [
+          "key": "email", "type": "TEXT", "label": "Email", "required": false,
+          "validation": ["regex": "^.+@.+$", "errorMessage": "Invalid email"]
+        ])
+      ])
+    )
+
+    assertValidateResolves(
+      davinciId: davinciId,
+      collectorKey: "email",
+      value: "alice@example.com"
+    ) { errors in
+      XCTAssertTrue(errors.isEmpty)
+    }
+  }
+
+  func testValidateResolvesEmptyArrayForNonValidatorCollector() {
+    let davinciId = "validate-non-validator"
+    RNPingDavinciCommon._setContinueNodeForTesting(
+      davinciId: davinciId,
+      node: makeContinueNode(collectors: [
+        FlowCollector(with: ["key": "next", "type": "FLOW", "label": "Next", "required": false])
+      ])
+    )
+
+    assertValidateResolves(
+      davinciId: davinciId,
+      collectorKey: "next",
+      value: "NEXT"
+    ) { errors in
+      XCTAssertTrue(errors.isEmpty)
+    }
+  }
+
   // MARK: - getSession
 
   func testGetSessionRejectsWhenDaVinciMissing() {
@@ -898,6 +1082,68 @@ final class RNPingDavinciCommonTests: XCTestCase {
     XCTAssertEqual(capture.error?.userInfo["type"] as? String, expectedType.rawValue, file: file, line: line)
   }
 
+  /// Same as `assertReject`, sized for `validate()`'s `NSArray`-resolving promise shape.
+  private func assertValidateReject(
+    expectedCode: String,
+    expectedType: ErrorType,
+    call: (
+      _ rejecter: @escaping @Sendable (String, String, NSError?) -> Void,
+      _ resolver: @escaping @Sendable (NSArray) -> Void
+    ) -> Void,
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) {
+    let rejectExpectation = expectation(description: "reject called")
+    let resolveExpectation = expectation(description: "resolve not called")
+    resolveExpectation.isInverted = true
+
+    let capture = ErrorCaptureBox()
+
+    call({ code, _, error in
+      capture.set(code: code, error: error)
+      Task { @MainActor in rejectExpectation.fulfill() }
+    }, { _ in
+      Task { @MainActor in resolveExpectation.fulfill() }
+    })
+
+    wait(for: [rejectExpectation, resolveExpectation], timeout: 1.0)
+
+    XCTAssertEqual(capture.code, expectedCode, file: file, line: line)
+    XCTAssertEqual(capture.error?.userInfo["type"] as? String, expectedType.rawValue, file: file, line: line)
+  }
+
+  /// Calls `validate()` for one collector/value pair and hands the resolved
+  /// validation error array to `assertions`.
+  private func assertValidateResolves(
+    davinciId: String,
+    collectorKey: String,
+    value: Any,
+    file: StaticString = #filePath,
+    line: UInt = #line,
+    assertions: ([[String: Any]]) -> Void
+  ) {
+    let resolveExpectation = expectation(description: "validate resolve")
+    let rejectExpectation = expectation(description: "validate reject not called")
+    rejectExpectation.isInverted = true
+    let capture = ErrorsCaptureBox()
+
+    RNPingDavinciCommon.validate(
+      davinciId,
+      collectorKey: collectorKey,
+      input: ["collectors": [["key": collectorKey, "value": value]]],
+      resolver: { errors in
+        capture.set(errors)
+        Task { @MainActor in resolveExpectation.fulfill() }
+      },
+      rejecter: { _, _, _ in
+        Task { @MainActor in rejectExpectation.fulfill() }
+      }
+    )
+
+    wait(for: [resolveExpectation, rejectExpectation], timeout: 1.0)
+    assertions(capture.value as? [[String: Any]] ?? [])
+  }
+
   /// Runs `pollDaVinci` against a `FakePollingCollector` that yields a single terminal
   /// status, waits for the corresponding `RNPingDavinci_NativeEmit` notification, and
   /// hands the decoded event body to `assertions`.
diff --git a/packages/davinci/src/NativeRNPingDavinci.ts b/packages/davinci/src/NativeRNPingDavinci.ts
index 9862abe94..a09f1ae5c 100644
--- a/packages/davinci/src/NativeRNPingDavinci.ts
+++ b/packages/davinci/src/NativeRNPingDavinci.ts
@@ -98,6 +98,20 @@ export interface Spec extends TurboModule {
    */
   next(davinciId: string, input: Object): Promise<Object>;
 
+  /**
+   * Validate one active collector without advancing the flow.
+   *
+   * @param davinciId - Native DaVinci instance identifier.
+   * @param collectorKey - Collector key to update and validate.
+   * @param input - Single-entry collector mutation payload.
+   * @returns Encoded validation errors.
+   */
+  validate(
+    davinciId: string,
+    collectorKey: string,
+    input: Object,
+  ): Promise<Object>;
+
   /**
    * Resolve the active user session.
    *
@@ -217,6 +231,9 @@ const NativeRNPingDavinci: Spec = {
   next(davinciId, input) {
     return getNativeModule().next(davinciId, input);
   },
+  validate(davinciId, collectorKey, input) {
+    return getNativeModule().validate(davinciId, collectorKey, input);
+  },
   getSession(davinciId) {
     return getNativeModule().getSession(davinciId);
   },
diff --git a/packages/davinci/src/__tests__/collectorHelpers.test.ts b/packages/davinci/src/__tests__/collectorHelpers.test.ts
index 7bd358519..f4a7cb99c 100644
--- a/packages/davinci/src/__tests__/collectorHelpers.test.ts
+++ b/packages/davinci/src/__tests__/collectorHelpers.test.ts
@@ -22,6 +22,7 @@ const manualTypes = [
   'TEXT',
   'PASSWORD',
   'PASSWORD_VERIFY',
+  'SINGLE_CHECKBOX',
   'SINGLE_SELECT',
   'DROPDOWN',
   'RADIO',
@@ -59,8 +60,8 @@ describe('resolveExecutionMode', () => {
     expect(resolveExecutionMode(type)).toBe('manual');
   });
 
-  it('returns output_only for LABEL', () => {
-    expect(resolveExecutionMode('LABEL')).toBe('output_only');
+  it.each(['LABEL', 'READ_ONLY_TEXT'])('returns output_only for %s', (type) => {
+    expect(resolveExecutionMode(type)).toBe('output_only');
   });
 
   it.each(immediateTypes)('returns immediate for %s', (type) => {
@@ -119,6 +120,10 @@ describe('resolveFieldKind', () => {
     },
   );
 
+  it('returns boolean for SINGLE_CHECKBOX', () => {
+    expect(resolveFieldKind('SINGLE_CHECKBOX')).toBe('boolean');
+  });
+
   it('returns phone for PHONE_NUMBER', () => {
     expect(resolveFieldKind('PHONE_NUMBER')).toBe('phone');
   });
@@ -130,8 +135,9 @@ describe('resolveFieldKind', () => {
     },
   );
 
-  it('returns output for LABEL', () => {
+  it('returns output for LABEL and READ_ONLY_TEXT', () => {
     expect(resolveFieldKind('LABEL')).toBe('output');
+    expect(resolveFieldKind('READ_ONLY_TEXT')).toBe('output');
   });
 
   it.each(['SUBMIT_BUTTON', 'ACTION', 'FLOW_BUTTON', 'FLOW_LINK'])(
@@ -240,6 +246,97 @@ describe('normalizeCollectors', () => {
     ]);
   });
 
+  it('normalizes a BooleanCollector while preserving richContent', () => {
+    const collector: DaVinciCollector = {
+      key: 'terms',
+      type: 'SINGLE_CHECKBOX',
+      label: 'Agree to terms',
+      required: true,
+      value: false,
+      appearance: 'CHECKBOX',
+      errorMessage: 'Agreement is required.',
+      richContent: {
+        content: 'I agree to the {terms}.',
+        replacements: {
+          terms: {
+            value: 'terms',
+            href: 'https://example.com/terms',
+            type: 'link',
+            target: '_blank',
+          },
+        },
+      },
+    } as DaVinciCollector;
+
+    const [normalized] = normalizeCollectors([collector]);
+
+    expect(normalized).toMatchObject({
+      executionMode: 'manual',
+      requiresUserInput: true,
+      kind: 'boolean',
+      richContent: collector.richContent,
+    });
+  });
+
+  it('normalizes a ReadOnlyTextCollector as output-only', () => {
+    const collector: DaVinciCollector = {
+      key: 'agreement',
+      type: 'READ_ONLY_TEXT',
+      content: 'Your agreement is available to review.',
+      title: 'Agreement',
+      titleEnabled: true,
+      enabled: true,
+      agreementId: 'agreement-id',
+      useDynamicAgreement: false,
+    } as DaVinciCollector;
+
+    const [normalized] = normalizeCollectors([collector]);
+
+    expect(normalized).toMatchObject({
+      executionMode: 'output_only',
+      requiresUserInput: false,
+      kind: 'output',
+      content: collector.content,
+      title: collector.title,
+    });
+  });
+
+  it('preserves PasswordCollector passwordPolicy and validation fields', () => {
+    const passwordPolicy = {
+      name: 'Default',
+      description: 'Password policy',
+      length: { min: 8, max: 64 },
+      minCharacters: { digit: 1 },
+      maxRepeatedCharacters: 2,
+      minUniqueCharacters: 3,
+      excludesProfileData: true,
+      notSimilarToCurrent: true,
+      excludesCommonlyUsed: true,
+      maxAgeDays: 90,
+      minAgeDays: 1,
+      populationCount: 1,
+      createdAt: '2026-01-01T00:00:00Z',
+      updatedAt: '2026-01-01T00:00:00Z',
+      default: true,
+    };
+    const collector: DaVinciCollector = {
+      key: 'password',
+      type: 'PASSWORD',
+      label: 'Password',
+      required: true,
+      value: '',
+      validation: { regex: '^.{8,}$' },
+      passwordPolicy,
+    } as DaVinciCollector;
+
+    const [normalized] = normalizeCollectors([collector]);
+
+    expect(normalized).toMatchObject({
+      validation: collector.validation,
+      passwordPolicy,
+    });
+  });
+
   it('extracts defaultValue from a server-seeded TEXT collector', () => {
     const collector: DaVinciCollector = {
       key: 'username',
@@ -268,6 +365,27 @@ describe('normalizeCollectors', () => {
   });
 
   it('extracts defaultValue from a server-seeded PHONE_NUMBER collector', () => {
+    const collector: DaVinciCollector = {
+      key: 'phone',
+      type: 'PHONE_NUMBER',
+      label: 'Phone',
+      required: false,
+      defaultCountryCode: '+1',
+      validatePhoneNumber: true,
+      countryCode: '+44',
+      phoneNumber: '5551234',
+      extension: '1234',
+    } as DaVinciCollector;
+
+    const [normalized] = normalizeCollectors([collector]);
+    expect(normalized.defaultValue).toEqual({
+      countryCode: '+44',
+      phoneNumber: '5551234',
+      extension: '1234',
+    });
+  });
+
+  it('defaults an absent PHONE_NUMBER extension to an empty string', () => {
     const collector: DaVinciCollector = {
       key: 'phone',
       type: 'PHONE_NUMBER',
@@ -283,6 +401,7 @@ describe('normalizeCollectors', () => {
     expect(normalized.defaultValue).toEqual({
       countryCode: '+44',
       phoneNumber: '5551234',
+      extension: '',
     });
   });
 
@@ -556,10 +675,14 @@ describe('buildNextInput — manual collector path', () => {
     });
   });
 
-  it('treats PHONE_NUMBER value as { countryCode, phoneNumber }', () => {
+  it('treats PHONE_NUMBER value as { countryCode, phoneNumber, extension }', () => {
     const node = makeNode([baseField('phone', 'PHONE_NUMBER', true)]);
 
-    const phone = { countryCode: '+1', phoneNumber: '5555555' };
+    const phone = {
+      countryCode: '+1',
+      phoneNumber: '5555555',
+      extension: '',
+    };
     const result = buildNextInput(node, { phone });
 
     expect(result.canSubmit).toBe(true);
@@ -570,7 +693,7 @@ describe('buildNextInput — manual collector path', () => {
     const node = makeNode([baseField('phone', 'PHONE_NUMBER', true)]);
 
     const result = buildNextInput(node, {
-      phone: { countryCode: '+1', phoneNumber: '' },
+      phone: { countryCode: '+1', phoneNumber: '', extension: '' },
     });
 
     expect(result.canSubmit).toBe(false);
@@ -649,9 +772,19 @@ describe('buildNextInput — excluded modes', () => {
     ]);
   });
 
-  it('excludes output_only collectors from payload entirely', () => {
+  it('excludes LABEL and READ_ONLY_TEXT collectors from the payload', () => {
     const node = makeNode([
       { key: 'banner', type: 'LABEL', content: 'hi' } as DaVinciCollector,
+      {
+        key: 'agreement',
+        type: 'READ_ONLY_TEXT',
+        content: 'Review this agreement.',
+        title: 'Agreement',
+        titleEnabled: true,
+        enabled: true,
+        agreementId: 'agreement-id',
+        useDynamicAgreement: false,
+      } as DaVinciCollector,
       baseField('username', 'TEXT'),
     ]);
 
diff --git a/packages/davinci/src/__tests__/node.types.test.ts b/packages/davinci/src/__tests__/node.types.test.ts
new file mode 100644
index 000000000..cab8c31f4
--- /dev/null
+++ b/packages/davinci/src/__tests__/node.types.test.ts
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type {
+  BooleanCollector,
+  DaVinciFieldValidationError,
+  LabelCollector,
+  PasswordCollector,
+  PhoneNumberCollector,
+} from '../types';
+
+/**
+ * Exhaustive mapper over every `DaVinciFieldValidationError` variant. Adding,
+ * removing, or reshaping a variant without updating this switch fails to
+ * compile, which is the regression signal this suite is checking for.
+ */
+function describeValidationError(error: DaVinciFieldValidationError): string {
+  switch (error.code) {
+    case 'REQUIRED':
+      return 'REQUIRED';
+    case 'REGEX_ERROR':
+      return `REGEX_ERROR:${error.message}`;
+    case 'INVALID_LENGTH':
+      return `INVALID_LENGTH:${error.min}-${error.max}`;
+    case 'UNIQUE_CHARACTER':
+      return `UNIQUE_CHARACTER:${error.min}`;
+    case 'MAX_REPEAT':
+      return `MAX_REPEAT:${error.max}`;
+    case 'MIN_CHARACTERS':
+      return `MIN_CHARACTERS:${error.character}:${error.min}`;
+  }
+}
+
+describe('DaVinciFieldValidationError', () => {
+  it('supports the REQUIRED and REGEX_ERROR variants', () => {
+    expect(describeValidationError({ code: 'REQUIRED' })).toBe('REQUIRED');
+    expect(
+      describeValidationError({ code: 'REGEX_ERROR', message: 'bad' }),
+    ).toBe('REGEX_ERROR:bad');
+  });
+
+  it('supports all four native password-policy variants', () => {
+    expect(
+      describeValidationError({ code: 'INVALID_LENGTH', min: 8, max: 64 }),
+    ).toBe('INVALID_LENGTH:8-64');
+    expect(describeValidationError({ code: 'UNIQUE_CHARACTER', min: 3 })).toBe(
+      'UNIQUE_CHARACTER:3',
+    );
+    expect(describeValidationError({ code: 'MAX_REPEAT', max: 2 })).toBe(
+      'MAX_REPEAT:2',
+    );
+    expect(
+      describeValidationError({
+        code: 'MIN_CHARACTERS',
+        character: 'digit',
+        min: 1,
+      }),
+    ).toBe('MIN_CHARACTERS:digit:1');
+  });
+});
+
+describe('BooleanCollector', () => {
+  it('keeps display error metadata separate from validate() results', () => {
+    const collector: BooleanCollector = {
+      key: 'agree',
+      type: 'SINGLE_CHECKBOX',
+      label: 'I agree',
+      required: true,
+      value: false,
+      appearance: 'CHECKBOX',
+      errorMessage: 'This field is required.',
+    };
+
+    expect(collector.errorMessage).toBe('This field is required.');
+  });
+});
+
+describe('PasswordCollector', () => {
+  it('declares an optional validation rule with structured errors', () => {
+    const collector: PasswordCollector = {
+      key: 'password',
+      type: 'PASSWORD',
+      label: 'Password',
+      required: true,
+      value: '',
+      validation: {
+        regex: '^.{8,}$',
+        errors: [{ code: 'INVALID_LENGTH', min: 8, max: 64 }],
+      },
+    };
+
+    expect(collector.validation?.errors).toEqual([
+      { code: 'INVALID_LENGTH', min: 8, max: 64 },
+    ]);
+  });
+});
+
+describe('LabelCollector', () => {
+  it('declares an optional richContent payload', () => {
+    const collector: LabelCollector = {
+      key: 'banner',
+      type: 'LABEL',
+      content: 'Read the {terms}',
+      richContent: {
+        content: 'Read the {terms}',
+        replacements: {
+          terms: { value: 'terms', href: 'https://example.com/terms' },
+        },
+      },
+    };
+
+    expect(collector.richContent?.replacements.terms.href).toBe(
+      'https://example.com/terms',
+    );
+  });
+});
+
+describe('PhoneNumberCollector', () => {
+  it('declares extension, showExtension, and extensionLabel', () => {
+    const collector: PhoneNumberCollector = {
+      key: 'phone',
+      type: 'PHONE_NUMBER',
+      label: 'Phone',
+      required: true,
+      defaultCountryCode: '+1',
+      validatePhoneNumber: true,
+      countryCode: '+1',
+      phoneNumber: '5551234',
+      extension: '99',
+      showExtension: true,
+      extensionLabel: 'Extension',
+    };
+
+    expect(collector.extension).toBe('99');
+    expect(collector.showExtension).toBe(true);
+    expect(collector.extensionLabel).toBe('Extension');
+  });
+
+  it('allows extension to be omitted', () => {
+    const collector: PhoneNumberCollector = {
+      key: 'phone',
+      type: 'PHONE_NUMBER',
+      label: 'Phone',
+      required: true,
+      defaultCountryCode: '+1',
+      validatePhoneNumber: true,
+      countryCode: '+1',
+      phoneNumber: '5551234',
+      showExtension: false,
+      extensionLabel: '',
+    };
+
+    expect(collector.extension).toBeUndefined();
+  });
+});
diff --git a/packages/davinci/src/collectorHelpers.ts b/packages/davinci/src/collectorHelpers.ts
index 60bc49608..47f79cc61 100644
--- a/packages/davinci/src/collectorHelpers.ts
+++ b/packages/davinci/src/collectorHelpers.ts
@@ -275,6 +275,7 @@ function resolveDefaultValue(
     const phone = collector as {
       countryCode?: string;
       phoneNumber?: string;
+      extension?: string;
     };
     if (phone.countryCode === undefined && phone.phoneNumber === undefined) {
       return undefined;
@@ -282,6 +283,7 @@ function resolveDefaultValue(
     return {
       countryCode: phone.countryCode ?? '',
       phoneNumber: phone.phoneNumber ?? '',
+      extension: phone.extension ?? '',
     };
   }
 
diff --git a/packages/davinci/src/davinci.ts b/packages/davinci/src/davinci.ts
index d0609a011..3874b58dd 100644
--- a/packages/davinci/src/davinci.ts
+++ b/packages/davinci/src/davinci.ts
@@ -16,6 +16,7 @@ import {
   refreshDaVinciSession,
   revokeDaVinciSession,
   startDaVinci,
+  validateDaVinci,
 } from './davinciMethods';
 import { DaVinciEvents } from './events';
 import type { NativeDaVinciConfig } from './NativeRNPingDavinci';
@@ -303,6 +304,34 @@ export function createDaVinciClient(config: DaVinciConfig): DaVinciClient {
       }
     },
 
+    /**
+     * Validates one active collector without advancing the flow.
+     *
+     * @param collectorKey - Collector key to update and validate.
+     * @param value - Candidate value to apply to the collector before validating.
+     * @returns Validation errors for the collector, or an empty array when valid.
+     * @throws {DaVinciError} When value application or validation fails.
+     */
+    async validate(collectorKey: string, value: unknown) {
+      const id = await ensureConfigured();
+      logDebug('DaVinci validate requested', { davinciId: id, collectorKey });
+      try {
+        const errors = await validateDaVinci(id, collectorKey, value);
+        logInfo('DaVinci validate succeeded', {
+          davinciId: id,
+          collectorKey,
+          errorCount: errors.length,
+        });
+        return errors;
+      } catch (error) {
+        logError('DaVinci validate failed', error, {
+          davinciId: id,
+          collectorKey,
+        });
+        throw error;
+      }
+    },
+
     /**
      * Resolves the active user session.
      *
diff --git a/packages/davinci/src/davinciMethods.ts b/packages/davinci/src/davinciMethods.ts
index f4bfd10ed..cf8b917a8 100644
--- a/packages/davinci/src/davinciMethods.ts
+++ b/packages/davinci/src/davinciMethods.ts
@@ -8,6 +8,7 @@
 import NativeRNPingDavinci from './NativeRNPingDavinci';
 import type { NativeDaVinciConfig } from './NativeRNPingDavinci';
 import type {
+  DaVinciFieldValidationError,
   DaVinciNextInput,
   DaVinciNode,
   DaVinciUserSession,
@@ -99,6 +100,42 @@ export async function nextDaVinci(
   }
 }
 
+/**
+ * Validate one active collector without advancing the flow.
+ *
+ * @param davinciId - Native DaVinci instance identifier.
+ * @param collectorKey - Collector key to update and validate.
+ * @param value - Candidate value to apply to the collector before validating.
+ * @returns Validation errors for the collector, or an empty array when valid.
+ * @throws {DaVinciError} When value application or validation fails.
+ */
+export async function validateDaVinci(
+  davinciId: string,
+  collectorKey: string,
+  value: unknown,
+): Promise<DaVinciFieldValidationError[]> {
+  try {
+    const input: DaVinciNextInput = {
+      collectors: [{ key: collectorKey, value }],
+    };
+    const result = await NativeRNPingDavinci.validate(
+      davinciId,
+      collectorKey,
+      input,
+    );
+    if (!Array.isArray(result)) {
+      throw new DaVinciError(
+        '[@ping-identity/rn-davinci] Native bridge returned a malformed validation payload.',
+        'DAVINCI_VALIDATE_ERROR',
+        'native_error',
+      );
+    }
+    return result as DaVinciFieldValidationError[];
+  } catch (error) {
+    throw DaVinciError.from(error);
+  }
+}
+
 /**
  * Resolve the active DaVinci user session.
  *
diff --git a/packages/davinci/src/types/client.types.ts b/packages/davinci/src/types/client.types.ts
index d0df7bb1f..0d9ef7fa8 100644
--- a/packages/davinci/src/types/client.types.ts
+++ b/packages/davinci/src/types/client.types.ts
@@ -7,6 +7,7 @@
 
 import type { DaVinciNextInput } from './config.types';
 import type {
+  DaVinciFieldValidationError,
   DaVinciNode,
   DaVinciPollStatusOptions,
   DaVinciUserSession,
@@ -57,6 +58,32 @@ export type DaVinciClient = {
    */
   next: (input: DaVinciNextInput) => Promise<DaVinciNode>;
 
+  /**
+   * Validate one active collector without advancing the flow.
+   *
+   * @remarks
+   * This is a command-query operation, not a pure check: it writes `value`
+   * onto the live collector backing the in-progress submission, because
+   * neither native SDK exposes a primitive that validates a candidate value
+   * without first setting it on the collector. The value passed in *will* be
+   * part of what a subsequent `next()` submits, even if the caller only
+   * intended a speculative/preview check.
+   *
+   * An empty result array means either "no validation errors" or "this
+   * collector has no validator" — it is not a positive confirmation that the
+   * value was actually checked.
+   *
+   * @param collectorKey - Collector key to update and validate.
+   * @param value - Candidate value to apply to the collector before validating.
+   * @returns Validation errors for the collector, or an empty array when valid
+   *   (or when the collector has no validator).
+   * @throws {DaVinciError} When value application or validation fails.
+   */
+  validate: (
+    collectorKey: string,
+    value: unknown,
+  ) => Promise<DaVinciFieldValidationError[]>;
+
   /**
    * Resolve the active user session.
    *
diff --git a/packages/davinci/src/types/error.types.ts b/packages/davinci/src/types/error.types.ts
index 6ea2e62ae..d269e3eba 100644
--- a/packages/davinci/src/types/error.types.ts
+++ b/packages/davinci/src/types/error.types.ts
@@ -55,6 +55,7 @@ export type DaVinciErrorCode =
   | 'DAVINCI_NEXT_ERROR' // next(): flow progression failure
   | 'DAVINCI_COLLECTOR_APPLY_ERROR' // next(): collector value application failure
   | 'DAVINCI_UNSUPPORTED_COLLECTOR_ERROR' // unsupported collector mutation request
+  | 'DAVINCI_VALIDATE_ERROR' // validate(): collector validation failure
   | 'DAVINCI_SESSION_ERROR' // user() / refresh() / revoke() / userinfo()
   | 'DAVINCI_LOGOUT_ERROR' // logoutUser()
   | 'DAVINCI_DISPOSE_ERROR' // dispose()
diff --git a/packages/davinci/src/types/form.types.ts b/packages/davinci/src/types/form.types.ts
index e8189632b..26d07f31a 100644
--- a/packages/davinci/src/types/form.types.ts
+++ b/packages/davinci/src/types/form.types.ts
@@ -128,7 +128,7 @@ export type DaVinciFormValue =
   | string // TEXT, PASSWORD, SINGLE_SELECT, DEVICE_REGISTRATION (type string)
   | string[] // MULTI_SELECT
   | boolean // SINGLE_CHECKBOX
-  | { countryCode: string; phoneNumber: string } // PHONE_NUMBER
+  | { countryCode: string; phoneNumber: string; extension?: string } // PHONE_NUMBER
   | { type: string; id?: string; description?: string } // DEVICE_AUTHENTICATION
   | null;
 
diff --git a/packages/davinci/src/types/node.types.ts b/packages/davinci/src/types/node.types.ts
index c781c266c..d5cebd613 100644
--- a/packages/davinci/src/types/node.types.ts
+++ b/packages/davinci/src/types/node.types.ts
@@ -34,41 +34,50 @@ export type BaseCollector = {
 };
 
 /**
- * Collector-level validation error returned by the native SDK's `validate()` method.
+ * Structured validation error mapped from the native SDK's `validate()` result.
  *
  * @remarks
- * In 2.0.1 the bridge emits only `REQUIRED` (iOS only) and `REGEX_ERROR` (both platforms).
- * TODO-SDK-FUTURE-SUPPORT: Password-policy cases (`INVALID_LENGTH`, `UNIQUE_CHARACTER`,
- * `MAX_REPEAT`, `MIN_CHARACTERS`) exist in both the iOS and Android SDKs but their
- * policy-validation blocks are behind `// TODO` markers in `PasswordCollector.validate()`
- * (iOS `PasswordCollector.swift:49-81`, Android `PasswordCollector.kt:63-91`) and are
- * never emitted at runtime — add them when both SDKs remove those blocks.
+ * The native bridge maps `REQUIRED`, `REGEX_ERROR`, `INVALID_LENGTH`,
+ * `UNIQUE_CHARACTER`, `MAX_REPEAT`, and `MIN_CHARACTERS` directly. Password
+ * policy variants include native constraint values, so consumers do not need to
+ * parse localized messages: `INVALID_LENGTH` includes `min` and `max`,
+ * `UNIQUE_CHARACTER` includes `min`, `MAX_REPEAT` includes `max`, and
+ * `MIN_CHARACTERS` includes `character` and `min`.
+ *
+ * Use {@link DaVinciClient.validate} to check a collector's current value
+ * on demand (e.g. on-blur) without advancing the flow.
  *
  * @public
  */
 export type DaVinciFieldValidationError =
   | { code: 'REQUIRED' }
-  | { code: 'REGEX_ERROR'; message: string };
+  | { code: 'REGEX_ERROR'; message: string }
+  | { code: 'INVALID_LENGTH'; min: number; max: number }
+  | { code: 'UNIQUE_CHARACTER'; min: number }
+  | { code: 'MAX_REPEAT'; max: number }
+  | { code: 'MIN_CHARACTERS'; character: string; min: number };
 
 /**
- * Validation rule attached to text and select collectors, including the current
- * evaluation result from the native SDK's `validate()` call.
+ * Server-provided validation rule attached to a validated field collector.
+ *
+ * @remarks
+ * The bridge maps the server regex to `regex`. Use {@link DaVinciClient.validate}
+ * to check a collector's current value on demand.
  *
  * @public
  */
 export type DaVinciValidation = {
-  /** Regular expression pattern the value must satisfy. */
+  /** Regular expression pattern the server requires the value to satisfy. */
   regex: string;
   /**
-   * Validation errors produced by the native SDK's `validate()` call on the
-   * current collector value. Empty when the value is valid; absent when
-   * `validate()` has not yet been called.
+   * Optional collector-level validation data when supplied by a native mapping.
+   * Use {@link DaVinciClient.validate} for on-demand validation results.
    */
   errors?: DaVinciFieldValidationError[];
 };
 
 /**
- * Rich-content payload for label and text collectors.
+ * Rich-content payload for label and boolean collectors.
  *
  * @public
  */
@@ -91,9 +100,8 @@ export type RichContent = {
  * Password policy constraints associated with a {@link PasswordCollector}.
  *
  * @remarks
- * The bridge reads this from `continueNode.input.form.components.fields[]`
- * because the SDK's own `passwordPolicy()` method targets the wrong JSON path
- * in 2.0.1 (it reads from `continueNode.input["passwordPolicy"]`).
+ * The bridge reads this through the native SDK's `passwordPolicy()` accessor,
+ * which handles both field-level and node-level policy payloads.
  *
  * @public
  */
@@ -190,13 +198,15 @@ export type TextCollector = BaseCollector & {
  * Password input collector.
  *
  * @remarks
- * `PASSWORD_VERIFY` is a password-confirmation variant of the same collector class.
+ * `PASSWORD_VERIFY` is a password-confirmation variant of the same collector
+ * class. Password values are write-only: pass them to `next()`. Use
+ * {@link DaVinciClient.validate} for on-demand validation of the current value.
  *
  * @public
  */
 export type PasswordCollector = BaseCollector & {
   type: 'PASSWORD' | 'PASSWORD_VERIFY';
-  /** Current password value (always `""` in bridge output — cleared before serialisation). */
+  /** Current password value (always `""` in bridge output because the bridge clears it before serialization). */
   value: string;
   /**
    * Whether the native collector clears its value when `close()` is called on node exit.
@@ -206,13 +216,15 @@ export type PasswordCollector = BaseCollector & {
    * across node transitions (e.g. validation-error retry loops).
    */
   clearPassword?: boolean;
+  /** Optional server-provided regular-expression validation rule. */
+  validation?: DaVinciValidation;
   /**
-   * Optional password policy constraints.
+   * Optional password policy constraints for rendering password requirements.
    *
    * @remarks
-   * Present only when the server includes a `passwordPolicy` object in the field
-   * definition. The bridge reads it directly from the raw JSON because the SDK's
-   * `passwordPolicy()` method targets the wrong path in 2.0.1.
+   * The bridge reads the native `passwordPolicy()` accessor, which uses a
+   * field-level policy when available and otherwise falls back to a node-level
+   * policy.
    */
   passwordPolicy?: PasswordPolicy;
 };
@@ -244,11 +256,10 @@ export type FlowCollector = BaseCollector & {
  * Label (read-only content) collector.
  *
  * @remarks
- * Does not extend {@link BaseCollector} — `LabelCollector` does not implement
- * `FieldCollector` in the native SDK and therefore has no `label` or `required`.
- *
- * `richContent` is absent from the 2.0.1 iOS/Android SDK sources (`LabelCollector`
- * has only `key` and `content`). Add it when the SDK version that includes it is adopted.
+ * Does not extend {@link BaseCollector}: `LabelCollector` does not implement
+ * `FieldCollector` in the native SDK and therefore has no `label`, `required`,
+ * or mutable value. Render `content` when `richContent` is absent; otherwise,
+ * use its template content and named replacements, including link metadata.
  *
  * @public
  */
@@ -258,7 +269,13 @@ export type LabelCollector = {
   type: 'LABEL';
   /** Raw display content for this label. */
   content: string;
-  // TODO-SDK-FUTURE-SUPPORT: add richContent?: RichContent when the SDK version that exposes it on LabelCollector is adopted
+  /**
+   * Optional rich content with template text and named link replacements.
+   *
+   * @remarks
+   * Present when the server includes a `richContent` object in the field definition.
+   */
+  richContent?: RichContent;
   /**
    * Raw server-side field JSON from `node.input.form.components.fields[]`.
    *
@@ -300,9 +317,12 @@ export type MultiSelectCollector = BaseCollector & {
  * Phone number input collector.
  *
  * @remarks
- * `extension`, `showExtension`, and `extensionLabel` do not exist in the 2.0.1
- * Android/iOS SDK sources and are therefore absent from this contract.
- * TODO-SDK-FUTURE-SUPPORT: add `extension`, `showExtension`, and `extensionLabel` when the SDK version that exposes it.
+ * `countryCode`, `phoneNumber`, and optional `extension` are mutable values
+ * passed to `next()`. `defaultCountryCode`, `validatePhoneNumber`,
+ * `showExtension`, and `extensionLabel` are server-provided configuration.
+ * Render an extension control when `showExtension` is `true`; the submitted
+ * extension can still be omitted.
+ *
  * @public
  */
 export type PhoneNumberCollector = BaseCollector & {
@@ -315,6 +335,12 @@ export type PhoneNumberCollector = BaseCollector & {
   countryCode: string;
   /** Currently entered phone number (mutable). */
   phoneNumber: string;
+  /** Currently entered phone extension (mutable, optional). */
+  extension?: string;
+  /** Whether the phone extension input should be displayed (read-only). */
+  showExtension: boolean;
+  /** Label for the phone extension input (read-only). */
+  extensionLabel: string;
 };
 
 /**
@@ -374,12 +400,9 @@ export type ProtectCollector = {
  * Single checkbox or toggle collector.
  *
  * @remarks
- * Corresponds to the native `BOOLEAN` inputType / `SINGLE_CHECKBOX` server type.
- * Extends {@link BaseCollector} — has `key`, `label`, and `required`.
- *
- * When `required` is `true` and `value` is `false`, the native SDK's `validate()`
- * emits a validation error using `errorMessage`. JS consumers should surface
- * `errorMessage` to the user in that case.
+ * Corresponds to the native `BOOLEAN` inputType / `SINGLE_CHECKBOX` server type
+ * and extends {@link BaseCollector}. `errorMessage` is the native display
+ * message for a required unchecked field.
  *
  * @public
  */
diff --git a/packages/davinci/src/useDavinci.tsx b/packages/davinci/src/useDavinci.tsx
index b2caf257b..d73d41299 100644
--- a/packages/davinci/src/useDavinci.tsx
+++ b/packages/davinci/src/useDavinci.tsx
@@ -17,6 +17,7 @@ import { DaVinciError } from './types/error.types';
 import type {
   DaVinciClient,
   DaVinciConfig,
+  DaVinciFieldValidationError,
   DaVinciNextInput,
   DaVinciNode,
   DaVinciPollStatusOptions,
@@ -47,6 +48,18 @@ export type DaVinciHookActions = {
    */
   next: (input: DaVinciNextInput) => Promise<DaVinciNode>;
 
+  /**
+   * Validate one active collector without advancing the flow.
+   *
+   * @param collectorKey - Collector key to update and validate.
+   * @param value - Candidate value to apply to the collector before validating.
+   * @returns Validation errors for the collector, or an empty array when valid.
+   * @throws {DaVinciError} When value application or validation fails.
+   */
+  validate: (
+    collectorKey: string,
+    value: unknown,
+  ) => Promise<DaVinciFieldValidationError[]>;
   /**
    * Resolve the active user session.
    *
@@ -155,6 +168,9 @@ const missingDaVinciClient: DaVinciClient = {
   async next(): Promise<DaVinciNode> {
     throw missingDaVinciClientError;
   },
+  async validate(): Promise<DaVinciFieldValidationError[]> {
+    throw missingDaVinciClientError;
+  },
   async user(): Promise<DaVinciUserSession | null> {
     throw missingDaVinciClientError;
   },
@@ -236,6 +252,15 @@ function useDaVinciState(client: DaVinciClient): DaVinciHookResult {
     [client, node],
   );
 
+  const validate = useCallback(
+    async (
+      collectorKey: string,
+      value: unknown,
+    ): Promise<DaVinciFieldValidationError[]> =>
+      await client.validate(collectorKey, value),
+    [client],
+  );
+
   const user = useCallback(
     async (): Promise<DaVinciUserSession | null> => await client.user(),
     [client],
@@ -283,6 +308,7 @@ function useDaVinciState(client: DaVinciClient): DaVinciHookResult {
     node,
     start,
     next,
+    validate,
     user,
     refresh,
     revoke,