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

package/dist/server/flow-surfaces/blueprint/compile-blocks.js

@@ -1305,6 +1305,19 @@ function attachDefaultActionPopupMetadata(popup, actionType, metadata) {
   const defaultPopup = actionType === "addChild" && import_lodash.default.isUndefined(popup) ? {} : popup;
   return attachCompiledPopupDefaults(defaultPopup, metadata);
 }
+function isFieldClickToOpenEnabled(settings) {
+  if (!import_lodash.default.isPlainObject(settings) || !Object.prototype.hasOwnProperty.call(settings, "clickToOpen")) {
+    return false;
+  }
+  const value = settings.clickToOpen;
+  return value === true || import_lodash.default.isPlainObject(value) && value.clickToOpen === true;
+}
+function buildGeneratedDefaultFieldPopup() {
+  return {
+    tryTemplate: true,
+    defaultType: "view"
+  };
+}
 function hasNestedDefaultPopupMetadata(value) {
   if (Array.isArray(value)) {
     return value.some((item) => hasNestedDefaultPopupMetadata(item));
@@ -1640,7 +1653,10 @@ function compileField(input, index, scopePrefix, assets, localBlockKeys, context
     parentContext: parentResourceContext,
     getCollection
   });
-  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`, defaults, {
+  const shouldAutoCompleteClickPopup = import_lodash.default.isUndefined(input.popup) && isFieldClickToOpenEnabled(settings);
+  const popupInput = shouldAutoCompleteClickPopup ? buildGeneratedDefaultFieldPopup() : input.popup;
+  const shouldAutoRelationFieldPopup = import_lodash.default.isUndefined(input.popup) && !!fieldPath && !syntheticType;
+  const popupResult = compilePopup(popupInput, `${key}.popup`, assets, `${context}[${index}].popup`, defaults, {
     getCollection,
     mode: popupOptions.mode,
     popupDepth: popupOptions.popupDepth,
@@ -1652,7 +1668,7 @@ function compileField(input, index, scopePrefix, assets, localBlockKeys, context
     associationName: popupOptions.associationName || (fieldAssociationContext == null ? void 0 : fieldAssociationContext.associationName)
   });
   settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
-  const popup = shouldAttachDefaultPopupMetadata(input.popup, void 0) ? attachCompiledPopupDefaults(popupResult.popup, popupDefaultsMetadata) : popupResult.popup;
+  const popup = shouldAttachDefaultPopupMetadata(popupInput, void 0) ? attachCompiledPopupDefaults(popupResult.popup, popupDefaultsMetadata) : popupResult.popup;
   return (0, import_service_utils.buildDefinedPayload)({
     key,
     fieldPath,
@@ -1668,7 +1684,9 @@ function compileField(input, index, scopePrefix, assets, localBlockKeys, context
     showIndex: input.showIndex,
     target: resolveTargetBlockKey(input.target, localBlockKeys, `${context}[${index}].target`),
     settings: Object.keys(settings).length ? settings : void 0,
-    popup
+    popup,
+    __autoPopupForRelationField: shouldAutoRelationFieldPopup ? true : void 0,
+    ...shouldAutoRelationFieldPopup && popupDefaultsMetadata ? { [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: import_lodash.default.cloneDeep(popupDefaultsMetadata) } : {}
   });
 }
 function compileAction(input, index, scopePrefix, assets, localBlockKeys, context, popupDefaultsMetadata, defaults, getCollection, options = {}) {

package/dist/server/flow-surfaces/blueprint/compile-plan.js

@@ -83,7 +83,7 @@ function buildTabSelectorFromUid(uid) {
   };
 }
 function compileCreatePlan(document, getCollection) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B;
   const steps = [];
   const chrome = buildPageChrome(document);
   if (import_lodash.default.isPlainObject((_a = document.navigation) == null ? void 0 : _a.group) && import_lodash.default.isUndefined(document.navigation.group.routeId)) {
@@ -105,10 +105,10 @@ function compileCreatePlan(document, getCollection) {
     values: (0, import_service_utils.buildDefinedPayload)({
       title: ((_k = (_j = document.navigation) == null ? void 0 : _j.item) == null ? void 0 : _k.title) || chrome.pageTitle,
       type: "item",
-      icon: (_m = (_l = document.navigation) == null ? void 0 : _l.item) == null ? void 0 : _m.icon,
-      tooltip: (_o = (_n = document.navigation) == null ? void 0 : _n.item) == null ? void 0 : _o.tooltip,
-      hideInMenu: (_q = (_p = document.navigation) == null ? void 0 : _p.item) == null ? void 0 : _q.hideInMenu,
-      parentMenuRouteId: import_lodash.default.isUndefined((_s = (_r = document.navigation) == null ? void 0 : _r.group) == null ? void 0 : _s.routeId) ? ((_u = (_t = document.navigation) == null ? void 0 : _t.group) == null ? void 0 : _u.title) ? { step: CREATE_MENU_GROUP_STEP_ID, path: "routeId" } : void 0 : (_w = (_v = document.navigation) == null ? void 0 : _v.group) == null ? void 0 : _w.routeId
+      icon: ((_m = (_l = document.navigation) == null ? void 0 : _l.item) == null ? void 0 : _m.icon) || ((_n = document.page) == null ? void 0 : _n.icon) || "FileOutlined",
+      tooltip: (_p = (_o = document.navigation) == null ? void 0 : _o.item) == null ? void 0 : _p.tooltip,
+      hideInMenu: (_r = (_q = document.navigation) == null ? void 0 : _q.item) == null ? void 0 : _r.hideInMenu,
+      parentMenuRouteId: import_lodash.default.isUndefined((_t = (_s = document.navigation) == null ? void 0 : _s.group) == null ? void 0 : _t.routeId) ? ((_v = (_u = document.navigation) == null ? void 0 : _u.group) == null ? void 0 : _v.title) ? { step: CREATE_MENU_GROUP_STEP_ID, path: "routeId" } : void 0 : (_x = (_w = document.navigation) == null ? void 0 : _w.group) == null ? void 0 : _x.routeId
     })
   });
   steps.push({
@@ -117,11 +117,11 @@ function compileCreatePlan(document, getCollection) {
     values: (0, import_service_utils.buildDefinedPayload)({
       menuRouteId: { step: CREATE_MENU_ITEM_STEP_ID, path: "routeId" },
       title: chrome.pageTitle,
-      icon: (_x = document.page) == null ? void 0 : _x.icon,
-      documentTitle: (_y = document.page) == null ? void 0 : _y.documentTitle,
-      enableHeader: (_z = document.page) == null ? void 0 : _z.enableHeader,
+      icon: (_y = document.page) == null ? void 0 : _y.icon,
+      documentTitle: (_z = document.page) == null ? void 0 : _z.documentTitle,
+      enableHeader: (_A = document.page) == null ? void 0 : _A.enableHeader,
       enableTabs: chrome.enableTabs,
-      displayTitle: (_A = document.page) == null ? void 0 : _A.displayTitle,
+      displayTitle: (_B = document.page) == null ? void 0 : _B.displayTitle,
       tabTitle: chrome.tabTitle,
       tabIcon: chrome.tabIcon,
       tabDocumentTitle: chrome.tabDocumentTitle,

package/dist/server/flow-surfaces/blueprint/normalize-document.js

@@ -588,12 +588,16 @@ function prepareFlowSurfaceApplyBlueprintDocument(input) {
   if (tabs.length > 1 && (page == null ? void 0 : page.enableTabs) === false) {
     (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint page.enableTabs cannot be false when tabs.length > 1`);
   }
+  const normalizedPage = tabs.length === 1 ? {
+    ...page || {},
+    enableTabs: false
+  } : page;
   return {
     version: "1",
     mode,
     ...target ? { target } : {},
     ...navigation ? { navigation } : {},
-    ...page ? { page } : {},
+    ...normalizedPage ? { page: normalizedPage } : {},
     ...defaults ? { defaults } : {},
     tabs,
     assets,

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

@@ -119,6 +119,10 @@ const FILTER_GROUP_SCHEMA = {
   additionalProperties: false,
   "x-flowSurfaceFormat": "filter-group"
 };
+const LINKAGE_RULES_SCHEMA = {
+  type: "array",
+  "x-flowSurfaceFormat": "linkage-rules"
+};
 const DEFAULT_DIRECT_EVENTS = ["beforeRender"];
 const ACTION_DIRECT_EVENTS = ["click", "beforeRender"];
 const ACTION_OBJECT_EVENTS = ["click"];
@@ -207,7 +211,7 @@ const ACTION_BUTTON_SETTINGS_GROUP = {
     "general.type": STRING_SCHEMA,
     "general.danger": BOOLEAN_SCHEMA,
     "general.color": STRING_SCHEMA,
-    "linkageRules.value": ARRAY_SCHEMA
+    "linkageRules.value": LINKAGE_RULES_SCHEMA
   }
 };
 const TRIGGER_WORKFLOWS_SETTINGS_GROUP = {
@@ -302,7 +306,7 @@ const EVENT_SETTINGS_GROUP = {
   allowedPaths: ["linkageRules.value"],
   eventBindingSteps: ["linkageRules"],
   pathSchemas: {
-    "linkageRules.value": ARRAY_SCHEMA
+    "linkageRules.value": LINKAGE_RULES_SCHEMA
   }
 };
 const CREATE_FORM_SETTINGS_EVENT_ONLY_GROUP = {
@@ -323,7 +327,7 @@ const DETAILS_SETTINGS_GROUP = {
     ...FORM_LAYOUT_PATH_SCHEMAS,
     "dataScope.filter": FILTER_GROUP_SCHEMA,
     "defaultSorting.sort": ARRAY_SCHEMA,
-    "linkageRules.value": ARRAY_SCHEMA
+    "linkageRules.value": LINKAGE_RULES_SCHEMA
   }
 };
 const FILTER_FORM_BLOCK_SETTINGS_GROUP = {
@@ -350,7 +354,7 @@ const BLOCK_CARD_SETTINGS_GROUP = {
     "titleDescription.description": STRING_SCHEMA,
     "blockHeight.heightMode": BLOCK_HEIGHT_MODE_SCHEMA,
     "blockHeight.height": NUMBER_SCHEMA,
-    "linkageRules.value": ARRAY_SCHEMA
+    "linkageRules.value": LINKAGE_RULES_SCHEMA
   }
 };
 const CALENDAR_SETTINGS_GROUP = {
@@ -484,6 +488,7 @@ const KANBAN_SETTINGS_GROUP = {
 const TABLE_SETTINGS_GROUP = {
   allowedPaths: [
     "quickEdit.editable",
+    "enableRowSelection.enableRowSelection",
     "showRowNumbers.showIndex",
     "pageSize.pageSize",
     "dataScope.filter",
@@ -496,6 +501,7 @@ const TABLE_SETTINGS_GROUP = {
   ],
   eventBindingSteps: [
     "quickEdit",
+    "enableRowSelection",
     "showRowNumbers",
     "pageSize",
     "dataScope",
@@ -508,6 +514,7 @@ const TABLE_SETTINGS_GROUP = {
   ],
   pathSchemas: {
     "quickEdit.editable": BOOLEAN_SCHEMA,
+    "enableRowSelection.enableRowSelection": BOOLEAN_SCHEMA,
     "showRowNumbers.showIndex": BOOLEAN_SCHEMA,
     "pageSize.pageSize": NUMBER_SCHEMA,
     "dataScope.filter": FILTER_GROUP_SCHEMA,
@@ -2188,7 +2195,7 @@ CALENDAR_READONLY_ACTION_CONTRACT.domains.stepParams = groupedDomain({
     mergeStrategy: "deep",
     eventBindingSteps: ["linkageRules"],
     pathSchemas: {
-      "linkageRules.value": ARRAY_SCHEMA
+      "linkageRules.value": LINKAGE_RULES_SCHEMA
     }
   }
 });
@@ -2441,16 +2448,26 @@ JS_ITEM_ACTION_CONTRACT.domains.stepParams = groupedDomain({
   jsSettings: RUN_JS_SETTINGS_GROUP
 });
 const AI_EMPLOYEE_ACTION_CONTRACT = createContract({
-  editableDomains: ["props"],
-  props: ["aiEmployee", "context", "auto", "tasks", "style"]
+  editableDomains: ["props", "stepParams"],
+  props: ["aiEmployee", "context", "auto", "style"],
+  stepParams: ["shortcutSettings"]
 });
-AI_EMPLOYEE_ACTION_CONTRACT.domains.props = keyedDomain(["aiEmployee", "context", "auto", "tasks", "style"], "deep", {
+AI_EMPLOYEE_ACTION_CONTRACT.domains.props = keyedDomain(["aiEmployee", "context", "auto", "style"], "deep", {
   aiEmployee: OBJECT_SCHEMA,
   context: OBJECT_SCHEMA,
   auto: BOOLEAN_SCHEMA,
-  tasks: ARRAY_SCHEMA,
   style: OBJECT_SCHEMA
 });
+AI_EMPLOYEE_ACTION_CONTRACT.domains.stepParams = groupedDomain({
+  shortcutSettings: {
+    allowedPaths: ["editTasks.tasks"],
+    mergeStrategy: "deep",
+    eventBindingSteps: ["editTasks"],
+    pathSchemas: {
+      "editTasks.tasks": ARRAY_SCHEMA
+    }
+  }
+});
 const APPROVAL_FORM_BLOCK_CONTRACT = createContract({
   editableDomains: ["props", "decoratorProps", "stepParams", "flowRegistry"],
   props: ["labelWidth", "labelWrap"],

package/dist/server/flow-surfaces/chart-config.js

@@ -64,6 +64,94 @@ __export(chart_config_exports, {
 module.exports = __toCommonJS(chart_config_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("./errors");
+var import_filter_group = require("./filter-group");
+const CHART_REPAIR_HINT = "This is a chart payload shape problem. Repair the current chart query/visual mappings and keep the chart block type. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const CHART_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "jsBlock",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop chart",
+  "defer chart"
+];
+const CHART_REPAIR_STEPS = [
+  "Keep the block type as chart.",
+  "Repair the chart query and visual mappings on the current chart payload.",
+  "Retry the chart payload instead of replacing the chart with another block type, omitting it, or deferring it."
+];
+const CHART_EXPECTED_SHAPE = {
+  settings: {
+    query: {
+      mode: "builder",
+      resource: {
+        dataSourceKey: "main",
+        collectionName: "employees"
+      },
+      measures: [
+        {
+          field: "id",
+          aggregation: "count",
+          alias: "employeeCount"
+        }
+      ]
+    },
+    visual: {
+      mode: "basic",
+      type: "bar",
+      mappings: {
+        x: "status",
+        y: "employeeCount"
+      }
+    }
+  }
+};
+function withChartRepairDetails(details = {}) {
+  return {
+    ...details,
+    requiredBlockType: "chart",
+    fixStrategy: "repair_same_block_type",
+    repairHint: CHART_REPAIR_HINT,
+    repairSteps: CHART_REPAIR_STEPS,
+    expectedShape: CHART_EXPECTED_SHAPE,
+    repairExample: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "<collectionName>"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "recordCount"
+            }
+          ],
+          dimensions: [
+            {
+              field: "<dimensionField>"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "<dimensionField>",
+            y: "recordCount"
+          }
+        }
+      }
+    },
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS
+  };
+}
+function withChartRepairMessage(message) {
+  return `${message}. ${CHART_REPAIR_HINT}`;
+}
 const CHART_DEFAULT_DATA_SOURCE_KEY = "main";
 const CHART_QUERY_MODES = ["builder", "sql"];
 const CHART_VISUAL_MODES = ["basic", "custom"];
@@ -82,10 +170,6 @@ const CHART_SORT_DIRECTIONS = ["asc", "desc"];
 const CHART_SORT_NULLS = ["default", "first", "last"];
 const CHART_LABEL_TYPES = ["value", "percent"];
 const CHART_FUNNEL_SORTS = ["descending", "ascending"];
-const EMPTY_FILTER_GROUP = {
-  logic: "$and",
-  items: []
-};
 const CHART_SAFE_DEFAULT_HINTS = [
   {
     key: "builder_basic_minimal",
@@ -371,6 +455,17 @@ function normalizeFieldPathValue(input, label, options = {}) {
   }
   throw new import_errors.FlowSurfaceBadRequestError(`${label} must be a string or string[]`);
 }
+function normalizeChartQueryFieldPathValue(input, label, options = {}) {
+  const normalized = normalizeFieldPathValue(input, label, options);
+  if (typeof normalized !== "string" || !normalized.includes(".")) {
+    return normalized;
+  }
+  const segments = normalized.split(".").map((segment) => segment.trim());
+  if (segments.some((segment) => !segment)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label} cannot contain empty path segments`);
+  }
+  return segments;
+}
 function aliasOfFieldValue(input) {
   if (Array.isArray(input)) {
     return input.filter(Boolean).map((item) => String(item)).join(".");
@@ -402,7 +497,7 @@ function fromPersistedOrder(input) {
   return CHART_SORT_DIRECTION_SET.has(normalized) ? normalized : void 0;
 }
 function createEmptyFilterGroup() {
-  return import_lodash.default.cloneDeep(EMPTY_FILTER_GROUP);
+  return import_lodash.default.cloneDeep(import_filter_group.FLOW_SURFACE_EMPTY_FILTER_GROUP);
 }
 function assertAllowedKeys(input, allowed, label) {
   const unknownKeys = Object.keys(input).filter((key) => !allowed.has(key));
@@ -478,25 +573,29 @@ function normalizeMergedChartResource(query, options = {}) {
 function normalizeChartMeasure(input, index) {
   const label = `chart query.measures[${index}]`;
   const normalized = ensurePlainObject(input, label);
+  const field = normalizeChartQueryFieldPathValue(normalized.field, `${label}.field`, { required: true });
+  const alias = normalizeOptionalTrimmedString(normalized.alias, `${label}.alias`);
   const aggregation = normalizeOptionalEnumValue(
     normalized.aggregation,
     CHART_QUERY_AGGREGATION_SET,
     `${label}.aggregation`
   );
   return buildDefinedObject({
-    field: normalizeFieldPathValue(normalized.field, `${label}.field`, { required: true }),
+    field,
     aggregation,
-    alias: normalizeOptionalTrimmedString(normalized.alias, `${label}.alias`),
+    alias: alias || (Array.isArray(field) && field.length > 1 ? aliasOfFieldValue(field) : void 0),
     distinct: normalizeOptionalBoolean(normalized.distinct, `${label}.distinct`)
   });
 }
 function normalizeChartDimension(input, index) {
   const label = `chart query.dimensions[${index}]`;
   const normalized = ensurePlainObject(input, label);
+  const field = normalizeChartQueryFieldPathValue(normalized.field, `${label}.field`, { required: true });
+  const alias = normalizeOptionalTrimmedString(normalized.alias, `${label}.alias`);
   return buildDefinedObject({
-    field: normalizeFieldPathValue(normalized.field, `${label}.field`, { required: true }),
+    field,
     format: normalizeOptionalTrimmedString(normalized.format, `${label}.format`),
-    alias: normalizeOptionalTrimmedString(normalized.alias, `${label}.alias`)
+    alias: alias || (Array.isArray(field) && field.length > 1 ? aliasOfFieldValue(field) : void 0)
   });
 }
 function normalizeBuilderCountMeasureFieldForRuntime(measure, dimensions) {
@@ -507,6 +606,12 @@ function normalizeBuilderCountMeasureFieldForRuntime(measure, dimensions) {
   if (!fallbackDimension) {
     return measure;
   }
+  if (Array.isArray(fallbackDimension.field) && fallbackDimension.field.length > 1) {
+    return measure;
+  }
+  if (typeof fallbackDimension.field === "string" && fallbackDimension.field.includes(".")) {
+    return measure;
+  }
   return {
     ...measure,
     field: import_lodash.default.cloneDeep(fallbackDimension.field)
@@ -521,18 +626,113 @@ function normalizeChartSortingItem(input, index) {
     `${label}.${hasOwn(normalized, "direction") ? "direction" : "order"}`
   );
   return buildDefinedObject({
-    field: normalizeFieldPathValue(normalized.field, `${label}.field`, { required: true }),
+    field: normalizeChartQueryFieldPathValue(normalized.field, `${label}.field`, { required: true }),
     order: toPersistedOrder(direction),
     nulls: normalizeOptionalEnumValue(normalized.nulls, CHART_SORT_NULLS_SET, `${label}.nulls`)
   });
 }
+function isFilterGroupLike(input) {
+  return import_lodash.default.isPlainObject(input) && isBackendQueryLogicKey(input.logic) && Array.isArray(input.items);
+}
+function assertFilterGroupKeys(input, label) {
+  if (!isFilterGroupLike(input)) {
+    return;
+  }
+  const unsupportedKeys = Object.keys(input).filter((key) => key !== "logic" && key !== "items");
+  if (unsupportedKeys.length) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label} does not support: ${unsupportedKeys.join(", ")}`);
+  }
+  if (Array.isArray(input.items)) {
+    input.items.forEach((item, index) => {
+      assertFilterGroupKeys(item, `${label}.items[${index}]`);
+    });
+  }
+}
+function isBackendQueryLogicKey(key) {
+  return key === "$and" || key === "$or";
+}
+function getBackendQueryLogicKey(input, label) {
+  const keys = Object.keys(input);
+  const logicKeys = keys.filter(isBackendQueryLogicKey);
+  if (!logicKeys.length) {
+    return void 0;
+  }
+  if (logicKeys.length > 1 || keys.length > 1) {
+    throw new import_errors.FlowSurfaceBadRequestError(
+      `${label}: cannot convert backend query filter with mixed logical and field conditions`
+    );
+  }
+  return logicKeys[0];
+}
+function convertBackendFieldConditionToFilterItems(field, condition, label) {
+  if (!field.trim() || field.startsWith("$")) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}: cannot convert backend query filter field "${field}"`);
+  }
+  if (!import_lodash.default.isPlainObject(condition)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}.${field}: backend query filter condition must be an object`);
+  }
+  const operators = Object.keys(condition);
+  if (!operators.length) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}.${field}: backend query filter condition cannot be empty`);
+  }
+  return operators.map((operator) => {
+    if (!operator.startsWith("$")) {
+      (0, import_filter_group.assertFlowSurfaceFilterOperator)(operator, `${label}.${field}.${operator}`);
+    }
+    if (!operator.startsWith("$") || isBackendQueryLogicKey(operator)) {
+      throw new import_errors.FlowSurfaceBadRequestError(
+        `${label}.${field}: cannot convert backend query filter operator "${operator}"`
+      );
+    }
+    return {
+      path: field,
+      operator,
+      value: import_lodash.default.cloneDeep(condition[operator])
+    };
+  });
+}
+function convertBackendQueryFilterToFilterGroup(input, label) {
+  const logicKey = getBackendQueryLogicKey(input, label);
+  if (logicKey) {
+    const operands = input[logicKey];
+    if (!Array.isArray(operands)) {
+      throw new import_errors.FlowSurfaceBadRequestError(`${label}.${logicKey}: backend query filter operands must be an array`);
+    }
+    return {
+      logic: logicKey,
+      items: operands.map(
+        (operand, index) => convertBackendQueryOperandToFilterItem(operand, `${label}.${logicKey}[${index}]`)
+      )
+    };
+  }
+  return {
+    logic: "$and",
+    items: Object.entries(input).flatMap(
+      ([field, condition]) => convertBackendFieldConditionToFilterItems(field, condition, label)
+    )
+  };
+}
+function convertBackendQueryOperandToFilterItem(input, label) {
+  if (isFilterGroupLike(input)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}: cannot mix filter groups with backend query filters`);
+  }
+  const group = convertBackendQueryFilterToFilterGroup(ensurePlainObject(input, label), label);
+  if (group.logic === "$and" && group.items.length === 1) {
+    return group.items[0];
+  }
+  return group;
+}
 function normalizeFilterGroupValue(input, label) {
   if (import_lodash.default.isUndefined(input) || import_lodash.default.isNull(input)) {
     return void 0;
   }
   const normalized = ensurePlainObject(input, label);
-  validateFilterGroupPaths(normalized, label);
-  return import_lodash.default.cloneDeep(normalized);
+  assertFilterGroupKeys(normalized, label);
+  const filterGroup = !Object.keys(normalized).length || isFilterGroupLike(normalized) ? (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(normalized, label, { strictDateValues: true }) : (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(convertBackendQueryFilterToFilterGroup(normalized, label), label, {
+    strictDateValues: true
+  });
+  validateFilterGroupPaths(filterGroup, label);
+  return filterGroup;
 }
 function validateFilterGroupPaths(input, label) {
   const items = Array.isArray(input == null ? void 0 : input.items) ? input.items : [];
@@ -564,6 +764,7 @@ function inferQueryMode(query) {
 }
 function validateLooseChartQuery(query) {
   inferQueryMode(query);
+  validateChartQueryFilterOperators(query);
   if (!hasOwn(query, "resource") || !hasOwn(query, "collectionPath")) {
     return;
   }
@@ -578,6 +779,11 @@ function validateLooseChartQuery(query) {
     );
   }
 }
+function validateChartQueryFilterOperators(query) {
+  if (hasOwn(query, "filter")) {
+    normalizeFilterGroupValue(query.filter, "chart query.filter");
+  }
+}
 function canStrictNormalizeChartQuery(query) {
   validateLooseChartQuery(query);
   const mode = inferQueryMode(query);
@@ -601,7 +807,10 @@ function mergeChartQuerySection(current, patch) {
   const nextMode = inferQueryMode(normalizedPatch);
   const modeChanged = currentMode && currentMode !== nextMode;
   const base = modeChanged ? {} : current || {};
-  const merged = mergeReplaceArrays(base, normalizedPatch);
+  const merged = mergeReplaceArrays(base, import_lodash.default.omit(normalizedPatch, ["filter"]));
+  if (hasOwn(normalizedPatch, "filter")) {
+    merged.filter = import_lodash.default.cloneDeep(normalizedPatch.filter);
+  }
   if (nextMode !== "builder") {
     return merged;
   }
@@ -1083,7 +1292,15 @@ function assertBasicVisualMappingsAgainstBuilderQuery(builderVisual, query) {
   for (const value of mappingValues) {
     if (!value || !allowedOutputs.has(value)) {
       throw new import_errors.FlowSurfaceBadRequestError(
-        `chart visual mappings only support query output fields: ${Array.from(allowedOutputs).join(", ")}`
+        withChartRepairMessage(
+          `chart visual mappings only support query output fields: ${Array.from(allowedOutputs).join(", ")}`
+        ),
+        void 0,
+        {
+          details: withChartRepairDetails({
+            allowedOutputs: Array.from(allowedOutputs)
+          })
+        }
       );
     }
   }

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

@@ -31,6 +31,8 @@ export type FlowSurfaceComposeNormalizedFieldSpec = {
     pageSize?: number;
     showIndex?: boolean;
     target?: string | Record<string, unknown>;
+    defaultTargetUid?: string;
+    targetBlockUid?: string;
     settings?: FlowSurfaceComposeObject;
     popup?: FlowSurfaceComposeObject;
     __autoPopupForRelationField?: boolean;

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

@@ -130,6 +130,8 @@ function buildComposeFieldCreatePayload(fieldSpec) {
     ...fieldSpec.popupSize ? { popupSize: fieldSpec.popupSize } : {},
     ...typeof fieldSpec.pageSize !== "undefined" ? { pageSize: fieldSpec.pageSize } : {},
     ...typeof fieldSpec.showIndex !== "undefined" ? { showIndex: fieldSpec.showIndex } : {},
+    ...fieldSpec.defaultTargetUid ? { defaultTargetUid: fieldSpec.defaultTargetUid } : {},
+    ...fieldSpec.targetBlockUid ? { targetBlockUid: fieldSpec.targetBlockUid } : {},
     ...fieldSpec.popup ? { popup: fieldSpec.popup } : {},
     ...fieldSpec.__autoPopupForRelationField ? { __autoPopupForRelationField: true } : {},
     ...fieldSpec[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY] ? {

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

@@ -150,6 +150,8 @@ async function createFields(plan, deps, state) {
   for (const fieldTask of plan.fields) {
     const block = requireBlockState(fieldTask.blockKey, state);
     const targetUid = fieldTask.containerSource === "item" ? block.result.itemUid || block.result.uid : block.result.uid;
+    const targetKey = readComposeFieldTargetKey(fieldTask.spec.target);
+    const resolvedTargetUid = targetKey ? (0, import_compose_compiler.resolveComposeTargetKey)(targetKey, state.keyMap, "field") : fieldTask.spec.defaultTargetUid || fieldTask.spec.targetBlockUid;
     let createdField;
     try {
       createdField = await deps.createField(
@@ -158,13 +160,8 @@ async function createFields(plan, deps, state) {
             uid: targetUid
           },
           ...fieldTask.payload,
-          ...readComposeFieldTargetKey(fieldTask.spec.target) ? {
-            defaultTargetUid: (0, import_compose_compiler.resolveComposeTargetKey)(
-              readComposeFieldTargetKey(fieldTask.spec.target),
-              state.keyMap,
-              "field"
-            )
-          } : {}
+          ...resolvedTargetUid ? { defaultTargetUid: resolvedTargetUid } : {},
+          ...fieldTask.spec.targetBlockUid ? { targetBlockUid: fieldTask.spec.targetBlockUid } : {}
         },
         fieldTask.spec,
         block.result

package/dist/server/flow-surfaces/configure-options.js

@@ -163,6 +163,7 @@ const TABLE_OPTIONS = {
   resource: COMMON_RESOURCE,
   pageSize: numberOption("Page size", { example: 20 }),
   density: stringOption("Table density", { enum: ["large", "middle", "small"], example: "middle" }),
+  enableRowSelection: booleanOption("Whether to enable row selection checkboxes", { example: true }),
   showRowNumbers: booleanOption("Whether to display row numbers", { example: true }),
   sorting: SORTING,
   dataScope: FILTER_GROUP,
@@ -518,8 +519,15 @@ const FIELD_NODE_OPTIONS = {
   displayStyle: DISPLAY_STYLE,
   options: objectOption("Component options")
 };
+function omitConfigureOptions(options, keys) {
+  const next = { ...options };
+  for (const key of keys) {
+    delete next[key];
+  }
+  return next;
+}
 const JS_FIELD_NODE_OPTIONS = {
-  ...FIELD_NODE_OPTIONS,
+  ...omitConfigureOptions(FIELD_NODE_OPTIONS, ["openView"]),
   code: JS_CODE,
   version: JS_VERSION
 };
@@ -632,20 +640,23 @@ const ACTION_EMAIL_OPTIONS = {
 const ACTION_AI_EMPLOYEE_OPTIONS = {
   username: stringOption("AI employee username", { example: "dex" }),
   auto: booleanOption("Whether the single configured task is prepared automatically", { example: false }),
-  workContext: arrayOption("Top-level AI work context. Use target=self or a same-blueprint block key before write.", {
-    example: [{ type: "flow-model", target: "self" }]
-  }),
-  tasks: arrayOption("AI employee task definitions", {
+  workContext: arrayOption(
+    "Top-level AI work context. Use target=self or a same-blueprint block key before write; type defaults to flow-model.",
+    {
+      example: [{ target: "self" }]
+    }
+  ),
+  tasks: arrayOption("AI employee task definitions. prompt is accepted as an alias for message.user.", {
     example: [
       {
         title: "Analyze current record",
+        prompt: "Analyze the current record and suggest next steps.",
         message: {
           system: "Use the current UI context.",
-          user: "Analyze the current record and suggest next steps.",
-          workContext: [{ type: "flow-model", target: "self" }]
+          workContext: [{ target: "self" }]
         },
         autoSend: false,
-        skillSettings: { skills: [], tools: [] },
+        skillSettings: null,
         model: null,
         webSearch: false
       }