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

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",
@@ -293,6 +297,7 @@ const POPUP_COLLECTION_BLOCK_SCENES = {
   CommentsBlockModel: ["one", "many"],
   TableBlockModel: ["many"],
   CalendarBlockModel: ["many"],
+  TreeBlockModel: ["filter"],
   KanbanBlockModel: ["many"],
   ListBlockModel: ["many"],
   GridCardBlockModel: ["many"],
@@ -951,8 +956,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 +972,98 @@ 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;
+    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 (["SubTableFieldModel", "DisplaySubTableFieldModel"].includes(fieldUse)) {
+      return import_lodash.default.castArray(((_c = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _c.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);
+    }
+    if (fieldUse === "PopupSubTableFieldModel") {
+      return import_lodash.default.castArray(((_d = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _d.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;
+      }).filter(Boolean);
+    }
+    if (["SubFormFieldModel", "SubFormListFieldModel", "DisplaySubItemFieldModel", "DisplaySubListFieldModel"].includes(
+      fieldUse
+    )) {
+      return import_lodash.default.castArray(((_g = (_f = (_e = fieldNode == null ? void 0 : fieldNode.subModels) == null ? void 0 : _e.grid) == null ? void 0 : _f.subModels) == null ? void 0 : _g.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;
+      }).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),
@@ -3814,6 +3897,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 +3958,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 +4897,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 +4927,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 +4962,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 +5045,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 +5158,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 +5176,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 +5188,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 +5296,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 +5329,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 +5359,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 +5399,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 +5426,9 @@ class FlowSurfacesService {
       ),
       fieldProps: import_lodash.default.merge(
         {},
-        defaultFieldState.fieldProps || {},
+        normalizedDefaultFieldProps,
         fieldShouldPersistTitleField ? { titleField: defaultTitleField } : {},
-        values.fieldProps || {}
+        normalizedInlineFieldProps
       )
     });
     this.contractGuard.validateNodeTreeAgainstContract(tree.model);
@@ -5254,6 +5467,21 @@ class FlowSurfacesService {
       associationPathName: normalizedFieldBinding.associationPathName,
       fieldPath: normalizedFieldBinding.fieldPath
     };
+    if (relationFieldTypeResolution) {
+      await this.applyResolvedRelationFieldType({
+        fieldUid: tree.innerUid,
+        fieldUse: boundFieldCapability.fieldUse,
+        targetCollection: relationFieldTypeResolution.targetCollection,
+        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,
@@ -9374,6 +9602,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 +9638,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`);
     }
@@ -9950,6 +10196,61 @@ 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.buildBlockTitleDescriptionFromSemanticChanges)(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);
+    return 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 } : {}
+        }),
+        decoratorProps: (0, import_service_utils.buildDefinedPayload)({
+          height: changes.height,
+          heightMode: (0, import_service_utils.normalizePublicBlockHeightMode)(changes.heightMode)
+        }),
+        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
+    );
+  }
   async configureKanbanBlock(target, current, changes, options) {
     var _a;
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("KanbanBlockModel");
@@ -10818,10 +11119,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 +11168,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 +11204,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 +11241,69 @@ 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,
+        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 +11316,7 @@ class FlowSurfacesService {
             uid: innerUid
           },
           props: {
-            titleField: syncedTitleField
+            titleField: effectiveSyncedTitleField
           }
         },
         options
@@ -11024,6 +11384,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 +11447,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 +11514,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 +11737,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 +11909,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);
@@ -13730,6 +14107,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 +14299,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 +14341,357 @@ 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(collection, fieldPath) {
+    return (0, import_service_utils.buildDefinedPayload)({
+      dataSourceKey: (collection == null ? void 0 : collection.dataSourceKey) || "main",
+      collectionName: (0, import_service_helpers.getCollectionName)(collection),
+      fieldPath
+    });
+  }
+  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(input.collection, input.fieldPath);
+    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(input.collection, input.fieldPath);
+    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"
+            })
+          ),
+          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"
+              })
+            )
+          ],
+          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
+            })
+          ),
+          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 +14799,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 +14814,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 +14825,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 +14841,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 +14852,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 +14883,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 +14899,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 +14942,8 @@ class FlowSurfacesService {
         fieldSettings: {
           init: fieldSource.fieldSettingsInit
         }
-      })
+      }),
+      subModels: nextSubModels
     };
     await this.repository.patch(nextFieldNode, { transaction: input.transaction });
     return normalizedTargetUse;