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

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

@@ -42,6 +42,7 @@ module.exports = __toCommonJS(service_exports);
 var import_crypto = require("crypto");
 var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
+var antDesignIconAsn = __toESM(require("@ant-design/icons-svg"));
 var import_repository = __toESM(require("../repository"));
 var import_catalog = require("./catalog");
 var import_action_scope = require("./action-scope");
@@ -80,6 +81,7 @@ var import_placement = require("./placement");
 var import_route_sync = require("./route-sync");
 var import_surface_context = require("./surface-context");
 var import_context = require("./context");
+var import_event_flow_normalizer = require("./event-flow-normalizer");
 var import_configure_options = require("./configure-options");
 var import_public_compatibility = require("./public-compatibility");
 var import_support_matrix = require("./support-matrix");
@@ -102,6 +104,131 @@ var import_template_service_utils = require("./template-service-utils");
 var import_hidden_popup_contract = require("./hidden-popup-contract");
 var import_hidden_popup_calendar = require("./hidden-popup-calendar");
 var import_hidden_popup_kanban = require("./hidden-popup-kanban");
+const FLOW_SURFACE_CHART_REPAIR_HINT = "This is a chart payload shape problem. Keep using chart and repair the current chart block payload 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. Do not drop or defer the chart. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const FLOW_SURFACE_CHART_REPAIR_STEPS = [
+  "Keep the block type as chart.",
+  "Define assets.charts.<key>.query and assets.charts.<key>.visual, or fill localized settings.query and settings.visual on the existing chart block.",
+  "Reference the asset from the chart block with block.chart = <key> when using assets.charts.",
+  "Retry the chart payload instead of replacing the chart with another block type, omitting it, or deferring it."
+];
+const FLOW_SURFACE_CHART_EXPECTED_SHAPE = {
+  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"
+      }
+    }
+  },
+  assets: {
+    charts: {
+      chartKey: {
+        query: "builder/sql query configuration",
+        visual: "basic/custom visual configuration"
+      }
+    }
+  },
+  block: {
+    type: "chart",
+    chart: "chartKey"
+  }
+};
+const FLOW_SURFACE_CHART_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "jsBlock",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop chart",
+  "defer chart"
+];
+const FLOW_SURFACE_CHART_REPAIR_EXAMPLE = {
+  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"
+      }
+    }
+  }
+};
+function withChartRepairMessage(message) {
+  return `${message}. ${FLOW_SURFACE_CHART_REPAIR_HINT}`;
+}
+function withFlowSurfaceChartRepairDetails(details = {}) {
+  return {
+    ...details,
+    requiredBlockType: "chart",
+    fixStrategy: "repair_same_block_type",
+    repairHint: FLOW_SURFACE_CHART_REPAIR_HINT,
+    repairSteps: FLOW_SURFACE_CHART_REPAIR_STEPS,
+    expectedShape: FLOW_SURFACE_CHART_EXPECTED_SHAPE,
+    repairExample: FLOW_SURFACE_CHART_REPAIR_EXAMPLE,
+    forbiddenFallbacks: FLOW_SURFACE_CHART_FORBIDDEN_FALLBACKS
+  };
+}
+function throwChartRepairBadRequest(message, options = {}) {
+  const details = import_lodash.default.isPlainObject(options.details) ? options.details : {};
+  (0, import_errors.throwBadRequest)(withChartRepairMessage(message), {
+    ...options,
+    details: withFlowSurfaceChartRepairDetails(details)
+  });
+}
+function isChartConfigureBadRequestError(error) {
+  return error instanceof import_errors.FlowSurfaceBadRequestError && String(error.message || "").startsWith("chart ");
+}
+function buildChartConfigureFromSemanticChangesWithRepair(currentConfigure, changes) {
+  try {
+    return (0, import_chart_config.buildChartConfigureFromSemanticChanges)(currentConfigure, changes);
+  } catch (error) {
+    if (isChartConfigureBadRequestError(error)) {
+      throwChartRepairBadRequest(error.message, error.options);
+    }
+    throw error;
+  }
+}
+function isFlowSurfaceChartRepairError(error) {
+  var _a, _b;
+  return error instanceof import_errors.FlowSurfaceBadRequestError && ((_b = (_a = error.options) == null ? void 0 : _a.details) == null ? void 0 : _b.repairHint) === FLOW_SURFACE_CHART_REPAIR_HINT;
+}
 const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel", ...import_approval.APPROVAL_FORM_BLOCK_USES]);
 const AUTO_SUBMIT_FORM_BLOCK_USES = /* @__PURE__ */ new Set(["CreateFormModel", "EditFormModel"]);
 const FLOW_SURFACE_DEFAULT_ACTION_SETTINGS_KEYS = /* @__PURE__ */ new Set(["filter"]);
@@ -251,6 +378,17 @@ const JS_ACTION_USES = /* @__PURE__ */ new Set([
   "JSActionModel"
 ]);
 const JS_ITEM_ACTION_USES = /* @__PURE__ */ new Set(["JSItemActionModel"]);
+const JS_POPUP_GUIDANCE_MESSAGE = "should use ctx.openView to open popup";
+const JS_POPUP_GUIDANCE_USES = /* @__PURE__ */ new Set([
+  ...JS_ACTION_USES,
+  ...JS_ITEM_ACTION_USES,
+  "JSColumnModel",
+  "JSItemModel",
+  "JSFieldModel",
+  "JSEditableFieldModel",
+  "FormJSFieldItemModel"
+]);
+const JS_POPUP_GUIDANCE_PUBLIC_KEYS = /* @__PURE__ */ new Set(["js", "jsColumn", "jsItem"]);
 const POPUP_ACTION_USES = /* @__PURE__ */ new Set([
   "AddNewActionModel",
   "ViewActionModel",
@@ -264,6 +402,24 @@ const POPUP_ACTION_USES = /* @__PURE__ */ new Set([
   "AddChildActionModel",
   "MailSendActionModel"
 ]);
+function withJsPopupGuidance(message, value) {
+  const normalizedValue = String(value || "").trim();
+  if (JS_POPUP_GUIDANCE_USES.has(normalizedValue) || JS_POPUP_GUIDANCE_PUBLIC_KEYS.has(normalizedValue)) {
+    return `${message}; ${JS_POPUP_GUIDANCE_MESSAGE}`;
+  }
+  return message;
+}
+function assertNoJsDeclarativeOpenView(context, changes, use) {
+  const normalizedUse = String(use || "").trim();
+  if ((0, import_service_utils.hasOwnDefined)(changes, "openView") && JS_POPUP_GUIDANCE_USES.has(normalizedUse)) {
+    (0, import_errors.throwBadRequest)(
+      withJsPopupGuidance(
+        `flowSurfaces configure ${context} '${normalizedUse}' does not support openView`,
+        normalizedUse
+      )
+    );
+  }
+}
 const POPUP_HOST_DEFAULT_RECORD_CONTEXT_ACTION_USES = /* @__PURE__ */ new Set([
   "ViewActionModel",
   "EditActionModel",
@@ -457,16 +613,25 @@ const UPDATE_SETTINGS_STEP_PARAM_MIRRORS_BY_USE = {
   DividerItemModel: DIVIDER_ITEM_STEP_PARAM_MIRRORS
 };
 const FLOW_SURFACE_MENU_BINDABLE_OPTION_KEY = "flowSurfaceMenuBindable";
+const ANT_DESIGN_ICON_NAMES = new Set(Object.keys(antDesignIconAsn || {}));
 const AI_EMPLOYEE_ACTION_USE = "AIEmployeeButtonModel";
 const AI_EMPLOYEE_OWNER_PLUGIN = "@nocobase/plugin-ai";
 const AI_EMPLOYEE_PUBLIC_SETTING_KEYS = ["username", "auto", "workContext", "tasks", "style"];
 const AI_EMPLOYEE_INTERNAL_PROP_KEYS = ["aiEmployee", "context", "auto", "tasks", "style"];
+const AI_EMPLOYEE_TASK_STEP_PARAMS_PATH = ["shortcutSettings", "editTasks", "tasks"];
 const AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS = ["type", "uid", "target"];
 const AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS = ["title", "message", "autoSend", "skillSettings", "model", "webSearch"];
+const AI_EMPLOYEE_TASK_PATCH_PUBLIC_SETTING_KEYS = [...AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS, "prompt"];
 const AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS = ["system", "user", "workContext"];
 const AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS = ["llmService", "model"];
 const AI_EMPLOYEE_SKILL_SETTINGS_PUBLIC_KEYS = ["skills", "tools", "skillsVersion", "toolsVersion"];
 const AI_EMPLOYEE_STYLE_PUBLIC_KEYS = ["size", "mask"];
+const AI_EMPLOYEE_WORK_CONTEXT_REPAIR_HINT = 'Use workContext entries like { "target": "self" } or { "uid": "<flow-model-uid>" }. The only supported type is flow-model, so type is optional and defaults to flow-model.';
+const AI_EMPLOYEE_TASK_REPAIR_HINT = "Use task keys title, message, prompt, autoSend, skillSettings, model, and webSearch. Put user instructions in tasks[n].message.user or the prompt alias; do not write raw props, stepParams, or prompt beside message.user.";
+const AI_EMPLOYEE_PROMPT_CONTEXT_MAX_DEPTH = 8;
+const AI_EMPLOYEE_PROMPT_VARIABLE_INVALID = "FLOW_SURFACE_AI_EMPLOYEE_PROMPT_VARIABLE_INVALID";
+const AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE = "{{ ctx.record }}";
+const AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE_RE = /\{\{\s*ctx\.record\s*\}\}/;
 const AI_EMPLOYEE_DEFAULT_STYLE = {
   size: 40,
   mask: false
@@ -710,10 +875,16 @@ class FlowSurfacesService {
     );
   }
   async loadEnabledPluginPackages(transaction) {
-    if (!this.db.getCollection("applicationPlugins")) {
+    var _a;
+    const db = this.db;
+    if (!((_a = db == null ? void 0 : db.getCollection) == null ? void 0 : _a.call(db, "applicationPlugins")) || !(db == null ? void 0 : db.getRepository)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const repository = db.getRepository("applicationPlugins");
+    if (!(repository == null ? void 0 : repository.find)) {
       return /* @__PURE__ */ new Set();
     }
-    const plugins = await this.db.getRepository("applicationPlugins").find({
+    const plugins = await repository.find({
       fields: ["packageName"],
       filter: {
         enabled: true
@@ -721,8 +892,8 @@ class FlowSurfacesService {
       transaction
     });
     const packageNames = plugins.map((plugin) => {
-      var _a;
-      return ((_a = plugin == null ? void 0 : plugin.get) == null ? void 0 : _a.call(plugin, "packageName")) || (plugin == null ? void 0 : plugin.packageName);
+      var _a2;
+      return ((_a2 = plugin == null ? void 0 : plugin.get) == null ? void 0 : _a2.call(plugin, "packageName")) || (plugin == null ? void 0 : plugin.packageName);
     }).filter((packageName) => typeof packageName === "string" && !!packageName.trim()).map((packageName) => packageName.trim());
     return new Set(packageNames);
   }
@@ -762,6 +933,18 @@ class FlowSurfacesService {
       })
     );
   }
+  routeParentIdMatches(routeParentId, parentId) {
+    if (import_lodash.default.isNil(routeParentId) && import_lodash.default.isNil(parentId)) {
+      return true;
+    }
+    return String(routeParentId ?? "") === String(parentId ?? "");
+  }
+  async findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction) {
+    const routes = await this.findMenuGroupRoutesByTitle(title, transaction);
+    return routes.filter(
+      (route) => this.routeParentIdMatches(this.readRouteField(route, "parentId") ?? null, parentId)
+    );
+  }
   async findFlowPageRoutesByParentIdAndTitle(parentId, title, transaction) {
     const normalizedTitle = String(title || "").trim();
     const normalizedParentId = String(parentId ?? "").trim();
@@ -843,20 +1026,97 @@ class FlowSurfacesService {
       ...extras
     };
   }
+  isValidMenuIconName(value) {
+    const normalized = String(value || "").trim();
+    return !!normalized && ANT_DESIGN_ICON_NAMES.has(normalized);
+  }
+  assertVisibleNavigationIcon(actionName, path, values) {
+    if (values.hideInMenu === true) {
+      return;
+    }
+    const icon = String(values.icon || "").trim();
+    if (!icon) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.icon is required when creating a visible menu route`, {
+        ruleId: "navigation-icon-required",
+        path: `${path}.icon`,
+        details: {
+          repairHint: "Pass a valid Ant Design icon name such as AppstoreOutlined, DashboardOutlined, or FolderOpenOutlined."
+        }
+      });
+    }
+    if (!this.isValidMenuIconName(icon)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.icon must be a valid Ant Design icon name`, {
+        ruleId: "navigation-icon-unknown",
+        path: `${path}.icon`,
+        details: {
+          icon
+        }
+      });
+    }
+  }
+  assertVisibleNavigationRouteIconUpdate(actionName, path, route, values) {
+    if (!Object.prototype.hasOwnProperty.call(values, "icon") || this.readRouteField(route, "hideInMenu") === true) {
+      return;
+    }
+    const icon = String(values.icon || "").trim();
+    if (!icon) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.icon cannot be empty for a visible menu route`, {
+        ruleId: "navigation-icon-required",
+        path: `${path}.icon`,
+        details: {
+          repairHint: "Pass a valid Ant Design icon name such as AppstoreOutlined, DashboardOutlined, or FolderOpenOutlined."
+        }
+      });
+    }
+    if (!this.isValidMenuIconName(icon)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.icon must be a valid Ant Design icon name`, {
+        ruleId: "navigation-icon-unknown",
+        path: `${path}.icon`,
+        details: {
+          icon
+        }
+      });
+    }
+  }
   async createFlowMenuGroup(values, transaction) {
     const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, transaction);
+    const parentId = this.readRouteField(parentRoute, "id") ?? null;
+    const title = String(values.title || "").trim();
+    const existingGroups = await this.findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction);
+    if (existingGroups.length === 1) {
+      return this.buildMenuResult(existingGroups[0]);
+    }
+    if (existingGroups.length > 1) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces createMenu group title '${title}' is ambiguous under parentMenuRouteId '${values.parentMenuRouteId ?? "root"}'; use an explicit existing navigation.group.routeId or clean up duplicate menu groups before retrying`,
+        {
+          ruleId: "menu-group-title-ambiguous-under-parent",
+          details: {
+            title,
+            parentMenuRouteId: values.parentMenuRouteId ?? null,
+            matches: existingGroups.map((route2) => ({
+              routeId: this.readRouteField(route2, "id"),
+              parentMenuRouteId: this.readRouteField(route2, "parentId") ?? null,
+              type: this.readRouteField(route2, "type"),
+              schemaUid: this.readRouteField(route2, "schemaUid") ?? null
+            }))
+          }
+        }
+      );
+    }
+    this.assertVisibleNavigationIcon("createMenu", "values", values);
     const schemaUid = values.schemaUid || (0, import_utils.uid)();
     const desktopRoutes = this.db.getRepository("desktopRoutes");
     await desktopRoutes.create({
       values: {
         type: "group",
         sort: this.allocateRouteSortValue(),
-        title: values.title,
+        title,
         icon: values.icon,
         tooltip: values.tooltip,
         schemaUid,
         hideInMenu: !!values.hideInMenu,
-        parentId: this.readRouteField(parentRoute, "id") ?? null
+        parentId
       },
       transaction
     });
@@ -869,6 +1129,7 @@ class FlowSurfacesService {
   async createFlowMenuItem(values, transaction) {
     var _a;
     const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, transaction);
+    this.assertVisibleNavigationIcon("createMenu", "values", values);
     const pageSchemaUid = values.pageSchemaUid || (0, import_utils.uid)();
     const pageUid = values.pageUid || (0, import_utils.uid)();
     const tabSchemaUid = values.tabSchemaUid || (0, import_utils.uid)();
@@ -903,7 +1164,7 @@ class FlowSurfacesService {
             parentId: null,
             options: {
               documentTitle: values.tabDocumentTitle,
-              flowRegistry: values.tabFlowRegistry || {}
+              flowRegistry: this.normalizeEventFlowRegistry("createMenu", values.tabFlowRegistry || {})
             }
           }
         ]
@@ -2596,6 +2857,10 @@ class FlowSurfacesService {
       ),
       options.transaction
     );
+    if (!(rawNode == null ? void 0 : rawNode.uid)) {
+      const resolvedUid = String((resolved == null ? void 0 : resolved.uid) || "").trim() || String(target.uid || target.tabSchemaUid || target.pageSchemaUid || target.routeId || "").trim() || "unknown";
+      (0, import_errors.throwBadRequest)(`flowSurfaces:get target '${resolvedUid}' could not resolve a readable surface tree`);
+    }
     const publicNode = this.stripInternalSurfaceMetaFromNodeTree(import_lodash.default.cloneDeep(rawNode));
     return this.buildSurfaceReadPayload(target, resolved, publicNode, options);
   }
@@ -2630,7 +2895,7 @@ class FlowSurfacesService {
           use: "RootPageTabModel",
           props: import_lodash.default.omit(import_lodash.default.cloneDeep((currentNode == null ? void 0 : currentNode.props) || {}), ["route"]),
           decoratorProps: import_lodash.default.cloneDeep((currentNode == null ? void 0 : currentNode.decoratorProps) || {}),
-          flowRegistry: import_lodash.default.cloneDeep((currentNode == null ? void 0 : currentNode.flowRegistry) || {}),
+          flowRegistry: this.getEventFlowRegistry(currentNode),
           stepParams: import_lodash.default.cloneDeep((values == null ? void 0 : values.stepParams) || (currentNode == null ? void 0 : currentNode.stepParams) || {})
         }),
         { transaction: options == null ? void 0 : options.transaction }
@@ -2767,13 +3032,13 @@ class FlowSurfacesService {
     if (!groupTitle) {
       return document;
     }
-    const matchedRoutes = await this.findMenuGroupRoutesByTitle(groupTitle, transaction);
+    const matchedRoutes = await this.findMenuGroupRoutesByParentIdAndTitle(null, groupTitle, transaction);
     if (!matchedRoutes.length) {
       return document;
     }
     if (matchedRoutes.length > 1) {
       (0, import_errors.throwBadRequest)(
-        `flowSurfaces applyBlueprint navigation.group.title '${groupTitle}' matches ${matchedRoutes.length} existing menu groups; pass navigation.group.routeId explicitly`
+        `flowSurfaces applyBlueprint navigation.group.title '${groupTitle}' matches ${matchedRoutes.length} existing root menu groups; pass navigation.group.routeId explicitly`
       );
     }
     const routeId = this.readRouteField(matchedRoutes[0], "id");
@@ -2843,6 +3108,225 @@ class FlowSurfacesService {
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey || "main", collectionName || "")
     });
   }
+  async prevalidateApplyBlueprintChartAssets(document, transaction) {
+    var _a;
+    const chartAssets = import_lodash.default.isPlainObject((_a = document.assets) == null ? void 0 : _a.charts) ? document.assets.charts : {};
+    for (const [chartKey, chartAsset] of Object.entries(chartAssets)) {
+      if (!import_lodash.default.isPlainObject(chartAsset)) {
+        continue;
+      }
+      (0, import_service_utils.assertSupportedSimpleChanges)("chart", chartAsset, (0, import_configure_options.getConfigureOptionKeysForUse)("ChartBlockModel"));
+      const nextConfigure = buildChartConfigureFromSemanticChangesWithRepair(void 0, chartAsset);
+      await this.validateChartConfigureForRuntime(
+        `applyBlueprint assets.charts.${chartKey}`,
+        nextConfigure,
+        transaction
+      );
+    }
+  }
+  composeChartBlockHasInlineConfig(block) {
+    const settings = import_lodash.default.isPlainObject(block.settings) ? block.settings : {};
+    return ["configure", "query", "visual", "events"].some(
+      (key) => Object.prototype.hasOwnProperty.call(settings, key)
+    );
+  }
+  prepareComposeChartAssetNestedPopupBlocks(input, path, chartAssets) {
+    if (!import_lodash.default.isPlainObject(input)) {
+      return { value: input, didResolveChartAsset: false };
+    }
+    let didResolveChartAsset = false;
+    let nextInput = input;
+    const ensureNextInput = () => {
+      if (nextInput === input) {
+        nextInput = { ...input };
+      }
+      return nextInput;
+    };
+    const preparePopupBlocks = (key) => {
+      const popup = input[key];
+      if (!import_lodash.default.isPlainObject(popup) || !Array.isArray(popup.blocks)) {
+        return;
+      }
+      const prepared = this.prepareComposeChartAssetBlockList(popup.blocks, `${path}.${key}.blocks`, chartAssets);
+      if (!prepared.didResolveChartAsset) {
+        return;
+      }
+      ensureNextInput()[key] = {
+        ...popup,
+        blocks: prepared.blocks
+      };
+      didResolveChartAsset = true;
+    };
+    preparePopupBlocks("popup");
+    preparePopupBlocks("openView");
+    return {
+      value: nextInput,
+      didResolveChartAsset
+    };
+  }
+  prepareComposeChartAssetBlockList(blocks, path, chartAssets) {
+    const rawBlocks = import_lodash.default.castArray(blocks || []);
+    if (!rawBlocks.length) {
+      return { blocks: rawBlocks, didResolveChartAsset: false };
+    }
+    let didResolveChartAsset = false;
+    const hiddenPopupKeys = [
+      "quickCreatePopup",
+      "eventPopup",
+      "cardPopup",
+      "quickCreatePopupSettings",
+      "eventPopupSettings",
+      "cardPopupSettings"
+    ];
+    const nextBlocks = rawBlocks.map((block, index) => {
+      if (!import_lodash.default.isPlainObject(block)) {
+        return block;
+      }
+      const blockPath = `${path}[${index}]`;
+      let nextBlock = block;
+      const ensureNextBlock = () => {
+        if (nextBlock === block) {
+          nextBlock = { ...block };
+        }
+        return nextBlock;
+      };
+      if (Array.isArray(block.blocks)) {
+        const prepared = this.prepareComposeChartAssetBlockList(block.blocks, `${blockPath}.blocks`, chartAssets);
+        if (prepared.didResolveChartAsset) {
+          ensureNextBlock().blocks = prepared.blocks;
+          didResolveChartAsset = true;
+        }
+      }
+      for (const slot of ["actions", "recordActions", "fields"]) {
+        if (!Array.isArray(block[slot])) {
+          continue;
+        }
+        let didPrepareSlot = false;
+        const nextItems = block[slot].map((item, itemIndex) => {
+          const prepared = this.prepareComposeChartAssetNestedPopupBlocks(
+            item,
+            `${blockPath}.${slot}[${itemIndex}]`,
+            chartAssets
+          );
+          didPrepareSlot = didPrepareSlot || prepared.didResolveChartAsset;
+          return prepared.value;
+        });
+        if (didPrepareSlot) {
+          ensureNextBlock()[slot] = nextItems;
+          didResolveChartAsset = true;
+        }
+      }
+      if (Array.isArray(block.fieldGroups)) {
+        let didPrepareFieldGroups = false;
+        const nextFieldGroups = block.fieldGroups.map((group, groupIndex) => {
+          if (!import_lodash.default.isPlainObject(group) || !Array.isArray(group.fields)) {
+            return group;
+          }
+          let didPrepareGroupFields = false;
+          const nextFields = group.fields.map((field, fieldIndex) => {
+            const prepared = this.prepareComposeChartAssetNestedPopupBlocks(
+              field,
+              `${blockPath}.fieldGroups[${groupIndex}].fields[${fieldIndex}]`,
+              chartAssets
+            );
+            didPrepareGroupFields = didPrepareGroupFields || prepared.didResolveChartAsset;
+            return prepared.value;
+          });
+          if (!didPrepareGroupFields) {
+            return group;
+          }
+          didPrepareFieldGroups = true;
+          return {
+            ...group,
+            fields: nextFields
+          };
+        });
+        if (didPrepareFieldGroups) {
+          ensureNextBlock().fieldGroups = nextFieldGroups;
+          didResolveChartAsset = true;
+        }
+      }
+      if (import_lodash.default.isPlainObject(block.popup) && Array.isArray(block.popup.blocks)) {
+        const prepared = this.prepareComposeChartAssetBlockList(
+          block.popup.blocks,
+          `${blockPath}.popup.blocks`,
+          chartAssets
+        );
+        if (prepared.didResolveChartAsset) {
+          ensureNextBlock().popup = {
+            ...block.popup,
+            blocks: prepared.blocks
+          };
+          didResolveChartAsset = true;
+        }
+      }
+      if (import_lodash.default.isPlainObject(block.settings)) {
+        for (const key of hiddenPopupKeys) {
+          const popup = block.settings[key];
+          if (!import_lodash.default.isPlainObject(popup) || !Array.isArray(popup.blocks)) {
+            continue;
+          }
+          const prepared = this.prepareComposeChartAssetBlockList(
+            popup.blocks,
+            `${blockPath}.settings.${key}.blocks`,
+            chartAssets
+          );
+          if (!prepared.didResolveChartAsset) {
+            continue;
+          }
+          ensureNextBlock().settings = {
+            ...nextBlock.settings || {},
+            [key]: {
+              ...popup,
+              blocks: prepared.blocks
+            }
+          };
+          didResolveChartAsset = true;
+        }
+      }
+      if (String(nextBlock.type || "").trim() !== "chart" || !Object.prototype.hasOwnProperty.call(nextBlock, "chart") || this.composeChartBlockHasInlineConfig(nextBlock)) {
+        return nextBlock;
+      }
+      const chartKey = String(nextBlock.chart || "").trim();
+      if (!chartKey) {
+        throwChartRepairBadRequest(`${blockPath}.chart must reference one key from assets.charts`, {
+          path: `${blockPath}.chart`,
+          ruleId: "chart-block-asset-reference-required"
+        });
+      }
+      const chartAsset = chartAssets[chartKey];
+      if (!import_lodash.default.isPlainObject(chartAsset)) {
+        throwChartRepairBadRequest(`${blockPath}.chart references missing chart asset '${chartKey}'`, {
+          path: `${blockPath}.chart`,
+          ruleId: "chart-block-asset-reference-missing",
+          details: {
+            chartKey
+          }
+        });
+      }
+      if (!import_lodash.default.isUndefined(nextBlock.settings) && !import_lodash.default.isPlainObject(nextBlock.settings)) {
+        return nextBlock;
+      }
+      didResolveChartAsset = true;
+      return {
+        ...nextBlock,
+        settings: import_lodash.default.merge({}, import_lodash.default.cloneDeep(nextBlock.settings || {}), import_lodash.default.cloneDeep(chartAsset))
+      };
+    });
+    return {
+      blocks: nextBlocks,
+      didResolveChartAsset
+    };
+  }
+  prepareComposeChartAssetSettings(values) {
+    var _a;
+    const chartAssets = import_lodash.default.isPlainObject((_a = values == null ? void 0 : values.assets) == null ? void 0 : _a.charts) ? values.assets.charts : {};
+    const prepared = this.prepareComposeChartAssetBlockList(values == null ? void 0 : values.blocks, "$.blocks", chartAssets);
+    return prepared.didResolveChartAsset ? {
+      ...values,
+      blocks: prepared.blocks
+    } : values;
+  }
   getApplyBlueprintKanbanBlockResourceObject(block) {
     return import_lodash.default.isPlainObject(block == null ? void 0 : block.resource) ? block.resource : {};
   }
@@ -3231,25 +3715,38 @@ class FlowSurfacesService {
     }
     if (!options.transaction) {
       const createdKanbanSortFields = [];
-      try {
-        return await this.transaction(
-          (transaction) => this.applyBlueprintWithTransaction(
-            values,
-            {
-              ...options,
-              transaction
-            },
-            createdKanbanSortFields
-          )
-        );
-      } catch (error) {
-        await this.cleanupApplyBlueprintKanbanSortFields(createdKanbanSortFields);
-        throw error;
-      }
+      const mutationResult = await this.applyBlueprintMutationWithoutExternalTransaction(
+        values,
+        options,
+        createdKanbanSortFields
+      );
+      const surface = await this.get(mutationResult.pageLocator, { currentRoles: options.currentRoles });
+      return this.buildApplyBlueprintResponse(mutationResult.mode, mutationResult.pageLocator, surface);
     }
   }
-  async applyBlueprintWithTransaction(values, options = {}, createdKanbanSortFields) {
-    var _a;
+  async applyBlueprintMutationWithoutExternalTransaction(values, options = {}, createdKanbanSortFields) {
+    try {
+      await this.assertApplyBlueprintAuthoringPayload(values, options);
+      const document = (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(values);
+      await this.prevalidateApplyBlueprintChartAssets(document);
+      return await this.transaction(
+        (transaction) => this.applyBlueprintWithTransaction(
+          values,
+          {
+            ...options,
+            transaction,
+            skipAuthoringValidation: true
+          },
+          createdKanbanSortFields,
+          { readSurface: false }
+        )
+      );
+    } catch (error) {
+      await this.cleanupApplyBlueprintKanbanSortFields(createdKanbanSortFields);
+      throw error;
+    }
+  }
+  async assertApplyBlueprintAuthoringPayload(values, options = {}) {
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("applyBlueprint", values, {
       transaction: options.transaction,
@@ -3257,6 +3754,11 @@ class FlowSurfacesService {
       findMenuGroupRoutesByTitle: (title, transaction) => this.findMenuGroupRoutesByTitle(title, transaction),
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey || "main", collectionName || "")
     });
+  }
+  async applyBlueprintWithTransaction(values, options = {}, createdKanbanSortFields, resultOptions = {}) {
+    if (options.skipAuthoringValidation !== true) {
+      await this.assertApplyBlueprintAuthoringPayload(values, options);
+    }
     const prepared = await this.prepareApplyBlueprintRequest(values, options.transaction, createdKanbanSortFields);
     const popupTemplateAliasSession = this.createPopupTemplateAliasSession();
     const popupTemplateTreeCache = /* @__PURE__ */ new Map();
@@ -3277,10 +3779,27 @@ class FlowSurfacesService {
       options
     );
     const pageLocator = (0, import_blueprint.resolveApplyBlueprintPageLocator)(prepared, result);
+    await this.ensureSurfaceTableDefaultActionIntegrity(pageLocator, {
+      ...options,
+      enabledPackages: await this.resolveEnabledPluginPackages(options),
+      popupTemplateAliasSession,
+      popupTemplateTreeCache
+    });
+    if (resultOptions.readSurface === false) {
+      return {
+        version: "1",
+        mode: prepared.document.mode,
+        pageLocator
+      };
+    }
     const surface = await this.get(pageLocator, options);
+    return this.buildApplyBlueprintResponse(prepared.document.mode, pageLocator, surface);
+  }
+  buildApplyBlueprintResponse(mode, pageLocator, surface) {
+    var _a;
     return {
       version: "1",
-      mode: prepared.document.mode,
+      mode,
       target: (0, import_service_utils.buildDefinedPayload)({
         pageSchemaUid: pageLocator.pageSchemaUid,
         pageUid: (_a = surface == null ? void 0 : surface.target) == null ? void 0 : _a.uid
@@ -3942,8 +4461,8 @@ class FlowSurfacesService {
       stepParams: (0, import_template_service_utils.buildFlowTemplateReferenceBlockStepParams)(template, templateTargetUid, init)
     };
   }
-  buildPopupTemplateReferenceOpenView(template, templateTargetUid) {
-    return this.buildPopupTemplateOpenView(template, "reference", templateTargetUid);
+  buildPopupTemplateReferenceOpenView(template, templateTargetUid, options = {}) {
+    return this.buildPopupTemplateOpenView(template, "reference", templateTargetUid, options);
   }
   shouldHydrateDetachedPopupTemplateBlockResourceContext(blockNode, context) {
     if (!this.isCollectionBlockUse(blockNode == null ? void 0 : blockNode.use) || !context.associationName || !context.sourceId) {
@@ -4293,15 +4812,35 @@ class FlowSurfacesService {
     }
     const nextStepParams = import_lodash.default.cloneDeep(sourceNode.stepParams || {});
     const currentGroup = import_lodash.default.isPlainObject(nextStepParams[openViewStep.flowKey]) ? import_lodash.default.cloneDeep(nextStepParams[openViewStep.flowKey]) : {};
+    const popupProfile = await this.resolvePopupBlockProfile(sourceNode.uid, null, sourceNode, transaction).catch(
+      () => null
+    );
+    const useRuntimeRecordFilterByTk = (popupProfile == null ? void 0 : popupProfile.hasCurrentRecord) === true;
+    const filterTargetKey = useRuntimeRecordFilterByTk ? await this.resolveOpenViewRuntimeRecordFilterTargetKey(openViewStep.openView, template, {
+      transaction,
+      popupTemplateHostUid: sourceNode.uid,
+      popupActionContext: {
+        hasCurrentRecord: true
+      }
+    }) : void 0;
+    const currentOpenView = import_lodash.default.omit(openViewStep.openView || {}, [
+      "popupTemplateUid",
+      "popupTemplateMode",
+      "popupTemplateContext",
+      "popupTemplateHasFilterByTk",
+      "popupTemplateHasSourceId"
+    ]);
+    if (useRuntimeRecordFilterByTk && this.shouldOmitRuntimeRecordFilterByTk(currentOpenView.filterByTk, {
+      filterTargetKey
+    })) {
+      delete currentOpenView.filterByTk;
+    }
     let nextOpenView = {
-      ...import_lodash.default.omit(openViewStep.openView || {}, [
-        "popupTemplateUid",
-        "popupTemplateMode",
-        "popupTemplateContext",
-        "popupTemplateHasFilterByTk",
-        "popupTemplateHasSourceId"
-      ]),
-      ...this.buildPopupTemplateReferenceOpenView(template, templateTargetUid)
+      ...currentOpenView,
+      ...this.buildPopupTemplateReferenceOpenView(template, templateTargetUid, {
+        filterTargetKey,
+        useRuntimeRecordFilterByTk
+      })
     };
     if (String(sourceNode.use || "").trim() === "AddChildActionModel") {
       nextOpenView = await this.normalizeAddChildOpenViewForAction(sourceNode, nextOpenView, transaction);
@@ -4862,12 +5401,13 @@ class FlowSurfacesService {
   async compose(values, options = {}) {
     var _a, _b, _c;
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
-    const target = await this.prepareWriteTarget("compose", values == null ? void 0 : values.target, values, options);
+    const composeValues = this.prepareComposeChartAssetSettings(values);
+    const target = await this.prepareWriteTarget("compose", composeValues == null ? void 0 : composeValues.target, composeValues, options);
     const authoringContext = await this.buildTargetAuthoringContext({
       target,
       transaction: options.transaction
     });
-    await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("compose", values, {
+    await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("compose", composeValues, {
       transaction: options.transaction,
       enabledPackages,
       skipGeneratedLayoutSingleColumnErrors: options.skipGeneratedLayoutSingleColumnErrors === true,
@@ -4880,12 +5420,17 @@ class FlowSurfacesService {
       ...options,
       popupTemplateTreeCache
     };
-    const mode = this.assertComposeMode(values == null ? void 0 : values.mode);
-    const popupDefaultsMetadata = this.buildPopupDefaultsMetadata(values == null ? void 0 : values.defaults);
-    const normalizedBlocks = this.normalizeComposeBlocks(values == null ? void 0 : values.blocks, enabledPackages, popupDefaultsMetadata, {
-      dataSourceKey: authoringContext.currentDataSourceKey,
-      collectionName: authoringContext.currentCollectionName
-    });
+    const mode = this.assertComposeMode(composeValues == null ? void 0 : composeValues.mode);
+    const popupDefaultsMetadata = this.buildPopupDefaultsMetadata(composeValues == null ? void 0 : composeValues.defaults);
+    const normalizedBlocks = this.normalizeComposeBlocks(
+      composeValues == null ? void 0 : composeValues.blocks,
+      enabledPackages,
+      popupDefaultsMetadata,
+      {
+        dataSourceKey: authoringContext.currentDataSourceKey,
+        collectionName: authoringContext.currentCollectionName
+      }
+    );
     this.validateComposePopupTemplateAliases(normalizedBlocks, popupTemplateAliasSession);
     const blockParent = await this.surfaceContext.resolveBlockParent(target, options.transaction);
     const gridUid = blockParent.parentUid;
@@ -4911,7 +5456,7 @@ class FlowSurfacesService {
       mode,
       normalizedBlocks,
       existingItemUids: existingItems.map((item) => item.uid),
-      layout: values.layout
+      layout: composeValues.layout
     });
     const generatedDefaultFilterByComposeBlockUid = /* @__PURE__ */ new Map();
     const result = await (0, import_compose_runtime.executeComposeRuntime)(plan, {
@@ -4946,7 +5491,7 @@ class FlowSurfacesService {
           {
             ...payload,
             ...Object.keys(hiddenPopupSettings).length ? { settings: hiddenPopupSettings } : {},
-            ...values.defaults ? { defaults: values.defaults } : {}
+            ...composeValues.defaults ? { defaults: composeValues.defaults } : {}
           },
           {
             ...runtimeOptions,
@@ -5043,6 +5588,13 @@ class FlowSurfacesService {
     });
     for (const [blockIndex, block] of result.blocks.entries()) {
       const blockSpec = normalizedBlocks.find((item) => item.key === block.key);
+      if ((blockSpec == null ? void 0 : blockSpec.type) === "table") {
+        await this.ensureTableDefaultActionIntegrity(block.uid, {
+          ...runtimeOptions,
+          enabledPackages,
+          popupTemplateAliasSession
+        });
+      }
       if ((blockSpec == null ? void 0 : blockSpec.type) === "table") {
         const appliedTreeTableDefaults = await this.applyTreeTableCreatedBlockDefaults(
           {
@@ -5176,7 +5728,7 @@ class FlowSurfacesService {
       if ((current == null ? void 0 : current.use) === "DividerItemModel") {
         return this.configureDividerItem(target, changes, options);
       }
-      return this.configureJSItem(target, changes, options);
+      return this.configureJSItem(target, changes, { ...options, currentUse: (current == null ? void 0 : current.use) || "JSItemModel" });
     }
     if ((0, import_service_utils.isFieldNodeUse)(current == null ? void 0 : current.use)) {
       return this.configureFieldNode(target, changes, configureOptions);
@@ -5251,6 +5803,7 @@ class FlowSurfacesService {
     if (!this.isBindableMenuRoutePendingInitialization(route, structure)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces createPage does not allow re-initializing menu route '${routeId}'`);
     }
+    this.assertVisibleNavigationRouteIconUpdate("createPage", "values", route, values);
     const existingPage = structure.pageModel;
     const enableTabs = !!values.enableTabs;
     const displayTitle = values.displayTitle !== false;
@@ -5275,7 +5828,7 @@ class FlowSurfacesService {
           parentId: routeId,
           options: {
             documentTitle: values.tabDocumentTitle,
-            flowRegistry: values.tabFlowRegistry || {}
+            flowRegistry: this.normalizeEventFlowRegistry("createPage", values.tabFlowRegistry || {})
           }
         },
         transaction
@@ -5294,7 +5847,10 @@ class FlowSurfacesService {
           options: {
             ...this.readRouteOptions(tabRoute),
             documentTitle: values.tabDocumentTitle ?? this.readRouteOptions(tabRoute).documentTitle,
-            flowRegistry: values.tabFlowRegistry || this.readRouteOptions(tabRoute).flowRegistry || {}
+            flowRegistry: this.normalizeEventFlowRegistry(
+              "createPage",
+              values.tabFlowRegistry || this.readRouteOptions(tabRoute).flowRegistry || {}
+            )
           }
         },
         transaction
@@ -5436,7 +5992,7 @@ class FlowSurfacesService {
         hidden: !pageRoute.get("enableTabs"),
         options: {
           documentTitle: values.documentTitle,
-          flowRegistry: values.flowRegistry || {}
+          flowRegistry: this.normalizeEventFlowRegistry("addTab", values.flowRegistry || {})
         }
       },
       transaction: options.transaction
@@ -5484,7 +6040,7 @@ class FlowSurfacesService {
           )
         }
       } : void 0,
-      flowRegistry: !import_lodash.default.isUndefined(values.flowRegistry) ? values.flowRegistry : void 0
+      flowRegistry: !import_lodash.default.isUndefined(values.flowRegistry) ? this.normalizeEventFlowRegistry("updateTab", values.flowRegistry) : void 0
     });
     await this.routeSync.persistTabSettings(target, current, nextPayload, options.transaction);
     return {
@@ -5600,7 +6156,7 @@ class FlowSurfacesService {
       title: values.title,
       icon: values.icon,
       documentTitle: values.documentTitle,
-      flowRegistry: values.flowRegistry
+      flowRegistry: this.normalizeEventFlowRegistry("addPopupTab", values.flowRegistry)
     });
     await this.repository.upsertModel(
       {
@@ -5655,7 +6211,7 @@ class FlowSurfacesService {
           }
         }
       } : void 0,
-      flowRegistry: !import_lodash.default.isUndefined(values.flowRegistry) ? values.flowRegistry : void 0
+      flowRegistry: !import_lodash.default.isUndefined(values.flowRegistry) ? this.normalizeEventFlowRegistry("updatePopupTab", values.flowRegistry) : void 0
     });
     if (Object.keys(nextPayload).length === 1) {
       return { uid: popupTab.uid };
@@ -5856,7 +6412,7 @@ class FlowSurfacesService {
           use: "ReferenceFormGridModel",
           props: currentGrid.props,
           decoratorProps: currentGrid.decoratorProps,
-          flowRegistry: currentGrid.flowRegistry,
+          flowRegistry: this.getEventFlowRegistry(currentGrid),
           sortIndex: currentGrid.sortIndex,
           parentId: blockUid,
           subKey: "grid",
@@ -6102,7 +6658,8 @@ class FlowSurfacesService {
     if ((0, import_service_utils.hasOwnDefined)(normalizedSettings, "defaultFilter")) {
       normalizedSettings.defaultFilter = (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
         normalizedSettings.defaultFilter,
-        `flowSurfaces ${actionName} defaultActionSettings.filter.defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+        `flowSurfaces ${actionName} defaultActionSettings.filter.defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        { strictDateValues: true }
       );
       normalizedSettings.defaultFilter = this.normalizeEffectivePublicDataSurfaceDefaultFilter(
         normalizedSettings.defaultFilter,
@@ -6330,7 +6887,7 @@ class FlowSurfacesService {
         key: String((values == null ? void 0 : values.key) || catalogItem.key || (values == null ? void 0 : values.type) || (values == null ? void 0 : values.use) || "addBlock_inline").trim() || "addBlock_inline",
         type: catalogItem.key || values.type,
         fields: values.fields,
-        fieldsLayout: values.fieldsLayout
+        ...Object.prototype.hasOwnProperty.call(values || {}, "fieldsLayout") ? { fieldsLayout: values.fieldsLayout } : {}
       },
       0,
       enabledPackages,
@@ -6524,6 +7081,8 @@ class FlowSurfacesService {
             ...fieldSpec.popupSize ? { popupSize: fieldSpec.popupSize } : {},
             ...!import_lodash.default.isUndefined(fieldSpec.pageSize) ? { pageSize: fieldSpec.pageSize } : {},
             ...!import_lodash.default.isUndefined(fieldSpec.showIndex) ? { showIndex: fieldSpec.showIndex } : {},
+            ...fieldSpec.defaultTargetUid ? { defaultTargetUid: fieldSpec.defaultTargetUid } : {},
+            ...fieldSpec.targetBlockUid ? { targetBlockUid: fieldSpec.targetBlockUid } : {},
             ...fieldSpec.popup ? { popup: fieldSpec.popup } : {},
             ...fieldSpec.__autoPopupForRelationField ? { __autoPopupForRelationField: true } : {},
             ...fieldSpec[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY] ? {
@@ -6598,6 +7157,13 @@ class FlowSurfacesService {
         enabledPackages
       }
     );
+    if (catalogItem.use === "TableBlockModel" && !options.skipDefaultBlockActions) {
+      await this.ensureTableDefaultActionIntegrity(created, {
+        ...options,
+        enabledPackages,
+        popupTemplateTreeCache: options.popupTemplateTreeCache
+      });
+    }
     if (!options.deferAutoLayout && (initialGrid == null ? void 0 : initialGrid.uid)) {
       const finalGrid = await this.repository.findModelById(parentUid, {
         transaction: options.transaction,
@@ -6665,7 +7231,9 @@ class FlowSurfacesService {
         (0, import_errors.throwBadRequest)("flowSurfaces fieldType is only supported for relation fields");
       }
       if (inlinePopup) {
-        (0, import_errors.throwBadRequest)(`flowSurfaces addField type '${values.type}' does not support popup`);
+        (0, import_errors.throwBadRequest)(
+          withJsPopupGuidance(`flowSurfaces addField type '${values.type}' does not support popup`, values.type)
+        );
       }
       if (isFilterFormItem) {
         (0, import_errors.throwBadRequest)(`flowSurfaces addField type '${values.type}' is not allowed under filter-form`);
@@ -6860,9 +7428,18 @@ class FlowSurfacesService {
       }
     }
     if (inlinePopup && !this.isPopupFieldHostUse(boundFieldCapability.fieldUse)) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces addField field '${boundFieldCapability.fieldUse}' does not support popup`);
+      (0, import_errors.throwBadRequest)(
+        withJsPopupGuidance(
+          `flowSurfaces addField field '${boundFieldCapability.fieldUse}' does not support popup`,
+          boundFieldCapability.fieldUse
+        )
+      );
     }
-    if (values.__autoPopupForRelationField === true && !inlinePopup && this.isPopupFieldHostUse(boundFieldCapability.fieldUse) && ((0, import_service_helpers.isAssociationField)(resolvedField.field) || !!normalizedFieldBinding.associationPathName) && !this.peekInlineFieldSettingsOpenView(inlineSettings, boundFieldCapability.wrapperUse)) {
+    const inlineSettingsOpenView = this.peekInlineFieldSettingsOpenView(
+      inlineSettings,
+      boundFieldCapability.wrapperUse
+    );
+    if (values.__autoPopupForRelationField === true && !inlinePopup && this.isPopupFieldHostUse(boundFieldCapability.fieldUse) && ((0, import_service_helpers.isAssociationField)(resolvedField.field) || !!normalizedFieldBinding.associationPathName) && !inlineSettingsOpenView) {
       const popupDefaultsMetadata = values[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY];
       inlinePopup = this.normalizeInlinePopup("addField", {
         tryTemplate: true,
@@ -6872,9 +7449,19 @@ class FlowSurfacesService {
         } : {}
       });
     }
-    if (inlinePopup && this.isExternalPopupOpenView(
-      this.peekInlineFieldSettingsOpenView(inlineSettings, boundFieldCapability.wrapperUse)
-    )) {
+    const hasExternalInlineSettingsOpenView = this.isExternalPopupOpenView(inlineSettingsOpenView);
+    if (!inlinePopup && this.isPopupFieldHostUse(boundFieldCapability.fieldUse) && !hasExternalInlineSettingsOpenView && (this.isInlineFieldClickToOpenEnabled(inlineSettings, boundFieldCapability.wrapperUse) || import_lodash.default.isPlainObject(inlineSettingsOpenView))) {
+      const popupDefaultsMetadata = values[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY];
+      inlinePopup = this.normalizeInlinePopup("addField", {
+        tryTemplate: true,
+        defaultType: "view",
+        ...import_lodash.default.isPlainObject(inlineSettingsOpenView) ? { openView: import_lodash.default.cloneDeep(inlineSettingsOpenView) } : {},
+        ...popupDefaultsMetadata ? {
+          [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: popupDefaultsMetadata
+        } : {}
+      });
+    }
+    if (inlinePopup && hasExternalInlineSettingsOpenView) {
       (0, import_errors.throwBadRequest)(`flowSurfaces addField popup cannot be combined with external openView.uid`);
     }
     const defaultFieldState = (0, import_service_utils.buildDefaultFieldState)(
@@ -7013,7 +7600,12 @@ class FlowSurfacesService {
       );
     }
     if (inlinePopup && !POPUP_ACTION_USES.has(actionCatalogItem.use)) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces addAction type '${actionCatalogItem.key}' does not support popup`);
+      (0, import_errors.throwBadRequest)(
+        withJsPopupGuidance(
+          `flowSurfaces addAction type '${actionCatalogItem.key}' does not support popup`,
+          actionCatalogItem.key
+        )
+      );
     }
     await this.assertApprovalActionSingleton(container.parentUid, actionCatalogItem.use, options.transaction);
     (0, import_action_scope.assertRequestedActionScope)({
@@ -7041,21 +7633,43 @@ class FlowSurfacesService {
       return result2;
     }
     const resourceContext = container.ownerUid ? await this.locator.resolveCollectionContext(container.ownerUid, options.transaction).catch(() => null) : null;
-    const aiEmployeeProps = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addAction", inlineSettings || {}, {
+    const aiEmployeeSettingsPayload = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addAction", inlineSettings || {}, {
       transaction: options.transaction,
       enabledPackages,
       requireUsername: true,
       currentRoles: options.currentRoles,
-      selfUid: container.ownerUid
+      selfUid: container.ownerUid,
+      promptContext: {
+        kind: "container",
+        ownerUid: container.ownerUid,
+        scope: resolvedScope
+      }
     }) : void 0;
+    const actionSettingsPayload = {
+      props: values.props,
+      stepParams: values.stepParams
+    };
+    if (aiEmployeeSettingsPayload) {
+      this.mergeAIEmployeeActionSettingsPayload(
+        { use: actionCatalogItem.use },
+        actionSettingsPayload,
+        aiEmployeeSettingsPayload
+      );
+      await this.assertNoDuplicateAIEmployeeAction(
+        "addAction",
+        container.parentUid,
+        actionSettingsPayload,
+        options.transaction
+      );
+    }
     const action = (0, import_builder.buildActionTree)({
       use: actionCatalogItem.use,
       containerUse: container.ownerUse,
       resourceInit: values.resourceInit || (resourceContext == null ? void 0 : resourceContext.resourceInit),
-      props: aiEmployeeProps || values.props,
+      props: actionSettingsPayload.props,
       decoratorProps: values.decoratorProps,
-      stepParams: values.stepParams,
-      flowRegistry: values.flowRegistry
+      stepParams: actionSettingsPayload.stepParams,
+      flowRegistry: this.normalizeEventFlowRegistry("addAction", values.flowRegistry)
     });
     this.contractGuard.validateNodeTreeAgainstContract(action);
     const created = await this.repository.upsertModel(
@@ -7109,8 +7723,13 @@ class FlowSurfacesService {
     );
     const resolvedScope = actionCatalogItem.scope;
     if (inlinePopup && !POPUP_ACTION_USES.has(actionCatalogItem.use)) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces addRecordAction type '${actionCatalogItem.key}' does not support popup`);
-    }
+      (0, import_errors.throwBadRequest)(
+        withJsPopupGuidance(
+          `flowSurfaces addRecordAction type '${actionCatalogItem.key}' does not support popup`,
+          actionCatalogItem.key
+        )
+      );
+    }
     if (this.isAddChildCatalogItem(actionCatalogItem)) {
       await this.assertAddChildSupportedForOwnerNode(container.ownerNode, "addRecordAction", options.transaction);
     }
@@ -7141,21 +7760,43 @@ class FlowSurfacesService {
     }
     const resourceContext = container.ownerUid ? await this.locator.resolveCollectionContext(container.ownerUid, options.transaction).catch(() => null) : null;
     const resourceInit = this.isAddChildCatalogItem(actionCatalogItem) ? await this.resolveAddChildResourceInitForOwnerNode(container.ownerNode, options.transaction) : values.resourceInit || (resourceContext == null ? void 0 : resourceContext.resourceInit);
-    const aiEmployeeProps = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addRecordAction", inlineSettings || {}, {
+    const aiEmployeeSettingsPayload = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addRecordAction", inlineSettings || {}, {
       transaction: options.transaction,
       enabledPackages,
       requireUsername: true,
       currentRoles: options.currentRoles,
-      selfUid: container.ownerUid
+      selfUid: container.ownerUid,
+      promptContext: {
+        kind: "container",
+        ownerUid: container.ownerUid,
+        scope: resolvedScope
+      }
     }) : void 0;
+    const actionSettingsPayload = {
+      props: values.props,
+      stepParams: values.stepParams
+    };
+    if (aiEmployeeSettingsPayload) {
+      this.mergeAIEmployeeActionSettingsPayload(
+        { use: actionCatalogItem.use },
+        actionSettingsPayload,
+        aiEmployeeSettingsPayload
+      );
+      await this.assertNoDuplicateAIEmployeeAction(
+        "addRecordAction",
+        materializedContainer.parentUid,
+        actionSettingsPayload,
+        options.transaction
+      );
+    }
     const action = (0, import_builder.buildActionTree)({
       use: actionCatalogItem.use,
       containerUse: container.containerUse,
       resourceInit,
-      props: aiEmployeeProps || values.props,
+      props: actionSettingsPayload.props,
       decoratorProps: values.decoratorProps,
-      stepParams: values.stepParams,
-      flowRegistry: values.flowRegistry
+      stepParams: actionSettingsPayload.stepParams,
+      flowRegistry: this.normalizeEventFlowRegistry("addRecordAction", values.flowRegistry)
     });
     this.contractGuard.validateNodeTreeAgainstContract(action);
     const created = await this.repository.upsertModel(
@@ -7207,7 +7848,8 @@ class FlowSurfacesService {
         },
         {
           ...options,
-          preserveSingleScopeDataBlockTitle
+          preserveSingleScopeDataBlockTitle,
+          skipAuthoringValidation: true
         }
       )
     });
@@ -8083,6 +8725,17 @@ class FlowSurfacesService {
     const { fieldChanges } = (0, import_service_utils.splitComposeFieldChanges)(settings, wrapperUse);
     return fieldChanges.openView;
   }
+  isInlineFieldClickToOpenEnabled(settings, wrapperUse) {
+    if (!settings || !Object.keys(settings).length) {
+      return false;
+    }
+    const { fieldChanges } = (0, import_service_utils.splitComposeFieldChanges)(settings, wrapperUse);
+    if (!Object.prototype.hasOwnProperty.call(fieldChanges, "clickToOpen")) {
+      return false;
+    }
+    const value = fieldChanges.clickToOpen;
+    return value === true || import_lodash.default.isPlainObject(value) && value.clickToOpen === true;
+  }
   async assertOpenViewUidTarget(actionName, uid2, options = {}) {
     const targetNode = await this.repository.findModelById(uid2, {
       transaction: options.transaction,
@@ -8613,15 +9266,71 @@ class FlowSurfacesService {
       sourceId: String(template.sourceId || "").trim() || void 0
     };
   }
-  buildPopupTemplateOpenView(template, mode, uidValue) {
+  shouldUseRuntimeRecordFilterByTkForOpenView(openView, options = {}) {
+    var _a;
+    return !!String((openView == null ? void 0 : openView.popupTemplateUid) || "").trim() && ((_a = options.popupActionContext) == null ? void 0 : _a.hasCurrentRecord) === true;
+  }
+  resolveOpenViewFilterTargetKey(openView, template) {
+    const dataSourceKey = String((openView == null ? void 0 : openView.dataSourceKey) || (template == null ? void 0 : template.dataSourceKey) || "main").trim() || "main";
+    const collectionName = String((openView == null ? void 0 : openView.collectionName) || (template == null ? void 0 : template.collectionName) || "").trim();
+    const collection = collectionName ? this.getCollection(dataSourceKey, collectionName) : null;
+    return this.getCollectionFilterTargetKey(collection);
+  }
+  async resolvePopupHostCurrentRecordFilterTargetKey(hostUid, transaction) {
+    var _a, _b, _c;
+    const normalizedHostUid = String(hostUid || "").trim();
+    if (!normalizedHostUid) {
+      return void 0;
+    }
+    const hostNode = await this.repository.findModelById(normalizedHostUid, {
+      transaction,
+      includeAsyncNode: true
+    }).catch(() => null);
+    if (!(hostNode == null ? void 0 : hostNode.uid)) {
+      return void 0;
+    }
+    const hostContext = await this.resolvePopupHostProfileContext(hostNode, transaction).catch(() => null);
+    const ownerResourceInit = ((_a = hostContext == null ? void 0 : hostContext.resourceContext) == null ? void 0 : _a.resourceInit) || {};
+    const dataSourceKey = String(((_b = hostContext == null ? void 0 : hostContext.associationContext) == null ? void 0 : _b.dataSourceKey) || ownerResourceInit.dataSourceKey || "main").trim() || "main";
+    const collectionName = String(
+      ((_c = hostContext == null ? void 0 : hostContext.associationContext) == null ? void 0 : _c.collectionName) || ownerResourceInit.collectionName || ""
+    ).trim();
+    const collection = collectionName ? this.getCollection(dataSourceKey, collectionName) : null;
+    return collection ? this.getCollectionFilterTargetKey(collection) : void 0;
+  }
+  async resolveOpenViewRuntimeRecordFilterTargetKey(openView, template, options = {}) {
+    var _a;
+    const contextKey = String(((_a = options.popupActionContext) == null ? void 0 : _a.currentRecordFilterTargetKey) || "").trim();
+    if (contextKey) {
+      return contextKey;
+    }
+    const hostKey = await this.resolvePopupHostCurrentRecordFilterTargetKey(
+      options.popupTemplateHostUid,
+      options.transaction
+    );
+    return hostKey || this.resolveOpenViewFilterTargetKey(openView, template);
+  }
+  shouldOmitRuntimeRecordFilterByTk(value, options = {}) {
+    const normalized = this.normalizeFlowContextTemplateValue(value);
+    if (!normalized) {
+      return false;
+    }
+    if (normalized === "{{ctx.view.inputArgs.filterByTk}}") {
+      return true;
+    }
+    const filterTargetKey = String(options.filterTargetKey || "").trim();
+    return !!filterTargetKey && normalized === `{{ctx.record.${filterTargetKey}}}`;
+  }
+  buildPopupTemplateOpenView(template, mode, uidValue, options = {}) {
     const popupTemplateHasFilterByTk = !!String(template.filterByTk || "").trim();
     const popupTemplateHasSourceId = !!String(template.sourceId || "").trim() || !!String(template.associationName || "").trim();
+    const omitRuntimeRecordFilterByTk = options.useRuntimeRecordFilterByTk === true && this.shouldOmitRuntimeRecordFilterByTk(template.filterByTk, { filterTargetKey: options.filterTargetKey });
     const base = (0, import_service_utils.buildDefinedPayload)({
       uid: uidValue,
       dataSourceKey: template.dataSourceKey,
       collectionName: template.collectionName,
       associationName: template.associationName,
-      ...popupTemplateHasFilterByTk ? { filterByTk: template.filterByTk } : {},
+      ...popupTemplateHasFilterByTk && !omitRuntimeRecordFilterByTk ? { filterByTk: template.filterByTk } : {},
       ...popupTemplateHasSourceId && template.sourceId ? { sourceId: template.sourceId } : {},
       popupTemplateHasFilterByTk,
       popupTemplateHasSourceId,
@@ -8694,7 +9403,7 @@ class FlowSurfacesService {
     }
   }
   async normalizeOpenView(actionName, openView, options = {}) {
-    var _a;
+    var _a, _b, _c, _d;
     if (import_lodash.default.isUndefined(openView) || import_lodash.default.isNull(openView)) {
       return openView;
     }
@@ -8761,17 +9470,39 @@ class FlowSurfacesService {
       if (templateRef.mode === "copy") {
         await this.ensurePopupSurface(resolvedUid, options.transaction);
       }
-      let nextTemplateOpenView = this.buildPopupTemplateOpenView(template, templateRef.mode, resolvedUid);
+      let runtimeRecordFilterTargetKey;
+      if (((_b = options.popupActionContext) == null ? void 0 : _b.hasCurrentRecord) === true) {
+        runtimeRecordFilterTargetKey = await this.resolveOpenViewRuntimeRecordFilterTargetKey(
+          normalizedOpenView,
+          template,
+          options
+        );
+      }
+      const filterTargetKey = runtimeRecordFilterTargetKey || this.resolveOpenViewFilterTargetKey(normalizedOpenView, template);
+      let nextTemplateOpenView = this.buildPopupTemplateOpenView(template, templateRef.mode, resolvedUid, {
+        filterTargetKey,
+        useRuntimeRecordFilterByTk: ((_c = options.popupActionContext) == null ? void 0 : _c.hasCurrentRecord) === true
+      });
       Object.keys(normalizedOpenView).forEach((key) => {
         if (key === "template" || key === "popupTemplateUid" || key === "popupTemplateMode" || key === "popupTemplateContext" || key === "popupTemplateHasFilterByTk" || key === "popupTemplateHasSourceId") {
           delete normalizedOpenView[key];
         }
       });
+      if (((_d = options.popupActionContext) == null ? void 0 : _d.hasCurrentRecord) === true && this.shouldOmitRuntimeRecordFilterByTk(normalizedOpenView.filterByTk, {
+        filterTargetKey
+      })) {
+        delete normalizedOpenView.filterByTk;
+      }
       if (String(options.popupTemplateHostUse || "").trim() === "AddChildActionModel") {
         nextTemplateOpenView = import_lodash.default.omit(nextTemplateOpenView, ["sourceId"]);
       }
       Object.assign(normalizedOpenView, nextTemplateOpenView);
     }
+    if (this.shouldUseRuntimeRecordFilterByTkForOpenView(normalizedOpenView, options) && this.shouldOmitRuntimeRecordFilterByTk(normalizedOpenView.filterByTk, {
+      filterTargetKey: await this.resolveOpenViewRuntimeRecordFilterTargetKey(normalizedOpenView, void 0, options)
+    })) {
+      delete normalizedOpenView.filterByTk;
+    }
     if (!import_lodash.default.isUndefined(normalizedOpenView.uid)) {
       const normalizedUid = String(normalizedOpenView.uid || "").trim();
       if (!normalizedUid) {
@@ -8812,7 +9543,8 @@ class FlowSurfacesService {
       return void 0;
     }
     return {
-      hasCurrentRecord: true
+      hasCurrentRecord: true,
+      currentRecordFilterTargetKey: await this.resolvePopupHostCurrentRecordFilterTargetKey(current.uid, transaction)
     };
   }
   unsetPayloadPathAndPruneEmptyParents(payload, path) {
@@ -8970,7 +9702,12 @@ class FlowSurfacesService {
       return {};
     }
     if (input.popup && !this.isPopupFieldHostUse(fieldNode.use)) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} field '${fieldNode.use}' does not support popup`);
+      (0, import_errors.throwBadRequest)(
+        withJsPopupGuidance(
+          `flowSurfaces ${actionName} field '${fieldNode.use}' does not support popup`,
+          fieldNode.use
+        )
+      );
     }
     let openView = this.resolvePopupHostOpenView(fieldNode);
     if (input.popup && this.isExternalPopupOpenView(openView, fieldHostUid)) {
@@ -9296,6 +10033,20 @@ class FlowSurfacesService {
   isEmptyInlinePopupPayload(popup) {
     return import_lodash.default.isPlainObject(popup) && Object.keys(popup).length === 0;
   }
+  isInlineFieldPopupDefaultShell(popup) {
+    if (!import_lodash.default.isPlainObject(popup)) {
+      return false;
+    }
+    const shellOnlyKeys = /* @__PURE__ */ new Set([
+      "title",
+      "mode",
+      "openView",
+      "tryTemplate",
+      "defaultType",
+      import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY
+    ]);
+    return Object.keys(popup).every((key) => shellOnlyKeys.has(key));
+  }
   shouldAutoCompleteDefaultFieldPopup(fieldNode, popup, wrapperNode) {
     if (!import_lodash.default.isPlainObject(popup)) {
       return false;
@@ -9310,7 +10061,7 @@ class FlowSurfacesService {
     if (!String(fieldContext.collectionName || "").trim()) {
       return false;
     }
-    return popup.tryTemplate === true || !import_lodash.default.isUndefined(popup.defaultType) || Object.keys(popup).length === 0;
+    return popup.tryTemplate === true || !import_lodash.default.isUndefined(popup.defaultType) || this.isInlineFieldPopupDefaultShell(popup);
   }
   isInlineFieldPopupBlockMissingResource(block) {
     if (!import_lodash.default.isPlainObject(block) || !import_lodash.default.isUndefined(block.template)) {
@@ -10372,14 +11123,21 @@ class FlowSurfacesService {
       actionNode,
       options.transaction
     ).catch(() => null);
-    const filterTargetKey = (popupProfile == null ? void 0 : popupProfile.currentCollection) ? this.getCollectionFilterTargetKey(popupProfile.currentCollection) : null;
+    const useRuntimeRecordFilterByTk = this.isReferencedPopupTemplateOpenView(currentOpenView, actionNode.uid);
+    const filterTargetKey = useRuntimeRecordFilterByTk ? await this.resolveOpenViewRuntimeRecordFilterTargetKey(currentOpenView, void 0, {
+      transaction: options.transaction,
+      popupTemplateHostUid: actionNode.uid,
+      popupActionContext: {
+        hasCurrentRecord: true
+      }
+    }) : (popupProfile == null ? void 0 : popupProfile.currentCollection) ? this.getCollectionFilterTargetKey(popupProfile.currentCollection) : null;
     const defaultFilterByTk = this.resolvePopupCurrentRecordResourceFilterByTk(popupProfile);
     const currentFilterByTk = import_lodash.default.isString(currentOpenView.filterByTk) ? currentOpenView.filterByTk.trim() : "";
-    const preserveCustomFilterByTk = currentFilterByTk && currentFilterByTk !== "{{ctx.view.inputArgs.filterByTk}}" && currentFilterByTk !== (filterTargetKey ? `{{ctx.record.${filterTargetKey}}}` : "");
+    const preserveCustomFilterByTk = currentFilterByTk && !this.shouldOmitRuntimeRecordFilterByTk(currentOpenView.filterByTk, { filterTargetKey: filterTargetKey || "" });
     const nextOpenView = (0, import_service_utils.buildDefinedPayload)({
-      ...currentOpenView,
+      ...useRuntimeRecordFilterByTk && !preserveCustomFilterByTk ? import_lodash.default.omit(currentOpenView, ["filterByTk"]) : currentOpenView,
       title: openViewTitle,
-      filterByTk: preserveCustomFilterByTk ? currentOpenView.filterByTk : defaultFilterByTk || currentOpenView.filterByTk
+      filterByTk: useRuntimeRecordFilterByTk ? preserveCustomFilterByTk ? currentOpenView.filterByTk : void 0 : preserveCustomFilterByTk ? currentOpenView.filterByTk : defaultFilterByTk || currentOpenView.filterByTk
     });
     if (import_lodash.default.isEqual(nextOpenView, currentOpenView)) {
       return;
@@ -10641,7 +11399,7 @@ class FlowSurfacesService {
     }
     if (this.isAIEmployeeActionUse(current == null ? void 0 : current.use) && this.hasAIEmployeePublicSettings(normalizedValues)) {
       const enabledPackages = await this.resolveEnabledPluginPackages(options);
-      const aiEmployeeProps = await this.normalizeAIEmployeeActionPublicSettings(
+      const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
         "updateSettings",
         import_lodash.default.pick(normalizedValues, AI_EMPLOYEE_PUBLIC_SETTING_KEYS),
         {
@@ -10649,13 +11407,17 @@ class FlowSurfacesService {
           enabledPackages,
           current,
           currentRoles: options.currentRoles,
-          selfUid: await this.resolveAIEmployeeActionSelfUid(current, options.transaction)
+          selfUid: await this.resolveAIEmployeeActionSelfUid(current, options.transaction),
+          promptContext: {
+            kind: "target",
+            targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
+          }
         }
       );
       AI_EMPLOYEE_PUBLIC_SETTING_KEYS.forEach((key) => {
         delete normalizedValues[key];
       });
-      normalizedValues.props = import_lodash.default.merge({}, normalizedValues.props || {}, aiEmployeeProps);
+      this.mergeAIEmployeeActionSettingsPayload(current, normalizedValues, aiEmployeeSettingsPayload);
     }
     assertNoFlowSurfaceIdTitleFieldSettings(normalizedValues, {
       action: "updateSettings",
@@ -10675,6 +11437,7 @@ class FlowSurfacesService {
       }
       if (domain === "flowRegistry") {
         this.assertNoTreeConnectFieldsFlowRegistry(current, normalizedValues[domain], "updateSettings");
+        normalizedValues[domain] = this.normalizeEventFlowRegistry("updateSettings", normalizedValues[domain]);
       }
       if (!contract.editableDomains.includes(domain)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces updateSettings domain '${domain}' is not editable`);
@@ -10691,6 +11454,9 @@ class FlowSurfacesService {
         current.use
       );
     });
+    if (!import_lodash.default.isUndefined(nextPayload.flowRegistry)) {
+      nextPayload.flowRegistry = this.normalizeEventFlowRegistry("updateSettings", nextPayload.flowRegistry);
+    }
     this.replaceExplicitPopupStepParamSubtreesForUpdateSettings(
       current,
       normalizedValues,
@@ -10703,6 +11469,14 @@ class FlowSurfacesService {
       nextPayload,
       options.replaceRecordHistorySettings === true
     );
+    this.syncAIEmployeeTaskStepParamsForUpdateSettings(current, nextPayload);
+    await this.normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options);
+    await this.assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings(
+      current,
+      nextPayload,
+      writeTarget,
+      options
+    );
     this.syncCalendarPopupPropsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncKanbanPopupPropsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncDefaultSortingForUpdateSettings(current, normalizedValues, nextPayload);
@@ -10749,7 +11523,7 @@ class FlowSurfacesService {
       props: nextPayload.props ?? current.props,
       decoratorProps: nextPayload.decoratorProps ?? current.decoratorProps,
       stepParams: nextPayload.stepParams ?? current.stepParams,
-      flowRegistry: nextPayload.flowRegistry ?? current.flowRegistry
+      flowRegistry: nextPayload.flowRegistry ?? this.getEventFlowRegistry(current)
     };
     const shouldValidateFlowRegistry = !import_lodash.default.isUndefined(nextPayload.flowRegistry) || !import_lodash.default.isUndefined(nextPayload.stepParams);
     assertNoFlowSurfaceIdTitleFieldSettings(import_lodash.default.pick(effectiveNode, ["props", "stepParams"]), {
@@ -11174,12 +11948,12 @@ class FlowSurfacesService {
           "flowSurfaces updateSettings filter action values 'props.defaultFilterValue/filterValue' and 'stepParams.filterSettings.defaultFilter.defaultFilter' must match"
         );
       }
-      const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(
-        hasStepDefaultFilter ? nextStepFilter : nextPropFilter,
-        {
-          requiredFieldCount: options.requiredFieldCount
-        }
+      const normalizedFilterValue = this.normalizeFilterActionDefaultFilterValue(
+        hasStepDefaultFilter ? nextStepFilter : nextPropFilter
       );
+      const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(normalizedFilterValue, {
+        requiredFieldCount: options.requiredFieldCount
+      });
       if (!hasPropsFilterableFieldNames && !hasStepFilterableFieldNames) {
         const filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(filterValue);
         if (filterableFieldNames.length) {
@@ -11590,7 +12364,12 @@ class FlowSurfacesService {
     }
     if (!((_c = sqlPreview.queryOutputs) == null ? void 0 : _c.length)) {
       (0, import_errors.throwBadRequest)(
-        "chart visual.mode='basic' requires previewable SQL query outputs; write query first, then read flowSurfaces:context(path='chart'), or use visual.mode='custom' after browser verification"
+        withChartRepairMessage(
+          "chart visual.mode='basic' requires previewable SQL query outputs; write query first, then read flowSurfaces:context(path='chart'), or use visual.mode='custom' after browser verification"
+        ),
+        {
+          details: withFlowSurfaceChartRepairDetails()
+        }
       );
     }
     const supportedOutputs = new Set(
@@ -11599,7 +12378,14 @@ class FlowSurfacesService {
     for (const mappingField of (0, import_chart_config.getChartVisualMappingAliases)(state.visual)) {
       if (!supportedOutputs.has(mappingField)) {
         (0, import_errors.throwBadRequest)(
-          `chart visual mappings only support SQL query output fields: ${Array.from(supportedOutputs).join(", ")}`
+          withChartRepairMessage(
+            `chart visual mappings only support SQL query output fields: ${Array.from(supportedOutputs).join(", ")}`
+          ),
+          {
+            details: withFlowSurfaceChartRepairDetails({
+              supportedOutputs: Array.from(supportedOutputs)
+            })
+          }
         );
       }
     }
@@ -11611,7 +12397,7 @@ class FlowSurfacesService {
     return String(input || "").trim();
   }
   validateBuilderChartFieldsForRuntime(actionName, configure) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f, _g;
     const resourceInit = (0, import_chart_config.getChartBuilderResourceInit)(configure);
     if (!(resourceInit == null ? void 0 : resourceInit.collectionName)) {
       return;
@@ -11629,10 +12415,12 @@ class FlowSurfacesService {
     const selections = [
       ...import_lodash.default.castArray(state.query.measures || []).map((selection, index) => ({
         selection,
+        kind: "measure",
         path: `chart query.measures[${index}].field`
       })),
       ...import_lodash.default.castArray(state.query.dimensions || []).map((selection, index) => ({
         selection,
+        kind: "dimension",
         path: `chart query.dimensions[${index}].field`
       }))
     ];
@@ -11641,20 +12429,153 @@ class FlowSurfacesService {
       if (!fieldPath) {
         continue;
       }
+      const fieldPathParts = fieldPath.split(".").filter(Boolean);
+      const isCountMeasureSelection = item.kind === "measure" && String(((_c = item.selection) == null ? void 0 : _c.aggregation) || "").trim() === "count" && !((_d = item.selection) == null ? void 0 : _d.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) => this.getCollection(resolvedDataSourceKey, targetCollection)
+        ) : null;
+        const invalidDirectSubfield = directAssociationTargetCollection ? (0, import_service_helpers.getInvalidChartBuilderRelationDirectSubfieldDetails)({
+          associationPathName: directAssociationPath,
+          selectedSubfieldPath: fieldPathParts.slice(1).join("."),
+          targetCollection: directAssociationTargetCollection
+        }) : null;
+        if (invalidDirectSubfield) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' must reference a direct scalar child field under relation '${invalidDirectSubfield.associationPath}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+                invalidDirectSubfield.associationPath,
+                invalidDirectSubfield.supportedFields
+              )}`
+            ),
+            {
+              path: item.path,
+              ruleId: "chart-builder-query-relation-direct-subfield-required",
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                dataSourceKey,
+                collectionName,
+                ...invalidDirectSubfield
+              })
+            }
+          );
+        }
+      }
       const parsed = this.parseFieldPath(collection, fieldPath, void 0, dataSourceKey, collectionName);
+      if (parsed.associationPathName) {
+        const associationField = parsed.associationField;
+        const associationTargetCollection = associationField && (0, import_service_helpers.isAssociationField)(associationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+          associationField,
+          dataSourceKey,
+          (resolvedDataSourceKey, targetCollection) => this.getCollection(resolvedDataSourceKey, targetCollection)
+        ) : null;
+        if (!associationField || !(0, import_service_helpers.isAssociationField)(associationField) || !associationTargetCollection) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' uses invalid association path '${parsed.associationPathName}' for builder charts`
+            ),
+            {
+              path: item.path,
+              ruleId: "chart-builder-query-association-path-invalid",
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                associationPath: parsed.associationPathName,
+                dataSourceKey,
+                collectionName
+              })
+            }
+          );
+        }
+      }
       const field = (0, import_service_helpers.resolveFieldFromCollection)(parsed.leafCollection, parsed.leafFieldPath);
+      const leafModelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(parsed.leafCollection);
+      const hasLeafModelAttribute = Object.prototype.hasOwnProperty.call(leafModelAttributes, parsed.leafFieldPath);
+      const isCountMeasureRelationSubfield = item.kind === "measure" && String(((_e = item.selection) == null ? void 0 : _e.aggregation) || "").trim() === "count" && !((_f = item.selection) == null ? void 0 : _f.distinct) && parsed.associationField && (0, import_service_helpers.isAssociationField)(parsed.associationField);
+      const unsupportedRelationSubfield = parsed.associationField && (0, import_service_helpers.isAssociationField)(parsed.associationField) ? (0, import_service_helpers.getUnsupportedChartBuilderRelationSubfieldDetails)({
+        associationPathName: parsed.associationPathName,
+        leafFieldName: parsed.leafFieldPath,
+        leafField: field,
+        targetCollection: parsed.leafCollection
+      }) : null;
       if (!field) {
-        if (this.collectionHasConcreteField(parsed.leafCollection, parsed.leafFieldPath)) {
-          continue;
+        const hasConcreteField = hasLeafModelAttribute || this.collectionHasConcreteField(parsed.leafCollection, parsed.leafFieldPath);
+        if (!hasConcreteField) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' does not exist on collection '${dataSourceKey}.${collectionName}'`
+            ),
+            {
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                dataSourceKey,
+                collectionName
+              })
+            }
+          );
         }
+      }
+      if (!fieldPath.includes(".") && field && (0, import_service_helpers.isAssociationField)(field)) {
+        const suggestion = this.resolveBuilderChartAssociationSubfieldSuggestion(fieldPath, field, dataSourceKey);
         (0, import_errors.throwBadRequest)(
-          `flowSurfaces ${actionName} ${item.path} '${fieldPath}' does not exist on collection '${dataSourceKey}.${collectionName}'`
+          withChartRepairMessage(
+            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' references an association field directly; use scalar subfield '${suggestion.suggestedFieldPath}' for builder charts`
+          ),
+          {
+            details: withFlowSurfaceChartRepairDetails({
+              fieldPath,
+              dataSourceKey,
+              collectionName,
+              ...suggestion
+            })
+          }
         );
       }
-      if (!fieldPath.includes(".") && (0, import_service_helpers.isAssociationField)(field)) {
-        const suggestion = this.resolveBuilderChartAssociationSubfieldSuggestion(fieldPath, field, dataSourceKey);
+      if (isCountMeasureRelationSubfield) {
+        (0, import_errors.throwBadRequest)(
+          withChartRepairMessage(
+            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' counts a relation subfield; count a scalar base field such as 'id' and keep '${fieldPath}' as a dimension`
+          ),
+          {
+            path: item.path,
+            ruleId: "chart-builder-query-count-measure-relation-subfield",
+            details: withFlowSurfaceChartRepairDetails({
+              fieldPath,
+              dataSourceKey,
+              collectionName,
+              suggestedMeasure: {
+                field: "id",
+                aggregation: "count",
+                alias: String(((_g = item.selection) == null ? void 0 : _g.alias) || "").trim() || "recordCount"
+              },
+              suggestedDimension: {
+                field: fieldPath
+              }
+            })
+          }
+        );
+      }
+      if (unsupportedRelationSubfield) {
         (0, import_errors.throwBadRequest)(
-          `flowSurfaces ${actionName} ${item.path} '${fieldPath}' references an association field directly; use scalar subfield '${suggestion.suggestedFieldPath}' for builder charts`
+          withChartRepairMessage(
+            `flowSurfaces ${actionName} ${item.path} '${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)(
+              unsupportedRelationSubfield.associationPath,
+              unsupportedRelationSubfield.supportedFields
+            )}`
+          ),
+          {
+            path: item.path,
+            ruleId: "chart-builder-query-relation-subfield-column-unsupported",
+            details: withFlowSurfaceChartRepairDetails({
+              fieldPath,
+              dataSourceKey,
+              collectionName,
+              ...unsupportedRelationSubfield
+            })
+          }
         );
       }
     }
@@ -11679,6 +12600,48 @@ class FlowSurfacesService {
       suggestedFieldPath: `${fieldPath}.<field>`
     };
   }
+  async validateChartConfigureForRuntime(actionName, configure, transaction) {
+    var _a, _b, _c;
+    if (!import_lodash.default.isPlainObject(configure)) {
+      return;
+    }
+    this.validateBuilderChartFieldsForRuntime(actionName, configure);
+    const state = (0, import_chart_config.deriveChartSemanticState)(configure);
+    if (((_a = state.query) == null ? void 0 : _a.mode) !== "sql") {
+      return;
+    }
+    const sqlPreview = await this.resolveSqlChartPreview(state.query, transaction);
+    if (((_b = state.visual) == null ? void 0 : _b.mode) !== "basic") {
+      return;
+    }
+    if (!((_c = sqlPreview.queryOutputs) == null ? void 0 : _c.length)) {
+      (0, import_errors.throwBadRequest)(
+        withChartRepairMessage(
+          "chart visual.mode='basic' requires previewable SQL query outputs; write query first, then read flowSurfaces:context(path='chart'), or use visual.mode='custom' after browser verification"
+        ),
+        {
+          details: withFlowSurfaceChartRepairDetails()
+        }
+      );
+    }
+    const supportedOutputs = new Set(
+      sqlPreview.queryOutputs.map((output) => String((output == null ? void 0 : output.alias) || "").trim()).filter(Boolean)
+    );
+    for (const mappingField of (0, import_chart_config.getChartVisualMappingAliases)(state.visual)) {
+      if (!supportedOutputs.has(mappingField)) {
+        (0, import_errors.throwBadRequest)(
+          withChartRepairMessage(
+            `chart visual mappings only support SQL query output fields: ${Array.from(supportedOutputs).join(", ")}`
+          ),
+          {
+            details: withFlowSurfaceChartRepairDetails({
+              supportedOutputs: Array.from(supportedOutputs)
+            })
+          }
+        );
+      }
+    }
+  }
   stripChartSqlForInspection(sql) {
     return sql.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\r\n]*/g, " ").replace(/'(?:''|[^'])*'/g, "''").replace(/"(?:[""]|[^"])*"/g, '""');
   }
@@ -11686,16 +12649,16 @@ class FlowSurfacesService {
     const normalized = (typeof sql === "string" ? sql : "").trim();
     const inspected = this.stripChartSqlForInspection(normalized).replace(/;+\s*$/, "").trim();
     if (!inspected) {
-      (0, import_errors.throwBadRequest)("chart query.sql cannot be empty");
+      throwChartRepairBadRequest("chart query.sql cannot be empty");
     }
     if (inspected.includes(";")) {
-      (0, import_errors.throwBadRequest)("chart query.sql must be a single read-only SELECT statement");
+      throwChartRepairBadRequest("chart query.sql must be a single read-only SELECT statement");
     }
     if (!/^(with|select)\b/i.test(inspected)) {
-      (0, import_errors.throwBadRequest)("chart query.sql must start with SELECT or WITH");
+      throwChartRepairBadRequest("chart query.sql must start with SELECT or WITH");
     }
     if (/\b(insert|update|delete|drop|alter|truncate|create|replace|grant|revoke|merge|call|execute)\b/i.test(inspected)) {
-      (0, import_errors.throwBadRequest)("chart query.sql must be read-only");
+      throwChartRepairBadRequest("chart query.sql must be read-only");
     }
     return normalized.replace(/;+\s*$/, "").trim();
   }
@@ -11713,7 +12676,7 @@ class FlowSurfacesService {
     if ((_a = db == null ? void 0 : db.sequelize) == null ? void 0 : _a.query) {
       return db.sequelize.query(sql, { bind, transaction });
     }
-    (0, import_errors.throwBadRequest)("chart SQL preview is unavailable for the target data source");
+    throwChartRepairBadRequest("chart SQL preview is unavailable for the target data source");
   }
   extractSqlChartPreviewAliases(metadata) {
     const pickName = (field) => {
@@ -11751,7 +12714,13 @@ class FlowSurfacesService {
   async resolveSqlChartPreview(query, _transaction) {
     var _a, _b;
     const normalizedSql = this.normalizeReadOnlyChartSql(query == null ? void 0 : query.sql);
-    const transformed = await (0, import_utils.transformSQL)(normalizedSql);
+    let transformed;
+    try {
+      transformed = await (0, import_utils.transformSQL)(normalizedSql);
+    } catch (error) {
+      const message = (error == null ? void 0 : error.message) || String(error);
+      throwChartRepairBadRequest(`chart query.sql is invalid: ${message}`);
+    }
     const riskyHints = [];
     const hasRuntimeContext = Object.keys((transformed == null ? void 0 : transformed.bind) || {}).length > 0 || Object.keys((transformed == null ? void 0 : transformed.liquidContext) || {}).length > 0;
     if (hasRuntimeContext) {
@@ -11807,7 +12776,7 @@ class FlowSurfacesService {
       }
       const outputAliases = Object.keys(firstRow);
       if (!outputAliases.length) {
-        (0, import_errors.throwBadRequest)("chart query.sql must expose at least one output column");
+        throwChartRepairBadRequest("chart query.sql must expose at least one output column");
       }
       return {
         queryOutputs: outputAliases.map((alias) => ({
@@ -11818,8 +12787,11 @@ class FlowSurfacesService {
         riskyHints
       };
     } catch (error) {
+      if (isFlowSurfaceChartRepairError(error)) {
+        throw error;
+      }
       const message = (error == null ? void 0 : error.message) || String(error);
-      (0, import_errors.throwBadRequest)(`chart query.sql is invalid: ${message}`);
+      throwChartRepairBadRequest(`chart query.sql is invalid: ${message}`);
     }
   }
   syncChartCardRuntimeStepParamsForUpdateSettings(current, nextPayload, replacementCardSettings) {
@@ -11876,6 +12848,8 @@ class FlowSurfacesService {
       options
     );
     const flowRegistry = this.getEventFlowRegistry(current);
+    const directEvents = import_lodash.default.cloneDeep(((_a = contract.eventCapabilities) == null ? void 0 : _a.direct) || []);
+    const objectEvents = import_lodash.default.uniq([...import_lodash.default.cloneDeep(((_b = contract.eventCapabilities) == null ? void 0 : _b.object) || []), ...directEvents]);
     return {
       target: {
         uid: target.uid,
@@ -11884,8 +12858,8 @@ class FlowSurfacesService {
       },
       flowRegistry,
       events: {
-        direct: import_lodash.default.cloneDeep(((_a = contract.eventCapabilities) == null ? void 0 : _a.direct) || []),
-        object: import_lodash.default.cloneDeep(((_b = contract.eventCapabilities) == null ? void 0 : _b.object) || [])
+        direct: directEvents,
+        object: objectEvents
       },
       phases: {
         supported: ["beforeAllFlows", "afterAllFlows", "beforeFlow", "afterFlow", "beforeStep", "afterStep"],
@@ -11920,13 +12894,12 @@ class FlowSurfacesService {
     if (phase !== "beforeAllFlows") {
       (0, import_errors.throwBadRequest)(`flowSurfaces addEventFlow only supports phase 'beforeAllFlows'`);
     }
-    const flow = this.normalizeAddEventFlowInput(key, values, phase);
-    const nextFlowRegistry = {
+    const nextFlowRegistry = this.normalizeEventFlowRegistry("addEventFlow", {
       ...flowRegistry,
-      [key]: flow
-    };
+      [key]: this.normalizeAddEventFlowInput(key, values, phase)
+    });
     await this.persistEventFlowRegistry("addEventFlow", target, current, nextFlowRegistry, options);
-    return this.buildEventFlowWriteResult(target, key, flow, nextFlowRegistry);
+    return this.buildEventFlowWriteResult(target, key, nextFlowRegistry[key], nextFlowRegistry);
   }
   async setEventFlow(values, options = {}) {
     var _a;
@@ -11940,13 +12913,12 @@ class FlowSurfacesService {
     const key = this.normalizeEventFlowKey("setEventFlow", (values == null ? void 0 : values.key) ?? ((_a = values == null ? void 0 : values.flow) == null ? void 0 : _a.key));
     this.assertEventFlowFingerprint("setEventFlow", values == null ? void 0 : values.expectedFingerprint, flowRegistry);
     const flowInput = import_lodash.default.isPlainObject(values == null ? void 0 : values.flow) ? values.flow : values;
-    const flow = this.normalizeEventFlowObject("setEventFlow", key, flowInput);
-    const nextFlowRegistry = {
+    const nextFlowRegistry = this.normalizeEventFlowRegistry("setEventFlow", {
       ...flowRegistry,
-      [key]: flow
-    };
+      [key]: this.normalizeEventFlowObject("setEventFlow", key, flowInput)
+    });
     await this.persistEventFlowRegistry("setEventFlow", target, current, nextFlowRegistry, options);
-    return this.buildEventFlowWriteResult(target, key, flow, nextFlowRegistry);
+    return this.buildEventFlowWriteResult(target, key, nextFlowRegistry[key], nextFlowRegistry);
   }
   async removeEventFlow(values, options = {}) {
     (0, import_payload_shape.validateFlowSurfacePayloadShape)("removeEventFlow", values, "values");
@@ -11961,14 +12933,14 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)(`flowSurfaces removeEventFlow flow '${key}' does not exist`);
     }
     this.assertEventFlowFingerprint("removeEventFlow", values == null ? void 0 : values.expectedFingerprint, flowRegistry);
-    const nextFlowRegistry = import_lodash.default.omit(flowRegistry, [key]);
+    const nextFlowRegistry = this.normalizeEventFlowRegistry("removeEventFlow", import_lodash.default.omit(flowRegistry, [key]));
     await this.persistEventFlowRegistry("removeEventFlow", target, current, nextFlowRegistry, options);
     return this.buildEventFlowWriteResult(target, key, void 0, nextFlowRegistry);
   }
   async setEventFlows(values, options = {}) {
     (0, import_payload_shape.validateFlowSurfacePayloadShape)("setEventFlows", values, "values");
     const { target, current } = await this.resolveEventFlowTarget("setEventFlows", values == null ? void 0 : values.target, values, options);
-    const flows = values.flowRegistry || values.flows || {};
+    const flows = this.normalizeEventFlowRegistry("setEventFlows", values.flowRegistry || values.flows || {});
     await this.persistEventFlowRegistry("setEventFlows", target, current, flows, options);
     return {
       uid: target.uid,
@@ -11994,7 +12966,10 @@ class FlowSurfacesService {
     };
   }
   getEventFlowRegistry(node) {
-    return import_lodash.default.isPlainObject(node == null ? void 0 : node.flowRegistry) ? import_lodash.default.cloneDeep(node.flowRegistry) : {};
+    return import_lodash.default.isPlainObject(node == null ? void 0 : node.flowRegistry) ? this.normalizeEventFlowRegistry("getEventFlowRegistry", node.flowRegistry) : {};
+  }
+  normalizeEventFlowRegistry(actionName, flowRegistry) {
+    return (0, import_event_flow_normalizer.normalizeFlowSurfaceEventFlowRegistry)(actionName, flowRegistry);
   }
   buildEventFlowFingerprint(flowRegistry) {
     return this.buildSurfaceFingerprint({
@@ -12032,7 +13007,9 @@ class FlowSurfacesService {
   normalizeAddEventFlowInput(key, values, phase) {
     var _a, _b, _c;
     const flow = import_lodash.default.isPlainObject(values.flow) ? import_lodash.default.cloneDeep(values.flow) : {};
-    const eventName = String(values.eventName ?? ((_a = flow == null ? void 0 : flow.on) == null ? void 0 : _a.eventName) ?? "").trim();
+    const eventName = String(
+      values.eventName ?? (typeof flow.on === "string" ? flow.on : (_a = flow == null ? void 0 : flow.on) == null ? void 0 : _a.eventName) ?? ""
+    ).trim();
     if (!eventName) {
       (0, import_errors.throwBadRequest)(`flowSurfaces addEventFlow requires eventName`);
     }
@@ -12055,25 +13032,7 @@ class FlowSurfacesService {
     });
   }
   normalizeEventFlowObject(actionName, key, flowInput) {
-    if (!import_lodash.default.isPlainObject(flowInput)) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} flow '${key}' must be an object`);
-    }
-    const flow = import_lodash.default.cloneDeep(flowInput);
-    flow.key = key;
-    if (import_lodash.default.isPlainObject(flow.on)) {
-      const eventName = String(flow.on.eventName || "").trim();
-      if (eventName) {
-        flow.on.eventName = eventName;
-      }
-      const phase = String(flow.on.phase || "").trim();
-      if (phase) {
-        flow.on.phase = phase;
-      }
-    }
-    if (import_lodash.default.isUndefined(flow.steps)) {
-      flow.steps = {};
-    }
-    return flow;
+    return (0, import_event_flow_normalizer.normalizeFlowSurfaceEventFlow)(actionName, key, flowInput);
   }
   async persistEventFlowRegistry(actionName, target, current, flowRegistry, options = {}) {
     this.assertNoTreeConnectFieldsFlowRegistry(current, flowRegistry, actionName);
@@ -13827,6 +14786,97 @@ class FlowSurfacesService {
       }
     }
   }
+  hasActionWithPublicType(actions, type) {
+    return actions.some((action) => import_catalog.ACTION_KEY_BY_USE.get(String((action == null ? void 0 : action.use) || "").trim()) === type);
+  }
+  async ensureTableDefaultActionIntegrity(tableUid, options = {}) {
+    var _a, _b, _c, _d;
+    let table = await this.repository.findModelById(tableUid, {
+      transaction: options.transaction,
+      includeAsyncNode: true
+    });
+    if ((table == null ? void 0 : table.use) !== "TableBlockModel" || this.resolveTreeTableCreationContext(table)) {
+      return;
+    }
+    const descriptors = (0, import_default_block_actions.getFlowSurfaceDefaultBlockActions)({ blockType: "table" });
+    const blockActionDescriptors = descriptors.filter((descriptor) => descriptor.scope === "actions");
+    const recordActionDescriptors = descriptors.filter((descriptor) => descriptor.scope === "recordActions");
+    let blockActions = import_lodash.default.castArray(((_a = table == null ? void 0 : table.subModels) == null ? void 0 : _a.actions) || []);
+    for (const descriptor of blockActionDescriptors) {
+      if (this.hasActionWithPublicType(blockActions, descriptor.type)) {
+        continue;
+      }
+      await this.addAction(
+        {
+          target: { uid: tableUid },
+          type: descriptor.type,
+          ...descriptor.popup ? { popup: import_lodash.default.cloneDeep(descriptor.popup) } : {}
+        },
+        options
+      );
+      table = await this.repository.findModelById(tableUid, {
+        transaction: options.transaction,
+        includeAsyncNode: true
+      });
+      blockActions = import_lodash.default.castArray(((_b = table == null ? void 0 : table.subModels) == null ? void 0 : _b.actions) || []);
+    }
+    const actionsColumnUid = await this.ensureTableActionsColumn(tableUid, options.transaction);
+    let actionsColumn = await this.repository.findModelById(actionsColumnUid, {
+      transaction: options.transaction,
+      includeAsyncNode: true
+    });
+    let recordActions = import_lodash.default.castArray(((_c = actionsColumn == null ? void 0 : actionsColumn.subModels) == null ? void 0 : _c.actions) || []);
+    for (const descriptor of recordActionDescriptors) {
+      if (this.hasActionWithPublicType(recordActions, descriptor.type)) {
+        continue;
+      }
+      await this.addRecordAction(
+        {
+          target: { uid: tableUid },
+          type: descriptor.type,
+          ...descriptor.popup ? { popup: import_lodash.default.cloneDeep(descriptor.popup) } : {}
+        },
+        options
+      );
+      actionsColumn = await this.repository.findModelById(actionsColumnUid, {
+        transaction: options.transaction,
+        includeAsyncNode: true
+      });
+      recordActions = import_lodash.default.castArray(((_d = actionsColumn == null ? void 0 : actionsColumn.subModels) == null ? void 0 : _d.actions) || []);
+    }
+    const missingRecordActions = recordActionDescriptors.map((descriptor) => descriptor.type).filter((type) => !this.hasActionWithPublicType(recordActions, type));
+    if (missingRecordActions.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces table '${tableUid}' is missing required default record actions`, {
+        ruleId: "table-record-actions-required",
+        details: {
+          tableUid,
+          missingRecordActions,
+          repairHint: "Put row actions under recordActions, or omit/pass an empty recordActions array so Flow Surfaces can create the default View/Edit/Delete row actions."
+        }
+      });
+    }
+  }
+  collectNodeTreeDescendants(node, predicate, bucket = []) {
+    if (!node || typeof node !== "object") {
+      return bucket;
+    }
+    if (predicate(node)) {
+      bucket.push(node);
+    }
+    Object.values(import_lodash.default.isPlainObject(node.subModels) ? node.subModels : {}).forEach((subModel) => {
+      import_lodash.default.castArray(subModel).forEach((child) => this.collectNodeTreeDescendants(child, predicate, bucket));
+    });
+    return bucket;
+  }
+  async ensureSurfaceTableDefaultActionIntegrity(pageLocator, options = {}) {
+    const surface = await this.get(pageLocator, options);
+    const tables = this.collectNodeTreeDescendants(surface == null ? void 0 : surface.tree, (item) => (item == null ? void 0 : item.use) === "TableBlockModel");
+    for (const table of tables) {
+      if (table == null ? void 0 : table.uid) {
+        await this.ensureTableDefaultActionIntegrity(table.uid, options);
+      }
+    }
+  }
   async resolveReusableSingletonAction(input) {
     var _a, _b, _c;
     if (AUTO_SUBMIT_FORM_BLOCK_USES.has(input.ownerUse || "") && input.actionUse === "FormSubmitActionModel") {
@@ -13990,8 +15040,10 @@ class FlowSurfacesService {
     if (blockCatalogItem) {
       this.validateComposeActionGroups(blockCatalogItem.use, actions, recordActions, enabledPackages);
     }
-    const actionKeys = new Set(actions.map((item) => item.key).filter(Boolean));
-    const recordActionKeys = new Set(recordActions.map((item) => item.key).filter(Boolean));
+    const actionKeys = new Set(actions.map((item) => String(item.key || "").trim()).filter(Boolean));
+    const recordActionKeys = new Set(
+      recordActions.map((item) => String(item.key || "").trim()).filter(Boolean)
+    );
     const blockDescriptor = this.describeComposeBlock({
       index: index + 1,
       key,
@@ -14422,6 +15474,7 @@ class FlowSurfacesService {
           ...(0, import_service_utils.hasDefinedValue)(changes, [
             "pageSize",
             "density",
+            "enableRowSelection",
             "showRowNumbers",
             "sorting",
             "dataScope",
@@ -14435,6 +15488,7 @@ class FlowSurfacesService {
               ...(0, import_service_utils.hasOwnDefined)(changes, "pageSize") ? { pageSize: { pageSize: changes.pageSize } } : {},
               ...(0, import_service_utils.hasOwnDefined)(changes, "density") ? { tableDensity: { size: changes.density } } : {},
               ...(0, import_service_utils.hasOwnDefined)(changes, "quickEdit") ? { quickEdit: { editable: changes.quickEdit } } : {},
+              ...(0, import_service_utils.hasOwnDefined)(changes, "enableRowSelection") ? { enableRowSelection: { enableRowSelection: changes.enableRowSelection } } : {},
               ...(0, import_service_utils.hasOwnDefined)(changes, "showRowNumbers") ? { showRowNumbers: { showIndex: changes.showRowNumbers } } : {},
               ...(0, import_service_utils.hasOwnDefined)(changes, "sorting") ? {
                 defaultSorting: {
@@ -15370,7 +16424,10 @@ class FlowSurfacesService {
     const shouldLoadCurrent = shouldUpdateConfigure || shouldUpdateCardSettings;
     const resolved = shouldLoadCurrent ? await this.locator.resolve(target, options) : null;
     const current = resolved ? await this.loadResolvedNode(resolved, options.transaction) : null;
-    let nextConfigure = shouldUpdateConfigure ? (0, import_chart_config.buildChartConfigureFromSemanticChanges)(import_lodash.default.get(current, ["stepParams", "chartSettings", "configure"]), changes) : void 0;
+    let nextConfigure = shouldUpdateConfigure ? buildChartConfigureFromSemanticChangesWithRepair(
+      import_lodash.default.get(current, ["stepParams", "chartSettings", "configure"]),
+      changes
+    ) : void 0;
     if (shouldUpdateConfigure) {
       nextConfigure = await this.stripBasicSqlVisualWhenPreviewUnavailable(nextConfigure, changes, options.transaction);
     }
@@ -15498,18 +16555,18 @@ class FlowSurfacesService {
     return String(raw || "").trim();
   }
   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 = import_lodash.default.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);
   }
   assertInitialBlockResourceCompatible(actionName, blockUse, resourceInit, popupProfile) {
     if (blockUse === "CommentsBlockModel") {
@@ -15812,6 +16869,7 @@ class FlowSurfacesService {
     );
   }
   async configureJSColumn(target, changes, options) {
+    assertNoJsDeclarativeOpenView("jsColumn", changes, "JSColumnModel");
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("JSColumnModel");
     (0, import_service_utils.assertSupportedSimpleChanges)("jsColumn", changes, allowedKeys);
     return this.updateSettings(
@@ -15845,6 +16903,8 @@ class FlowSurfacesService {
     );
   }
   async configureJSItem(target, changes, options) {
+    const { currentUse = "JSItemModel", ...updateOptions } = options;
+    assertNoJsDeclarativeOpenView("jsItem", changes, currentUse);
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)("JSItemModel");
     (0, import_service_utils.assertSupportedSimpleChanges)("jsItem", changes, allowedKeys);
     return this.updateSettings(
@@ -15869,7 +16929,7 @@ class FlowSurfacesService {
           }
         } : void 0
       },
-      options
+      updateOptions
     );
   }
   async configureDividerItem(target, changes, options) {
@@ -15920,6 +16980,7 @@ class FlowSurfacesService {
       transaction: options.transaction,
       includeAsyncNode: true
     }) : null;
+    assertNoJsDeclarativeOpenView("field", changes, innerField == null ? void 0 : innerField.use);
     const currentFieldInit = ((_e = (_d = current == null ? void 0 : current.stepParams) == null ? void 0 : _d.fieldSettings) == null ? void 0 : _e.init) || ((_g = (_f = innerField == null ? void 0 : innerField.stepParams) == null ? void 0 : _f.fieldSettings) == null ? void 0 : _g.init) || {};
     const bindingChange = (0, import_service_utils.hasDefinedValue)(wrapperChanges, ["fieldPath", "associationPathName"]);
     const normalizedBinding = bindingChange ? this.normalizeDisplayFieldBinding({
@@ -16131,6 +17192,8 @@ class FlowSurfacesService {
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const resolved = await this.locator.resolve(target, options);
     const current = await this.loadResolvedNode(resolved, options.transaction);
+    const isJsFieldNode = ["JSFieldModel", "JSEditableFieldModel"].includes((current == null ? void 0 : current.use) || "");
+    assertNoJsDeclarativeOpenView("field", changes, current == null ? void 0 : current.use);
     (0, import_service_utils.assertSupportedSimpleChanges)(
       "field",
       changes,
@@ -16141,7 +17204,6 @@ class FlowSurfacesService {
       transaction: options.transaction,
       includeAsyncNode: true
     }) : null;
-    const isJsFieldNode = ["JSFieldModel", "JSEditableFieldModel"].includes((current == null ? void 0 : current.use) || "");
     if ((0, import_service_utils.hasDefinedValue)(changes, ["code", "version"]) && !isJsFieldNode) {
       (0, import_errors.throwBadRequest)(`flowSurfaces configure field '${current == null ? void 0 : current.use}' does not support code/version`);
     }
@@ -16315,7 +17377,11 @@ class FlowSurfacesService {
         items: []
       };
     }
-    return import_lodash.default.cloneDeep(value);
+    return (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
+      value,
+      `flowSurfaces configure action defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+      { strictDateValues: true }
+    );
   }
   normalizeActionAssignValues(actionName, value) {
     if (!import_lodash.default.isPlainObject(value)) {
@@ -16346,6 +17412,93 @@ class FlowSurfacesService {
   isAIEmployeeActionUse(use) {
     return String(use || "").trim() === AI_EMPLOYEE_ACTION_USE;
   }
+  stableSerializeAIEmployeeValue(value) {
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => this.stableSerializeAIEmployeeValue(item)).join(",")}]`;
+    }
+    if (import_lodash.default.isPlainObject(value)) {
+      return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${this.stableSerializeAIEmployeeValue(value[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+  }
+  buildAIEmployeeActionDedupIdentity(values) {
+    var _a, _b, _c, _d, _e, _f;
+    const username = String(((_b = (_a = values == null ? void 0 : values.props) == null ? void 0 : _a.aiEmployee) == null ? void 0 : _b.username) || "").trim();
+    if (!username) {
+      return "";
+    }
+    return this.stableSerializeAIEmployeeValue({
+      username,
+      auto: typeof ((_c = values == null ? void 0 : values.props) == null ? void 0 : _c.auto) === "boolean" ? values.props.auto : false,
+      workContext: this.normalizeAIEmployeeWorkContextForDedupIdentity((_e = (_d = values == null ? void 0 : values.props) == null ? void 0 : _d.context) == null ? void 0 : _e.workContext),
+      tasks: this.normalizeAIEmployeeTasksForDedupIdentity(
+        import_lodash.default.get(values, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])
+      ),
+      style: {
+        ...AI_EMPLOYEE_DEFAULT_STYLE,
+        ...import_lodash.default.isPlainObject((_f = values == null ? void 0 : values.props) == null ? void 0 : _f.style) ? import_lodash.default.pick(values.props.style, AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
+      }
+    });
+  }
+  normalizeAIEmployeeWorkContextForDedupIdentity(value) {
+    return import_lodash.default.castArray(value || []).map(
+      (item) => import_lodash.default.isPlainObject(item) ? import_lodash.default.pick(item, AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS) : item
+    );
+  }
+  normalizeAIEmployeeTasksForDedupIdentity(value) {
+    return import_lodash.default.castArray(value || []).map((task) => {
+      if (!import_lodash.default.isPlainObject(task)) {
+        return task;
+      }
+      const output = import_lodash.default.pick(task, AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS);
+      if (import_lodash.default.isPlainObject(output.message)) {
+        output.message = import_lodash.default.pick(output.message, AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS);
+        if (Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
+          output.message.workContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(output.message.workContext);
+        }
+      }
+      if (import_lodash.default.isPlainObject(output.model)) {
+        output.model = import_lodash.default.pick(output.model, AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS);
+      }
+      if (import_lodash.default.isPlainObject(output.skillSettings)) {
+        output.skillSettings = import_lodash.default.pick(output.skillSettings, AI_EMPLOYEE_SKILL_SETTINGS_PUBLIC_KEYS);
+      }
+      return output;
+    });
+  }
+  async assertNoDuplicateAIEmployeeAction(actionName, parentUid, values, transaction) {
+    var _a;
+    const identity = this.buildAIEmployeeActionDedupIdentity(values);
+    if (!identity) {
+      return;
+    }
+    const parentNode = await this.repository.findModelById(parentUid, {
+      transaction,
+      includeAsyncNode: true
+    });
+    const duplicate = import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a.actions) || []).find((action) => {
+      if (!this.isAIEmployeeActionUse(action == null ? void 0 : action.use)) {
+        return false;
+      }
+      return this.buildAIEmployeeActionDedupIdentity({
+        props: action.props,
+        stepParams: action.stepParams
+      }) === identity;
+    });
+    if (!(duplicate == null ? void 0 : duplicate.uid)) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} 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`,
+      {
+        ruleId: "duplicate-ai-employee-action",
+        details: {
+          existingUid: duplicate.uid,
+          repairHint: "Remove the duplicate aiEmployee action, or change username, task title/key, or workContext if this is a genuinely different AI employee action."
+        }
+      }
+    );
+  }
   hasAIEmployeePublicSettings(settings) {
     return import_lodash.default.isPlainObject(settings) && AI_EMPLOYEE_PUBLIC_SETTING_KEYS.some((key) => Object.prototype.hasOwnProperty.call(settings, key));
   }
@@ -16353,16 +17506,31 @@ class FlowSurfacesService {
     const unsupportedKeys = Object.keys(settings || {}).filter((key) => !AI_EMPLOYEE_PUBLIC_SETTING_KEYS.includes(key));
     if (unsupportedKeys.length) {
       (0, import_errors.throwBadRequest)(
-        `flowSurfaces ${actionName} AI employee settings do not support keys: ${unsupportedKeys.join(", ")}`
+        `flowSurfaces ${actionName} AI employee settings do not support keys: ${unsupportedKeys.join(
+          ", "
+        )}; allowed keys: ${AI_EMPLOYEE_PUBLIC_SETTING_KEYS.join(
+          ", "
+        )}; repairHint: use top-level username, auto, workContext, tasks, or style instead of raw props/stepParams`
       );
     }
   }
+  aiEmployeeNestedRepairHint(path) {
+    if (path.includes("workContext")) {
+      return AI_EMPLOYEE_WORK_CONTEXT_REPAIR_HINT;
+    }
+    if (path.includes("tasks")) {
+      return AI_EMPLOYEE_TASK_REPAIR_HINT;
+    }
+    return "Use only the documented public AI employee settings keys for this nested object.";
+  }
   assertOnlyAIEmployeeNestedPublicSettings(actionName, path, value, allowedKeys) {
     const unsupportedKeys = Object.keys(value || {}).filter((key) => !allowedKeys.includes(key));
     if (!unsupportedKeys.length) {
       return;
     }
-    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} does not support key '${unsupportedKeys[0]}'`);
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${path} does not support key '${unsupportedKeys[0]}'; allowed keys: ${allowedKeys.join(", ")}; repairHint: ${this.aiEmployeeNestedRepairHint(path)}`
+    );
   }
   assertNoAIEmployeeInternalPropSettings(actionName, values) {
     const props = values == null ? void 0 : values.props;
@@ -16381,6 +17549,67 @@ class FlowSurfacesService {
       )}; use top-level username, auto, workContext, tasks or style instead`
     );
   }
+  readAIEmployeePersistedTasks(current) {
+    var _a;
+    const stepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (Array.isArray(stepTasks)) {
+      return stepTasks;
+    }
+    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    return Array.isArray(legacyPropsTasks) ? legacyPropsTasks : [];
+  }
+  buildAIEmployeeTaskStepParams(tasks) {
+    const stepParams = {};
+    import_lodash.default.set(stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH, import_lodash.default.cloneDeep(tasks));
+    return stepParams;
+  }
+  mergeAIEmployeeActionSettingsPayload(current, values, payload) {
+    if (Object.keys(payload.props).length) {
+      values.props = import_lodash.default.merge({}, values.props || {}, payload.props);
+    }
+    if (Object.keys(payload.stepParams).length) {
+      values.stepParams = import_lodash.default.mergeWith({}, values.stepParams || {}, payload.stepParams, (_currentValue, nextValue) => {
+        if (Array.isArray(nextValue)) {
+          return import_lodash.default.cloneDeep(nextValue);
+        }
+        return void 0;
+      });
+    }
+    if (import_lodash.default.has(payload.stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH) && this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      if (import_lodash.default.isPlainObject(values.props)) {
+        delete values.props.tasks;
+      }
+    }
+  }
+  syncAIEmployeeTaskStepParamsForUpdateSettings(current, nextPayload) {
+    var _a;
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      return;
+    }
+    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const hasLegacyPropsTasks = Array.isArray(legacyPropsTasks);
+    const hasNextStepTasks = import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    const currentStepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!hasNextStepTasks && hasLegacyPropsTasks && !Array.isArray(currentStepTasks)) {
+      nextPayload.stepParams = import_lodash.default.mergeWith(
+        {},
+        (current == null ? void 0 : current.stepParams) || {},
+        this.buildAIEmployeeTaskStepParams(legacyPropsTasks),
+        (_currentValue, nextValue) => {
+          if (Array.isArray(nextValue)) {
+            return import_lodash.default.cloneDeep(nextValue);
+          }
+          return void 0;
+        }
+      );
+    }
+    if (!hasLegacyPropsTasks && !import_lodash.default.has(nextPayload, ["props", "tasks"])) {
+      return;
+    }
+    const nextProps = import_lodash.default.cloneDeep(nextPayload.props ?? (current == null ? void 0 : current.props) ?? {});
+    delete nextProps.tasks;
+    nextPayload.props = nextProps;
+  }
   assertAIEmployeePluginEnabled(actionName, enabledPackages) {
     if (!enabledPackages.has(AI_EMPLOYEE_OWNER_PLUGIN)) {
       (0, import_errors.throwBadRequest)(
@@ -16464,8 +17693,13 @@ class FlowSurfacesService {
     return username;
   }
   assertAIEmployeeWorkContextType(actionName, itemPath, item) {
+    if (!Object.prototype.hasOwnProperty.call(item, "type") || import_lodash.default.isUndefined(item.type) || item.type === null) {
+      return;
+    }
     if (String(item.type || "").trim() !== "flow-model") {
-      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${itemPath}.type must be 'flow-model'`);
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${itemPath}.type only supports 'flow-model'; omit type to use the default flow-model context. repairHint: ${AI_EMPLOYEE_WORK_CONTEXT_REPAIR_HINT}`
+      );
     }
   }
   normalizeAIEmployeeWorkContext(actionName, value, options) {
@@ -16574,8 +17808,290 @@ class FlowSurfacesService {
     if (Object.prototype.hasOwnProperty.call(next, "toolsVersion") && typeof next.toolsVersion !== "number") {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.toolsVersion must be a number`);
     }
+    const hasSkills = Object.prototype.hasOwnProperty.call(next, "skills");
+    const hasTools = Object.prototype.hasOwnProperty.call(next, "tools");
+    const hasSkillsVersion = Object.prototype.hasOwnProperty.call(next, "skillsVersion");
+    const hasToolsVersion = Object.prototype.hasOwnProperty.call(next, "toolsVersion");
+    if (hasSkills && hasTools && !hasSkillsVersion && !hasToolsVersion && Array.isArray(next.skills) && Array.isArray(next.tools) && next.skills.length === 0 && next.tools.length === 0) {
+      return null;
+    }
+    if (hasSkills && !hasSkillsVersion) {
+      next.skillsVersion = 2;
+    }
+    if (hasTools && !hasToolsVersion) {
+      next.toolsVersion = 2;
+    }
     return next;
   }
+  collectAIEmployeePromptVariables(value) {
+    if (!value.includes("{{")) {
+      return [];
+    }
+    return [...value.matchAll(/\{\{\s*([\s\S]+?)\s*\}\}/g)].map(([raw, inner]) => ({
+      raw,
+      inner: String(inner || "").trim()
+    }));
+  }
+  hasAIEmployeePromptVariables(tasks) {
+    return import_lodash.default.castArray(tasks || []).some((task) => {
+      const message = task == null ? void 0 : task.message;
+      return typeof (message == null ? void 0 : message.system) === "string" && this.collectAIEmployeePromptVariables(message.system).length > 0 || typeof (message == null ? void 0 : message.user) === "string" && this.collectAIEmployeePromptVariables(message.user).length > 0;
+    });
+  }
+  collectAIEmployeeContextPathEntries(context) {
+    const result = /* @__PURE__ */ new Map();
+    const visit = (prefix, info) => {
+      if (!prefix || !info) {
+        return;
+      }
+      result.set(prefix, info);
+      if (info.dynamicProperties) {
+        result.set(`${prefix}.*`, info.dynamicProperties);
+      }
+      for (const [childKey, childInfo] of Object.entries(info.properties || {})) {
+        visit(`${prefix}.${childKey}`, childInfo);
+      }
+    };
+    for (const [key, info] of Object.entries((context == null ? void 0 : context.vars) || {})) {
+      visit(key, info);
+    }
+    return result;
+  }
+  isAIEmployeeContextInfoPathAllowed(info, segments) {
+    var _a;
+    if (!info) {
+      return false;
+    }
+    if (!segments.length) {
+      return true;
+    }
+    const [segment, ...rest] = segments;
+    const staticChild = (_a = info.properties) == null ? void 0 : _a[segment];
+    if (staticChild) {
+      return this.isAIEmployeeContextInfoPathAllowed(staticChild, rest);
+    }
+    if (info.dynamicProperties) {
+      return this.isAIEmployeeContextInfoPathAllowed(info.dynamicProperties, rest);
+    }
+    return false;
+  }
+  canResolveAIEmployeeContextPath(path, semantic) {
+    var _a;
+    return !!((_a = (0, import_context.buildFlowSurfaceContextResponse)({
+      semantic,
+      path,
+      maxDepth: 1
+    }).vars) == null ? void 0 : _a[path]);
+  }
+  isAIEmployeeContextPathAllowed(path, validation) {
+    if (validation.contextPaths.has(path)) {
+      return true;
+    }
+    for (const [allowedPath, info] of validation.contextPaths) {
+      if (!allowedPath.endsWith(".*")) {
+        continue;
+      }
+      const prefix = allowedPath.slice(0, -2);
+      if (!path.startsWith(`${prefix}.`)) {
+        continue;
+      }
+      const dynamicSegments = path.slice(prefix.length + 1).split(".").filter(Boolean);
+      if (dynamicSegments.length && this.isAIEmployeeContextInfoPathAllowed(info, dynamicSegments.slice(1))) {
+        return true;
+      }
+    }
+    return this.canResolveAIEmployeeContextPath(path, validation.semantic);
+  }
+  extractAIEmployeePromptContextPath(expression) {
+    const normalized = String(expression || "").trim();
+    if (normalized === "ctx") {
+      return "";
+    }
+    if (!normalized.startsWith("ctx.")) {
+      return null;
+    }
+    const path = normalized.slice(4).trim();
+    return (0, import_context.isBareFlowContextPath)(path) ? path : null;
+  }
+  buildAIEmployeePromptVariableHint(targetUid) {
+    return `Call flowSurfaces:context${targetUid ? ` with target.uid "${targetUid}"` : ""} to inspect available ctx paths before writing prompt variables.`;
+  }
+  throwAIEmployeePromptVariableInvalid(input) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${input.actionName} ${input.fieldPath} variable "${input.variable}" is not allowed: ${input.reason}. Use a concrete ctx path such as "{{ ctx.record.id }}" only when that path is available. ${this.buildAIEmployeePromptVariableHint(
+        input.targetUid
+      )}`,
+      AI_EMPLOYEE_PROMPT_VARIABLE_INVALID,
+      {
+        path: input.fieldPath,
+        details: (0, import_service_utils.buildDefinedPayload)({
+          variable: input.variable,
+          contextPath: input.path,
+          targetUid: input.targetUid
+        })
+      }
+    );
+  }
+  assertAIEmployeePromptVariablesAllowed(actionName, fieldPath, value, validation) {
+    for (const variable of this.collectAIEmployeePromptVariables(value)) {
+      const path = this.extractAIEmployeePromptContextPath(variable.inner);
+      if (path === "") {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          reason: "the whole ctx object is not a valid prompt variable; use a concrete ctx path"
+        });
+      }
+      if (!path) {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          reason: 'only simple ctx dot paths like "{{ ctx.record.id }}" are supported'
+        });
+      }
+      if (!this.isAIEmployeeContextPathAllowed(path, validation)) {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          path,
+          reason: `path "${path}" is not available in the current Flow Surface context`
+        });
+      }
+    }
+  }
+  assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation, path = "settings.tasks") {
+    if (!validation) {
+      return;
+    }
+    tasks.forEach((task, index) => {
+      const message = task == null ? void 0 : task.message;
+      if (typeof (message == null ? void 0 : message.system) === "string") {
+        this.assertAIEmployeePromptVariablesAllowed(
+          actionName,
+          `${path}[${index}].message.system`,
+          message.system,
+          validation
+        );
+      }
+      if (typeof (message == null ? void 0 : message.user) === "string") {
+        this.assertAIEmployeePromptVariablesAllowed(
+          actionName,
+          `${path}[${index}].message.user`,
+          message.user,
+          validation
+        );
+      }
+    });
+  }
+  appendAIEmployeeCurrentRecordPromptVariable(value) {
+    if (AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE_RE.test(value)) {
+      return value;
+    }
+    return value ? `${value}
+${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE;
+  }
+  async resolveAIEmployeePromptActionTargetUid(context, transaction) {
+    if (!context) {
+      return void 0;
+    }
+    if (context.kind === "target") {
+      return String(context.targetUid || "").trim() || void 0;
+    }
+    return String(context.ownerUid || "").trim() || void 0;
+  }
+  async buildAIEmployeePromptValidationContext(actionName, tasks, options) {
+    var _a, _b;
+    if (!this.hasAIEmployeePromptVariables(tasks)) {
+      return void 0;
+    }
+    const targetUid = await this.resolveAIEmployeePromptActionTargetUid(options.promptContext, options.transaction);
+    if (!targetUid) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} AI employee prompt variables require a resolvable Flow Surface context. ${this.buildAIEmployeePromptVariableHint()}`,
+        AI_EMPLOYEE_PROMPT_VARIABLE_INVALID
+      );
+    }
+    const target = { uid: targetUid };
+    const resolved = await this.locator.resolve(target, { transaction: options.transaction });
+    let semantic = await this.resolveContextSemantic(((_a = resolved == null ? void 0 : resolved.node) == null ? void 0 : _a.uid) || target.uid, resolved, options.transaction);
+    if (((_b = options.promptContext) == null ? void 0 : _b.kind) === "container" && options.promptContext.scope === "record") {
+      semantic = {
+        ...semantic,
+        recordCollection: semantic.recordCollection || semantic.collection || await this.resolveContextOwnerCollection(targetUid, options.transaction).catch(() => null)
+      };
+    }
+    const context = (0, import_context.buildFlowSurfaceContextResponse)({
+      semantic,
+      maxDepth: AI_EMPLOYEE_PROMPT_CONTEXT_MAX_DEPTH
+    });
+    return {
+      targetUid,
+      semantic,
+      contextPaths: this.collectAIEmployeeContextPathEntries(context)
+    };
+  }
+  appendAIEmployeeCurrentRecordPromptVariableToTasks(tasks, validation) {
+    if (!tasks.length || !validation || !this.isAIEmployeeContextPathAllowed("record", validation)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      var _a;
+      if (typeof ((_a = task == null ? void 0 : task.message) == null ? void 0 : _a.user) !== "string") {
+        return task;
+      }
+      const next = import_lodash.default.cloneDeep(task);
+      next.message.user = this.appendAIEmployeeCurrentRecordPromptVariable(next.message.user);
+      return next;
+    });
+  }
+  async assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings(current, nextPayload, writeTarget, options) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
+      return;
+    }
+    const tasks = import_lodash.default.get(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!Array.isArray(tasks)) {
+      return;
+    }
+    const actionName = options.openViewActionName || "updateSettings";
+    this.assertAIEmployeeTaskPromptVariablesAllowed(
+      actionName,
+      tasks,
+      await this.buildAIEmployeePromptValidationContext(actionName, tasks, {
+        transaction: options.transaction,
+        promptContext: {
+          kind: "target",
+          targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
+        }
+      }),
+      "stepParams.shortcutSettings.editTasks.tasks"
+    );
+  }
+  async normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
+      return;
+    }
+    const tasks = import_lodash.default.get(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!Array.isArray(tasks)) {
+      return;
+    }
+    const actionName = options.openViewActionName || "updateSettings";
+    const normalizedTasks = this.normalizeAIEmployeeTasks(
+      actionName,
+      tasks,
+      this.readAIEmployeePersistedTasks(current),
+      {
+        selfUid: await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction),
+        path: "stepParams.shortcutSettings.editTasks.tasks"
+      }
+    );
+    import_lodash.default.set(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH], normalizedTasks);
+  }
   normalizeAIEmployeeTaskMessage(actionName, path, value, existing, options) {
     if (!import_lodash.default.isPlainObject(value)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} must be an object`);
@@ -16616,9 +18132,18 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${options.path} must be an object`);
     }
     const next = import_lodash.default.pick(import_lodash.default.isPlainObject(existing) ? import_lodash.default.cloneDeep(existing) : {}, AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS);
+    if (Object.prototype.hasOwnProperty.call(patch, "prompt") && import_lodash.default.isPlainObject(patch.message) && Object.prototype.hasOwnProperty.call(patch.message, "user")) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${options.path} cannot set both prompt and message.user; prompt is an alias for message.user. repairHint: keep only one of ${options.path}.prompt or ${options.path}.message.user`
+      );
+    }
     Object.entries(patch).forEach(([key, value]) => {
-      if (!AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS.includes(key)) {
-        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${options.path} does not support key '${key}'`);
+      if (!AI_EMPLOYEE_TASK_PATCH_PUBLIC_SETTING_KEYS.includes(key)) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} ${options.path} does not support key '${key}'; allowed keys: ${AI_EMPLOYEE_TASK_PATCH_PUBLIC_SETTING_KEYS.join(
+            ", "
+          )}; repairHint: ${AI_EMPLOYEE_TASK_REPAIR_HINT}`
+        );
       }
       if (key === "message") {
         next.message = this.normalizeAIEmployeeTaskMessage(actionName, `${options.path}.message`, value, next.message, {
@@ -16627,6 +18152,18 @@ class FlowSurfacesService {
         });
         return;
       }
+      if (key === "prompt") {
+        if (typeof value !== "string") {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces ${actionName} ${options.path}.prompt must be a string; repairHint: ${AI_EMPLOYEE_TASK_REPAIR_HINT}`
+          );
+        }
+        next.message = {
+          ...import_lodash.default.isPlainObject(next.message) ? import_lodash.default.cloneDeep(next.message) : {},
+          user: value
+        };
+        return;
+      }
       if (key === "title") {
         if (typeof value !== "string") {
           (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${options.path}.title must be a string`);
@@ -16661,6 +18198,14 @@ class FlowSurfacesService {
     if (!import_lodash.default.isPlainObject(next.message)) {
       next.message = {};
     }
+    if (import_lodash.default.isPlainObject(next.skillSettings)) {
+      if (Array.isArray(next.skillSettings.skills) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "skillsVersion")) {
+        next.skillSettings.skillsVersion = 2;
+      }
+      if (Array.isArray(next.skillSettings.tools) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "toolsVersion")) {
+        next.skillSettings.toolsVersion = 2;
+      }
+    }
     return next;
   }
   normalizeAIEmployeeTasks(actionName, value, currentTasks, options) {
@@ -16723,6 +18268,7 @@ class FlowSurfacesService {
       });
     }
     const props = {};
+    const stepParams = {};
     if (effectiveUsername && (hasUsername || options.requireUsername)) {
       props.aiEmployee = {
         ...import_lodash.default.isPlainObject(currentProps.aiEmployee) ? import_lodash.default.cloneDeep(currentProps.aiEmployee) : {},
@@ -16748,11 +18294,36 @@ class FlowSurfacesService {
       };
     }
     if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
-      props.tasks = this.normalizeAIEmployeeTasks(actionName, settings.tasks, currentProps.tasks, {
-        selfUid: options.selfUid,
-        keyMap: options.keyMap,
-        path: "settings.tasks"
+      const normalizedTasks = this.normalizeAIEmployeeTasks(
+        actionName,
+        settings.tasks,
+        this.readAIEmployeePersistedTasks(options.current),
+        {
+          selfUid: options.selfUid,
+          keyMap: options.keyMap,
+          path: "settings.tasks"
+        }
+      );
+      const validation = options.promptContext && normalizedTasks.length ? await this.buildAIEmployeePromptValidationContext(
+        actionName,
+        [
+          {
+            message: {
+              user: AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE
+            }
+          }
+        ],
+        {
+          transaction: options.transaction,
+          promptContext: options.promptContext
+        }
+      ) : await this.buildAIEmployeePromptValidationContext(actionName, normalizedTasks, {
+        transaction: options.transaction,
+        promptContext: options.promptContext
       });
+      const tasks = this.appendAIEmployeeCurrentRecordPromptVariableToTasks(normalizedTasks, validation);
+      this.assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation);
+      import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
     }
     if (Object.prototype.hasOwnProperty.call(settings, "style") || options.requireUsername) {
       const style = Object.prototype.hasOwnProperty.call(settings, "style") ? settings.style : {};
@@ -16780,7 +18351,10 @@ class FlowSurfacesService {
         import_lodash.default.isPlainObject(style) ? import_lodash.default.pick(import_lodash.default.cloneDeep(style), AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
       );
     }
-    return props;
+    return {
+      props,
+      stepParams
+    };
   }
   async resolveAIEmployeeActionSelfUid(actionNode, transaction) {
     const parentUid = String((actionNode == null ? void 0 : actionNode.parentId) || "").trim() || ((actionNode == null ? void 0 : actionNode.uid) ? await this.locator.findParentUid(actionNode.uid, transaction).catch(() => "") : "");
@@ -16804,27 +18378,39 @@ class FlowSurfacesService {
     }) : null);
     changes = await this.normalizeActionPanelActionChanges(changes, options);
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)(use);
+    if ((0, import_service_utils.hasOwnDefined)(changes, "openView") && !allowedKeys.includes("openView") && JS_POPUP_GUIDANCE_USES.has(use)) {
+      (0, import_errors.throwBadRequest)(withJsPopupGuidance(`flowSurfaces configure action '${use}' does not support openView`, use));
+    }
     (0, import_service_utils.assertSupportedSimpleChanges)("action", changes, allowedKeys);
     if (this.isAIEmployeeActionUse(use)) {
-      const props2 = await this.normalizeAIEmployeeActionPublicSettings("configure action", changes, {
-        transaction: options.transaction,
-        enabledPackages: options.enabledPackages || await this.resolveEnabledPluginPackages(options),
-        current: currentNode,
-        currentRoles: options.currentRoles,
-        selfUid: await this.resolveAIEmployeeActionSelfUid(currentNode, options.transaction)
-      });
-      return this.updateSettings(
-        {
-          target,
-          props: props2
-        },
+      const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
+        "configure action",
+        changes,
         {
-          ...options,
-          openViewActionName: options.openViewActionName || "configure action",
-          popupTemplateHostUid: target.uid,
-          allowAIEmployeeInternalProps: true
+          transaction: options.transaction,
+          enabledPackages: options.enabledPackages || await this.resolveEnabledPluginPackages(options),
+          current: currentNode,
+          currentRoles: options.currentRoles,
+          selfUid: await this.resolveAIEmployeeActionSelfUid(currentNode, options.transaction),
+          promptContext: {
+            kind: "target",
+            targetUid: (currentNode == null ? void 0 : currentNode.uid) || target.uid
+          }
         }
       );
+      const settingsValues = { target };
+      if (Object.keys(aiEmployeeSettingsPayload.props).length) {
+        settingsValues.props = aiEmployeeSettingsPayload.props;
+      }
+      if (Object.keys(aiEmployeeSettingsPayload.stepParams).length) {
+        settingsValues.stepParams = aiEmployeeSettingsPayload.stepParams;
+      }
+      return this.updateSettings(settingsValues, {
+        ...options,
+        openViewActionName: options.openViewActionName || "configure action",
+        popupTemplateHostUid: target.uid,
+        allowAIEmployeeInternalProps: true
+      });
     }
     const normalizedDefaultFilter = (0, import_service_utils.hasOwnDefined)(changes, "defaultFilter") ? this.normalizeFilterActionDefaultFilterValue(changes.defaultFilter) : void 0;
     const stepParams = {};
@@ -16888,7 +18474,7 @@ class FlowSurfacesService {
           openView: import_lodash.default.cloneDeep(changes.openView)
         };
       } else if (!POPUP_ACTION_USES.has(use)) {
-        (0, import_errors.throwBadRequest)(`flowSurfaces configure action '${use}' does not support openView`);
+        (0, import_errors.throwBadRequest)(withJsPopupGuidance(`flowSurfaces configure action '${use}' does not support openView`, use));
       } else {
         let openView = import_lodash.default.cloneDeep(changes.openView);
         if (use === "AddChildActionModel") {
@@ -18117,7 +19703,8 @@ class FlowSurfacesService {
   }
   resolveRecordActionContextOwner(ancestors) {
     const currentNode = ancestors[0];
-    if (!String((currentNode == null ? void 0 : currentNode.use) || "").endsWith("ActionModel")) {
+    const currentUse = String((currentNode == null ? void 0 : currentNode.use) || "").trim();
+    if (!currentUse.endsWith("ActionModel") && !import_node_use_sets.ACTION_BUTTON_USES.has(currentUse)) {
       return null;
     }
     return ancestors.slice(1).find((node) => (0, import_action_scope.getActionContainerScope)(node == null ? void 0 : node.use) === "record") || null;
@@ -18368,11 +19955,12 @@ class FlowSurfacesService {
     };
   }
   getCollection(dataSourceKey, collectionName) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const normalizedDataSourceKey = dataSourceKey || "main";
-    const dataSourceManager = this.plugin.app.dataSourceManager;
-    const dataSource = (_a = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _a.call(dataSourceManager, normalizedDataSourceKey);
-    return ((_c = (_b = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _b.getCollection) == null ? void 0 : _c.call(_b, collectionName)) || ((_e = (_d = this.plugin.app.db) == null ? void 0 : _d.getCollection) == null ? void 0 : _e.call(_d, collectionName));
+    const app = (_a = this.plugin) == null ? void 0 : _a.app;
+    const dataSourceManager = app == null ? void 0 : app.dataSourceManager;
+    const dataSource = (_b = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _b.call(dataSourceManager, normalizedDataSourceKey);
+    return ((_d = (_c = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _c.getCollection) == null ? void 0 : _d.call(_c, collectionName)) || ((_f = (_e = app == null ? void 0 : app.db) == null ? void 0 : _e.getCollection) == null ? void 0 : _f.call(_e, collectionName)) || ((_h = (_g = this.db) == null ? void 0 : _g.getCollection) == null ? void 0 : _h.call(_g, collectionName));
   }
   normalizeKanbanFieldNameInput(value, context, options = {}) {
     if (import_lodash.default.isUndefined(value)) {
@@ -20443,7 +22031,7 @@ class FlowSurfacesService {
         (value) => !import_lodash.default.isUndefined(value)
       ),
       decoratorProps: import_lodash.default.cloneDeep(innerField.decoratorProps || {}),
-      flowRegistry: import_lodash.default.cloneDeep(innerField.flowRegistry || {}),
+      flowRegistry: this.getEventFlowRegistry(innerField),
       stepParams: import_lodash.default.merge({}, innerField.stepParams || {}, {
         fieldBinding: {
           use: normalizedTargetUse