@nocobase/plugin-flow-engine 2.1.0-alpha.40 → 2.1.0-alpha.46

package/dist/server/flow-surfaces/authoring-validation.js

@@ -59,6 +59,8 @@ var import_template_reference = require("./template-reference");
 var import_association_interfaces = require("./association-interfaces");
 var import_defaults = require("./blueprint/defaults");
 var import_runjs_authoring = require("./runjs-authoring");
+var import_configure_options = require("./configure-options");
+var import_filter_group = require("./filter-group");
 const MAIN_BLOCK_UNSUPPORTED_SECTIONS = {
   calendar: ["fields", "fieldGroups", "recordActions", "fieldsLayout"],
   kanban: ["fieldGroups", "recordActions", "fieldsLayout"],
@@ -71,6 +73,62 @@ const SORTABLE_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "details", "list"
 const CHART_BLOCK_TYPES = /* @__PURE__ */ new Set(["chart"]);
 const COMMENTS_PAGE_SIZE_VALUES = /* @__PURE__ */ new Set([5, 10, 20, 50, 100, 200]);
 const RECORD_HISTORY_INTERNAL_COLLECTIONS = /* @__PURE__ */ new Set(["recordHistories", "recordFieldHistories"]);
+const VISIBLE_FIELD_REQUIRED_DATA_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "table",
+  "list",
+  "gridCard",
+  "details",
+  "createForm",
+  "editForm",
+  "filterForm",
+  "kanban"
+]);
+const VISIBLE_FIELD_MINIMUM_DATA_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "details"]);
+const IMPLICIT_RELATION_TITLE_FIELD_DISPLAY_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "details"]);
+const IMPLICIT_RELATION_TITLE_FIELD_CONTAINER_USE_BY_BLOCK_TYPE = {
+  details: "DetailsItemModel",
+  gridCard: "GridCardItemModel",
+  list: "ListItemModel",
+  table: "TableColumnModel"
+};
+const RICH_COLLECTION_VISIBLE_FIELD_THRESHOLD = import_public_data_surface_default_filter.FLOW_SURFACE_DEFAULT_FILTER_REQUIRED_FIELD_COUNT * 2;
+const RICH_DATA_BLOCK_VISIBLE_FIELD_MINIMUM = 3;
+const NON_BUSINESS_VISIBLE_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "id",
+  "uid",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "createdBy",
+  "updatedBy",
+  "deletedBy",
+  "createdById",
+  "updatedById",
+  "deletedById",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+  "created_by",
+  "updated_by",
+  "deleted_by"
+]);
+const NON_BUSINESS_VISIBLE_FIELD_INTERFACES = /* @__PURE__ */ new Set([
+  "id",
+  "createdAt",
+  "updatedAt",
+  "createdBy",
+  "updatedBy",
+  "sort"
+]);
+const NON_BUSINESS_VISIBLE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "action",
+  "actions",
+  "button",
+  "divider",
+  "operation",
+  "operations",
+  "sort"
+]);
 const ANT_DESIGN_ICON_NAMES = new Set(Object.keys(antDesignIconAsn || {}));
 const PUBLIC_BLOCK_TYPE_BY_MODEL_USE = {
   TableBlockModel: "table",
@@ -106,12 +164,43 @@ const GRID_CARD_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([
   "sorting",
   "layout"
 ]);
+const TABLE_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([...(0, import_configure_options.getConfigureOptionKeysForUse)("TableBlockModel"), "sort"]);
+const TABLE_INTERNAL_AUTHORING_KEYS = ["tableSettings", "defaultSorting", "stepParams"];
+const TABLE_SETTINGS_REPAIR_HINT = "Use public table settings keys such as settings.pageSize, settings.sorting, settings.dataScope, settings.density, settings.showRowNumbers, settings.treeTable, settings.dragSort, and settings.dragSortBy. Do not nest persisted tableSettings/defaultSorting/stepParams payloads.";
 const JS_BLOCK_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["title", "description", "className", "code", "version"]);
 const JS_BLOCK_TOP_LEVEL_JS_KEYS = ["code", "version"];
 const JS_BLOCK_INTERNAL_AUTHORING_KEYS = ["props", "decoratorProps", "flowRegistry", "stepParams"];
+const JS_BLOCK_REPAIR_HINT = "This is a jsBlock payload shape problem. Repair this jsBlock using inline settings.code/settings.version, or applyBlueprint assets.scripts.<key>.code plus block.script. Do not change this block type to table, chart, actionPanel, gridCard, or another block type.";
+const CHART_REPAIR_HINT = "This is a chart payload shape problem. Keep using chart and repair this chart using assets.charts.<key>.query/visual plus block.chart, or localized settings.query/settings.visual. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type, and do not drop or defer the chart. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const REPAIR_ALL_ERRORS_AGENT_INSTRUCTION = "If this response contains errors[], fix every listed error in one payload revision before retrying the same write. Do not fix only this error and immediately retry.";
+const JS_BLOCK_AGENT_INSTRUCTION = `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Do not skip, drop, defer, or replace this required jsBlock. Repair it as jsBlock.`;
+const CHART_AGENT_INSTRUCTION = `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Do not skip, drop, defer, or replace this required chart. Repair it as chart.`;
+const VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT = "Add direct visible collection fields to this block. Do not rely on defaults.collections.*.fieldGroups, action-only fields, dividers, or generated popup/form defaults as a substitute for visible block fields.";
+const JS_BLOCK_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "chart",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop jsBlock",
+  "defer jsBlock"
+];
+const CHART_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "jsBlock",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop chart",
+  "defer chart"
+];
 const CHART_QUERY_MODE_SET = new Set(import_chart_config.CHART_QUERY_MODES);
 const CHART_VISUAL_MODE_SET = new Set(import_chart_config.CHART_VISUAL_MODES);
 const CHART_BASIC_VISUAL_TYPE_SET = new Set(import_chart_config.CHART_BASIC_VISUAL_TYPES);
+const CHART_BASIC_VISUAL_TYPE_LIST = import_chart_config.CHART_BASIC_VISUAL_TYPES.join(", ");
+const STRICT_LOCALIZED_CHART_ACTIONS = /* @__PURE__ */ new Set(["compose", "addBlocks"]);
 const CHART_VISUAL_LEGACY_BUILDER_KEYS = /* @__PURE__ */ new Set([
   "xField",
   "yField",
@@ -146,6 +235,7 @@ const CHART_SQL_QUERY_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
   "offset"
 ]);
 const CHART_CUSTOM_VISUAL_FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["type", "mappings", "style"]);
+const CHART_DEFAULT_DATA_SOURCE_KEY = "main";
 const JS_ITEM_COLLECTION_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "calendar", "kanban"]);
 const JS_ITEM_RECORD_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "details", "list", "gridCard"]);
 const JS_ITEM_FORM_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["createForm", "editForm"]);
@@ -264,6 +354,67 @@ const DEFAULT_POPUPS_ALLOWED_KEYS = ["view", "addNew", "edit", "associations"];
 const DEFAULT_POPUP_ACTION_ALLOWED_KEYS = ["name", "description"];
 const DEFAULT_POPUP_ASSOCIATION_ALLOWED_KEYS = ["view", "addNew", "edit"];
 const DEFAULT_POPUP_ACTIONS = ["view", "addNew", "edit"];
+const AUTHORING_AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS = ["type", "uid", "target"];
+const AUTHORING_AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS = [
+  "title",
+  "message",
+  "autoSend",
+  "skillSettings",
+  "model",
+  "webSearch"
+];
+const AUTHORING_AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS = ["system", "user", "workContext"];
+const AUTHORING_AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS = ["llmService", "model"];
+const AUTHORING_AI_EMPLOYEE_SKILL_SETTINGS_PUBLIC_KEYS = ["skills", "tools", "skillsVersion", "toolsVersion"];
+const AUTHORING_AI_EMPLOYEE_STYLE_PUBLIC_KEYS = ["size", "mask"];
+const AUTHORING_AI_EMPLOYEE_DEFAULT_STYLE = {
+  size: 40,
+  mask: false
+};
+function buildCalendarMainBlockRepairDetails(section) {
+  const popupSectionHint = section === "fieldGroups" || section === "recordActions" || section === "fieldsLayout" ? " Put event form/details content under settings.quickCreatePopup or settings.eventPopup instead of on the calendar main block." : "";
+  return {
+    repairHint: "Calendar main block payload shape issue. Put event bindings under settings.titleField, settings.startField, settings.endField, and optional settings.colorField; do not put collection fields in block fields. Keep block type calendar and repair this payload." + popupSectionHint,
+    example: {
+      type: "calendar",
+      collection: "tasks",
+      settings: {
+        titleField: "title",
+        startField: "startAt",
+        endField: "endAt"
+      }
+    }
+  };
+}
+function buildKanbanMainBlockRepairDetails(section) {
+  return {
+    repairHint: "Kanban main block payload shape issue. Put card display fields in block fields, grouping in settings.groupField, and quick-create/card details under settings.quickCreatePopup or settings.cardPopup. Keep block type kanban and repair this payload.",
+    section,
+    example: {
+      type: "kanban",
+      collection: "tasks",
+      fields: ["title", "priority"],
+      settings: {
+        groupField: "status"
+      }
+    }
+  };
+}
+function buildTwoColumnLayoutRepairDetails() {
+  return {
+    repairHint: "When multiple non-filter blocks should share a row, put them in the same layout row. Do not place every block on a separate row.",
+    example: {
+      layout: {
+        rows: [
+          [
+            { key: "calendar", span: 12 },
+            { key: "kanban", span: 12 }
+          ]
+        ]
+      }
+    }
+  };
+}
 async function assertFlowSurfaceAuthoringPayload(actionName, values, context = {}) {
   const errors = await collectFlowSurfaceAuthoringErrors(actionName, values, context);
   if (errors.length) {
@@ -280,6 +431,14 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   if (!_.isPlainObject(values)) {
     return errors;
   }
+  validationContext.getDefaultFieldGroups = validationContext.getDefaultFieldGroups || ((dataSourceKey, collectionName) => {
+    var _a2;
+    return (_a2 = (0, import_defaults.resolveFlowSurfaceApplyBlueprintDefaultCollection)({
+      metadata: values == null ? void 0 : values.defaults,
+      dataSourceKey,
+      collectionName
+    }).collectionDefaults) == null ? void 0 : _a2.fieldGroups;
+  });
   if (actionName === "applyBlueprint" && _.isPlainObject((_a = values == null ? void 0 : values.assets) == null ? void 0 : _a.scripts)) {
     validationContext.applyBlueprintScriptAssets = values.assets.scripts;
   }
@@ -292,7 +451,7 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   collectApplyBlueprintChartAssetErrors(actionName, values, validationContext, errors);
   if (actionName === "configure") {
     await collectConfigureErrors(values, errors, validationContext);
-    errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, validationContext));
+    appendRunJsAuthoringErrors(actionName, values, validationContext, errors);
     if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
       collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
     }
@@ -313,9 +472,42 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
     collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
   }
-  errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, validationContext));
+  appendRunJsAuthoringErrors(actionName, values, validationContext, errors);
   return errors;
 }
+function appendRunJsAuthoringErrors(actionName, values, context, errors) {
+  try {
+    errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, context));
+  } catch (error) {
+    if (shouldKeepExistingChartAuthoringErrors(error, errors)) {
+      return;
+    }
+    if (isChartBadRequestError(error)) {
+      pushChartBadRequestAuthoringError(errors, error, actionName === "configure" ? "$.changes" : "$");
+      return;
+    }
+    throw error;
+  }
+}
+function isChartBadRequestError(error) {
+  return error instanceof import_errors.FlowSurfaceBadRequestError && String(error.message || "").startsWith("chart ");
+}
+function shouldKeepExistingChartAuthoringErrors(error, errors) {
+  return isChartBadRequestError(error) && errors.some((item) => {
+    var _a;
+    return ((_a = item.details) == null ? void 0 : _a.repairHint) === CHART_REPAIR_HINT;
+  });
+}
+function pushChartBadRequestAuthoringError(errors, error, fallbackPath) {
+  var _a, _b, _c;
+  const details = _.isPlainObject((_a = error.options) == null ? void 0 : _a.details) ? error.options.details : {};
+  pushAuthoringError(errors, {
+    path: typeof ((_b = error.options) == null ? void 0 : _b.path) === "string" && error.options.path ? error.options.path : fallbackPath,
+    ruleId: typeof ((_c = error.options) == null ? void 0 : _c.ruleId) === "string" && error.options.ruleId ? error.options.ruleId : "chart-configure-invalid",
+    message: error.message,
+    details: withChartRepairHint(details)
+  });
+}
 async function collectNavigationGroupErrors(actionName, values, context, errors) {
   var _a;
   if (actionName !== "applyBlueprint" || (values == null ? void 0 : values.mode) !== "create" || !_.isPlainObject((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.group)) {
@@ -329,38 +521,43 @@ async function collectNavigationGroupErrors(actionName, values, context, errors)
     return;
   }
   const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction);
-  if (matchedRoutes.length <= 1) {
+  const rootMatchedRoutes = filterRootMenuGroupRoutes(matchedRoutes);
+  if (rootMatchedRoutes.length <= 1) {
     return;
   }
   pushAuthoringError(errors, {
     path: "$.navigation.group.title",
     ruleId: "navigation-group-title-ambiguous",
-    message: `flowSurfaces authoring $.navigation.group.title '${groupTitle}' matches ${matchedRoutes.length} existing menu groups; pass navigation.group.routeId explicitly`,
+    message: `flowSurfaces authoring $.navigation.group.title '${groupTitle}' matches ${rootMatchedRoutes.length} existing root menu groups; pass navigation.group.routeId explicitly`,
     details: {
       title: groupTitle,
-      matches: matchedRoutes.length
+      parentMenuRouteId: null,
+      matches: rootMatchedRoutes.length
     }
   });
 }
 async function collectNavigationIconErrors(actionName, values, context, errors) {
-  var _a, _b;
+  var _a, _b, _c;
   if (actionName !== "applyBlueprint" || (values == null ? void 0 : values.mode) !== "create") {
     return;
   }
   const group = _.isPlainObject((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.group) ? values.navigation.group : null;
   const groupRouteId = String((group == null ? void 0 : group.routeId) || "").trim();
-  if (group && !groupRouteId) {
+  if (group && !groupRouteId && group.hideInMenu !== true) {
     const groupIcon = String(group.icon || "").trim();
     if (!groupIcon && await shouldRequireNewNavigationGroupIcon(group, context)) {
       pushAuthoringError(errors, {
         path: "$.navigation.group.icon",
-        ruleId: "missing-menu-group-icon",
-        message: "flowSurfaces authoring $.navigation.group.icon is required when creating a new navigation group"
+        ruleId: "navigation-icon-required",
+        message: "flowSurfaces authoring $.navigation.group.icon is required when creating a visible navigation group",
+        details: {
+          repairHint: "Pass a valid Ant Design icon name such as AppstoreOutlined, DashboardOutlined, or FolderOpenOutlined."
+        }
       });
     } else if (groupIcon && !isValidAntDesignIconName(groupIcon)) {
       pushAuthoringError(errors, {
         path: "$.navigation.group.icon",
-        ruleId: "invalid-menu-group-icon",
+        ruleId: "navigation-icon-unknown",
         message: "flowSurfaces authoring $.navigation.group.icon must be a valid Ant Design icon name",
         details: {
           icon: groupIcon
@@ -370,7 +567,7 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
   } else if (group && String(group.icon || "").trim() && !isValidAntDesignIconName(group.icon)) {
     pushAuthoringError(errors, {
       path: "$.navigation.group.icon",
-      ruleId: "invalid-menu-group-icon",
+      ruleId: "navigation-icon-unknown",
       message: "flowSurfaces authoring $.navigation.group.icon must be a valid Ant Design icon name",
       details: {
         icon: String(group.icon || "").trim()
@@ -382,13 +579,24 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
   if (itemIcon && !isValidAntDesignIconName(itemIcon)) {
     pushAuthoringError(errors, {
       path: "$.navigation.item.icon",
-      ruleId: "invalid-menu-item-icon",
+      ruleId: "navigation-icon-unknown",
       message: "flowSurfaces authoring $.navigation.item.icon must be a valid Ant Design icon name",
       details: {
         icon: itemIcon
       }
     });
   }
+  const pageIcon = String(((_c = values == null ? void 0 : values.page) == null ? void 0 : _c.icon) || "").trim();
+  if (pageIcon && !isValidAntDesignIconName(pageIcon)) {
+    pushAuthoringError(errors, {
+      path: "$.page.icon",
+      ruleId: "navigation-icon-unknown",
+      message: "flowSurfaces authoring $.page.icon must be a valid Ant Design icon name when used as the create-mode page route icon",
+      details: {
+        icon: pageIcon
+      }
+    });
+  }
 }
 async function shouldRequireNewNavigationGroupIcon(group, context) {
   const groupTitle = String((group == null ? void 0 : group.title) || "").trim();
@@ -396,7 +604,22 @@ async function shouldRequireNewNavigationGroupIcon(group, context) {
     return true;
   }
   const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction);
-  return matchedRoutes.length === 0;
+  return filterRootMenuGroupRoutes(matchedRoutes).length === 0;
+}
+function filterRootMenuGroupRoutes(routes) {
+  return _.castArray(routes || []).filter(
+    (route) => routeParentIdMatches(readAuthoringRouteField(route, "parentId"), null)
+  );
+}
+function readAuthoringRouteField(route, key) {
+  var _a;
+  return ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, key)) ?? (route == null ? void 0 : route[key]);
+}
+function routeParentIdMatches(routeParentId, parentId) {
+  if (_.isNil(routeParentId) && _.isNil(parentId)) {
+    return true;
+  }
+  return String(routeParentId ?? "") === String(parentId ?? "");
 }
 function isValidAntDesignIconName(value) {
   const normalized = String(value || "").trim();
@@ -494,6 +717,355 @@ function collectChartAssetBlockTreeErrors(block, path, chartAssets, errors) {
     );
   });
 }
+function withJsBlockRepairHint(details = {}) {
+  return {
+    ...details,
+    requiredBlockType: "jsBlock",
+    fixStrategy: "repair_same_block_type",
+    repairHint: JS_BLOCK_REPAIR_HINT,
+    agentInstruction: JS_BLOCK_AGENT_INSTRUCTION,
+    repairExample: {
+      inlineBlock: {
+        type: "jsBlock",
+        settings: {
+          code: 'ctx.render("Replace this with the required rendered UI");'
+        }
+      },
+      assetBlock: {
+        assets: {
+          scripts: {
+            scriptKey: {
+              code: 'ctx.render("Replace this with the required rendered UI");'
+            }
+          }
+        },
+        block: {
+          type: "jsBlock",
+          script: "scriptKey"
+        }
+      }
+    },
+    forbiddenFallbacks: JS_BLOCK_FORBIDDEN_FALLBACKS
+  };
+}
+function withChartRepairHint(details = {}) {
+  return {
+    ...details,
+    requiredBlockType: "chart",
+    fixStrategy: "repair_same_block_type",
+    repairHint: CHART_REPAIR_HINT,
+    agentInstruction: CHART_AGENT_INSTRUCTION,
+    repairSteps: [
+      "Keep the block type as chart.",
+      "Define assets.charts.<key>.query and assets.charts.<key>.visual.",
+      "Reference that asset from the chart block with block.chart = <key>.",
+      "Retry the chart payload instead of replacing the chart with another block type or omitting it."
+    ],
+    expectedShape: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "employees"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "employeeCount"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "status",
+            y: "employeeCount"
+          }
+        }
+      },
+      legacySettings: {
+        configure: {
+          query: {
+            mode: "builder",
+            resource: {
+              dataSourceKey: "main",
+              collectionName: "employees"
+            },
+            measures: [
+              {
+                field: "id",
+                aggregation: "count",
+                alias: "employeeCount"
+              }
+            ]
+          },
+          chart: {
+            option: {
+              mode: "basic",
+              builder: {
+                type: "bar",
+                xField: "status",
+                yField: "employeeCount"
+              }
+            }
+          }
+        }
+      },
+      assets: {
+        charts: {
+          chartKey: {
+            query: "builder/sql query configuration",
+            visual: "basic/custom visual configuration"
+          }
+        }
+      },
+      block: {
+        type: "chart",
+        chart: "chartKey"
+      }
+    },
+    repairExample: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "<collectionName>"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "recordCount"
+            }
+          ],
+          dimensions: [
+            {
+              field: "<dimensionField>"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "<dimensionField>",
+            y: "recordCount"
+          }
+        }
+      },
+      assets: {
+        charts: {
+          chartKey: {
+            query: {
+              mode: "builder",
+              resource: {
+                dataSourceKey: "main",
+                collectionName: "<collectionName>"
+              },
+              measures: [
+                {
+                  field: "id",
+                  aggregation: "count",
+                  alias: "recordCount"
+                }
+              ],
+              dimensions: [
+                {
+                  field: "<dimensionField>"
+                }
+              ]
+            },
+            visual: {
+              mode: "basic",
+              type: "bar",
+              mappings: {
+                x: "<dimensionField>",
+                y: "recordCount"
+              }
+            }
+          }
+        }
+      },
+      block: {
+        type: "chart",
+        chart: "chartKey"
+      }
+    },
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS
+  };
+}
+function withUnsupportedChartVisualTypeHint(details = {}) {
+  const jsBlockHint = `Supported basic chart visual types are: ${CHART_BASIC_VISUAL_TYPE_LIST}. If the required visualization cannot be represented by these chart types, use a jsBlock instead.`;
+  return {
+    ...details,
+    fixStrategy: "use_supported_chart_type_or_jsBlock",
+    repairHint: jsBlockHint,
+    agentInstruction: `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Use one of the supported chart visual types, or use a jsBlock when the requested visualization is outside the chart plugin capabilities.`,
+    supportedVisualTypes: [...import_chart_config.CHART_BASIC_VISUAL_TYPES],
+    alternativeBlockType: "jsBlock",
+    alternativeHint: jsBlockHint,
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS.filter((item) => item !== "jsBlock")
+  };
+}
+function collectLocalizedChartSettingsErrors(block, blockType, path, errors, context) {
+  if (blockType !== "chart" || !STRICT_LOCALIZED_CHART_ACTIONS.has(context.authoringActionName)) {
+    return;
+  }
+  const settingsPath = `${path}.settings`;
+  if (!_.isUndefined(block.settings) && !_.isPlainObject(block.settings)) {
+    pushAuthoringError(errors, {
+      path: settingsPath,
+      ruleId: "chart-localized-settings-invalid",
+      message: `flowSurfaces authoring ${settingsPath} must be an object for compose/addBlocks chart blocks`,
+      details: withChartRepairHint()
+    });
+    return;
+  }
+  const settings = _.isPlainObject(block.settings) ? block.settings : {};
+  if (hasOwn(settings, "configure")) {
+    if (["query", "visual", "events"].some((key) => hasOwn(settings, key))) {
+      pushAuthoringError(errors, {
+        path: settingsPath,
+        ruleId: "chart-localized-settings-mixed-configure",
+        message: `flowSurfaces authoring ${settingsPath} cannot mix legacy configure with query/visual/events`,
+        details: withChartRepairHint()
+      });
+      return;
+    }
+    collectLocalizedLegacyChartConfigureErrors(settings.configure, `${settingsPath}.configure`, errors);
+    return;
+  }
+  if (!hasOwn(settings, "query") && !hasOwn(settings, "visual")) {
+    return;
+  }
+  collectChartAssetQueryErrors(settings, settingsPath, context, errors);
+  collectChartAssetVisualErrors(settings, settingsPath, errors);
+}
+function collectLocalizedLegacyChartConfigureErrors(configure, path, errors) {
+  if (!_.isPlainObject(configure)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-configure-invalid",
+      message: `flowSurfaces authoring ${path} must be an object`,
+      details: withChartRepairHint()
+    });
+    return;
+  }
+  collectLegacyChartQueryCompatibilityErrors(configure.query, `${path}.query`, errors);
+}
+function collectLegacyChartQueryCompatibilityErrors(query, path, errors) {
+  if (!_.isPlainObject(query)) {
+    return;
+  }
+  collectChartQueryFilterOperatorErrors(query, path, errors);
+  const hasResource = hasOwn(query, "resource");
+  const hasCollectionPath = hasOwn(query, "collectionPath");
+  if (!hasResource && !hasCollectionPath) {
+    return;
+  }
+  const resource = hasResource ? normalizeLegacyChartResourceForValidation(query.resource, `${path}.resource`, errors) : void 0;
+  const collectionPathResource = hasCollectionPath ? normalizeLegacyChartCollectionPathResourceForValidation(query.collectionPath, `${path}.collectionPath`, errors) : void 0;
+  if (hasResource && hasCollectionPath && resource && collectionPathResource && !_.isEqual(resource, collectionPathResource)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-resource-conflict",
+      message: `flowSurfaces authoring ${path}.resource and ${path}.collectionPath must reference the same collection`,
+      details: withChartRepairHint({
+        resource,
+        collectionPathResource
+      })
+    });
+  }
+}
+function normalizeLegacyChartCollectionPathResource(collectionPath) {
+  if (!Array.isArray(collectionPath)) {
+    return void 0;
+  }
+  const collectionName = normalizeLegacyChartRequiredString(collectionPath[1]);
+  if (!collectionName) {
+    return void 0;
+  }
+  const dataSourceKey = normalizeLegacyChartCollectionPathDataSourceKey(collectionPath[0]);
+  if (!dataSourceKey) {
+    return void 0;
+  }
+  return {
+    dataSourceKey,
+    collectionName
+  };
+}
+function normalizeLegacyChartResourceForValidation(resource, path, errors) {
+  if (!_.isPlainObject(resource)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path} must be an object with string collectionName`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  const collectionName = normalizeLegacyChartRequiredString(resource.collectionName);
+  if (!collectionName) {
+    pushAuthoringError(errors, {
+      path: `${path}.collectionName`,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path}.collectionName must be a non-empty string`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  const dataSourceKey = normalizeLegacyChartResourceDataSourceKey(resource.dataSourceKey);
+  if (!dataSourceKey) {
+    pushAuthoringError(errors, {
+      path: `${path}.dataSourceKey`,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path}.dataSourceKey must be a non-empty string when provided`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  return {
+    dataSourceKey,
+    collectionName
+  };
+}
+function normalizeLegacyChartCollectionPathResourceForValidation(collectionPath, path, errors) {
+  const resource = normalizeLegacyChartCollectionPathResource(collectionPath);
+  if (!resource) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-collection-path-invalid",
+      message: `flowSurfaces authoring ${path} must be [dataSourceKey, collectionName] with string values and a non-empty collectionName`,
+      details: withChartRepairHint()
+    });
+  }
+  return resource;
+}
+function normalizeLegacyChartRequiredString(input) {
+  if (typeof input !== "string") {
+    return void 0;
+  }
+  return input.trim() || void 0;
+}
+function normalizeLegacyChartResourceDataSourceKey(input) {
+  if (_.isUndefined(input) || _.isNull(input)) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  return normalizeLegacyChartRequiredString(input);
+}
+function normalizeLegacyChartCollectionPathDataSourceKey(input) {
+  if (_.isUndefined(input) || _.isNull(input)) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  if (typeof input === "string" && !input.trim()) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  return normalizeLegacyChartRequiredString(input);
+}
 function collectChartBlockAssetReferenceErrors(block, path, chartAssets, errors) {
   if (!CHART_BLOCK_TYPES.has(String((block == null ? void 0 : block.type) || "").trim())) {
     return;
@@ -502,7 +1074,8 @@ function collectChartBlockAssetReferenceErrors(block, path, chartAssets, errors)
     pushAuthoringError(errors, {
       path: `${path}.stepParams`,
       ruleId: "chart-block-step-params-unsupported",
-      message: `flowSurfaces authoring ${path}.stepParams is not accepted on public chart blocks; put chart configuration under assets.charts and reference it with block.chart`
+      message: `flowSurfaces authoring ${path}.stepParams is not accepted on public chart blocks; put chart configuration under assets.charts and reference it with block.chart`,
+      details: withChartRepairHint()
     });
   }
   const chartKey = String(block.chart || "").trim();
@@ -510,7 +1083,8 @@ function collectChartBlockAssetReferenceErrors(block, path, chartAssets, errors)
     pushAuthoringError(errors, {
       path: `${path}.chart`,
       ruleId: "chart-block-asset-reference-required",
-      message: `flowSurfaces authoring ${path}.chart must reference one key from assets.charts`
+      message: `flowSurfaces authoring ${path}.chart must reference one key from assets.charts`,
+      details: withChartRepairHint()
     });
     return;
   }
@@ -519,9 +1093,9 @@ function collectChartBlockAssetReferenceErrors(block, path, chartAssets, errors)
       path: `${path}.chart`,
       ruleId: "chart-block-asset-reference-missing",
       message: `flowSurfaces authoring ${path}.chart references missing chart asset '${chartKey}'`,
-      details: {
+      details: withChartRepairHint({
         chartKey
-      }
+      })
     });
   }
 }
@@ -535,7 +1109,8 @@ function collectChartAssetRegistryErrors(charts, path, context, errors) {
       pushAuthoringError(errors, {
         path: assetPath,
         ruleId: "chart-asset-invalid",
-        message: `flowSurfaces authoring ${assetPath} must be an object`
+        message: `flowSurfaces authoring ${assetPath} must be an object`,
+        details: withChartRepairHint()
       });
       return;
     }
@@ -549,7 +1124,8 @@ function collectChartAssetQueryErrors(asset, path, context, errors) {
     pushAuthoringError(errors, {
       path: `${path}.query`,
       ruleId: "chart-query-missing",
-      message: `flowSurfaces authoring ${path}.query is required`
+      message: `flowSurfaces authoring ${path}.query is required`,
+      details: withChartRepairHint()
     });
     return;
   }
@@ -559,9 +1135,9 @@ function collectChartAssetQueryErrors(asset, path, context, errors) {
       path: `${path}.query.mode`,
       ruleId: "chart-query-mode-unsupported",
       message: `flowSurfaces authoring ${path}.query.mode '${mode}' is not supported`,
-      details: {
+      details: withChartRepairHint({
         mode
-      }
+      })
     });
     return;
   }
@@ -577,14 +1153,16 @@ function collectBuilderChartAssetQueryErrors(query, path, context, errors) {
     pushAuthoringError(errors, {
       path: `${path}.query.resource`,
       ruleId: "chart-builder-query-resource-missing",
-      message: `flowSurfaces authoring ${path}.query.resource.collectionName is required for builder chart assets`
+      message: `flowSurfaces authoring ${path}.query.resource.collectionName is required for builder chart assets`,
+      details: withChartRepairHint()
     });
   }
   if (!Array.isArray(query.measures) || !query.measures.length) {
     pushAuthoringError(errors, {
       path: `${path}.query.measures`,
       ruleId: "chart-builder-query-measures-missing",
-      message: `flowSurfaces authoring ${path}.query.measures must include at least one measure`
+      message: `flowSurfaces authoring ${path}.query.measures must include at least one measure`,
+      details: withChartRepairHint()
     });
   }
   collectForbiddenObjectKeyErrors(
@@ -592,10 +1170,88 @@ function collectBuilderChartAssetQueryErrors(query, path, context, errors) {
     `${path}.query`,
     CHART_BUILDER_QUERY_FORBIDDEN_KEYS,
     "chart-builder-query-forbidden-keys",
-    errors
+    errors,
+    withChartRepairHint()
   );
+  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors);
   collectBuilderChartAssetFieldErrors(query, path, context, errors);
 }
+function collectChartQueryFilterOperatorErrors(query, path, errors) {
+  if (!_.isPlainObject(query) || !hasOwn(query, "filter")) {
+    return;
+  }
+  collectChartFilterOperatorErrors(query.filter, `${path}.filter`, errors);
+}
+function collectChartFilterOperatorErrors(filter, path, errors) {
+  if (_.isUndefined(filter) || _.isNull(filter) || !_.isPlainObject(filter)) {
+    return;
+  }
+  if (Array.isArray(filter.items)) {
+    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors);
+    return;
+  }
+  collectBackendQueryFilterOperatorErrors(filter, path, errors);
+}
+function collectChartFilterGroupOperatorErrors(items, path, errors) {
+  items.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!_.isPlainObject(item)) {
+      return;
+    }
+    if (Array.isArray(item.items)) {
+      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors);
+      return;
+    }
+    if (hasOwn(item, "operator")) {
+      collectChartFilterOperatorError(item.operator, `${itemPath}.operator`, errors);
+      collectChartFilterDateValueError(item.operator, item.value, `${itemPath}.value`, errors);
+    }
+  });
+}
+function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
+  Object.entries(filter).forEach(([field, condition]) => {
+    const fieldPath = `${path}.${field}`;
+    if ((field === "$and" || field === "$or") && Array.isArray(condition)) {
+      condition.forEach(
+        (operand, index) => collectChartFilterOperatorErrors(operand, `${fieldPath}[${index}]`, errors)
+      );
+      return;
+    }
+    if (!_.isPlainObject(condition)) {
+      return;
+    }
+    Object.keys(condition).forEach((operator) => {
+      if (operator === "$and" || operator === "$or") {
+        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors);
+        return;
+      }
+      collectChartFilterOperatorError(operator, `${fieldPath}.${operator}`, errors);
+      collectChartFilterDateValueError(operator, condition[operator], `${fieldPath}.${operator}`, errors);
+    });
+  });
+}
+function collectChartFilterOperatorError(operator, path, errors) {
+  try {
+    (0, import_filter_group.assertFlowSurfaceFilterOperator)(operator, path);
+  } catch (error) {
+    if (error instanceof import_errors.FlowSurfaceBadRequestError) {
+      pushChartBadRequestAuthoringError(errors, error, path);
+      return;
+    }
+    throw error;
+  }
+}
+function collectChartFilterDateValueError(operator, value, path, errors) {
+  try {
+    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+  } catch (error) {
+    if (error instanceof import_errors.FlowSurfaceBadRequestError) {
+      pushChartBadRequestAuthoringError(errors, error, path);
+      return;
+    }
+    throw error;
+  }
+}
 function normalizeChartAssetFieldPath(input) {
   if (Array.isArray(input)) {
     return input.map((item) => String(item || "").trim()).filter(Boolean).join(".");
@@ -603,6 +1259,7 @@ function normalizeChartAssetFieldPath(input) {
   return String(input || "").trim();
 }
 function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
+  var _a, _b, _c, _d, _e;
   const resource = _.isPlainObject(query.resource) ? query.resource : null;
   const collectionName = String((resource == null ? void 0 : resource.collectionName) || "").trim();
   if (!collectionName || typeof context.getCollection !== "function") {
@@ -616,10 +1273,12 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
   const selections = [
     ..._.castArray(query.measures || []).map((selection, index) => ({
       selection,
+      kind: "measure",
       fieldPath: `${path}.query.measures[${index}].field`
     })),
     ..._.castArray(query.dimensions || []).map((selection, index) => ({
       selection,
+      kind: "dimension",
       fieldPath: `${path}.query.dimensions[${index}].field`
     }))
   ];
@@ -631,24 +1290,80 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
     if (!fieldPath) {
       continue;
     }
+    const fieldPathParts = fieldPath.split(".").filter(Boolean);
+    const isCountMeasureSelection = item.kind === "measure" && String(((_a = item.selection) == null ? void 0 : _a.aggregation) || "").trim() === "count" && !((_b = item.selection) == null ? void 0 : _b.distinct);
+    if (fieldPathParts.length > 1 && !isCountMeasureSelection) {
+      const directAssociationPath = fieldPathParts[0];
+      const directAssociationField = (0, import_service_helpers.resolveFieldFromCollection)(collection, directAssociationPath);
+      const directAssociationTargetCollection = directAssociationField && (0, import_service_helpers.isAssociationField)(directAssociationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+        directAssociationField,
+        dataSourceKey,
+        (resolvedDataSourceKey, targetCollection) => {
+          var _a2;
+          return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollection);
+        }
+      ) : null;
+      const invalidDirectSubfield = directAssociationTargetCollection ? (0, import_service_helpers.getInvalidChartBuilderRelationDirectSubfieldDetails)({
+        associationPathName: directAssociationPath,
+        selectedSubfieldPath: fieldPathParts.slice(1).join("."),
+        targetCollection: directAssociationTargetCollection
+      }) : null;
+      if (invalidDirectSubfield) {
+        pushAuthoringError(errors, {
+          path: item.fieldPath,
+          ruleId: "chart-builder-query-relation-direct-subfield-required",
+          message: `flowSurfaces authoring ${item.fieldPath} must reference a direct scalar child field under relation '${invalidDirectSubfield.associationPath}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+            invalidDirectSubfield.associationPath,
+            invalidDirectSubfield.supportedFields
+          )}`,
+          details: withChartRepairHint({
+            fieldPath,
+            dataSourceKey,
+            collectionName,
+            ...invalidDirectSubfield
+          })
+        });
+        continue;
+      }
+    }
     const field = (0, import_service_helpers.resolveFieldFromCollection)(collection, fieldPath);
+    const associationPath = fieldPath.includes(".") ? fieldPath.split(".").slice(0, -1).join(".") : "";
+    const leafFieldName = fieldPath.split(".").slice(-1)[0];
+    const associationField = associationPath ? (0, import_service_helpers.resolveFieldFromCollection)(collection, associationPath) : null;
+    const associationTargetCollection = associationField && (0, import_service_helpers.isAssociationField)(associationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+      associationField,
+      dataSourceKey,
+      (resolvedDataSourceKey, targetCollection) => {
+        var _a2;
+        return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollection);
+      }
+    ) : null;
+    const leafModelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(associationTargetCollection || collection);
+    const hasLeafModelAttribute = Object.prototype.hasOwnProperty.call(leafModelAttributes, leafFieldName);
+    const isCountMeasureRelationSubfield = item.kind === "measure" && String(((_c = item.selection) == null ? void 0 : _c.aggregation) || "").trim() === "count" && !((_d = item.selection) == null ? void 0 : _d.distinct) && associationField && (0, import_service_helpers.isAssociationField)(associationField);
+    const unsupportedRelationSubfield = associationTargetCollection ? (0, import_service_helpers.getUnsupportedChartBuilderRelationSubfieldDetails)({
+      associationPathName: associationPath,
+      leafFieldName,
+      leafField: field,
+      targetCollection: associationTargetCollection
+    }) : null;
     if (!field) {
-      if (collectionHasConcreteField(collection, fieldPath)) {
+      const hasConcreteField = associationTargetCollection ? hasLeafModelAttribute || collectionHasConcreteField(associationTargetCollection, leafFieldName) : collectionHasConcreteField(collection, fieldPath);
+      if (!hasConcreteField) {
+        pushAuthoringError(errors, {
+          path: item.fieldPath,
+          ruleId: "chart-builder-query-field-unknown",
+          message: `flowSurfaces authoring ${item.fieldPath} references unknown field '${fieldPath}' on collection '${dataSourceKey}.${collectionName}'`,
+          details: withChartRepairHint({
+            fieldPath,
+            dataSourceKey,
+            collectionName
+          })
+        });
         continue;
       }
-      pushAuthoringError(errors, {
-        path: item.fieldPath,
-        ruleId: "chart-builder-query-field-unknown",
-        message: `flowSurfaces authoring ${item.fieldPath} references unknown field '${fieldPath}' on collection '${dataSourceKey}.${collectionName}'`,
-        details: {
-          fieldPath,
-          dataSourceKey,
-          collectionName
-        }
-      });
-      continue;
     }
-    if (!fieldPath.includes(".") && (0, import_service_helpers.isAssociationField)(field)) {
+    if (!fieldPath.includes(".") && field && (0, import_service_helpers.isAssociationField)(field)) {
       const suggestion = resolveChartBuilderAssociationSubfieldSuggestion(
         fieldPath,
         field,
@@ -659,12 +1374,49 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
         path: item.fieldPath,
         ruleId: "chart-builder-query-association-field-requires-subfield",
         message: `flowSurfaces authoring ${item.fieldPath} references association field '${fieldPath}' directly; use scalar subfield '${suggestion.suggestedFieldPath}' for builder charts`,
-        details: {
+        details: withChartRepairHint({
           fieldPath,
           dataSourceKey,
           collectionName,
           ...suggestion
-        }
+        })
+      });
+    }
+    if (isCountMeasureRelationSubfield) {
+      pushAuthoringError(errors, {
+        path: item.fieldPath,
+        ruleId: "chart-builder-query-count-measure-relation-subfield",
+        message: `flowSurfaces authoring ${item.fieldPath} counts relation subfield '${fieldPath}'; count a scalar base field such as 'id' and keep '${fieldPath}' as a dimension`,
+        details: withChartRepairHint({
+          fieldPath,
+          dataSourceKey,
+          collectionName,
+          suggestedMeasure: {
+            field: "id",
+            aggregation: "count",
+            alias: String(((_e = item.selection) == null ? void 0 : _e.alias) || "").trim() || "recordCount"
+          },
+          suggestedDimension: {
+            field: fieldPath
+          }
+        })
+      });
+      continue;
+    }
+    if (unsupportedRelationSubfield) {
+      pushAuthoringError(errors, {
+        path: item.fieldPath,
+        ruleId: "chart-builder-query-relation-subfield-column-unsupported",
+        message: `flowSurfaces authoring ${item.fieldPath} references relation subfield '${fieldPath}', but current chart builder SQL generation cannot query relation subfield '${unsupportedRelationSubfield.leafFieldName}' because its database column is '${unsupportedRelationSubfield.columnName}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+          associationPath,
+          unsupportedRelationSubfield.supportedFields
+        )}`,
+        details: withChartRepairHint({
+          fieldPath,
+          dataSourceKey,
+          collectionName,
+          ...unsupportedRelationSubfield
+        })
       });
     }
   }
@@ -691,7 +1443,8 @@ function collectSqlChartAssetQueryErrors(query, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.query.sql`,
       ruleId: "chart-sql-query-text-missing",
-      message: `flowSurfaces authoring ${path}.query.sql must be a non-empty string`
+      message: `flowSurfaces authoring ${path}.query.sql must be a non-empty string`,
+      details: withChartRepairHint()
     });
   }
   collectForbiddenObjectKeyErrors(
@@ -699,7 +1452,8 @@ function collectSqlChartAssetQueryErrors(query, path, errors) {
     `${path}.query`,
     CHART_SQL_QUERY_FORBIDDEN_KEYS,
     "chart-sql-query-forbidden-builder-keys",
-    errors
+    errors,
+    withChartRepairHint()
   );
 }
 function collectChartAssetVisualErrors(asset, path, errors) {
@@ -708,7 +1462,8 @@ function collectChartAssetVisualErrors(asset, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.visual`,
       ruleId: "chart-visual-missing",
-      message: `flowSurfaces authoring ${path}.visual is required`
+      message: `flowSurfaces authoring ${path}.visual is required`,
+      details: withChartRepairHint()
     });
     return;
   }
@@ -717,7 +1472,8 @@ function collectChartAssetVisualErrors(asset, path, errors) {
     `${path}.visual`,
     CHART_VISUAL_LEGACY_BUILDER_KEYS,
     "chart-visual-legacy-builder-keys-unsupported",
-    errors
+    errors,
+    withChartRepairHint()
   );
   const mode = String(visual.mode || "basic").trim();
   if (!CHART_VISUAL_MODE_SET.has(mode)) {
@@ -725,9 +1481,9 @@ function collectChartAssetVisualErrors(asset, path, errors) {
       path: `${path}.visual.mode`,
       ruleId: "chart-visual-mode-unsupported",
       message: `flowSurfaces authoring ${path}.visual.mode '${mode}' is not supported`,
-      details: {
+      details: withChartRepairHint({
         mode
-      }
+      })
     });
     return;
   }
@@ -736,7 +1492,8 @@ function collectChartAssetVisualErrors(asset, path, errors) {
       pushAuthoringError(errors, {
         path: `${path}.visual.raw`,
         ruleId: "chart-custom-visual-raw-missing",
-        message: `flowSurfaces authoring ${path}.visual.raw is required for custom chart assets`
+        message: `flowSurfaces authoring ${path}.visual.raw is required for custom chart assets`,
+        details: withChartRepairHint()
       });
     }
     collectForbiddenObjectKeyErrors(
@@ -744,7 +1501,8 @@ function collectChartAssetVisualErrors(asset, path, errors) {
       `${path}.visual`,
       CHART_CUSTOM_VISUAL_FORBIDDEN_KEYS,
       "chart-custom-visual-public-keys-unsupported",
-      errors
+      errors,
+      withChartRepairHint()
     );
     return;
   }
@@ -753,23 +1511,25 @@ function collectChartAssetVisualErrors(asset, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.visual.type`,
       ruleId: "chart-visual-type-missing",
-      message: `flowSurfaces authoring ${path}.visual.type is required for basic chart assets`
+      message: `flowSurfaces authoring ${path}.visual.type is required for basic chart assets`,
+      details: withChartRepairHint()
     });
   } else if (!CHART_BASIC_VISUAL_TYPE_SET.has(type)) {
     pushAuthoringError(errors, {
       path: `${path}.visual.type`,
       ruleId: "chart-visual-type-unsupported",
-      message: `flowSurfaces authoring ${path}.visual.type '${type}' is not supported`,
-      details: {
+      message: `flowSurfaces authoring ${path}.visual.type '${type}' is not supported. Supported basic chart visual types: ${CHART_BASIC_VISUAL_TYPE_LIST}. If these types do not satisfy the requirement, use a jsBlock instead.`,
+      details: withUnsupportedChartVisualTypeHint({
         type
-      }
+      })
     });
   }
   if (!_.isPlainObject(visual.mappings)) {
     pushAuthoringError(errors, {
       path: `${path}.visual.mappings`,
       ruleId: "chart-visual-mappings-missing",
-      message: `flowSurfaces authoring ${path}.visual.mappings is required for basic chart assets`
+      message: `flowSurfaces authoring ${path}.visual.mappings is required for basic chart assets`,
+      details: withChartRepairHint()
     });
     return;
   }
@@ -781,14 +1541,14 @@ function collectChartAssetVisualErrors(asset, path, errors) {
       path: `${path}.visual.mappings`,
       ruleId: "chart-visual-required-mappings-missing",
       message: `flowSurfaces authoring ${path}.visual.mappings is missing required keys: ${missingMappings.join(", ")}`,
-      details: {
+      details: withChartRepairHint({
         type,
         missingMappings
-      }
+      })
     });
   }
 }
-function collectForbiddenObjectKeyErrors(value, path, forbiddenKeys, ruleId, errors) {
+function collectForbiddenObjectKeyErrors(value, path, forbiddenKeys, ruleId, errors, details = {}) {
   if (!_.isPlainObject(value)) {
     return;
   }
@@ -801,6 +1561,7 @@ function collectForbiddenObjectKeyErrors(value, path, forbiddenKeys, ruleId, err
     ruleId,
     message: `flowSurfaces authoring ${path} does not accept keys: ${keys.join(", ")}`,
     details: {
+      ...details,
       keys
     }
   });
@@ -3186,11 +3947,16 @@ function collectBlockErrors(block, path, errors, localKeys, context) {
     context
   );
   collectSemanticBindingErrors(block, blockType, path, errors, context);
+  collectVisibleDataBlockFieldErrors(block, blockType, path, errors, context);
   collectCommentsBlockErrors(block, blockType, path, errors, context);
   collectRecordHistoryBlockErrors(block, blockType, path, errors, context);
+  collectLocalizedChartSettingsErrors(block, blockType, path, errors, context);
   collectChartDisplayTitleErrors(block, blockType, path, errors);
   collectTreeTableExplicitFieldsErrors(block, blockType, path, errors, context);
   collectTreeConnectFieldsErrors((_a = block.settings) == null ? void 0 : _a.connectFields, `${path}.settings.connectFields`, errors);
+  collectTableSettingsErrors(block, blockType, path, errors, {
+    deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
+  });
   collectGridCardSettingsErrors(block, blockType, path, errors);
   const descendantContext = getBlockDescendantValidationContext(block, context);
   collectActionListErrors(block.actions, `${path}.actions`, errors, block, descendantContext, "actions");
@@ -3214,7 +3980,8 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
     pushAuthoringError(errors, {
       path: `${path}.type`,
       ruleId: "jsBlock-type-alias-unsupported",
-      message: `flowSurfaces authoring ${path}.type must be "jsBlock"; "js" is only an action type and is not a public JSBlock block alias. Use ${path}.settings.code for inline JSBlock code`
+      message: `flowSurfaces authoring ${path}.type must be "jsBlock"; "js" is only an action type and is not a public JSBlock block alias. Use ${path}.settings.code for inline JSBlock code`,
+      details: withJsBlockRepairHint()
     });
     return;
   }
@@ -3228,7 +3995,8 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
     pushAuthoringError(errors, {
       path: `${path}.${key}`,
       ruleId: `jsBlock-top-level-${key}-unsupported`,
-      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code and ${path}.settings.version for inline JS code`
+      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code and ${path}.settings.version for inline JS code`,
+      details: withJsBlockRepairHint({ key })
     });
   });
   JS_BLOCK_INTERNAL_AUTHORING_KEYS.forEach((key) => {
@@ -3239,16 +4007,17 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
       path: `${path}.${key}`,
       ruleId: key === "stepParams" ? "jsBlock-stepParams-unsupported" : "jsBlock-internal-field-unsupported",
       message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code and ${path}.settings.version instead of internal persisted fields`,
-      details: {
+      details: withJsBlockRepairHint({
         key
-      }
+      })
     });
   });
   if (hasOwn(block, "script") && context.authoringActionName !== "applyBlueprint") {
     pushAuthoringError(errors, {
       path: `${path}.script`,
       ruleId: "jsBlock-script-unsupported",
-      message: `flowSurfaces authoring ${path}.script is only supported by applyBlueprint assets.scripts; use ${path}.settings.code for localized jsBlock inline JS code`
+      message: `flowSurfaces authoring ${path}.script is only supported by applyBlueprint assets.scripts; use ${path}.settings.code for localized jsBlock inline JS code`,
+      details: withJsBlockRepairHint()
     });
   }
   const settings = _.isPlainObject(block.settings) ? block.settings : void 0;
@@ -3261,10 +4030,10 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
         path: `${path}.settings.${key}`,
         ruleId: "jsBlock-settings-unsupported-key",
         message: `flowSurfaces authoring ${path}.settings.${key} is not part of the public jsBlock contract; use ${path}.settings.code and ${path}.settings.version for inline JS code`,
-        details: {
+        details: withJsBlockRepairHint({
           key,
           allowedKeys: Array.from(JS_BLOCK_ALLOWED_SETTINGS_KEYS)
-        }
+        })
       });
     });
   }
@@ -3274,9 +4043,9 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
       path: `${path}.script`,
       ruleId: "jsBlock-mixed-inline-and-script",
       message: `flowSurfaces authoring ${path} cannot combine script asset references with ${inlineKeys.map((key) => `settings.${key}`).join(", ")}; use either applyBlueprint assets.scripts + block.script or inline ${path}.settings.code`,
-      details: {
+      details: withJsBlockRepairHint({
         inlineKeys
-      }
+      })
     });
   }
   const hasInlineCode = typeof (settings == null ? void 0 : settings.code) === "string" && !!settings.code.trim();
@@ -3286,7 +4055,8 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
     pushAuthoringError(errors, {
       path,
       ruleId: "jsBlock-source-required",
-      message: `flowSurfaces authoring ${path} jsBlock must include inline ${path}.settings.code or, for applyBlueprint only, a block.script asset reference`
+      message: `flowSurfaces authoring ${path} jsBlock must include inline ${path}.settings.code or, for applyBlueprint only, a block.script asset reference`,
+      details: withJsBlockRepairHint()
     });
   }
 }
@@ -3302,16 +4072,17 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
       path: `${path}.${key}`,
       ruleId: key === "stepParams" ? "jsBlock-stepParams-unsupported" : "jsBlock-internal-field-unsupported",
       message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock configure changes; use ${path}.code and ${path}.version instead of internal persisted fields`,
-      details: {
+      details: withJsBlockRepairHint({
         key
-      }
+      })
     });
   });
   if (hasOwn(changes, "script")) {
     pushAuthoringError(errors, {
       path: `${path}.script`,
       ruleId: "jsBlock-script-unsupported",
-      message: `flowSurfaces authoring ${path}.script is only supported by applyBlueprint assets.scripts; use ${path}.code for localized jsBlock configure JS code`
+      message: `flowSurfaces authoring ${path}.script is only supported by applyBlueprint assets.scripts; use ${path}.code for localized jsBlock configure JS code`,
+      details: withJsBlockRepairHint()
     });
   }
   const inlineKeys = JS_BLOCK_TOP_LEVEL_JS_KEYS.filter((key) => hasOwn(changes, key));
@@ -3320,9 +4091,9 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
       path: `${path}.script`,
       ruleId: "jsBlock-mixed-inline-and-script",
       message: `flowSurfaces authoring ${path} cannot combine script asset references with ${inlineKeys.map((key) => `${path}.${key}`).join(", ")}; use either applyBlueprint assets.scripts + block.script or localized ${path}.code`,
-      details: {
+      details: withJsBlockRepairHint({
         inlineKeys
-      }
+      })
     });
   }
   if (!hasOwn(changes, "settings")) {
@@ -3333,7 +4104,8 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.settings`,
       ruleId: "jsBlock-settings-unsupported-key",
-      message: `flowSurfaces authoring ${path}.settings is not part of the public jsBlock configure contract; use ${path}.code and ${path}.version`
+      message: `flowSurfaces authoring ${path}.settings is not part of the public jsBlock configure contract; use ${path}.code and ${path}.version`,
+      details: withJsBlockRepairHint()
     });
     return;
   }
@@ -3342,9 +4114,9 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
       path: `${path}.settings.${key}`,
       ruleId: "jsBlock-settings-unsupported-key",
       message: `flowSurfaces authoring ${path}.settings.${key} is not part of the public jsBlock configure contract; use ${path}.${key}`,
-      details: {
+      details: withJsBlockRepairHint({
         key
-      }
+      })
     });
   });
 }
@@ -3376,7 +4148,8 @@ function collectUnsupportedMainBlockSectionErrors(block, blockType, path, errors
     pushAuthoringError(errors, {
       path: `${path}.${section}`,
       ruleId: `${blockType}-main-block-unsupported-${section}`,
-      message: `flowSurfaces authoring ${path} ${blockType} main blocks do not support ${section}`
+      message: `flowSurfaces authoring ${path} ${blockType} main blocks do not support ${section}`,
+      details: blockType === "calendar" ? buildCalendarMainBlockRepairDetails(section) : blockType === "kanban" ? buildKanbanMainBlockRepairDetails(section) : void 0
     });
   });
 }
@@ -3393,7 +4166,8 @@ function collectApplyBlueprintKanbanFieldLimitErrors(block, blockType, path, err
     message: `flowSurfaces authoring ${path}.fields supports at most 2 fields for applyBlueprint kanban main blocks`,
     details: {
       max: 2,
-      count: block.fields.length
+      count: block.fields.length,
+      repairHint: "Kanban main block fields controls compact card display only. Keep at most 2 fields in applyBlueprint kanban fields, move richer card details to settings.cardPopup, and keep block type kanban."
     }
   });
 }
@@ -3440,6 +4214,7 @@ function collectFieldGroupsShapeErrors(fieldGroups, blockPath, errors, block, co
         if (fieldPath) {
           collectUnknownFieldPathError(fieldPath, itemPath, block, context, errors);
         }
+        collectImplicitRelationTitleFieldErrors(field, itemPath, block, context, errors);
         if (!_.isPlainObject(field)) {
           return;
         }
@@ -3489,6 +4264,8 @@ async function collectConfigureErrors(values, errors, context) {
   collectCommentsBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectRecordHistoryBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectChartDisplayTitleErrors(changes, hostBlockType, "$.changes", errors);
+  collectChartConfigureFilterOperatorErrors(changes, hostBlockType, "$.changes", errors);
+  collectTableSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectGridCardSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectAssignValuesErrors(changes.assignValues, "$.changes.assignValues", errors, changesBlock, context);
   collectTriggerWorkflowsErrors(changes.triggerWorkflows, "$.changes.triggerWorkflows", errors);
@@ -3531,9 +4308,18 @@ function pushAuthoringError(errors, error) {
     type: "bad_request",
     code: "FLOW_SURFACE_AUTHORING_VALIDATION_ERROR",
     status: 400,
-    ...error
+    ...error,
+    message: appendRepairHintToAuthoringMessage(error)
   });
 }
+function appendRepairHintToAuthoringMessage(error) {
+  var _a;
+  const repairHint = typeof ((_a = error.details) == null ? void 0 : _a.repairHint) === "string" ? error.details.repairHint.trim() : "";
+  if (!repairHint || error.message.includes(repairHint)) {
+    return error.message;
+  }
+  return `${error.message}. ${repairHint}`;
+}
 function hasOwnDefined(value, key) {
   return _.isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, key) && !_.isUndefined(value[key]);
 }
@@ -3567,6 +4353,23 @@ function collectUnsupportedDefaultFilterOperatorError(operator, path, errors) {
     }
   });
 }
+function collectDefaultFilterDateValueError(operator, value, path, errors) {
+  var _a, _b, _c;
+  try {
+    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+  } catch (error) {
+    if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
+      throw error;
+    }
+    const details = _.isPlainObject((_a = error.options) == null ? void 0 : _a.details) ? error.options.details : {};
+    pushAuthoringError(errors, {
+      path: typeof ((_b = error.options) == null ? void 0 : _b.path) === "string" && error.options.path ? error.options.path : path,
+      ruleId: typeof ((_c = error.options) == null ? void 0 : _c.ruleId) === "string" && error.options.ruleId ? error.options.ruleId : "filter-group-date-value-invalid",
+      message: error.message,
+      details
+    });
+  }
+}
 function collectTopLevelLayoutErrors(actionName, values, errors) {
   if (actionName !== "applyBlueprint") {
     return;
@@ -3696,7 +4499,8 @@ function collectPublicLayoutErrors(layout, layoutPath, knownEntries, kind, error
     pushAuthoringError(errors, {
       path: `${layoutPath}.rows`,
       ruleId: "block-layout-single-column",
-      message: `flowSurfaces authoring ${layoutPath}.rows must not place every non-filter block on its own row`
+      message: `flowSurfaces authoring ${layoutPath}.rows must not place every non-filter block on its own row`,
+      details: buildTwoColumnLayoutRepairDetails()
     });
   }
 }
@@ -4064,81 +4868,274 @@ function collectTemplateBackedPublicDataSurfaceDefaultOverrideErrors(block, bloc
   if (!(0, import_public_data_surface_default_filter.isFlowSurfacePublicDataSurfaceBlockType)(blockType) || !(0, import_template_reference.hasFlowSurfaceTemplateDocument)(block == null ? void 0 : block.template)) {
     return;
   }
-  if (hasOwn(block, "defaultFilter")) {
-    pushAuthoringError(errors, {
-      path: `${path}.defaultFilter`,
-      ruleId: "data-surface-block-default-filter-template-unsupported",
-      message: "Template-backed table, list, gridCard, calendar, and kanban blocks do not support block-level defaultFilter; only direct blocks may define it."
-    });
+  if (hasOwn(block, "defaultFilter")) {
+    pushAuthoringError(errors, {
+      path: `${path}.defaultFilter`,
+      ruleId: "data-surface-block-default-filter-template-unsupported",
+      message: "Template-backed table, list, gridCard, calendar, and kanban blocks do not support block-level defaultFilter; only direct blocks may define it."
+    });
+  }
+  if (hasOwn(block, "defaultActionSettings")) {
+    pushAuthoringError(errors, {
+      path: `${path}.defaultActionSettings`,
+      ruleId: "data-surface-block-default-action-settings-template-unsupported",
+      message: "Template-backed table, list, gridCard, calendar, and kanban blocks do not support defaultActionSettings; use filter action settings on direct blocks instead."
+    });
+  }
+}
+function collectDefaultActionSettingsFilterErrors(defaultActionSettings, path, errors, block, context = {}) {
+  if (_.isUndefined(defaultActionSettings)) {
+    return;
+  }
+  if (!_.isPlainObject(defaultActionSettings)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "defaultActionSettings-invalid-shape",
+      message: `flowSurfaces authoring ${path} must be an object`
+    });
+    return;
+  }
+  if (!Object.prototype.hasOwnProperty.call(defaultActionSettings, "filter")) {
+    return;
+  }
+  if (!doesBlockConsumeDefaultFilterAction(block)) {
+    return;
+  }
+  const filterSettings = defaultActionSettings.filter;
+  const filterSettingsPath = `${path}.filter`;
+  if (!_.isPlainObject(filterSettings)) {
+    pushAuthoringError(errors, {
+      path: filterSettingsPath,
+      ruleId: "defaultActionSettings-filter-invalid-shape",
+      message: `flowSurfaces authoring ${filterSettingsPath} must be an object`
+    });
+    return;
+  }
+  collectDefaultFilterErrors(
+    filterSettings.defaultFilter,
+    `${filterSettingsPath}.defaultFilter`,
+    errors,
+    block,
+    context
+  );
+  const filterableFieldNames = collectFilterableFieldNamesErrors(
+    filterSettings.filterableFieldNames,
+    `${filterSettingsPath}.filterableFieldNames`,
+    errors,
+    block,
+    context
+  );
+  const blockPath = path.replace(/\.defaultActionSettings$/, "");
+  const effectiveDefaultFilter = getEffectiveFilterSettingsDefaultFilter(
+    block,
+    filterSettings,
+    filterSettingsPath,
+    blockPath,
+    context
+  );
+  collectDefaultFilterFilterableFieldErrors(
+    effectiveDefaultFilter == null ? void 0 : effectiveDefaultFilter.value,
+    (effectiveDefaultFilter == null ? void 0 : effectiveDefaultFilter.path) || `${filterSettingsPath}.defaultFilter`,
+    filterableFieldNames,
+    errors
+  );
+}
+function doesBlockConsumeDefaultFilterAction(block) {
+  const blockType = String((block == null ? void 0 : block.type) || "").trim();
+  return (0, import_public_data_surface_default_filter.isFlowSurfacePublicDataSurfaceBlockType)(blockType) && !(0, import_template_reference.hasFlowSurfaceTemplateDocument)(block == null ? void 0 : block.template);
+}
+function collectVisibleDataBlockFieldErrors(block, blockType, path, errors, context) {
+  if (!VISIBLE_FIELD_REQUIRED_DATA_BLOCK_TYPES.has(blockType) || (0, import_template_reference.hasFlowSurfaceTemplateReference)(block == null ? void 0 : block.template)) {
+    return;
+  }
+  const fieldEntries = collectVisibleDataBlockFieldEntries(block, path);
+  const validBusinessFieldNames = collectVisibleDataBlockValidBusinessFieldNames(block, context, fieldEntries);
+  if (!fieldEntries.length || !validBusinessFieldNames.length) {
+    const hasBlockFields2 = Array.isArray(block == null ? void 0 : block.fields);
+    const hasBlockFieldGroups2 = Array.isArray(block == null ? void 0 : block.fieldGroups);
+    const fieldConfigPath2 = !hasBlockFields2 && hasBlockFieldGroups2 ? `${path}.fieldGroups` : `${path}.fields`;
+    const fieldConfigLabel2 = !hasBlockFields2 && hasBlockFieldGroups2 ? `${path}.fieldGroups[].fields` : `${path}.fields`;
+    const suggestedFields = pickVisibleDataBlockFieldSuggestions(block, context);
+    pushAuthoringError(errors, {
+      path: fieldConfigPath2,
+      ruleId: "data-block-visible-fields-required",
+      message: `flowSurfaces authoring ${path} ${blockType} block has no valid business fields. Add collection field names to ${fieldConfigLabel2}; defaults.collections.*.fieldGroups only configures generated popups/forms and is not a substitute for visible block columns.`,
+      details: {
+        blockType,
+        collection: getBlockCollectionName(block, context),
+        fieldCount: fieldEntries.length,
+        repairHint: VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT,
+        agentInstruction: REPAIR_ALL_ERRORS_AGENT_INSTRUCTION,
+        ...suggestedFields.length ? { suggestion: { fields: suggestedFields } } : {}
+      }
+    });
+    return;
+  }
+  if (!VISIBLE_FIELD_MINIMUM_DATA_BLOCK_TYPES.has(blockType)) {
+    return;
+  }
+  if (hasUnknownVisibleDataBlockFieldPath(block, context, fieldEntries)) {
+    return;
+  }
+  const eligibleBusinessFields = collectVisibleDataBlockEligibleBusinessFieldNames(block, context);
+  if (eligibleBusinessFields.length < RICH_COLLECTION_VISIBLE_FIELD_THRESHOLD) {
+    return;
+  }
+  const requiredFieldCount = Math.min(RICH_DATA_BLOCK_VISIBLE_FIELD_MINIMUM, eligibleBusinessFields.length);
+  if (validBusinessFieldNames.length >= requiredFieldCount) {
+    return;
+  }
+  const hasBlockFields = Array.isArray(block == null ? void 0 : block.fields);
+  const hasBlockFieldGroups = Array.isArray(block == null ? void 0 : block.fieldGroups);
+  const fieldConfigPath = !hasBlockFields && hasBlockFieldGroups ? `${path}.fieldGroups` : `${path}.fields`;
+  const fieldConfigLabel = !hasBlockFields && hasBlockFieldGroups ? `${path}.fieldGroups[].fields` : `${path}.fields`;
+  pushAuthoringError(errors, {
+    path: fieldConfigPath,
+    ruleId: "data-block-visible-fields-minimum",
+    message: `flowSurfaces authoring ${path} ${blockType} block only has ${validBusinessFieldNames.length} valid business field(s). Add at least ${requiredFieldCount} collection field names to ${fieldConfigLabel}; defaults.collections.*.fieldGroups only configures generated popups/forms and is not a substitute for visible block columns.`,
+    details: {
+      blockType,
+      collection: getBlockCollectionName(block, context),
+      fieldCount: validBusinessFieldNames.length,
+      requiredFieldCount,
+      eligibleBusinessFieldCount: eligibleBusinessFields.length,
+      repairHint: VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT,
+      agentInstruction: REPAIR_ALL_ERRORS_AGENT_INSTRUCTION,
+      suggestion: {
+        fields: eligibleBusinessFields.slice(0, requiredFieldCount)
+      }
+    }
+  });
+}
+function collectVisibleDataBlockFieldEntries(block, path) {
+  const entries = [];
+  if (Array.isArray(block == null ? void 0 : block.fields)) {
+    block.fields.forEach((field, index) => {
+      entries.push({ field, path: `${path}.fields[${index}]` });
+    });
+  }
+  if (Array.isArray(block == null ? void 0 : block.fieldGroups)) {
+    block.fieldGroups.forEach((group, groupIndex) => {
+      if (!Array.isArray(group == null ? void 0 : group.fields)) {
+        return;
+      }
+      group.fields.forEach((field, fieldIndex) => {
+        entries.push({
+          field,
+          path: `${path}.fieldGroups[${groupIndex}].fields[${fieldIndex}]`
+        });
+      });
+    });
+  }
+  return entries;
+}
+function collectVisibleDataBlockValidBusinessFieldNames(block, context, fieldEntries) {
+  const names = /* @__PURE__ */ new Set();
+  fieldEntries.forEach((entry) => {
+    const fieldPath = getAssociationAwareFieldPathInput(entry.field);
+    if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+      return;
+    }
+    if (!isVisibleDataBlockBusinessField(entry.field, block, context)) {
+      return;
+    }
+    names.add((0, import_service_helpers.normalizeFieldPath)(fieldPath));
+  });
+  return Array.from(names);
+}
+function hasUnknownVisibleDataBlockFieldPath(block, context, fieldEntries) {
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return false;
+  }
+  return fieldEntries.some((entry) => {
+    const fieldPath = getAssociationAwareFieldPathInput(entry.field);
+    if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+      return false;
+    }
+    return !(0, import_service_helpers.resolveFieldFromCollection)(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath));
+  });
+}
+function collectVisibleDataBlockEligibleBusinessFieldNames(block, context) {
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return [];
+  }
+  return (0, import_service_helpers.getCollectionFields)(collection).map((field) => {
+    const name = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+    if (!name || !isVisibleDataBlockMinimumCandidateResolvedField(field, name)) {
+      return "";
+    }
+    return name;
+  }).filter(Boolean);
+}
+function isVisibleDataBlockMinimumCandidateResolvedField(field, fieldName) {
+  if (!isVisibleDataBlockBusinessResolvedField(field, fieldName)) {
+    return false;
+  }
+  if ((0, import_service_helpers.isAssociationField)(field)) {
+    return false;
   }
-  if (hasOwn(block, "defaultActionSettings")) {
-    pushAuthoringError(errors, {
-      path: `${path}.defaultActionSettings`,
-      ruleId: "data-surface-block-default-action-settings-template-unsupported",
-      message: "Template-backed table, list, gridCard, calendar, and kanban blocks do not support defaultActionSettings; use filter action settings on direct blocks instead."
-    });
+  if (/Id$/.test(fieldName)) {
+    return false;
   }
+  return true;
 }
-function collectDefaultActionSettingsFilterErrors(defaultActionSettings, path, errors, block, context = {}) {
-  if (_.isUndefined(defaultActionSettings)) {
-    return;
+function isVisibleDataBlockBusinessField(field, block, context) {
+  const fieldPath = getAssociationAwareFieldPathInput(field);
+  if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+    return false;
   }
-  if (!_.isPlainObject(defaultActionSettings)) {
-    pushAuthoringError(errors, {
-      path,
-      ruleId: "defaultActionSettings-invalid-shape",
-      message: `flowSurfaces authoring ${path} must be an object`
-    });
-    return;
+  if (_.isPlainObject(field)) {
+    if (field.hidden === true || field.internal === true || field.synthetic === true || field.actionOnly === true) {
+      return false;
+    }
+    const semanticType = String(field.type || field.fieldType || field.interface || "").trim();
+    if (semanticType && NON_BUSINESS_VISIBLE_FIELD_TYPES.has(semanticType)) {
+      return false;
+    }
   }
-  if (!Object.prototype.hasOwnProperty.call(defaultActionSettings, "filter")) {
-    return;
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return true;
   }
-  if (!doesBlockConsumeDefaultFilterAction(block)) {
-    return;
+  const resolvedField = (0, import_service_helpers.resolveFieldFromCollection)(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath));
+  if (!resolvedField) {
+    return true;
   }
-  const filterSettings = defaultActionSettings.filter;
-  const filterSettingsPath = `${path}.filter`;
-  if (!_.isPlainObject(filterSettings)) {
-    pushAuthoringError(errors, {
-      path: filterSettingsPath,
-      ruleId: "defaultActionSettings-filter-invalid-shape",
-      message: `flowSurfaces authoring ${filterSettingsPath} must be an object`
-    });
-    return;
+  const fieldName = (0, import_service_helpers.getFieldName)(resolvedField) || fieldPath;
+  return isVisibleDataBlockBusinessResolvedField(resolvedField, fieldName);
+}
+function pickVisibleDataBlockFieldSuggestions(block, context) {
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return [];
   }
-  collectDefaultFilterErrors(
-    filterSettings.defaultFilter,
-    `${filterSettingsPath}.defaultFilter`,
-    errors,
-    block,
-    context
-  );
-  const filterableFieldNames = collectFilterableFieldNamesErrors(
-    filterSettings.filterableFieldNames,
-    `${filterSettingsPath}.filterableFieldNames`,
-    errors,
-    block,
-    context
-  );
-  const blockPath = path.replace(/\.defaultActionSettings$/, "");
-  const effectiveDefaultFilter = getEffectiveFilterSettingsDefaultFilter(
-    block,
-    filterSettings,
-    filterSettingsPath,
-    blockPath,
-    context
-  );
-  collectDefaultFilterFilterableFieldErrors(
-    effectiveDefaultFilter == null ? void 0 : effectiveDefaultFilter.value,
-    (effectiveDefaultFilter == null ? void 0 : effectiveDefaultFilter.path) || `${filterSettingsPath}.defaultFilter`,
-    filterableFieldNames,
-    errors
-  );
+  return (0, import_service_helpers.getCollectionFields)(collection).map((field) => {
+    const name = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+    if (!name || !isVisibleDataBlockBusinessResolvedField(field, name)) {
+      return "";
+    }
+    return name;
+  }).filter(Boolean).slice(0, 3);
 }
-function doesBlockConsumeDefaultFilterAction(block) {
-  const blockType = String((block == null ? void 0 : block.type) || "").trim();
-  return (0, import_public_data_surface_default_filter.isFlowSurfacePublicDataSurfaceBlockType)(blockType) && !(0, import_template_reference.hasFlowSurfaceTemplateDocument)(block == null ? void 0 : block.template);
+function isVisibleDataBlockBusinessResolvedField(field, fieldName) {
+  var _a;
+  if (NON_BUSINESS_VISIBLE_FIELD_NAMES.has(fieldName)) {
+    return false;
+  }
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  if (NON_BUSINESS_VISIBLE_FIELD_INTERFACES.has(fieldInterface)) {
+    return false;
+  }
+  const fieldType = String((0, import_service_helpers.getFieldType)(field) || "").trim();
+  if (NON_BUSINESS_VISIBLE_FIELD_TYPES.has(fieldType)) {
+    return false;
+  }
+  if ((field == null ? void 0 : field.hidden) === true || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.hidden) === true) {
+    return false;
+  }
+  return true;
 }
 function hasConcreteFilterItem(value) {
   if (!_.isPlainObject(value)) {
@@ -4377,6 +5374,15 @@ function collectChartDisplayTitleErrors(block, blockType, blockPath, errors) {
     message: "Chart block settings do not support displayTitle in the current flowSurfaces runtime; keep settings.title and omit displayTitle."
   });
 }
+function collectChartConfigureFilterOperatorErrors(changes, hostBlockType, path, errors) {
+  if (hostBlockType !== "chart" || !_.isPlainObject(changes)) {
+    return;
+  }
+  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors);
+  if (_.isPlainObject(changes.configure)) {
+    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors);
+  }
+}
 function visitFilterItems(value, path, errors, block, context = {}) {
   if (Array.isArray(value)) {
     value.forEach((item, index) => visitFilterItems(item, `${path}[${index}]`, errors, block, context));
@@ -4391,6 +5397,7 @@ function visitFilterItems(value, path, errors, block, context = {}) {
   }
   if (typeof value.operator === "string") {
     collectUnsupportedDefaultFilterOperatorError(value.operator, `${path}.operator`, errors);
+    collectDefaultFilterDateValueError(value.operator, value.value, `${path}.value`, errors);
   }
   const filterItems = value.items;
   if (Array.isArray(filterItems)) {
@@ -4414,8 +5421,9 @@ function visitFilterItems(value, path, errors, block, context = {}) {
     }
     collectDefaultFilterFieldPathError(key, `${path}.${key}`, block, context, errors);
     if (_.isPlainObject(child)) {
-      Object.keys(child).forEach((operator) => {
+      Object.entries(child).forEach(([operator, operatorValue]) => {
         collectUnsupportedDefaultFilterOperatorError(operator, `${path}.${key}.${operator}`, errors);
+        collectDefaultFilterDateValueError(operator, operatorValue, `${path}.${key}.${operator}`, errors);
       });
     }
   });
@@ -4768,6 +5776,87 @@ function getCollectionFilterTargetKey(collection) {
 function normalizeDataSourceKey(value) {
   return String(value || "main").trim() || "main";
 }
+function collectTableSettingsErrors(block, blockType, blockPath, errors, options = {}) {
+  if (blockType !== "table" || !_.isPlainObject(block)) {
+    return;
+  }
+  TABLE_INTERNAL_AUTHORING_KEYS.forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(block, key)) {
+      pushTableSettingsUnsupportedError(errors, `${blockPath}.${key}`, key);
+    }
+  });
+  const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
+  if (!hasSettings) {
+    return;
+  }
+  const settings = block.settings;
+  const settingsPath = `${blockPath}.settings`;
+  Object.keys(settings).forEach((key) => {
+    if (TABLE_ALLOWED_SETTINGS_KEYS.has(key) && options.directSettings !== true) {
+      return;
+    }
+    if (options.directSettings === true && !TABLE_INTERNAL_AUTHORING_KEYS.includes(key)) {
+      return;
+    }
+    pushTableSettingsUnsupportedError(errors, `${settingsPath}.${key}`, key);
+  });
+  if (!shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
+    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors);
+  }
+}
+function pushTableSettingsUnsupportedError(errors, path, key) {
+  pushAuthoringError(errors, {
+    path,
+    ruleId: "table-settings-unsupported-key",
+    message: `flowSurfaces authoring ${path} is not part of the public table settings contract`,
+    details: {
+      key,
+      allowedKeys: Array.from(TABLE_ALLOWED_SETTINGS_KEYS),
+      repairHint: TABLE_SETTINGS_REPAIR_HINT
+    }
+  });
+}
+function collectPublicDataScopeErrors(value, path, errors) {
+  if (_.isUndefined(value)) {
+    return;
+  }
+  if (value === null || _.isPlainObject(value) && !Object.keys(value).length) {
+    return;
+  }
+  const validationValue = normalizePublicDataScopeValueForValidation(value);
+  try {
+    (0, import_filter_group.assertFlowSurfaceFilterGroupShape)(validationValue);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "dataScope-filter-group-invalid-shape",
+      message: `flowSurfaces authoring ${path} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}: ${reason}`,
+      details: {
+        repairHint: 'Use settings.dataScope with logic/items, for example {"logic":"$and","items":[{"path":"status","operator":"$eq","value":"Active"}]}; do not use a field-name map.'
+      }
+    });
+  }
+}
+function shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options) {
+  if (options.deferPublicDataScopeErrors !== true) {
+    return false;
+  }
+  if (!/^\$\.blocks\[\d+\]$/.test(blockPath)) {
+    return false;
+  }
+  return !errors.some((error) => error.path === `${blockPath}.settings.dataScope`);
+}
+function normalizePublicDataScopeValueForValidation(value) {
+  if (!_.isPlainObject(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 1 && keys[0] === "filter") {
+    return value.filter;
+  }
+  return value;
+}
 function collectGridCardSettingsErrors(block, blockType, blockPath, errors, options = {}) {
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings && options.directSettings !== true) {
@@ -4853,8 +5942,115 @@ function collectActionListErrors(actions, path, errors, block, context = {}, slo
   if (!Array.isArray(actions)) {
     return;
   }
+  collectDuplicateAIEmployeeActionErrors(actions, path, errors, block);
   actions.forEach((action, index) => collectActionErrors(action, `${path}[${index}]`, errors, block, context, slot));
 }
+function collectDuplicateAIEmployeeActionErrors(actions, path, errors, block) {
+  const seen = /* @__PURE__ */ new Map();
+  actions.forEach((action, index) => {
+    const actionType = resolveAuthoringActionType(action, block);
+    if (actionType !== "aiEmployee" || !_.isPlainObject(action)) {
+      return;
+    }
+    const identity = buildAuthoringAIEmployeeActionIdentity(action.settings);
+    if (!identity) {
+      return;
+    }
+    const currentPath = `${path}[${index}]`;
+    const previousPath = seen.get(identity);
+    if (previousPath) {
+      pushAuthoringError(errors, {
+        path: currentPath,
+        ruleId: "duplicate-ai-employee-action",
+        message: `flowSurfaces authoring ${currentPath} duplicates an existing AI employee action in the same action container; reuse or update the existing button instead of appending another identical AI employee action.`,
+        details: {
+          duplicateOf: previousPath,
+          repairHint: "Remove the duplicate aiEmployee action, or change username, task title/key, or workContext if this is a genuinely different AI employee action."
+        }
+      });
+      return;
+    }
+    seen.set(identity, currentPath);
+  });
+}
+function buildAuthoringAIEmployeeActionIdentity(settings) {
+  if (!_.isPlainObject(settings)) {
+    return "";
+  }
+  const username = String(settings.username || "").trim();
+  if (!username) {
+    return "";
+  }
+  return stableSerializeAuthoringValue(normalizeAuthoringAIEmployeePublicSettingsForIdentity(settings));
+}
+function normalizeAuthoringAIEmployeePublicSettingsForIdentity(settings) {
+  return {
+    username: String(settings.username || "").trim(),
+    auto: typeof settings.auto === "boolean" ? settings.auto : false,
+    workContext: Object.prototype.hasOwnProperty.call(settings, "workContext") ? normalizeAuthoringAIEmployeeWorkContextForIdentity(settings.workContext) : [{ type: "flow-model", target: "self" }],
+    tasks: normalizeAuthoringAIEmployeeTasksForIdentity(settings.tasks),
+    style: {
+      ...AUTHORING_AI_EMPLOYEE_DEFAULT_STYLE,
+      ..._.isPlainObject(settings.style) ? _.pick(settings.style, AUTHORING_AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
+    }
+  };
+}
+function normalizeAuthoringAIEmployeeWorkContextForIdentity(value) {
+  return _.castArray(value || []).map((item) => {
+    if (!_.isPlainObject(item)) {
+      return item;
+    }
+    const output = _.pick(item, AUTHORING_AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS);
+    if (!Object.prototype.hasOwnProperty.call(output, "type") || _.isUndefined(output.type) || output.type === null) {
+      output.type = "flow-model";
+    }
+    return output;
+  });
+}
+function normalizeAuthoringAIEmployeeTasksForIdentity(value) {
+  return _.castArray(value || []).map((task) => {
+    if (!_.isPlainObject(task)) {
+      return task;
+    }
+    const output = _.pick(task, AUTHORING_AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS);
+    if (_.isPlainObject(output.message)) {
+      output.message = _.pick(output.message, AUTHORING_AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS);
+      if (_.isPlainObject(output.message.workContext)) {
+        output.message.workContext = normalizeAuthoringAIEmployeeWorkContextForIdentity(output.message.workContext);
+      } else if (Array.isArray(output.message.workContext)) {
+        output.message.workContext = normalizeAuthoringAIEmployeeWorkContextForIdentity(output.message.workContext);
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(task, "prompt") && !Object.prototype.hasOwnProperty.call(output.message || {}, "user")) {
+      output.message = {
+        ..._.isPlainObject(output.message) ? output.message : {},
+        user: task.prompt
+      };
+    }
+    if (_.isPlainObject(output.model)) {
+      output.model = _.pick(output.model, AUTHORING_AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS);
+    }
+    if (_.isPlainObject(output.skillSettings)) {
+      output.skillSettings = _.pick(output.skillSettings, AUTHORING_AI_EMPLOYEE_SKILL_SETTINGS_PUBLIC_KEYS);
+      if (Array.isArray(output.skillSettings.skills) && !Object.prototype.hasOwnProperty.call(output.skillSettings, "skillsVersion")) {
+        output.skillSettings.skillsVersion = 2;
+      }
+      if (Array.isArray(output.skillSettings.tools) && !Object.prototype.hasOwnProperty.call(output.skillSettings, "toolsVersion")) {
+        output.skillSettings.toolsVersion = 2;
+      }
+    }
+    return output;
+  });
+}
+function stableSerializeAuthoringValue(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerializeAuthoringValue(item)).join(",")}]`;
+  }
+  if (_.isPlainObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableSerializeAuthoringValue(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
 function resolveAuthoringActionType(action, block) {
   const rawType = typeof action === "string" ? action : _.isPlainObject(action) ? action.type : "";
   const normalized = String(rawType || "").trim().toLowerCase();
@@ -5301,6 +6497,7 @@ function collectFieldListErrors(fields, path, errors, localKeys, context, block)
     if (fieldPath) {
       collectUnknownFieldPathError(fieldPath, `${path}[${index}]`, block, context, errors);
     }
+    collectImplicitRelationTitleFieldErrors(field, `${path}[${index}]`, block, context, errors);
     if (!_.isPlainObject(field)) {
       return;
     }
@@ -5388,7 +6585,8 @@ function collectApplyBlueprintScriptAssetReferenceErrors(spec, path, errors, con
       pushAuthoringError(errors, {
         path: `${path}.script`,
         ruleId: "apply-blueprint-script-asset-key-invalid",
-        message: `flowSurfaces applyBlueprint ${publicPath}.script must be a non-empty string asset key; use settings.code for inline JS code`
+        message: `flowSurfaces applyBlueprint ${publicPath}.script must be a non-empty string asset key; use settings.code for inline JS code`,
+        details: withJsBlockRepairHint()
       });
       return;
     }
@@ -5399,14 +6597,18 @@ function collectApplyBlueprintScriptAssetReferenceErrors(spec, path, errors, con
     pushAuthoringError(errors, {
       path: `${path}.script`,
       ruleId: "apply-blueprint-script-asset-code-required",
-      message: `flowSurfaces applyBlueprint ${publicPath}.script references script asset '${scriptKey}' without non-empty code; use settings.code for inline JS code`
+      message: `flowSurfaces applyBlueprint ${publicPath}.script references script asset '${scriptKey}' without non-empty code; use settings.code for inline JS code`,
+      details: withJsBlockRepairHint({
+        scriptKey
+      })
     });
     return;
   }
   pushAuthoringError(errors, {
     path: `${path}.script`,
     ruleId: "apply-blueprint-script-asset-key-invalid",
-    message: `flowSurfaces applyBlueprint ${publicPath}.script must be a string asset key; use settings.code for inline JS code`
+    message: `flowSurfaces applyBlueprint ${publicPath}.script must be a string asset key; use settings.code for inline JS code`,
+    details: withJsBlockRepairHint()
   });
 }
 function hasApplyBlueprintRunnableScriptAssetReference(script, context) {
@@ -5616,6 +6818,106 @@ function collectRelationTitleFieldErrors(fieldSpec, path, block, context, errors
     })
   });
 }
+function collectImplicitRelationTitleFieldErrors(fieldSpec, path, block, context, errors) {
+  var _a;
+  if (context.authoringActionName !== "applyBlueprint") {
+    return;
+  }
+  const hostBlockType = String((block == null ? void 0 : block.type) || "").trim();
+  if (!IMPLICIT_RELATION_TITLE_FIELD_DISPLAY_BLOCK_TYPES.has(hostBlockType)) {
+    return;
+  }
+  if (_.isPlainObject(fieldSpec) && fieldSpec.__autoPopupForRelationField === true) {
+    return;
+  }
+  if (_.isPlainObject(fieldSpec) && Object.prototype.hasOwnProperty.call(fieldSpec, "titleField")) {
+    return;
+  }
+  const fieldPath = getFieldPathInput(fieldSpec);
+  if (!fieldPath || fieldPath.includes(".")) {
+    return;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection || !context.getCollection) {
+    return;
+  }
+  const resolvedField = (0, import_service_helpers.resolveFieldFromCollection)(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath));
+  if (!resolvedField || !(0, import_service_helpers.isAssociationField)(resolvedField)) {
+    return;
+  }
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  if (hasUsableDefaultFieldGroupRelationTitleField({
+    fieldGroups: (_a = context.getDefaultFieldGroups) == null ? void 0 : _a.call(context, dataSourceKey, getBlockCollectionName(block, context)),
+    fieldPath,
+    field: resolvedField,
+    dataSourceKey,
+    context
+  })) {
+    return;
+  }
+  const registeredBinding = (0, import_field_binding_registry.resolveRegisteredFieldBinding)({
+    containerUse: IMPLICIT_RELATION_TITLE_FIELD_CONTAINER_USE_BY_BLOCK_TYPE[hostBlockType],
+    field: resolvedField,
+    dataSourceKey,
+    enabledPackages: context.enabledPackages,
+    getCollection: (resolvedDataSourceKey, targetCollectionName) => {
+      var _a2;
+      return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollectionName);
+    },
+    useStrictOnly: true
+  });
+  if (registeredBinding == null ? void 0 : registeredBinding.modelClassName) {
+    return;
+  }
+  try {
+    const resolvedTitleField = (0, import_association_title_field.resolveAssociationSafeTitleField)(resolvedField, dataSourceKey, context.getCollection, {
+      action: context.authoringActionName,
+      path: `${path}.titleField`,
+      fieldPath
+    });
+    if (!(resolvedTitleField == null ? void 0 : resolvedTitleField.fieldName)) {
+      pushAuthoringError(errors, {
+        path: `${path}.titleField`,
+        ruleId: "relation-titleField-unavailable",
+        message: `flowSurfaces authoring ${path} relation field '${fieldPath}' requires an explicit readable titleField`,
+        details: {
+          fieldPath,
+          repairHint: `Use object field form such as {"field":"${fieldPath}","titleField":"<readable target field>"}.`
+        }
+      });
+    }
+  } catch (error) {
+    if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
+      throw error;
+    }
+    pushAuthoringError(errors, {
+      path: `${path}.titleField`,
+      ruleId: error.options.ruleId || "relation-titleField-unavailable",
+      message: `flowSurfaces authoring ${path} relation field '${fieldPath}' requires an explicit readable titleField`,
+      details: {
+        ...error.options.details || {},
+        fieldPath,
+        repairHint: `Use object field form such as {"field":"${fieldPath}","titleField":"<readable target field>"}.`
+      }
+    });
+  }
+}
+function hasUsableDefaultFieldGroupRelationTitleField(input) {
+  const titleField = (0, import_defaults.getFlowSurfaceDefaultFieldGroupRelationTitleFieldOverride)(input.fieldGroups, input.fieldPath);
+  if (!titleField || titleField === "id" || !input.context.getCollection) {
+    return false;
+  }
+  const targetCollection = (0, import_service_helpers.resolveFieldTargetCollection)(
+    input.field,
+    input.dataSourceKey,
+    (dataSourceKey, collectionName) => {
+      var _a, _b;
+      return (_b = (_a = input.context).getCollection) == null ? void 0 : _b.call(_a, dataSourceKey, collectionName);
+    }
+  );
+  const targetField = targetCollection ? (0, import_service_helpers.resolveFieldFromCollection)(targetCollection, titleField) : void 0;
+  return !!targetField && !(0, import_service_helpers.isAssociationField)(targetField);
+}
 function getRelationTitleFieldInvalidReason(titleField, targetField) {
   if (titleField === "id") {
     return "id";
@@ -5649,18 +6951,18 @@ function getRecordHistoryDeclaredFilterTargetKey(collection) {
   return String(raw || "").trim();
 }
 function collectionHasConcreteField(collection, fieldName) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c;
   const normalized = String(fieldName || "").trim();
   if (!normalized) {
     return false;
   }
-  const modelAttributes = (typeof ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.getAttributes) === "function" ? collection.model.getAttributes() : null) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.rawAttributes) || ((_c = collection == null ? void 0 : collection.model) == null ? void 0 : _c.attributes) || {};
+  const modelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(collection);
   const primaryKeyAttributes = _.castArray(
-    ((_d = collection == null ? void 0 : collection.model) == null ? void 0 : _d.primaryKeyAttributes) || ((_e = collection == null ? void 0 : collection.model) == null ? void 0 : _e.primaryKeyAttribute) || []
+    ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.primaryKeyAttributes) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.primaryKeyAttribute) || []
   );
   const modelAttribute = modelAttributes == null ? void 0 : modelAttributes[normalized];
   const isModelPrimaryKey = primaryKeyAttributes.includes(normalized) || !!(modelAttribute == null ? void 0 : modelAttribute.primaryKey);
-  return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_f = collection == null ? void 0 : collection.getField) == null ? void 0 : _f.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
+  return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_c = collection == null ? void 0 : collection.getField) == null ? void 0 : _c.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
 }
 function collectDefaultFilterFieldPathError(rawFieldPath, path, block, context, errors) {
   const fieldPath = String(rawFieldPath || "").trim();