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

package/dist/server/flow-surfaces/constants.d.ts

@@ -45,6 +45,13 @@ export declare const FLOW_SURFACE_ACTION_DEFINITIONS: {
         readonly mutate: false;
         readonly valueSource: "default";
     };
+    readonly exportBlueprint: {
+        readonly method: "post";
+        readonly read: true;
+        readonly transaction: false;
+        readonly mutate: false;
+        readonly valueSource: "default";
+    };
     readonly getReactionMeta: {
         readonly method: "post";
         readonly read: true;
@@ -373,7 +380,7 @@ type SelectFlowSurfaceActionNames<TFlag extends keyof FlowSurfaceActionDefinitio
     [K in FlowSurfacesActionName]: (typeof FLOW_SURFACE_ACTION_DEFINITIONS)[K][TFlag] extends true ? K : never;
 }[FlowSurfacesActionName];
 type FlowSurfaceMutateActionName = SelectFlowSurfaceActionNames<'mutate'>;
-export declare const FLOW_SURFACES_ACTION_NAMES: ("setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate" | "apply")[];
+export declare const FLOW_SURFACES_ACTION_NAMES: ("setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate" | "apply")[];
 export declare const FLOW_SURFACES_READ_ACTION_NAMES: SelectFlowSurfaceActionNames<"read">[];
 export declare const FLOW_SURFACE_MUTATE_OP_TYPES: FlowSurfaceMutateActionName[];
-export declare const FLOW_SURFACES_ACTION_METHODS: Record<"setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate" | "apply", FlowSurfaceActionMethod>;
+export declare const FLOW_SURFACES_ACTION_METHODS: Record<"setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate" | "apply", FlowSurfaceActionMethod>;

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

@@ -40,6 +40,7 @@ const FLOW_SURFACE_ACTION_DEFINITIONS = {
   context: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   get: { method: "get", read: true, transaction: false, mutate: false, valueSource: "read" },
   describeSurface: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
+  exportBlueprint: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   getReactionMeta: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   setFieldValueRules: { method: "post", read: false, transaction: true, mutate: false, valueSource: "default" },
   setBlockLinkageRules: { method: "post", read: false, transaction: true, mutate: false, valueSource: "default" },

package/dist/server/flow-surfaces/default-action-popup.d.ts

@@ -47,6 +47,7 @@ export type FlowSurfaceDefaultActionPopupFieldGroupCandidate = {
 type FlowSurfaceDefaultActionPopupFieldFilterOptions = {
     excludeAuditTimestampFields?: boolean;
     excludeAssociationFields?: boolean;
+    excludeRelationBackingForeignKeyFields?: boolean;
 };
 type FlowSurfaceDefaultActionPopupFieldsInput = any[] | {
     fieldPaths?: any[];
@@ -60,6 +61,7 @@ export declare function getFlowSurfaceDefaultActionPopupConfigByUse(use?: string
 export declare function resolveFlowSurfaceDefaultActionPopupTabTitle(use?: string, currentTitle?: string | null): string;
 export declare function isFlowSurfaceDefaultActionPopupBusinessField(field: any): boolean;
 export declare function pickFlowSurfaceDefaultActionPopupFieldPaths(candidates: FlowSurfaceDefaultActionPopupFieldCandidate[], options?: FlowSurfaceDefaultActionPopupFieldFilterOptions): string[];
+export declare function collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths(fieldGroups: FlowSurfaceDefaultActionPopupFieldGroupCandidate[] | undefined): Set<string>;
 export declare function pickFlowSurfaceDefaultActionPopupFieldGroups(candidates: FlowSurfaceDefaultActionPopupFieldCandidate[], fieldGroups: FlowSurfaceDefaultActionPopupFieldGroupCandidate[] | undefined, options?: FlowSurfaceDefaultActionPopupFieldFilterOptions): FlowSurfaceDefaultActionPopupFieldGroupCandidate[];
 export declare function buildFlowSurfaceDefaultActionPopupBlocks(use: string | undefined, fieldsInput: FlowSurfaceDefaultActionPopupFieldsInput): _.Dictionary<string | any[] | Record<string, any> | FlowSurfaceDefaultActionPopupFieldGroupCandidate[] | FlowSurfaceDefaultActionPopupSubmitAction[] | {
     binding: "currentCollection" | "currentRecord";

package/dist/server/flow-surfaces/default-action-popup.js

@@ -39,6 +39,7 @@ __export(default_action_popup_exports, {
   FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
   FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
   buildFlowSurfaceDefaultActionPopupBlocks: () => buildFlowSurfaceDefaultActionPopupBlocks,
+  collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths: () => collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths,
   getFlowSurfaceDefaultActionPopupConfigByUse: () => getFlowSurfaceDefaultActionPopupConfigByUse,
   hasFlowSurfaceInlinePopupBlocks: () => hasFlowSurfaceInlinePopupBlocks,
   hasFlowSurfaceInlinePopupTemplate: () => hasFlowSurfaceInlinePopupTemplate,
@@ -52,6 +53,7 @@ __export(default_action_popup_exports, {
 module.exports = __toCommonJS(default_action_popup_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_association_interfaces = require("./association-interfaces");
+var import_relation_backing_foreign_key = require("./relation-backing-foreign-key");
 var import_service_helpers = require("./service-helpers");
 const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "createdBy", "createdById", "updatedBy", "updatedById"]);
 const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_INTERFACES = /* @__PURE__ */ new Set([
@@ -214,13 +216,10 @@ function isFlowSurfaceDefaultActionPopupAssociationField(field) {
   const fieldType = String((0, import_service_helpers.getFieldType)(field) || "").trim();
   return fieldType === "belongsTo" || fieldType === "hasOne" || fieldType === "hasMany" || fieldType === "belongsToMany";
 }
-function collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates) {
-  return new Set(
-    candidates.map((candidate) => candidate == null ? void 0 : candidate.field).filter((field) => (0, import_service_helpers.getFieldType)(field) === "belongsTo").map((field) => {
-      var _a;
-      return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
-    }).filter(Boolean)
-  );
+function collectFlowSurfaceDefaultActionPopupRelationBackingForeignKeys(candidates) {
+  return (0, import_relation_backing_foreign_key.collectRelationBackingForeignKeyNames)({
+    getFields: () => candidates.map((candidate) => candidate == null ? void 0 : candidate.field).filter(Boolean)
+  });
 }
 function isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(field, associationForeignKeys) {
   const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
@@ -229,13 +228,26 @@ function isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(field, associ
 function pickFlowSurfaceDefaultActionPopupFieldPaths(candidates, options = {}) {
   return filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options).map((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim()).filter(Boolean);
 }
+function collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths(fieldGroups) {
+  const fieldPaths = /* @__PURE__ */ new Set();
+  import_lodash.default.castArray(fieldGroups || []).forEach((group) => {
+    import_lodash.default.castArray((group == null ? void 0 : group.fields) || []).forEach((field) => {
+      const fieldPath = getFlowSurfaceDefaultActionPopupFieldGroupFieldPath(field);
+      if (fieldPath) {
+        fieldPaths.add(fieldPath);
+      }
+    });
+  });
+  return fieldPaths;
+}
 function filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options = {}) {
-  const associationForeignKeys = collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates);
+  const associationForeignKeys = collectFlowSurfaceDefaultActionPopupRelationBackingForeignKeys(candidates);
+  const excludeRelationBackingForeignKeyFields = options.excludeRelationBackingForeignKeyFields !== false;
   const preferredCandidates = candidates.filter(
-    (candidate) => !isFlowSurfaceDefaultActionPopupSystemField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+    (candidate) => !isFlowSurfaceDefaultActionPopupSystemField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && (!excludeRelationBackingForeignKeyFields || !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys))
   );
   const fallbackCandidates = candidates.filter(
-    (candidate) => !isFlowSurfaceDefaultActionPopupTechnicalIdField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+    (candidate) => !isFlowSurfaceDefaultActionPopupTechnicalIdField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && (!excludeRelationBackingForeignKeyFields || !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys))
   );
   const baseCandidates = preferredCandidates.length ? preferredCandidates : fallbackCandidates;
   return baseCandidates.filter((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim());
@@ -266,9 +278,10 @@ function normalizeFlowSurfaceDefaultActionPopupFieldGroupField(field, fieldPath)
 }
 function pickFlowSurfaceDefaultActionPopupFieldGroups(candidates, fieldGroups, options = {}) {
   const allowedFieldPaths = new Set(
-    filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options).map(
-      (candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim()
-    )
+    filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, {
+      ...options,
+      excludeRelationBackingForeignKeyFields: false
+    }).map((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim())
   );
   const usedFieldPaths = /* @__PURE__ */ new Set();
   return import_lodash.default.castArray(fieldGroups || []).flatMap((group) => {
@@ -351,6 +364,7 @@ function hasFlowSurfaceInlinePopupBlocks(popup) {
   FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
   FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
   buildFlowSurfaceDefaultActionPopupBlocks,
+  collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths,
   getFlowSurfaceDefaultActionPopupConfigByUse,
   hasFlowSurfaceInlinePopupBlocks,
   hasFlowSurfaceInlinePopupTemplate,

package/dist/server/flow-surfaces/filter-group.d.ts

@@ -11,13 +11,30 @@ export declare const FLOW_SURFACE_EMPTY_FILTER_GROUP: {
     items: any[];
 };
 export declare const FLOW_SURFACE_FILTER_GROUP_EXAMPLE: string;
+export declare const FLOW_SURFACE_DATE_FILTER_OPERATORS: Set<string>;
 export declare function assertFlowSurfaceFilterOperator(operator: unknown, path: string): void;
-export declare function normalizeFlowSurfaceFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
-export declare function normalizeFlowSurfaceStrictFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
+export declare function normalizeFlowSurfaceFilterDateValue(operator: unknown, value: unknown, path: string, options?: {
+    allowContextPathValue?: boolean;
+}): unknown;
+export declare function normalizeFlowSurfaceStrictFilterDateValue(operator: unknown, value: unknown, path: string, options?: {
+    allowContextPathValue?: boolean;
+}): unknown;
+export declare function isFlowSurfaceDateLikeFieldMeta(value: {
+    type?: unknown;
+    interface?: unknown;
+} | undefined | null): boolean;
+export declare function normalizeFlowSurfaceDateConditionValue(operator: unknown, value: unknown, path: string, options?: {
+    fieldPath?: string;
+    fieldType?: unknown;
+    fieldInterface?: unknown;
+    allowContextPathValue?: boolean;
+}): unknown;
 export declare function normalizeFlowSurfaceFilterGroupValue(value: any, errorPrefix: string, options?: {
     strictDateValues?: boolean;
+    allowContextPathValue?: boolean;
 }): any;
 export declare function normalizeFlowSurfaceCompatibleFilterGroupValue(value: unknown, errorPrefix: string, options?: {
     strictDateValues?: boolean;
+    allowContextPathValue?: boolean;
 }): any;
 export declare function assertFlowSurfaceFilterGroupShape(filter: any): void;

package/dist/server/flow-surfaces/filter-group.js

@@ -36,11 +36,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var filter_group_exports = {};
 __export(filter_group_exports, {
+  FLOW_SURFACE_DATE_FILTER_OPERATORS: () => FLOW_SURFACE_DATE_FILTER_OPERATORS,
   FLOW_SURFACE_EMPTY_FILTER_GROUP: () => FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE: () => FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape: () => assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator: () => assertFlowSurfaceFilterOperator,
+  isFlowSurfaceDateLikeFieldMeta: () => isFlowSurfaceDateLikeFieldMeta,
   normalizeFlowSurfaceCompatibleFilterGroupValue: () => normalizeFlowSurfaceCompatibleFilterGroupValue,
+  normalizeFlowSurfaceDateConditionValue: () => normalizeFlowSurfaceDateConditionValue,
   normalizeFlowSurfaceFilterDateValue: () => normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue: () => normalizeFlowSurfaceFilterGroupValue,
   normalizeFlowSurfaceStrictFilterDateValue: () => normalizeFlowSurfaceStrictFilterDateValue
@@ -76,6 +79,17 @@ const FLOW_SURFACE_DATE_FILTER_OPERATORS = /* @__PURE__ */ new Set([
   "$dateNotAfter",
   "$dateBetween"
 ]);
+const FLOW_SURFACE_DATE_COMPARISON_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$lt", "$lte", "$gt", "$gte", "$in", "$notIn"]);
+const FLOW_SURFACE_EMPTY_FILTER_OPERATORS = /* @__PURE__ */ new Set(["$empty", "$notEmpty", "$exists", "$notExists"]);
+const FLOW_SURFACE_DATE_LIKE_TYPES = /* @__PURE__ */ new Set([
+  "date",
+  "datetime",
+  "dateonly",
+  "datetimenotz",
+  "unixtimestamp",
+  "createdat",
+  "updatedat"
+]);
 const FLOW_SURFACE_DATE_RANGE_TYPES = /* @__PURE__ */ new Set([
   "today",
   "yesterday",
@@ -109,6 +123,18 @@ const FLOW_SURFACE_DATE_VALUE_REPAIR_EXAMPLE = {
     }
   ]
 };
+const FLOW_SURFACE_DATE_CONDITION_REPAIR_HINT = "Date/DateTime condition values must be valid UI date values or safe context-path templates. Do not use template arithmetic such as {{$now - 14 * 24 * 60 * 60 * 1000}}; use date operators such as $dateBefore with a relative descriptor instead.";
+const FLOW_SURFACE_DATE_CONDITION_REPAIR_EXAMPLE = {
+  logic: "$and",
+  items: [
+    {
+      path: "lastFollowUpAt",
+      operator: "$dateBefore",
+      value: { type: "past", number: 14, unit: "day" }
+    }
+  ]
+};
+const FLOW_SURFACE_ISO_DATE_VALUE_RE = /^\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 const FLOW_SURFACE_KNOWN_FILTER_OPERATORS = buildFlowSurfaceKnownFilterOperators();
 function buildFlowSurfaceKnownFilterOperators() {
   const operators = new Set(Object.keys(import_database.operators));
@@ -156,13 +182,16 @@ function assertFlowSurfaceFilterOperator(operator, path) {
     );
   }
 }
-function normalizeFlowSurfaceFilterDateValue(operator, value, path) {
+function normalizeFlowSurfaceFilterDateValue(operator, value, path, options = {}) {
   if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
     return value;
   }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
   return normalizeFlowSurfaceDateValue(value, path);
 }
-function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path) {
+function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path, options = {}) {
   if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
     return value;
   }
@@ -171,8 +200,33 @@ function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path) {
       invalidReason: "date filter value is required"
     });
   }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
   return normalizeFlowSurfaceDateValue(value, path);
 }
+function isFlowSurfaceDateLikeFieldMeta(value) {
+  const fieldType = String((value == null ? void 0 : value.type) || "").trim().toLowerCase();
+  const fieldInterface = String((value == null ? void 0 : value.interface) || "").trim().toLowerCase();
+  return FLOW_SURFACE_DATE_LIKE_TYPES.has(fieldType) || FLOW_SURFACE_DATE_LIKE_TYPES.has(fieldInterface);
+}
+function normalizeFlowSurfaceDateConditionValue(operator, value, path, options = {}) {
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!normalizedOperator || FLOW_SURFACE_EMPTY_FILTER_OPERATORS.has(normalizedOperator)) {
+    return value;
+  }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
+  if (FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator)) {
+    assertNoUnsafeFlowSurfaceDateTemplateValues(value, path, options);
+    return normalizeFlowSurfaceStrictFilterDateValue(normalizedOperator, value, path);
+  }
+  if (!FLOW_SURFACE_DATE_COMPARISON_OPERATORS.has(normalizedOperator)) {
+    return value;
+  }
+  return normalizeFlowSurfaceDateComparisonValue(normalizedOperator, value, path, options);
+}
 function normalizeFlowSurfaceFilterGroupValue(value, errorPrefix, options = {}) {
   const normalized = value === null || import_lodash.default.isPlainObject(value) && !Object.keys(value).length ? import_lodash.default.cloneDeep(FLOW_SURFACE_EMPTY_FILTER_GROUP) : import_lodash.default.cloneDeep(value);
   try {
@@ -332,7 +386,11 @@ function normalizeFlowSurfaceFilterGroupDateValues(filter, errorPrefix, options)
       normalizeFlowSurfaceFilterGroupDateValues(item, itemPath, options);
       return;
     }
-    item.value = options.strictDateValues ? normalizeFlowSurfaceStrictFilterDateValue(item.operator, item.value, `${itemPath}.value`) : normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`);
+    item.value = options.strictDateValues ? normalizeFlowSurfaceStrictFilterDateValue(item.operator, item.value, `${itemPath}.value`, {
+      allowContextPathValue: options.allowContextPathValue
+    }) : normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`, {
+      allowContextPathValue: options.allowContextPathValue
+    });
   });
 }
 function normalizeFlowSurfaceDateValue(value, path) {
@@ -344,6 +402,82 @@ function normalizeFlowSurfaceDateValue(value, path) {
   }
   return normalizeFlowSurfaceDateValuePart(value, path);
 }
+function normalizeFlowSurfaceDateComparisonValue(operator, value, path, options) {
+  if (operator === "$in" || operator === "$notIn") {
+    if (!Array.isArray(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        operator,
+        invalidReason: "date comparison array operators require an array value"
+      });
+    }
+    return value.map(
+      (item, index) => normalizeFlowSurfaceDateComparisonValuePart(item, `${path}[${index}]`, {
+        ...options,
+        operator
+      })
+    );
+  }
+  return normalizeFlowSurfaceDateComparisonValuePart(value, path, {
+    ...options,
+    operator
+  });
+}
+function normalizeFlowSurfaceDateComparisonValuePart(value, path, options) {
+  if (import_lodash.default.isNil(value) || value === "") {
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date comparison value is required; use $empty or $notEmpty for empty checks"
+    });
+  }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
+  if (isTemplateDateString(value)) {
+    if (isUnsafeFlowSurfaceDateTemplateString(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date condition template strings must be simple context-path references; template arithmetic, $now, Date/dayjs/moment calls, and Invalid date are not supported"
+      });
+    }
+    return value;
+  }
+  if (import_lodash.default.isDate(value)) {
+    if (!Number.isNaN(value.getTime())) {
+      return value;
+    }
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date condition value must be a valid Date"
+    });
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (/invalid\s+date/i.test(normalized)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date condition value cannot be Invalid date"
+      });
+    }
+    if (isFlowSurfaceIsoLikeDateValue(normalized)) {
+      return normalized;
+    }
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date comparison strings must use concrete YYYY-MM-DD or ISO-like date/datetime strings"
+    });
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "relative date descriptors require date operators such as $dateBefore or $dateBetween instead of comparison operators"
+    });
+  }
+  throwInvalidFlowSurfaceDateConditionValue(path, value, {
+    ...options,
+    invalidReason: "date condition value must be an exact date string, ISO datetime string, or safe context path template"
+  });
+}
 function normalizeFlowSurfaceDateArrayValue(value, path) {
   if (value.length !== 2) {
     throwInvalidFlowSurfaceDateValue(path, value, {
@@ -386,6 +520,25 @@ function isFlowSurfaceExactDateValue(value) {
     return parsed.isValid() && parsed.format(format) === value;
   });
 }
+function isFlowSurfaceIsoLikeDateValue(value) {
+  const match = FLOW_SURFACE_ISO_DATE_VALUE_RE.exec(value);
+  if (!match) {
+    return false;
+  }
+  const [year, month, day] = value.slice(0, 10).split("-").map((item) => Number(item));
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+    return false;
+  }
+  const timeMatch = /[T\s](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,6}))?)?/.exec(value);
+  if (!timeMatch) {
+    return true;
+  }
+  const hour = Number(timeMatch[1]);
+  const minute = Number(timeMatch[2]);
+  const second = Number(timeMatch[3] || 0);
+  return hour <= 23 && minute <= 59 && second <= 59 && (0, import_utils.dayjs)(value).isValid();
+}
 function normalizeRelativeDateDescriptor(value, path) {
   const invalidKeys = Object.keys(value).filter((key) => !FLOW_SURFACE_RELATIVE_DATE_DESCRIPTOR_KEYS.has(key));
   if (invalidKeys.length) {
@@ -456,6 +609,67 @@ function normalizeRelativeDateDescriptor(value, path) {
 function isTemplateDateString(value) {
   return typeof value === "string" && /^\s*\{\{[\s\S]*\}\}\s*$/.test(value);
 }
+function isFlowSurfaceContextPathValueObject(value) {
+  if (!import_lodash.default.isPlainObject(value) || value.source !== "path") {
+    return false;
+  }
+  const path = value.path;
+  if (typeof path !== "string") {
+    return false;
+  }
+  const normalizedPath = path.trim();
+  if (isTemplateDateString(normalizedPath)) {
+    return !isUnsafeFlowSurfaceDateTemplateString(normalizedPath);
+  }
+  return isSimpleFlowSurfaceTemplateReference(normalizedPath);
+}
+function extractTemplateDateExpression(value) {
+  return value.replace(/^\s*\{\{\s*/, "").replace(/\s*\}\}\s*$/, "").trim();
+}
+function isSimpleFlowSurfaceTemplateReference(expression) {
+  const identifier = "[A-Za-z_$][A-Za-z0-9_$-]*";
+  const segment = `(?:\\.${identifier}|\\[(?:\\d+|"[^"\\]]+"|'[^'\\]]+')\\])`;
+  return new RegExp(`^${identifier}(?:${segment})*$`).test(expression.replace(/\s+/g, ""));
+}
+function isUnsafeFlowSurfaceDateTemplateString(value) {
+  const expression = extractTemplateDateExpression(value);
+  if (!expression) {
+    return true;
+  }
+  if (/\$now\b/i.test(expression)) {
+    return true;
+  }
+  if (/invalid\s+date/i.test(expression)) {
+    return true;
+  }
+  if (/\bnew\s+Date\b|\bDate\s*\(|\bdayjs\s*\(|\bmoment\s*\(/.test(expression)) {
+    return true;
+  }
+  if (isSimpleFlowSurfaceTemplateReference(expression)) {
+    return false;
+  }
+  return /[+\-*/%()]|=>/.test(expression);
+}
+function assertNoUnsafeFlowSurfaceDateTemplateValues(value, path, options = {}) {
+  if (isTemplateDateString(value)) {
+    if (isUnsafeFlowSurfaceDateTemplateString(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date filter template strings must be simple context-path references; template arithmetic, $now, Date/dayjs/moment calls, and Invalid date are not supported"
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoUnsafeFlowSurfaceDateTemplateValues(item, `${path}[${index}]`, options));
+    return;
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    Object.entries(value).forEach(
+      ([key, item]) => assertNoUnsafeFlowSurfaceDateTemplateValues(item, `${path}.${key}`, options)
+    );
+  }
+}
 function hasTemplateDateValue(value) {
   if (isTemplateDateString(value)) {
     return true;
@@ -468,6 +682,18 @@ function hasTemplateDateValue(value) {
   }
   return false;
 }
+function throwInvalidFlowSurfaceDateConditionValue(path, value, details = {}) {
+  (0, import_errors.throwBadRequest)(`${path} must be a valid Date/DateTime condition value`, {
+    path,
+    ruleId: "date-condition-value-invalid",
+    details: {
+      invalidValue: value,
+      ...details,
+      repairHint: FLOW_SURFACE_DATE_CONDITION_REPAIR_HINT,
+      repairExample: FLOW_SURFACE_DATE_CONDITION_REPAIR_EXAMPLE
+    }
+  });
+}
 function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
   (0, import_errors.throwBadRequest)(`${path} must be a valid date filter value`, {
     path,
@@ -482,11 +708,14 @@ function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FLOW_SURFACE_DATE_FILTER_OPERATORS,
   FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator,
+  isFlowSurfaceDateLikeFieldMeta,
   normalizeFlowSurfaceCompatibleFilterGroupValue,
+  normalizeFlowSurfaceDateConditionValue,
   normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue,
   normalizeFlowSurfaceStrictFilterDateValue

package/dist/server/flow-surfaces/planning/compiler.d.ts

@@ -22,6 +22,7 @@ type CompilePlanStepDeps = NormalizePlanSelectorDeps & {
     resolveLocator: (target: FlowSurfaceReadLocator, options?: {
         transaction?: any;
     }) => Promise<FlowSurfaceResolvedTarget>;
+    loadResolvedSurfaceTree?: (resolved: FlowSurfaceResolvedTarget, transaction?: any) => Promise<any>;
     buildPlanKeyKind: (node: any, resolvedKind?: string) => string;
 };
 export declare function normalizePlanSelector(actionName: string, selector: any, deps: NormalizePlanSelectorDeps, fieldName?: string, options?: NormalizePlanSelectorOptions): FlowSurfacePlanSelector;