@nocobase/plugin-flow-engine 2.2.0-beta.2 → 2.2.0-beta.3

package/dist/server/flow-surfaces/planning/compiler.js

@@ -180,6 +180,8 @@ async function resolvePlanSelectorInContext(actionName, selector, context, deps,
     uid: resolved.uid,
     source: "system",
     kind: deps.buildPlanKeyKind(node, resolved.kind),
+    node: node || resolved.node,
+    resolved,
     locator: (0, import_service_utils.buildDefinedPayload)({
       uid: normalizedSelector.locator.uid,
       pageSchemaUid: normalizedSelector.locator.pageSchemaUid,
@@ -217,51 +219,146 @@ function buildSelectorRuntimeValue(selector) {
   }
   return selector.uid;
 }
+function getResolvedSelectorUid(selector) {
+  if (!selector || "summary" in selector) {
+    return void 0;
+  }
+  return selector.uid;
+}
+function isReplaceComposeStep(step) {
+  var _a;
+  return step.action === "compose" && String(((_a = step.values) == null ? void 0 : _a.mode) || "").trim() === "replace";
+}
+function assertReplaceComposeTargetSupportsScopeResolution(actionName, index, step, target) {
+  if (!isReplaceComposeStep(step) || !target || !("summary" in target) || target.summary.source !== "step") {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(
+    `flowSurfaces ${actionName} plan.steps[${index}] compose replace does not support selectors.target.step; use a concrete locator or key for the existing replace target`
+  );
+}
+function collectDescendantUids(node, carry = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object") {
+    return carry;
+  }
+  for (const value of Object.values(node.subModels || {})) {
+    for (const child of import_lodash.default.castArray(value)) {
+      if (child == null ? void 0 : child.uid) {
+        carry.add(child.uid);
+      }
+      collectDescendantUids(child, carry);
+    }
+  }
+  return carry;
+}
+function collectNodeAndDescendantUids(node, carry = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object") {
+    return carry;
+  }
+  if (node.uid) {
+    carry.add(node.uid);
+  }
+  return collectDescendantUids(node, carry);
+}
+function findNodeInTreeByUid(node, uid) {
+  if (!node || typeof node !== "object" || !uid) {
+    return void 0;
+  }
+  if (node.uid === uid) {
+    return node;
+  }
+  for (const value of Object.values(node.subModels || {})) {
+    for (const child of import_lodash.default.castArray(value)) {
+      const matched = findNodeInTreeByUid(child, uid);
+      if (matched) {
+        return matched;
+      }
+    }
+  }
+  return void 0;
+}
+function getContextNodeByUid(context, uid) {
+  if (!uid) {
+    return void 0;
+  }
+  return findNodeInTreeByUid(context.publicTree, uid) || findNodeInTreeByUid(context.rawTree, uid);
+}
+function getSingleSubModel(node, key) {
+  var _a;
+  const value = (_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a[key];
+  return Array.isArray(value) ? value[0] : value;
+}
+function getSubModelList(node, key) {
+  var _a;
+  return import_lodash.default.castArray(((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a[key]) || []).filter((item) => item && typeof item === "object");
+}
+function isGridNode(node) {
+  return typeof (node == null ? void 0 : node.use) === "string" && node.use.endsWith("GridModel");
+}
+function resolveReplaceComposeGridNode(targetNode) {
+  if (!targetNode || typeof targetNode !== "object") {
+    return void 0;
+  }
+  if (isGridNode(targetNode)) {
+    return targetNode;
+  }
+  const directGrid = getSingleSubModel(targetNode, "grid");
+  if (directGrid) {
+    return directGrid;
+  }
+  const firstTab = getSubModelList(targetNode, "tabs")[0];
+  const firstTabGrid = getSingleSubModel(firstTab, "grid");
+  if (firstTabGrid) {
+    return firstTabGrid;
+  }
+  const popupPage = getSingleSubModel(targetNode, "page");
+  const firstPopupTab = getSubModelList(popupPage, "tabs")[0];
+  return getSingleSubModel(firstPopupTab, "grid");
+}
+async function collectReplaceScopeExistingKeys(step, context, target, deps, options = {}) {
+  if (!isReplaceComposeStep(step)) {
+    return /* @__PURE__ */ new Set();
+  }
+  let targetNode = getContextNodeByUid(context, getResolvedSelectorUid(target)) || (!target || "summary" in target ? void 0 : target.node);
+  if (!targetNode && target && !("summary" in target) && target.resolved && deps.loadResolvedSurfaceTree) {
+    targetNode = await deps.loadResolvedSurfaceTree(target.resolved, options.transaction);
+  }
+  if (!targetNode) {
+    return /* @__PURE__ */ new Set();
+  }
+  const gridNode = resolveReplaceComposeGridNode(targetNode);
+  if (!gridNode) {
+    return /* @__PURE__ */ new Set();
+  }
+  const replacedUids = /* @__PURE__ */ new Set();
+  for (const item of getSubModelList(gridNode, "items")) {
+    collectNodeAndDescendantUids(item, replacedUids);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  context.keyMap.forEach((info, key) => {
+    if (replacedUids.has(info.uid)) {
+      keys.add(key);
+    }
+  });
+  return keys;
+}
+function buildExistingKeysForConflict(context, priorCreatedKeys, allowedExistingKeys) {
+  const existing = /* @__PURE__ */ new Set();
+  context.keyMap.forEach((_info, key) => {
+    if (!allowedExistingKeys.has(key)) {
+      existing.add(key);
+    }
+  });
+  priorCreatedKeys.forEach((key) => existing.add(key));
+  return existing;
+}
 async function compilePlanStep(actionName, step, index, context, deps, priorStepIds, priorCreatedKeys, options = {}) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a, _b, _c, _d, _e, _f, _g;
   const runtimeValues = step.action === "compose" ? (0, import_created_keys.normalizeComposeInlineKeysForPlan)(step.values || {}, `plan.steps[${index}].values`) : import_lodash.default.cloneDeep(step.values || {});
-  const payload = (0, import_step_link.replaceFlowSurfacePlanStepLinks)(
-    actionName,
-    runtimeValues,
-    `plan.steps[${index}].values`,
-    priorStepIds,
-    /* @__PURE__ */ new Set([...context.keyMap.keys(), ...priorCreatedKeys])
-  );
   const targetSelectorKey = (0, import_created_keys.isFlowSurfacePureKeyObject)((_a = step.selectors) == null ? void 0 : _a.target) ? String(step.selectors.target.key || "").trim() : void 0;
   const createdKeys = (0, import_created_keys.collectFlowSurfaceCreatedKeys)(step.action, step.values || {}, {
     targetSelectorKey
   });
-  (0, import_created_keys.assertNoDuplicateFlowSurfaceCreatedKeys)(createdKeys, `flowSurfaces ${actionName} plan.steps[${index}]`, {
-    existingKeys: [...context.keyMap.keys(), ...priorCreatedKeys],
-    reservedNames: [...priorStepIds, ...step.id ? [step.id] : []]
-  });
-  const compiled = {
-    index,
-    ...step.id ? { id: step.id } : {},
-    action: step.action,
-    payload,
-    resolvedSelectors: {},
-    usedKeys: [],
-    usedStepLinks: [],
-    createdKeys
-  };
-  const addUsedKey = (selector) => {
-    if ("summary" in selector) {
-      if (isFlowSurfaceResolvedStepLink(selector)) {
-        compiled.usedStepLinks.push(selector);
-      }
-      return selector.summary;
-    }
-    if (selector.source === "request" || selector.source === "declared") {
-      compiled.usedKeys.push(selector);
-    }
-    return {
-      uid: selector.uid,
-      kind: selector.kind,
-      ...selector.key ? { key: selector.key } : {},
-      source: selector.source
-    };
-  };
   const spec = (0, import_action_specs.getFlowSurfacePlanActionSpec)(step.action);
   if (!spec) {
     (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].action '${step.action}' is not supported`);
@@ -283,14 +380,14 @@ async function compilePlanStep(actionName, step, index, context, deps, priorStep
       `flowSurfaces ${actionName} plan.steps[${index}] action '${step.action}' does not support selectors.source`
     );
   }
-  if (spec.selectorMode === "none") {
-    compiled.payload = payload;
-  } else if (spec.selectorMode === "target") {
+  let resolvedTarget;
+  let resolvedSource;
+  if (selectorRequirements.requiresTarget) {
     const targetSelector = (_f = step.selectors) == null ? void 0 : _f.target;
     if (!targetSelector) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.target`);
     }
-    const target = await resolvePlanSelectorInContext(
+    resolvedTarget = await resolvePlanSelectorInContext(
       actionName,
       targetSelector,
       context,
@@ -300,59 +397,85 @@ async function compilePlanStep(actionName, step, index, context, deps, priorStep
       priorCreatedKeys,
       options
     );
-    compiled.payload = {
-      ...payload,
-      target: {
-        uid: buildSelectorRuntimeValue(target)
-      }
-    };
-    compiled.resolvedSelectors.target = addUsedKey(target);
-  } else if (spec.selectorMode === "rootUidTarget") {
-    const targetSelector = (_g = step.selectors) == null ? void 0 : _g.target;
-    if (!targetSelector) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.target`);
+  }
+  if (selectorRequirements.requiresSource) {
+    const sourceSelector = (_g = step.selectors) == null ? void 0 : _g.source;
+    if (!sourceSelector) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.source`);
     }
-    const target = await resolvePlanSelectorInContext(
+    resolvedSource = await resolvePlanSelectorInContext(
       actionName,
-      targetSelector,
+      sourceSelector,
       context,
       deps,
-      `plan.steps[${index}].selectors.target`,
+      `plan.steps[${index}].selectors.source`,
       priorStepIds,
       priorCreatedKeys,
       options
     );
+  }
+  assertReplaceComposeTargetSupportsScopeResolution(actionName, index, step, resolvedTarget);
+  const allowedExistingKeys = await collectReplaceScopeExistingKeys(step, context, resolvedTarget, deps, options);
+  (0, import_created_keys.assertNoDuplicateFlowSurfaceCreatedKeys)(createdKeys, `flowSurfaces ${actionName} plan.steps[${index}]`, {
+    existingKeys: buildExistingKeysForConflict(context, priorCreatedKeys, allowedExistingKeys),
+    reservedNames: [...priorStepIds, ...step.id ? [step.id] : []]
+  });
+  const payload = (0, import_step_link.replaceFlowSurfacePlanStepLinks)(
+    actionName,
+    runtimeValues,
+    `plan.steps[${index}].values`,
+    priorStepIds,
+    /* @__PURE__ */ new Set([...context.keyMap.keys(), ...priorCreatedKeys]),
+    allowedExistingKeys
+  );
+  const compiled = {
+    index,
+    ...step.id ? { id: step.id } : {},
+    action: step.action,
+    payload,
+    resolvedSelectors: {},
+    usedKeys: [],
+    usedStepLinks: [],
+    createdKeys
+  };
+  const addUsedKey = (selector) => {
+    if ("summary" in selector) {
+      if (isFlowSurfaceResolvedStepLink(selector)) {
+        compiled.usedStepLinks.push(selector);
+      }
+      return selector.summary;
+    }
+    if (selector.source === "request" || selector.source === "declared") {
+      compiled.usedKeys.push(selector);
+    }
+    return {
+      uid: selector.uid,
+      kind: selector.kind,
+      ...selector.key ? { key: selector.key } : {},
+      source: selector.source
+    };
+  };
+  if (spec.selectorMode === "none") {
+    compiled.payload = payload;
+  } else if (spec.selectorMode === "target") {
+    const target = resolvedTarget;
+    compiled.payload = {
+      ...payload,
+      target: {
+        uid: buildSelectorRuntimeValue(target)
+      }
+    };
+    compiled.resolvedSelectors.target = addUsedKey(target);
+  } else if (spec.selectorMode === "rootUidTarget") {
+    const target = resolvedTarget;
     compiled.payload = {
       ...payload,
       uid: buildSelectorRuntimeValue(target)
     };
     compiled.resolvedSelectors.target = addUsedKey(target);
   } else if (spec.selectorMode === "sourceTarget") {
-    const sourceSelector = (_h = step.selectors) == null ? void 0 : _h.source;
-    const targetSelector = (_i = step.selectors) == null ? void 0 : _i.target;
-    if (!sourceSelector || !targetSelector) {
-      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.source and selectors.target`);
-    }
-    const source = await resolvePlanSelectorInContext(
-      actionName,
-      sourceSelector,
-      context,
-      deps,
-      `plan.steps[${index}].selectors.source`,
-      priorStepIds,
-      priorCreatedKeys,
-      options
-    );
-    const target = await resolvePlanSelectorInContext(
-      actionName,
-      targetSelector,
-      context,
-      deps,
-      `plan.steps[${index}].selectors.target`,
-      priorStepIds,
-      priorCreatedKeys,
-      options
-    );
+    const source = resolvedSource;
+    const target = resolvedTarget;
     compiled.payload = {
       ...payload,
       sourceUid: buildSelectorRuntimeValue(source),

package/dist/server/flow-surfaces/planning/runtime.js

@@ -152,6 +152,7 @@ async function compilePlanStep(actionName, step, index, context, deps, priorStep
     {
       normalizeGetTarget: deps.normalizeGetTarget,
       resolveLocator: deps.resolveLocator,
+      loadResolvedSurfaceTree: deps.loadResolvedSurfaceTree,
       buildPlanKeyKind: import_key_kind.buildPlanKeyKind
     },
     priorStepIds,

package/dist/server/flow-surfaces/planning/step-link.d.ts

@@ -11,4 +11,4 @@ import type { FlowSurfacePlanStepLink } from '../types';
 export declare const isFlowSurfacePlanStepLink: typeof isFlowSurfacePlanStepValue;
 export declare function normalizeFlowSurfacePlanStepLink(actionName: string, input: any, fieldName: string): FlowSurfacePlanStepLink;
 export declare function assertFlowSurfaceKnownPlanStepLink(actionName: string, stepLink: FlowSurfacePlanStepLink, fieldName: string, knownStepIds?: Set<string>): void;
-export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>): any;
+export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>, blockedRuntimeKeys?: Set<string>): any;

package/dist/server/flow-surfaces/planning/step-link.js

@@ -56,10 +56,17 @@ function assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, fieldName, kno
   }
   (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.step '${stepLink.step}' is not a previous step id`);
 }
-function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys) {
+function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys, blockedRuntimeKeys) {
   if (Array.isArray(input)) {
     return input.map(
-      (item, index) => replaceFlowSurfacePlanStepLinks(actionName, item, `${path}[${index}]`, knownStepIds, knownRuntimeKeys)
+      (item, index) => replaceFlowSurfacePlanStepLinks(
+        actionName,
+        item,
+        `${path}[${index}]`,
+        knownStepIds,
+        knownRuntimeKeys,
+        blockedRuntimeKeys
+      )
     );
   }
   if (!import_lodash.default.isPlainObject(input)) {
@@ -81,6 +88,11 @@ function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds,
     if (!runtimeKey) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key cannot be empty`);
     }
+    if (blockedRuntimeKeys == null ? void 0 : blockedRuntimeKeys.has(runtimeKey)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${path}.key '${runtimeKey}' belongs to the current replace scope; replace-step key links cannot resolve to old replace subtree nodes`
+      );
+    }
     if (!(knownRuntimeKeys == null ? void 0 : knownRuntimeKeys.has(runtimeKey))) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key '${runtimeKey}' is not defined`);
     }
@@ -91,7 +103,14 @@ function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds,
   return Object.fromEntries(
     Object.entries(input).map(([key, value]) => [
       key,
-      replaceFlowSurfacePlanStepLinks(actionName, value, `${path}.${key}`, knownStepIds, knownRuntimeKeys)
+      replaceFlowSurfacePlanStepLinks(
+        actionName,
+        value,
+        `${path}.${key}`,
+        knownStepIds,
+        knownRuntimeKeys,
+        blockedRuntimeKeys
+      )
     ])
   );
 }

package/dist/server/flow-surfaces/public-data-surface-default-filter.js

@@ -299,9 +299,7 @@ function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
   if (import_lodash.default.isUndefined(defaultFilter)) {
     return settings;
   }
-  const filterableFieldNames = resolveFlowSurfaceDefaultFilterFieldNames(defaultFilter);
   const defaults = {
-    ...filterableFieldNames.length ? { filterableFieldNames } : {},
     defaultFilter: import_lodash.default.cloneDeep(defaultFilter)
   };
   if (import_lodash.default.isUndefined(settings)) {
@@ -311,13 +309,6 @@ function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
     return settings;
   }
   if (Object.prototype.hasOwnProperty.call(settings, "defaultFilter")) {
-    const explicitFilterableFieldNames = resolveFlowSurfaceDefaultFilterFieldNames(settings.defaultFilter);
-    if (!Object.prototype.hasOwnProperty.call(settings, "filterableFieldNames") && explicitFilterableFieldNames.length) {
-      return {
-        ...import_lodash.default.cloneDeep(settings),
-        filterableFieldNames: explicitFilterableFieldNames
-      };
-    }
     return settings;
   }
   return {

package/dist/server/flow-surfaces/reaction/field-value.d.ts

@@ -17,6 +17,15 @@ export type FlowSurfaceFieldValueCompileResult = FlowSurfaceReactionWriteResult<
 export declare function isFieldValueTargetUseSupported(use?: string | null): boolean;
 export declare function assertFieldValueTargetSupported(target: FlowSurfaceFieldValueTarget): void;
 export declare function normalizeFieldValueRules(rules: FlowSurfaceFieldValueRule[] | undefined): FlowSurfaceFieldValueRule[];
+export declare function validateFieldValueRulesAgainstCapability(rules: FlowSurfaceFieldValueRule[], capability: {
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
+    };
+}): void;
 export declare function compileFieldValueRulesToCanonical(rules: FlowSurfaceFieldValueRule[] | undefined): {
     key: string;
     enable: boolean;

package/dist/server/flow-surfaces/reaction/field-value.js

@@ -41,11 +41,13 @@ __export(field_value_exports, {
   collectUpdateAssociationValuesFromFieldValueRules: () => collectUpdateAssociationValuesFromFieldValueRules,
   compileFieldValueRulesToCanonical: () => compileFieldValueRulesToCanonical,
   isFieldValueTargetUseSupported: () => isFieldValueTargetUseSupported,
-  normalizeFieldValueRules: () => normalizeFieldValueRules
+  normalizeFieldValueRules: () => normalizeFieldValueRules,
+  validateFieldValueRulesAgainstCapability: () => validateFieldValueRulesAgainstCapability
 });
 module.exports = __toCommonJS(field_value_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("../errors");
+var import_filter_group = require("../filter-group");
 var import_errors2 = require("./errors");
 var import_fingerprint = require("./fingerprint");
 var import_registry = require("./registry");
@@ -85,6 +87,52 @@ function normalizeFieldValueRules(rules) {
   const list = Array.isArray(rules) ? rules : [];
   return list.map((rule, index) => normalizeFieldValueRule(rule, index));
 }
+function validateFieldValueRulesAgainstCapability(rules, capability) {
+  for (const [ruleIndex, rule] of (rules || []).entries()) {
+    validateFieldValueDateConditionFilter(rule.when, capability, `rules[${ruleIndex}].when`);
+  }
+}
+function validateFieldValueDateConditionFilter(filter, capability, prefix) {
+  const visit = (node, currentPrefix) => {
+    var _a;
+    if (!import_lodash.default.isPlainObject(node)) {
+      return;
+    }
+    if (Array.isArray(node.items)) {
+      node.items.forEach((item, index) => visit(item, `${currentPrefix}.items[${index}]`));
+      return;
+    }
+    const operator = typeof node.operator === "string" ? node.operator.trim() : "";
+    const path = typeof node.path === "string" ? node.path.trim() : "";
+    if (!operator || !path || !Object.prototype.hasOwnProperty.call(node, "value")) {
+      return;
+    }
+    const fieldMeta = resolveFieldValueConditionFieldMeta(path, (_a = capability.conditionMeta) == null ? void 0 : _a.fieldMetaByPath);
+    if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+      return;
+    }
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, node.value, `${currentPrefix}.value`, {
+      fieldPath: path,
+      fieldType: fieldMeta == null ? void 0 : fieldMeta.type,
+      fieldInterface: fieldMeta == null ? void 0 : fieldMeta.interface,
+      allowContextPathValue: true
+    });
+  };
+  visit(filter, prefix);
+}
+function resolveFieldValueConditionFieldMeta(path, fieldMetaByPath) {
+  if (!fieldMetaByPath) {
+    return void 0;
+  }
+  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 compileFieldValueRulesToCanonical(rules) {
   return normalizeFieldValueRules(rules).map((rule) => ({
     key: rule.key,
@@ -177,5 +225,6 @@ function buildFieldValueWriteResult(params) {
   collectUpdateAssociationValuesFromFieldValueRules,
   compileFieldValueRulesToCanonical,
   isFieldValueTargetUseSupported,
-  normalizeFieldValueRules
+  normalizeFieldValueRules,
+  validateFieldValueRulesAgainstCapability
 });

package/dist/server/flow-surfaces/reaction/linkage.d.ts

@@ -6,7 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import type { FlowSurfaceActionLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldLinkageScene, FlowSurfaceFieldOption, FlowSurfaceFieldPathToUidResolver, FlowSurfaceFieldUidToPathResolver, FlowSurfaceBlockLinkageRule } from './types';
+import type { FlowSurfaceActionLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldLinkageScene, FlowSurfaceFieldOption, FlowSurfaceFieldPathToUidResolver, FlowSurfaceFieldUidToPathResolver, FlowSurfaceReactionFilter, FlowSurfaceBlockLinkageRule } from './types';
 type NormalizeFieldRuleOptions = {
     scene: FlowSurfaceFieldLinkageScene;
     resolveFieldPath?: FlowSurfaceFieldUidToPathResolver;
@@ -18,6 +18,10 @@ type CompileFieldRuleOptions = {
 type FlowSurfaceLinkageValidationCapability = {
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 };
 type FlowSurfaceFieldLinkageValidationCapability = FlowSurfaceLinkageValidationCapability & {
@@ -26,6 +30,7 @@ type FlowSurfaceFieldLinkageValidationCapability = FlowSurfaceLinkageValidationC
         supportedSources: Array<'literal' | 'path' | 'runjs'>;
     };
 };
+export declare function validateReactionFilterAgainstCapability(filter: FlowSurfaceReactionFilter | undefined, capability: FlowSurfaceLinkageValidationCapability, prefix: string): void;
 export declare function buildReactionFingerprint(value: any): string;
 export declare function normalizeBlockLinkageRules(rawRules: unknown): FlowSurfaceBlockLinkageRule[];
 export declare function normalizeActionLinkageRules(rawRules: unknown): FlowSurfaceActionLinkageRule[];

package/dist/server/flow-surfaces/reaction/linkage.js

@@ -48,7 +48,8 @@ __export(linkage_exports, {
   validateBlockLinkageRulesAgainstCapability: () => validateBlockLinkageRulesAgainstCapability,
   validateBlockLinkageSceneSupport: () => validateBlockLinkageSceneSupport,
   validateFieldLinkageRulesAgainstCapability: () => validateFieldLinkageRulesAgainstCapability,
-  validateFieldLinkageSceneSupport: () => validateFieldLinkageSceneSupport
+  validateFieldLinkageSceneSupport: () => validateFieldLinkageSceneSupport,
+  validateReactionFilterAgainstCapability: () => validateReactionFilterAgainstCapability
 });
 module.exports = __toCommonJS(linkage_exports);
 var import_node_crypto = require("node:crypto");
@@ -148,7 +149,10 @@ function normalizeReactionFilter(rawFilter) {
   }
   const normalizedFilter = (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
     rawFilter,
-    "flowSurfaces linkage rule condition"
+    "flowSurfaces linkage rule condition",
+    {
+      allowContextPathValue: true
+    }
   );
   const visit = (node) => {
     if (!import_lodash.default.isPlainObject(node)) {
@@ -639,6 +643,7 @@ function validateReactionFilterAgainstCapability(filter, capability, prefix) {
   var _a;
   const operatorsByPath = ((_a = capability.conditionMeta) == null ? void 0 : _a.operatorsByPath) || {};
   const visit = (node, currentPrefix) => {
+    var _a2, _b;
     if (!import_lodash.default.isPlainObject(node)) {
       return;
     }
@@ -683,6 +688,15 @@ function validateReactionFilterAgainstCapability(filter, capability, prefix) {
       );
     }
     if (hasValue) {
+      const fieldMeta = (_b = (_a2 = capability.conditionMeta) == null ? void 0 : _a2.fieldMetaByPath) == null ? void 0 : _b[operatorPath];
+      if (import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator) || (0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+        (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, node.value, `${currentPrefix}.value`, {
+          fieldPath: path,
+          fieldType: fieldMeta == null ? void 0 : fieldMeta.type,
+          fieldInterface: fieldMeta == null ? void 0 : fieldMeta.interface,
+          allowContextPathValue: true
+        });
+      }
       validateContextBoundValue(node.value, capability, `${currentPrefix}.value`);
     }
   };
@@ -895,5 +909,6 @@ function compileFieldLinkageCanonicalRules(rules, options) {
   validateBlockLinkageRulesAgainstCapability,
   validateBlockLinkageSceneSupport,
   validateFieldLinkageRulesAgainstCapability,
-  validateFieldLinkageSceneSupport
+  validateFieldLinkageSceneSupport,
+  validateReactionFilterAgainstCapability
 });

package/dist/server/flow-surfaces/reaction/meta.js

@@ -114,6 +114,19 @@ function buildConditionOperatorsByPath(context) {
   }
   return operatorsByPath;
 }
+function buildConditionFieldMetaByPath(context) {
+  const fieldMetaByPath = {};
+  for (const [path, info] of collectContextPathEntries(context)) {
+    if (!isAuthorableLinkageContextPath(path)) {
+      continue;
+    }
+    fieldMetaByPath[path] = {
+      ...(info == null ? void 0 : info.type) ? { type: info.type } : {},
+      ...(info == null ? void 0 : info.interface) ? { interface: info.interface } : {}
+    };
+  }
+  return fieldMetaByPath;
+}
 function isAuthorableLinkageContextPath(path) {
   const segments = String(path || "").split(".").filter(Boolean);
   const root = segments[0];
@@ -395,6 +408,10 @@ function buildFieldValueCapability(input, capability) {
     canonicalRules,
     context: input.context,
     targetFields: collectFieldOptions(input.resolvedTarget.node, input.context, capability.resolvedScene),
+    conditionMeta: {
+      operatorsByPath: buildConditionOperatorsByPath(input.context),
+      fieldMetaByPath: buildConditionFieldMetaByPath(input.context)
+    },
     valueExprMeta: {
       supportedSources: ["literal", "path", "runjs"],
       runjsScene: "fieldValue"
@@ -412,7 +429,8 @@ function buildLinkageCapability(input, capability) {
     context: input.context,
     supportedActions: buildSupportedActions(capability),
     conditionMeta: {
-      operatorsByPath: buildConditionOperatorsByPath(input.context)
+      operatorsByPath: buildConditionOperatorsByPath(input.context),
+      fieldMetaByPath: buildConditionFieldMetaByPath(input.context)
     }
   };
   if (capability.kind === "fieldLinkage") {