@nocobase/plugin-flow-engine 2.1.0-beta.36 → 2.1.0-beta.37

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

@@ -297,6 +297,85 @@ const AST_CTX_METHOD_NAMES = /* @__PURE__ */ new Set(["runjs", "makeResource", "
 const REACT_NODE_COMPONENT_PROP_NAMES = /* @__PURE__ */ new Set(["avatar", "extra", "icon", "prefix", "suffix"]);
 const CANONICAL_CTX_LIB_MEMBERS = ["React", "ReactDOM", "antd", "dayjs", "antdIcons", "lodash", "formula", "math"];
 const CTX_LIB_MEMBER_BY_LOWERCASE = new Map(CANONICAL_CTX_LIB_MEMBERS.map((member) => [member.toLowerCase(), member]));
+const RUNJS_CTX_LIB_ANTD_ALLOWED_MEMBERS = /* @__PURE__ */ new Set([
+  "Affix",
+  "Alert",
+  "Anchor",
+  "App",
+  "AutoComplete",
+  "Avatar",
+  "BackTop",
+  "Badge",
+  "Breadcrumb",
+  "Button",
+  "Calendar",
+  "Card",
+  "Carousel",
+  "Cascader",
+  "Checkbox",
+  "Col",
+  "Collapse",
+  "ColorPicker",
+  "ConfigProvider",
+  "DatePicker",
+  "Descriptions",
+  "Divider",
+  "Drawer",
+  "Dropdown",
+  "Empty",
+  "Flex",
+  "FloatButton",
+  "Form",
+  "Grid",
+  "Image",
+  "Input",
+  "InputNumber",
+  "Layout",
+  "List",
+  "Mentions",
+  "Menu",
+  "Modal",
+  "Pagination",
+  "Popconfirm",
+  "Popover",
+  "Progress",
+  "QRCode",
+  "Radio",
+  "Rate",
+  "Result",
+  "Row",
+  "Segmented",
+  "Select",
+  "Skeleton",
+  "Slider",
+  "Space",
+  "Spin",
+  "Splitter",
+  "Statistic",
+  "Steps",
+  "Switch",
+  "Table",
+  "Tabs",
+  "Tag",
+  "TimePicker",
+  "Timeline",
+  "Tooltip",
+  "Tour",
+  "Transfer",
+  "Tree",
+  "TreeSelect",
+  "Typography",
+  "Upload",
+  "Watermark",
+  "message",
+  "notification",
+  "theme",
+  "unstableSetRender",
+  "version"
+]);
+const RUNJS_CTX_LIB_ALLOWED_MEMBERS_BY_LIBRARY = /* @__PURE__ */ new Map([
+  ["antd", RUNJS_CTX_LIB_ANTD_ALLOWED_MEMBERS]
+]);
 const RUNJS_CTX_API_ALLOWED_MEMBERS = /* @__PURE__ */ new Set(["auth", "request", "resource"]);
 const RUNJS_CTX_API_AUTH_ALLOWED_MEMBERS = /* @__PURE__ */ new Set(["authenticator", "locale", "role", "token"]);
 const RUNJS_RESOURCE_METHODS = /* @__PURE__ */ new Set(["list", "get", "create", "update", "destroy"]);
@@ -382,7 +461,6 @@ const MULTI_RECORD_RESOURCE_METHODS = unionMethodSets([
     "setUpdateActionOptions",
     "setSelectedRows",
     "getSelectedRows",
-    "getCount",
     "setPage",
     "getPage",
     "setPageSize",
@@ -437,7 +515,10 @@ const FLOW_RESOURCE_METHODS_BY_TYPE = {
   SQLResource: SQL_RESOURCE_METHODS
 };
 const UNKNOWN_FLOW_RESOURCE_METHODS = unionMethodSets(Object.values(FLOW_RESOURCE_METHODS_BY_TYPE));
-const FLOW_RESOURCE_METHOD_SUGGESTIONS = /* @__PURE__ */ new Map([["setFilters", "setFilter"]]);
+const FLOW_RESOURCE_METHOD_SUGGESTIONS = /* @__PURE__ */ new Map([
+  ["setFilters", "setFilter"],
+  ["getCount", "getData"]
+]);
 const CONTEXT_FIRST_REPAIR_CLASSES = /* @__PURE__ */ new Set([
   "unknown-surface-stop",
   "unknown-model-stop",
@@ -1720,6 +1801,28 @@ function collectCtxContractErrors(path, source, scan, modelUse, surface, errors)
       })
     );
   });
+  scan.invalidCtxLibMemberAccesses.forEach((entry) => {
+    const importHint = entry.suggestedImport ? `; import it with await ctx.importAsync('${entry.suggestedImport}') instead` : "";
+    errors.push(
+      buildRunJsAuthoringError({
+        path,
+        repairClass: "ctx-libs-member-mismatch-stop",
+        ruleId: entry.ruleId,
+        message: `flowSurfaces authoring ${path} ${entry.capability} is not a supported RunJS ctx.libs.${entry.library} member${importHint}`,
+        modelUse,
+        surface,
+        index: entry.index,
+        source,
+        details: {
+          accessKind: entry.accessKind,
+          capability: entry.capability,
+          library: entry.library,
+          member: entry.member,
+          suggestedImport: entry.suggestedImport
+        }
+      })
+    );
+  });
   scan.invalidCtxApiMemberAccesses.forEach((entry) => {
     const message = entry.ruleId === "runjs-ctx-api-member-dynamic-unresolved" ? `flowSurfaces authoring ${path} cannot validate dynamic ${entry.capability} access` : entry.ruleId === "runjs-ctx-api-auth-member-readonly" ? `flowSurfaces authoring ${path} cannot write readonly RunJS ${entry.capability}; read ctx.api.auth.locale, role, token, or authenticator without mutating them` : entry.ruleId === "runjs-ctx-api-auth-member-unsupported" ? `flowSurfaces authoring ${path} ${entry.capability} is not a supported RunJS ctx.api.auth member; read ctx.api.auth.locale, role, token, or authenticator instead` : `flowSurfaces authoring ${path} ${entry.capability} is not a supported RunJS ctx.api member; use ctx.request(...), ctx.api.request(...), ctx.api.resource(...), or readonly ctx.api.auth fields`;
     errors.push(
@@ -1867,6 +1970,7 @@ function scanJavaScriptSource(source, ast, context = {}) {
     ctxAliases,
     ctxLibMemberCaseMismatches: collectCtxLibMemberCaseMismatches(source, masked, sourceBindings),
     invalidCtxApiMemberAccesses: (astInspection == null ? void 0 : astInspection.invalidCtxApiMemberAccesses) || [],
+    invalidCtxLibMemberAccesses: (astInspection == null ? void 0 : astInspection.invalidCtxLibMemberAccesses) || [],
     forbiddenBareGlobals,
     ctxMemberAccesses: collectCtxMemberAccesses(masked, sourceBindings),
     dynamicCtxAccesses: findUnboundCtxMatches(masked, /\bctx\s*(?:\?\.\s*)?\[/g, sourceBindings),
@@ -1877,6 +1981,8 @@ function inspectRunJsAst(ast, source, stringBindings, context = {}) {
   const identifierBindings = collectAstIdentifierBindingsFromAst(ast, source);
   const aliases = collectCtxMethodAliasesFromAst(ast, source, identifierBindings);
   const ctxApiAliases = collectCtxApiAliasesFromAst(ast, source, identifierBindings);
+  const ctxLibsRootAliases = collectCtxLibsRootAliasesFromAst(ast, source, identifierBindings);
+  const ctxLibAliases = collectCtxLibAliasesFromAst(ast, source, ctxLibsRootAliases, identifierBindings);
   const ctxApiResourceAliases = collectCtxApiResourceAliasesFromAst(ast, source, ctxApiAliases, identifierBindings);
   const reactNamespaceAliases = collectReactNamespaceAliasesFromAst(ast, source, identifierBindings);
   const reactCreateElementAliases = collectReactCreateElementAliasesFromAst(
@@ -1898,6 +2004,9 @@ function inspectRunJsAst(ast, source, stringBindings, context = {}) {
   const invalidCtxApiMemberAccesses = [
     ...collectAstInvalidCtxApiPatternAccesses(ast, ctxApiAliases, identifierBindings)
   ];
+  const invalidCtxLibMemberAccesses = [
+    ...collectAstInvalidCtxLibPatternAccesses(ast, ctxLibAliases, ctxLibsRootAliases, identifierBindings, source)
+  ];
   const invalidApiResourceCalls = [];
   const invalidResourceTypeCalls = [];
   const invalidFlowResourceListCalls = [];
@@ -1963,6 +2072,16 @@ function inspectRunJsAst(ast, source, stringBindings, context = {}) {
       ).forEach((entry) => reactAsyncComponentReferences.push(entry));
     },
     MemberExpression(node) {
+      const invalidCtxLibAccess = collectAstInvalidCtxLibMemberAccess(
+        node,
+        ctxLibAliases,
+        ctxLibsRootAliases,
+        identifierBindings,
+        source
+      );
+      if (invalidCtxLibAccess) {
+        invalidCtxLibMemberAccesses.push(invalidCtxLibAccess);
+      }
       const invalidCtxApiAccess = collectAstInvalidCtxApiMemberAccess(node, ctxApiAliases, identifierBindings, source);
       if (invalidCtxApiAccess) {
         invalidCtxApiMemberAccesses.push(invalidCtxApiAccess);
@@ -2006,6 +2125,9 @@ function inspectRunJsAst(ast, source, stringBindings, context = {}) {
       dedupeIndexedEntries(invalidCtxApiMemberAccesses),
       dedupedInvalidApiResourceCalls
     ).sort((left, right) => left.index - right.index),
+    invalidCtxLibMemberAccesses: dedupeIndexedEntries(invalidCtxLibMemberAccesses).sort(
+      (left, right) => left.index - right.index
+    ),
     invalidResourceTypeCalls: dedupeAstResourceEntries(invalidResourceTypeCalls),
     invalidFlowResourceListCalls: dedupeIndexedEntries(invalidFlowResourceListCalls).sort(
       (left, right) => left.index - right.index
@@ -2150,6 +2272,117 @@ function collectCtxApiObjectPatternAliases(pattern, capability, addAlias) {
 function trimCtxApiAliasesAfterWrites(aliases, writes, identifierBindings) {
   return trimAstAliasesAfterWrites(aliases, writes, identifierBindings);
 }
+function collectCtxLibsRootAliasesFromAst(ast, source, identifierBindings) {
+  const aliases = [];
+  const writes = collectAstIdentifierWritesFromAst(ast, source);
+  const addAlias = (name, node, ancestors, isVar = false) => {
+    const scope = getAstBindingScopeRange(ancestors, source.length, isVar);
+    aliases.push({
+      capability: "ctx.libs",
+      declarationStart: typeof (node == null ? void 0 : node.start) === "number" ? node.start : scope.start,
+      executionScope: getAstExecutionScopeRange(ancestors, source.length),
+      name,
+      start: typeof (node == null ? void 0 : node.start) === "number" ? node.start : scope.start,
+      end: scope.end
+    });
+  };
+  const getActiveAliases = () => trimAstAliasesAfterWrites(aliases, writes, identifierBindings);
+  walkAstAncestor(ast, {
+    AssignmentExpression(node, ancestors) {
+      var _a;
+      if (!isAstCtxApiAliasAssignmentOperator(node.operator)) {
+        return;
+      }
+      if (((_a = node.left) == null ? void 0 : _a.type) === "Identifier" && isCtxLibsRootFromAst(node.right, getActiveAliases(), identifierBindings)) {
+        addAlias(node.left.name, node, ancestors);
+      }
+    },
+    VariableDeclarator(node, ancestors) {
+      var _a;
+      if (((_a = node.id) == null ? void 0 : _a.type) !== "Identifier" || !isCtxLibsRootFromAst(node.init, getActiveAliases(), identifierBindings)) {
+        return;
+      }
+      const declaration = findAstAncestor(ancestors, "VariableDeclaration");
+      addAlias(node.id.name, node, ancestors, (declaration == null ? void 0 : declaration.kind) === "var");
+    }
+  });
+  return trimAstAliasesAfterWrites(aliases, writes, identifierBindings);
+}
+function collectCtxLibAliasesFromAst(ast, source, rootAliases, identifierBindings) {
+  const aliases = [];
+  const writes = collectAstIdentifierWritesFromAst(ast, source);
+  const addAlias = (name, library, capability, node, ancestors, isVar = false) => {
+    const scope = getAstBindingScopeRange(ancestors, source.length, isVar);
+    aliases.push({
+      capability,
+      declarationStart: typeof (node == null ? void 0 : node.start) === "number" ? node.start : scope.start,
+      executionScope: getAstExecutionScopeRange(ancestors, source.length),
+      library,
+      name,
+      start: typeof (node == null ? void 0 : node.start) === "number" ? node.start : scope.start,
+      end: scope.end
+    });
+  };
+  const getActiveAliases = () => trimAstAliasesAfterWrites(aliases, writes, identifierBindings);
+  walkAstAncestor(ast, {
+    AssignmentExpression(node, ancestors) {
+      var _a, _b;
+      if (!isAstCtxApiAliasAssignmentOperator(node.operator)) {
+        return;
+      }
+      const activeAliases = getActiveAliases();
+      const sourcePath = getCtxLibMemberPathFromAst(node.right, activeAliases, rootAliases, identifierBindings, source);
+      if (((_a = node.left) == null ? void 0 : _a.type) === "Identifier" && sourcePath && !sourcePath.hasDynamicMember && !sourcePath.members.length) {
+        addAlias(node.left.name, sourcePath.library, sourcePath.rootCapability, node, ancestors);
+        return;
+      }
+      if (node.operator === "=" && ((_b = node.left) == null ? void 0 : _b.type) === "ObjectPattern") {
+        collectCtxLibObjectPatternAliases(
+          node.left,
+          node.right,
+          rootAliases,
+          identifierBindings,
+          (name, alias, aliasNode) => {
+            addAlias(name, alias.library, alias.capability, aliasNode || node, ancestors);
+          }
+        );
+      }
+    },
+    VariableDeclarator(node, ancestors) {
+      var _a, _b;
+      const declaration = findAstAncestor(ancestors, "VariableDeclaration");
+      const isVar = (declaration == null ? void 0 : declaration.kind) === "var";
+      const activeAliases = getActiveAliases();
+      const sourcePath = getCtxLibMemberPathFromAst(node.init, activeAliases, rootAliases, identifierBindings, source);
+      if (((_a = node.id) == null ? void 0 : _a.type) === "Identifier" && sourcePath && !sourcePath.hasDynamicMember && !sourcePath.members.length) {
+        addAlias(node.id.name, sourcePath.library, sourcePath.rootCapability, node, ancestors, isVar);
+        return;
+      }
+      if (((_b = node.id) == null ? void 0 : _b.type) === "ObjectPattern") {
+        collectCtxLibObjectPatternAliases(
+          node.id,
+          node.init,
+          rootAliases,
+          identifierBindings,
+          (name, alias, aliasNode) => {
+            addAlias(name, alias.library, alias.capability, aliasNode || node, ancestors, isVar);
+          }
+        );
+      }
+    }
+  });
+  return trimAstAliasesAfterWrites(aliases, writes, identifierBindings);
+}
+function collectCtxLibObjectPatternAliases(pattern, sourceNode, rootAliases, identifierBindings, addAlias) {
+  if (!isCtxLibsRootFromAst(sourceNode, rootAliases, identifierBindings)) {
+    return;
+  }
+  collectAstObjectPatternAliases(pattern, (name, member, aliasNode) => {
+    if (member) {
+      addAlias(name, { capability: `ctx.libs.${member}`, library: member }, aliasNode);
+    }
+  });
+}
 function trimAstAliasesAfterWrites(aliases, writes, identifierBindings) {
   return aliases.map((alias) => {
     const aliasDeclarationStart = alias.declarationStart ?? alias.start;
@@ -4199,6 +4432,183 @@ function getSuggestedFlowResourceMethod(method) {
 function isKnownFlowResourceInstanceType(value) {
   return value in FLOW_RESOURCE_METHODS_BY_TYPE;
 }
+function collectAstInvalidCtxLibPatternAccesses(ast, aliases, rootAliases, identifierBindings, source) {
+  const entries = [];
+  const collectPattern = (pattern, sourceNode) => {
+    const sourcePath = getCtxLibMemberPathFromAst(sourceNode, aliases, rootAliases, identifierBindings, source);
+    if (!sourcePath || sourcePath.hasDynamicMember || sourcePath.members.length) {
+      return;
+    }
+    collectInvalidCtxLibObjectPatternAccesses(pattern, sourcePath).forEach((entry) => entries.push(entry));
+  };
+  walkAstAncestor(ast, {
+    AssignmentExpression(node) {
+      var _a;
+      if (node.operator !== "=" || ((_a = node.left) == null ? void 0 : _a.type) !== "ObjectPattern") {
+        return;
+      }
+      collectPattern(node.left, node.right);
+    },
+    VariableDeclarator(node) {
+      var _a;
+      if (((_a = node.id) == null ? void 0 : _a.type) !== "ObjectPattern") {
+        return;
+      }
+      collectPattern(node.id, node.init);
+    }
+  });
+  return dedupeIndexedEntries(entries);
+}
+function collectInvalidCtxLibObjectPatternAccesses(pattern, sourcePath) {
+  var _a;
+  const entries = [];
+  for (const property of (pattern == null ? void 0 : pattern.properties) || []) {
+    if (!property || property.type !== "Property") {
+      continue;
+    }
+    const member = getAstStaticPropertyName(property);
+    if (!member) {
+      continue;
+    }
+    const invalidAccess = buildInvalidCtxLibMemberAccess({
+      ...sourcePath,
+      members: [
+        {
+          accessKind: "destructure",
+          index: typeof ((_a = property.key) == null ? void 0 : _a.start) === "number" ? property.key.start : property.start || 0,
+          name: member
+        }
+      ]
+    });
+    if (invalidAccess) {
+      entries.push(invalidAccess);
+    }
+  }
+  return entries;
+}
+function collectAstInvalidCtxLibMemberAccess(node, aliases, rootAliases, identifierBindings, source) {
+  const path = getCtxLibMemberPathFromAst(node, aliases, rootAliases, identifierBindings, source);
+  if (!path || path.hasDynamicMember || !path.members.length) {
+    return void 0;
+  }
+  return buildInvalidCtxLibMemberAccess(path);
+}
+function buildInvalidCtxLibMemberAccess(path) {
+  const allowedMembers = RUNJS_CTX_LIB_ALLOWED_MEMBERS_BY_LIBRARY.get(path.library);
+  const member = path.members[0];
+  if (!allowedMembers || !member || allowedMembers.has(member.name)) {
+    return void 0;
+  }
+  return {
+    accessKind: member.accessKind,
+    capability: getCtxLibMemberCapability(path.rootCapability, member),
+    index: member.index,
+    library: path.library,
+    member: member.name,
+    ruleId: "runjs-ctx-libs-member-unknown",
+    suggestedImport: getSuggestedCtxLibMemberImport(path.library, member.name)
+  };
+}
+function getCtxLibMemberCapability(rootCapability, member) {
+  return member.accessKind === "bracket" ? `${rootCapability}[${JSON.stringify(member.name)}]` : `${rootCapability}.${member.name}`;
+}
+function getSuggestedCtxLibMemberImport(library, member) {
+  if (library === "antd" && member === "colors") {
+    return "@ant-design/colors";
+  }
+  return void 0;
+}
+function getCtxLibMemberPathFromAst(node, aliases, rootAliases, identifierBindings, source) {
+  var _a;
+  const unwrapped = unwrapAstChainExpression(node);
+  if (!unwrapped) {
+    return void 0;
+  }
+  if (unwrapped.type === "Identifier") {
+    const alias = resolveAstAliasBinding(unwrapped.name, unwrapped.start || 0, aliases, identifierBindings);
+    if (!alias) {
+      return void 0;
+    }
+    const index = typeof unwrapped.start === "number" ? unwrapped.start : alias.start;
+    return {
+      dynamicIndex: index,
+      hasDynamicMember: false,
+      library: alias.library,
+      libraryIndex: index,
+      memberIndex: index,
+      members: [],
+      rootCapability: alias.capability
+    };
+  }
+  if (unwrapped.type !== "MemberExpression") {
+    return void 0;
+  }
+  const objectPath = getCtxLibMemberPathFromAst(unwrapped.object, aliases, rootAliases, identifierBindings, source);
+  if (objectPath) {
+    const propertyName = getAstStaticPropertyName(unwrapped);
+    const propertyIndex = typeof ((_a = unwrapped.property) == null ? void 0 : _a.start) === "number" ? unwrapped.property.start : unwrapped.start || 0;
+    return {
+      ...objectPath,
+      dynamicIndex: propertyName ? objectPath.dynamicIndex : propertyIndex,
+      hasDynamicMember: objectPath.hasDynamicMember || !propertyName,
+      memberIndex: objectPath.members.length ? objectPath.memberIndex : propertyIndex,
+      members: propertyName ? [
+        ...objectPath.members,
+        {
+          accessKind: unwrapped.computed ? "bracket" : "member",
+          index: propertyIndex,
+          name: propertyName
+        }
+      ] : objectPath.members
+    };
+  }
+  return getDirectCtxLibPathFromAst(unwrapped, rootAliases, identifierBindings, source);
+}
+function getDirectCtxLibPathFromAst(node, rootAliases, identifierBindings, source) {
+  var _a;
+  const member = unwrapAstChainExpression(node);
+  if (!member || member.type !== "MemberExpression") {
+    return void 0;
+  }
+  const propertyName = getAstStaticPropertyName(member);
+  if (!propertyName) {
+    return void 0;
+  }
+  const propertyIndex = typeof ((_a = member.property) == null ? void 0 : _a.start) === "number" ? member.property.start : member.start || 0;
+  if (isCtxLibsRootFromAst(member.object, rootAliases, identifierBindings)) {
+    return {
+      dynamicIndex: propertyIndex,
+      hasDynamicMember: false,
+      library: propertyName,
+      libraryIndex: propertyIndex,
+      memberIndex: propertyIndex,
+      members: [],
+      rootCapability: getAstSource(member, source) || `ctx.libs.${propertyName}`
+    };
+  }
+  if (CANONICAL_CTX_LIB_MEMBERS.includes(propertyName) && isUnshadowedCtxIdentifier(member.object, identifierBindings)) {
+    return {
+      dynamicIndex: propertyIndex,
+      hasDynamicMember: false,
+      library: propertyName,
+      libraryIndex: propertyIndex,
+      memberIndex: propertyIndex,
+      members: [],
+      rootCapability: getAstSource(member, source) || `ctx.${propertyName}`
+    };
+  }
+  return void 0;
+}
+function isCtxLibsRootFromAst(node, rootAliases, identifierBindings) {
+  const unwrapped = unwrapAstChainExpression(node);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === "Identifier") {
+    return !!resolveAstAliasBinding(unwrapped.name, unwrapped.start || 0, rootAliases, identifierBindings);
+  }
+  return unwrapped.type === "MemberExpression" && getAstStaticPropertyName(unwrapped) === "libs" && isUnshadowedCtxIdentifier(unwrapped.object, identifierBindings);
+}
 function collectAstInvalidCtxApiPatternAccesses(ast, aliases, identifierBindings) {
   const entries = [];
   const collectPattern = (pattern, capability) => {

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

@@ -9,13 +9,19 @@
 import type { Plugin } from '@nocobase/server';
 import _ from 'lodash';
 import FlowModelRepository from '../repository';
+import type { FlowSurfaceApplyBlueprintDocument } from './blueprint';
 import { SurfaceLocator } from './locator';
 import type { TemplateTranslate } from './template-display';
 import type { FlowSurfaceActionLinkageRule, FlowSurfaceBlockLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldValueRule, FlowSurfaceGetReactionMetaResult, FlowSurfaceGetReactionMetaValues, FlowSurfaceReactionWriteResult, FlowSurfaceReactionWriteValues } from './reaction/types';
 import type { FlowSurfaceTemplateListPopupActionContext, FlowSurfaceTemplateListValues, FlowSurfaceTemplateRow } from './template-service-utils';
-import type { FlowSurfaceApplyValues, FlowSurfaceCatalogResponse, FlowSurfaceCatalogValues, FlowSurfaceComposeValues, FlowSurfaceConfigureValues, FlowSurfaceContextValues, FlowSurfaceDescribeValues, FlowSurfaceMutateValues } from './types';
+import type { FlowSurfaceApplyValues, FlowSurfaceActionScope, FlowSurfaceCatalogResponse, FlowSurfaceCatalogValues, FlowSurfaceComposeValues, FlowSurfaceConfigureValues, FlowSurfaceContextValues, FlowSurfaceDescribeValues, FlowSurfaceMutateValues } from './types';
+import type { FlowSurfaceContextResponse, FlowSurfaceContextVarInfo } from './types';
 type FlowSurfacePopupTemplateAliasSession = Map<string, string>;
 type FlowSurfaceRequestRoles = readonly string[] | string;
+type FlowSurfaceReadOptions = {
+    transaction?: any;
+    currentRoles?: FlowSurfaceRequestRoles;
+};
 type FlowSurfaceAddFieldResult = {
     uid?: string;
     parentUid?: string;
@@ -34,6 +40,12 @@ type FlowSurfaceAddFieldResult = {
     popupGridUid?: string;
 };
 type FlowSurfacePopupTemplateTreeCache = Map<string, Promise<any | null> | any | null>;
+type FlowSurfaceApplyBlueprintResponse = {
+    version: '1';
+    mode: FlowSurfaceApplyBlueprintDocument['mode'];
+    target: Record<string, any>;
+    surface: any;
+};
 export declare class FlowSurfacesService {
     private readonly plugin;
     constructor(plugin: Plugin);
@@ -129,7 +141,7 @@ export declare class FlowSurfacesService {
     private buildAssociatedRecordsResourceInit;
     context(values: FlowSurfaceContextValues, options?: {
         transaction?: any;
-    }): Promise<import("./types").FlowSurfaceContextResponse>;
+    }): Promise<FlowSurfaceContextResponse>;
     private extractReactionCanonicalRules;
     private buildReactionFieldPathMaps;
     private extractReactionFieldPaths;
@@ -162,9 +174,7 @@ export declare class FlowSurfacesService {
     private stripInternalSurfaceMetaFromNodeTree;
     private buildSurfaceReadPayload;
     private buildSurfaceContextFingerprint;
-    get(input: Record<string, any>, options?: {
-        transaction?: any;
-    }): Promise<Record<string, any>>;
+    get(input: Record<string, any>, options?: FlowSurfaceReadOptions): Promise<Record<string, any>>;
     private getDeclaredKeyPersistenceDeps;
     private patchDeclaredKeyModel;
     private persistCreatedKeysForAction;
@@ -177,6 +187,7 @@ export declare class FlowSurfacesService {
     private resolveApplyBlueprintCreateNavigationGroup;
     private resolveApplyBlueprintCreatePageIdentity;
     private prepareApplyBlueprintRequest;
+    private prevalidateApplyBlueprintChartAssets;
     private getApplyBlueprintKanbanBlockResourceObject;
     private normalizeApplyBlueprintKanbanResourceText;
     private getApplyBlueprintKanbanBlockBinding;
@@ -201,13 +212,11 @@ export declare class FlowSurfacesService {
     applyBlueprint(values: Record<string, any>, options?: {
         transaction?: any;
         currentRoles?: FlowSurfaceRequestRoles;
-    }): Promise<{
-        version: string;
-        mode: import("./blueprint").FlowSurfaceApplyBlueprintMode;
-        target: _.Dictionary<any>;
-        surface: Record<string, any>;
-    }>;
+    }): Promise<FlowSurfaceApplyBlueprintResponse>;
+    private applyBlueprintMutationWithoutExternalTransaction;
+    private assertApplyBlueprintAuthoringPayload;
     private applyBlueprintWithTransaction;
+    private buildApplyBlueprintResponse;
     private findApprovalSurfaceRootForNode;
     private syncApprovalRuntimeConfigForSurfaceRoot;
     private syncApprovalRuntimeConfigForNode;
@@ -456,7 +465,7 @@ export declare class FlowSurfacesService {
         uid: any;
         parentUid: any;
         subKey: string;
-        scope: import("./types").FlowSurfaceActionScope;
+        scope: FlowSurfaceActionScope;
     }>;
     addRecordAction(values: Record<string, any>, options?: {
         transaction?: any;
@@ -469,7 +478,7 @@ export declare class FlowSurfacesService {
         uid: any;
         parentUid: any;
         subKey: string;
-        scope: import("./types").FlowSurfaceActionScope;
+        scope: FlowSurfaceActionScope;
     }>;
     addBlocks(values: Record<string, any>): Promise<{
         [x: string]: number | Record<string, any>[];
@@ -727,6 +736,7 @@ export declare class FlowSurfacesService {
     private normalizeChartSelectionFieldPath;
     private validateBuilderChartFieldsForRuntime;
     private resolveBuilderChartAssociationSubfieldSuggestion;
+    private validateChartConfigureForRuntime;
     private stripChartSqlForInspection;
     private normalizeReadOnlyChartSql;
     private buildChartSqlPreviewQuery;
@@ -773,7 +783,7 @@ export declare class FlowSurfacesService {
                 additionalProperties: boolean;
             };
         }[];
-        vars: Record<string, import("./types").FlowSurfaceContextVarInfo>;
+        vars: Record<string, FlowSurfaceContextVarInfo>;
         fingerprint: string;
         writeCapabilities: {
             defaultAddPhase: string;
@@ -1006,6 +1016,10 @@ export declare class FlowSurfacesService {
     private assertOnlyAIEmployeePublicSettings;
     private assertOnlyAIEmployeeNestedPublicSettings;
     private assertNoAIEmployeeInternalPropSettings;
+    private readAIEmployeePersistedTasks;
+    private buildAIEmployeeTaskStepParams;
+    private mergeAIEmployeeActionSettingsPayload;
+    private syncAIEmployeeTaskStepParamsForUpdateSettings;
     private assertAIEmployeePluginEnabled;
     private readRecordPlainObject;
     private readRecordField;
@@ -1017,6 +1031,23 @@ export declare class FlowSurfacesService {
     private normalizeAIEmployeeWorkContext;
     private normalizeAIEmployeeTaskModel;
     private normalizeAIEmployeeSkillSettings;
+    private collectAIEmployeePromptVariables;
+    private hasAIEmployeePromptVariables;
+    private collectAIEmployeeContextPathEntries;
+    private isAIEmployeeContextInfoPathAllowed;
+    private canResolveAIEmployeeContextPath;
+    private isAIEmployeeContextPathAllowed;
+    private extractAIEmployeePromptContextPath;
+    private buildAIEmployeePromptVariableHint;
+    private throwAIEmployeePromptVariableInvalid;
+    private assertAIEmployeePromptVariablesAllowed;
+    private assertAIEmployeeTaskPromptVariablesAllowed;
+    private appendAIEmployeeCurrentRecordPromptVariable;
+    private resolveAIEmployeePromptActionTargetUid;
+    private buildAIEmployeePromptValidationContext;
+    private appendAIEmployeeCurrentRecordPromptVariableToTasks;
+    private assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings;
+    private normalizeAIEmployeeStepParamTasksForUpdateSettings;
     private normalizeAIEmployeeTaskMessage;
     private normalizeAIEmployeeTaskPatch;
     private normalizeAIEmployeeTasks;