@openg2p/registry-widgets 1.1.6-dev.4 → 1.1.6-dev.6

package/dist/index.esm.js

@@ -61,6 +61,10 @@ const widgetSlice = createSlice({
             }
             state.values = merged;
         },
+        /** Full replace of values (section revert / reset). Unlike setValues, does not merge. */
+        replaceValues: (state, action) => {
+            state.values = action.payload;
+        },
         setError: (state, action) => {
             if (action.payload.errors.length > 0) {
                 state.errors[action.payload.widgetId] = action.payload.errors;
@@ -89,7 +93,7 @@ const widgetSlice = createSlice({
         resetAll: () => initialState,
     },
 });
-const { setValue, setValues, setError, setTouched, setLoading, setDataSource, resetWidget, resetAll, } = widgetSlice.actions;
+const { setValue, setValues, replaceValues, setError, setTouched, setLoading, setDataSource, resetWidget, resetAll, } = widgetSlice.actions;
 var widgetReducer = widgetSlice.reducer;
 
 const createWidgetStore = () => {
@@ -99,7 +103,7 @@ const createWidgetStore = () => {
         },
         middleware: (getDefaultMiddleware) => getDefaultMiddleware({
             serializableCheck: {
-                ignoredActions: ['widget/setValue', 'widget/setValues', 'widget/setError'],
+                ignoredActions: ['widget/setValue', 'widget/setValues', 'widget/replaceValues', 'widget/setError'],
                 ignoredPaths: ['widget.values'],
             },
         }),
@@ -152,6 +156,34 @@ const setValueByPath = (obj, path, value) => {
     current[lastKey] = value;
     return newObj;
 };
+/** Remove a nested path (used when reverting to empty schema data). */
+const deleteValueByPath = (obj, path) => {
+    if (!obj || !path)
+        return obj;
+    const keys = path.split('.');
+    if (keys.length === 1) {
+        if (!Object.prototype.hasOwnProperty.call(obj, keys[0])) {
+            return obj;
+        }
+        const { [keys[0]]: _removed, ...rest } = obj;
+        return rest;
+    }
+    const newObj = Array.isArray(obj) ? [...obj] : { ...obj };
+    const lastKey = keys[keys.length - 1];
+    let current = newObj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] == null || typeof current[key] !== 'object') {
+            return newObj;
+        }
+        current[key] = Array.isArray(current[key]) ? [...current[key]] : { ...current[key] };
+        current = current[key];
+    }
+    if (Object.prototype.hasOwnProperty.call(current, lastKey)) {
+        delete current[lastKey];
+    }
+    return newObj;
+};
 /**
  * Parse widget data path (can be string or object)
  */
@@ -186,22 +218,134 @@ const getWidgetValue = (values, dataPath, widgetId) => {
     return result;
 };
 /**
- * Set value in widget state using data path
+ * Set value in widget state using data path.
+ * Pass `undefined` to clear the path(s) and widgetId entry.
  */
 const setWidgetValue = (currentValues, dataPath, widgetId, value) => {
+    const clearWidgetId = (values) => {
+        if (!widgetId || !Object.prototype.hasOwnProperty.call(values, widgetId)) {
+            return values;
+        }
+        const { [widgetId]: _removed, ...rest } = values;
+        return rest;
+    };
+    if (value === undefined) {
+        let cleared = currentValues;
+        if (!dataPath) {
+            return clearWidgetId(cleared);
+        }
+        if (typeof dataPath === 'string') {
+            cleared = deleteValueByPath(cleared, dataPath);
+        }
+        else {
+            for (const path of Object.values(dataPath)) {
+                if (typeof path === 'string') {
+                    cleared = deleteValueByPath(cleared, path);
+                }
+            }
+        }
+        return clearWidgetId(cleared);
+    }
     if (!dataPath) {
         return { ...currentValues, [widgetId]: value };
     }
     if (typeof dataPath === 'string') {
-        return setValueByPath(currentValues, dataPath, value);
+        const next = setValueByPath(currentValues, dataPath, value);
+        return widgetId ? { ...next, [widgetId]: value } : next;
     }
     let newValues = { ...currentValues };
-    for (const [key, path] of Object.entries(dataPath)) {
-        if (value && typeof value === 'object' && key in value) {
-            newValues = setValueByPath(newValues, path, value[key]);
+    if (value === null) {
+        for (const path of Object.values(dataPath)) {
+            if (typeof path === 'string') {
+                newValues = setValueByPath(newValues, path, null);
+            }
+        }
+    }
+    else {
+        for (const [key, path] of Object.entries(dataPath)) {
+            if (value && typeof value === 'object' && key in value) {
+                const pathValue = value[key];
+                newValues =
+                    pathValue === undefined
+                        ? deleteValueByPath(newValues, path)
+                        : setValueByPath(newValues, path, pathValue);
+            }
         }
     }
-    return newValues;
+    return widgetId ? { ...newValues, [widgetId]: value } : newValues;
+};
+
+const isFile = (value) => {
+    return value instanceof File;
+};
+const isSerializedFile = (value) => {
+    return value && typeof value === 'object' && value.__type === 'File';
+};
+const serializeFile = async (file) => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const base64 = reader.result.split(',')[1];
+            resolve({
+                __type: 'File',
+                name: file.name,
+                type: file.type,
+                size: file.size,
+                lastModified: file.lastModified,
+                data: base64,
+            });
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+};
+const deserializeFile = (serialized) => {
+    const byteCharacters = atob(serialized.data);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], { type: serialized.type });
+    return new File([blob], serialized.name, {
+        type: serialized.type,
+        lastModified: serialized.lastModified,
+    });
+};
+const serializeValue = async (value) => {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (isFile(value)) {
+        return await serializeFile(value);
+    }
+    if (Array.isArray(value)) {
+        return Promise.all(value.map(item => serializeValue(item)));
+    }
+    if (value && typeof value === 'object' && !(value instanceof Date) && !(value instanceof RegExp)) {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = await serializeValue(val);
+        }
+        return result;
+    }
+    return value;
+};
+const deserializeValue = (value) => {
+    if (isSerializedFile(value)) {
+        return deserializeFile(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => deserializeValue(item));
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = deserializeValue(val);
+        }
+        return result;
+    }
+    return value;
 };
 
 const VALIDATION_PATTERNS = {
@@ -222,6 +366,16 @@ const getValidationPattern = (validationType) => {
     return VALIDATION_PATTERNS[validationType] || null;
 };
 
+const isWidgetValueEmpty = (value) => {
+    if (value === null || value === undefined || value === '') {
+        return true;
+    }
+    if (typeof value === 'object' && !Array.isArray(value) && value !== null && 'value' in value) {
+        const inner = value.value;
+        return inner === null || inner === undefined || inner === '';
+    }
+    return false;
+};
 /**
  * @param skipRequired - Skip required checks for per-section Save/Next navigation;
  *   format and range validation still run.
@@ -232,7 +386,7 @@ const validateWidget = (value, validation, required = false, skipRequired = fals
         return errors;
     }
     const isRequired = !skipRequired && (validation?.required ?? required);
-    const isEmpty = value === null || value === undefined || value === '';
+    const isEmpty = isWidgetValueEmpty(value);
     if (isRequired && isEmpty) {
         errors.push('This field is required');
         return errors;
@@ -292,6 +446,35 @@ const validateWidget = (value, validation, required = false, skipRequired = fals
     }
     return errors;
 };
+const isDocsSlotFilled = (stored) => {
+    if (stored == null || stored === '') {
+        return false;
+    }
+    if (typeof stored === 'string') {
+        return stored.trim().length > 0;
+    }
+    if (typeof File !== 'undefined' && stored instanceof File) {
+        return true;
+    }
+    return isSerializedFile(stored);
+};
+const validateDocsWidget = (value, documents, skipRequired = false) => {
+    if (skipRequired || !documents?.length) {
+        return [];
+    }
+    const docsValue = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+    const errors = [];
+    for (const doc of documents) {
+        if (!doc['document-required'])
+            continue;
+        if (!isDocsSlotFilled(docsValue[doc['document-key']])) {
+            errors.push('This document is required');
+        }
+    }
+    return errors;
+};
 const createZodSchema = (validation, required = false) => {
     if (!validation && !required) {
         return null;
@@ -1739,6 +1922,7 @@ const useBaseWidget = (options) => {
     const loading = useSelector((state) => state.widget.loading[widgetId] || false);
     const dataSourceOptions = useSelector((state) => state.widget.dataSources[widgetId] ?? EMPTY_DATA_SOURCE);
     const isLayoutWidget = config['widget-type'] === 'layout';
+    const isDocsWidget = config.widget === 'docs';
     const userHasSetValueRef = useRef(false);
     const valuesRef = useRef(values);
     const loadingRef = useRef(loading);
@@ -1771,6 +1955,19 @@ const useBaseWidget = (options) => {
         if (isLayoutWidget) {
             return undefined; // Layout widgets don't have values
         }
+        if (isDocsWidget) {
+            let docsValue = values[widgetId];
+            if (docsValue === undefined && config['widget-data-path']) {
+                docsValue = getWidgetValue(values, config['widget-data-path'], widgetId);
+            }
+            if (userHasSetValueRef.current) {
+                return docsValue;
+            }
+            if (docsValue === null) {
+                return null;
+            }
+            return docsValue !== undefined ? docsValue : config['widget-data-default'];
+        }
         let value = values[widgetId];
         if (value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value)) {
             value = extractValueFromObject(value);
@@ -1797,13 +1994,13 @@ const useBaseWidget = (options) => {
             return null; // User explicitly cleared it, don't use default
         }
         return value !== undefined ? value : config['widget-data-default'];
-    }, [values, config, widgetId, isLayoutWidget, extractValueFromObject]);
+    }, [values, config, widgetId, isLayoutWidget, isDocsWidget, extractValueFromObject]);
     const lastMirroredValueRef = useRef(null);
     // Mirror value from dataPath to widgetId in Redux state if it's not already there.
     // This is essential for widgets that depend on this widget via 'dependsOn' using its widgetId,
     // CRITICAL: This ensures that dependencies are resolved correctly when entering Edit mode.
     useEffect(() => {
-        if (isLayoutWidget || !config['widget-data-path']) {
+        if (isLayoutWidget || isDocsWidget || !config['widget-data-path']) {
             return;
         }
         const rawValue = getWidgetValue(values, config['widget-data-path'], widgetId);
@@ -1883,7 +2080,9 @@ const useBaseWidget = (options) => {
             dispatch(setValues(updatedValues));
         }
         if (validate) {
-            const validationErrors = validateWidget(newValue, config['widget-data-validation'], resolveIsRequired(currentValues));
+            const validationErrors = isDocsWidget
+                ? validateDocsWidget(newValue, config['documents'])
+                : validateWidget(newValue, config['widget-data-validation'], resolveIsRequired(currentValues));
             dispatch(setError({ widgetId, errors: validationErrors }));
         }
         if (onValueChange) {
@@ -1897,11 +2096,16 @@ const useBaseWidget = (options) => {
                 timestamp: Date.now(),
             });
         }
-    }, [config, widgetId, dispatch, onValueChange, eventBus, resolveIsRequired] // Removed 'values' to prevent stale closures
-    );
+    }, [config, widgetId, dispatch, onValueChange, eventBus, resolveIsRequired, isDocsWidget]);
     const handleBlur = useCallback(() => {
         dispatch(setTouched({ widgetId, touched: true }));
-        const validationErrors = validateWidget(currentValue, config['widget-data-validation'], resolveIsRequired(valuesRef.current));
+        const latestValues = valuesRef.current;
+        const valueToValidate = isDocsWidget
+            ? latestValues[widgetId] ?? getWidgetValue(latestValues, config['widget-data-path'], widgetId)
+            : currentValue;
+        const validationErrors = isDocsWidget
+            ? validateDocsWidget(valueToValidate, config['documents'])
+            : validateWidget(valueToValidate, config['widget-data-validation'], resolveIsRequired(latestValues));
         dispatch(setError({ widgetId, errors: validationErrors }));
         if (eventBus) {
             eventBus.publish({
@@ -1911,7 +2115,7 @@ const useBaseWidget = (options) => {
                 timestamp: Date.now(),
             });
         }
-    }, [currentValue, config, widgetId, dispatch, eventBus, resolveIsRequired]);
+    }, [currentValue, config, widgetId, dispatch, eventBus, resolveIsRequired, isDocsWidget]);
     const getFieldValue = useCallback((path) => {
         return getWidgetValue(values, path, '');
     }, [values]);
@@ -2417,7 +2621,9 @@ const sectionValidate = (section, currentSchemaData, dispatch, skipRequired = fa
         }
         const value = getWidgetValue(currentSchemaData, widget['widget-data-path'], widgetId);
         const isRequired = shouldRequireWidget(widget['widget-data-options'], currentSchemaData, widget['widget-required'] ?? false);
-        const errors = validateWidget(value, widget['widget-data-validation'], isRequired, skipRequired);
+        const errors = widget.widget === 'docs'
+            ? validateDocsWidget(value, widget['documents'], skipRequired)
+            : validateWidget(value, widget['widget-data-validation'], isRequired, skipRequired);
         if (errors.length > 0) {
             isValid = false;
             dispatch(setTouched({ widgetId, touched: true }));
@@ -2649,14 +2855,10 @@ const buildSectionRecords = (widgets, sourceData, { sectionRegisterId, editActio
                 : fullPath;
             cleanedSnapshot[fieldPath] = value;
         });
-        const sectionData = sectionRegisterId
-            ? sourceData[sectionRegisterId] ?? {}
-            : {};
         const includeEditAction = editAction === 'always' ||
             (editAction === 'when-register-id' && sectionRegisterId);
         return [
             {
-                ...sectionData,
                 ...cleanedSnapshot,
                 ...(includeEditAction ? { edit_action: 'UPDATE' } : {}),
             },
@@ -2716,6 +2918,119 @@ function buildSectionChanges(section, storeValues, options) {
     };
 }
 
+const IDENTITY_AND_META_KEYS = new Set([
+    'edit_action',
+    'internal_record_id',
+    'link_internal_record_id',
+    'functional_record_id',
+    'created_at',
+    'created_by',
+    'last_approved_at',
+    'last_approved_by',
+    'search_text',
+]);
+const isPlainRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const valuesEqual = (baselineValue, currentValue) => {
+    if (Object.is(baselineValue, currentValue))
+        return true;
+    if (baselineValue === undefined || baselineValue === null || baselineValue === '') {
+        return currentValue === undefined || currentValue === null || currentValue === '';
+    }
+    if (currentValue === undefined || currentValue === null || currentValue === '') {
+        return false;
+    }
+    try {
+        return JSON.stringify(baselineValue) === JSON.stringify(currentValue);
+    }
+    catch {
+        return false;
+    }
+};
+const getRowId = (row) => {
+    const id = row.internal_record_id;
+    return typeof id === 'string' && id.length > 0 ? id : null;
+};
+const sectionFieldKeys = (baseline, current) => {
+    const keys = new Set([...Object.keys(baseline), ...Object.keys(current)]);
+    return [...keys].filter((key) => !IDENTITY_AND_META_KEYS.has(key));
+};
+const pickChangedFields = (baseline, current) => {
+    const changed = {};
+    for (const key of sectionFieldKeys(baseline, current)) {
+        if (!valuesEqual(baseline[key], current[key])) {
+            changed[key] = current[key];
+        }
+    }
+    return changed;
+};
+/** All section fields (changed or not). Identity / meta keys stay out of the CR payload. */
+const pickAllSectionFields = (baseline, current) => {
+    const fields = {};
+    for (const key of sectionFieldKeys(baseline, current)) {
+        fields[key] = Object.prototype.hasOwnProperty.call(current, key)
+            ? current[key]
+            : baseline[key];
+    }
+    return fields;
+};
+const toRowList = (records) => records.filter(isPlainRecord);
+const diffFormRecord = (baselineRecords, currentRecords) => {
+    const baseline = toRowList(baselineRecords)[0] ?? {};
+    const current = toRowList(currentRecords)[0] ?? {};
+    const changedFields = pickChangedFields(baseline, current);
+    if (Object.keys(changedFields).length === 0)
+        return [];
+    return [{ ...pickAllSectionFields(baseline, current), edit_action: 'UPDATE' }];
+};
+const diffTableRows = (baselineRecords, currentRecords) => {
+    const baselineRows = toRowList(baselineRecords);
+    const currentRows = toRowList(currentRecords);
+    const baselineById = new Map();
+    for (const row of baselineRows) {
+        const id = getRowId(row);
+        if (id) {
+            baselineById.set(id, row);
+        }
+    }
+    const result = [];
+    currentRows.forEach((row) => {
+        const editAction = typeof row.edit_action === 'string' ? row.edit_action : undefined;
+        const rowId = getRowId(row);
+        // Deleted row
+        if (editAction === 'DELETE') {
+            if (!rowId)
+                return;
+            result.push({
+                ...row,
+                internal_record_id: rowId,
+                edit_action: 'DELETE',
+            });
+            return;
+        }
+        // New row
+        if (editAction === 'ADD' || !rowId) {
+            result.push({
+                ...row,
+                edit_action: 'ADD',
+            });
+            return;
+        }
+        // Existing row:
+        // Always include the complete row with UPDATE action,
+        // whether it was actually modified or not.
+        result.push({
+            ...row,
+            edit_action: 'UPDATE',
+        });
+    });
+    return result;
+};
+function diffSectionChangeRecords(baselineRecords, currentRecords, { isTable }) {
+    return isTable
+        ? diffTableRows(baselineRecords, currentRecords)
+        : diffFormRecord(baselineRecords, currentRecords);
+}
+
 const cloneValue = (value) => {
     if (value === undefined) {
         return undefined;
@@ -2780,7 +3095,10 @@ function captureSectionEditSnapshot(values, section, options) {
 function applySectionEditSnapshot(currentValues, snapshot) {
     let result = currentValues;
     for (const { path, value } of snapshot.dataPaths) {
-        result = setValueByPath(result, path, cloneValue(value));
+        result =
+            value === undefined
+                ? deleteValueByPath(result, path)
+                : setValueByPath(result, path, cloneValue(value));
     }
     for (const [widgetId, entry] of Object.entries(snapshot.widgetIds)) {
         if (entry.present) {
@@ -2794,36 +3112,55 @@ function applySectionEditSnapshot(currentValues, snapshot) {
     return result;
 }
 
+const resolveSchemaValue = (schemaData, dataPath) => {
+    if (typeof dataPath === 'object') {
+        const value = {};
+        Object.entries(dataPath).forEach(([key, path]) => {
+            if (typeof path === 'string') {
+                value[key] = getValueByPath(schemaData, path);
+            }
+        });
+        return value;
+    }
+    return getValueByPath(schemaData, dataPath);
+};
+/** Empty schema → explicit empty value so replaceValues clears edited data. */
+const emptyRestoreValue = (widget, schemaValue) => {
+    if (schemaValue !== undefined)
+        return schemaValue;
+    return isTableLikeWidget(widget) ? [] : null;
+};
+const clearTableCellDraftKeys = (values, widgetId) => {
+    const prefix = `${widgetId}-row-`;
+    const next = { ...values };
+    for (const key of Object.keys(next)) {
+        if (key.startsWith(prefix)) {
+            delete next[key];
+        }
+    }
+    return next;
+};
+/**
+ * Restore section widget values after cancel/save from schemaData
+ * (approved register data). Uses replaceValues — setValues merges and would
+ * keep deleted table rows / cleared fields.
+ */
 const revertSectionValues = ({ section, store, dispatch, schemaData, contextSchemaData, hasSupportingDocuments, sectionId, editEntrySnapshot, }) => {
     const sectionWidgets = collectWidgets(section.panels);
     const currentStoreValues = store.getState().widget.values;
-    let newStoreValues = currentStoreValues;
-    if (editEntrySnapshot) {
-        newStoreValues = applySectionEditSnapshot(currentStoreValues, editEntrySnapshot);
-    }
-    else {
-        const oldSchemaData = schemaData || contextSchemaData;
+    const oldSchemaData = schemaData || contextSchemaData;
+    let newStoreValues = { ...currentStoreValues };
+    if (oldSchemaData) {
         sectionWidgets.forEach((widget) => {
             const widgetId = widget['widget-id'];
-            const originalDataPath = widget['widget-data-path'];
-            const storeDataPath = originalDataPath;
-            if (widgetId && originalDataPath) {
-                let oldValue;
-                if (typeof originalDataPath === 'object') {
-                    oldValue = {};
-                    Object.entries(originalDataPath).forEach(([key, path]) => {
-                        if (typeof path === 'string') {
-                            oldValue[key] = getValueByPath(oldSchemaData, path);
-                        }
-                    });
-                }
-                else if (typeof originalDataPath === 'string') {
-                    oldValue = getValueByPath(oldSchemaData, originalDataPath);
-                }
-                if (oldValue !== undefined) {
-                    newStoreValues = setWidgetValue(newStoreValues, storeDataPath, widgetId, oldValue);
-                    newStoreValues = { ...newStoreValues, [widgetId]: oldValue };
-                }
+            const dataPath = widget['widget-data-path'];
+            if (!widgetId || !dataPath)
+                return;
+            const schemaValue = resolveSchemaValue(oldSchemaData, dataPath);
+            const restoreValue = emptyRestoreValue(widget, schemaValue);
+            newStoreValues = setWidgetValue(newStoreValues, dataPath, widgetId, restoreValue);
+            if (isTableLikeWidget(widget)) {
+                newStoreValues = clearTableCellDraftKeys(newStoreValues, widgetId);
             }
         });
         if (hasSupportingDocuments) {
@@ -2832,84 +3169,14 @@ const revertSectionValues = ({ section, store, dispatch, schemaData, contextSche
                 const widgetId = `supporting-doc-${sectionId}-${index}`;
                 const originalDataPath = doc['document-data-path'];
                 const oldValue = getValueByPath(oldSchemaData, originalDataPath);
-                newStoreValues = setWidgetValue(newStoreValues, originalDataPath, widgetId, oldValue);
-            });
-        }
-    }
-    dispatch(setValues(newStoreValues));
-};
-
-const isFile = (value) => {
-    return value instanceof File;
-};
-const isSerializedFile = (value) => {
-    return value && typeof value === 'object' && value.__type === 'File';
-};
-const serializeFile = async (file) => {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            const base64 = reader.result.split(',')[1];
-            resolve({
-                __type: 'File',
-                name: file.name,
-                type: file.type,
-                size: file.size,
-                lastModified: file.lastModified,
-                data: base64,
+                newStoreValues = setWidgetValue(newStoreValues, originalDataPath, widgetId, oldValue === undefined ? null : oldValue);
             });
-        };
-        reader.onerror = reject;
-        reader.readAsDataURL(file);
-    });
-};
-const deserializeFile = (serialized) => {
-    const byteCharacters = atob(serialized.data);
-    const byteNumbers = new Array(byteCharacters.length);
-    for (let i = 0; i < byteCharacters.length; i++) {
-        byteNumbers[i] = byteCharacters.charCodeAt(i);
-    }
-    const byteArray = new Uint8Array(byteNumbers);
-    const blob = new Blob([byteArray], { type: serialized.type });
-    return new File([blob], serialized.name, {
-        type: serialized.type,
-        lastModified: serialized.lastModified,
-    });
-};
-const serializeValue = async (value) => {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (isFile(value)) {
-        return await serializeFile(value);
-    }
-    if (Array.isArray(value)) {
-        return Promise.all(value.map(item => serializeValue(item)));
-    }
-    if (value && typeof value === 'object' && !(value instanceof Date) && !(value instanceof RegExp)) {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = await serializeValue(val);
         }
-        return result;
-    }
-    return value;
-};
-const deserializeValue = (value) => {
-    if (isSerializedFile(value)) {
-        return deserializeFile(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => deserializeValue(item));
     }
-    if (value && typeof value === 'object') {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = deserializeValue(val);
-        }
-        return result;
+    else if (editEntrySnapshot) {
+        newStoreValues = applySectionEditSnapshot(currentStoreValues, editEntrySnapshot);
     }
-    return value;
+    dispatch(replaceValues(newStoreValues));
 };
 
 const collectDocsWidgetFiles = (panels, sourceData) => {
@@ -3004,15 +3271,16 @@ const extractProfileImage = (records) => {
     });
     return { records: clonedRecords, profileImage };
 };
-const executeSectionSave = async ({ store, dispatch, section, schemaData, contextSchemaData, hasSupportingDocuments, dbSectionId, sectionRegisterId, onSectionSave, }) => {
+const executeSectionSave = async ({ store, dispatch, section, schemaData, contextSchemaData, hasSupportingDocuments, dbSectionId, sectionRegisterId, sectionFieldsOnly = false, skipRequired = false, onSectionSave, }) => {
     const sectionWidgets = collectWidgets(section.panels);
     const currentState = store.getState().widget;
     let currentSchemaData = currentState.values || {};
-    const isSectionValid = sectionValidate(section, currentSchemaData, dispatch, true);
+    const isSectionValid = sectionValidate(section, currentSchemaData, dispatch, skipRequired);
     if (!isSectionValid) {
         return { validated: false, saved: false, currentSchemaData };
     }
-    const oldSchemaData = schemaData || contextSchemaData;
+    const baselineSource = (schemaData || contextSchemaData || {});
+    const baselineRecords = trackSectionChanges(sectionWidgets, baselineSource, sectionRegisterId);
     const newSchemaData = trackSectionChanges(sectionWidgets, currentSchemaData, sectionRegisterId);
     const sectionFiles = [];
     if (hasSupportingDocuments) {
@@ -3024,12 +3292,20 @@ const executeSectionSave = async ({ store, dispatch, section, schemaData, contex
     // Collect files from any docs widgets and add them to the save payload.
     const docsFiles = collectDocsWidgetFiles(section.panels, currentSchemaData);
     sectionFiles.push(...docsFiles);
-    if (JSON.stringify(oldSchemaData) === JSON.stringify(newSchemaData)) {
+    if (JSON.stringify(baselineRecords) === JSON.stringify(newSchemaData) && docsFiles.length === 0) {
         return { validated: true, saved: false, currentSchemaData };
     }
     const { records: recordsWithImage, profileImage } = extractProfileImage([...newSchemaData]);
     // Strip the docs blob objects from records — they travel in `files` instead.
-    const records = stripDocsWidgetFields(recordsWithImage, section.panels);
+    let records = stripDocsWidgetFields(recordsWithImage, section.panels);
+    if (sectionFieldsOnly) {
+        const baselineStripped = stripDocsWidgetFields([...baselineRecords], section.panels);
+        const isTable = sectionWidgets.some((widget) => isTableLikeWidget(widget));
+        records = diffSectionChangeRecords(baselineStripped, records, { isTable });
+        if (records.length === 0 && sectionFiles.length === 0 && !profileImage) {
+            return { validated: true, saved: false, currentSchemaData };
+        }
+    }
     try {
         await onSectionSave?.({
             section_id: dbSectionId ?? section['section-id'],
@@ -3046,23 +3322,6 @@ const executeSectionSave = async ({ store, dispatch, section, schemaData, contex
     return { validated: true, saved: true, currentSchemaData };
 };
 
-const useCrViewData = (mode, currentSchemaData, storeValues) => useMemo(() => {
-    if (mode !== 'CRView')
-        return null;
-    const dataSource = { ...storeValues, ...currentSchemaData };
-    const recordPath = Object.keys(dataSource)[0];
-    const records = dataSource[recordPath]?.records;
-    const auditPath = Array.isArray(records) && records.length > 0
-        ? `${recordPath}.records.${records.length - 1}`
-        : recordPath;
-    return {
-        createdBy: getValueByPath(dataSource, `${auditPath}.created_by`),
-        createdDate: getValueByPath(dataSource, `${auditPath}.created_at`),
-        approvedBy: getValueByPath(dataSource, `${auditPath}.last_approved_by`),
-        approvedDate: getValueByPath(dataSource, `${auditPath}.last_approved_at`),
-    };
-}, [mode, currentSchemaData, storeValues]);
-
 const useIntakeFormAccordion = (mode, sectionIndex, expandedSectionIndex, isAccessible = false, onExpandSection) => {
     const [standaloneExpanded, setStandaloneExpanded] = useState(true);
     const isExpandedFromContainer = typeof sectionIndex === 'number' && expandedSectionIndex === sectionIndex;
@@ -3198,7 +3457,7 @@ const useSectionDirty = ({ mode, isDraft, isEditMode, section, sectionId, hasSup
     return {
         isDirty,
         intakeFormSectionStatus,
-        editEntrySnapshotRef: editEntrySnapshotRef,
+        editEntrySnapshotRef,
         captureEditEntrySnapshot,
         markIntakeFormSaved,
         markIntakeFormSavedWithoutData,
@@ -3255,6 +3514,8 @@ const useSectionActions = ({ section, originalSectionId, sectionId, mode, isDraf
             hasSupportingDocuments,
             dbSectionId,
             sectionRegisterId,
+            sectionFieldsOnly: mode === 'RegistryView' || mode === 'CRView',
+            skipRequired: false,
             onSectionSave,
         });
         if (!result.validated)
@@ -3293,6 +3554,7 @@ const useSectionActions = ({ section, originalSectionId, sectionId, mode, isDraf
                 hasSupportingDocuments,
                 dbSectionId,
                 sectionRegisterId,
+                skipRequired: true,
                 onSectionSave,
             });
             if (!result.validated)
@@ -3405,19 +3667,15 @@ const openFileInNewTab = (file) => {
     window.setTimeout(() => URL.revokeObjectURL(url), 60000);
 };
 
-var img$h = "data:image/png;base64,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";
-
-var img$g = "data:image/png;base64,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";
+var img$f = "data:image/png;base64,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";
 
-var img$f = "data:image/png;base64,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";
+var img$e = "data:image/png;base64,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";
 
-var img$e = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAkCAYAAACe0YppAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAHqADAAQAAAABAAAAJAAAAAAh0JciAAACrUlEQVRYCcWXPW8TQRCG31kbpNBChGiiRJQ0tFDggPgBtKGhJgEJUGxDFCmJUBKwDUoV2jRxS2NEhZCgAPELKBAhIPFRpKIwUXIe3vFHFJzbs2zWupHWu7e7M8/OenbuVkDReUzoLjbZvGDP/ysiWJQSlpLsiN7HOBp4rco6oBC+Svicz2QWERYULSjh605Q3dvHnk/B138sg1EV1DrjtPVAC9j1eS6NPD5x8lko3rgKch3FfmvbOY2w1a3n89xxlWdsMuvP3UqDPhO2xPLF9NueL3Tbct0dIZ4jJdTh8iH4Irf9H/hQwLZ4edSCs7ltz/Tc4CvWNhka2IwbXDKYZLMDt4Brep61CUFE8Jt26iwj9KbcKGDW7GrDfnGi+csf8zwqoh7MY1nFjhLYBpziKTl3UIDRDthqp5gJ5zENZsrMCXlscQE3DoMO2sJ8wURFr08GBRtAythgZeWIRAVsSDtZBdvqI5QeHamBE7c6yqPKJND/G0sZvIqXmQpmfI57wVrEGI/CFINhIOGCp3lml/mS+B5nwAuWx/iqs5hnDr8ap9ijT7noF+5JPNR0vWAblAqWWVkJLqkFV2rgxK1mVG8ySC4Oss/NqC5j2qfrBdf5RSERrg8c1cBNvYOHsoYfcXAveISvNHpcZIrLxSkm9rXO8SvngZquF2yDTPolVlaCS2rBlRo4cav56fscgvNJ+8wYqDEt3k6aEzfmBVtU82P/Wq+oZiq/pfdQkqf4Fgfw9XnBFtXM1XeZq73nmGPK68871yfUFuMF2yBz9RorK8ElteDiHY2blYI4/ks7xuUCxofNJ2OizfiZZVTW2GGfKJNMkc9cFlUu5k/QRQiOYx9TfHFcMrtkvhWdw2l2fmDnWFCY39i2XWucrOAXb1A5ruKjf26wkfeEXrE71V+iV9IhdJQEvwAAAABJRU5ErkJggg==";
+var img$d = "data:image/png;base64,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";
 
-var img$d = "data:image/png;base64,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";
+var img$c = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAkCAYAAACe0YppAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAHqADAAQAAAABAAAAJAAAAAAh0JciAAACrUlEQVRYCcWXPW8TQRCG31kbpNBChGiiRJQ0tFDggPgBtKGhJgEJUGxDFCmJUBKwDUoV2jRxS2NEhZCgAPELKBAhIPFRpKIwUXIe3vFHFJzbs2zWupHWu7e7M8/OenbuVkDReUzoLjbZvGDP/ysiWJQSlpLsiN7HOBp4rco6oBC+Svicz2QWERYULSjh605Q3dvHnk/B138sg1EV1DrjtPVAC9j1eS6NPD5x8lko3rgKch3FfmvbOY2w1a3n89xxlWdsMuvP3UqDPhO2xPLF9NueL3Tbct0dIZ4jJdTh8iH4Irf9H/hQwLZ4edSCs7ltz/Tc4CvWNhka2IwbXDKYZLMDt4Brep61CUFE8Jt26iwj9KbcKGDW7GrDfnGi+csf8zwqoh7MY1nFjhLYBpziKTl3UIDRDthqp5gJ5zENZsrMCXlscQE3DoMO2sJ8wURFr08GBRtAythgZeWIRAVsSDtZBdvqI5QeHamBE7c6yqPKJND/G0sZvIqXmQpmfI57wVrEGI/CFINhIOGCp3lml/mS+B5nwAuWx/iqs5hnDr8ap9ijT7noF+5JPNR0vWAblAqWWVkJLqkFV2rgxK1mVG8ySC4Oss/NqC5j2qfrBdf5RSERrg8c1cBNvYOHsoYfcXAveISvNHpcZIrLxSkm9rXO8SvngZquF2yDTPolVlaCS2rBlRo4cav56fscgvNJ+8wYqDEt3k6aEzfmBVtU82P/Wq+oZiq/pfdQkqf4Fgfw9XnBFtXM1XeZq73nmGPK68871yfUFuMF2yBz9RorK8ElteDiHY2blYI4/ks7xuUCxofNJ2OizfiZZVTW2GGfKJNMkc9cFlUu5k/QRQiOYx9TfHFcMrtkvhWdw2l2fmDnWFCY39i2XWucrOAXb1A5ruKjf26wkfeEXrE71V+iV9IhdJQEvwAAAABJRU5ErkJggg==";
 
-var img$c = "data:image/png;base64,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";
-
-var img$b = "data:image/png;base64,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";
+var img$b = "data:image/png;base64,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";
 
 var img$a = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAgKADAAQAAAABAAAAgAAAAABIjgR3AAAFPElEQVR4Ae2dzWtdVRTFn5o40EFTraQgFIoOI04cVOdVQZxIoP4DrSSx1o515h9QCgWtrW3UGPsxcKTYjgt+xagdONNBKCRiCEgQCYXWtcFb8l5vYnLevefsc8/vwOJ+vHfP2XutdfZ536/Xo8EADMAADMAADMAADMAADMAADMAADMAADMAADHSfgYe6n2IjGY6ql2eEEWG9kR7pJAsGXlOUC8KGcPc/rGg7J4wLtI4yMKa85oVK9Lrtqm6f7Gj+Raf1mLJfFOpEHzx3R/ebKpqtjiW/G/ErM2CCjpggRHxMgPj3lgoqQcZm+EqxV7N5mC0myNAERxsSvzKOmWA6Qx6KDPkBZb0mVOI1tcUEmdjpqRbEr0yECTIwgb3SVwnW1pblwLERXo1gADMWJnBqggORDIAJnBrAwlrGBI7ViRDa6xENYJVgJkJODLFLBr7Q/dt6EFjXLybYpUBt332PBvgOE7RNs+/+MYFvfaJEhwmi0Ox7EDPB90Ld2t3WOR4TOPNEChO86YyD4sOxzwX+ILQ16+v6xQTObIcJnAmSIhxMkIJ1Z2OaCez7AXVlu61zLAfOTLAXEzhTJEE4KUxwPEGeDLkNA2aCH4W2Sn9dv5hgG0FS3IQJUrDubEwzwU6/QlY3q0POUQmcmWCYbxOFGMCuwQSYABM480DPKsFPQuisDrmOSuDMBSlM8JYzDooP53ExELsSYAJntjMT/CyElPXQazABJuhhAkyACZx5oGfLwS9CaGkPuY5K4MwF+xKY4IQzDooPx0xwUwiZ0aHXYAJntsMEzgRJEY57E1iA7wlfC38KoeWH63xxt6PlYFKC/4HonTX9tiY4gvCdFX5zNX5bOvc1+7n4/cKXwiN9t3DQRQZeVlJ/Cd9WyZkB3hFerE6w7TwDfSZ4UOk+1/mUSXCQgVM68ZKdtB9KXBXsJUtaWQwsKd0JM4A9SKCVycC7tgTQymXgeSpAueJb5stUgLIN0MMAZRtgEQOUbYBv7DHA78LBsnkoMvslZT1hFWCxyPRJ+pgoWDcD3ICL4hg4qYyvVVk/rJ1fhc3vGrHfXT7ue0fQjPCCcBsTdH4S1IpvBrB2SPhNYPZ3k4PaD4TY28FVu6WdWeFv4R9hTHhUoOXPgM380/mnkX8G9rT7fSFmla2d+flTmV8GJv4HiJ+fcE1EjPhNsJhpHyb+WYGyn6mAw4Rt4n8YWXy+HDqMYg1ea+KfQ/wGGc2oK8TPSKymQzXxzwsx13zKftMqBvZn4n+E+IHsZX6ZvbN6AfEzVzEwfBP/YmTx+aHIQLGavgzxm2Y0o/5M/Fkh5gM+Zr4Tg5j4HyO+EzUih2Hif4L4kVl3MhziOxEiRRgm/qcCa34K9hOPaZ+emossPv8dmFj0angT/zPEr+goa4v4Zendl62JPy/EXPMp+30SpDsw8T9H/HQCpBzZxL+E+CklSDd2CvFn0qXLyJsZGNHBZSHmmo/4mxVIuG/iX0H8hAokHBrxE5LvYegzCoKy70GJBDEcRvwErDsa0n4jKdbsn3aUN6GIgScRv2wfvBLJAMx8pz6zv8lpu/wjvlPxLaynWzTAHfWN+May42bf5FkTmq4CiO9Y9MHQ3mjYAIg/yHAGx9cbMoGJP5VBvoQ4wMATOh72v30Rf4DU3A6HMQHi56b2FvGGmADxtyAz19O7MQHi56ry/8Rtf6N3Vdju6aH93Z69kETrMAMm8IKwIVRmWNH+nDAu0AphYFR5PivYm0c0GIABGIABGIABGIABGIABGIABGIABGIABGIABGMiMgX8BIPxPwjb9HfIAAAAASUVORK5CYII=";
 
@@ -3571,7 +3829,7 @@ const FileInputWidget = ({ config }) => {
             const file = files[0];
             const fileName = file instanceof File ? file.name : file.split('/').pop() || file;
             const canPreview = canPreviewInWeb(file);
-            const fileIconElement = (jsxRuntimeExports.jsx("img", { src: img$e, alt: "File icon", style: {
+            const fileIconElement = (jsxRuntimeExports.jsx("img", { src: img$c, alt: "File icon", style: {
                     width: '15px',
                     height: '18px',
                     aspectRatio: '5/6',
@@ -3588,7 +3846,7 @@ const FileInputWidget = ({ config }) => {
         return (jsxRuntimeExports.jsx("div", { className: "flex flex-wrap gap-2", children: files.map((file, index) => {
                 const fileName = file instanceof File ? file.name : file.split('/').pop() || file;
                 const canPreview = canPreviewInWeb(file);
-                const fileIconElement = (jsxRuntimeExports.jsx("img", { src: img$e, alt: "File icon", style: {
+                const fileIconElement = (jsxRuntimeExports.jsx("img", { src: img$c, alt: "File icon", style: {
                         width: '15px',
                         height: '18px',
                         aspectRatio: '5/6',
@@ -3624,7 +3882,7 @@ const FileInputWidget = ({ config }) => {
                                                 fontWeight: 400,
                                                 lineHeight: '24px',
                                                 textAlign: 'left'
-                                            }, children: t?.('common.uploadFile') || 'Upload File' }), jsxRuntimeExports.jsx("img", { src: img$d, alt: "Upload", style: {
+                                            }, children: t?.('common.uploadFile') || 'Upload File' }), jsxRuntimeExports.jsx("img", { src: img$b, alt: "Upload", style: {
                                                 width: '18px',
                                                 height: '18px',
                                                 aspectRatio: '1/1',
@@ -3661,61 +3919,6 @@ const SectionEditControls = ({ onCancel, onSave, isDirty, }) => {
                     }, children: t?.('common.save') || 'Save' })] }) }));
 };
 
-const CRViewFooter = ({ createdBy, createdDate, approvedBy, approvedDate, }) => (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx("hr", { className: "w-full", style: {
-                height: '1px',
-                marginTop: '20px',
-                marginBottom: '0px',
-                border: 'none',
-                backgroundColor: 'var(--owt-color-border, #C4C4C4)',
-            } }), jsxRuntimeExports.jsxs("div", { className: "cr-view-container", style: {
-                marginTop: '20px',
-                paddingBottom: '30px',
-                display: 'flex',
-                justifyContent: 'space-between',
-                alignItems: 'center',
-                width: '100%',
-            }, children: [jsxRuntimeExports.jsxs("div", { className: "created-by-section", style: { display: 'flex', alignItems: 'center', gap: '6px', flex: 1 }, children: [jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: "Created by" }), jsxRuntimeExports.jsx("img", { src: img$c, alt: "Person", width: "16", height: "16", style: {
-                                filter: 'brightness(0) saturate(100%) invert(56%) sepia(45%) saturate(5139%) hue-rotate(348deg) brightness(96%) contrast(92%)',
-                            } }), createdBy != null && createdBy !== '' && (jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: String(createdBy) })), jsxRuntimeExports.jsx("img", { src: img$b, alt: "Calendar", width: "16", height: "16", style: { marginLeft: '6px' } }), createdDate != null && createdDate !== '' && (jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: String(createdDate) }))] }), jsxRuntimeExports.jsxs("div", { className: "approved-by-section", style: {
-                        display: 'flex',
-                        alignItems: 'center',
-                        gap: '6px',
-                        flex: 1,
-                        justifyContent: 'flex-end',
-                    }, children: [jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: "Approved by" }), jsxRuntimeExports.jsx("img", { src: img$c, alt: "Person", width: "16", height: "16", style: {
-                                filter: 'brightness(0) saturate(100%) invert(56%) sepia(45%) saturate(5139%) hue-rotate(348deg) brightness(96%) contrast(92%)',
-                            } }), approvedBy != null && approvedBy !== '' && (jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: String(approvedBy) })), jsxRuntimeExports.jsx("img", { src: img$b, alt: "Calendar", width: "16", height: "16", style: { marginLeft: '6px' } }), approvedDate != null && approvedDate !== '' && (jsxRuntimeExports.jsx("span", { style: {
-                                fontFamily: 'Roboto, sans-serif',
-                                fontSize: '14px',
-                                color: 'var(--owt-color-text, #011627)',
-                                fontWeight: 'normal',
-                            }, children: String(approvedDate) }))] })] })] }));
-
 const SectionStyles = ({ sectionClassId, gridId, columnSpan, hasTableWidget, readonlyValueRowRootsCss, readonlyValueRowFlex1Css, readonlySingleLineValueTextCss, }) => (jsxRuntimeExports.jsx("style", { children: `
     .${sectionClassId} {
       width: 100%;
@@ -3793,6 +3996,12 @@ const SectionStyles = ({ sectionClassId, gridId, columnSpan, hasTableWidget, rea
       min-width: 0;
       position: relative;
     }
+    #${gridId} > hr,
+    #${gridId} > .registry-edit-details {
+      flex: 0 0 100%;
+      width: 100%;
+      max-width: 100%;
+    }
     @media (min-width: 640px) {
       #${gridId} > .panel-wrapper {
         flex: 1 1 calc(50% - 0.75rem);
@@ -4040,7 +4249,7 @@ const IntakeFormLayout = ({ section, sectionId, gridId, sectionIndex, isExpanded
                                     }, children: [t?.('common.next') || 'Next', jsxRuntimeExports.jsx("img", { src: img$6, alt: "", "aria-hidden": true, style: { width: '14px', height: '14px' } })] })] })] }) }))] }));
 };
 
-const RegistryViewLayout = ({ mode, section, gridId, editableSection, dataSourceRequestHandler, schemaData, onValueChange, changeRequestType, showChangeRequestLabel = true, crViewData, effectiveHideEditButton, isEditMode, onEdit, }) => {
+const RegistryViewLayout = ({ mode, section, gridId, editableSection, dataSourceRequestHandler, schemaData, onValueChange, changeRequestType, showChangeRequestLabel = true, effectiveHideEditButton, isEditMode, onEdit, }) => {
     const { t } = useWidgetContext();
     const sectionTitle = section['section-title'];
     return (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [sectionTitle && (jsxRuntimeExports.jsxs("div", { style: {
@@ -4067,13 +4276,15 @@ const RegistryViewLayout = ({ mode, section, gridId, editableSection, dataSource
                                 : 'var(--owt-color-error, #B91C1C)',
                             whiteSpace: 'nowrap',
                             boxShadow: changeRequestType === 'new' ? '0 2px 4px rgba(40, 167, 69, 0.3)' : 'none',
-                        }, children: changeRequestType === 'new' ? 'New' : 'Old' }))] })), jsxRuntimeExports.jsxs("div", { id: gridId, className: "section-panels", style: mode === 'RegistryView' && effectiveHideEditButton ? { paddingBottom: '30px' } : {}, children: [jsxRuntimeExports.jsx(PanelGrid, { panels: editableSection.panels, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, wrapInContainer: false }), mode === 'CRView' && crViewData && (jsxRuntimeExports.jsx(CRViewFooter, { createdBy: crViewData.createdBy, createdDate: crViewData.createdDate, approvedBy: crViewData.approvedBy, approvedDate: crViewData.approvedDate })), mode === 'RegistryView' && !effectiveHideEditButton && (jsxRuntimeExports.jsx("hr", { className: "w-full", style: {
+                        }, children: changeRequestType === 'new' ? 'New' : 'Old' }))] })), jsxRuntimeExports.jsxs("div", { id: gridId, className: "section-panels", style: mode === 'CRView' || (mode === 'RegistryView' && effectiveHideEditButton)
+                    ? { paddingBottom: '30px' }
+                    : {}, children: [jsxRuntimeExports.jsx(PanelGrid, { panels: editableSection.panels, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, wrapInContainer: false }), mode === 'RegistryView' && !effectiveHideEditButton && (jsxRuntimeExports.jsx("hr", { className: "w-full", style: {
                             height: '1px',
                             marginTop: !isEditMode ? '10px' : 0,
                             marginBottom: '14px',
                             border: 'none',
                             backgroundColor: 'var(--owt-color-border, #C4C4C4)',
-                        } })), mode === 'RegistryView' && !isEditMode && !effectiveHideEditButton && (jsxRuntimeExports.jsx("div", { className: "flex justify-center items-center", style: { marginBottom: '20px' }, children: jsxRuntimeExports.jsxs("button", { onClick: onEdit, className: "font-normal inline-flex items-center gap-2 bg-transparent border-0 p-0 cursor-pointer hover:opacity-80", style: {
+                        } })), mode === 'RegistryView' && !isEditMode && !effectiveHideEditButton && (jsxRuntimeExports.jsx("div", { className: "registry-edit-details flex justify-start items-center", style: { marginBottom: '20px' }, children: jsxRuntimeExports.jsxs("button", { onClick: onEdit, className: "font-normal inline-flex items-center gap-2 bg-transparent border-0 p-0 cursor-pointer hover:opacity-80", style: {
                                 fontFamily: 'Roboto, sans-serif',
                                 fontSize: '16px',
                                 color: 'var(--owt-color-text-muted, #727474)',
@@ -4085,13 +4296,11 @@ const SectionRenderer = ({ section, dataSourceRequestHandler: propDataSourceRequ
     const portalCSSVariables = useMemo(() => themeToCSSVariables(resolvedTheme), [resolvedTheme]);
     const { schemaData: contextSchemaData, dataSourceRequestHandler: contextDataSourceRequestHandler } = useWidgetContext();
     const dataSourceRequestHandler = propDataSourceRequestHandler || contextDataSourceRequestHandler;
-    const currentSchemaData = schemaData || contextSchemaData || {};
     const storeValues = useSelector((state) => state.widget?.values || {});
     const originalSectionId = section['section-id'];
     const sectionId = section['section-id'];
     const gridId = `section-panels-${sectionId}`;
     const sectionClassId = `section-${sectionId}`;
-    const crViewData = useCrViewData(mode, currentSchemaData, storeValues);
     const { columnSpan, hasTable: hasTableWidget, hasExplicitTableSpan } = useMemo(() => resolveSectionColumnSpan(section.panels, gridColumnSpan), [section.panels, gridColumnSpan]);
     const readonlyStyles = useMemo(() => buildReadonlyStyleSelectors(sectionClassId), [sectionClassId]);
     const supportingDocuments = section['section-supporting-documents'] || [];
@@ -4150,15 +4359,12 @@ const SectionRenderer = ({ section, dataSourceRequestHandler: propDataSourceRequ
                             border: '1px dashed var(--owt-color-primary-dark, #F07B1A)',
                         }
                         : {
-                            backgroundColor: changeRequestType === 'old'
-                                ? 'var(--owt-color-bg-alt, #F6F6F6)'
-                                : 'var(--owt-section-bg, #FFFFFF)',
-                            opacity: changeRequestType === 'old' ? 0.95 : 1,
+                            backgroundColor: 'var(--owt-section-bg, #FFFFFF)',
                         }),
                     ...(isEditMode && sectionHeight
                         ? { height: `${sectionHeight}px`, minHeight: `${sectionHeight}px` }
                         : { minHeight: 'auto', height: 'auto' }),
-                }, children: mode === 'IntakeForm' ? (jsxRuntimeExports.jsx(IntakeFormLayout, { section: section, sectionId: sectionId, gridId: gridId, sectionIndex: sectionIndex, isExpanded: isExpanded, isAccessible: isAccessible, isDraft: isDraft, intakeFormSectionStatus: intakeFormSectionStatus, editableSection: editableSection, supportingDocuments: supportingDocuments, hasSupportingDocuments: hasSupportingDocuments, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, onAccordionToggle: handleAccordionToggle, onPreviousSection: onPreviousSection, onSave: handleIntakeFormSave })) : (jsxRuntimeExports.jsx(RegistryViewLayout, { mode: mode, section: section, gridId: gridId, editableSection: editableSection, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, changeRequestType: changeRequestType, showChangeRequestLabel: showChangeRequestLabel, crViewData: crViewData, effectiveHideEditButton: effectiveHideEditButton, isEditMode: isEditMode, onEdit: handleEdit })) })] }));
+                }, children: mode === 'IntakeForm' ? (jsxRuntimeExports.jsx(IntakeFormLayout, { section: section, sectionId: sectionId, gridId: gridId, sectionIndex: sectionIndex, isExpanded: isExpanded, isAccessible: isAccessible, isDraft: isDraft, intakeFormSectionStatus: intakeFormSectionStatus, editableSection: editableSection, supportingDocuments: supportingDocuments, hasSupportingDocuments: hasSupportingDocuments, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, onAccordionToggle: handleAccordionToggle, onPreviousSection: onPreviousSection, onSave: handleIntakeFormSave })) : (jsxRuntimeExports.jsx(RegistryViewLayout, { mode: mode, section: section, gridId: gridId, editableSection: editableSection, dataSourceRequestHandler: dataSourceRequestHandler, schemaData: schemaData, onValueChange: onValueChange, changeRequestType: changeRequestType, showChangeRequestLabel: showChangeRequestLabel, effectiveHideEditButton: effectiveHideEditButton, isEditMode: isEditMode, onEdit: handleEdit })) })] }));
 };
 
 const SectionsContainer = ({ sections, dataSourceRequestHandler: propDataSourceRequestHandler, schemaData, onValueChange, className = '', onSectionSave, hideEditButton = false, mode = 'RegistryView', isDraft, onSectionDirtyChange, onFormReady, }) => {
@@ -7272,13 +7478,22 @@ const TableCellSelect = ({ config, value, onValueChange }) => {
     const { t } = useWidgetContext();
     const { dataSourceOptions, loading, } = useBaseWidget({ config });
     const isReadonly = config['widget-readonly'] || false;
-    return (jsxRuntimeExports.jsxs("div", { className: "table-cell-field w-full", children: [jsxRuntimeExports.jsxs("select", { value: value || '', onChange: (e) => onValueChange(e.target.value === '' ? undefined : e.target.value), disabled: isReadonly || loading, className: `w-full h-[28px] px-2 text-sm border focus:outline-none ${isReadonly || loading ? 'cursor-not-allowed' : ''} table-cell-input`, style: {
+    return (jsxRuntimeExports.jsxs("div", { className: "table-cell-field w-full", children: [jsxRuntimeExports.jsxs("select", { value: value === undefined || value === null ? '' : String(value), onChange: (e) => {
+                    const rawValue = e.target.value;
+                    if (rawValue === '') {
+                        onValueChange(undefined);
+                        return;
+                    }
+                    const selectedOption = dataSourceOptions.find((option) => String(option.value) === rawValue);
+                    onValueChange(selectedOption ? selectedOption.value : rawValue);
+                }, disabled: isReadonly || loading, className: `w-full h-[28px] px-2 text-sm border focus:outline-none ${isReadonly || loading ? 'cursor-not-allowed' : ''} table-cell-input`, style: {
                     borderRadius: '10px',
                     borderColor: 'var(--owt-widget-input-border, #C4C4C4)',
                     backgroundColor: isReadonly || loading ? 'var(--owt-color-bg-alt, #F6F6F6)' : 'var(--owt-color-bg, #FFFFFF)',
-                }, children: [jsxRuntimeExports.jsx("option", { value: "", children: t?.('common.select') || 'Select' }), dataSourceOptions.map((option) => (jsxRuntimeExports.jsx("option", { value: option.value, children: option.label }, option.value)))] }), jsxRuntimeExports.jsx("p", { className: "table-cell-field-error", "aria-hidden": "true", children: '\u00a0' })] }));
+                }, children: [jsxRuntimeExports.jsx("option", { value: "", children: t?.('common.select') || 'Select' }), dataSourceOptions.map((option) => (jsxRuntimeExports.jsx("option", { value: option.value, children: tSchema(t, option.label) }, option.value)))] }), jsxRuntimeExports.jsx("p", { className: "table-cell-field-error", "aria-hidden": "true", children: '\u00a0' })] }));
 };
 const SelectDisplayValue$1 = ({ config, value }) => {
+    const { t } = useWidgetContext();
     const { dataSourceOptions, loading } = useBaseWidget({ config });
     if (loading) {
         return jsxRuntimeExports.jsx("span", { children: "-" });
@@ -7287,7 +7502,9 @@ const SelectDisplayValue$1 = ({ config, value }) => {
         return jsxRuntimeExports.jsx("span", { children: "-" });
     }
     const selectedOption = dataSourceOptions.find((option) => option.value === value || String(option.value) === String(value));
-    return jsxRuntimeExports.jsx("span", { children: selectedOption ? selectedOption.label : String(value) });
+    return (jsxRuntimeExports.jsx("span", { children: selectedOption
+            ? tSchema(t, selectedOption.label)
+            : tSchema(t, String(value)) }));
 };
 const TableCellText = ({ config, value, onValueChange }) => {
     const isReadonly = config['widget-readonly'] || false;
@@ -7305,22 +7522,62 @@ const TableCellNumber = ({ config, value, onValueChange }) => {
     const placeholder = config['widget-data-placeholder'] || '';
     const formatConfig = config['widget-data-format'];
     const validationConfig = config['widget-data-validation'];
-    const displayValue = value !== null && value !== undefined ? String(value) : '';
+    const min = validationConfig?.min;
+    const max = validationConfig?.max;
+    const allowSigned = min !== undefined ? min < 0 : formatConfig?.allowSigned !== false;
+    const formatForKeys = { ...formatConfig, allowSigned };
+    const committedDisplay = value !== null && value !== undefined ? String(value) : '';
+    const [draft, setDraft] = useState(null);
+    const displayValue = draft !== null ? draft : committedDisplay;
+    const isWithinBounds = (numValue) => {
+        if (min !== undefined && numValue < min) {
+            return false;
+        }
+        if (max !== undefined && numValue > max) {
+            return false;
+        }
+        return true;
+    };
     const handleChange = (e) => {
         const inputValue = e.target.value;
         if (inputValue === '') {
+            setDraft(null);
             onValueChange('');
             return;
         }
+        if (inputValue === '-' && allowSigned) {
+            setDraft('-');
+            return;
+        }
         const numValue = parseFloat(inputValue);
-        if (!isNaN(numValue)) {
+        if (isNaN(numValue)) {
+            return;
+        }
+        if (!isWithinBounds(numValue)) {
+            if (min !== undefined && numValue < min && numValue >= 0) {
+                setDraft(inputValue);
+            }
+            return;
+        }
+        setDraft(null);
+        onValueChange(numValue);
+    };
+    const handleBlur = () => {
+        if (draft === null) {
+            return;
+        }
+        const numValue = parseFloat(draft);
+        setDraft(null);
+        if (!isNaN(numValue) && isWithinBounds(numValue)) {
             onValueChange(numValue);
         }
-        else {
-            onValueChange(inputValue);
+    };
+    const handleKeyDown = (e) => {
+        if (!isAllowedKey(e.key, formatForKeys, e.currentTarget.value, e)) {
+            e.preventDefault();
         }
     };
-    return (jsxRuntimeExports.jsxs("div", { className: "table-cell-field w-full", children: [jsxRuntimeExports.jsx("input", { type: "number", value: displayValue, onChange: handleChange, disabled: isReadonly, placeholder: placeholder, min: validationConfig?.min, max: validationConfig?.max, step: formatConfig?.decimalPlaces ? Math.pow(0.1, formatConfig.decimalPlaces) : undefined, className: `w-full h-[28px] px-2 text-sm border focus:outline-none text-right ${isReadonly ? 'cursor-not-allowed' : ''} table-cell-input`, style: {
+    return (jsxRuntimeExports.jsxs("div", { className: "table-cell-field w-full", children: [jsxRuntimeExports.jsx("input", { type: "number", value: displayValue, onChange: handleChange, onBlur: handleBlur, onKeyDown: handleKeyDown, disabled: isReadonly, placeholder: placeholder, min: min, max: max, step: formatConfig?.decimalPlaces ? Math.pow(0.1, formatConfig.decimalPlaces) : undefined, className: `w-full h-[28px] px-2 text-sm border focus:outline-none text-right ${isReadonly ? 'cursor-not-allowed' : ''} table-cell-input`, style: {
                     borderRadius: '10px',
                     borderColor: 'var(--owt-widget-input-border, #C4C4C4)',
                     backgroundColor: isReadonly ? 'var(--owt-color-bg-alt, #F6F6F6)' : 'var(--owt-color-bg, #FFFFFF)',
@@ -8058,13 +8315,16 @@ const getRowCellStyle = (editAction) => {
     return {};
 };
 const SelectDisplayValue = ({ config, value }) => {
+    const { t } = useWidgetContext();
     const { dataSourceOptions, loading } = useBaseWidget({ config });
     if (loading)
         return jsxRuntimeExports.jsx("span", { children: "-" });
     if (value === null || value === undefined || value === '')
         return jsxRuntimeExports.jsx("span", { children: "-" });
     const selectedOption = dataSourceOptions.find((option) => option.value === value || String(option.value) === String(value));
-    return jsxRuntimeExports.jsx("span", { children: selectedOption ? selectedOption.label : String(value) });
+    return (jsxRuntimeExports.jsx("span", { children: selectedOption
+            ? tSchema(t, selectedOption.label)
+            : tSchema(t, String(value)) }));
 };
 /** Isolated dialog field — avoids re-running data-source effects when sibling fields update. */
 const DialogTableField = memo(function DialogTableField({ col, cellWidgetId, dialogConditionValues, isReadonly, }) {
@@ -8604,7 +8864,7 @@ const ProfileWidget = ({ config }) => {
                                     if (placeholder) {
                                         placeholder.style.display = 'flex';
                                     }
-                                } })) : null, jsxRuntimeExports.jsx("div", { className: "profile-avatar-placeholder", style: { display: imageUrl ? 'none' : 'flex' }, children: jsxRuntimeExports.jsx("img", { src: img$h, alt: t?.('profile.profilePlaceholderAlt') ?? 'Profile Placeholder' }) })] }), jsxRuntimeExports.jsxs("div", { className: "profile-info", children: [displayName && (jsxRuntimeExports.jsx("div", { className: "profile-name", children: displayName })), idValue && (jsxRuntimeExports.jsxs("div", { className: "profile-id", children: [showIdLabel && (jsxRuntimeExports.jsx("span", { className: "profile-id-label", children: t?.('profile.idLabel') ?? 'ID :' })), jsxRuntimeExports.jsx("span", { className: "profile-id-value", children: idValue })] }))] })] })] }));
+                                } })) : null, jsxRuntimeExports.jsx("div", { className: "profile-avatar-placeholder", style: { display: imageUrl ? 'none' : 'flex' }, children: jsxRuntimeExports.jsx("img", { src: img$f, alt: t?.('profile.profilePlaceholderAlt') ?? 'Profile Placeholder' }) })] }), jsxRuntimeExports.jsxs("div", { className: "profile-info", children: [displayName && (jsxRuntimeExports.jsx("div", { className: "profile-name", children: displayName })), idValue && (jsxRuntimeExports.jsxs("div", { className: "profile-id", children: [showIdLabel && (jsxRuntimeExports.jsx("span", { className: "profile-id-label", children: t?.('profile.idLabel') ?? 'ID :' })), jsxRuntimeExports.jsx("span", { className: "profile-id-value", children: idValue })] }))] })] })] }));
 };
 
 const TextAreaWidget = ({ config }) => {
@@ -9236,7 +9496,7 @@ const HeaderSectionWidget = ({ config }) => {
                                                 .parentElement?.querySelector('.hdr-avatar-placeholder');
                                             if (placeholder)
                                                 placeholder.style.display = 'flex';
-                                        } })) : null, jsxRuntimeExports.jsx("div", { className: "hdr-avatar-placeholder", style: { display: displayImageUrl ? 'none' : 'flex' }, children: jsxRuntimeExports.jsx("img", { src: img$h, alt: "Profile Placeholder" }) }), !isReadonly && (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsxs("div", { className: "hdr-avatar-overlay", children: [jsxRuntimeExports.jsxs("button", { type: "button", className: "hdr-avatar-action", onClick: () => fileInputRef.current?.click(), children: [jsxRuntimeExports.jsxs("svg", { width: "13", height: "13", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }), jsxRuntimeExports.jsx("polyline", { points: "17 8 12 3 7 8" }), jsxRuntimeExports.jsx("line", { x1: "12", y1: "3", x2: "12", y2: "15" })] }), "Upload"] }), jsxRuntimeExports.jsxs("button", { type: "button", className: "hdr-avatar-action hdr-avatar-action--delete", onClick: handleImageDelete, children: [jsxRuntimeExports.jsxs("svg", { width: "13", height: "13", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("polyline", { points: "3 6 5 6 21 6" }), jsxRuntimeExports.jsx("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" })] }), "Delete"] })] }), jsxRuntimeExports.jsx("input", { ref: fileInputRef, type: "file", accept: "image/*", style: { display: 'none' }, onChange: handleImageUpload })] }))] }), jsxRuntimeExports.jsxs("div", { className: "hdr-info", children: [displayName && jsxRuntimeExports.jsx("div", { className: "hdr-name", children: displayName }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsxs("span", { className: "hdr-field-label", title: `${getLabel('functionalId')} :`, children: [getLabel('functionalId'), " :"] }), jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: functionalId || '-', children: functionalId || '-' })] }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsx("span", { className: "hdr-field-label", title: getLabel('status'), children: getLabel('status') }), isReadonly ? (statusLabel ? (jsxRuntimeExports.jsx("span", { className: "hdr-status-badge", style: { backgroundColor: statusColor }, title: statusLabel, children: statusLabel })) : (jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: "-", children: "-" }))) : (jsxRuntimeExports.jsxs("select", { className: "hdr-select", value: statusValue, onChange: (e) => updateFieldValue('status', e.target.value), children: [jsxRuntimeExports.jsx("option", { value: "", children: getLabel('select') }), statusOptions.map((opt) => (jsxRuntimeExports.jsx("option", { value: opt.value, children: opt.label }, opt.value)))] }))] }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsxs("span", { className: "hdr-field-label", title: `${getLabel('statusReason')} :`, children: [getLabel('statusReason'), " :"] }), isReadonly ? (jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: statusReason || '-', children: statusReason || '-' })) : (jsxRuntimeExports.jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 4 }, children: [jsxRuntimeExports.jsx("input", { type: "text", className: `hdr-input ${(!isReadonly && (showReasonRequired || isReasonMissing) && isReasonMissing) ? 'hdr-input--error' : ''}`, value: statusReason, placeholder: getLabel('enterReason'), required: isStatusChanged, "aria-required": isStatusChanged, "aria-invalid": !isReadonly && (showReasonRequired || isReasonMissing) && isReasonMissing, onBlur: () => {
+                                        } })) : null, jsxRuntimeExports.jsx("div", { className: "hdr-avatar-placeholder", style: { display: displayImageUrl ? 'none' : 'flex' }, children: jsxRuntimeExports.jsx("img", { src: img$f, alt: "Profile Placeholder" }) }), !isReadonly && (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsxs("div", { className: "hdr-avatar-overlay", children: [jsxRuntimeExports.jsxs("button", { type: "button", className: "hdr-avatar-action", onClick: () => fileInputRef.current?.click(), children: [jsxRuntimeExports.jsxs("svg", { width: "13", height: "13", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }), jsxRuntimeExports.jsx("polyline", { points: "17 8 12 3 7 8" }), jsxRuntimeExports.jsx("line", { x1: "12", y1: "3", x2: "12", y2: "15" })] }), "Upload"] }), jsxRuntimeExports.jsxs("button", { type: "button", className: "hdr-avatar-action hdr-avatar-action--delete", onClick: handleImageDelete, children: [jsxRuntimeExports.jsxs("svg", { width: "13", height: "13", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("polyline", { points: "3 6 5 6 21 6" }), jsxRuntimeExports.jsx("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" })] }), "Delete"] })] }), jsxRuntimeExports.jsx("input", { ref: fileInputRef, type: "file", accept: "image/*", style: { display: 'none' }, onChange: handleImageUpload })] }))] }), jsxRuntimeExports.jsxs("div", { className: "hdr-info", children: [displayName && jsxRuntimeExports.jsx("div", { className: "hdr-name", children: displayName }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsxs("span", { className: "hdr-field-label", title: `${getLabel('functionalId')} :`, children: [getLabel('functionalId'), " :"] }), jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: functionalId || '-', children: functionalId || '-' })] }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsx("span", { className: "hdr-field-label", title: getLabel('status'), children: getLabel('status') }), isReadonly ? (statusLabel ? (jsxRuntimeExports.jsx("span", { className: "hdr-status-badge", style: { backgroundColor: statusColor }, title: statusLabel, children: statusLabel })) : (jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: "-", children: "-" }))) : (jsxRuntimeExports.jsxs("select", { className: "hdr-select", value: statusValue, onChange: (e) => updateFieldValue('status', e.target.value), children: [jsxRuntimeExports.jsx("option", { value: "", children: getLabel('select') }), statusOptions.map((opt) => (jsxRuntimeExports.jsx("option", { value: opt.value, children: opt.label }, opt.value)))] }))] }), jsxRuntimeExports.jsxs("div", { className: "hdr-field-row", children: [jsxRuntimeExports.jsxs("span", { className: "hdr-field-label", title: `${getLabel('statusReason')} :`, children: [getLabel('statusReason'), " :"] }), isReadonly ? (jsxRuntimeExports.jsx("span", { className: "hdr-field-value", title: statusReason || '-', children: statusReason || '-' })) : (jsxRuntimeExports.jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 4 }, children: [jsxRuntimeExports.jsx("input", { type: "text", className: `hdr-input ${(!isReadonly && (showReasonRequired || isReasonMissing) && isReasonMissing) ? 'hdr-input--error' : ''}`, value: statusReason, placeholder: getLabel('enterReason'), required: isStatusChanged, "aria-required": isStatusChanged, "aria-invalid": !isReadonly && (showReasonRequired || isReasonMissing) && isReasonMissing, onBlur: () => {
                                                             if (isReasonMissing)
                                                                 setShowReasonRequired(true);
                                                         }, onChange: (e) => {
@@ -10247,7 +10507,7 @@ const RegisterLookupWidget = ({ config }) => {
                                     onChange(null);
                                     setAppliedRecord(null);
                                     setPendingRow(null);
-                                }, className: "text-sm underline text-red-500 p-0 border-0 bg-transparent cursor-pointer focus:outline-none focus:ring-2 focus:ring-red-500 focus:ring-offset-1 rounded", children: t?.('common.remove', { defaultValue: 'Remove' }) })] })), !isReadonly && touched && error.length > 0 && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mt-1", children: error[0] })] })) : !isReadonly ? (jsxRuntimeExports.jsxs("div", { className: "w-full min-w-0", children: [jsxRuntimeExports.jsxs("button", { type: "button", disabled: !isEnabled, onClick: openLookup, title: actionLabel, className: `flex items-center gap-2 w-full sm:w-[180px] max-w-full px-3 h-[30px] text-sm border rounded-[10px] shadow-sm transition-colors ${hasError ? 'border-red-500 text-gray-700' : 'border-gray-300 text-gray-700'} ${!isEnabled ? 'bg-gray-100 text-gray-400 cursor-not-allowed' : 'bg-white cursor-pointer'}`, children: [jsxRuntimeExports.jsx("img", { src: img$g, alt: "", className: "w-4 h-4 opacity-50 flex-shrink-0" }), jsxRuntimeExports.jsx("span", { className: "min-w-0 truncate", children: actionLabel }), isRequired && jsxRuntimeExports.jsx("span", { className: "shrink-0 text-red-500", children: "*" })] }), touched && error.length > 0 && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mt-1", children: error[0] })] })) : null, !isReadonly && isOpen && (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx("div", { className: "fixed inset-0 z-50", style: { backgroundColor: 'rgba(0,0,0,0.5)' }, onClick: () => { setIsOpen(false); onBlur(); } }), jsxRuntimeExports.jsxs("div", { className: "flex flex-col overflow-hidden", style: {
+                                }, className: "text-sm underline text-red-500 p-0 border-0 bg-transparent cursor-pointer focus:outline-none focus:ring-2 focus:ring-red-500 focus:ring-offset-1 rounded", children: t?.('common.remove', { defaultValue: 'Remove' }) })] })), !isReadonly && touched && error.length > 0 && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mt-1", children: error[0] })] })) : !isReadonly ? (jsxRuntimeExports.jsxs("div", { className: "w-full min-w-0", children: [jsxRuntimeExports.jsxs("button", { type: "button", disabled: !isEnabled, onClick: openLookup, title: actionLabel, className: `flex items-center gap-2 w-full sm:w-[180px] max-w-full px-3 h-[30px] text-sm border rounded-[10px] shadow-sm transition-colors ${hasError ? 'border-red-500 text-gray-700' : 'border-gray-300 text-gray-700'} ${!isEnabled ? 'bg-gray-100 text-gray-400 cursor-not-allowed' : 'bg-white cursor-pointer'}`, children: [jsxRuntimeExports.jsx("img", { src: img$e, alt: "", className: "w-4 h-4 opacity-50 flex-shrink-0" }), jsxRuntimeExports.jsx("span", { className: "min-w-0 truncate", children: actionLabel }), isRequired && jsxRuntimeExports.jsx("span", { className: "shrink-0 text-red-500", children: "*" })] }), touched && error.length > 0 && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mt-1", children: error[0] })] })) : null, !isReadonly && isOpen && (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx("div", { className: "fixed inset-0 z-50", style: { backgroundColor: 'rgba(0,0,0,0.5)' }, onClick: () => { setIsOpen(false); onBlur(); } }), jsxRuntimeExports.jsxs("div", { className: "flex flex-col overflow-hidden", style: {
                             position: 'fixed',
                             top: modalPos.y,
                             left: modalPos.x,
@@ -10266,12 +10526,12 @@ const RegisterLookupWidget = ({ config }) => {
                                     e.preventDefault();
                                     isDragging.current = true;
                                     dragOrigin.current = { mouseX: e.clientX, mouseY: e.clientY, posX: modalPos.x, posY: modalPos.y };
-                                }, className: "flex items-center justify-between px-5 py-4 flex-shrink-0 select-none border-b border-gray-200 cursor-grab", children: [jsxRuntimeExports.jsx("h3", { className: "text-lg font-semibold text-gray-900", children: t?.('common.selectTitle', { label, defaultValue: `Select ${label}` }) }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => { setIsOpen(false); onBlur(); }, onMouseDown: (e) => e.stopPropagation(), className: "p-0 border-0 bg-transparent cursor-pointer", "aria-label": t?.('common.close', { defaultValue: 'Close' }), children: jsxRuntimeExports.jsx("img", { src: img$f, alt: "", className: "w-5 h-5 opacity-60" }) })] }), jsxRuntimeExports.jsx("div", { className: "px-5 py-3 flex-shrink-0 border-b border-gray-200", children: jsxRuntimeExports.jsxs("div", { className: "flex items-center gap-2 px-3 h-[30px] border border-gray-300 rounded-[10px] bg-white", children: [jsxRuntimeExports.jsx("input", { ref: searchInputRef, type: "text", value: searchText, onChange: (e) => setSearchText(e.target.value), onKeyDown: (e) => {
+                                }, className: "flex items-center justify-between px-5 py-4 flex-shrink-0 select-none border-b border-gray-200 cursor-grab", children: [jsxRuntimeExports.jsx("h3", { className: "text-lg font-semibold text-gray-900", children: t?.('common.selectTitle', { label, defaultValue: `Select ${label}` }) }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => { setIsOpen(false); onBlur(); }, onMouseDown: (e) => e.stopPropagation(), className: "p-0 border-0 bg-transparent cursor-pointer", "aria-label": t?.('common.close', { defaultValue: 'Close' }), children: jsxRuntimeExports.jsx("img", { src: img$d, alt: "", className: "w-5 h-5 opacity-60" }) })] }), jsxRuntimeExports.jsx("div", { className: "px-5 py-3 flex-shrink-0 border-b border-gray-200", children: jsxRuntimeExports.jsxs("div", { className: "flex items-center gap-2 px-3 h-[30px] border border-gray-300 rounded-[10px] bg-white", children: [jsxRuntimeExports.jsx("input", { ref: searchInputRef, type: "text", value: searchText, onChange: (e) => setSearchText(e.target.value), onKeyDown: (e) => {
                                                 if (e.key === 'Enter') {
                                                     e.preventDefault();
                                                     runSearch(searchText, 1);
                                                 }
-                                            }, placeholder: searchPlaceholder, className: "flex-1 outline-none text-sm text-gray-900 bg-transparent" }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => runSearch(searchText, 1), "aria-label": t?.('common.search', { defaultValue: 'Search' }), className: "flex-shrink-0 p-0 border-0 bg-transparent cursor-pointer", children: jsxRuntimeExports.jsx("img", { src: img$g, alt: "", className: "w-4 h-4 opacity-40" }) })] }) }), jsxRuntimeExports.jsx("div", { className: "overflow-auto flex-1", children: searchResults.length === 0 ? (jsxRuntimeExports.jsx("p", { className: "text-center text-sm text-gray-500 py-10", children: searchText
+                                            }, placeholder: searchPlaceholder, className: "flex-1 outline-none text-sm text-gray-900 bg-transparent" }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => runSearch(searchText, 1), "aria-label": t?.('common.search', { defaultValue: 'Search' }), className: "flex-shrink-0 p-0 border-0 bg-transparent cursor-pointer", children: jsxRuntimeExports.jsx("img", { src: img$e, alt: "", className: "w-4 h-4 opacity-40" }) })] }) }), jsxRuntimeExports.jsx("div", { className: "overflow-auto flex-1", children: searchResults.length === 0 ? (jsxRuntimeExports.jsx("p", { className: "text-center text-sm text-gray-500 py-10", children: searchText
                                         ? t?.('common.noResults', { defaultValue: 'No results found' })
                                         : t?.('common.searchHint', { defaultValue: 'Type and press Enter or click search' }) })) : (jsxRuntimeExports.jsx(ResultsTable, { rows: searchResults, selectedRowKey: pendingRow?.internal_record_id ?? null, onRowClick: setPendingRow, onRowDoubleClick: applySelection })) }), jsxRuntimeExports.jsxs("div", { className: `flex-shrink-0 flex flex-wrap items-center gap-3 px-5 py-3 border-t border-gray-200 ${totalCount !== null ? 'justify-between' : 'justify-end'}`, children: [totalCount !== null && (jsxRuntimeExports.jsx(PaginationFooter, { embedded: true, currentPage: currentPage, totalPages: totalPages, totalCount: totalCount, pageSize: pageSize, onPageChange: (page) => runSearch(searchText, page), onPrev: () => currentPage > 1 && runSearch(searchText, currentPage - 1), onNext: () => currentPage < totalPages && runSearch(searchText, currentPage + 1) })), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => pendingRow && applySelection(pendingRow), disabled: !pendingRow, className: "px-4 h-9 text-sm font-medium rounded-[10px] text-white disabled:opacity-40 disabled:cursor-not-allowed flex-shrink-0", style: { backgroundColor: 'var(--owt-color-info, #2563eb)' }, children: selectRecordLabel })] })] })] }))] }));
 };
@@ -10599,12 +10859,12 @@ const ParentLookupWidget = ({ config, value: valueProp, error: errorProp, touche
                                 }, className: "flex items-center justify-between px-5 py-4 flex-shrink-0 select-none border-b border-gray-200 cursor-grab", children: [jsxRuntimeExports.jsx("h3", { className: "text-lg font-semibold text-gray-900", children: t?.('common.selectTitle', { label, defaultValue: `Select ${label}` }) }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => {
                                             setIsOpen(false);
                                             onBlur();
-                                        }, onMouseDown: (e) => e.stopPropagation(), className: "p-0 border-0 bg-transparent cursor-pointer", "aria-label": t?.('common.close', { defaultValue: 'Close' }), children: jsxRuntimeExports.jsx("img", { src: img$f, alt: "", className: "w-5 h-5 opacity-60" }) })] }), jsxRuntimeExports.jsx("div", { className: "px-5 py-3 flex-shrink-0 border-b border-gray-200", children: jsxRuntimeExports.jsxs("div", { className: "flex items-center gap-2 px-3 h-[30px] border border-gray-300 rounded-[10px] bg-white", children: [jsxRuntimeExports.jsx("input", { ref: searchInputRef, type: "text", value: searchText, onChange: (e) => setSearchText(e.target.value), onKeyDown: (e) => {
+                                        }, onMouseDown: (e) => e.stopPropagation(), className: "p-0 border-0 bg-transparent cursor-pointer", "aria-label": t?.('common.close', { defaultValue: 'Close' }), children: jsxRuntimeExports.jsx("img", { src: img$d, alt: "", className: "w-5 h-5 opacity-60" }) })] }), jsxRuntimeExports.jsx("div", { className: "px-5 py-3 flex-shrink-0 border-b border-gray-200", children: jsxRuntimeExports.jsxs("div", { className: "flex items-center gap-2 px-3 h-[30px] border border-gray-300 rounded-[10px] bg-white", children: [jsxRuntimeExports.jsx("input", { ref: searchInputRef, type: "text", value: searchText, onChange: (e) => setSearchText(e.target.value), onKeyDown: (e) => {
                                                 if (e.key === 'Enter') {
                                                     e.preventDefault();
                                                     runSearch(searchText, 1);
                                                 }
-                                            }, placeholder: searchPlaceholder, className: "flex-1 outline-none text-sm text-gray-900 bg-transparent" }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => runSearch(searchText, 1), "aria-label": t?.('common.search', { defaultValue: 'Search' }), className: "flex-shrink-0 p-0 border-0 bg-transparent cursor-pointer", children: jsxRuntimeExports.jsx("img", { src: img$g, alt: "", className: "w-4 h-4 opacity-40" }) })] }) }), jsxRuntimeExports.jsx("div", { className: "overflow-auto flex-1", children: searchResults.length === 0 ? (jsxRuntimeExports.jsx("p", { className: "text-center text-sm text-gray-500 py-10", children: searchText
+                                            }, placeholder: searchPlaceholder, className: "flex-1 outline-none text-sm text-gray-900 bg-transparent" }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => runSearch(searchText, 1), "aria-label": t?.('common.search', { defaultValue: 'Search' }), className: "flex-shrink-0 p-0 border-0 bg-transparent cursor-pointer", children: jsxRuntimeExports.jsx("img", { src: img$e, alt: "", className: "w-4 h-4 opacity-40" }) })] }) }), jsxRuntimeExports.jsx("div", { className: "overflow-auto flex-1", children: searchResults.length === 0 ? (jsxRuntimeExports.jsx("p", { className: "text-center text-sm text-gray-500 py-10", children: searchText
                                         ? t?.('common.noResults', { defaultValue: 'No results found' })
                                         : t?.('common.searchHint', {
                                             defaultValue: 'Type and press Enter or click search',
@@ -11174,6 +11434,13 @@ function getDeepestSelectedValue(orderedLevels, selectedValues) {
     }
     return deepest;
 }
+/** True when every hierarchy level has a selected value. */
+function isGeoHierarchyComplete(orderedLevels, selectedValues) {
+    if (orderedLevels.length === 0) {
+        return false;
+    }
+    return orderedLevels.every((level) => Boolean(selectedValues[level.level_id]));
+}
 /** Build geo_code_hierarchy_json document from current selections (for save payload). */
 function buildHierarchyJson(orderedLevels, selectedValues, options, resolvedLabels = {}) {
     const hierarchy = [];
@@ -11286,29 +11553,36 @@ function useGeoHierarchy({ config }) {
     const hierarchyJsonPath = useMemo(() => resolveHierarchyPath(config), [config]);
     const dataPath = useMemo(() => resolveDataPath(config), [config]);
     /**
-     * Approved hierarchy for hydrate/display: schema first, then store.
-     * Edits persist draft hierarchy into store values for save; schema keeps approved.
+     * Read mode: schemaData is source of truth (including empty).
+     * Edit mode: store/draft values; schema only seeds when store is empty.
      */
     const baseHierarchyJson = useMemo(() => {
         if (!hierarchyJsonPath) {
             return null;
         }
         const fromSchema = readPathValue(schemaData, hierarchyJsonPath);
-        if (fromSchema !== undefined && fromSchema !== null) {
-            return fromSchema;
+        if (isReadonly) {
+            return fromSchema ?? null;
+        }
+        const fromStore = getValueByPath(values, hierarchyJsonPath);
+        if (fromStore !== undefined && fromStore !== null) {
+            return fromStore;
         }
-        return getValueByPath(values, hierarchyJsonPath);
-    }, [hierarchyJsonPath, schemaData, values]);
+        return fromSchema ?? null;
+    }, [hierarchyJsonPath, schemaData, values, isReadonly]);
     const baseStoredValue = useMemo(() => {
         if (!dataPath) {
             return base.value;
         }
         const fromSchema = readPathValue(schemaData, dataPath);
-        if (fromSchema !== undefined && fromSchema !== null && String(fromSchema).trim() !== '') {
-            return fromSchema;
+        if (isReadonly) {
+            return fromSchema ?? '';
         }
-        return base.value;
-    }, [base.value, dataPath, schemaData]);
+        if (base.value !== undefined && base.value !== null && String(base.value).trim() !== '') {
+            return base.value;
+        }
+        return fromSchema ?? base.value;
+    }, [base.value, dataPath, schemaData, isReadonly]);
     const [levels, setLevels] = useState([]);
     const [selectedValues, setSelectedValues] = useState({});
     const [options, setOptions] = useState({});
@@ -11394,11 +11668,13 @@ function useGeoHierarchy({ config }) {
             return;
         }
         const deepest = getDeepestSelectedValue(orderedLevels, nextSelectedValues);
-        selfPersistedValueRef.current = deepest ? String(deepest) : '';
+        const complete = isGeoHierarchyComplete(orderedLevels, nextSelectedValues);
+        // When required, only persist the leaf once every level is filled so submit validation fails for partial chains.
+        const nextValue = base.isRequired && !complete ? null : (deepest ?? null);
+        selfPersistedValueRef.current = nextValue ? String(nextValue) : '';
         const hierarchyDocument = buildHierarchyJson(orderedLevels, nextSelectedValues, nextOptions, nextResolvedLabels);
         const hierarchyPayload = formatHierarchyForPersist(hierarchyDocument, baseHierarchyRef.current);
         const rawDataPath = config['widget-data-path'];
-        const nextValue = deepest ?? null;
         if (rawDataPath && typeof rawDataPath === 'object') {
             const payload = { value: nextValue };
             if ('hierarchy' in rawDataPath) {
@@ -11468,6 +11744,34 @@ function useGeoHierarchy({ config }) {
             hydratingRef.current = false;
         }
     }, [loadOptionsAlongChain, resolveStoredChain]);
+    const hydrateFromHierarchyOnly = useCallback(async (orderedLevels) => {
+        const hierarchy = parseHierarchyJson(baseHierarchyRef.current);
+        if (hierarchy.length === 0) {
+            return false;
+        }
+        const chain = mapHierarchyToChain(orderedLevels, hierarchy);
+        if (chain.length === 0) {
+            return false;
+        }
+        hydratingRef.current = true;
+        try {
+            const nextSelectedValues = mapChainToSelections(orderedLevels, chain);
+            const labelMap = {};
+            chain.forEach((entry) => {
+                if (entry.level_value_id && entry.level_value_mnemonic) {
+                    labelMap[entry.level_value_id] = formatLevelLabel(entry.level_value_mnemonic);
+                }
+            });
+            const nextOptions = await loadOptionsAlongChain(orderedLevels, chain);
+            setSelectedValues(nextSelectedValues);
+            setOptions(nextOptions);
+            setResolvedLabels(labelMap);
+            return true;
+        }
+        finally {
+            hydratingRef.current = false;
+        }
+    }, [loadOptionsAlongChain]);
     const initialize = useCallback(async () => {
         if (!geoDataSource || !dataSourceRequestHandler || initializingRef.current) {
             if (!geoDataSource || !dataSourceRequestHandler) {
@@ -11489,6 +11793,10 @@ function useGeoHierarchy({ config }) {
                     return;
                 }
             }
+            // Draft/partial selections may have hierarchy without a leaf value when required.
+            if (await hydrateFromHierarchyOnly(orderedLevels)) {
+                return;
+            }
             setSelectedValues({});
             setOptions({});
             setResolvedLabels({});
@@ -11508,6 +11816,7 @@ function useGeoHierarchy({ config }) {
         dataSourceRequestHandler,
         fetchLevels,
         geoDataSource,
+        hydrateFromHierarchyOnly,
         hydrateFromStoredValue,
         loadOptionsForLevel,
     ]);
@@ -11612,7 +11921,7 @@ function resolveDisplayValue(levelId, selectedValues, options, resolvedLabels, l
     }
     return loading ? '-' : selected;
 }
-function renderLevelRows({ columnLevels, levels, isReadonly, selectedValues, options, resolvedLabels, loadingLevels, loadingLevelId, isEnabled, isRequired, showValidationError, t, onBlur, handleLevelChange, isLevelEnabled, formatLevelLabel, }) {
+function renderLevelRows({ columnLevels, levels, isReadonly, selectedValues, options, resolvedLabels, loadingLevels, loadingLevelId, isEnabled, isRequired, touched, hasError, t, onBlur, handleLevelChange, isLevelEnabled, formatLevelLabel, }) {
     return columnLevels.map((level) => {
         const levelIndex = levels.findIndex((item) => item.level_id === level.level_id);
         const levelLabel = formatLevelLabel(level.level_mnemonic);
@@ -11624,10 +11933,12 @@ function renderLevelRows({ columnLevels, levels, isReadonly, selectedValues, opt
         const isLoading = loadingLevelId === level.level_id;
         const levelEnabled = isLevelEnabled(levelIndex);
         const disabled = !isEnabled || loadingLevels || isLoading || !levelEnabled;
-        return (jsxRuntimeExports.jsx("div", { className: "mb-[10px]", children: jsxRuntimeExports.jsxs("div", { className: "flex flex-col sm:flex-row sm:items-start", children: [jsxRuntimeExports.jsx(WidgetFieldLabel, { className: "text-base font-medium text-gray-700 md:min-w-[120px] sm:pr-4 sm:pt-1 mb-1 sm:mb-0", label: levelLabel, required: isRequired && levelIndex === 0 }), jsxRuntimeExports.jsx("div", { className: "flex-1 min-w-0", children: jsxRuntimeExports.jsxs("select", { value: selectedValues[level.level_id] || '', onChange: (event) => {
+        const levelHasValue = Boolean(selectedValues[level.level_id]);
+        const showLevelError = (isRequired && !levelHasValue) || (touched && hasError && !levelHasValue);
+        return (jsxRuntimeExports.jsx("div", { className: "mb-[10px]", children: jsxRuntimeExports.jsxs("div", { className: "flex flex-col sm:flex-row sm:items-start", children: [jsxRuntimeExports.jsx(WidgetFieldLabel, { className: "text-base font-medium text-gray-700 md:min-w-[120px] sm:pr-4 sm:pt-1 mb-1 sm:mb-0", label: levelLabel, required: isRequired }), jsxRuntimeExports.jsx("div", { className: "flex-1 min-w-0", children: jsxRuntimeExports.jsxs("select", { value: selectedValues[level.level_id] || '', onChange: (event) => {
                                 const nextValue = event.target.value;
                                 void handleLevelChange(levelIndex, nextValue === '' ? undefined : nextValue);
-                            }, onBlur: onBlur, disabled: disabled, className: `w-full sm:w-[180px] max-w-full h-[30px] px-3 border shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 ${showValidationError
+                            }, onBlur: onBlur, disabled: disabled, className: `w-full sm:w-[180px] max-w-full h-[30px] px-3 border shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 ${showLevelError
                                 ? 'border-red-500 focus:ring-red-500 focus:border-red-500'
                                 : 'border-gray-300'} ${disabled ? 'bg-gray-100 cursor-not-allowed' : 'bg-white'}`, style: { borderRadius: '10px' }, children: [jsxRuntimeExports.jsx("option", { value: "", children: t?.('common.select') }), levelOptions.map((option) => (jsxRuntimeExports.jsx("option", { value: option.value, children: tSchema(t, option.label) }, option.value)))] }) })] }) }, level.level_id));
     });
@@ -11635,9 +11946,9 @@ function renderLevelRows({ columnLevels, levels, isReadonly, selectedValues, opt
 const GeoHierarchyWidget = ({ config }) => {
     const { isEnabled, isRequired, error, touched, onBlur, config: widgetConfig, levels, selectedValues, options, resolvedLabels, visibleColumns, loadingLevels, loadingLevelId, geoError, handleLevelChange, isLevelEnabled, formatLevelLabel, } = useGeoHierarchy({ config });
     const { t } = useWidgetContext();
-    const showValidationError = Boolean((touched && error.length > 0) ||
-        (widgetConfig['widget-required'] &&
-            !Object.values(selectedValues).some((value) => value)));
+    const isComplete = levels.length > 0 &&
+        levels.every((level) => Boolean(selectedValues[level.level_id]));
+    const hasError = error.length > 0 || (isRequired && levels.length > 0 && !isComplete);
     const isReadonly = Boolean(widgetConfig['widget-readonly']);
     const rowProps = {
         levels,
@@ -11649,7 +11960,8 @@ const GeoHierarchyWidget = ({ config }) => {
         loadingLevelId,
         isEnabled,
         isRequired,
-        showValidationError,
+        touched,
+        hasError,
         t,
         onBlur,
         handleLevelChange,
@@ -11678,7 +11990,7 @@ const GeoHierarchyWidget = ({ config }) => {
                                 : 'var(--owt-color-primary, #F5BB1A)',
                         } })), renderLevelRows({ ...rowProps, columnLevels: column.levels })] }, `geo-column-${column.index}`));
         }) }));
-    return (jsxRuntimeExports.jsxs("div", { className: isReadonly ? 'GeoHierarchyDisplayWidget' : 'GeoHierarchyWidget', children: [content, loadingLevels && levels.length === 0 && (jsxRuntimeExports.jsx("p", { className: "text-sm text-gray-500 mb-[10px]", children: t?.('common.loadingOptions') })), geoError && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mb-[10px]", children: geoError }), !isReadonly && touched && error.length > 0 && (jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mb-[10px]", children: error[0] }))] }));
+    return (jsxRuntimeExports.jsxs("div", { className: isReadonly ? 'GeoHierarchyDisplayWidget' : 'GeoHierarchyWidget', children: [content, loadingLevels && levels.length === 0 && (jsxRuntimeExports.jsx("p", { className: "text-sm text-gray-500 mb-[10px]", children: t?.('common.loading') })), geoError && jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mb-[10px]", children: geoError }), !isReadonly && touched && hasError && (jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mb-[10px]", children: error[0] || 'This field is required' }))] }));
 };
 
 const distributeDocsToColumns = (docs, totalDocs) => {
@@ -11700,18 +12012,14 @@ const getFileName = (file) => file instanceof File ? file.name : file.split('/')
 const iconButtonClass = 'inline-flex items-center justify-center shrink-0 p-0 border-0 bg-transparent focus:outline-none';
 const docControlClass = 'w-full h-9 min-w-0 flex items-center rounded-lg px-2.5 box-border';
 const DocsWidget = ({ config }) => {
-    const { isEnabled, onChange, onBlur, config: widgetConfig, } = useBaseWidget({ config });
+    const { value, error, touched, isEnabled, onChange, onBlur, config: widgetConfig, } = useBaseWidget({ config });
     const { t } = useWidgetContext();
     const documents = widgetConfig['documents'] || [];
     const totalDocs = widgetConfig['widget-total-docs'] || documents.length;
     const docColumns = distributeDocsToColumns(documents, totalDocs);
     const isReadonly = Boolean(widgetConfig['widget-readonly']);
-    const widgetId = widgetConfig['widget-id'];
-    const dataPath = widgetConfig['widget-data-path'];
-    const allValues = useSelector((state) => state.widget.values);
-    const rawValue = typeof dataPath === 'string' ? getValueByPath(allValues, dataPath) : allValues[widgetId];
-    const currentValue = rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue)
-        ? rawValue
+    const currentValue = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
         : {};
     const fileInputRefs = useRef({});
     const handleFileChange = async (docKey, e) => {
@@ -11733,7 +12041,6 @@ const DocsWidget = ({ config }) => {
                 [`${docKey}_source_filename`]: file.name,
             };
             onChange(updated);
-            onBlur();
         }
         catch (err) {
             console.error('Error serializing file:', err);
@@ -11787,15 +12094,19 @@ const DocsWidget = ({ config }) => {
         const file = getDocValue(docKey);
         const hasFile = !!file;
         const displayFileName = getSourceFilename(docKey, file);
+        const isEmptyRequired = isRequired && !hasFile;
+        const showValidationError = touched && error.length > 0 && isEmptyRequired;
         if (isReadonly) {
             return (jsxRuntimeExports.jsxs("div", { className: "mb-[10px] FileDisplayWidget flex flex-row items-start w-full", children: [jsxRuntimeExports.jsxs("div", { className: "w-1/2 min-w-0 pr-2 text-base text-gray-600 font-medium truncate", style: { fontFamily: 'Roboto, sans-serif' }, title: tSchema(t, label), children: [tSchema(t, label), ":"] }), jsxRuntimeExports.jsx("div", { className: "w-1/2 min-w-0 flex items-center min-h-[1.5rem]", children: hasFile ? (jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx("span", { className: "w-10/12 min-w-0 truncate text-base text-gray-900 font-medium", title: displayFileName, children: displayFileName }), jsxRuntimeExports.jsx("button", { type: "button", onClick: (e) => handlePreview(file, e), className: `w-2/12 ${iconButtonClass}`, title: displayFileName, children: jsxRuntimeExports.jsx("img", { src: img$1, alt: t?.('common.view') ?? 'View', className: "h-4 w-4" }) })] })) : (jsxRuntimeExports.jsx("span", { className: "text-base text-gray-900 font-medium", children: "-" })) })] }, docKey));
         }
-        return (jsxRuntimeExports.jsx("div", { className: "mb-[10px]", children: jsxRuntimeExports.jsxs("div", { className: "flex flex-row items-center w-full", children: [jsxRuntimeExports.jsx(WidgetFieldLabel, { className: "w-1/2 min-w-0 pr-2 text-base font-medium text-gray-700", label: tSchema(t, label), required: isRequired }), jsxRuntimeExports.jsxs("div", { className: "w-1/2 min-w-0 flex items-center min-h-[1.5rem]", children: [!hasFile && (jsxRuntimeExports.jsxs("label", { className: `${docControlClass} cursor-pointer justify-center gap-2 border border-dashed ${!isEnabled ? 'opacity-50 cursor-not-allowed' : ''}`, style: {
-                                    borderColor: 'var(--owt-color-primary-dark, #F07B1A)',
+        return (jsxRuntimeExports.jsx("div", { className: "mb-[10px]", children: jsxRuntimeExports.jsxs("div", { className: "flex flex-row items-start w-full", children: [jsxRuntimeExports.jsx(WidgetFieldLabel, { className: "w-1/2 min-w-0 pr-2 text-base font-medium text-gray-700", label: tSchema(t, label), required: isRequired }), jsxRuntimeExports.jsxs("div", { className: "w-1/2 min-w-0 flex flex-col justify-center min-h-[1.5rem]", children: [!hasFile && (jsxRuntimeExports.jsxs("label", { className: `${docControlClass} cursor-pointer justify-center gap-2 border border-dashed ${!isEnabled ? 'opacity-50 cursor-not-allowed' : ''}`, style: {
+                                    borderColor: isEmptyRequired
+                                        ? 'var(--owt-widget-error-color, #B91C1C)'
+                                        : 'var(--owt-color-primary-dark, #F07B1A)',
                                     backgroundColor: 'var(--owt-color-background, #FFFFFF)',
-                                }, children: [jsxRuntimeExports.jsx("img", { src: img$d, alt: "", className: "h-4 w-4 shrink-0" }), jsxRuntimeExports.jsx("span", { className: "text-sm font-medium text-gray-900", children: t?.('common.upload') ?? 'Upload' }), jsxRuntimeExports.jsx("input", { type: "file", accept: accept, onChange: (e) => void handleFileChange(docKey, e), onBlur: onBlur, disabled: !isEnabled, className: "hidden", ref: (el) => {
+                                }, children: [jsxRuntimeExports.jsx("img", { src: img$b, alt: "", className: "h-4 w-4 shrink-0" }), jsxRuntimeExports.jsx("span", { className: "text-sm font-medium text-gray-900", children: t?.('common.upload') ?? 'Upload' }), jsxRuntimeExports.jsx("input", { type: "file", accept: accept, onChange: (e) => void handleFileChange(docKey, e), onBlur: onBlur, disabled: !isEnabled, className: "hidden", ref: (el) => {
                                             fileInputRefs.current[docKey] = el;
-                                        } })] })), hasFile && (jsxRuntimeExports.jsxs("div", { className: `${docControlClass} gap-2 border border-gray-200 bg-white`, title: displayFileName, children: [jsxRuntimeExports.jsxs("button", { type: "button", onClick: (e) => handlePreview(file, e), className: `${iconButtonClass} min-w-0 flex-1 gap-2 justify-start`, title: displayFileName, children: [jsxRuntimeExports.jsx("img", { src: img$1, alt: "", className: "h-4 w-4 shrink-0" }), jsxRuntimeExports.jsx("span", { className: "min-w-0 truncate text-sm font-medium text-gray-900", children: displayFileName })] }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => handleRemove(docKey), disabled: !isEnabled, className: `inline-flex items-center justify-center shrink-0 h-5 w-5 p-0 border-0 rounded-full bg-gray-200 hover:bg-gray-300 focus:outline-none ${!isEnabled ? 'opacity-50 cursor-not-allowed' : ''}`, title: t?.('common.remove') ?? 'Remove', children: jsxRuntimeExports.jsx("img", { src: img, alt: t?.('common.remove') ?? 'Remove', className: "h-2.5 w-2.5" }) })] }))] })] }) }, docKey));
+                                        } })] })), hasFile && (jsxRuntimeExports.jsxs("div", { className: `${docControlClass} gap-2 border border-gray-200 bg-white`, title: displayFileName, children: [jsxRuntimeExports.jsxs("button", { type: "button", onClick: (e) => handlePreview(file, e), className: `${iconButtonClass} min-w-0 flex-1 gap-2 justify-start`, title: displayFileName, children: [jsxRuntimeExports.jsx("img", { src: img$1, alt: "", className: "h-4 w-4 shrink-0" }), jsxRuntimeExports.jsx("span", { className: "min-w-0 truncate text-sm font-medium text-gray-900", children: displayFileName })] }), jsxRuntimeExports.jsx("button", { type: "button", onClick: () => handleRemove(docKey), disabled: !isEnabled, className: `inline-flex items-center justify-center shrink-0 h-5 w-5 p-0 border-0 rounded-full bg-gray-200 hover:bg-gray-300 focus:outline-none ${!isEnabled ? 'opacity-50 cursor-not-allowed' : ''}`, title: t?.('common.remove') ?? 'Remove', children: jsxRuntimeExports.jsx("img", { src: img, alt: t?.('common.remove') ?? 'Remove', className: "h-2.5 w-2.5" }) })] })), showValidationError && (jsxRuntimeExports.jsx("p", { className: "text-red-500 text-sm mt-1", children: error[0] }))] })] }) }, docKey));
     };
     return (jsxRuntimeExports.jsx("div", { className: isReadonly ? 'DocsDisplayWidget mb-[10px]' : 'DocsWidget mb-[10px]', children: jsxRuntimeExports.jsx("div", { className: "flex flex-col lg:grid w-full", style: { gridTemplateColumns: `repeat(${docColumns.length || 1}, minmax(0, 1fr))` }, children: docColumns.map((column, columnIndex) => {
                 const isLast = columnIndex === docColumns.length - 1;
@@ -11945,5 +12256,5 @@ const translateUISchema = (schema, translate) => {
     };
 };
 
-export { BooleanWidget, CheckboxWidget, DateInputWidget, DateTimeInputWidget, DialogTableWidget, DisplayWidget, DocsWidget, FileInputWidget, GeoHierarchyWidget, HeaderSectionWidget, IdAuthenticationWidget, JSONEditorPanel, MultiSelectWidget, NumberInputWidget, PanelRenderer, ParentLookupWidget, PhoneInputWidget, ProfileWidget, PropertyEditor, RadioWidget, RegisterLookupWidget, ScoresDisplayWidget, SectionBuilder, SectionRenderer, SectionTree, SectionsContainer, SelectWidget, TableWidget, TextAreaWidget, TextInputWidget, VisualBuilderPanel, WidgetEventBus, WidgetProvider, WidgetRenderer, applyCaseControl, applyDecimalPrecision, applyMask, createWidgetStore, createZodSchema, defaultTheme, evaluateCondition, evaluateWidgetConditions, filterByCharacterType, formatCurrency, formatDate, formatNumber, formatPhone, formatValue, getApiDataSource, getCachedApiDataSource, getFormattedNumberLength, getSchemaDataSource, getStaticDataSource, getValueByPath, getWidgetValue, hasVisibilityRules, isAllowedKey, isGeoHierarchyDataSource, normalizeNumericDefault, normalizeOptionRules, parseDataPath, parseNumber, registerDefaultWidgets, removeMask, resetAll, resetWidget, resolveTheme, resolveWidgetIdValue, setDataSource, setError, setLoading, setTouched, setValue, setValueByPath, setValues, setWidgetValue, shouldEnableWidget, shouldRequireWidget, shouldShowWidget, transformDataSourceOptions, translatePanelConfig, translateUISchema, translateWidgetConfig, useBaseWidget, useWidgetCascade, useWidgetContext, useWidgetEventBus, useWidgetTheme, validateNumericValue, validateWidget, widgetRegistry };
+export { BooleanWidget, CheckboxWidget, DateInputWidget, DateTimeInputWidget, DialogTableWidget, DisplayWidget, DocsWidget, FileInputWidget, GeoHierarchyWidget, HeaderSectionWidget, IdAuthenticationWidget, JSONEditorPanel, MultiSelectWidget, NumberInputWidget, PanelRenderer, ParentLookupWidget, PhoneInputWidget, ProfileWidget, PropertyEditor, RadioWidget, RegisterLookupWidget, ScoresDisplayWidget, SectionBuilder, SectionRenderer, SectionTree, SectionsContainer, SelectWidget, TableWidget, TextAreaWidget, TextInputWidget, VisualBuilderPanel, WidgetEventBus, WidgetProvider, WidgetRenderer, applyCaseControl, applyDecimalPrecision, applyMask, createWidgetStore, createZodSchema, defaultTheme, deleteValueByPath, evaluateCondition, evaluateWidgetConditions, filterByCharacterType, formatCurrency, formatDate, formatNumber, formatPhone, formatValue, getApiDataSource, getCachedApiDataSource, getFormattedNumberLength, getSchemaDataSource, getStaticDataSource, getValueByPath, getWidgetValue, hasVisibilityRules, isAllowedKey, isGeoHierarchyDataSource, isWidgetValueEmpty, normalizeNumericDefault, normalizeOptionRules, parseDataPath, parseNumber, registerDefaultWidgets, removeMask, replaceValues, resetAll, resetWidget, resolveTheme, resolveWidgetIdValue, setDataSource, setError, setLoading, setTouched, setValue, setValueByPath, setValues, setWidgetValue, shouldEnableWidget, shouldRequireWidget, shouldShowWidget, transformDataSourceOptions, translatePanelConfig, translateUISchema, translateWidgetConfig, useBaseWidget, useWidgetCascade, useWidgetContext, useWidgetEventBus, useWidgetTheme, validateDocsWidget, validateNumericValue, validateWidget, widgetRegistry };
 //# sourceMappingURL=index.esm.js.map