@sapui5/sap.suite.ui.generic.template 1.150.1 → 1.152.0

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFieldCollector.js

@@ -25,6 +25,58 @@ sap.ui.define([
 
         // ─── Field Mapping for LLM ───────────────────────────────────────────────
 
+        /**
+         * Builds a live editability map by scanning all SmartFields on the ObjectPage
+         * and checking their actual runtime editable state.
+         *
+         * This is the authoritative source for whether a field is editable — it reflects
+         * hardcoded editable="false" in extension fragments, dynamic field-control values,
+         * key fields, and any other UI-level restriction, without needing to re-implement
+         * each rule from metadata. Mirrors the FE V4 approach (EasyFillButton._getEditableFields).
+         *
+         * If the same property appears in multiple SmartFields, it is treated as editable
+         * if at least one instance is editable (OR logic — consistent with V4).
+         *
+         * @param {object} oObjectPage - the ObjectPage control
+         * @returns {object} map of { propertyName: boolean } — true means editable in live UI
+         */
+        buildLiveEditabilityMap: function(oObjectPage) {
+            // This function is kept for backward compatibility but the full
+            // rendered walk is now done inside buildObjectPageStructureMap which
+            // returns both sections/fieldMap AND liveEditable in one pass.
+            var mLiveEditable = Object.create(null);
+            if (!oObjectPage || !oObjectPage.findAggregatedObjects) {
+                return mLiveEditable;
+            }
+            oObjectPage.findAggregatedObjects(true, function(oControl) {
+                if (!oControl.isA("sap.ui.comp.smartfield.SmartField")) {
+                    return false;
+                }
+                var oBindingInfo = oControl.getBindingInfo("value");
+                var sPropertyName = oBindingInfo && oBindingInfo.path;
+                if (!sPropertyName || sPropertyName.indexOf("/") !== -1) {
+                    return false;
+                }
+                var bEditable = oControl.getEditable();
+                if (mLiveEditable[sPropertyName] === undefined) {
+                    mLiveEditable[sPropertyName] = bEditable;
+                } else {
+                    // Hardcoded editable="false" (no binding) is non-negotiable — overrides everything.
+                    // OR logic only applies when the existing stored value is not already a settled hardcoded false,
+                    // preventing a later dynamic-true instance from overwriting it.
+                    var oEditableBinding = oControl.getBindingInfo("editable");
+                    if (!bEditable && !oEditableBinding) {
+                        mLiveEditable[sPropertyName] = false;
+                    } else if (mLiveEditable[sPropertyName] !== false) {
+                        mLiveEditable[sPropertyName] = mLiveEditable[sPropertyName] || bEditable;
+                    }
+                }
+                return false;
+            });
+            oLogger.debug("buildLiveEditabilityMap: scanned " + Object.keys(mLiveEditable).length + " SmartField(s)");
+            return mLiveEditable;
+        },
+
         /**
          * Builds the flat property map for the main entity type, used as the LLM input schema.
          * Each entry contains the field label and OData data type.
@@ -175,16 +227,26 @@ sap.ui.define([
         // ─── Updatable / Non-Updatable Classification ────────────────────────────
 
         /**
-         * Splits LLM-returned simple fields into updatable and non-updatable buckets
-         * based on OData metadata annotations (sap:updatable, FieldControl, etc.).
+         * Splits LLM-returned simple fields into updatable and non-updatable buckets.
          *
-         * @param {object} oAiCallResult - flat map of { fieldName: aiValue } from the LLM
-         * @param {object} oEntityType - OData entity type metadata
+         * Uses mLiveEditable (scanned from live SmartFields at dialog open) as the primary
+         * source when available — it captures all runtime restrictions: hardcoded editable="false"
+         * in extension fragments, key fields, dynamic field-control values, etc.
+         * Falls back to OData metadata annotation checks for fields not present in the live map.
+         *
+         * Decision per field:
+         *   1. mLiveEditable[field] === false  → non-updatable (UI definitively non-editable)
+         *   2. mLiveEditable[field] === true   → updatable (UI definitively editable)
+         *   3. mLiveEditable[field] === undefined → fall back to metadata annotation check
+         *
+         * @param {object} oAiCallResult     - flat map of { fieldName: aiValue } from the LLM
+         * @param {object} oEntityType       - OData entity type metadata
          * @param {object} oObjectPageContext - current ObjectPage binding context
-         * @param {object} oEntitySet - OData entity set metadata (for entity-set-level sap:updatable checks)
+         * @param {object} oEntitySet         - OData entity set metadata
+         * @param {object} [mLiveEditable]   - live editability map from buildLiveEditabilityMap
          * @returns {{ updatableFields: object, nonUpdatableFields: object }}
          */
-        getUpdatableAndNonUpdatableFields: function(oAiCallResult, oEntityType, oObjectPageContext, oEntitySet) {
+        getUpdatableAndNonUpdatableFields: function(oAiCallResult, oEntityType, oObjectPageContext, oEntitySet, mLiveEditable) {
             var updatableFields = {};
             var nonUpdatableFields = {};
 
@@ -194,9 +256,22 @@ sap.ui.define([
             }
 
             Object.keys(oAiCallResult).forEach(function(sKey) {
+                // Live map is the primary source when available
+                if (mLiveEditable) {
+                    if (mLiveEditable[sKey] === false) {
+                        nonUpdatableFields[sKey] = oAiCallResult[sKey];
+                        return;
+                    }
+                    if (mLiveEditable[sKey] === true) {
+                        updatableFields[sKey] = oAiCallResult[sKey];
+                        return;
+                    }
+                    // undefined → field not present in live UI (e.g. table-only property)
+                    // fall through to metadata check
+                }
+
                 var oProperty = oEntityType.property.find(function(oP) { return oP.name === sKey; });
                 if (!oProperty) {
-                    // Property not found in metadata → treat as non-updatable
                     nonUpdatableFields[sKey] = oAiCallResult[sKey];
                     return;
                 }
@@ -234,7 +309,8 @@ sap.ui.define([
                     return oHiddenAnnotation["Bool"] !== "true";
                 }
                 if (oHiddenAnnotation["Path"] && oObjectPageContext) {
-                    return !oObjectPageContext.getObject()[oHiddenAnnotation["Path"]];
+                    var oContextObj = oObjectPageContext.getObject();
+                    return oContextObj ? !oContextObj[oHiddenAnnotation["Path"]] : false;
                 }
                 // <Annotation Term="UI.Hidden"/> with no value → hidden
                 return false;
@@ -243,7 +319,8 @@ sap.ui.define([
             // Check "sap:field-control" attribute (value 0 = hidden)
             var sFieldControl = oProperty["sap:field-control"];
             if (sFieldControl && oObjectPageContext) {
-                var iFieldControlValue = oObjectPageContext.getObject()[sFieldControl];
+                var oCtxObj = oObjectPageContext.getObject();
+                var iFieldControlValue = oCtxObj ? oCtxObj[sFieldControl] : undefined;
                 return iFieldControlValue !== 0;
             }
 
@@ -306,122 +383,338 @@ sap.ui.define([
                 return sUpdatable !== "false";
             }
 
-            // Check "com.sap.vocabularies.Common.v1.FieldControl" enum member
+            // Check "com.sap.vocabularies.Common.v1.FieldControl" — static enum or dynamic path
+            // FieldControl values: 0=Hidden, 1=ReadOnly, 3=Optional, 7=Mandatory
             var oAnnotation = oProperty["com.sap.vocabularies.Common.v1.FieldControl"];
             if (oAnnotation && oAnnotation["EnumMember"]) {
                 return oAnnotation["EnumMember"] !== "com.sap.vocabularies.Common.v1.FieldControlType/ReadOnly";
             }
+            if (oAnnotation && oAnnotation["Path"]) {
+                var iDynamicFieldControl = oContextObject && oContextObject[oAnnotation["Path"]];
+                if (iDynamicFieldControl !== undefined && iDynamicFieldControl !== null) {
+                    return iDynamicFieldControl !== 0 && iDynamicFieldControl !== 1;
+                }
+            }
 
-            // Check "sap:field-control" dynamic path (value 1 = read-only)
+            // Check "sap:field-control" dynamic path (values: 0=Hidden, 1=ReadOnly)
+            // If the _fc property is defined in metadata but absent from the context object
+            // (not fetched / not in $select), treat as non-editable — safe fallback.
             var sFieldControl = oProperty["sap:field-control"];
             if (sFieldControl) {
-                var iFieldControlValue = oContextObject && oContextObject[sFieldControl];
-                return iFieldControlValue !== 1;
+                if (!oContextObject || !(sFieldControl in oContextObject)) {
+                    return false;
+                }
+                var iFieldControlValue = oContextObject[sFieldControl];
+                return iFieldControlValue !== 0 && iFieldControlValue !== 1;
             }
 
             // No restriction → editable by default
             return true;
         },
 
-        // ─── Section Tree Building (from ObjectPageSectionHandler) ───────────────
+        // ─── ObjectPage Structure Map & Section Building ─────────────────────────
 
         /**
-         * Builds a flat section tree for the Condensed view mode.
-         * Creates two sections: "Filled Fields" (updatable) and "Unfilled Fields" (non-updatable).
+         * Walks the RENDERED ObjectPage using findAggregatedObjects — the same proven
+         * approach used by buildLiveEditabilityMap — and produces the section/group/field
+         * structure map AND the live editability map in a SINGLE pass.
+         *
+         * IMPORTANT: Must be called when the page is in EDIT MODE with the OData entity
+         * context fully resolved (i.e. inside _handleAISubmit, not at dialog open).
+         * At that point getBindingInfo("value").path is reliably populated for all SmartFields.
+         *
+         * This approach is correct because:
+         *   ✓ Extension fragment SmartFields are included automatically
+         *   ✓ Editability reflects actual UI state (editable="false" in extension = non-editable)
+         *   ✓ Section/group titles come from the rendered page — same as what the user sees
+         *   ✓ Hidden sections are naturally excluded by checking the parent Section's visible state
+         *   ✓ One walk replaces two separate scans
          *
-         * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
-         * @param {object} oUpdatableFields - flat map of updatable fields only
-         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only
-         * @returns {Array} section tree array
+         * For each SmartField found, we walk UP the parent chain to get section/group context:
+         *   SmartField → GroupElement → SmartForm.Group → SmartForm → block → SubSection → Section
+         *
+         * Falls back to annotation-based structure if the rendered walk finds no fields
+         * (edge case: entity context not yet resolved).
+         *
+         * @param {object} oObjectPage - the REAL rendered FLP ObjectPage (not EasyFill dialog OPL)
+         * @param {object} [oEntityTypeFallback] - OData entity type for annotation fallback
+         * @param {object} [oRbFallback] - i18n resource bundle for annotation fallback
+         * @returns {{ sections: Array, fieldMap: Map, liveEditable: object }}
          */
-        getSectionsForCondensedView: function(oLLMResult, oUpdatableFields, oNonUpdatableFields) {
-            var aUpdatableKeys = Object.keys(oUpdatableFields || {});
-            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+        buildObjectPageStructureMap: function(oObjectPage, oEntityTypeFallback, oRbFallback) {
+            if (!oObjectPage || !oObjectPage.findAggregatedObjects) {
+                return { sections: [], fieldMap: new Map(), liveEditable: Object.create(null) };
+            }
+
+            var aSections     = [];
+            var mFieldMap     = new Map();
+            var mLiveEditable = Object.create(null);
+            var mSectionByKey = {};
+            var mGroupByKey   = {};
+            var that = this;
+
+            oObjectPage.findAggregatedObjects(true, function(oControl) {
+                if (!oControl.isA("sap.ui.comp.smartfield.SmartField")) { return false; }
+
+                // Get property name from value binding
+                var oBindingInfo = oControl.getBindingInfo("value");
+                var sPropertyName = oBindingInfo && oBindingInfo.path;
+                if (!sPropertyName || sPropertyName.indexOf("/") !== -1) { return false; }
+
+                // Walk UP parent chain to get section + group context
+                var sSectionTitle = "";
+                var sGroupTitle   = "";
+                var oParent = oControl.getParent();
+                while (oParent) {
+                    if (oParent.isA && oParent.isA("sap.ui.comp.smartform.Group")) {
+                        var oTitleObj = oParent.getTitle && oParent.getTitle();
+                        sGroupTitle = (oTitleObj && typeof oTitleObj.getText === "function")
+                            ? (oTitleObj.getText() || "") : "";
+                    }
+                    if (oParent.isA && oParent.isA("sap.uxap.ObjectPageSection")) {
+                        // Skip hidden sections
+                        if (oParent.getVisible && !oParent.getVisible()) { return false; }
+                        sSectionTitle = oParent.getTitle() || "";
+                        break;
+                    }
+                    oParent = oParent.getParent && oParent.getParent();
+                }
+
+                // Skip fields not in any visible section (e.g. header display fields)
+                if (!sSectionTitle) { return false; }
+                if (!sGroupTitle) { sGroupTitle = sSectionTitle; }
+
+                var sGroupKey = sSectionTitle + "|" + sGroupTitle;
+
+                // Ensure section + group exist in our structures
+                if (!Object.prototype.hasOwnProperty.call(mSectionByKey, sSectionTitle)) {
+                    mSectionByKey[sSectionTitle] = aSections.length;
+                    aSections.push({
+                        id:     that._generateId(sSectionTitle, []),
+                        title:  sSectionTitle,
+                        groups: []
+                    });
+                }
+                var iSectionIdx = mSectionByKey[sSectionTitle];
+                var oSectionEntry = aSections[iSectionIdx];
+
+                if (!Object.prototype.hasOwnProperty.call(mGroupByKey, sGroupKey)) {
+                    var sGroupId = that._generateId(sGroupKey, []);
+                    mGroupByKey[sGroupKey] = { sectionId: oSectionEntry.id, groupId: sGroupId };
+                    oSectionEntry.groups.push({ id: sGroupId, title: sGroupTitle });
+                }
+
+                // Register in fieldMap (first occurrence wins)
+                if (!mFieldMap.has(sPropertyName)) {
+                    mFieldMap.set(sPropertyName, {
+                        sectionId: mGroupByKey[sGroupKey].sectionId,
+                        groupId:   mGroupByKey[sGroupKey].groupId
+                    });
+                }
+
+                // Live editability — hardcoded false overrides dynamic instances regardless of order
+                var bEditable = oControl.getEditable();
+                var oEditableBinding = oControl.getBindingInfo("editable");
+                var bIsHardcodedFalse = !bEditable && !oEditableBinding;
+
+                if (mLiveEditable[sPropertyName] === undefined) {
+                    mLiveEditable[sPropertyName] = bEditable;
+                } else if (bIsHardcodedFalse) {
+                    // Extension fragment has explicit editable="false" — non-negotiable
+                    mLiveEditable[sPropertyName] = false;
+                } else if (mLiveEditable[sPropertyName] !== false) {
+                    // Only OR-in the new value if a hardcoded false hasn't already settled this field
+                    mLiveEditable[sPropertyName] = mLiveEditable[sPropertyName] || bEditable;
+                }
+
+                return false;
+            });
+
+            oLogger.debug("buildObjectPageStructureMap: rendered walk found "
+                + mFieldMap.size + " fields in " + aSections.length + " sections");
+
+            // Fallback: if rendered walk found nothing (entity context not yet resolved),
+            // fall back to annotation walk so at least section structure is available
+            if (mFieldMap.size === 0 && oEntityTypeFallback) {
+                oLogger.debug("buildObjectPageStructureMap: falling back to annotation walk");
+                var oAnnotationResult = this._buildFromAnnotations(oEntityTypeFallback, oRbFallback);
+                return {
+                    sections:    oAnnotationResult.sections,
+                    fieldMap:    oAnnotationResult.fieldMap,
+                    liveEditable: this.buildLiveEditabilityMap(oObjectPage)
+                };
+            }
+
+            return { sections: aSections, fieldMap: mFieldMap, liveEditable: mLiveEditable };
+        },
+
+        /**
+         * Annotation-based fallback for buildObjectPageStructureMap.
+         * Used when the rendered walk finds no fields (entity context not yet resolved).
+         * @private
+         */
+        _buildFromAnnotations: function(oEntityType, oRb) {
+            var aRaw = this._buildRawAnnotationTree(oEntityType, oRb);
             var aSections = [];
-            // Section 1: Filled Fields (updatable)
-            if (aUpdatableKeys.length > 0) {
-                aSections.push({
-                    title: "{@i18n>EASY_FILL_FILLED_FIELDS}",
-                    fields: [],
-                    children: [{
-                        title: "",
-                        fields: aUpdatableKeys,
-                        id: this._generateId("filledFields", aUpdatableKeys)
-                    }]
+            var mSectionByKey = {};
+            var mGroupByKey   = {};
+            var mFieldMap = new Map();
+
+            aRaw.forEach(function(oEntry) {
+                var aTitle        = oEntry.title;
+                var sField        = oEntry.property;
+                var sSectionTitle = aTitle[0] || "";
+                var sGroupTitle   = aTitle.length > 1 ? aTitle[aTitle.length - 1] : "";
+                var sGroupKey     = sSectionTitle + "|" + sGroupTitle;
+
+                if (!Object.prototype.hasOwnProperty.call(mSectionByKey, sSectionTitle)) {
+                    mSectionByKey[sSectionTitle] = aSections.length;
+                    aSections.push({ id: this._generateId(sSectionTitle, []), title: sSectionTitle, groups: [] });
+                }
+                var oSection = aSections[mSectionByKey[sSectionTitle]];
+
+                if (!Object.prototype.hasOwnProperty.call(mGroupByKey, sGroupKey)) {
+                    var sGroupId = this._generateId(sGroupKey, []);
+                    mGroupByKey[sGroupKey] = { sectionId: oSection.id, groupId: sGroupId };
+                    oSection.groups.push({ id: sGroupId, title: sGroupTitle });
+                }
+
+                if (!mFieldMap.has(sField)) {
+                    mFieldMap.set(sField, {
+                        sectionId: mGroupByKey[sGroupKey].sectionId,
+                        groupId:   mGroupByKey[sGroupKey].groupId
+                    });
+                }
+            }.bind(this));
+
+            return { sections: aSections, fieldMap: mFieldMap };
+        },
+
+        /**
+         * Applies LLM results to the pre-built structure map and returns a sections array
+         * ready to be written to easyFillDialogModel>/sections.
+         *
+         * Each section node shape: { type, title, id, visible, fields, children }
+         * Each child group shape:  { id, title, visible, aActiveFields, fields }
+         *
+         * O(fields returned by LLM) — no annotation walk, no DOM traversal.
+         *
+         * @param {Map}    mFieldMap           - from buildObjectPageStructureMap
+         * @param {Array}  aOpSections         - sections from buildObjectPageStructureMap
+         * @param {object} oUpdatableFields    - { fieldName: value }
+         * @param {object} oNonUpdatableFields - { fieldName: value }
+         * @returns {Array} sections array for easyFillDialogModel>/sections
+         */
+        applyLLMResultToStructureMap: function(mFieldMap, aOpSections, oUpdatableFields, oNonUpdatableFields) {
+            var mSectionById = {};
+            var mGroupById   = {};
+            (aOpSections || []).forEach(function(oSec, iSec) {
+                mSectionById[oSec.id] = iSec;
+                (oSec.groups || []).forEach(function(oGrp, iGrp) {
+                    mGroupById[oGrp.id] = { sectionIdx: iSec, groupIdx: iGrp };
                 });
-            }
+            });
+
+            // Start with all sections hidden, no active fields
+            var aSections = (aOpSections || []).map(function(oSec) {
+                return {
+                    title:    oSec.title,
+                    id:       oSec.id,
+                    visible:  false,
+                    fields:   [],
+                    children: (oSec.groups || []).map(function(oGrp) {
+                        return {
+                            id:           oGrp.id,
+                            title:        oGrp.title,
+                            visible:      false,
+                            aActiveFields: [],
+                            fields:       []
+                        };
+                    })
+                };
+            });
+
+            // Flip sections/groups that have LLM-matched updatable fields
+            Object.keys(oUpdatableFields || {}).forEach(function(sField) {
+                if (!mFieldMap.has(sField)) { return; }
+                var oLoc    = mFieldMap.get(sField);
+                var iSec    = mSectionById[oLoc.sectionId];
+                var oGrpLoc = mGroupById[oLoc.groupId];
+                if (iSec === undefined || !oGrpLoc) { return; }
+                aSections[iSec].visible = true;
+                var oGrp = aSections[oGrpLoc.sectionIdx].children[oGrpLoc.groupIdx];
+                oGrp.visible = true;
+                if (oGrp.aActiveFields.indexOf(sField) === -1) {
+                    oGrp.aActiveFields.push(sField);
+                }
+            });
 
-            // Section 2: Unfilled Fields (non-updatable/read-only)
+            // Non-updatable fields → "Unfilled Fields" section appended at the end
+            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
             if (aNonUpdatableKeys.length > 0) {
+                var sUnfilledGrpId = this._generateId("unfilledFields", []);
                 aSections.push({
-                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
-                    fields: [],
+                    title:   "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    id:      this._generateId("unfilledFieldsSection", []),
+                    visible: true,
+                    fields:  [],
                     children: [{
-                        title: "",
-                        fields: aNonUpdatableKeys,
-                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                        id:            sUnfilledGrpId,
+                        title:         "",
+                        visible:       true,
+                        aActiveFields: aNonUpdatableKeys,
+                        fields:        aNonUpdatableKeys
                     }]
                 });
             }
 
-            // Fallback: if no split provided, use old behavior
-            if (aSections.length === 0) {
-                return this._transformToTreeExpanded(oLLMResult);
-            }
-
             return aSections;
         },
 
         /**
-         * Builds a structured section tree for the ObjectPage view mode.
-         * Mirrors the ObjectPage section/facet structure and filters to only include
-         * updatable fields returned by the LLM. Non-updatable (read-only) fields are
-         * excluded from the annotation sections and shown exclusively in the
-         * "Unfilled Fields" section appended at the end.
+         * Builds a sections array for Condensed mode ready for easyFillDialogModel>/sections.
+         * Two flat groups: "Filled Fields" (updatable) and "Unfilled Fields" (non-updatable).
          *
-         * @param {object} oEntityType - OData entity type metadata
-         * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
-         * @param {object} oRb - i18n resource bundle
-         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only (optional)
-         * @returns {Array} filtered section tree array
+         * @param {object} oUpdatableFields    - { fieldName: value }
+         * @param {object} oNonUpdatableFields - { fieldName: value }
+         * @returns {Array} sections array
          */
-        getSectionsForObjectPageView: function(oEntityType, oLLMResult, oRb, oNonUpdatableFields) {
-            var aSections = [];
-            aSections = aSections
-                .concat(this._getSectionsForHeader(oEntityType, oRb))
-                .concat(this._getSectionsForObjectPageFacets(oEntityType));
-            var aTree = this._transformToTree(aSections);
-
-            // Annotation sections must only show updatable fields.
-            // Derive the updatable-only subset by removing non-updatable keys from oLLMResult
-            // so non-updatable fields do not appear in both annotation sections AND Unfilled Fields.
-            var aNonUpdatableSet = Object.keys(oNonUpdatableFields || {});
-            var oUpdatableResult = Object.keys(oLLMResult).reduce(function(oAcc, sKey) {
-                if (aNonUpdatableSet.indexOf(sKey) === -1) {
-                    oAcc[sKey] = oLLMResult[sKey];
-                }
-                return oAcc;
-            }, {});
-            var aFilteredTree = this._filterTreeByLLMResult(aTree, oUpdatableResult);
-            aFilteredTree = this._flattenTreeForObjectPageDialog(aFilteredTree);
-
-            // "Unfilled Fields" contains only non-updatable (read-only) fields.
-            // Editable fields that have no annotation section are silently dropped here —
-            // they already appear in their respective annotation-matched sections above.
+        getSectionInfoForCondensedMode: function(oUpdatableFields, oNonUpdatableFields) {
+            var aUpdatableKeys    = Object.keys(oUpdatableFields   || {});
             var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+            var aSections = [];
+
+            if (aUpdatableKeys.length > 0) {
+                aSections.push({
+                    title:   "{@i18n>EASY_FILL_FILLED_FIELDS}",
+                    visible: true,
+                    fields:  [],
+                    children: [{
+                        title:         "",
+                        visible:       true,
+                        aActiveFields: aUpdatableKeys,
+                        fields:        aUpdatableKeys,
+                        id:            this._generateId("filledFields", aUpdatableKeys)
+                    }]
+                });
+            }
+
             if (aNonUpdatableKeys.length > 0) {
-                aFilteredTree.push({
-                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
-                    fields: [],
+                aSections.push({
+                    title:   "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    visible: true,
+                    fields:  [],
                     children: [{
-                        title: "",
-                        fields: aNonUpdatableKeys,
-                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                        title:         "",
+                        visible:       true,
+                        aActiveFields: aNonUpdatableKeys,
+                        fields:        aNonUpdatableKeys,
+                        id:            this._generateId("unfilledFields", aNonUpdatableKeys)
                     }]
                 });
             }
 
-            return aFilteredTree;
+            return aSections;
         },
 
         // ─── SmartTable Utilities ─────────────────────────────────────────────────
@@ -513,102 +806,15 @@ sap.ui.define([
         // ─── Private Helpers ─────────────────────────────────────────────────────
 
         /**
-         * Extracts the navigation property name from an OData binding path.
-         * E.g. "/to_Items" → "to_Items", "/SalesOrderSet/to_Items" → "to_Items"
-         *
-         * @param {string} sBindingPath
-         * @returns {string|null}
-         */
-        _extractNavigationPropertyName: function(sBindingPath) {
-            if (!sBindingPath || typeof sBindingPath !== "string") {
-                return null;
-            }
-            var aParts = sBindingPath.split("/").filter(Boolean);
-            return aParts.length ? aParts[aParts.length - 1] : null;
-        },
-
-        /**
-         * Builds the "condensed" tree: all LLM fields in a single flat group.
-         * @private
-         */
-        _transformToTreeExpanded: function(oLLMRes) {
-            return [
-                {
-                    title: "",
-                    fields: [],
-                    children: [{
-                        title: "",
-                        fields: Object.keys(oLLMRes),
-                        id: this._generateId("", Object.keys(oLLMRes))
-                    }]
-                }
-            ];
-        },
-
-        /**
-         * Builds the "ObjectPage" section tree from a flat array of { title[], property } entries.
-         * Groups entries by their title path hierarchy.
-         * @private
-         */
-        _transformToTree: function(data) {
-            var rootMap = {};
-            var seen = new Set();
-            var that = this;
-
-            data.forEach(function(entry) {
-                var title = entry.title;
-                var property = entry.property;
-                if (seen.has(property)) { return; }
-                seen.add(property);
-
-                var currentMap = rootMap;
-                var sTitlePath = "";
-
-                title.forEach(function(level, index) {
-                    var isLast = index === title.length - 1;
-                    sTitlePath = sTitlePath ? (sTitlePath + "_" + level) : level;
-
-                    if (!currentMap[level]) {
-                        currentMap[level] = {
-                            title: level,
-                            titlePath: sTitlePath,
-                            fields: [],
-                            _childrenMap: {}
-                        };
-                    }
-
-                    if (isLast) {
-                        currentMap[level].fields.push(property);
-                    } else {
-                        currentMap = currentMap[level]._childrenMap;
-                    }
-                });
-            });
-
-            function convertToArray(oMap) {
-                return Object.values(oMap).map(function(oNode) {
-                    return {
-                        title: oNode.title,
-                        id: that._generateId(oNode.titlePath, oNode.fields),
-                        fields: oNode.fields,
-                        children: oNode._childrenMap ? convertToArray(oNode._childrenMap) : []
-                    };
-                });
-            }
-
-            return convertToArray(rootMap);
-        },
-
-        /**
-         * Generates a stable DOM-safe ID for a SmartForm section based on its title path and fields.
+         * Generates a stable DOM-safe ID string from a title path and optional field list.
          * @private
          */
         _generateId: function(sTitlePath, aFields) {
-            var sSanitizedTitle = sTitlePath
+            var sSanitizedTitle = (sTitlePath || "")
                 .replace(/\s+/g, "_")
                 .replace(/[^a-zA-Z0-9_]/g, "")
                 .toLowerCase();
-            var sFieldsPart = aFields
+            var sFieldsPart = (aFields || [])
                 .join("_")
                 .replace(/[^a-zA-Z0-9_]/g, "")
                 .toLowerCase();
@@ -616,90 +822,29 @@ sap.ui.define([
         },
 
         /**
-         * Filters a section tree to only include nodes that contain at least one LLM-returned field.
-         * Fields with no matching annotation section are silently dropped; the caller is responsible
-         * for surfacing them elsewhere (e.g. the "unfilledFields" section for non-updatable fields).
-         *
-         * @param {Array} aTree - section tree
-         * @param {object} oLLMResult - flat map of all LLM fields
-         * @returns {Array} filtered tree
+         * Extracts the navigation property name from an OData binding path.
+         * E.g. "/to_Items" → "to_Items", "/SalesOrderSet/to_Items" → "to_Items"
          * @private
          */
-        _filterTreeByLLMResult: function(aTree, oLLMResult) {
-            var aRequestedKeys = Object.keys(oLLMResult);
-            var that = this;
-
-            function filterNode(oNode, sParentPath) {
-                var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
-
-                var aFilteredFields = oNode.fields.filter(function(sField) {
-                    return aRequestedKeys.includes(sField);
-                });
-
-                var aFilteredChildren = oNode.children
-                    .map(function(oChild) { return filterNode(oChild, sTitlePath); })
-                    .filter(function(oChild) { return oChild.fields.length > 0 || oChild.children.length > 0; });
-
-                return {
-                    title: oNode.title,
-                    id: that._generateId(sTitlePath, aFilteredFields),
-                    fields: aFilteredFields,
-                    children: aFilteredChildren
-                };
+        _extractNavigationPropertyName: function(sBindingPath) {
+            if (!sBindingPath || typeof sBindingPath !== "string") {
+                return null;
             }
-
-            return aTree
-                .map(function(oNode) { return filterNode(oNode, ""); })
-                .filter(function(oNode) { return oNode.fields.length > 0 || oNode.children.length > 0; });
+            var aParts = sBindingPath.split("/").filter(Boolean);
+            return aParts.length ? aParts[aParts.length - 1] : null;
         },
 
         /**
-         * Flattens nested ObjectPage section trees to one group level expected by the dialog fragment.
-         *
-         * EasyFill dialog binds SmartForm groups only to section.children (one level deep).
-         * If annotation facets produce deeper nesting, section titles can render while fields remain
-         * invisible because grandchildren are never bound as groups.
-         *
-         * @param {Array} aTree - filtered section tree
-         * @returns {Array} dialog-compatible tree with one-level children per section
+         * Walks all ObjectPage annotations (HeaderInfo + HeaderFacets + UI.Facets) and returns
+         * a flat array of { title[], property } entries. This is the single source of truth for
+         * the raw annotation structure and is shared by both the map builder and the un-cached path.
          * @private
          */
-        _flattenTreeForObjectPageDialog: function(aTree) {
-            var that = this;
-
-            function collectRenderableGroups(oNode, sParentPath) {
-                var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
-                var aGroups = [];
-
-                if (Array.isArray(oNode.fields) && oNode.fields.length > 0) {
-                    aGroups.push({
-                        title: oNode.title,
-                        id: that._generateId(sTitlePath, oNode.fields),
-                        fields: oNode.fields,
-                        children: []
-                    });
-                }
-
-                if (Array.isArray(oNode.children) && oNode.children.length > 0) {
-                    oNode.children.forEach(function(oChild) {
-                        aGroups = aGroups.concat(collectRenderableGroups(oChild, sTitlePath));
-                    });
-                }
-
-                return aGroups;
-            }
-
-            return (aTree || []).map(function(oSection) {
-                var sSectionPath = oSection.title || "";
-                return {
-                    title: oSection.title,
-                    id: oSection.id,
-                    fields: [],
-                    children: collectRenderableGroups(oSection, sSectionPath)
-                };
-            }).filter(function(oSection) {
-                return Array.isArray(oSection.children) && oSection.children.length > 0;
-            });
+        _buildRawAnnotationTree: function(oEntityType, oRb) {
+            return [].concat(
+                this._getSectionsForHeader(oEntityType, oRb),
+                this._getSectionsForObjectPageFacets(oEntityType)
+            );
         },
 
         /**
@@ -725,8 +870,12 @@ sap.ui.define([
 
             if (aHeaderFacets && aHeaderFacets.length > 0) {
                 var aSections = this._extractSectionInfoFromReferenceFacet(oEntityType, aHeaderFacets);
+                var sHeaderTitle = oRb.getText("EASY_FILL_SECTION_HEADER");
                 aSections.forEach(function(oSection) {
-                    oSection.title = [oRb.getText("EASY_FILL_SECTION_HEADER"), oRb.getText("EASY_FILL_SECTION_HEADER")];
+                    // Prepend the "Header" section title while keeping the facet's own label as the
+                    // second hierarchy level. Previously both levels were set to the same headerText,
+                    // which collapsed all header facets into one group and lost their individual labels.
+                    oSection.title = [sHeaderTitle].concat(oSection.title);
                 });
                 aRes.push.apply(aRes, aSections);
             }
@@ -772,14 +921,49 @@ sap.ui.define([
 
         /**
          * Extracts { title[], property } entries from a set of ReferenceFacets.
-         * Skips IntentBasedNavigation, ForAction, and ForAnnotation record types (not supported).
+         * Handles UI.DataFieldForAnnotation by following its Target to the referenced FieldGroup —
+         * this is the primary pattern used in ObjectPage apps to embed FieldGroups inside UI.Facets.
+         * Skips IntentBasedNavigation, ForAction, and other non-renderable record types.
          * @private
          */
         _extractSectionInfoFromReferenceFacet: function(oEntityType, aFacets, aText) {
             aText = aText || [];
             var aRes = [];
             aFacets.forEach(function(oFacet) {
-                // Skip unsupported annotation types
+                var sNormalized = oFacet.RecordType
+                    ? oFacet.RecordType.replace("com.sap.vocabularies.UI.v1.", "UI.")
+                    : null;
+
+                // DataFieldForAnnotation: the record itself is not a field — it is a pointer to a
+                // FieldGroup (or other annotation). Follow the Target.AnnotationPath to get its Data.
+                if (sNormalized === "UI.DataFieldForAnnotation") {
+                    if (!oFacet.Target || !oFacet.Target.AnnotationPath) { return; }
+                    var sInnerPath = oFacet.Target.AnnotationPath.substring(1);
+                    var oInnerAnnotation = oEntityType[sInnerPath];
+                    if (!oInnerAnnotation) { return; }
+
+                    // Resolve the label: DataFieldForAnnotation.Label → FieldGroup.Label → fallback
+                    var sInnerLabel = null;
+                    if (oFacet.Label && oFacet.Label.String) {
+                        sInnerLabel = oFacet.Label.String;
+                    } else if (oInnerAnnotation.Label && oInnerAnnotation.Label.String) {
+                        sInnerLabel = oInnerAnnotation.Label.String;
+                    }
+
+                    var aTempText = aText.slice();
+                    if (sInnerLabel) { aTempText.push(sInnerLabel); }
+
+                    if (Array.isArray(oInnerAnnotation.Data)) {
+                        oInnerAnnotation.Data.forEach(function(oData) {
+                            if (!this._isSupportedRecordType(oData.RecordType)) { return; }
+                            if (!oData.Value || !oData.Value.Path) { return; }
+                            aRes.push({ title: aTempText, property: oData.Value.Path });
+                        }.bind(this));
+                    }
+                    return;
+                }
+
+                // Skip remaining unsupported types
                 if (!this._isSupportedRecordType(oFacet.RecordType)) {
                     return;
                 }
@@ -829,17 +1013,16 @@ sap.ui.define([
         },
 
         /**
-         * Returns false for record types that EasyFill does not support rendering.
-         * Currently excludes: IntentBasedNavigation, ForAnnotation, ForAction.
-         * Handles both fully-qualified names (com.sap.vocabularies.UI.v1.*) and
-         * alias form (UI.*) that OData metadata can return depending on the service.
+         * Returns false for record types that represent navigation/action triggers rather than
+         * editable data fields. DataFieldForAnnotation is NOT in this list — it is handled
+         * explicitly in _extractSectionInfoFromReferenceFacet by following its AnnotationPath.
+         * Handles both fully-qualified names (com.sap.vocabularies.UI.v1.*) and alias form (UI.*).
          * @private
          */
         _isSupportedRecordType: function(sRecordType) {
             if (!sRecordType) { return false; }
             var sNormalized = sRecordType.replace("com.sap.vocabularies.UI.v1.", "UI.");
             return sNormalized !== "UI.DataFieldForIntentBasedNavigation" &&
-                   sNormalized !== "UI.DataFieldForAnnotation" &&
                    sNormalized !== "UI.DataFieldForAction" &&
                    sNormalized !== "UI.DataFieldWithNavigationPath" &&
                    sNormalized !== "UI.DataFieldWithIntentBasedNavigation";