@nocobase/plugin-flow-engine 2.1.0-beta.20 → 2.1.0-beta.22

package/dist/server/flow-surfaces/service.js

@@ -64,6 +64,7 @@ var import_created_keys = require("./planning/created-keys");
 var import_key_persistence = require("./planning/key-persistence");
 var import_payload_shape = require("./payload-shape");
 var import_field_semantics = require("./field-semantics");
+var import_association_interfaces = require("./association-interfaces");
 var import_field_binding_registry = require("./field-binding-registry");
 var import_node_use_sets = require("./node-use-sets");
 var import_chart_config = require("./chart-config");
@@ -89,6 +90,7 @@ var import_association_title_field = require("./association-title-field");
 var import_default_action_popup = require("./default-action-popup");
 var import_defaults = require("./blueprint/defaults");
 var import_service_utils = require("./service-utils");
+var import_field_type_resolver = require("./field-type-resolver");
 var import_template_compatibility = require("./template-compatibility");
 var import_template_service_utils = require("./template-service-utils");
 const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel", ...import_approval.APPROVAL_FORM_BLOCK_USES]);
@@ -128,6 +130,7 @@ const KANBAN_POPUP_ACTION_KEYS = Object.keys(KANBAN_POPUP_ACTION_UID_SUFFIX_BY_K
 const CANONICAL_BLOCK_HEADER_USES = /* @__PURE__ */ new Set([
   "TableBlockModel",
   "CalendarBlockModel",
+  "TreeBlockModel",
   "KanbanBlockModel",
   "FormBlockModel",
   "CreateFormModel",
@@ -154,6 +157,7 @@ const OPEN_VIEW_SUPPORTED_MODES = /* @__PURE__ */ new Set(["drawer", "dialog", "
 const FILTER_TARGET_BLOCK_USES = /* @__PURE__ */ new Set([
   "TableBlockModel",
   "CalendarBlockModel",
+  "TreeBlockModel",
   "KanbanBlockModel",
   "DetailsBlockModel",
   "ListBlockModel",
@@ -162,6 +166,7 @@ const FILTER_TARGET_BLOCK_USES = /* @__PURE__ */ new Set([
   "MapBlockModel",
   "CommentsBlockModel"
 ]);
+const TREE_CONNECT_TARGET_BLOCK_USES = new Set(FILTER_TARGET_BLOCK_USES);
 const EDITABLE_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set(["FormItemModel", "FilterFormItemModel", "PatternFormItemModel"]);
 const DISPLAY_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set([
   "DetailsItemModel",
@@ -293,6 +298,7 @@ const POPUP_COLLECTION_BLOCK_SCENES = {
   CommentsBlockModel: ["one", "many"],
   TableBlockModel: ["many"],
   CalendarBlockModel: ["many"],
+  TreeBlockModel: ["filter"],
   KanbanBlockModel: ["many"],
   ListBlockModel: ["many"],
   GridCardBlockModel: ["many"],
@@ -951,8 +957,8 @@ class FlowSurfacesService {
     return this.patchResolvedNodeConfigureOptions(node, projected, enabledPackages);
   }
   patchResolvedNodeConfigureOptions(node, projected, enabledPackages) {
-    var _a, _b, _c;
-    if (!((_a = projected == null ? void 0 : projected.configureOptions) == null ? void 0 : _a.fieldComponent) || !(node == null ? void 0 : node.use)) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (!((_a = projected == null ? void 0 : projected.configureOptions) == null ? void 0 : _a.fieldType) || !(node == null ? void 0 : node.use)) {
       return projected;
     }
     try {
@@ -967,20 +973,107 @@ class FlowSurfacesService {
       if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.size)) {
         return projected;
       }
+      const supportedFieldTypes = Array.from(supportedFieldUses).map((use) => (0, import_field_type_resolver.getPublicFieldTypeForUse)(use)).filter(Boolean);
       const configureOptions = import_lodash.default.cloneDeep(projected.configureOptions || {});
-      configureOptions.fieldComponent = {
-        type: ((_c = configureOptions.fieldComponent) == null ? void 0 : _c.type) || "string",
-        ...configureOptions.fieldComponent || {},
-        enum: Array.from(supportedFieldUses)
+      configureOptions.fieldType = {
+        type: ((_c = configureOptions.fieldType) == null ? void 0 : _c.type) || "string",
+        ...configureOptions.fieldType || {},
+        enum: Array.from(new Set(supportedFieldTypes))
       };
+      const innerField = ((_d = node == null ? void 0 : node.subModels) == null ? void 0 : _d.field) || node;
+      const relationFieldTypes = Array.from(new Set(supportedFieldTypes));
+      const defaultTitleField = this.getAssociationDefaultTitleFieldName(
+        fieldSource.field,
+        (_e = fieldSource.fieldSettingsInit) == null ? void 0 : _e.dataSourceKey
+      );
       return {
         ...projected,
-        configureOptions
+        configureOptions,
+        relation: {
+          ...projected.relation,
+          fieldTypes: relationFieldTypes,
+          current: (0, import_service_utils.buildDefinedPayload)({
+            fieldType: (0, import_field_type_resolver.getPublicFieldTypeForUse)(((_g = (_f = innerField == null ? void 0 : innerField.stepParams) == null ? void 0 : _f.fieldBinding) == null ? void 0 : _g.use) || (innerField == null ? void 0 : innerField.use)),
+            fields: this.collectRelationNestedFieldPaths(innerField),
+            selectorFields: this.collectRelationSelectorFieldPaths(innerField),
+            titleField: ((_h = innerField == null ? void 0 : innerField.props) == null ? void 0 : _h.titleField) || ((_i = node == null ? void 0 : node.props) == null ? void 0 : _i.titleField)
+          }),
+          defaults: (0, import_service_utils.buildDefinedPayload)({
+            titleField: defaultTitleField
+          }),
+          candidates: this.buildRelationFieldTypeCandidates(relationFieldTypes, defaultTitleField),
+          configureOptions
+        }
       };
     } catch {
       return projected;
     }
   }
+  buildRelationFieldTypeCandidates(fieldTypes, defaultTitleField) {
+    return fieldTypes.map((fieldType) => {
+      const defaults = {
+        titleField: defaultTitleField
+      };
+      if (["subForm", "subFormList", "subDetails", "subDetailsList", "subTable", "popupSubTable"].includes(fieldType) && defaultTitleField) {
+        defaults.fields = [defaultTitleField];
+      }
+      if (fieldType === "picker" && defaultTitleField) {
+        defaults.selectorFields = [defaultTitleField];
+      }
+      return {
+        fieldType,
+        defaults: (0, import_service_utils.buildDefinedPayload)(defaults)
+      };
+    });
+  }
+  collectRelationNestedFieldPaths(fieldNode) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const fieldUse = String(((_b = (_a = fieldNode == null ? void 0 : fieldNode.stepParams) == null ? void 0 : _a.fieldBinding) == null ? void 0 : _b.use) || (fieldNode == null ? void 0 : fieldNode.use) || "").trim();
+    const relationFieldInit = ((_d = (_c = fieldNode == null ? void 0 : fieldNode.stepParams) == null ? void 0 : _c.fieldSettings) == null ? void 0 : _d.init) || {};
+    const relationFieldPath = (0, import_service_helpers.normalizeFieldPath)(relationFieldInit.fieldPath, relationFieldInit.associationPathName);
+    const toPublicFieldPath = (fieldPath) => {
+      const normalized = String(fieldPath || "").trim();
+      if (!normalized || !relationFieldPath || !normalized.startsWith(`${relationFieldPath}.`)) {
+        return normalized;
+      }
+      return normalized.slice(relationFieldPath.length + 1);
+    };
+    if (["SubTableFieldModel", "DisplaySubTableFieldModel"].includes(fieldUse)) {
+      return import_lodash.default.castArray(((_e = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _e.columns) || []).map((item) => {
+        var _a2, _b2, _c2;
+        return (_c2 = (_b2 = (_a2 = item == null ? void 0 : item.stepParams) == null ? void 0 : _a2.fieldSettings) == null ? void 0 : _b2.init) == null ? void 0 : _c2.fieldPath;
+      }).map(toPublicFieldPath).filter(Boolean);
+    }
+    if (fieldUse === "PopupSubTableFieldModel") {
+      return import_lodash.default.castArray(((_f = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _f.subTableColumns) || []).filter((item) => (item == null ? void 0 : item.use) === "TableColumnModel").map((item) => {
+        var _a2, _b2, _c2;
+        return (_c2 = (_b2 = (_a2 = item == null ? void 0 : item.stepParams) == null ? void 0 : _a2.fieldSettings) == null ? void 0 : _b2.init) == null ? void 0 : _c2.fieldPath;
+      }).map(toPublicFieldPath).filter(Boolean);
+    }
+    if (["SubFormFieldModel", "SubFormListFieldModel", "DisplaySubItemFieldModel", "DisplaySubListFieldModel"].includes(
+      fieldUse
+    )) {
+      return import_lodash.default.castArray(((_i = (_h = (_g = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _g.grid) == null ? void 0 : _h.subModels) == null ? void 0 : _i.items) || []).map((item) => {
+        var _a2, _b2, _c2;
+        return (_c2 = (_b2 = (_a2 = item == null ? void 0 : item.stepParams) == null ? void 0 : _a2.fieldSettings) == null ? void 0 : _b2.init) == null ? void 0 : _c2.fieldPath;
+      }).map(toPublicFieldPath).filter(Boolean);
+    }
+    return void 0;
+  }
+  collectRelationSelectorFieldPaths(fieldNode) {
+    var _a, _b, _c, _d, _e, _f;
+    const fieldUse = String(((_b = (_a = fieldNode == null ? void 0 : fieldNode.stepParams) == null ? void 0 : _a.fieldBinding) == null ? void 0 : _b.use) || (fieldNode == null ? void 0 : fieldNode.use) || "").trim();
+    if (fieldUse !== "RecordPickerFieldModel") {
+      return void 0;
+    }
+    const table = import_lodash.default.castArray(((_e = (_d = (_c = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _c["grid-block"]) == null ? void 0 : _d.subModels) == null ? void 0 : _e.items) || []).find(
+      (item) => (item == null ? void 0 : item.use) === "TableBlockModel"
+    );
+    return import_lodash.default.castArray(((_f = table == null ? void 0 : table.subModels) == null ? void 0 : _f.columns) || []).map((item) => {
+      var _a2, _b2, _c2;
+      return (_c2 = (_b2 = (_a2 = item == null ? void 0 : item.stepParams) == null ? void 0 : _a2.fieldSettings) == null ? void 0 : _b2.init) == null ? void 0 : _c2.fieldPath;
+    }).filter(Boolean);
+  }
   projectCatalogItem(item, expand) {
     return (0, import_catalog_smart.projectCatalogItem)(item, expand, {
       getEditableDomains: this.getEditableDomains.bind(this),
@@ -3738,6 +3831,7 @@ class FlowSurfacesService {
         }
         await this.applyInlineNodeSettings(actionName, targetUid, settings, options);
       },
+      resolveBlockSettings: (settings, state) => this.resolveComposeBlockSettings(settings, state.keyMap),
       createField: async (payload) => this.addField(payload, {
         ...options,
         popupTemplateAliasSession
@@ -3814,6 +3908,9 @@ class FlowSurfacesService {
     if ((current == null ? void 0 : current.use) === "CalendarBlockModel") {
       return this.configureCalendarBlock(target, current, values.changes, options);
     }
+    if ((current == null ? void 0 : current.use) === "TreeBlockModel") {
+      return this.configureTreeBlock(target, current, values.changes, options);
+    }
     if ((current == null ? void 0 : current.use) === "KanbanBlockModel") {
       return this.configureKanbanBlock(target, current, values.changes, options);
     }
@@ -3872,7 +3969,10 @@ class FlowSurfacesService {
       return this.configureFieldNode(target, values.changes, options);
     }
     if (import_node_use_sets.ACTION_BUTTON_USES.has((current == null ? void 0 : current.use) || "")) {
-      return this.configureActionNode(target, current.use, values.changes, options);
+      return this.configureActionNode(target, current.use, values.changes, {
+        ...options,
+        current
+      });
     }
     (0, import_errors.throwBadRequest)(`flowSurfaces configure does not support configureOptions on '${(current == null ? void 0 : current.use) || resolved.uid}'`);
   }
@@ -4808,7 +4908,7 @@ class FlowSurfacesService {
     };
   }
   async addBlock(values, options = {}) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const templateRef = import_lodash.default.isUndefined(values == null ? void 0 : values.template) ? void 0 : this.normalizeFlowTemplateReference("addBlock", values.template, {
       allowUsage: true,
       expectedType: "block"
@@ -4838,6 +4938,7 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)("flowSurfaces addBlock does not allow resource and resourceInit at the same time");
     }
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
+    const hasInlineFields = Object.prototype.hasOwnProperty.call(values || {}, "fields") || Object.prototype.hasOwnProperty.call(values || {}, "fieldsLayout");
     let resolvedTarget = await this.locator.resolve(target, options);
     let targetNode = await this.loadResolvedNode(resolvedTarget, options.transaction);
     const targetOpenView = this.resolvePopupHostOpenView(targetNode);
@@ -4872,6 +4973,16 @@ class FlowSurfacesService {
         requireCreateSupported: true
       }
     );
+    const inlineFields = hasInlineFields ? this.normalizeComposeBlock(
+      {
+        key: String((values == null ? void 0 : values.key) || catalogItem.key || (values == null ? void 0 : values.type) || (values == null ? void 0 : values.use) || "addBlock_inline").trim() || "addBlock_inline",
+        type: catalogItem.key || values.type,
+        fields: values.fields,
+        fieldsLayout: values.fieldsLayout
+      },
+      0,
+      enabledPackages
+    ) : null;
     const resolvedResourceInit = await this.resolvePopupCollectionBlockResourceInit({
       actionName: "addBlock",
       blockUse: catalogItem.use,
@@ -4945,6 +5056,73 @@ class FlowSurfacesService {
       } : {}
     };
     await this.applyInlineNodeSettings("addBlock", created, inlineSettings, options);
+    if ((_f = inlineFields == null ? void 0 : inlineFields.fields) == null ? void 0 : _f.length) {
+      const fieldTargetUid = this.resolveComposeFieldContainerUid(inlineFields, result);
+      const createdByKey = {};
+      for (const fieldSpec of inlineFields.fields) {
+        const createdField = await this.addField(
+          {
+            target: {
+              uid: fieldTargetUid
+            },
+            ...fieldSpec.key ? { key: fieldSpec.key } : {},
+            ...fieldSpec.fieldPath ? { fieldPath: fieldSpec.fieldPath } : {},
+            ...fieldSpec.associationPathName ? { associationPathName: fieldSpec.associationPathName } : {},
+            ...fieldSpec.renderer ? { renderer: fieldSpec.renderer } : {},
+            ...fieldSpec.type ? { type: fieldSpec.type } : {},
+            ...fieldSpec.fieldType ? { fieldType: fieldSpec.fieldType } : {},
+            ...!import_lodash.default.isUndefined(fieldSpec.fields) ? { fields: fieldSpec.fields } : {},
+            ...!import_lodash.default.isUndefined(fieldSpec.selectorFields) ? { selectorFields: fieldSpec.selectorFields } : {},
+            ...fieldSpec.titleField ? { titleField: fieldSpec.titleField } : {},
+            ...fieldSpec.openMode ? { openMode: fieldSpec.openMode } : {},
+            ...fieldSpec.popupSize ? { popupSize: fieldSpec.popupSize } : {},
+            ...!import_lodash.default.isUndefined(fieldSpec.pageSize) ? { pageSize: fieldSpec.pageSize } : {},
+            ...!import_lodash.default.isUndefined(fieldSpec.showIndex) ? { showIndex: fieldSpec.showIndex } : {},
+            ...fieldSpec.popup ? { popup: fieldSpec.popup } : {},
+            ...fieldSpec.__autoPopupForRelationField ? { __autoPopupForRelationField: true } : {},
+            ...fieldSpec[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY] ? {
+              [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: fieldSpec[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]
+            } : {}
+          },
+          {
+            transaction: options.transaction,
+            enabledPackages
+          }
+        );
+        if (fieldSpec.settings && Object.keys(fieldSpec.settings).length) {
+          await this.applyInlineFieldSettings("addBlock field", createdField, fieldSpec.settings, {
+            transaction: options.transaction
+          });
+        }
+        const layoutUid = createdField.wrapperUid || createdField.uid;
+        if (layoutUid && fieldSpec.key) {
+          createdByKey[fieldSpec.key] = { uid: layoutUid };
+        }
+      }
+      if (inlineFields.fieldsLayout && Object.keys(createdByKey).length) {
+        const layoutHost = await this.repository.findModelById(created, {
+          transaction: options.transaction,
+          includeAsyncNode: true
+        });
+        const layoutItems = import_lodash.default.castArray(
+          ((_i = (_h = (_g = layoutHost == null ? void 0 : layoutHost.subModels) == null ? void 0 : _g.grid) == null ? void 0 : _h.subModels) == null ? void 0 : _i.items) || ((_j = layoutHost == null ? void 0 : layoutHost.subModels) == null ? void 0 : _j.items) || []
+        );
+        const layoutPayload = this.buildComposeLayoutPayload({
+          layout: inlineFields.fieldsLayout,
+          createdByKey,
+          finalItems: layoutItems
+        });
+        await this.setLayout(
+          {
+            target: {
+              uid: created
+            },
+            ...layoutPayload
+          },
+          options
+        );
+      }
+    }
     if (!options.skipDefaultBlockActions) {
       await this.applyDefaultActionsForCreatedBlock(
         {
@@ -4991,6 +5169,8 @@ class FlowSurfacesService {
       return result2;
     }
     const target = await this.prepareWriteTarget("addField", values == null ? void 0 : values.target, values, options);
+    (0, import_field_type_resolver.assertNoInternalFieldKeys)(values, "flowSurfaces addField");
+    (0, import_field_type_resolver.assertNoInternalFieldKeys)(values == null ? void 0 : values.settings, "flowSurfaces addField.settings");
     (0, import_service_utils.ensureNoRawDirectAddKeys)("addField", values, [
       "wrapperProps",
       "fieldProps",
@@ -5007,6 +5187,8 @@ class FlowSurfacesService {
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const isFilterFormItem = container.wrapperUse === "FilterFormItemModel";
     const isApprovalFormTarget = (0, import_approval.isApprovalFormContainerUse)(container.ownerUse);
+    const requestedLegacyFieldUse = (0, import_service_utils.resolveRequestedFieldUseAlias)(values);
+    let requestedFieldUse = (0, import_service_utils.resolveRequestedFieldUse)(values);
     const requestedStandaloneType = typeof values.type === "string" && values.type.trim().length ? values.type.trim() : void 0;
     const fieldCapability = (0, import_catalog.resolveSupportedFieldCapability)({
       containerUse: container.ownerUse,
@@ -5017,6 +5199,9 @@ class FlowSurfacesService {
       enabledPackages
     });
     if (fieldCapability.standaloneUse) {
+      if ((0, import_service_utils.hasOwnDefined)(values, "fieldType")) {
+        (0, import_errors.throwBadRequest)("flowSurfaces fieldType is only supported for relation fields");
+      }
       if (inlinePopup) {
         (0, import_errors.throwBadRequest)(`flowSurfaces addField type '${values.type}' does not support popup`);
       }
@@ -5122,6 +5307,32 @@ class FlowSurfacesService {
       associationPathName: resolvedField.associationPathName,
       field: resolvedField.field
     });
+    const relationFieldTypeResolution = (0, import_field_type_resolver.resolveRelationFieldType)({
+      fieldType: values.fieldType,
+      containerUse: container.ownerUse,
+      field: resolvedField.field,
+      dataSourceKey: resolvedField.dataSourceKey,
+      getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName),
+      fields: values.fields,
+      selectorFields: values.selectorFields,
+      titleField: values.titleField,
+      openMode: values.openMode,
+      popupSize: values.popupSize,
+      pageSize: values.pageSize,
+      showIndex: values.showIndex,
+      context: "addField"
+    });
+    if (relationFieldTypeResolution) {
+      if (values.renderer) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces addField fieldType cannot be combined with renderer`);
+      }
+      if (requestedLegacyFieldUse && requestedLegacyFieldUse !== relationFieldTypeResolution.fieldUse) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces fieldUse '${requestedLegacyFieldUse}' does not match fieldType '${relationFieldTypeResolution.fieldType}'`
+        );
+      }
+      requestedFieldUse = relationFieldTypeResolution.fieldUse;
+    }
     const filterFormInit = isFilterFormItem ? {
       filterField: (0, import_service_helpers.buildFilterFieldMeta)(resolvedField.field),
       ...(selectedFilterTarget == null ? void 0 : selectedFilterTarget.ownerUid) ? { defaultTargetUid: selectedFilterTarget.ownerUid } : {}
@@ -5129,25 +5340,29 @@ class FlowSurfacesService {
     let capabilityField = preferredCapabilityField;
     let boundFieldCapability;
     if ((fieldMenuCandidate == null ? void 0 : fieldMenuCandidate.explicitWrapperUse) && (fieldMenuCandidate == null ? void 0 : fieldMenuCandidate.explicitFieldUse) && !values.renderer) {
-      if ((0, import_service_utils.hasOwnDefined)(values, "fieldUse") && values.fieldUse !== fieldMenuCandidate.explicitFieldUse) {
+      if (requestedLegacyFieldUse && requestedLegacyFieldUse !== fieldMenuCandidate.explicitFieldUse) {
         (0, import_errors.throwBadRequest)(
-          `flowSurfaces fieldUse '${values.fieldUse}' does not match inferred fieldUse '${fieldMenuCandidate.explicitFieldUse}' under '${container.ownerUse}'`
+          `flowSurfaces fieldUse '${requestedLegacyFieldUse}' does not match inferred fieldUse '${fieldMenuCandidate.explicitFieldUse}' under '${container.ownerUse}'`
         );
       }
-      boundFieldCapability = {
-        wrapperUse: fieldMenuCandidate.explicitWrapperUse,
-        fieldUse: fieldMenuCandidate.explicitFieldUse,
-        inferredFieldUse: fieldMenuCandidate.explicitFieldUse,
-        standaloneUse: void 0,
-        renderer: void 0
-      };
-      capabilityField = resolvedField.field;
-    } else {
+      if (!relationFieldTypeResolution) {
+        boundFieldCapability = {
+          wrapperUse: fieldMenuCandidate.explicitWrapperUse,
+          fieldUse: fieldMenuCandidate.explicitFieldUse,
+          inferredFieldUse: fieldMenuCandidate.explicitFieldUse,
+          standaloneUse: void 0,
+          renderer: void 0
+        };
+        capabilityField = resolvedField.field;
+      }
+    }
+    if (!boundFieldCapability) {
       try {
         boundFieldCapability = (0, import_catalog.resolveSupportedFieldCapability)({
           containerUse: container.ownerUse,
           field: capabilityField,
-          requestedFieldUse: values.fieldUse,
+          requestedFieldUse,
+          requestedFieldUseMode: relationFieldTypeResolution ? "fieldType" : "fieldUse",
           requestedWrapperUse: container.wrapperUse,
           requestedRenderer: values.renderer,
           enabledPackages,
@@ -5155,12 +5370,13 @@ class FlowSurfacesService {
           getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName)
         });
       } catch (error) {
-        if ((0, import_service_utils.hasOwnDefined)(values, "fieldUse") && capabilityField !== resolvedField.field && error instanceof import_errors.FlowSurfaceBadRequestError) {
+        if (requestedFieldUse && capabilityField !== resolvedField.field && error instanceof import_errors.FlowSurfaceBadRequestError) {
           capabilityField = resolvedField.field;
           boundFieldCapability = (0, import_catalog.resolveSupportedFieldCapability)({
             containerUse: container.ownerUse,
             field: capabilityField,
-            requestedFieldUse: values.fieldUse,
+            requestedFieldUse,
+            requestedFieldUseMode: relationFieldTypeResolution ? "fieldType" : "fieldUse",
             requestedWrapperUse: container.wrapperUse,
             requestedRenderer: values.renderer,
             enabledPackages,
@@ -5194,9 +5410,17 @@ class FlowSurfacesService {
       boundFieldCapability.fieldUse,
       capabilityField
     );
-    const defaultTitleField = titleFieldSyncDecision.titleField ?? normalizedFieldBinding.defaultTitleField ?? (fieldMenuCandidate == null ? void 0 : fieldMenuCandidate.defaultTitleField);
+    const defaultTitleField = (relationFieldTypeResolution == null ? void 0 : relationFieldTypeResolution.titleField) ?? titleFieldSyncDecision.titleField ?? normalizedFieldBinding.defaultTitleField ?? (fieldMenuCandidate == null ? void 0 : fieldMenuCandidate.defaultTitleField);
     const wrapperShouldPersistTitleField = !import_lodash.default.isUndefined(defaultTitleField) && TITLE_FIELD_SUPPORTED_WRAPPER_USES.has(boundFieldCapability.wrapperUse || "");
-    const fieldShouldPersistTitleField = !import_lodash.default.isUndefined(defaultTitleField);
+    const fieldShouldPersistTitleField = !import_lodash.default.isUndefined(defaultTitleField) && this.supportsFieldTitleFieldProp(boundFieldCapability.fieldUse);
+    const normalizedDefaultFieldProps = this.normalizeFieldPropsForUse(
+      boundFieldCapability.fieldUse,
+      defaultFieldState.fieldProps || {}
+    );
+    const normalizedInlineFieldProps = this.normalizeFieldPropsForUse(
+      boundFieldCapability.fieldUse,
+      values.fieldProps || {}
+    );
     const tree = (0, import_builder.buildFieldTree)({
       wrapperUse: boundFieldCapability.wrapperUse,
       fieldUse: boundFieldCapability.fieldUse,
@@ -5213,9 +5437,9 @@ class FlowSurfacesService {
       ),
       fieldProps: import_lodash.default.merge(
         {},
-        defaultFieldState.fieldProps || {},
+        normalizedDefaultFieldProps,
         fieldShouldPersistTitleField ? { titleField: defaultTitleField } : {},
-        values.fieldProps || {}
+        normalizedInlineFieldProps
       )
     });
     this.contractGuard.validateNodeTreeAgainstContract(tree.model);
@@ -5254,6 +5478,22 @@ class FlowSurfacesService {
       associationPathName: normalizedFieldBinding.associationPathName,
       fieldPath: normalizedFieldBinding.fieldPath
     };
+    if (relationFieldTypeResolution) {
+      await this.applyResolvedRelationFieldType({
+        fieldUid: tree.innerUid,
+        fieldUse: boundFieldCapability.fieldUse,
+        targetCollection: relationFieldTypeResolution.targetCollection,
+        relationFieldInit: normalizedFieldBinding,
+        fields: relationFieldTypeResolution.fields,
+        selectorFields: relationFieldTypeResolution.selectorFields,
+        titleField: relationFieldTypeResolution.titleField,
+        openMode: relationFieldTypeResolution.openMode,
+        popupSize: relationFieldTypeResolution.popupSize,
+        pageSize: relationFieldTypeResolution.pageSize,
+        showIndex: relationFieldTypeResolution.showIndex,
+        transaction: options.transaction
+      });
+    }
     await this.applyInlineFieldSettings("addField", result, inlineSettings, options);
     await this.applyInlineFieldPopup("addField", result, inlinePopup, {
       ...options,
@@ -6555,6 +6795,27 @@ class FlowSurfacesService {
       (0, import_service_utils.rethrowInlineConfigurationError)(error, `flowSurfaces ${actionName} settings invalid`);
     }
   }
+  resolveComposeBlockSettings(settings, keyMap) {
+    if (!import_lodash.default.isPlainObject(settings == null ? void 0 : settings.connectFields) || !Array.isArray(settings.connectFields.targets)) {
+      return settings;
+    }
+    const nextSettings = import_lodash.default.cloneDeep(settings);
+    nextSettings.connectFields = {
+      ...nextSettings.connectFields,
+      targets: import_lodash.default.castArray(nextSettings.connectFields.targets).map((target) => {
+        if (!import_lodash.default.isPlainObject(target) || import_lodash.default.isUndefined(target.target) || target.target === null || target.target === "") {
+          return target;
+        }
+        const nextTarget = {
+          ...target,
+          targetId: (0, import_compose_compiler.resolveComposeTargetKey)(String(target.target), keyMap, "tree connectFields")
+        };
+        delete nextTarget.target;
+        return nextTarget;
+      })
+    };
+    return nextSettings;
+  }
   async applyInlineFieldPopup(actionName, result, popup, options) {
     popup = this.prepareInlinePopupTemplateAliases(actionName, popup, options.popupTemplateAliasSession);
     const fieldHostUid = result.fieldUid || result.uid;
@@ -7602,6 +7863,9 @@ class FlowSurfacesService {
       if (typeof normalizedValues[domain] === "undefined") {
         return;
       }
+      if (domain === "flowRegistry") {
+        this.assertNoTreeConnectFieldsFlowRegistry(current, normalizedValues[domain], "updateSettings");
+      }
       if (!contract.editableDomains.includes(domain)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces updateSettings domain '${domain}' is not editable`);
       }
@@ -7633,7 +7897,6 @@ class FlowSurfacesService {
     this.syncChartConfigureForUpdateSettings(current, nextPayload);
     await this.validateChartConfigureForUpdateSettings(current, nextPayload, options.transaction);
     this.syncCanonicalBlockHeaderForUpdateSettings(current, nextPayload);
-    this.syncMapHeightChromeForUpdateSettings(current, nextPayload);
     this.syncChartCardRuntimeStepParamsForUpdateSettings(
       current,
       nextPayload,
@@ -7824,6 +8087,7 @@ class FlowSurfacesService {
     import_lodash.default.set(values, titleDescriptionPath, normalizedTitleDescription);
   }
   syncCanonicalBlockHeaderForUpdateSettings(current, nextPayload) {
+    var _a;
     const semanticUse = (0, import_approval.normalizeApprovalSemanticUse)(current == null ? void 0 : current.use);
     if (!CANONICAL_BLOCK_HEADER_USES.has(semanticUse)) {
       return;
@@ -7834,11 +8098,19 @@ class FlowSurfacesService {
     const nextStepParams = import_lodash.default.cloneDeep(nextPayload.stepParams ?? (current == null ? void 0 : current.stepParams) ?? {});
     const nextCardSettings = import_lodash.default.cloneDeep(import_lodash.default.get(nextStepParams, ["cardSettings"]) || {});
     const normalizedTitleDescription = (0, import_service_utils.normalizeBlockTitleDescription)(import_lodash.default.get(nextCardSettings, ["titleDescription"]));
+    const normalizedBlockHeight = (_a = (0, import_service_utils.normalizeChartCardSettings)({
+      blockHeight: import_lodash.default.get(nextCardSettings, ["blockHeight"])
+    })) == null ? void 0 : _a.blockHeight;
     if (normalizedTitleDescription) {
       import_lodash.default.set(nextCardSettings, ["titleDescription"], normalizedTitleDescription);
     } else {
       import_lodash.default.unset(nextCardSettings, ["titleDescription"]);
     }
+    if (normalizedBlockHeight) {
+      import_lodash.default.set(nextCardSettings, ["blockHeight"], normalizedBlockHeight);
+    } else {
+      import_lodash.default.unset(nextCardSettings, ["blockHeight"]);
+    }
     if (import_lodash.default.isEmpty(nextCardSettings)) {
       import_lodash.default.unset(nextStepParams, ["cardSettings"]);
     } else {
@@ -7872,28 +8144,6 @@ class FlowSurfacesService {
       );
     }
   }
-  syncMapHeightChromeForUpdateSettings(current, nextPayload) {
-    if ((current == null ? void 0 : current.use) !== "MapBlockModel") {
-      return;
-    }
-    const nextProps = import_lodash.default.isPlainObject(nextPayload.props) ? nextPayload.props : void 0;
-    if (!nextProps) {
-      return;
-    }
-    const nextDecoratorProps = import_lodash.default.cloneDeep(nextPayload.decoratorProps ?? (current == null ? void 0 : current.decoratorProps) ?? {});
-    let changed = false;
-    if (Object.prototype.hasOwnProperty.call(nextProps, "height") && nextDecoratorProps.height !== nextProps.height) {
-      nextDecoratorProps.height = nextProps.height;
-      changed = true;
-    }
-    if (Object.prototype.hasOwnProperty.call(nextProps, "heightMode") && nextDecoratorProps.heightMode !== nextProps.heightMode) {
-      nextDecoratorProps.heightMode = nextProps.heightMode;
-      changed = true;
-    }
-    if (changed) {
-      nextPayload.decoratorProps = (0, import_service_utils.buildDefinedPayload)(nextDecoratorProps);
-    }
-  }
   async normalizeOpenViewForUpdateSettings(actionName, current, nextPayload, options = {}) {
     const openViewPaths = [
       ["popupSettings", "openView"],
@@ -8161,6 +8411,7 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)(`flowSurfaces setEventFlows is not supported on '${(current == null ? void 0 : current.use) || target.uid}'`);
     }
     const flows = values.flowRegistry || values.flows || {};
+    this.assertNoTreeConnectFieldsFlowRegistry(current, flows, "setEventFlows");
     this.contractGuard.validateFlowRegistry(current, flows);
     if (target.kind === "tab" && target.tabRoute) {
       await this.routeSync.persistTabSettings(
@@ -8276,10 +8527,13 @@ class FlowSurfacesService {
     });
     this.assertRemoveNodeResolvedTarget(resolved, node);
     if ((node == null ? void 0 : node.use) === "FilterFormItemModel") {
-      await this.removeFilterFormConnectConfig(resolved.uid, options.transaction);
+      await this.removeFilterSourceBindings(resolved.uid, options.transaction);
+    }
+    if ((node == null ? void 0 : node.use) === "TreeBlockModel") {
+      await this.removeFilterSourceBindings(resolved.uid, options.transaction);
     }
     if (FILTER_TARGET_BLOCK_USES.has((node == null ? void 0 : node.use) || "")) {
-      await this.removeFilterFormTargetBindings(resolved.uid, options.transaction);
+      await this.removeFilterTargetBindings(resolved.uid, options.transaction);
     }
     const approvalRoot = await this.findApprovalSurfaceRootForNode(resolved.uid, options.transaction);
     await this.removeNodeTreeWithBindings(resolved.uid, options.transaction);
@@ -9374,6 +9628,7 @@ class FlowSurfacesService {
     );
     const hasFields = Object.prototype.hasOwnProperty.call(input, "fields");
     const hasFieldGroups = Object.prototype.hasOwnProperty.call(input, "fieldGroups");
+    const hasActions = Object.prototype.hasOwnProperty.call(input, "actions");
     const hasRecordActions = Object.prototype.hasOwnProperty.call(input, "recordActions");
     if (type === "calendar") {
       if (hasFields) {
@@ -9409,6 +9664,23 @@ class FlowSurfacesService {
         );
       }
     }
+    if (type === "tree") {
+      if (hasFields) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} tree does not support fields[]`);
+      }
+      if (hasFieldGroups) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} tree does not support fieldGroups[]`);
+      }
+      if (hasActions) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} tree does not support actions[]`);
+      }
+      if (hasRecordActions) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} tree does not support recordActions[]`);
+      }
+      if (Object.prototype.hasOwnProperty.call(input, "fieldsLayout")) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} tree does not support fieldsLayout`);
+      }
+    }
     if (hasFields && hasFieldGroups) {
       (0, import_errors.throwBadRequest)(`flowSurfaces compose block #${index + 1} cannot mix fields with fieldGroups`);
     }
@@ -9730,10 +10002,13 @@ class FlowSurfacesService {
       }
     }
     if (node.use === "FilterFormItemModel") {
-      await this.removeFilterFormConnectConfig(node.uid, transaction);
+      await this.removeFilterSourceBindings(node.uid, transaction);
+    }
+    if (node.use === "TreeBlockModel") {
+      await this.removeFilterSourceBindings(node.uid, transaction);
     }
     if (FILTER_TARGET_BLOCK_USES.has(node.use || "")) {
-      await this.removeFilterFormTargetBindings(node.uid, transaction);
+      await this.removeFilterTargetBindings(node.uid, transaction);
     }
   }
   async configurePage(target, changes, options) {
@@ -9801,15 +10076,11 @@ class FlowSurfacesService {
   }
   async configureTableBlock(target, changes, options) {
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("TableBlockModel");
-    const cardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("table", changes, allowedKeys);
     return this.updateSettings(
       {
         target,
-        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-          height: changes.height,
-          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-        }),
         stepParams: {
           ...cardSettings ? { cardSettings } : {},
           ...changes.resource ? {
@@ -9850,7 +10121,7 @@ class FlowSurfacesService {
   async configureCalendarBlock(target, current, changes, options) {
     var _a;
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("CalendarBlockModel");
-    const cardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("calendar", changes, allowedKeys);
     this.validateCalendarSettingValues("configure", {
       defaultView: changes.defaultView,
@@ -9903,10 +10174,6 @@ class FlowSurfacesService {
           quickCreatePopupSettings,
           eventPopupSettings
         }),
-        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-          height: changes.height,
-          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-        }),
         stepParams: {
           ...cardSettings ? { cardSettings } : {},
           ...changes.resource ? {
@@ -9950,10 +10217,93 @@ class FlowSurfacesService {
     await this.ensureCalendarBlockPopupHosts(reloaded, options.transaction);
     return result;
   }
+  async configureTreeBlock(target, current, changes, options) {
+    var _a, _b;
+    const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("TreeBlockModel");
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
+    (0, import_service_utils.assertSupportedSimpleChanges)("tree", changes, allowedKeys);
+    const nextFieldNames = import_lodash.default.isPlainObject(changes.fieldNames) ? import_lodash.default.merge({}, ((_a = current == null ? void 0 : current.props) == null ? void 0 : _a.fieldNames) || {}, changes.fieldNames) : import_lodash.default.cloneDeep(((_b = current == null ? void 0 : current.props) == null ? void 0 : _b.fieldNames) || {});
+    if ((0, import_service_utils.hasOwnDefined)(changes, "titleField")) {
+      nextFieldNames.title = String(changes.titleField || "").trim();
+    }
+    const hasFieldNamesPatch = (0, import_service_utils.hasOwnDefined)(changes, "titleField") || import_lodash.default.isPlainObject(changes.fieldNames);
+    const result = await this.updateSettings(
+      {
+        target,
+        props: (0, import_service_utils.buildDefinedPayload)({
+          ...(0, import_service_utils.hasOwnDefined)(changes, "searchable") ? { searchable: changes.searchable !== false } : {},
+          ...(0, import_service_utils.hasOwnDefined)(changes, "defaultExpandAll") ? { defaultExpandAll: changes.defaultExpandAll === true } : {},
+          ...(0, import_service_utils.hasOwnDefined)(changes, "includeDescendants") ? { includeDescendants: changes.includeDescendants !== false } : {},
+          ...hasFieldNamesPatch ? { fieldNames: nextFieldNames } : {},
+          ...(0, import_service_utils.hasOwnDefined)(changes, "pageSize") ? { pageSize: changes.pageSize } : {}
+        }),
+        stepParams: {
+          ...cardSettings ? { cardSettings } : {},
+          ...changes.resource ? {
+            resourceSettings: {
+              init: (0, import_service_utils.normalizeSimpleResourceInit)(changes.resource)
+            }
+          } : {},
+          ...(0, import_service_utils.hasDefinedValue)(changes, [
+            "searchable",
+            "defaultExpandAll",
+            "includeDescendants",
+            "titleField",
+            "pageSize",
+            "dataScope",
+            "sorting"
+          ]) ? {
+            treeSettings: (0, import_service_utils.buildDefinedPayload)({
+              ...(0, import_service_utils.hasOwnDefined)(changes, "searchable") ? { searchable: { searchable: changes.searchable !== false } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "defaultExpandAll") ? { defaultExpandAll: { defaultExpandAll: changes.defaultExpandAll === true } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "includeDescendants") ? { includeDescendants: { includeDescendants: changes.includeDescendants !== false } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "titleField") ? { titleField: { titleField: nextFieldNames.title } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "pageSize") ? { pageSize: { pageSize: changes.pageSize } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "dataScope") ? { dataScope: { filter: changes.dataScope } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "sorting") ? { defaultSorting: { sort: changes.sorting } } : {}
+            })
+          } : {}
+        }
+      },
+      options
+    );
+    if ((0, import_service_utils.hasOwnDefined)(changes, "connectFields")) {
+      const effectiveTreeNode = changes.resource || hasFieldNamesPatch || (0, import_service_utils.hasDefinedValue)(changes, [
+        "searchable",
+        "defaultExpandAll",
+        "includeDescendants",
+        "titleField",
+        "pageSize",
+        "dataScope",
+        "sorting"
+      ]) ? await this.repository.findModelById(current.uid, {
+        transaction: options.transaction,
+        includeAsyncNode: true
+      }) : current;
+      await this.persistTreeConnectFields(
+        effectiveTreeNode,
+        changes.connectFields,
+        "configure tree",
+        options.transaction
+      );
+      return {
+        ...result,
+        updated: import_lodash.default.uniq([...result.updated || [], "connectFields"])
+      };
+    }
+    if ((0, import_service_utils.hasOwnDefined)(changes, "resource")) {
+      await this.removeFilterSourceBindings(current.uid, options.transaction);
+      return {
+        ...result,
+        updated: import_lodash.default.uniq([...result.updated || [], "connectFields"])
+      };
+    }
+    return result;
+  }
   async configureKanbanBlock(target, current, changes, options) {
     var _a;
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("KanbanBlockModel");
-    const blockCardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const blockCardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("kanban", changes, allowedKeys);
     if (!import_lodash.default.isUndefined(changes.dragEnabled) && !import_lodash.default.isBoolean(changes.dragEnabled)) {
       (0, import_errors.throwBadRequest)("flowSurfaces configure kanban dragEnabled must be a boolean");
@@ -10232,15 +10582,11 @@ class FlowSurfacesService {
       } : {}
     });
     const updated = /* @__PURE__ */ new Set();
-    if (Object.keys(blockProps).length || Object.keys(blockStepParams).length || (0, import_service_utils.hasDefinedValue)(changes, ["height", "heightMode"])) {
+    if (Object.keys(blockProps).length || Object.keys(blockStepParams).length) {
       const blockResult = await this.updateSettings(
         {
           target,
           props: blockProps,
-          decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-            height: changes.height,
-            heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-          }),
           stepParams: blockStepParams
         },
         options
@@ -10417,16 +10763,12 @@ class FlowSurfacesService {
   }
   async configureListBlock(target, changes, options) {
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("ListBlockModel");
-    const cardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("list", changes, allowedKeys);
     const layoutValue = (0, import_service_utils.normalizeSimpleLayoutValue)(changes.layout);
     return this.updateSettings(
       {
         target,
-        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-          height: changes.height,
-          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-        }),
         stepParams: {
           ...cardSettings ? { cardSettings } : {},
           ...changes.resource ? {
@@ -10449,17 +10791,13 @@ class FlowSurfacesService {
   }
   async configureGridCardBlock(target, changes, options) {
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("GridCardBlockModel");
-    const cardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("gridCard", changes, allowedKeys);
     const layoutValue = (0, import_service_utils.normalizeSimpleLayoutValue)(changes.layout);
     const columns = (0, import_service_utils.normalizeGridCardColumns)(changes.columns);
     return this.updateSettings(
       {
         target,
-        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-          height: changes.height,
-          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-        }),
         stepParams: {
           ...cardSettings ? { cardSettings } : {},
           ...changes.resource ? {
@@ -10628,15 +10966,11 @@ class FlowSurfacesService {
   }
   async configureMapBlock(target, changes, options) {
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("MapBlockModel");
-    const cardSettings = (0, import_service_utils.buildBlockTitleDescriptionFromSemanticChanges)(changes);
+    const cardSettings = (0, import_service_utils.buildBlockCardSettingsFromSemanticChanges)(changes);
     (0, import_service_utils.assertSupportedSimpleChanges)("map", changes, allowedKeys);
     return this.updateSettings(
       {
         target,
-        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
-          height: changes.height,
-          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
-        }),
         stepParams: (0, import_service_utils.buildDefinedPayload)({
           ...cardSettings ? { cardSettings } : {},
           ...changes.resource ? {
@@ -10818,10 +11152,22 @@ class FlowSurfacesService {
     );
   }
   async configureFieldWrapper(target, current, changes, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     (0, import_service_utils.assertSupportedSimpleChanges)("field wrapper", changes, (0, import_configure_options.getConfigureOptionKeysForUse)(current == null ? void 0 : current.use));
-    const rawWrapperChanges = import_lodash.default.omit(changes, ["clickToOpen", "openView", "code", "version", "fieldComponent"]);
+    const rawWrapperChanges = import_lodash.default.omit(changes, [
+      "clickToOpen",
+      "openView",
+      "code",
+      "version",
+      "fieldType",
+      "fields",
+      "selectorFields",
+      "openMode",
+      "popupSize",
+      "pageSize",
+      "showIndex"
+    ]);
     const wrapperChanges = (current == null ? void 0 : current.use) === "TableColumnModel" && !(0, import_service_utils.hasOwnDefined)(rawWrapperChanges, "title") && (0, import_service_utils.hasOwnDefined)(rawWrapperChanges, "label") ? {
       ...rawWrapperChanges,
       title: rawWrapperChanges.label
@@ -10855,6 +11201,8 @@ class FlowSurfacesService {
     });
     const shouldSyncTitleField = titleFieldSyncDecision.shouldSync;
     const syncedTitleField = titleFieldSyncDecision.titleField;
+    const shouldPatchTableColumnTitle = (current == null ? void 0 : current.use) === "TableColumnModel" && (0, import_service_utils.hasOwnDefined)(wrapperChanges, "title");
+    const shouldPatchFieldSettings = (0, import_service_utils.hasDefinedValue)(wrapperChanges, ["fieldPath", "associationPathName"]) || shouldPatchTableColumnTitle;
     if (Object.keys(wrapperChanges).length) {
       await this.updateSettings(
         {
@@ -10889,8 +11237,8 @@ class FlowSurfacesService {
             labelWidth: wrapperChanges.labelWidth,
             labelWrap: wrapperChanges.labelWrap
           }),
-          stepParams: (0, import_service_utils.hasDefinedValue)(wrapperChanges, ["fieldPath", "associationPathName"]) || (current == null ? void 0 : current.use) === "TableColumnModel" && (0, import_service_utils.hasOwnDefined)(wrapperChanges, "title") ? (0, import_service_utils.buildDefinedPayload)({
-            ...(current == null ? void 0 : current.use) === "TableColumnModel" && (0, import_service_utils.hasOwnDefined)(wrapperChanges, "title") ? {
+          stepParams: shouldPatchFieldSettings ? (0, import_service_utils.buildDefinedPayload)({
+            ...shouldPatchTableColumnTitle ? {
               tableColumnSettings: {
                 title: {
                   title: wrapperChanges.title
@@ -10926,24 +11274,70 @@ class FlowSurfacesService {
         );
       }
     }
-    if ((0, import_service_utils.hasOwnDefined)(changes, "fieldComponent")) {
+    let effectiveInnerFieldUse = innerField == null ? void 0 : innerField.use;
+    let fieldTypeResolution;
+    let relationTitleFieldToApply;
+    if ((0, import_service_utils.hasOwnDefined)(changes, "fieldType") || (0, import_service_utils.hasOwnDefined)(changes, "fields") || (0, import_service_utils.hasOwnDefined)(changes, "selectorFields") || (0, import_service_utils.hasOwnDefined)(changes, "titleField") || (0, import_service_utils.hasOwnDefined)(changes, "openMode") || (0, import_service_utils.hasOwnDefined)(changes, "popupSize") || (0, import_service_utils.hasOwnDefined)(changes, "pageSize") || (0, import_service_utils.hasOwnDefined)(changes, "showIndex")) {
       if (!innerUid) {
         (0, import_errors.throwConflict)(
           `flowSurfaces configure field wrapper '${current == null ? void 0 : current.use}' cannot resolve inner field`,
           "FLOW_SURFACE_INNER_FIELD_MISSING"
         );
       }
+      const fieldSource = this.resolveFieldComponentFieldSource(current, normalizedBinding);
+      const currentPublicFieldType = (0, import_field_type_resolver.getPublicFieldTypeForUse)(
+        ((_k = (_j = innerField == null ? void 0 : innerField.stepParams) == null ? void 0 : _j.fieldBinding) == null ? void 0 : _k.use) || (innerField == null ? void 0 : innerField.use)
+      );
+      const shouldApplyResolverDefaults = (0, import_service_utils.hasOwnDefined)(changes, "fieldType") && changes.fieldType !== currentPublicFieldType;
+      fieldTypeResolution = (0, import_field_type_resolver.resolveRelationFieldType)({
+        fieldType: (0, import_service_utils.hasOwnDefined)(changes, "fieldType") ? changes.fieldType : currentPublicFieldType,
+        containerUse: current == null ? void 0 : current.use,
+        field: fieldSource.field,
+        dataSourceKey: (_l = fieldSource.fieldSettingsInit) == null ? void 0 : _l.dataSourceKey,
+        getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName),
+        fields: changes.fields,
+        selectorFields: changes.selectorFields,
+        titleField: (0, import_service_utils.hasOwnDefined)(wrapperChanges, "titleField") ? wrapperChanges.titleField : void 0,
+        openMode: (0, import_service_utils.hasOwnDefined)(changes, "openMode") ? changes.openMode : void 0,
+        popupSize: (0, import_service_utils.hasOwnDefined)(changes, "popupSize") ? changes.popupSize : void 0,
+        pageSize: (0, import_service_utils.hasOwnDefined)(changes, "pageSize") ? changes.pageSize : void 0,
+        showIndex: (0, import_service_utils.hasOwnDefined)(changes, "showIndex") ? changes.showIndex : void 0,
+        applyDefaults: shouldApplyResolverDefaults,
+        context: "configure"
+      });
+      if (!fieldTypeResolution) {
+        (0, import_errors.throwBadRequest)("flowSurfaces configure fieldType is required when configuring relation fields");
+      }
+      const shouldApplyFieldTypeDefaults = shouldApplyResolverDefaults;
+      const shouldApplyRelationTitleField = (0, import_service_utils.hasOwnDefined)(wrapperChanges, "titleField") || shouldApplyFieldTypeDefaults;
+      relationTitleFieldToApply = shouldApplyRelationTitleField ? fieldTypeResolution.titleField : void 0;
       const normalizedFieldComponentUse = await this.rebuildFieldSubModelOnServer({
         wrapperNode: current,
         innerField,
-        targetFieldUse: changes.fieldComponent,
+        targetFieldUse: fieldTypeResolution.fieldUse,
         normalizedBinding,
         enabledPackages,
         transaction: options.transaction
       });
-      await this.syncFieldComponentStepParams(current, normalizedFieldComponentUse, options.transaction);
+      effectiveInnerFieldUse = normalizedFieldComponentUse;
+      await this.syncFieldTypeStepParams(current, normalizedFieldComponentUse, options.transaction);
+      await this.applyResolvedRelationFieldType({
+        fieldUid: innerUid,
+        fieldUse: normalizedFieldComponentUse,
+        targetCollection: fieldTypeResolution.targetCollection,
+        relationFieldInit: fieldSource.fieldSettingsInit,
+        fields: (0, import_service_utils.hasOwnDefined)(changes, "fields") || shouldApplyFieldTypeDefaults ? fieldTypeResolution.fields : void 0,
+        selectorFields: (0, import_service_utils.hasOwnDefined)(changes, "selectorFields") || shouldApplyFieldTypeDefaults ? fieldTypeResolution.selectorFields : void 0,
+        titleField: relationTitleFieldToApply,
+        openMode: fieldTypeResolution.openMode,
+        popupSize: fieldTypeResolution.popupSize,
+        pageSize: fieldTypeResolution.pageSize,
+        showIndex: fieldTypeResolution.showIndex,
+        transaction: options.transaction
+      });
     }
-    if (shouldSyncTitleField) {
+    const effectiveSyncedTitleField = relationTitleFieldToApply ?? syncedTitleField;
+    if ((shouldSyncTitleField || !import_lodash.default.isUndefined(relationTitleFieldToApply)) && this.supportsFieldTitleFieldProp(effectiveInnerFieldUse)) {
       if (!innerUid) {
         (0, import_errors.throwConflict)(
           `flowSurfaces configure field wrapper '${current == null ? void 0 : current.use}' cannot resolve inner field`,
@@ -10956,7 +11350,7 @@ class FlowSurfacesService {
             uid: innerUid
           },
           props: {
-            titleField: syncedTitleField
+            titleField: effectiveSyncedTitleField
           }
         },
         options
@@ -11024,6 +11418,7 @@ class FlowSurfacesService {
     });
     const shouldSyncTitleField = titleFieldSyncDecision.shouldSync;
     const syncedTitleField = titleFieldSyncDecision.titleField;
+    const canSyncInnerTitleField = this.supportsFieldTitleFieldProp(current == null ? void 0 : current.use);
     if ((parentWrapper == null ? void 0 : parentWrapper.uid) && canSyncWrapperTitleField && shouldSyncTitleField) {
       await this.updateSettings(
         {
@@ -11086,7 +11481,7 @@ class FlowSurfacesService {
           quickCreate: changes.quickCreate,
           displayStyle: changes.displayStyle,
           options: changes.options,
-          ...shouldSyncTitleField ? { titleField: syncedTitleField } : {},
+          ...shouldSyncTitleField && canSyncInnerTitleField ? { titleField: syncedTitleField } : {},
           ...(0, import_service_utils.hasOwnDefined)(changes, "clickToOpen") || !import_lodash.default.isUndefined(changes.openView) ? { clickToOpen: effectiveClickToOpen } : {}
         }),
         stepParams: (0, import_service_utils.buildDefinedPayload)({
@@ -11153,6 +11548,7 @@ class FlowSurfacesService {
     return import_lodash.default.cloneDeep(value);
   }
   async configureActionNode(target, use, changes, options) {
+    changes = await this.normalizeActionPanelActionChanges(changes, options);
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)(use);
     (0, import_service_utils.assertSupportedSimpleChanges)("action", changes, allowedKeys);
     const normalizedDefaultFilter = (0, import_service_utils.hasOwnDefined)(changes, "defaultFilter") ? this.normalizeFilterActionDefaultFilterValue(changes.defaultFilter) : void 0;
@@ -11375,6 +11771,21 @@ class FlowSurfacesService {
       }
     );
   }
+  async normalizeActionPanelActionChanges(changes, options) {
+    var _a;
+    if (!(0, import_service_utils.hasOwnDefined)(changes, "type") || !((_a = options.current) == null ? void 0 : _a.uid)) {
+      return changes;
+    }
+    const parentUid = options.current.parentId || await this.locator.findParentUid(options.current.uid, options.transaction);
+    const parentNode = parentUid ? await this.repository.findModelById(parentUid, {
+      transaction: options.transaction,
+      includeAsyncNode: true
+    }) : null;
+    if ((parentNode == null ? void 0 : parentNode.use) !== "ActionPanelBlockModel") {
+      return changes;
+    }
+    return import_lodash.default.omit(changes, ["type"]);
+  }
   async buildFieldCatalog(target, options = {}) {
     const resolved = await this.locator.resolve(target, { transaction: options.transaction });
     const container = await this.surfaceContext.resolveFieldContainer(resolved.uid, options.transaction).catch(() => null);
@@ -11532,7 +11943,7 @@ class FlowSurfacesService {
         continue;
       }
       const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
-      if (import_field_semantics.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
+      if (import_association_interfaces.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
         continue;
       }
       const associationFieldName = (0, import_service_helpers.getFieldName)(field);
@@ -11856,6 +12267,222 @@ class FlowSurfacesService {
     }
     return null;
   }
+  assertNoTreeConnectFieldsFlowRegistry(node, flowRegistry, actionName) {
+    if ((node == null ? void 0 : node.use) !== "TreeBlockModel" || !import_lodash.default.isPlainObject(flowRegistry) || !Object.prototype.hasOwnProperty.call(flowRegistry, "connectFields")) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} tree connectFields is not a flowRegistry key; use configure changes.connectFields`
+    );
+  }
+  normalizeTreeConnectFields(value, actionName) {
+    if (!import_lodash.default.isPlainObject(value)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields must be an object`);
+    }
+    if (!Array.isArray(value.targets)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields.targets must be an array`);
+    }
+    const seenTargetBlockUids = /* @__PURE__ */ new Set();
+    return value.targets.map((target, targetIndex) => {
+      if (!import_lodash.default.isPlainObject(target)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields.targets[${targetIndex}] must be an object`);
+      }
+      const targetBlockUid = String(target.targetId || target.targetBlockUid || "").trim();
+      if (!targetBlockUid) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields.targets[${targetIndex}] requires targetId`);
+      }
+      if (seenTargetBlockUids.has(targetBlockUid)) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} tree connectFields.targets[${targetIndex}] duplicate targetId '${targetBlockUid}'`
+        );
+      }
+      seenTargetBlockUids.add(targetBlockUid);
+      let filterPaths;
+      if ((0, import_service_utils.hasOwnDefined)(target, "filterPaths")) {
+        if (!Array.isArray(target.filterPaths) || !target.filterPaths.length) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces ${actionName} tree connectFields.targets[${targetIndex}].filterPaths must be a non-empty string array`
+          );
+        }
+        filterPaths = target.filterPaths.map((path, pathIndex) => {
+          if (typeof path !== "string" || !path.trim()) {
+            (0, import_errors.throwBadRequest)(
+              `flowSurfaces ${actionName} tree connectFields.targets[${targetIndex}].filterPaths[${pathIndex}] must be a non-empty string`
+            );
+          }
+          return (0, import_service_helpers.normalizeFieldPath)(path);
+        });
+      }
+      return {
+        targetBlockUid,
+        ...filterPaths ? { filterPaths } : {}
+      };
+    });
+  }
+  getDataBlockResourceInit(blockNode) {
+    if ((blockNode == null ? void 0 : blockNode.use) === "ChartBlockModel") {
+      return (0, import_chart_config.getChartBuilderResourceInit)(import_lodash.default.get(blockNode, ["stepParams", "chartSettings", "configure"]));
+    }
+    const init = import_lodash.default.cloneDeep(import_lodash.default.get(blockNode, ["stepParams", "resourceSettings", "init"]) || {});
+    if (init.collectionName && !init.dataSourceKey) {
+      init.dataSourceKey = "main";
+    }
+    return init;
+  }
+  getTreeSelectedKeyFieldPath(treeNode, treeCollection) {
+    const configuredKey = String(import_lodash.default.get(treeNode, ["props", "fieldNames", "key"]) || "").trim();
+    return configuredKey ? (0, import_service_helpers.normalizeFieldPath)(configuredKey) : this.getCollectionFilterTargetKey(treeCollection);
+  }
+  normalizeTreeConnectFilterPaths(input) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const treeDataSourceKey = String(((_a = input.treeResourceInit) == null ? void 0 : _a.dataSourceKey) || "main").trim();
+    const treeCollectionName = String(((_b = input.treeResourceInit) == null ? void 0 : _b.collectionName) || "").trim();
+    const targetDataSourceKey = String(((_c = input.targetResourceInit) == null ? void 0 : _c.dataSourceKey) || "main").trim();
+    const targetCollectionName = String(((_d = input.targetResourceInit) == null ? void 0 : _d.collectionName) || "").trim();
+    if (!treeCollectionName) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${input.actionName} tree block '${((_e = input.treeNode) == null ? void 0 : _e.uid) || "unknown"}' requires resource.collectionName`
+      );
+    }
+    if (!targetCollectionName) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${input.actionName} tree connectFields target '${((_f = input.targetNode) == null ? void 0 : _f.uid) || "unknown"}' requires resource.collectionName`
+      );
+    }
+    const targetCollection = this.getCollection(targetDataSourceKey, targetCollectionName);
+    if (!targetCollection) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${input.actionName} tree connectFields target collection '${targetDataSourceKey}.${targetCollectionName}' not found`
+      );
+    }
+    const treeCollection = this.getCollection(treeDataSourceKey, treeCollectionName);
+    if (!treeCollection) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${input.actionName} tree connectFields source collection '${treeDataSourceKey}.${treeCollectionName}' not found`
+      );
+    }
+    const isSameCollection = treeDataSourceKey === targetDataSourceKey && treeCollectionName === targetCollectionName;
+    const normalizedPaths = input.filterPaths && input.filterPaths.length ? input.filterPaths : isSameCollection ? [this.getCollectionFilterTargetKey(targetCollection)] : void 0;
+    if (!(normalizedPaths == null ? void 0 : normalizedPaths.length)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${input.actionName} tree connectFields target '${((_g = input.targetNode) == null ? void 0 : _g.uid) || "unknown"}' requires filterPaths when target collection differs from tree collection`
+      );
+    }
+    const filterTargetKey = this.getCollectionFilterTargetKey(targetCollection);
+    const treeKeyFieldPath = this.getTreeSelectedKeyFieldPath(input.treeNode, treeCollection);
+    const treeKeyField = this.resolveTreeConnectComparableField(treeCollection, treeKeyFieldPath);
+    const treeKeyKind = this.normalizeTreeConnectValueKind(treeKeyField);
+    return normalizedPaths.map((fieldPath) => {
+      const normalizedFieldPath = (0, import_service_helpers.normalizeFieldPath)(fieldPath);
+      const isBuiltInTargetPath = normalizedFieldPath === "id" || normalizedFieldPath === filterTargetKey;
+      const targetField = this.resolveTreeConnectComparableField(targetCollection, normalizedFieldPath);
+      if (!isBuiltInTargetPath && !targetField) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${input.actionName} tree connectFields filterPaths '${normalizedFieldPath}' does not exist on target collection '${targetDataSourceKey}.${targetCollectionName}'`
+        );
+      }
+      const targetKind = this.normalizeTreeConnectValueKind(targetField);
+      if (treeKeyKind && targetKind && treeKeyKind !== targetKind) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${input.actionName} tree connectFields filterPaths '${normalizedFieldPath}' is not type-compatible with tree selected key '${treeKeyFieldPath}'`
+        );
+      }
+      return normalizedFieldPath;
+    });
+  }
+  resolveTreeConnectComparableField(collection, fieldPath) {
+    const normalizedFieldPath = (0, import_service_helpers.normalizeFieldPath)(fieldPath);
+    const resolvedField = (0, import_service_helpers.resolveFieldFromCollection)(collection, normalizedFieldPath);
+    if (resolvedField) {
+      return resolvedField;
+    }
+    if (normalizedFieldPath === "id") {
+      return {
+        name: "id",
+        type: "bigInt",
+        interface: "integer"
+      };
+    }
+    return null;
+  }
+  normalizeTreeConnectValueKind(field) {
+    const fieldType = String((0, import_service_helpers.getFieldType)(field) || "").trim().toLowerCase();
+    const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim().toLowerCase();
+    if (["bigint", "integer", "int", "number", "float", "double", "decimal", "real"].includes(fieldType) || ["bigint", "integer", "number", "percent"].includes(fieldInterface)) {
+      return "number";
+    }
+    if (["string", "text", "uid", "uuid", "varchar", "char"].includes(fieldType) || ["input", "textarea", "select", "radiogroup", "url", "email", "phone"].includes(fieldInterface)) {
+      return "string";
+    }
+    if (["date", "datetime", "time"].includes(fieldType) || ["date", "datetime", "time"].includes(fieldInterface)) {
+      return "date";
+    }
+    if (fieldType === "boolean" || fieldInterface === "boolean") {
+      return "boolean";
+    }
+    return void 0;
+  }
+  async persistTreeConnectFields(treeNode, connectFields, actionName, transaction) {
+    if ((treeNode == null ? void 0 : treeNode.use) !== "TreeBlockModel" || !(treeNode == null ? void 0 : treeNode.uid)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} connectFields is only supported on tree blocks`);
+    }
+    const targets = this.normalizeTreeConnectFields(connectFields, actionName);
+    const blockGrid = await this.findOwningBlockGrid(treeNode.uid, transaction);
+    if (!(blockGrid == null ? void 0 : blockGrid.uid)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree block '${treeNode.uid}' is not under a block grid`);
+    }
+    const treeResourceInit = this.getDataBlockResourceInit(treeNode);
+    const nextBindings = [];
+    for (const target of targets) {
+      if (target.targetBlockUid === treeNode.uid) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields targetId cannot be the tree block itself`);
+      }
+      const targetNode = await this.repository.findModelById(target.targetBlockUid, {
+        transaction,
+        includeAsyncNode: true
+      });
+      if (!(targetNode == null ? void 0 : targetNode.uid)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} tree connectFields targetId '${target.targetBlockUid}' not found`);
+      }
+      if (!TREE_CONNECT_TARGET_BLOCK_USES.has(targetNode.use || "")) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} target '${target.targetBlockUid}' does not support tree connectFields`
+        );
+      }
+      const targetGrid = await this.findOwningBlockGrid(targetNode.uid, transaction);
+      if ((targetGrid == null ? void 0 : targetGrid.uid) !== blockGrid.uid) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} tree connectFields target '${target.targetBlockUid}' must be in the same block grid`
+        );
+      }
+      const targetResourceInit = this.getDataBlockResourceInit(targetNode);
+      nextBindings.push({
+        filterId: treeNode.uid,
+        targetId: targetNode.uid,
+        filterPaths: this.normalizeTreeConnectFilterPaths({
+          actionName,
+          treeNode,
+          treeResourceInit,
+          targetNode,
+          targetResourceInit,
+          filterPaths: target.filterPaths
+        })
+      });
+    }
+    const currentConfigs = import_lodash.default.castArray(blockGrid.filterManager || []);
+    const nextConfigs = currentConfigs.filter((config) => (config == null ? void 0 : config.filterId) !== treeNode.uid);
+    nextConfigs.push(...nextBindings);
+    if (import_lodash.default.isEqual(nextConfigs, currentConfigs)) {
+      return;
+    }
+    await this.repository.patch(
+      {
+        uid: blockGrid.uid,
+        filterManager: nextConfigs
+      },
+      { transaction }
+    );
+  }
   isFilterFormFieldPathAvailableForResource(resourceInit, fieldPath, associationPathName) {
     if (!(resourceInit == null ? void 0 : resourceInit.dataSourceKey) || !(resourceInit == null ? void 0 : resourceInit.collectionName) || !fieldPath) {
       return false;
@@ -11886,7 +12513,7 @@ class FlowSurfacesService {
       { transaction }
     );
   }
-  async removeFilterFormConnectConfig(filterModelUid, transaction) {
+  async removeFilterSourceBindings(filterModelUid, transaction) {
     const blockGrid = await this.findOwningBlockGrid(filterModelUid, transaction);
     if (!(blockGrid == null ? void 0 : blockGrid.uid)) {
       return;
@@ -11904,7 +12531,7 @@ class FlowSurfacesService {
       { transaction }
     );
   }
-  async removeFilterFormTargetBindings(targetBlockUid, transaction) {
+  async removeFilterTargetBindings(targetBlockUid, transaction) {
     const blockGrid = await this.findOwningBlockGrid(targetBlockUid, transaction);
     if (!(blockGrid == null ? void 0 : blockGrid.uid)) {
       return;
@@ -12005,7 +12632,7 @@ class FlowSurfacesService {
     const fieldInit = import_lodash.default.get(node, ["stepParams", "fieldSettings", "init"]) || {};
     const defaultTargetUid = import_lodash.default.get(node, ["stepParams", "filterFormItemSettings", "init", "defaultTargetUid"]);
     if (!(fieldInit == null ? void 0 : fieldInit.fieldPath) || !defaultTargetUid) {
-      await this.removeFilterFormConnectConfig(node.uid, transaction);
+      await this.removeFilterSourceBindings(node.uid, transaction);
       return;
     }
     const parentUid = await this.locator.findParentUid(node.uid, transaction);
@@ -12020,7 +12647,7 @@ class FlowSurfacesService {
       if (!options.skipIfTargetUnavailable) {
         throw error;
       }
-      await this.removeFilterFormConnectConfig(node.uid, transaction);
+      await this.removeFilterSourceBindings(node.uid, transaction);
       return null;
     });
     if (!target) {
@@ -12031,7 +12658,7 @@ class FlowSurfacesService {
       fieldInit.fieldPath,
       fieldInit.associationPathName
     )) {
-      await this.removeFilterFormConnectConfig(node.uid, transaction);
+      await this.removeFilterSourceBindings(node.uid, transaction);
       return;
     }
     await this.persistFilterFormConnectConfig(
@@ -13730,6 +14357,19 @@ class FlowSurfacesService {
     );
     return (0, import_service_helpers.resolveFieldFromCollection)(targetCollection, titleFieldName) || input.field;
   }
+  supportsFieldTitleFieldProp(use) {
+    return (0, import_configure_options.getConfigureOptionKeysForUse)(use).includes("titleField");
+  }
+  normalizeFieldPropsForUse(use, props) {
+    const normalizedProps = import_lodash.default.cloneDeep(props || {});
+    if (this.supportsFieldTitleFieldProp(use)) {
+      return normalizedProps;
+    }
+    if (Object.prototype.hasOwnProperty.call(normalizedProps, "titleField")) {
+      delete normalizedProps.titleField;
+    }
+    return normalizedProps;
+  }
   async ensureGridChild(parentUid, use, transaction) {
     const existing = await this.repository.findModelByParentId(parentUid, {
       transaction,
@@ -13909,7 +14549,7 @@ class FlowSurfacesService {
     );
     const associationInterface = (0, import_service_helpers.getFieldInterface)(parsed.associationField);
     const leafField = (0, import_service_helpers.resolveFieldFromCollection)(parsed.leafCollection, parsed.leafFieldPath);
-    const shouldBindAssociationValue = DISPLAY_FIELD_WRAPPER_USES.has(input.wrapperUse || "") && !!parsed.associationPathName && parsed.fieldPath !== parsed.associationPathName && import_field_semantics.MULTI_VALUE_ASSOCIATION_INTERFACES.has(associationInterface || "");
+    const shouldBindAssociationValue = DISPLAY_FIELD_WRAPPER_USES.has(input.wrapperUse || "") && !!parsed.associationPathName && parsed.fieldPath !== parsed.associationPathName && import_association_interfaces.MULTI_VALUE_ASSOCIATION_INTERFACES.has(associationInterface || "");
     if (shouldBindAssociationValue) {
       const associationFieldPath = parsed.associationPathName;
       if (!associationFieldPath) {
@@ -13951,6 +14591,382 @@ class FlowSurfacesService {
       usesAssociationValueBinding: false
     };
   }
+  getCollectionFieldOrBadRequest(collection, fieldPath, context) {
+    const field = (0, import_service_helpers.resolveFieldFromCollection)(collection, fieldPath);
+    if (!field) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${context} field '${fieldPath}' does not exist on relation target collection`);
+    }
+    return field;
+  }
+  buildRelationTargetFieldInit(input) {
+    var _a, _b, _c, _d, _e, _f;
+    const relationFieldPath = (0, import_service_helpers.normalizeFieldPath)(
+      (_a = input.relationFieldInit) == null ? void 0 : _a.fieldPath,
+      (_b = input.relationFieldInit) == null ? void 0 : _b.associationPathName
+    );
+    if (!relationFieldPath) {
+      return (0, import_service_utils.buildDefinedPayload)({
+        dataSourceKey: ((_c = input.targetCollection) == null ? void 0 : _c.dataSourceKey) || "main",
+        collectionName: (0, import_service_helpers.getCollectionName)(input.targetCollection),
+        fieldPath: input.targetFieldPath
+      });
+    }
+    const targetAssociationPath = input.targetFieldPath.includes(".") ? input.targetFieldPath.split(".").slice(0, -1).join(".") : void 0;
+    return (0, import_service_utils.buildDefinedPayload)({
+      dataSourceKey: ((_d = input.relationFieldInit) == null ? void 0 : _d.dataSourceKey) || ((_e = input.targetCollection) == null ? void 0 : _e.dataSourceKey) || "main",
+      collectionName: ((_f = input.relationFieldInit) == null ? void 0 : _f.collectionName) || (0, import_service_helpers.getCollectionName)(input.targetCollection),
+      fieldPath: `${relationFieldPath}.${input.targetFieldPath}`,
+      associationPathName: targetAssociationPath ? `${relationFieldPath}.${targetAssociationPath}` : void 0
+    });
+  }
+  buildRelationTargetTableColumnNode(input) {
+    const field = this.getCollectionFieldOrBadRequest(input.collection, input.fieldPath, "fieldType.fields");
+    const fieldUse = input.columnUse === "SubTableColumnModel" ? (0, import_service_helpers.inferFieldMenuEditableFieldUse)((0, import_service_helpers.getFieldInterface)(field)) || "InputFieldModel" : (0, import_service_helpers.inferAssociationLeafDisplayFieldUse)((0, import_service_helpers.getFieldInterface)(field)) || "DisplayTextFieldModel";
+    const title = (0, import_service_helpers.getFieldTitle)(field);
+    const fieldInit = this.buildRelationTargetFieldInit({
+      targetCollection: input.collection,
+      targetFieldPath: input.fieldPath,
+      relationFieldInit: input.relationFieldInit
+    });
+    return {
+      uid: (0, import_utils.uid)(),
+      use: input.columnUse,
+      props: (0, import_service_utils.buildDefinedPayload)({
+        title,
+        dataIndex: (0, import_service_helpers.getFieldName)(field)
+      }),
+      stepParams: {
+        fieldSettings: {
+          init: fieldInit
+        },
+        ...input.columnUse === "TableColumnModel" ? {
+          tableColumnSettings: {
+            title: {
+              title
+            }
+          }
+        } : {}
+      },
+      subModels: {
+        field: {
+          uid: (0, import_utils.uid)(),
+          use: fieldUse,
+          props: this.normalizeFieldPropsForUse(
+            fieldUse,
+            (0, import_service_utils.getFieldBindingDefaultProps)("TableColumnModel", fieldUse, field)
+          ),
+          stepParams: {
+            fieldSettings: {
+              init: fieldInit
+            },
+            fieldBinding: {
+              use: fieldUse
+            }
+          }
+        }
+      }
+    };
+  }
+  buildRelationTargetGridItemNode(input) {
+    const field = this.getCollectionFieldOrBadRequest(input.collection, input.fieldPath, "fieldType.fields");
+    const fieldUse = input.wrapperUse === "FormItemModel" ? (0, import_service_helpers.inferFieldMenuEditableFieldUse)((0, import_service_helpers.getFieldInterface)(field)) || "InputFieldModel" : (0, import_service_helpers.inferAssociationLeafDisplayFieldUse)((0, import_service_helpers.getFieldInterface)(field)) || "DisplayTextFieldModel";
+    const title = (0, import_service_helpers.getFieldTitle)(field);
+    const fieldInit = this.buildRelationTargetFieldInit({
+      targetCollection: input.collection,
+      targetFieldPath: input.fieldPath,
+      relationFieldInit: input.relationFieldInit
+    });
+    return {
+      uid: (0, import_utils.uid)(),
+      use: input.wrapperUse,
+      props: (0, import_service_utils.buildDefinedPayload)({
+        label: title
+      }),
+      stepParams: {
+        fieldSettings: {
+          init: fieldInit
+        }
+      },
+      subModels: {
+        field: {
+          uid: (0, import_utils.uid)(),
+          use: fieldUse,
+          props: this.normalizeFieldPropsForUse(
+            fieldUse,
+            (0, import_service_utils.getFieldBindingDefaultProps)(input.wrapperUse, fieldUse, field)
+          ),
+          stepParams: {
+            fieldSettings: {
+              init: fieldInit
+            },
+            fieldBinding: {
+              use: fieldUse
+            }
+          }
+        }
+      }
+    };
+  }
+  async replaceFieldSubModelArray(input) {
+    var _a, _b;
+    const parentNode = await this.repository.findModelById(input.parentUid, {
+      transaction: input.transaction,
+      includeAsyncNode: true
+    });
+    const keptChildren = [];
+    for (const child of import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a[input.subKey]) || [])) {
+      if (!(child == null ? void 0 : child.uid)) {
+        continue;
+      }
+      if ((_b = input.keepUses) == null ? void 0 : _b.includes(child.use)) {
+        keptChildren.push(child);
+        continue;
+      }
+      await this.removeNodeTreeWithBindings(child.uid, input.transaction);
+    }
+    for (const child of keptChildren.reverse()) {
+      await this.repository.attach(
+        child.uid,
+        {
+          parentId: input.parentUid,
+          subKey: input.subKey,
+          subType: "array",
+          position: "first"
+        },
+        { transaction: input.transaction }
+      );
+    }
+    for (const child of input.children) {
+      await this.repository.upsertModel(
+        {
+          parentId: input.parentUid,
+          subKey: input.subKey,
+          subType: "array",
+          ...child
+        },
+        { transaction: input.transaction }
+      );
+    }
+  }
+  buildPopupSubTableActionsColumnNode(existing) {
+    var _a, _b;
+    const defaultActionColumn = import_lodash.default.cloneDeep(
+      (_b = (_a = (0, import_builder.getStandaloneFieldDefaults)("PopupSubTableFieldModel").subModels) == null ? void 0 : _a.subTableColumns) == null ? void 0 : _b[0]
+    );
+    return {
+      ...defaultActionColumn || {
+        use: "PopupSubTableActionsColumnModel"
+      },
+      ...existing || {},
+      uid: (existing == null ? void 0 : existing.uid) || (defaultActionColumn == null ? void 0 : defaultActionColumn.uid) || (0, import_utils.uid)()
+    };
+  }
+  async ensureFieldGridSubModel(input) {
+    var _a;
+    const fieldNode = await this.repository.findModelById(input.fieldUid, {
+      transaction: input.transaction,
+      includeAsyncNode: true
+    });
+    const existingGrid = (_a = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _a.grid;
+    if (existingGrid == null ? void 0 : existingGrid.uid) {
+      return existingGrid.uid;
+    }
+    const gridUid = (0, import_utils.uid)();
+    await this.repository.upsertModel(
+      {
+        uid: gridUid,
+        parentId: input.fieldUid,
+        subKey: "grid",
+        subType: "object",
+        use: input.gridUse
+      },
+      { transaction: input.transaction }
+    );
+    return gridUid;
+  }
+  async applyResolvedRelationFieldType(input) {
+    var _a;
+    if (input.titleField || !import_lodash.default.isUndefined(input.pageSize) || !import_lodash.default.isUndefined(input.showIndex)) {
+      const fieldNode = await this.repository.findModelById(input.fieldUid, {
+        transaction: input.transaction,
+        includeAsyncNode: true
+      });
+      const props = (0, import_service_utils.buildDefinedPayload)({
+        ...input.titleField && this.supportsFieldTitleFieldProp(input.fieldUse) ? { titleField: input.titleField } : {},
+        pageSize: input.pageSize,
+        showIndex: input.showIndex
+      });
+      if (Object.keys(props).length) {
+        await this.repository.patch(
+          {
+            uid: input.fieldUid,
+            props: {
+              ...(fieldNode == null ? void 0 : fieldNode.props) || {},
+              ...props
+            }
+          },
+          { transaction: input.transaction }
+        );
+      }
+    }
+    const fields = input.fields;
+    if ((0, import_field_type_resolver.usesNestedRelationFields)(input.fieldUse) && fields) {
+      if (["SubTableFieldModel", "DisplaySubTableFieldModel"].includes(input.fieldUse)) {
+        await this.replaceFieldSubModelArray({
+          parentUid: input.fieldUid,
+          subKey: "columns",
+          children: fields.map(
+            (fieldPath) => this.buildRelationTargetTableColumnNode({
+              collection: input.targetCollection,
+              fieldPath,
+              columnUse: input.fieldUse === "SubTableFieldModel" ? "SubTableColumnModel" : "TableColumnModel",
+              relationFieldInit: input.relationFieldInit
+            })
+          ),
+          transaction: input.transaction
+        });
+      } else if (input.fieldUse === "PopupSubTableFieldModel") {
+        const fieldNode = await this.repository.findModelById(input.fieldUid, {
+          transaction: input.transaction,
+          includeAsyncNode: true
+        });
+        const existingActionsColumn = import_lodash.default.castArray(((_a = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _a.subTableColumns) || []).find(
+          (item) => (item == null ? void 0 : item.use) === "PopupSubTableActionsColumnModel"
+        );
+        await this.replaceFieldSubModelArray({
+          parentUid: input.fieldUid,
+          subKey: "subTableColumns",
+          children: [
+            this.buildPopupSubTableActionsColumnNode(existingActionsColumn),
+            ...fields.map(
+              (fieldPath) => this.buildRelationTargetTableColumnNode({
+                collection: input.targetCollection,
+                fieldPath,
+                columnUse: "TableColumnModel",
+                relationFieldInit: input.relationFieldInit
+              })
+            )
+          ],
+          transaction: input.transaction
+        });
+      } else {
+        const gridUse = ["SubFormFieldModel", "SubFormListFieldModel"].includes(input.fieldUse) ? "FormGridModel" : "DetailsGridModel";
+        const wrapperUse = ["SubFormFieldModel", "SubFormListFieldModel"].includes(input.fieldUse) ? "FormItemModel" : "DetailsItemModel";
+        const gridUid = await this.ensureFieldGridSubModel({
+          fieldUid: input.fieldUid,
+          gridUse,
+          transaction: input.transaction
+        });
+        await this.replaceFieldSubModelArray({
+          parentUid: gridUid,
+          subKey: "items",
+          children: fields.map(
+            (fieldPath) => this.buildRelationTargetGridItemNode({
+              collection: input.targetCollection,
+              fieldPath,
+              wrapperUse,
+              relationFieldInit: input.relationFieldInit
+            })
+          ),
+          transaction: input.transaction
+        });
+      }
+    }
+    if (input.fieldUse === "RecordPickerFieldModel") {
+      await this.applyRecordPickerFieldTypeSettings(input);
+    }
+  }
+  async applyRecordPickerFieldTypeSettings(input) {
+    var _a, _b, _c;
+    const fieldNode = await this.repository.findModelById(input.fieldUid, {
+      transaction: input.transaction,
+      includeAsyncNode: true
+    });
+    const openView = (0, import_service_utils.buildDefinedPayload)({
+      mode: input.openMode,
+      size: input.popupSize,
+      pageModelClass: "ChildPageModel",
+      dataSourceKey: ((_a = input.targetCollection) == null ? void 0 : _a.dataSourceKey) || "main",
+      collectionName: (0, import_service_helpers.getCollectionName)(input.targetCollection)
+    });
+    if (Object.keys(openView).length > 2) {
+      await this.repository.patch(
+        {
+          uid: input.fieldUid,
+          stepParams: import_lodash.default.merge({}, (fieldNode == null ? void 0 : fieldNode.stepParams) || {}, {
+            popupSettings: {
+              openView
+            }
+          })
+        },
+        { transaction: input.transaction }
+      );
+    }
+    if (!input.selectorFields) {
+      return;
+    }
+    let grid = await this.repository.findModelByParentId(input.fieldUid, {
+      transaction: input.transaction,
+      subKey: "grid-block",
+      includeAsyncNode: true
+    });
+    if (!(grid == null ? void 0 : grid.uid)) {
+      const gridUid = (0, import_utils.uid)();
+      await this.repository.upsertModel(
+        {
+          uid: gridUid,
+          parentId: input.fieldUid,
+          subKey: "grid-block",
+          subType: "object",
+          use: "BlockGridModel"
+        },
+        { transaction: input.transaction }
+      );
+      grid = await this.repository.findModelById(gridUid, {
+        transaction: input.transaction,
+        includeAsyncNode: true
+      });
+    }
+    if (!(grid == null ? void 0 : grid.uid)) {
+      return;
+    }
+    const existingTable = import_lodash.default.castArray(((_b = grid == null ? void 0 : grid.subModels) == null ? void 0 : _b.items) || []).find(
+      (item) => (item == null ? void 0 : item.use) === "TableBlockModel"
+    );
+    const tableUid = (existingTable == null ? void 0 : existingTable.uid) || (0, import_utils.uid)();
+    if (!(existingTable == null ? void 0 : existingTable.uid)) {
+      await this.repository.upsertModel(
+        {
+          uid: tableUid,
+          parentId: grid.uid,
+          subKey: "items",
+          subType: "array",
+          use: "TableBlockModel",
+          stepParams: {
+            resourceSettings: {
+              init: {
+                dataSourceKey: ((_c = input.targetCollection) == null ? void 0 : _c.dataSourceKey) || "main",
+                collectionName: (0, import_service_helpers.getCollectionName)(input.targetCollection)
+              }
+            }
+          }
+        },
+        { transaction: input.transaction }
+      );
+    }
+    await this.replaceFieldSubModelArray({
+      parentUid: tableUid,
+      subKey: "columns",
+      children: input.selectorFields.map(
+        (fieldPath) => this.buildRelationTargetTableColumnNode({
+          collection: input.targetCollection,
+          fieldPath,
+          columnUse: "TableColumnModel"
+        })
+      ),
+      transaction: input.transaction
+    });
+  }
   buildExactFieldSettingsInitPayload(input) {
     return (0, import_service_utils.buildDefinedPayload)({
       dataSourceKey: input.dataSourceKey,
@@ -14058,7 +15074,7 @@ class FlowSurfacesService {
     const targetFieldUse = input.targetFieldUse;
     const normalizedTargetUse = String(targetFieldUse || "").trim();
     if (!normalizedTargetUse) {
-      (0, import_errors.throwBadRequest)("flowSurfaces configure fieldComponent cannot be empty");
+      (0, import_errors.throwBadRequest)("flowSurfaces configure fieldType cannot be empty");
     }
     const normalizedWrapperUse = String(wrapperUse || "").trim();
     const containerUse = normalizedWrapperUse === "FormAssociationItemModel" ? "DetailsItemModel" : normalizedWrapperUse;
@@ -14073,7 +15089,7 @@ class FlowSurfacesService {
         });
         if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.has(normalizedTargetUse))) {
           (0, import_errors.throwBadRequest)(
-            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldType '${normalizedTargetUse}'`
           );
         }
         return normalizedTargetUse;
@@ -14084,7 +15100,7 @@ class FlowSurfacesService {
       });
       if (!(contract == null ? void 0 : contract.fieldUse)) {
         (0, import_errors.throwBadRequest)(
-          `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+          `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldType '${normalizedTargetUse}'`
         );
       }
       return contract.fieldUse;
@@ -14100,7 +15116,7 @@ class FlowSurfacesService {
         });
         if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.has(normalizedTargetUse))) {
           (0, import_errors.throwBadRequest)(
-            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldType '${normalizedTargetUse}'`
           );
         }
         return normalizedTargetUse;
@@ -14111,19 +15127,22 @@ class FlowSurfacesService {
       });
       if (!(contract == null ? void 0 : contract.fieldUse)) {
         (0, import_errors.throwBadRequest)(
-          `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+          `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldType '${normalizedTargetUse}'`
         );
       }
       return contract.fieldUse;
     }
-    (0, import_errors.throwBadRequest)(`flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent`);
+    (0, import_errors.throwBadRequest)(`flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldType`);
   }
-  async syncFieldComponentStepParams(wrapperNode, targetFieldUse, transaction) {
+  async syncFieldTypeStepParams(wrapperNode, targetFieldUse, transaction) {
     const flowDomain = this.inferFieldComponentFlowDomain(wrapperNode == null ? void 0 : wrapperNode.use);
     if (!flowDomain || !(wrapperNode == null ? void 0 : wrapperNode.uid)) {
       return;
     }
-    const nextStepParams = import_lodash.default.merge({}, wrapperNode.stepParams || {}, {
+    const latestWrapper = await this.repository.findModelById(wrapperNode.uid, {
+      transaction
+    });
+    const nextStepParams = import_lodash.default.merge({}, (latestWrapper == null ? void 0 : latestWrapper.stepParams) || wrapperNode.stepParams || {}, {
       [flowDomain.flowKey]: {
         [flowDomain.stepKey]: {
           use: targetFieldUse
@@ -14139,7 +15158,7 @@ class FlowSurfacesService {
     );
   }
   async rebuildFieldSubModelOnServer(input) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const innerField = input.innerField;
     if (!(innerField == null ? void 0 : innerField.uid)) {
       (0, import_errors.throwConflict)(
@@ -14155,16 +15174,38 @@ class FlowSurfacesService {
       dataSourceKey: (_c = fieldSource.fieldSettingsInit) == null ? void 0 : _c.dataSourceKey,
       enabledPackages: input.enabledPackages
     });
+    if (innerField.use === normalizedTargetUse) {
+      await this.repository.patch(
+        {
+          uid: innerField.uid,
+          stepParams: import_lodash.default.merge({}, innerField.stepParams || {}, {
+            fieldBinding: {
+              use: normalizedTargetUse
+            },
+            fieldSettings: {
+              init: fieldSource.fieldSettingsInit
+            }
+          })
+        },
+        { transaction: input.transaction }
+      );
+      return normalizedTargetUse;
+    }
     const defaultProps = (0, import_service_utils.getFieldBindingDefaultProps)((_d = input.wrapperNode) == null ? void 0 : _d.use, normalizedTargetUse, fieldSource.field);
+    const fieldDefaults = (0, import_builder.getStandaloneFieldDefaults)(normalizedTargetUse);
     const shouldPreservePatternFormField = ((_e = input.wrapperNode) == null ? void 0 : _e.use) === "PatternFormItemModel";
+    const preservedPopupPageSubModel = ((_f = input.innerField) == null ? void 0 : _f.subModels) && Object.prototype.hasOwnProperty.call(input.innerField.subModels, "page") ? {
+      page: import_lodash.default.cloneDeep(input.innerField.subModels.page)
+    } : {};
+    const nextSubModels = {
+      ...fieldDefaults.subModels ? import_lodash.default.cloneDeep(fieldDefaults.subModels) : {},
+      ...preservedPopupPageSubModel
+    };
     const nextFieldNode = {
       uid: innerField.uid,
       use: shouldPreservePatternFormField ? "PatternFormFieldModel" : normalizedTargetUse,
       props: import_lodash.default.pickBy(
-        {
-          ...innerField.props || {},
-          ...defaultProps
-        },
+        this.normalizeFieldPropsForUse(normalizedTargetUse, { ...innerField.props || {}, ...defaultProps }),
         (value) => !import_lodash.default.isUndefined(value)
       ),
       decoratorProps: import_lodash.default.cloneDeep(innerField.decoratorProps || {}),
@@ -14176,7 +15217,8 @@ class FlowSurfacesService {
         fieldSettings: {
           init: fieldSource.fieldSettingsInit
         }
-      })
+      }),
+      subModels: nextSubModels
     };
     await this.repository.patch(nextFieldNode, { transaction: input.transaction });
     return normalizedTargetUse;