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

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") {

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

@@ -163,6 +163,13 @@ export type FlowSurfaceReactionCapabilityBase<TKind extends FlowSurfaceReactionK
 };
 export type FlowSurfaceFieldValueCapability = FlowSurfaceReactionCapabilityBase<'fieldValue', FlowSurfaceFieldValueRule> & {
     targetFields: FlowSurfaceFieldOption[];
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
+    };
     valueExprMeta: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;
         runjsScene: 'fieldValue';
@@ -172,17 +179,29 @@ export type FlowSurfaceLinkageCapability = (FlowSurfaceReactionCapabilityBase<'b
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'actionLinkage', FlowSurfaceActionLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'fieldLinkage', FlowSurfaceFieldLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     targetFields: FlowSurfaceFieldOption[];
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
     valueExprMeta?: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;

package/dist/server/flow-surfaces/relation-backing-foreign-key.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare function collectRelationBackingForeignKeyNames(collection: any): Set<string>;
+export declare function isRelationBackingForeignKeyField(collection: any, fieldOrFieldName: any): boolean;

package/dist/server/flow-surfaces/relation-backing-foreign-key.js

@@ -0,0 +1,79 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var relation_backing_foreign_key_exports = {};
+__export(relation_backing_foreign_key_exports, {
+  collectRelationBackingForeignKeyNames: () => collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField: () => isRelationBackingForeignKeyField
+});
+module.exports = __toCommonJS(relation_backing_foreign_key_exports);
+var import_service_helpers = require("./service-helpers");
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES = /* @__PURE__ */ new Set(["belongsto"]);
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["m2o"]);
+const CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["o2o"]);
+const RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["o2m", "m2m", "mbm"]);
+const RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["hasone", "hasmany", "belongstomany"]);
+function collectRelationBackingForeignKeyNames(collection) {
+  const fields = (0, import_service_helpers.getCollectionFields)(collection);
+  const scalarFieldNames = new Set(
+    fields.filter((field) => !(0, import_service_helpers.isAssociationField)(field)).map((field) => String((0, import_service_helpers.getFieldName)(field) || "").trim()).filter(Boolean)
+  );
+  const names = /* @__PURE__ */ new Set();
+  fields.forEach((field) => {
+    const foreignKey = getCurrentCollectionRelationForeignKey(field);
+    if (foreignKey && scalarFieldNames.has(foreignKey)) {
+      names.add(foreignKey);
+    }
+  });
+  return names;
+}
+function isRelationBackingForeignKeyField(collection, fieldOrFieldName) {
+  const fieldName = typeof fieldOrFieldName === "string" ? fieldOrFieldName.trim() : String((0, import_service_helpers.getFieldName)(fieldOrFieldName) || "").trim();
+  return !!fieldName && collectRelationBackingForeignKeyNames(collection).has(fieldName);
+}
+function getCurrentCollectionRelationForeignKey(field) {
+  var _a;
+  if (!(0, import_service_helpers.isAssociationField)(field)) {
+    return "";
+  }
+  if (!relationCanStoreForeignKeyInCurrentCollection(field)) {
+    return "";
+  }
+  return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+}
+function relationCanStoreForeignKeyInCurrentCollection(field) {
+  const type = String((0, import_service_helpers.getFieldType)(field) || "").trim().toLowerCase();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim().toLowerCase();
+  if (RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(type) || RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(fieldInterface)) {
+    return false;
+  }
+  return CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES.has(type) || CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface) || CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField
+});

package/dist/server/flow-surfaces/runjs-authoring/ast/source.d.ts

@@ -23,6 +23,7 @@ export declare function getPreviousSignificantTokenInfo(sourceLike: string | str
 export declare function skipQuotedLiteral(source: string, start: number, quote: string): number;
 export declare function skipTemplateLiteral(source: string, start: number): number;
 export declare function findFunctionRanges(masked: string): SourceRange[];
+export declare function collectAstFunctionBodyRanges(ast: unknown): SourceRange[];
 export declare function collectFunctionRanges(masked: string, pattern: RegExp, ranges: SourceRange[]): void;
 export declare function collectArrowExpressionRanges(masked: string, ranges: SourceRange[]): void;
 export declare function collectMethodFunctionRanges(masked: string, ranges: SourceRange[]): void;

package/dist/server/flow-surfaces/runjs-authoring/ast/source.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var source_exports = {};
 __export(source_exports, {
   collectArrowExpressionRanges: () => collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges: () => collectAstFunctionBodyRanges,
   collectBraceRanges: () => collectBraceRanges,
   collectComputedMethodCandidates: () => collectComputedMethodCandidates,
   collectFunctionRanges: () => collectFunctionRanges,
@@ -69,6 +70,7 @@ __export(source_exports, {
 });
 module.exports = __toCommonJS(source_exports);
 var import_constants = require("../runtime/constants");
+var import_walk = require("./walk");
 function maskJavaScriptSource(source) {
   const chars = source.split("");
   const maskRange = (start, end) => {
@@ -406,6 +408,23 @@ function findFunctionRanges(masked) {
   collectMethodFunctionRanges(masked, ranges);
   return mergeRanges(ranges);
 }
+function collectAstFunctionBodyRanges(ast) {
+  const ranges = [];
+  const addBodyRange = (node) => {
+    var _a, _b;
+    const start = (_a = node.body) == null ? void 0 : _a.start;
+    const end = (_b = node.body) == null ? void 0 : _b.end;
+    if (typeof start === "number" && typeof end === "number" && end > start) {
+      ranges.push({ start, end });
+    }
+  };
+  (0, import_walk.walkAstSimple)(ast, {
+    FunctionDeclaration: addBodyRange,
+    FunctionExpression: addBodyRange,
+    ArrowFunctionExpression: addBodyRange
+  });
+  return mergeRanges(ranges);
+}
 function collectFunctionRanges(masked, pattern, ranges) {
   for (const match of masked.matchAll(pattern)) {
     const openBrace = masked.indexOf("{", match.index || 0);
@@ -853,6 +872,7 @@ function getAstSource(node, source) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges,
   collectBraceRanges,
   collectComputedMethodCandidates,
   collectFunctionRanges,

package/dist/server/flow-surfaces/runjs-authoring/scan/filter.js

@@ -900,7 +900,13 @@ function buildRunJsResourceFilterOperatorError(operator, index, input) {
   };
 }
 function buildRunJsResourceDateFilterValueError(operator, index, valueNode, input) {
-  if (!isRunJsDateFilterOperator(operator)) {
+  const fieldType = String((0, import_service_helpers.getFieldType)(input.field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(input.field) || "").trim();
+  const shouldValidateDateValue = isRunJsDateFilterOperator(operator) || (0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)({
+    type: fieldType,
+    interface: fieldInterface
+  });
+  if (!shouldValidateDateValue) {
     return null;
   }
   const valueObject = resolveRunJsStaticFilterObjectNode(
@@ -924,7 +930,11 @@ function buildRunJsResourceDateFilterValueError(operator, index, valueNode, inpu
     return null;
   }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`, {
+      fieldPath: input.fieldPath,
+      fieldType,
+      fieldInterface
+    });
     return null;
   } catch (error) {
     return buildRunJsStrictDateFilterValueError(operator, index, resolvedValue.value, input, error);

package/dist/server/flow-surfaces/runjs-authoring/scan/index.js

@@ -43,7 +43,7 @@ var import_filter = require("./filter");
 var import_constants = require("../runtime/constants");
 function scanJavaScriptSource(source, ast, context = {}, modelUse = "") {
   const masked = (0, import_source.maskJavaScriptSource)(source);
-  const functionRanges = (0, import_source.findFunctionRanges)(masked);
+  const functionRanges = collectScanFunctionRanges(masked, ast);
   const blockRanges = (0, import_source.collectBraceRanges)(masked);
   const staticBlockRanges = (0, import_source.collectStaticBlockRanges)(masked);
   const sourceBindings = (0, import_bindings.collectSourceBindings)(masked, functionRanges, blockRanges, staticBlockRanges);
@@ -139,6 +139,14 @@ function scanJavaScriptSource(source, ast, context = {}, modelUse = "") {
     isTopLevelFunctionWrapper: (0, import_source_patterns.isTopLevelFunctionWrapper)(masked, functionRanges, topLevelReachableCtxRenderCalls)
   };
 }
+function collectScanFunctionRanges(masked, ast) {
+  if (!ast) {
+    return (0, import_source.findFunctionRanges)(masked);
+  }
+  const ranges = (0, import_source.collectAstFunctionBodyRanges)(ast);
+  (0, import_source.collectArrowExpressionRanges)(masked, ranges);
+  return (0, import_source.mergeRanges)(ranges);
+}
 function collectAstUnknownBareGlobalsFromAst(ast, identifierBindings, modelUse) {
   var _a;
   const allowedGlobals = new Set(import_constants.RUNJS_ALLOWED_BARE_GLOBALS);

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

@@ -142,6 +142,7 @@ export declare class FlowSurfacesService {
     private getCollectionFilterTargetKey;
     private normalizeFlowContextTemplateValue;
     private isSameConfiguredFlowContextValue;
+    private isPopupCurrentRecordFilterByTkMatch;
     private isPopupAssociatedRecordsSourceIdMatch;
     private classifyPopupRawResourceInit;
     private resolvePopupAssociationField;
@@ -160,6 +161,7 @@ export declare class FlowSurfacesService {
     private persistReactionSlot;
     private buildLinkageWriteResult;
     private getLiveLinkageCapability;
+    private getLiveFieldValueCapability;
     getReactionMeta(values: FlowSurfaceGetReactionMetaValues, options?: {
         transaction?: any;
     }): Promise<FlowSurfaceGetReactionMetaResult>;
@@ -182,6 +184,17 @@ export declare class FlowSurfacesService {
     private buildSurfaceReadPayload;
     private buildSurfaceContextFingerprint;
     get(input: Record<string, any>, options?: FlowSurfaceReadOptions): Promise<Record<string, any>>;
+    exportBlueprint(input: Record<string, unknown>, options?: FlowSurfaceReadOptions): Promise<{
+        document: FlowSurfaceApplyBlueprintDocument;
+        source: {
+            target: {
+                pageSchemaUid: string;
+            };
+            pageTitle?: string;
+        };
+        warnings: string[];
+        unsupported: import("./blueprint/export-document").FlowSurfaceExportBlueprintUnsupportedItem[];
+    }>;
     private getDeclaredKeyPersistenceDeps;
     private patchDeclaredKeyModel;
     private persistCreatedKeysForAction;
@@ -288,6 +301,7 @@ export declare class FlowSurfacesService {
     private createFlowTemplateReferenceBlockModel;
     private buildPopupTemplateReferenceOpenView;
     private shouldHydrateDetachedPopupTemplateBlockResourceContext;
+    private resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk;
     private collectDetachedPopupTemplateBlockResourceContextPatches;
     private hydrateDetachedPopupTemplateBlockResourceContext;
     private hydrateDetachedPopupTemplateSourceContext;
@@ -736,6 +750,9 @@ export declare class FlowSurfacesService {
     private syncFilterActionSettingsForUpdateSettings;
     private resolveFilterActionDefaultFilterRequiredFieldCount;
     private syncMirroredStepParamsForUpdateSettings;
+    private syncActionButtonSettingsForUpdateSettings;
+    private supportsActionButtonSettingsSync;
+    private pickRequestedActionButtonSettings;
     private syncCreatedFieldWrapperTitleFieldStepParams;
     private syncUpdateActionAssignedValuesForUpdateSettings;
     private syncActionTriggerWorkflowsForUpdateSettings;
@@ -916,6 +933,12 @@ export declare class FlowSurfacesService {
     private normalizeRemoveNodeTarget;
     private assertRemoveNodeResolvedTarget;
     private normalizeGetTarget;
+    private normalizeExportBlueprintRequest;
+    private normalizeExportBlueprintUnsupportedPolicy;
+    private normalizeExportBlueprintLocatorValue;
+    private readRouteString;
+    private resolveExportBlueprintPageSchemaUid;
+    private assertExportBlueprintRootTarget;
     private normalizeContextPath;
     private normalizeContextMaxDepth;
     private buildReadTargetSummary;
@@ -1088,6 +1111,7 @@ export declare class FlowSurfacesService {
     private buildFieldCatalog;
     private getFieldMenuCatalogMode;
     private resolveRegisteredFieldBinding;
+    private isCollectionTitleField;
     private resolveAssociationLeafDisplaySemantics;
     private buildFieldMenuDirectCandidates;
     private collectFieldMenuAssociationLeafCandidates;