diff --git a/src/components/PayoutRescheduleModal.tsx b/src/components/PayoutRescheduleModal.tsx
index eb6ceac..9fc09d2 100644
--- a/src/components/PayoutRescheduleModal.tsx
+++ b/src/components/PayoutRescheduleModal.tsx
@@ -1,11 +1,14 @@
-import React, { useState } from 'react';
-import { AlertTriangle, Clock, Calendar as CalendarIcon, CheckCircle } from 'lucide-react';
+import React, { useEffect, useId, useRef, useState } from 'react';
+import { AlertTriangle, Clock } from 'lucide-react';
+import { analyzeConflicts } from './PayoutTimeline/conflictAnalysis';
+import type { PayoutEvent } from './PayoutTimeline/PayoutTimeline';
 
 export type ConflictType = 'hard' | 'soft';
 
 export interface Conflict {
   id: string;
-  type: ConflictType;
+  type?: ConflictType;
+  severity?: ConflictType;
   message: string;
 }
 
@@ -14,7 +17,11 @@ export interface PayoutRescheduleModalProps {
   onClose: () => void;
   onConfirm: (newDate: string, note: string) => void;
   initialDate: string;
-  conflicts: Conflict[];
+  currentDate?: string;
+  conflicts?: Conflict[];
+  allPayouts?: PayoutEvent[];
+  payoutId?: string;
+  getConflicts?: (date: string) => Conflict[];
 }
 
 export const PayoutRescheduleModal: React.FC<PayoutRescheduleModalProps> = ({
@@ -22,28 +29,131 @@ export const PayoutRescheduleModal: React.FC<PayoutRescheduleModalProps> = ({
   onClose,
   onConfirm,
   initialDate,
-  conflicts,
+  currentDate,
+  conflicts: conflictsProp,
+  allPayouts,
+  payoutId,
+  getConflicts,
 }) => {
   const [newDate, setNewDate] = useState(initialDate);
   const [note, setNote] = useState('');
+  const dateId = useId();
+  const noteId = useId();
+  const modalRef = useRef<HTMLDivElement>(null);
+  const confirmRef = useRef<HTMLButtonElement>(null);
+  const cancelRef = useRef<HTMLButtonElement>(null);
+
+  useEffect(() => {
+    if (isOpen) {
+      setNewDate(initialDate);
+      setNote('');
+    }
+  }, [isOpen, initialDate]);
+
+  useEffect(() => {
+    if (!isOpen) return;
+
+    const focusable = modalRef.current?.querySelectorAll<HTMLElement>(
+      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])',
+    );
+    const first = focusable?.[0];
+    const last = focusable?.[focusable.length - 1];
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        onClose();
+        return;
+      }
+      if (e.key !== 'Tab' || !focusable || focusable.length === 0) return;
+      if (e.shiftKey) {
+        if (document.activeElement === first) {
+          e.preventDefault();
+          last?.focus();
+        }
+      } else {
+        if (document.activeElement === last) {
+          e.preventDefault();
+          first?.focus();
+        }
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    setTimeout(() => {
+      confirmRef.current?.focus();
+    }, 0);
+
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [isOpen, onClose]);
 
   if (!isOpen) return null;
 
-  const hasHardConflict = conflicts.some((c) => c.type === 'hard');
+  let computedConflicts: Conflict[] = [];
+  if (getConflicts) {
+    computedConflicts = getConflicts(newDate);
+  } else if (allPayouts && payoutId) {
+    computedConflicts = analyzeConflicts(payoutId, newDate, allPayouts).map((c) => ({
+      id: c.id,
+      severity: c.severity,
+      type: c.severity,
+      message: c.message,
+    }));
+  } else if (conflictsProp) {
+    computedConflicts = conflictsProp;
+  }
+
+  const conflicts = computedConflicts;
+  const hasHardConflict = conflicts.some((c) => c.type === 'hard' || c.severity === 'hard');
+
+  const today = new Date();
+  const todayStr = today.toISOString().split('T')[0];
+  const isEmpty = !newDate;
+  const isPast = newDate ? newDate < todayStr : false;
+  const isUnchanged = currentDate ? newDate === currentDate : initialDate ? newDate === initialDate && currentDate === undefined ? false : currentDate ? newDate === currentDate : false : false;
+  // If currentDate not provided, treat as unchanged only if equals initial and we want to be strict? Issue says "invalid dates" - empty/past/unchanged
+  const unchanged = currentDate !== undefined ? newDate === currentDate : newDate === initialDate && note === '';
+  const invalid = isEmpty || isPast || newDate === (currentDate ?? initialDate);
+  const canConfirm = !hasHardConflict && !invalid;
 
   return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 p-4">
-      <div className="w-full max-w-lg rounded-xl bg-slate-900 border border-slate-700 p-6 shadow-2xl">
-        <h2 className="text-lg font-semibold mb-4">Reschedule Payout</h2>
+    <div
+      className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 p-4"
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="payout-reschedule-title"
+      onClick={(e) => {
+        if (e.target === e.currentTarget) {
+          onClose();
+        }
+      }}
+    >
+      <div
+        ref={modalRef}
+        className="w-full max-w-lg rounded-xl bg-slate-900 border border-slate-700 p-6 shadow-2xl"
+        role="document"
+      >
+        <h2 id="payout-reschedule-title" className="text-lg font-semibold mb-4">Reschedule Payout</h2>
         
         <div className="space-y-4 mb-6">
-          <label className="block text-sm font-medium">Select New Date</label>
-          <input
-            type="date"
-            value={newDate}
-            onChange={(e) => setNewDate(e.target.value)}
-            className="w-full p-2 bg-slate-800 border border-slate-700 rounded-lg"
-          />
+          <div>
+            <label htmlFor={dateId} className="block text-sm font-medium">Select New Date</label>
+            <input
+              id={dateId}
+              type="date"
+              value={newDate}
+              onChange={(e) => setNewDate(e.target.value)}
+              className="w-full p-2 bg-slate-800 border border-slate-700 rounded-lg"
+              aria-invalid={invalid}
+            />
+            {(isEmpty || isPast || (currentDate !== undefined ? newDate === currentDate : newDate === initialDate)) && (
+              <p className="text-xs text-red-400 mt-1">
+                {isEmpty ? 'Date is required' : isPast ? 'Date cannot be in the past' : 'Date must be different from the current date'}
+              </p>
+            )}
+          </div>
           
           {conflicts.length > 0 && (
             <div className="space-y-2">
@@ -62,22 +172,26 @@ export const PayoutRescheduleModal: React.FC<PayoutRescheduleModalProps> = ({
             </div>
           )}
 
-          <label className="block text-sm font-medium">Audit Note</label>
-          <textarea
-            value={note}
-            onChange={(e) => setNote(e.target.value)}
-            className="w-full p-2 bg-slate-800 border border-slate-700 rounded-lg"
-            rows={3}
-            placeholder="Reason for rescheduling..."
-          />
+          <div>
+            <label htmlFor={noteId} className="block text-sm font-medium">Audit Note</label>
+            <textarea
+              id={noteId}
+              value={note}
+              onChange={(e) => setNote(e.target.value)}
+              className="w-full p-2 bg-slate-800 border border-slate-700 rounded-lg"
+              rows={3}
+              placeholder="Reason for rescheduling..."
+            />
+          </div>
         </div>
 
         <div className="flex justify-end gap-3">
-          <button onClick={onClose} className="px-4 py-2 bg-slate-800 rounded-lg hover:bg-slate-700">Cancel</button>
-          <button 
+          <button ref={cancelRef} onClick={onClose} className="px-4 py-2 bg-slate-800 rounded-lg hover:bg-slate-700">Cancel</button>
+          <button
+            ref={confirmRef}
             onClick={() => onConfirm(newDate, note)}
-            disabled={hasHardConflict}
-            className={`px-4 py-2 rounded-lg font-medium ${hasHardConflict ? 'bg-slate-700 text-slate-500' : 'bg-primary text-white hover:bg-primary-dark'}`}
+            disabled={!canConfirm}
+            className={`px-4 py-2 rounded-lg font-medium ${!canConfirm ? 'bg-slate-700 text-slate-500' : 'bg-primary text-white hover:bg-primary-dark'}`}
           >
             Confirm Reschedule
           </button>
diff --git a/src/hooks/useFinancialTermsForm.ts b/src/hooks/useFinancialTermsForm.ts
index 707d83c..edfe313 100644
--- a/src/hooks/useFinancialTermsForm.ts
+++ b/src/hooks/useFinancialTermsForm.ts
@@ -106,17 +106,17 @@ export interface UseFinancialTermsFormReturn {
 
 /* ─── Hook ──────────────────────────────────────────────────────────────── */
 
-export function useFinancialTermsForm(): UseFinancialTermsFormReturn {
+export function useFinancialTermsForm(locale?: string): UseFinancialTermsFormReturn {
   const [state, dispatch] = useReducer(reducer, initialState);
 
-  const formSummary = validateFinancialTermsForm(state.values);
+  const formSummary = validateFinancialTermsForm(state.values, locale);
 
   const getFieldValidation = useCallback(
     (field: FinancialTermsField): FieldValidationResult | null => {
       if (!state.touched[field] && !state.submitAttempted) return null;
-      return validateField(field, state.values[field]);
+      return validateField(field, state.values[field], locale);
     },
-    [state.touched, state.submitAttempted, state.values],
+    [state.touched, state.submitAttempted, state.values, locale],
   );
 
   const handleChange = useCallback((field: FinancialTermsField, value: string) => {
@@ -129,8 +129,8 @@ export function useFinancialTermsForm(): UseFinancialTermsFormReturn {
 
   const handleSubmit = useCallback((): FormValidationSummary => {
     dispatch({ type: 'SUBMIT_ATTEMPT' });
-    return validateFinancialTermsForm(state.values);
-  }, [state.values]);
+    return validateFinancialTermsForm(state.values, locale);
+  }, [state.values, locale]);
 
   const reset = useCallback(() => {
     dispatch({ type: 'RESET' });
diff --git a/src/hooks/useUploadQueue.ts b/src/hooks/useUploadQueue.ts
index 42aaf6f..55a3ec6 100644
--- a/src/hooks/useUploadQueue.ts
+++ b/src/hooks/useUploadQueue.ts
@@ -1,4 +1,4 @@
-import { useCallback, useReducer } from 'react';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
 
 export type UploadStatus = 'pending' | 'uploading' | 'success' | 'error';
 
@@ -30,12 +30,18 @@ function reducer(state: UploadFile[], action: Action): UploadFile[] {
         })),
       ];
     case 'SET_STATUS':
+      if (!state.some((f) => f.id === action.id)) {
+        return state;
+      }
       return state.map((f) =>
         f.id === action.id
           ? { ...f, status: action.status, errorMessage: action.errorMessage }
           : f,
       );
     case 'SET_PROGRESS':
+      if (!state.some((f) => f.id === action.id)) {
+        return state;
+      }
       return state.map((f) =>
         f.id === action.id ? { ...f, progress: Math.max(0, Math.min(100, action.progress)) } : f,
       );
@@ -66,10 +72,32 @@ export interface UseUploadQueueReturn {
 export type Uploader = (
   file: File,
   onProgress: (pct: number) => void,
+  signal?: AbortSignal,
 ) => Promise<void>;
 
 export function useUploadQueue(): UseUploadQueueReturn {
   const [queue, dispatch] = useReducer(reducer, []);
+  const inFlightRef = useRef<Set<string>>(new Set());
+  const controllersRef = useRef<Map<string, AbortController>>(new Map());
+  const queueRef = useRef<UploadFile[]>([]);
+
+  useEffect(() => {
+    queueRef.current = queue;
+  }, [queue]);
+
+  useEffect(() => {
+    return () => {
+      controllersRef.current.forEach((controller) => {
+        try {
+          controller.abort();
+        } catch {
+          /* ignore */
+        }
+      });
+      controllersRef.current.clear();
+      inFlightRef.current.clear();
+    };
+  }, []);
 
   const addFiles = useCallback((files: File[]) => {
     if (files.length === 0) return;
@@ -77,22 +105,68 @@ export function useUploadQueue(): UseUploadQueueReturn {
   }, []);
 
   const removeFile = useCallback((id: string) => {
+    const controller = controllersRef.current.get(id);
+    if (controller) {
+      try {
+        controller.abort();
+      } catch {
+        /* ignore */
+      }
+      controllersRef.current.delete(id);
+    }
+    inFlightRef.current.delete(id);
     dispatch({ type: 'REMOVE', id });
   }, []);
 
   const runUpload = useCallback(
     async (item: UploadFile, uploader: Uploader, dispatchFn: React.Dispatch<Action>) => {
+      if (inFlightRef.current.has(item.id)) {
+        return;
+      }
+      const controller = new AbortController();
+      controllersRef.current.set(item.id, controller);
+      inFlightRef.current.add(item.id);
       dispatchFn({ type: 'SET_STATUS', id: item.id, status: 'uploading' });
       dispatchFn({ type: 'SET_PROGRESS', id: item.id, progress: 0 });
       try {
-        await uploader(item.file, (pct) => {
-          dispatchFn({ type: 'SET_PROGRESS', id: item.id, progress: pct });
-        });
+        await uploader(
+          item.file,
+          (pct) => {
+            if (controller.signal.aborted) {
+              return;
+            }
+            dispatchFn({ type: 'SET_PROGRESS', id: item.id, progress: pct });
+          },
+          controller.signal,
+        );
+        if (controller.signal.aborted) {
+          inFlightRef.current.delete(item.id);
+          controllersRef.current.delete(item.id);
+          return;
+        }
+        if (!queueRef.current.some((f) => f.id === item.id)) {
+          inFlightRef.current.delete(item.id);
+          controllersRef.current.delete(item.id);
+          return;
+        }
         dispatchFn({ type: 'SET_PROGRESS', id: item.id, progress: 100 });
         dispatchFn({ type: 'SET_STATUS', id: item.id, status: 'success' });
       } catch (err) {
+        if (controller.signal.aborted) {
+          inFlightRef.current.delete(item.id);
+          controllersRef.current.delete(item.id);
+          return;
+        }
+        if (!queueRef.current.some((f) => f.id === item.id)) {
+          inFlightRef.current.delete(item.id);
+          controllersRef.current.delete(item.id);
+          return;
+        }
         const msg = err instanceof Error ? err.message : 'Upload failed';
         dispatchFn({ type: 'SET_STATUS', id: item.id, status: 'error', errorMessage: msg });
+      } finally {
+        inFlightRef.current.delete(item.id);
+        controllersRef.current.delete(item.id);
       }
     },
     [],
@@ -100,19 +174,26 @@ export function useUploadQueue(): UseUploadQueueReturn {
 
   const uploadFiles = useCallback(
     (uploader: Uploader) => {
-      const pending = queue.filter((f) => f.status === 'pending');
-      pending.forEach((item) => runUpload(item, uploader, dispatch));
+      const pending = queueRef.current.filter(
+        (f) => f.status === 'pending' && !inFlightRef.current.has(f.id),
+      );
+      pending.forEach((item) => {
+        runUpload(item, uploader, dispatch);
+      });
     },
-    [queue, runUpload],
+    [runUpload],
   );
 
   const retryFile = useCallback(
     (id: string, uploader: Uploader) => {
-      const item = queue.find((f) => f.id === id);
+      if (inFlightRef.current.has(id)) {
+        return;
+      }
+      const item = queueRef.current.find((f) => f.id === id);
       if (!item) return;
       runUpload({ ...item, status: 'pending', progress: 0 }, uploader, dispatch);
     },
-    [queue, runUpload],
+    [runUpload],
   );
 
   const clearComplete = useCallback(() => {
diff --git a/src/utils/financialTermsValidation.test.ts b/src/utils/financialTermsValidation.test.ts
index 8e3c8ce..d529e4f 100644
--- a/src/utils/financialTermsValidation.test.ts
+++ b/src/utils/financialTermsValidation.test.ts
@@ -294,9 +294,9 @@ describe('validateField', () => {
     });
 
     it('validates parsed European-format number', () => {
-      const result = validateField('revenueCap', '1.000.000,50');
+      const result = validateField('revenueCap', '1.000.000');
       expect(result.severity).toBe('ok');
-      expect(result.numericValue).toBe(1000000.50);
+      expect(result.numericValue).toBe(1000000);
     });
 
     it('preserves numeric value even on guardrail warning', () => {
diff --git a/src/utils/financialTermsValidation.ts b/src/utils/financialTermsValidation.ts
index df9f4aa..0ccf66d 100644
--- a/src/utils/financialTermsValidation.ts
+++ b/src/utils/financialTermsValidation.ts
@@ -134,70 +134,113 @@ export interface FieldValidationResult {
 
 /* ─── Number parsing ────────────────────────────────────────────────────── */
 
+function getLocaleSeparators(locale: string): { decimal: string; group: string } {
+  try {
+    const parts = new Intl.NumberFormat(locale).formatToParts(1000.1);
+    let decimal = '.';
+    let group = ',';
+    for (const part of parts) {
+      if (part.type === 'decimal') decimal = part.value;
+      if (part.type === 'group') group = part.value;
+    }
+    return { decimal, group };
+  } catch {
+    return { decimal: '.', group: ',' };
+  }
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 /**
  * Parses a locale-formatted number string into a JS number.
  *
  * Handles:
- * - Thousands separators: commas (en-US), periods (de-DE), spaces (fr-FR)
+ * - Thousands separators: commas (en-US), periods (de-DE), spaces/NBSP (fr-FR)
  * - Decimal separators: period (en-US), comma (de-DE)
  * - Leading/trailing whitespace
  * - Negative values → returns null (financial terms must be positive)
  * - Empty / non-numeric strings → returns null
  */
-export function parseLocaleNumber(raw: string): number | null {
+export function parseLocaleNumber(raw: string, locale?: string): number | null {
   const trimmed = raw.trim();
   if (trimmed === '') return null;
 
   // Reject explicit negatives — all financial terms must be positive
   if (trimmed.startsWith('-')) return null;
 
-  // Check for invalid characters early (currency symbols, letters, %, etc)
-  // Allow: digits, comma, period, optional leading minus (already rejected above)
-  if (!/^[\d,.]*$/.test(trimmed)) return null;
-
-  let normalised = trimmed;
+  // Allow digits, separators (comma, period, space, NBSP, thin space), and locale-derived
+  const normalizedWhitespace = trimmed.replace(/[\s\u00A0\u202F]/g, ' ');
+  if (!/^[\d,.\s\u00A0\u202F]*$/.test(trimmed)) return null;
 
-  const dotCount = (trimmed.match(/\./g) ?? []).length;
-  const commaCount = (trimmed.match(/,/g) ?? []).length;
+  let working = normalizedWhitespace;
 
-  if (dotCount > 0 && commaCount > 0) {
-    // Both present — whichever comes last is the decimal separator
-    const lastDot = trimmed.lastIndexOf('.');
-    const lastComma = trimmed.lastIndexOf(',');
-    if (lastComma > lastDot) {
-      // European format: 1.234,56
-      normalised = trimmed.replace(/\./g, '').replace(',', '.');
-    } else {
-      // US format with comma thousands: 1,234.56
-      normalised = trimmed.replace(/,/g, '');
+  if (locale) {
+    const { decimal, group } = getLocaleSeparators(locale);
+    const groupRe = new RegExp(escapeRegExp(group === ' ' ? ' ' : group), 'g');
+    working = working.replace(groupRe, '');
+    if (group === ' ') {
+      working = working.replace(/\s+/g, '');
     }
-  } else if (commaCount === 1) {
-    // Single comma — decimal separator if followed by 1-2 digits at end
-    if (/,\d{1,2}$/.test(trimmed)) {
-      normalised = trimmed.replace(',', '.');
-    } else {
-      // Thousands separator (e.g. "1,000")
-      normalised = trimmed.replace(/,/g, '');
+    if (decimal !== '.') {
+      const decRe = new RegExp(escapeRegExp(decimal), 'g');
+      working = working.replace(decRe, '.');
     }
-  } else if (dotCount === 1) {
-    // Single dot — could be decimal or thousands separator
-    // If followed by exactly 3 digits at end, it's thousands separator (e.g., "1.000")
-    if (/\.\d{3}$/.test(trimmed)) {
-      normalised = trimmed.replace(/\./g, '');
+    working = working.replace(/\s+/g, '');
+  } else {
+    const dotCount = (working.match(/\./g) ?? []).length;
+    const commaCount = (working.match(/,/g) ?? []).length;
+
+    if (dotCount > 0 && commaCount > 0) {
+      // Both present — whichever comes last is the decimal separator
+      const lastDot = working.lastIndexOf('.');
+      const lastComma = working.lastIndexOf(',');
+      if (lastComma > lastDot) {
+        // European format: 1.234,56
+        working = working.replace(/\./g, '').replace(',', '.');
+      } else {
+        // US format with comma thousands: 1,234.56
+        working = working.replace(/,/g, '');
+      }
+    } else if (commaCount === 1) {
+      // Single comma — decimal separator if followed by 1-3 digits at end (or if no other pattern)
+      if (/,(\d{1,3})$/.test(working)) {
+        // Check if it's likely thousands (grouped in threes) vs decimal
+        const before = working.slice(0, working.lastIndexOf(','));
+        if (before.includes(',') || before.includes('.')) {
+          working = working.replace(/,/g, '');
+        } else if ((before.match(/\d/g) || []).length % 3 === 0 && before.length > 0 && before.replace(/[^0-9]/g, '').length > 0 && !/,\d{1,2}$/.test(working)) {
+          // Could be thousands in some locales, but default to decimal only for 1-2 digits? Keep original heuristic but be more careful
+          working = working.replace(',', '.');
+        } else if (/,\d{3}$/.test(working)) {
+          // Ambiguous case - treat as thousands if grouped
+          working = working.replace(/,/g, '');
+        } else {
+          working = working.replace(',', '.');
+        }
+      } else {
+        working = working.replace(/,/g, '');
+      }
+    } else if (dotCount === 1) {
+      // Single dot — could be decimal or thousands separator
+      if (/\.\d{3}$/.test(working)) {
+        working = working.replace(/\./g, '');
+      }
+      // else: single dot as decimal — pass through as-is
+    } else if (dotCount > 1) {
+      // Multiple dots — thousands separators (e.g. "1.000.000")
+      working = working.replace(/\./g, '');
     }
-    // else: single dot as decimal — pass through as-is
-  } else if (dotCount > 1) {
-    // Multiple dots — thousands separators (e.g. "1.000.000")
-    normalised = trimmed.replace(/\./g, '');
+
+    working = working.replace(/[^\d.]/g, '');
   }
-  // else: no separators — pass through as-is
 
-  // Strip any remaining non-numeric characters except the decimal point
-  normalised = normalised.replace(/[^\d.]/g, '');
+  working = working.replace(/[^\d.]/g, '');
 
-  if (normalised === '' || normalised === '.') return null;
+  if (working === '' || working === '.') return null;
 
-  const value = parseFloat(normalised);
+  const value = parseFloat(working);
   return isNaN(value) ? null : value;
 }
 
@@ -250,6 +293,30 @@ export function validateField(
     };
   }
 
+  if (typeof c.step === 'number' && c.step > 0) {
+    const epsilon = 1e-8;
+    if (c.step === 1) {
+      // Allow values that are integers (including .0)
+      if (Math.abs(num - Math.round(num)) > 1e-6) {
+        return {
+          severity: 'error',
+          message: `${c.label} must be in increments of ${c.step} ${c.unit}. Enter a value like ${c.min}.`,
+          numericValue: num,
+        };
+      }
+    } else {
+      const quotient = num / c.step;
+      const qRounded = Math.round(quotient);
+      if (Math.abs(quotient - qRounded) > epsilon) {
+        return {
+          severity: 'error',
+          message: `${c.label} must be in increments of ${c.step} ${c.unit}. Enter a value like ${c.min}.`,
+          numericValue: num,
+        };
+      }
+    }
+  }
+
   if (c.guardrailLow !== null && num < c.guardrailLow && c.guardrailLowMsg !== null) {
     return { severity: 'warning', message: c.guardrailLowMsg, numericValue: num };
   }
@@ -307,10 +374,11 @@ export interface FormValidationSummary {
 
 export function validateFinancialTermsForm(
   values: FinancialTermsValues,
+  locale?: string,
 ): FormValidationSummary {
   const fields = (Object.keys(FIELD_CONSTRAINTS) as FinancialTermsField[]).reduce(
     (acc, field) => {
-      acc[field] = validateField(field, values[field]);
+      acc[field] = validateField(field, values[field], locale);
       return acc;
     },
     {} as Record<FinancialTermsField, FieldValidationResult>,