@nocobase/plugin-flow-engine 2.2.0-beta.1 → 2.2.0-beta.11

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

@@ -51,6 +51,7 @@ var import_association_title_field = require("./association-title-field");
 var import_chart_config = require("./chart-config");
 var import_public_data_surface_default_filter = require("./public-data-surface-default-filter");
 var import_default_action_popup = require("./default-action-popup");
+var import_relation_backing_foreign_key = require("./relation-backing-foreign-key");
 var import_default_block_actions = require("./default-block-actions");
 var import_hidden_popup_contract = require("./hidden-popup-contract");
 var import_node_use_sets = require("./node-use-sets");
@@ -60,7 +61,23 @@ var import_association_interfaces = require("./association-interfaces");
 var import_defaults = require("./blueprint/defaults");
 var import_runjs_authoring = require("./runjs-authoring");
 var import_configure_options = require("./configure-options");
+var import_context = require("./context");
 var import_filter_group = require("./filter-group");
+const FLOW_SURFACE_DATA_SCOPE_DATE_EMPTY_OPERATORS = /* @__PURE__ */ new Set(["$empty", "$notEmpty"]);
+const FLOW_SURFACE_DATA_SCOPE_DATE_ALLOWED_OPERATORS = /* @__PURE__ */ new Set([
+  ...import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS,
+  ...FLOW_SURFACE_DATA_SCOPE_DATE_EMPTY_OPERATORS
+]);
+const FLOW_SURFACE_DATA_SCOPE_DATE_UI_INCOMPATIBLE_OPERATORS = /* @__PURE__ */ new Set([
+  "$eq",
+  "$ne",
+  "$lt",
+  "$lte",
+  "$gt",
+  "$gte",
+  "$in",
+  "$notIn"
+]);
 const MAIN_BLOCK_UNSUPPORTED_SECTIONS = {
   calendar: ["fields", "fieldGroups", "recordActions", "fieldsLayout"],
   kanban: ["fieldGroups", "recordActions", "fieldsLayout"],
@@ -171,10 +188,17 @@ const GRID_CARD_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([
 const TABLE_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([...(0, import_configure_options.getConfigureOptionKeysForUse)("TableBlockModel"), "sort"]);
 const TABLE_INTERNAL_AUTHORING_KEYS = ["tableSettings", "defaultSorting", "stepParams"];
 const TABLE_SETTINGS_REPAIR_HINT = "Use public table settings keys such as settings.pageSize, settings.sorting, settings.dataScope, settings.density, settings.showRowNumbers, settings.treeTable, settings.dragSort, and settings.dragSortBy. Do not nest persisted tableSettings/defaultSorting/stepParams payloads.";
-const JS_BLOCK_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["title", "description", "className", "code", "version"]);
+const JS_BLOCK_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "className",
+  "showBlockCard",
+  "code",
+  "version"
+]);
 const JS_BLOCK_TOP_LEVEL_JS_KEYS = ["code", "version"];
 const JS_BLOCK_INTERNAL_AUTHORING_KEYS = ["props", "decoratorProps", "flowRegistry", "stepParams"];
-const JS_BLOCK_REPAIR_HINT = "This is a jsBlock payload shape problem. Repair this jsBlock using inline settings.code/settings.version, or applyBlueprint assets.scripts.<key>.code plus block.script. Do not change this block type to table, chart, actionPanel, gridCard, or another block type.";
+const JS_BLOCK_REPAIR_HINT = "This is a jsBlock payload shape problem. Repair this jsBlock using inline settings.code/settings.version/settings.showBlockCard, or applyBlueprint assets.scripts.<key>.code plus block.script with optional settings.showBlockCard. Do not change this block type to table, chart, actionPanel, gridCard, or another block type.";
 const CHART_REPAIR_HINT = "This is a chart payload shape problem. Keep using chart and repair this chart using assets.charts.<key>.query/visual plus block.chart, or localized settings.query/settings.visual. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type, and do not drop or defer the chart. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
 const REPAIR_ALL_ERRORS_AGENT_INSTRUCTION = "If this response contains errors[], fix every listed error in one payload revision before retrying the same write. Do not fix only this error and immediately retry.";
 const JS_BLOCK_AGENT_INSTRUCTION = `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Do not skip, drop, defer, or replace this required jsBlock. Repair it as jsBlock.`;
@@ -472,7 +496,10 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
     blocks.forEach(({ block }) => collectLocalKeys(block, localKeys));
   }
   blocks.forEach(({ block, path }) => collectBlockErrors(block, path, errors, localKeys, validationContext));
-  collectReactionErrors(values == null ? void 0 : values.reaction, "$.reaction", localKeys, errors);
+  collectReactionErrors(values == null ? void 0 : values.reaction, "$.reaction", localKeys, errors, {
+    values,
+    context: validationContext
+  });
   if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
     collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
   }
@@ -513,10 +540,13 @@ function pushChartBadRequestAuthoringError(errors, error, fallbackPath) {
   });
 }
 async function collectNavigationGroupErrors(actionName, values, context, errors) {
-  var _a;
+  var _a, _b;
   if (actionName !== "applyBlueprint" || (values == null ? void 0 : values.mode) !== "create" || !_.isPlainObject((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.group)) {
     return;
   }
+  if (await isApplyBlueprintMobileCreateNavigation(values, context)) {
+    return;
+  }
   if (!_.isUndefined(values.navigation.group.routeId) || !context.findMenuGroupRoutesByTitle) {
     return;
   }
@@ -524,7 +554,8 @@ async function collectNavigationGroupErrors(actionName, values, context, errors)
   if (!groupTitle) {
     return;
   }
-  const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction);
+  const layoutUid = String(((_b = values == null ? void 0 : values.navigation) == null ? void 0 : _b.layoutUid) || "").trim() || void 0;
+  const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction, layoutUid);
   const rootMatchedRoutes = filterRootMenuGroupRoutes(matchedRoutes);
   if (rootMatchedRoutes.length <= 1) {
     return;
@@ -541,15 +572,17 @@ async function collectNavigationGroupErrors(actionName, values, context, errors)
   });
 }
 async function collectNavigationIconErrors(actionName, values, context, errors) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (actionName !== "applyBlueprint" || (values == null ? void 0 : values.mode) !== "create") {
     return;
   }
+  const isMobileCreateNavigation = await isApplyBlueprintMobileCreateNavigation(values, context);
   const group = _.isPlainObject((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.group) ? values.navigation.group : null;
   const groupRouteId = String((group == null ? void 0 : group.routeId) || "").trim();
-  if (group && !groupRouteId && group.hideInMenu !== true) {
+  const layoutUid = String(((_b = values == null ? void 0 : values.navigation) == null ? void 0 : _b.layoutUid) || "").trim() || void 0;
+  if (!isMobileCreateNavigation && group && !groupRouteId && group.hideInMenu !== true) {
     const groupIcon = String(group.icon || "").trim();
-    if (!groupIcon && await shouldRequireNewNavigationGroupIcon(group, context)) {
+    if (!groupIcon && await shouldRequireNewNavigationGroupIcon(group, context, layoutUid)) {
       pushAuthoringError(errors, {
         path: "$.navigation.group.icon",
         ruleId: "navigation-icon-required",
@@ -568,7 +601,7 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
         }
       });
     }
-  } else if (group && String(group.icon || "").trim() && !isValidAntDesignIconName(group.icon)) {
+  } else if (!isMobileCreateNavigation && group && String(group.icon || "").trim() && !isValidAntDesignIconName(group.icon)) {
     pushAuthoringError(errors, {
       path: "$.navigation.group.icon",
       ruleId: "navigation-icon-unknown",
@@ -578,7 +611,7 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
       }
     });
   }
-  const item = _.isPlainObject((_b = values == null ? void 0 : values.navigation) == null ? void 0 : _b.item) ? values.navigation.item : null;
+  const item = _.isPlainObject((_c = values == null ? void 0 : values.navigation) == null ? void 0 : _c.item) ? values.navigation.item : null;
   const itemIcon = String((item == null ? void 0 : item.icon) || "").trim();
   if (itemIcon && !isValidAntDesignIconName(itemIcon)) {
     pushAuthoringError(errors, {
@@ -590,7 +623,7 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
       }
     });
   }
-  const pageIcon = String(((_c = values == null ? void 0 : values.page) == null ? void 0 : _c.icon) || "").trim();
+  const pageIcon = String(((_d = values == null ? void 0 : values.page) == null ? void 0 : _d.icon) || "").trim();
   if (pageIcon && !isValidAntDesignIconName(pageIcon)) {
     pushAuthoringError(errors, {
       path: "$.page.icon",
@@ -602,12 +635,20 @@ async function collectNavigationIconErrors(actionName, values, context, errors)
     });
   }
 }
-async function shouldRequireNewNavigationGroupIcon(group, context) {
+async function isApplyBlueprintMobileCreateNavigation(values, context) {
+  var _a;
+  const layoutUid = String(((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.layoutUid) || "").trim();
+  if (!layoutUid || !context.getUiLayoutTypeByUid) {
+    return false;
+  }
+  return await context.getUiLayoutTypeByUid(layoutUid, context.transaction) === "mobile";
+}
+async function shouldRequireNewNavigationGroupIcon(group, context, layoutUid) {
   const groupTitle = String((group == null ? void 0 : group.title) || "").trim();
   if (!groupTitle || !context.findMenuGroupRoutesByTitle) {
     return true;
   }
-  const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction);
+  const matchedRoutes = await context.findMenuGroupRoutesByTitle(groupTitle, context.transaction, layoutUid);
   return filterRootMenuGroupRoutes(matchedRoutes).length === 0;
 }
 function filterRootMenuGroupRoutes(routes) {
@@ -732,6 +773,7 @@ function withJsBlockRepairHint(details = {}) {
       inlineBlock: {
         type: "jsBlock",
         settings: {
+          showBlockCard: true,
           code: 'ctx.render("Replace this with the required rendered UI");'
         }
       },
@@ -745,7 +787,10 @@ function withJsBlockRepairHint(details = {}) {
         },
         block: {
           type: "jsBlock",
-          script: "scriptKey"
+          script: "scriptKey",
+          settings: {
+            showBlockCard: true
+          }
         }
       }
     },
@@ -1177,47 +1222,69 @@ function collectBuilderChartAssetQueryErrors(query, path, context, errors) {
     errors,
     withChartRepairHint()
   );
-  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors);
+  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors, context);
   collectBuilderChartAssetFieldErrors(query, path, context, errors);
 }
-function collectChartQueryFilterOperatorErrors(query, path, errors) {
+const AUTHORABLE_REACTION_SCALAR_CONTEXT_PATHS = /* @__PURE__ */ new Set(["role", "locale", "token", "deviceType"]);
+const AUTHORABLE_REACTION_CONTEXT_ROOTS = /* @__PURE__ */ new Set([
+  "user",
+  "collection",
+  "formValues",
+  "record",
+  "item",
+  "popup",
+  "urlSearchParams"
+]);
+function collectChartQueryFilterOperatorErrors(query, path, errors, context) {
   if (!_.isPlainObject(query) || !hasOwn(query, "filter")) {
     return;
   }
-  collectChartFilterOperatorErrors(query.filter, `${path}.filter`, errors);
+  collectChartFilterOperatorErrors(
+    query.filter,
+    `${path}.filter`,
+    errors,
+    createChartQueryDateConditionFieldResolver(query, context)
+  );
 }
-function collectChartFilterOperatorErrors(filter, path, errors) {
+function collectChartFilterOperatorErrors(filter, path, errors, resolveField) {
   if (_.isUndefined(filter) || _.isNull(filter) || !_.isPlainObject(filter)) {
     return;
   }
   if (Array.isArray(filter.items)) {
-    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors);
+    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors, resolveField);
     return;
   }
-  collectBackendQueryFilterOperatorErrors(filter, path, errors);
+  collectBackendQueryFilterOperatorErrors(filter, path, errors, resolveField);
 }
-function collectChartFilterGroupOperatorErrors(items, path, errors) {
+function collectChartFilterGroupOperatorErrors(items, path, errors, resolveField) {
   items.forEach((item, index) => {
     const itemPath = `${path}[${index}]`;
     if (!_.isPlainObject(item)) {
       return;
     }
     if (Array.isArray(item.items)) {
-      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors);
+      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors, resolveField);
       return;
     }
     if (hasOwn(item, "operator")) {
       collectChartFilterOperatorError(item.operator, `${itemPath}.operator`, errors);
-      collectChartFilterDateValueError(item.operator, item.value, `${itemPath}.value`, errors);
+      const fieldPath = String(item.path || item.field || "").trim();
+      collectChartFilterDateValueError(
+        item.operator,
+        item.value,
+        `${itemPath}.value`,
+        errors,
+        fieldPath ? (resolveField == null ? void 0 : resolveField(fieldPath)) || { fieldPath } : void 0
+      );
     }
   });
 }
-function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
+function collectBackendQueryFilterOperatorErrors(filter, path, errors, resolveField) {
   Object.entries(filter).forEach(([field, condition]) => {
     const fieldPath = `${path}.${field}`;
     if ((field === "$and" || field === "$or") && Array.isArray(condition)) {
       condition.forEach(
-        (operand, index) => collectChartFilterOperatorErrors(operand, `${fieldPath}[${index}]`, errors)
+        (operand, index) => collectChartFilterOperatorErrors(operand, `${fieldPath}[${index}]`, errors, resolveField)
       );
       return;
     }
@@ -1226,11 +1293,17 @@ function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
     }
     Object.keys(condition).forEach((operator) => {
       if (operator === "$and" || operator === "$or") {
-        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors);
+        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors, resolveField);
         return;
       }
       collectChartFilterOperatorError(operator, `${fieldPath}.${operator}`, errors);
-      collectChartFilterDateValueError(operator, condition[operator], `${fieldPath}.${operator}`, errors);
+      collectChartFilterDateValueError(
+        operator,
+        condition[operator],
+        `${fieldPath}.${operator}`,
+        errors,
+        (resolveField == null ? void 0 : resolveField(field)) || { fieldPath: field }
+      );
     });
   });
 }
@@ -1245,9 +1318,18 @@ function collectChartFilterOperatorError(operator, path, errors) {
     throw error;
   }
 }
-function collectChartFilterDateValueError(operator, value, path, errors) {
+function collectChartFilterDateValueError(operator, value, path, errors, fieldContext) {
+  const fieldMeta = getDateConditionFieldContextMeta(fieldContext);
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+    return;
+  }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, value, path, {
+      fieldPath: fieldContext == null ? void 0 : fieldContext.fieldPath,
+      fieldType: fieldMeta.type,
+      fieldInterface: fieldMeta.interface
+    });
   } catch (error) {
     if (error instanceof import_errors.FlowSurfaceBadRequestError) {
       pushChartBadRequestAuthoringError(errors, error, path);
@@ -1256,6 +1338,38 @@ function collectChartFilterDateValueError(operator, value, path, errors) {
     throw error;
   }
 }
+function createChartQueryDateConditionFieldResolver(query, context) {
+  const resource = _.isPlainObject(query == null ? void 0 : query.resource) ? query.resource : null;
+  const collectionName = String((resource == null ? void 0 : resource.collectionName) || "").trim();
+  if (!collectionName || typeof (context == null ? void 0 : context.getCollection) !== "function") {
+    return null;
+  }
+  const dataSourceKey = String((resource == null ? void 0 : resource.dataSourceKey) || "main").trim() || "main";
+  const collection = context.getCollection(dataSourceKey, collectionName);
+  if (!collection) {
+    return null;
+  }
+  return (fieldPath) => {
+    const normalizedFieldPath = (0, import_service_helpers.normalizeFieldPath)(fieldPath);
+    const resolved = resolveDefaultFilterFieldPath(collection, normalizedFieldPath, dataSourceKey, context);
+    return {
+      fieldPath,
+      field: resolved.field
+    };
+  };
+}
+function getDateConditionFieldMeta(field) {
+  return {
+    type: (0, import_service_helpers.getFieldType)(field),
+    interface: (0, import_service_helpers.getFieldInterface)(field)
+  };
+}
+function getDateConditionFieldContextMeta(fieldContext) {
+  return {
+    ...getDateConditionFieldMeta(fieldContext == null ? void 0 : fieldContext.field),
+    ...(fieldContext == null ? void 0 : fieldContext.fieldMeta) || {}
+  };
+}
 function normalizeChartAssetFieldPath(input) {
   if (Array.isArray(input)) {
     return input.map((item) => String(item || "").trim()).filter(Boolean).join(".");
@@ -3616,6 +3730,9 @@ function getGeneratedPopupBusinessFieldCandidates(collection) {
     if (!fieldName || !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
       return [];
     }
+    if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field)) {
+      return [];
+    }
     return [
       {
         field,
@@ -3730,11 +3847,15 @@ function getGeneratedPopupDefaultFormFieldPaths(candidates, fieldGroups) {
 }
 function getGeneratedPopupRuntimeFieldCandidates(input) {
   const candidateContext = DEFAULT_ACTION_POPUP_FIELD_CONTEXT_BY_TYPE[input.actionType];
+  const explicitDefaultFieldPaths = (0, import_default_action_popup.collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths)(input.fieldGroups);
   return (0, import_service_helpers.getCollectionFields)(input.collection).flatMap((field) => {
     const fieldName = (0, import_service_helpers.getFieldName)(field);
     if (!fieldName || !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
       return [];
     }
+    if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(input.collection, field) && !explicitDefaultFieldPaths.has(fieldName)) {
+      return [];
+    }
     const fieldInterface = (0, import_service_helpers.getFieldInterface)(field);
     const registeredBinding = (0, import_field_binding_registry.resolveRegisteredFieldBinding)({
       containerUse: candidateContext.ownerUse,
@@ -3958,9 +4079,16 @@ function collectBlockErrors(block, path, errors, localKeys, context) {
   collectChartDisplayTitleErrors(block, blockType, path, errors);
   collectTreeTableExplicitFieldsErrors(block, blockType, path, errors, context);
   collectTreeConnectFieldsErrors((_a = block.settings) == null ? void 0 : _a.connectFields, `${path}.settings.connectFields`, errors);
-  collectTableSettingsErrors(block, blockType, path, errors, {
-    deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
-  });
+  collectTableSettingsErrors(
+    block,
+    blockType,
+    path,
+    errors,
+    {
+      deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
+    },
+    context
+  );
   collectGridCardSettingsErrors(block, blockType, path, errors);
   const descendantContext = getBlockDescendantValidationContext(block, context);
   collectActionListErrors(block.actions, `${path}.actions`, errors, block, descendantContext, "actions");
@@ -3999,7 +4127,7 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
     pushAuthoringError(errors, {
       path: `${path}.${key}`,
       ruleId: `jsBlock-top-level-${key}-unsupported`,
-      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code and ${path}.settings.version for inline JS code`,
+      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code, ${path}.settings.version, and ${path}.settings.showBlockCard for public JS block settings`,
       details: withJsBlockRepairHint({ key })
     });
   });
@@ -4010,7 +4138,7 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
     pushAuthoringError(errors, {
       path: `${path}.${key}`,
       ruleId: key === "stepParams" ? "jsBlock-stepParams-unsupported" : "jsBlock-internal-field-unsupported",
-      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code and ${path}.settings.version instead of internal persisted fields`,
+      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock blocks; use ${path}.settings.code, ${path}.settings.version, and ${path}.settings.showBlockCard instead of internal persisted fields`,
       details: withJsBlockRepairHint({
         key
       })
@@ -4033,7 +4161,7 @@ function collectJsBlockPublicContractErrors(block, path, errors, context) {
       pushAuthoringError(errors, {
         path: `${path}.settings.${key}`,
         ruleId: "jsBlock-settings-unsupported-key",
-        message: `flowSurfaces authoring ${path}.settings.${key} is not part of the public jsBlock contract; use ${path}.settings.code and ${path}.settings.version for inline JS code`,
+        message: `flowSurfaces authoring ${path}.settings.${key} is not part of the public jsBlock contract; use ${path}.settings.code, ${path}.settings.version, and ${path}.settings.showBlockCard for public JS block settings`,
         details: withJsBlockRepairHint({
           key,
           allowedKeys: Array.from(JS_BLOCK_ALLOWED_SETTINGS_KEYS)
@@ -4075,7 +4203,7 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.${key}`,
       ruleId: key === "stepParams" ? "jsBlock-stepParams-unsupported" : "jsBlock-internal-field-unsupported",
-      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock configure changes; use ${path}.code and ${path}.version instead of internal persisted fields`,
+      message: `flowSurfaces authoring ${path}.${key} is not accepted on public jsBlock configure changes; use ${path}.code, ${path}.version, and ${path}.showBlockCard instead of internal persisted fields`,
       details: withJsBlockRepairHint({
         key
       })
@@ -4108,7 +4236,7 @@ function collectJsBlockConfigurePublicContractErrors(changes, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.settings`,
       ruleId: "jsBlock-settings-unsupported-key",
-      message: `flowSurfaces authoring ${path}.settings is not part of the public jsBlock configure contract; use ${path}.code and ${path}.version`,
+      message: `flowSurfaces authoring ${path}.settings is not part of the public jsBlock configure contract; use ${path}.code, ${path}.version, and ${path}.showBlockCard`,
       details: withJsBlockRepairHint()
     });
     return;
@@ -4268,11 +4396,12 @@ async function collectConfigureErrors(values, errors, context) {
   collectCommentsBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectRecordHistoryBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectChartDisplayTitleErrors(changes, hostBlockType, "$.changes", errors);
-  collectChartConfigureFilterOperatorErrors(changes, hostBlockType, "$.changes", errors);
-  collectTableSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
+  collectChartConfigureFilterOperatorErrors(changes, hostBlockType, "$.changes", errors, context);
+  collectTableSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true }, context);
   collectGridCardSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectAssignValuesErrors(changes.assignValues, "$.changes.assignValues", errors, changesBlock, context);
   collectTriggerWorkflowsErrors(changes.triggerWorkflows, "$.changes.triggerWorkflows", errors);
+  collectLinkageRulesErrors(changes.linkageRules, "$.changes.linkageRules", errors);
   collectFieldListInternalKeyErrors(changes.fields, "$.changes.fields", errors);
   const connectFieldsTargets = collectTreeConnectFieldsErrors(changes.connectFields, "$.changes.connectFields", errors);
   await collectTreeConnectFieldsLiveErrors(connectFieldsTargets, changes, "$.changes.connectFields", errors, context);
@@ -4357,10 +4486,20 @@ function collectUnsupportedDefaultFilterOperatorError(operator, path, errors) {
     }
   });
 }
-function collectDefaultFilterDateValueError(operator, value, path, errors) {
+function collectDefaultFilterDateValueError(operator, value, path, errors, fieldContext, options = {}) {
   var _a, _b, _c;
+  const fieldMeta = getDateConditionFieldContextMeta(fieldContext);
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+    return;
+  }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, value, path, {
+      fieldPath: fieldContext == null ? void 0 : fieldContext.fieldPath,
+      fieldType: fieldMeta.type,
+      fieldInterface: fieldMeta.interface,
+      allowContextPathValue: options.allowContextPathValue
+    });
   } catch (error) {
     if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
       throw error;
@@ -4374,6 +4513,82 @@ function collectDefaultFilterDateValueError(operator, value, path, errors) {
     });
   }
 }
+function collectPublicDataScopeDateOperatorError(operator, value, path, errors, fieldContext) {
+  const fieldMeta = getDateConditionFieldContextMeta(fieldContext);
+  if (!(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+    return;
+  }
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (FLOW_SURFACE_DATA_SCOPE_DATE_ALLOWED_OPERATORS.has(normalizedOperator)) {
+    return;
+  }
+  const isComparisonOperator = FLOW_SURFACE_DATA_SCOPE_DATE_UI_INCOMPATIBLE_OPERATORS.has(normalizedOperator);
+  const suggestedOperator = isComparisonOperator ? getSuggestedPublicDataScopeDateOperator(normalizedOperator) : void 0;
+  const suggestedValue = getSuggestedPublicDataScopeDateValue(value);
+  pushAuthoringError(errors, {
+    path,
+    ruleId: "dataScope-date-operator-ui-incompatible",
+    message: `flowSurfaces authoring ${path} cannot use operator '${normalizedOperator}' for a date/datetime DataScope condition`,
+    details: {
+      fieldPath: fieldContext == null ? void 0 : fieldContext.fieldPath,
+      fieldType: fieldMeta.type,
+      fieldInterface: fieldMeta.interface,
+      invalidOperator: normalizedOperator,
+      invalidValue: value,
+      allowedOperators: Array.from(FLOW_SURFACE_DATA_SCOPE_DATE_ALLOWED_OPERATORS),
+      ...suggestedOperator ? { suggestedOperator } : {},
+      ...typeof suggestedValue !== "undefined" ? { suggestedValue } : {},
+      repairHint: 'For public settings.dataScope date/datetime fields, use UI date operators such as $dateOn with UI date values like "2026-07-05"; do not move fixed data-range conditions to defaultFilter.',
+      repairExample: {
+        logic: "$and",
+        items: [
+          {
+            path: (fieldContext == null ? void 0 : fieldContext.fieldPath) || "createdAt",
+            operator: suggestedOperator || "$dateOn",
+            value: typeof suggestedValue !== "undefined" ? suggestedValue : "2026-07-05"
+          }
+        ]
+      },
+      agentInstruction: "Replace date/datetime DataScope comparison operators with $dateOn/$dateNotOn/$dateBefore/$dateAfter/$dateNotBefore/$dateNotAfter/$dateBetween and UI date values. Keep the condition in dataScope when it is a fixed data range."
+    }
+  });
+}
+function getSuggestedPublicDataScopeDateOperator(operator) {
+  switch (operator) {
+    case "$eq":
+      return "$dateOn";
+    case "$ne":
+      return "$dateNotOn";
+    case "$lt":
+      return "$dateBefore";
+    case "$lte":
+      return "$dateNotAfter";
+    case "$gt":
+      return "$dateAfter";
+    case "$gte":
+      return "$dateNotBefore";
+    default:
+      return void 0;
+  }
+}
+function getSuggestedPublicDataScopeDateValue(value) {
+  if (typeof value === "string") {
+    const match = /^(\d{4}-\d{2}-\d{2})/.exec(value.trim());
+    if (match) {
+      return match[1];
+    }
+  }
+  if (Array.isArray(value)) {
+    const suggested = value.map((item) => {
+      var _a;
+      return typeof item === "string" ? (_a = /^(\d{4}-\d{2}-\d{2})/.exec(item.trim())) == null ? void 0 : _a[1] : void 0;
+    }).filter(Boolean);
+    if (suggested.length === value.length && suggested.length > 0) {
+      return suggested;
+    }
+  }
+  return void 0;
+}
 function collectTopLevelLayoutErrors(actionName, values, errors) {
   if (actionName !== "applyBlueprint") {
     return;
@@ -5423,13 +5638,13 @@ function collectChartDisplayTitleErrors(block, blockType, blockPath, errors) {
     message: "Chart block settings do not support displayTitle in the current flowSurfaces runtime; keep settings.title and omit displayTitle."
   });
 }
-function collectChartConfigureFilterOperatorErrors(changes, hostBlockType, path, errors) {
+function collectChartConfigureFilterOperatorErrors(changes, hostBlockType, path, errors, context) {
   if (hostBlockType !== "chart" || !_.isPlainObject(changes)) {
     return;
   }
-  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors);
+  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors, context);
   if (_.isPlainObject(changes.configure)) {
-    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors);
+    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors, context);
   }
 }
 function visitFilterItems(value, path, errors, block, context = {}) {
@@ -5446,7 +5661,13 @@ function visitFilterItems(value, path, errors, block, context = {}) {
   }
   if (typeof value.operator === "string") {
     collectUnsupportedDefaultFilterOperatorError(value.operator, `${path}.operator`, errors);
-    collectDefaultFilterDateValueError(value.operator, value.value, `${path}.value`, errors);
+    collectDefaultFilterDateValueError(
+      value.operator,
+      value.value,
+      `${path}.value`,
+      errors,
+      fieldRef ? resolveDefaultFilterDateConditionField(fieldRef.value, block, context) : void 0
+    );
   }
   const filterItems = value.items;
   if (Array.isArray(filterItems)) {
@@ -5472,11 +5693,33 @@ function visitFilterItems(value, path, errors, block, context = {}) {
     if (_.isPlainObject(child)) {
       Object.entries(child).forEach(([operator, operatorValue]) => {
         collectUnsupportedDefaultFilterOperatorError(operator, `${path}.${key}.${operator}`, errors);
-        collectDefaultFilterDateValueError(operator, operatorValue, `${path}.${key}.${operator}`, errors);
+        collectDefaultFilterDateValueError(
+          operator,
+          operatorValue,
+          `${path}.${key}.${operator}`,
+          errors,
+          resolveDefaultFilterDateConditionField(key, block, context)
+        );
       });
     }
   });
 }
+function resolveDefaultFilterDateConditionField(rawFieldPath, block, context) {
+  const fieldPath = String(rawFieldPath || "").trim();
+  if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+    return null;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return null;
+  }
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  const resolved = resolveDefaultFilterFieldPath(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath), dataSourceKey, context);
+  return {
+    fieldPath,
+    field: resolved.field
+  };
+}
 function collectTreeConnectFieldsErrors(value, path, errors) {
   if (_.isUndefined(value)) {
     return [];
@@ -5825,7 +6068,7 @@ function getCollectionFilterTargetKey(collection) {
 function normalizeDataSourceKey(value) {
   return String(value || "main").trim() || "main";
 }
-function collectTableSettingsErrors(block, blockType, blockPath, errors, options = {}) {
+function collectTableSettingsErrors(block, blockType, blockPath, errors, options = {}, context = {}) {
   if (blockType !== "table" || !_.isPlainObject(block)) {
     return;
   }
@@ -5836,6 +6079,9 @@ function collectTableSettingsErrors(block, blockType, blockPath, errors, options
   });
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings) {
+    if (options.directSettings === true && !shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
+      collectPublicDataScopeErrors(block.dataScope, `${blockPath}.dataScope`, errors, block, context);
+    }
     return;
   }
   const settings = block.settings;
@@ -5850,7 +6096,7 @@ function collectTableSettingsErrors(block, blockType, blockPath, errors, options
     pushTableSettingsUnsupportedError(errors, `${settingsPath}.${key}`, key);
   });
   if (!shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
-    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors);
+    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors, block, context);
   }
 }
 function pushTableSettingsUnsupportedError(errors, path, key) {
@@ -5865,7 +6111,7 @@ function pushTableSettingsUnsupportedError(errors, path, key) {
     }
   });
 }
-function collectPublicDataScopeErrors(value, path, errors) {
+function collectPublicDataScopeErrors(value, path, errors, block, context) {
   if (_.isUndefined(value)) {
     return;
   }
@@ -5885,6 +6131,62 @@ function collectPublicDataScopeErrors(value, path, errors) {
         repairHint: 'Use settings.dataScope with logic/items, for example {"logic":"$and","items":[{"path":"status","operator":"$eq","value":"Active"}]}; do not use a field-name map.'
       }
     });
+    return;
+  }
+  collectPublicDataScopeFieldPathErrors(validationValue, path, errors, block, context);
+  collectFilterGroupDateConditionErrors(validationValue, path, errors, block, context);
+}
+function collectPublicDataScopeFieldPathErrors(value, path, errors, block, context) {
+  if (!_.isPlainObject(value)) {
+    return;
+  }
+  if (hasOwn(value, "operator")) {
+    collectPublicDataScopeFieldPathError(value.path, `${path}.path`, block, context, errors);
+  }
+  if (Array.isArray(value.items)) {
+    value.items.forEach(
+      (item, index) => collectPublicDataScopeFieldPathErrors(item, `${path}.items[${index}]`, errors, block, context)
+    );
+  }
+}
+function collectPublicDataScopeFieldPathError(rawFieldPath, path, block, context, errors) {
+  const fieldPath = String(rawFieldPath || "").trim();
+  if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+    return;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return;
+  }
+  const resolved = resolveDefaultFilterFieldPath(
+    collection,
+    (0, import_service_helpers.normalizeFieldPath)(fieldPath),
+    getBlockDataSourceKey(block, context),
+    context
+  );
+  if (!resolved.field) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "field-path-unknown",
+      message: `flowSurfaces authoring ${path} references unknown field '${fieldPath}'`,
+      details: {
+        fieldPath,
+        collection: (0, import_service_helpers.getCollectionName)(resolved.collection || collection),
+        availableFields: (0, import_service_helpers.getCollectionFields)(resolved.collection || collection).map((field) => String((0, import_service_helpers.getFieldName)(field) || "").trim()).filter(Boolean)
+      }
+    });
+    return;
+  }
+  if ((0, import_service_helpers.isAssociationField)(resolved.field)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "defaultFilter-relation-field-unsupported",
+      message: `flowSurfaces authoring ${path} cannot use relation field '${fieldPath}' itself; use a scalar subfield instead`,
+      details: {
+        fieldPath,
+        fieldName: (0, import_service_helpers.getFieldName)(resolved.field)
+      }
+    });
   }
 }
 function shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options) {
@@ -5906,6 +6208,24 @@ function normalizePublicDataScopeValueForValidation(value) {
   }
   return value;
 }
+function collectFilterGroupDateConditionErrors(value, path, errors, block, context) {
+  if (!_.isPlainObject(value)) {
+    return;
+  }
+  if (Array.isArray(value.items)) {
+    value.items.forEach(
+      (item, index) => collectFilterGroupDateConditionErrors(item, `${path}.items[${index}]`, errors, block, context)
+    );
+    return;
+  }
+  if (!hasOwn(value, "operator")) {
+    return;
+  }
+  const fieldPath = String(value.path || value.field || "").trim();
+  const fieldContext = fieldPath ? resolveDefaultFilterDateConditionField(fieldPath, block, context) : void 0;
+  collectPublicDataScopeDateOperatorError(value.operator, value.value, `${path}.operator`, errors, fieldContext);
+  collectDefaultFilterDateValueError(value.operator, value.value, `${path}.value`, errors, fieldContext);
+}
 function collectGridCardSettingsErrors(block, blockType, blockPath, errors, options = {}) {
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings && options.directSettings !== true) {
@@ -6033,11 +6353,12 @@ function buildAuthoringAIEmployeeActionIdentity(settings) {
   return stableSerializeAuthoringValue(normalizeAuthoringAIEmployeePublicSettingsForIdentity(settings));
 }
 function normalizeAuthoringAIEmployeePublicSettingsForIdentity(settings) {
+  const workContext = Object.prototype.hasOwnProperty.call(settings, "workContext") ? normalizeAuthoringAIEmployeeWorkContextForIdentity(settings.workContext) : [{ type: "flow-model", target: "self" }];
   return {
     username: String(settings.username || "").trim(),
     auto: typeof settings.auto === "boolean" ? settings.auto : false,
-    workContext: Object.prototype.hasOwnProperty.call(settings, "workContext") ? normalizeAuthoringAIEmployeeWorkContextForIdentity(settings.workContext) : [{ type: "flow-model", target: "self" }],
-    tasks: normalizeAuthoringAIEmployeeTasksForIdentity(settings.tasks),
+    workContext,
+    tasks: normalizeAuthoringAIEmployeeTasksForIdentity(settings.tasks, workContext),
     style: {
       ...AUTHORING_AI_EMPLOYEE_DEFAULT_STYLE,
       ..._.isPlainObject(settings.style) ? _.pick(settings.style, AUTHORING_AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
@@ -6056,7 +6377,14 @@ function normalizeAuthoringAIEmployeeWorkContextForIdentity(value) {
     return output;
   });
 }
-function normalizeAuthoringAIEmployeeTasksForIdentity(value) {
+function normalizeAuthoringAIEmployeeTaskWorkContextForIdentity(value, defaultWorkContext) {
+  const normalized = normalizeAuthoringAIEmployeeWorkContextForIdentity(value);
+  if (Array.isArray(defaultWorkContext) && !normalized.length) {
+    return _.cloneDeep(defaultWorkContext);
+  }
+  return normalized;
+}
+function normalizeAuthoringAIEmployeeTasksForIdentity(value, defaultWorkContext) {
   return _.castArray(value || []).map((task) => {
     if (!_.isPlainObject(task)) {
       return task;
@@ -6064,10 +6392,11 @@ function normalizeAuthoringAIEmployeeTasksForIdentity(value) {
     const output = _.pick(task, AUTHORING_AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS);
     if (_.isPlainObject(output.message)) {
       output.message = _.pick(output.message, AUTHORING_AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS);
-      if (_.isPlainObject(output.message.workContext)) {
-        output.message.workContext = normalizeAuthoringAIEmployeeWorkContextForIdentity(output.message.workContext);
-      } else if (Array.isArray(output.message.workContext)) {
-        output.message.workContext = normalizeAuthoringAIEmployeeWorkContextForIdentity(output.message.workContext);
+      if (Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
+        output.message.workContext = normalizeAuthoringAIEmployeeTaskWorkContextForIdentity(
+          output.message.workContext,
+          defaultWorkContext
+        );
       }
     }
     if (Object.prototype.hasOwnProperty.call(task, "prompt") && !Object.prototype.hasOwnProperty.call(output.message || {}, "user")) {
@@ -6076,6 +6405,13 @@ function normalizeAuthoringAIEmployeeTasksForIdentity(value) {
         user: task.prompt
       };
     }
+    if (!_.isPlainObject(output.message) && Array.isArray(defaultWorkContext)) {
+      output.message = {
+        workContext: _.cloneDeep(defaultWorkContext)
+      };
+    } else if (_.isPlainObject(output.message) && !Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
+      output.message.workContext = _.cloneDeep(defaultWorkContext || []);
+    }
     if (_.isPlainObject(output.model)) {
       output.model = _.pick(output.model, AUTHORING_AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS);
     }
@@ -6154,7 +6490,7 @@ function collectActionSlotErrors(actionType, path, errors, block, slot = "action
   }
 }
 function collectActionErrors(action, path, errors, block, context = {}, slot = "actions") {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   const actionType = resolveAuthoringActionType(action, block);
   collectActionSlotErrors(actionType, path, errors, block, slot);
   if (!_.isPlainObject(action)) {
@@ -6163,6 +6499,7 @@ function collectActionErrors(action, path, errors, block, context = {}, slot = "
   collectApplyBlueprintScriptAssetReferenceErrors(action, path, errors, context);
   collectAssignValuesErrors((_a = action.settings) == null ? void 0 : _a.assignValues, `${path}.settings.assignValues`, errors, block, context);
   collectTriggerWorkflowsErrors((_b = action.settings) == null ? void 0 : _b.triggerWorkflows, `${path}.settings.triggerWorkflows`, errors);
+  collectLinkageRulesErrors((_c = action.settings) == null ? void 0 : _c.linkageRules, `${path}.settings.linkageRules`, errors);
   if (hasOwn(action, "assignValues")) {
     pushAuthoringError(errors, {
       path: `${path}.assignValues`,
@@ -6198,7 +6535,7 @@ function collectActionErrors(action, path, errors, block, context = {}, slot = "
         }
       });
     }
-    const hasRunnableSource = typeof action.source === "string" && action.source.trim() || typeof action.code === "string" && action.code.trim() || hasApplyBlueprintRunnableScriptAssetReference(action.script, context) || typeof ((_c = action.settings) == null ? void 0 : _c.source) === "string" && action.settings.source.trim() || typeof ((_d = action.settings) == null ? void 0 : _d.code) === "string" && action.settings.code.trim();
+    const hasRunnableSource = typeof action.source === "string" && action.source.trim() || typeof action.code === "string" && action.code.trim() || hasApplyBlueprintRunnableScriptAssetReference(action.script, context) || typeof ((_d = action.settings) == null ? void 0 : _d.source) === "string" && action.settings.source.trim() || typeof ((_e = action.settings) == null ? void 0 : _e.code) === "string" && action.settings.code.trim();
     if (!hasRunnableSource) {
       pushAuthoringError(errors, {
         path,
@@ -6463,6 +6800,59 @@ function collectTriggerWorkflowsErrors(value, path, errors) {
     }
   });
 }
+function collectLinkageRulesErrors(value, path, errors) {
+  if (_.isUndefined(value)) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "linkageRules-invalid-shape",
+      message: `flowSurfaces authoring ${path} must be an array`
+    });
+    return;
+  }
+  value.forEach((rule, index) => {
+    const rulePath = `${path}[${index}]`;
+    if (!_.isPlainObject(rule)) {
+      pushAuthoringError(errors, {
+        path: rulePath,
+        ruleId: "linkageRules-rule-invalid-shape",
+        message: `flowSurfaces authoring ${rulePath} must be an object`
+      });
+      return;
+    }
+    const conditionPath = hasOwn(rule, "condition") ? `${rulePath}.condition` : hasOwn(rule, "when") ? `${rulePath}.when` : `${rulePath}.condition`;
+    const conditionValue = hasOwn(rule, "condition") ? rule.condition : hasOwn(rule, "when") ? rule.when : import_filter_group.FLOW_SURFACE_EMPTY_FILTER_GROUP;
+    try {
+      (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
+        conditionValue,
+        `flowSurfaces authoring ${conditionPath} expects FilterGroup or backend query filter like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        { strictDateValues: true }
+      );
+    } catch (error) {
+      pushAuthoringError(errors, {
+        path: conditionPath,
+        ruleId: "linkageRules-condition-invalid-shape",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (hasOwn(rule, "actions") && !Array.isArray(rule.actions)) {
+      pushAuthoringError(errors, {
+        path: `${rulePath}.actions`,
+        ruleId: "linkageRules-actions-invalid-shape",
+        message: `flowSurfaces authoring ${rulePath}.actions must be an array`
+      });
+    }
+    if (hasOwn(rule, "then") && !Array.isArray(rule.then)) {
+      pushAuthoringError(errors, {
+        path: `${rulePath}.then`,
+        ruleId: "linkageRules-actions-invalid-shape",
+        message: `flowSurfaces authoring ${rulePath}.then must be an array`
+      });
+    }
+  });
+}
 function collectPopupErrors(popup, path, errors, localKeys, context = {}) {
   if (!_.isPlainObject(popup)) {
     return;
@@ -6516,7 +6906,7 @@ function collectNestedBlockErrors(blocks, path, errors, localKeys, context) {
   }
   blocks.forEach((block, index) => collectBlockErrors(block, `${path}[${index}]`, errors, localKeys, context));
 }
-function collectReactionErrors(reaction, path, localKeys, errors) {
+function collectReactionErrors(reaction, path, localKeys, errors, options = {}) {
   const items = Array.isArray(reaction == null ? void 0 : reaction.items) ? reaction.items : [];
   items.forEach((item, index) => {
     const rawTarget = (item == null ? void 0 : item.target) ?? (item == null ? void 0 : item.targetKey) ?? (item == null ? void 0 : item.targetBlock);
@@ -6534,8 +6924,198 @@ function collectReactionErrors(reaction, path, localKeys, errors) {
         message: `flowSurfaces authoring ${path}.items[${index}].target references unknown local target '${target}'`
       });
     }
+    collectReactionItemDateConditionErrors(item, `${path}.items[${index}]`, target, errors, options);
   });
 }
+function collectReactionItemDateConditionErrors(item, path, target, errors, options) {
+  if (!_.isPlainObject(item) || !_.isPlainObject(options.values) || !options.context) {
+    return;
+  }
+  const targetMatch = findApplyBlueprintReactionTargetBlock(options.values, target, options.context);
+  if (!targetMatch) {
+    return;
+  }
+  const type = String(item.type || "").trim();
+  const conditionFieldMetaByPath = buildApplyBlueprintReactionConditionFieldMetaByPath(
+    targetMatch.block,
+    targetMatch.context
+  );
+  _.castArray(item.rules || []).forEach((rule, ruleIndex) => {
+    collectReactionFilterDateConditionErrors(
+      (rule == null ? void 0 : rule.when) ?? (rule == null ? void 0 : rule.condition),
+      `${path}.rules[${ruleIndex}].when`,
+      errors,
+      targetMatch.block,
+      targetMatch.context,
+      conditionFieldMetaByPath
+    );
+    if (type !== "setFieldLinkageRules") {
+      return;
+    }
+    _.castArray((rule == null ? void 0 : rule.then) || (rule == null ? void 0 : rule.actions) || []).forEach((action, actionIndex) => {
+      _.castArray((action == null ? void 0 : action.items) || []).forEach((assignItem, itemIndex) => {
+        collectReactionFilterDateConditionErrors(
+          (assignItem == null ? void 0 : assignItem.when) ?? (assignItem == null ? void 0 : assignItem.condition),
+          `${path}.rules[${ruleIndex}].then[${actionIndex}].items[${itemIndex}].when`,
+          errors,
+          targetMatch.block,
+          targetMatch.context,
+          conditionFieldMetaByPath
+        );
+      });
+    });
+  });
+}
+function collectReactionFilterDateConditionErrors(filter, path, errors, block, context, fieldMetaByPath = {}) {
+  if (!_.isPlainObject(filter)) {
+    return;
+  }
+  if (Array.isArray(filter.items)) {
+    filter.items.forEach(
+      (item, index) => collectReactionFilterDateConditionErrors(
+        item,
+        `${path}.items[${index}]`,
+        errors,
+        block,
+        context,
+        fieldMetaByPath
+      )
+    );
+    return;
+  }
+  if (!hasOwn(filter, "operator")) {
+    return;
+  }
+  const conditionPath = normalizeReactionConditionPath(filter.path);
+  const fieldContext = resolveReactionConditionFieldContext(conditionPath, block, context, fieldMetaByPath);
+  collectDefaultFilterDateValueError(filter.operator, filter.value, `${path}.value`, errors, fieldContext, {
+    allowContextPathValue: true
+  });
+}
+function normalizeReactionConditionPath(rawPath) {
+  const value = String(rawPath || "").trim();
+  const templateMatch = /^\{\{\s*ctx(?:\.([^}]+?))?\s*\}\}$/.exec(value);
+  const path = templateMatch ? String(templateMatch[1] || "").trim() : value.replace(/^ctx\./, "");
+  return path.split(".").map((segment) => segment.trim()).filter(Boolean).join(".");
+}
+function buildApplyBlueprintReactionConditionFieldMetaByPath(block, context) {
+  var _a, _b;
+  const collection = getBlockCollection(block, context);
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  const userCollection = ((_a = context.getCollection) == null ? void 0 : _a.call(context, "main", "users")) || ((_b = context.getCollection) == null ? void 0 : _b.call(context, dataSourceKey, "users")) || null;
+  const response = (0, import_context.buildFlowSurfaceContextResponse)({
+    semantic: {
+      collection,
+      userCollection,
+      recordCollection: collection,
+      formValuesCollection: collection,
+      itemCollections: collection ? [collection] : [],
+      itemRootCollection: collection || void 0,
+      popupLevels: context.isPopupSurface || context.popupHasCurrentRecord ? [
+        {
+          recordCollection: collection,
+          sourceRecordCollection: collection
+        }
+      ] : []
+    },
+    maxDepth: 4
+  });
+  const fieldMetaByPath = collectAuthorableReactionContextFieldMetaByPath(response);
+  addCollectionFieldMetaAliases(fieldMetaByPath, collection, ["collection", "record", "formValues"]);
+  addCollectionFieldMetaAliases(fieldMetaByPath, collection, ["item"], {
+    preserveExisting: true,
+    reservedKeys: /* @__PURE__ */ new Set(["index", "length", "value", "parentItem"])
+  });
+  if (userCollection) {
+    addCollectionFieldMetaAliases(fieldMetaByPath, userCollection, ["user"]);
+  }
+  return fieldMetaByPath;
+}
+function collectAuthorableReactionContextFieldMetaByPath(context) {
+  const fieldMetaByPath = {};
+  const visit = (prefix, info) => {
+    if (!prefix || !info) {
+      return;
+    }
+    if (isAuthorableReactionContextPath(prefix)) {
+      fieldMetaByPath[prefix] = {
+        ...info.type ? { type: info.type } : {},
+        ...info.interface ? { interface: info.interface } : {}
+      };
+    }
+    if (info.dynamicProperties) {
+      visit(`${prefix}.*`, info.dynamicProperties);
+    }
+    Object.entries(info.properties || {}).forEach(([key, child]) => visit(`${prefix}.${key}`, child));
+  };
+  Object.entries((context == null ? void 0 : context.vars) || {}).forEach(([key, info]) => visit(key, info));
+  return fieldMetaByPath;
+}
+function isAuthorableReactionContextPath(path) {
+  const segments = String(path || "").split(".").filter(Boolean);
+  const root = segments[0];
+  if (!root) {
+    return false;
+  }
+  if (AUTHORABLE_REACTION_SCALAR_CONTEXT_PATHS.has(root)) {
+    return segments.length === 1;
+  }
+  return AUTHORABLE_REACTION_CONTEXT_ROOTS.has(root);
+}
+function addCollectionFieldMetaAliases(fieldMetaByPath, collection, roots, options = {}) {
+  var _a;
+  for (const field of (0, import_service_helpers.getCollectionFields)(collection)) {
+    const fieldName = (0, import_service_helpers.getFieldName)(field);
+    if (!fieldName) {
+      continue;
+    }
+    const fieldMeta = {
+      ...(0, import_service_helpers.getFieldType)(field) ? { type: (0, import_service_helpers.getFieldType)(field) } : {},
+      ...(0, import_service_helpers.getFieldInterface)(field) ? { interface: (0, import_service_helpers.getFieldInterface)(field) } : {}
+    };
+    for (const root of roots) {
+      if ((_a = options.reservedKeys) == null ? void 0 : _a.has(fieldName)) {
+        continue;
+      }
+      const aliasPath = `${root}.${fieldName}`;
+      if (options.preserveExisting && fieldMetaByPath[aliasPath]) {
+        continue;
+      }
+      fieldMetaByPath[aliasPath] = {
+        ...fieldMetaByPath[aliasPath],
+        ...fieldMeta
+      };
+    }
+  }
+}
+function resolveReactionConditionFieldContext(path, block, context, fieldMetaByPath) {
+  const normalized = String(path || "").trim();
+  const contextMeta = resolveReactionConditionFieldMeta(normalized, fieldMetaByPath);
+  if (contextMeta) {
+    return {
+      fieldPath: normalized,
+      fieldMeta: contextMeta
+    };
+  }
+  const fieldPath = resolveReactionConditionFieldPath(normalized);
+  return fieldPath ? resolveDefaultFilterDateConditionField(fieldPath, block, context) || void 0 : void 0;
+}
+function resolveReactionConditionFieldMeta(path, fieldMetaByPath) {
+  if (fieldMetaByPath[path]) {
+    return fieldMetaByPath[path];
+  }
+  const wildcardPath = Object.keys(fieldMetaByPath).filter((candidate) => candidate.endsWith(".*")).sort((a, b) => b.length - a.length).find((candidate) => {
+    const prefix = candidate.slice(0, -2);
+    return path.startsWith(`${prefix}.`) && path.length > prefix.length + 1;
+  });
+  return wildcardPath ? fieldMetaByPath[wildcardPath] : void 0;
+}
+function resolveReactionConditionFieldPath(path) {
+  const normalized = String(path || "").trim();
+  const prefixes = ["formValues.", "record.", "item.value.", "item.", "popup.record.", "collection.", "user."];
+  const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+  return prefix ? normalized.slice(prefix.length) : "";
+}
 function collectFieldListErrors(fields, path, errors, localKeys, context, block) {
   if (!Array.isArray(fields)) {
     return;