@nocobase/plugin-flow-engine 2.1.0-beta.15 → 2.1.0-beta.16

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

@@ -0,0 +1,206 @@
+/**
+ * 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 registry_exports = {};
+__export(registry_exports, {
+  FLOW_SURFACE_ACTION_LINKAGE_STATES: () => FLOW_SURFACE_ACTION_LINKAGE_STATES,
+  FLOW_SURFACE_BLOCK_LINKAGE_STATES: () => FLOW_SURFACE_BLOCK_LINKAGE_STATES,
+  FLOW_SURFACE_FIELD_LINKAGE_ACTION_TYPES_BY_SCENE: () => FLOW_SURFACE_FIELD_LINKAGE_ACTION_TYPES_BY_SCENE,
+  FLOW_SURFACE_FIELD_LINKAGE_STATES_BY_SCENE: () => FLOW_SURFACE_FIELD_LINKAGE_STATES_BY_SCENE,
+  FLOW_SURFACE_LINKAGE_CANONICAL_ACTION_NAMES: () => FLOW_SURFACE_LINKAGE_CANONICAL_ACTION_NAMES,
+  FLOW_SURFACE_REACTION_SLOT_REGISTRY: () => FLOW_SURFACE_REACTION_SLOT_REGISTRY,
+  FLOW_SURFACE_REACTION_SUPPORTED_KINDS_BY_USE: () => FLOW_SURFACE_REACTION_SUPPORTED_KINDS_BY_USE,
+  getReactionKindsForUse: () => getReactionKindsForUse,
+  getReactionSlot: () => getReactionSlot
+});
+module.exports = __toCommonJS(registry_exports);
+const FLOW_SURFACE_REACTION_SLOT_REGISTRY = {
+  fieldValue: {
+    form: {
+      flowKey: "formModelSettings",
+      stepKey: "assignRules",
+      valuePath: "value"
+    }
+  },
+  blockLinkage: {
+    block: {
+      flowKey: "cardSettings",
+      stepKey: "linkageRules",
+      valuePath: null
+    }
+  },
+  fieldLinkage: {
+    form: {
+      flowKey: "eventSettings",
+      stepKey: "linkageRules",
+      valuePath: "value"
+    },
+    details: {
+      flowKey: "detailsSettings",
+      stepKey: "linkageRules",
+      valuePath: "value"
+    },
+    subForm: {
+      flowKey: "eventSettings",
+      stepKey: "linkageRules",
+      valuePath: "value"
+    }
+  },
+  actionLinkage: {
+    action: {
+      flowKey: "buttonSettings",
+      stepKey: "linkageRules",
+      valuePath: null
+    }
+  }
+};
+const FLOW_SURFACE_REACTION_SUPPORTED_KINDS_BY_USE = {
+  CreateFormModel: ["fieldValue", "blockLinkage", "fieldLinkage"],
+  EditFormModel: ["fieldValue", "blockLinkage", "fieldLinkage"],
+  FormBlockModel: ["blockLinkage", "fieldLinkage"],
+  ApplyFormModel: ["fieldValue", "blockLinkage", "fieldLinkage"],
+  ProcessFormModel: ["fieldValue", "blockLinkage", "fieldLinkage"],
+  DetailsBlockModel: ["blockLinkage", "fieldLinkage"],
+  ApprovalDetailsModel: ["blockLinkage", "fieldLinkage"],
+  ApplyTaskCardDetailsModel: ["blockLinkage", "fieldLinkage"],
+  ApprovalTaskCardDetailsModel: ["blockLinkage", "fieldLinkage"],
+  TableBlockModel: ["blockLinkage"],
+  CalendarBlockModel: ["blockLinkage"],
+  ListBlockModel: ["blockLinkage"],
+  GridCardBlockModel: ["blockLinkage"],
+  MarkdownBlockModel: ["blockLinkage"],
+  IframeBlockModel: ["blockLinkage"],
+  MapBlockModel: ["blockLinkage"],
+  CommentsBlockModel: ["blockLinkage"],
+  ChartBlockModel: ["blockLinkage"],
+  ActionPanelBlockModel: ["blockLinkage"],
+  AddNewActionModel: ["actionLinkage"],
+  ViewActionModel: ["actionLinkage"],
+  EditActionModel: ["actionLinkage"],
+  PopupCollectionActionModel: ["actionLinkage"],
+  DeleteActionModel: ["actionLinkage"],
+  UpdateRecordActionModel: ["actionLinkage"],
+  BulkUpdateActionModel: ["actionLinkage"],
+  BulkDeleteActionModel: ["actionLinkage"],
+  BulkEditActionModel: ["actionLinkage"],
+  DuplicateActionModel: ["actionLinkage"],
+  AddChildActionModel: ["actionLinkage"],
+  MailSendActionModel: ["actionLinkage"],
+  JSCollectionActionModel: ["actionLinkage"],
+  JSRecordActionModel: ["actionLinkage"],
+  JSFormActionModel: ["actionLinkage"],
+  JSItemActionModel: ["actionLinkage"],
+  FilterFormJSActionModel: ["actionLinkage"],
+  JSActionModel: ["actionLinkage"],
+  CalendarTodayActionModel: ["actionLinkage"],
+  CalendarNavActionModel: ["actionLinkage"],
+  CalendarTitleActionModel: ["actionLinkage"],
+  CalendarViewSelectActionModel: ["actionLinkage"],
+  LinkActionModel: ["actionLinkage"],
+  ExportActionModel: ["actionLinkage"],
+  ExportAttachmentActionModel: ["actionLinkage"],
+  ImportActionModel: ["actionLinkage"],
+  CollectionTriggerWorkflowActionModel: ["actionLinkage"],
+  RecordTriggerWorkflowActionModel: ["actionLinkage"],
+  FormTriggerWorkflowActionModel: ["actionLinkage"],
+  WorkbenchTriggerWorkflowActionModel: ["actionLinkage"],
+  RefreshActionModel: ["actionLinkage"],
+  FilterActionModel: ["actionLinkage"],
+  ExpandCollapseActionModel: ["actionLinkage"],
+  FormSubmitActionModel: ["actionLinkage"],
+  ApplyFormSubmitModel: ["actionLinkage"],
+  ApplyFormSaveDraftModel: ["actionLinkage"],
+  ApplyFormWithdrawModel: ["actionLinkage"],
+  ProcessFormApproveModel: ["actionLinkage"],
+  ProcessFormRejectModel: ["actionLinkage"],
+  ProcessFormReturnModel: ["actionLinkage"],
+  ProcessFormDelegateModel: ["actionLinkage"],
+  ProcessFormAddAssigneeModel: ["actionLinkage"],
+  FilterFormSubmitActionModel: ["actionLinkage"],
+  FilterFormResetActionModel: ["actionLinkage"],
+  FilterFormCollapseActionModel: ["actionLinkage"],
+  SubFormFieldModel: ["fieldLinkage"],
+  SubFormListFieldModel: ["fieldLinkage"]
+};
+const FLOW_SURFACE_BLOCK_LINKAGE_STATES = ["visible", "hidden"];
+const FLOW_SURFACE_ACTION_LINKAGE_STATES = ["visible", "hidden", "hiddenText", "enabled", "disabled"];
+const FLOW_SURFACE_FIELD_LINKAGE_STATES_BY_SCENE = {
+  form: ["visible", "hidden", "hiddenReservedValue", "required", "notRequired", "disabled", "enabled"],
+  details: ["visible", "hidden", "hiddenReservedValue"],
+  subForm: ["visible", "hidden", "hiddenReservedValue", "required", "notRequired", "disabled", "enabled"]
+};
+const FLOW_SURFACE_FIELD_LINKAGE_ACTION_TYPES_BY_SCENE = {
+  form: ["setFieldState", "assignField", "setFieldDefaultValue", "runjs"],
+  details: ["setFieldState", "runjs"],
+  subForm: ["setFieldState", "assignField", "runjs"]
+};
+const FLOW_SURFACE_LINKAGE_CANONICAL_ACTION_NAMES = {
+  block: {
+    setBlockState: "linkageSetBlockProps",
+    runjs: "linkageRunjs"
+  },
+  action: {
+    setActionState: "linkageSetActionProps",
+    runjs: "linkageRunjs"
+  },
+  form: {
+    setFieldState: "linkageSetFieldProps",
+    assignField: "linkageAssignField",
+    setFieldDefaultValue: "setFieldsDefaultValue",
+    runjs: "linkageRunjs"
+  },
+  details: {
+    setFieldState: "linkageSetDetailsFieldProps",
+    runjs: "linkageRunjs"
+  },
+  subForm: {
+    setFieldState: "subFormLinkageSetFieldProps",
+    assignField: "subFormLinkageAssignField",
+    runjs: "linkageRunjs"
+  }
+};
+function getReactionKindsForUse(use) {
+  if (!use) {
+    return [];
+  }
+  return [...FLOW_SURFACE_REACTION_SUPPORTED_KINDS_BY_USE[use] || []];
+}
+function getReactionSlot(kind, scene) {
+  var _a;
+  return (_a = FLOW_SURFACE_REACTION_SLOT_REGISTRY[kind]) == null ? void 0 : _a[scene];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_ACTION_LINKAGE_STATES,
+  FLOW_SURFACE_BLOCK_LINKAGE_STATES,
+  FLOW_SURFACE_FIELD_LINKAGE_ACTION_TYPES_BY_SCENE,
+  FLOW_SURFACE_FIELD_LINKAGE_STATES_BY_SCENE,
+  FLOW_SURFACE_LINKAGE_CANONICAL_ACTION_NAMES,
+  FLOW_SURFACE_REACTION_SLOT_REGISTRY,
+  FLOW_SURFACE_REACTION_SUPPORTED_KINDS_BY_USE,
+  getReactionKindsForUse,
+  getReactionSlot
+});

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

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+import type { FlowSurfaceReactionKind, FlowSurfaceResolveReactionCapabilityResult, FlowSurfaceResolveReactionTargetValues, FlowSurfaceResolvedReactionCapability, FlowSurfaceResolvedReactionTarget } from './types';
+type FlowSurfaceReactionReadbackLike = {
+    tree?: any;
+    nodeMap?: Record<string, any>;
+};
+type FlowSurfaceResolveReactionTargetFromReadbackValues = Omit<FlowSurfaceResolveReactionTargetValues, 'node' | 'use'> & {
+    readback: FlowSurfaceReactionReadbackLike;
+};
+export declare function findReactionTargetNodeInReadback(readback: FlowSurfaceReactionReadbackLike, uid: string): any;
+export declare function resolveReactionTarget(values: FlowSurfaceResolveReactionTargetValues): FlowSurfaceResolvedReactionTarget;
+export declare function resolveReactionTargetFromReadback(values: FlowSurfaceResolveReactionTargetFromReadbackValues): FlowSurfaceResolvedReactionTarget;
+export declare function resolveReactionCapability(resolvedTarget: FlowSurfaceResolvedReactionTarget, kind: FlowSurfaceReactionKind): FlowSurfaceResolveReactionCapabilityResult;
+export declare function resolveReactionStorageNode(resolvedTarget: FlowSurfaceResolvedReactionTarget, capability: FlowSurfaceResolvedReactionCapability): any;
+export {};

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

@@ -0,0 +1,202 @@
+/**
+ * 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 resolver_exports = {};
+__export(resolver_exports, {
+  findReactionTargetNodeInReadback: () => findReactionTargetNodeInReadback,
+  resolveReactionCapability: () => resolveReactionCapability,
+  resolveReactionStorageNode: () => resolveReactionStorageNode,
+  resolveReactionTarget: () => resolveReactionTarget,
+  resolveReactionTargetFromReadback: () => resolveReactionTargetFromReadback
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_errors = require("../errors");
+var import_errors2 = require("./errors");
+var import_registry = require("./registry");
+const FORM_REACTION_USES = /* @__PURE__ */ new Set(["CreateFormModel", "EditFormModel", "FormBlockModel"]);
+const DETAILS_REACTION_USES = /* @__PURE__ */ new Set(["DetailsBlockModel"]);
+const SUB_FORM_REACTION_USES = /* @__PURE__ */ new Set(["SubFormFieldModel", "SubFormListFieldModel"]);
+const FORM_GRID_STORAGE_KINDS = /* @__PURE__ */ new Set(["fieldValue", "fieldLinkage"]);
+function normalizeTargetUid(input) {
+  const uid = String((input == null ? void 0 : input.uid) || "").trim();
+  if (!uid) {
+    (0, import_errors.throwBadRequest)("flowSurfaces reaction requires target.uid");
+  }
+  return uid;
+}
+function inferReactionTargetKind(use, supportedKinds) {
+  if (SUB_FORM_REACTION_USES.has(use || "")) {
+    return "fieldHost";
+  }
+  if (supportedKinds.includes("actionLinkage") && supportedKinds.length === 1) {
+    return "action";
+  }
+  return "block";
+}
+function inferReactionScene(kind, use) {
+  switch (kind) {
+    case "fieldValue":
+      return FORM_REACTION_USES.has(use || "") ? "form" : void 0;
+    case "blockLinkage":
+      return "block";
+    case "actionLinkage":
+      return "action";
+    case "fieldLinkage":
+      if (FORM_REACTION_USES.has(use || "")) {
+        return "form";
+      }
+      if (DETAILS_REACTION_USES.has(use || "")) {
+        return "details";
+      }
+      if (SUB_FORM_REACTION_USES.has(use || "")) {
+        return "subForm";
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function buildUnsupportedTargetMessage(kind, use) {
+  if (kind === "fieldValue") {
+    return "flowSurfaces reaction field values are only available on create/edit form blocks";
+  }
+  return `flowSurfaces reaction target '${use || "unknown"}' does not support ${kind}`;
+}
+function findReactionTargetNodeInReadback(readback, uid) {
+  var _a;
+  const normalizedUid = String(uid || "").trim();
+  if (!normalizedUid) {
+    return void 0;
+  }
+  const visit = (node) => {
+    if (!node || typeof node !== "object") {
+      return void 0;
+    }
+    if (node.uid === normalizedUid) {
+      return node;
+    }
+    for (const child of Object.values(node.subModels || {})) {
+      const children = Array.isArray(child) ? child : [child];
+      for (const item of children) {
+        const matched = visit(item);
+        if (matched) {
+          return matched;
+        }
+      }
+    }
+    return void 0;
+  };
+  return visit(readback == null ? void 0 : readback.tree) || ((_a = readback == null ? void 0 : readback.nodeMap) == null ? void 0 : _a[normalizedUid]);
+}
+function resolveReactionTarget(values) {
+  const uid = normalizeTargetUid(values.target);
+  const node = values.node || {};
+  const use = String(values.use || (node == null ? void 0 : node.use) || "").trim() || void 0;
+  const supportedKinds = (0, import_registry.getReactionKindsForUse)(use);
+  if (!supportedKinds.length) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces reaction target '${use || uid}' does not support advanced reaction capabilities`,
+      import_errors2.FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND
+    );
+  }
+  const capabilities = supportedKinds.map((kind) => {
+    const resolvedScene = inferReactionScene(kind, use);
+    if (!resolvedScene) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces reaction target '${use || uid}' cannot uniquely resolve scene for ${kind}`,
+        import_errors2.FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE
+      );
+    }
+    const resolvedSlot = (0, import_registry.getReactionSlot)(kind, resolvedScene);
+    if (!resolvedSlot) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces reaction target '${use || uid}' cannot resolve storage slot for ${kind}`,
+        import_errors2.FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE
+      );
+    }
+    return {
+      kind,
+      resolvedScene,
+      resolvedSlot
+    };
+  });
+  return {
+    target: {
+      uid,
+      publicPath: String(
+        values.publicPath || ("publicPath" in values.target && typeof values.target.publicPath === "string" ? values.target.publicPath : "")
+      ).trim() || void 0
+    },
+    node,
+    use,
+    targetKind: inferReactionTargetKind(use, supportedKinds),
+    capabilities
+  };
+}
+function resolveReactionTargetFromReadback(values) {
+  const uid = normalizeTargetUid(values.target);
+  const node = findReactionTargetNodeInReadback(values.readback, uid);
+  return resolveReactionTarget({
+    node,
+    use: node == null ? void 0 : node.use,
+    target: values.target,
+    publicPath: values.publicPath
+  });
+}
+function resolveReactionCapability(resolvedTarget, kind) {
+  const matched = resolvedTarget.capabilities.find((item) => item.kind === kind);
+  if (!matched) {
+    (0, import_errors.throwBadRequest)(
+      buildUnsupportedTargetMessage(kind, resolvedTarget.use),
+      kind === "fieldValue" ? import_errors2.FLOW_SURFACE_REACTION_FORM_ONLY : import_errors2.FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND
+    );
+  }
+  return {
+    ...resolvedTarget,
+    ...matched
+  };
+}
+function resolveReactionStorageNode(resolvedTarget, capability) {
+  var _a, _b;
+  if (FORM_REACTION_USES.has(resolvedTarget.use || "") && capability.resolvedScene === "form" && FORM_GRID_STORAGE_KINDS.has(capability.kind)) {
+    const gridNode = (_b = (_a = resolvedTarget.node) == null ? void 0 : _a.subModels) == null ? void 0 : _b.grid;
+    if (gridNode && typeof gridNode === "object" && String(gridNode.uid || "").trim()) {
+      return gridNode;
+    }
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces reaction target '${resolvedTarget.use || resolvedTarget.target.uid}' is missing form grid storage node for ${capability.kind}`
+    );
+  }
+  return resolvedTarget.node;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findReactionTargetNodeInReadback,
+  resolveReactionCapability,
+  resolveReactionStorageNode,
+  resolveReactionTarget,
+  resolveReactionTargetFromReadback
+});

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

@@ -0,0 +1,241 @@
+/**
+ * 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.
+ */
+import type { FlowSurfaceContextResponse, FlowSurfaceWriteTarget } from '../types';
+export type FlowSurfaceReactionKind = 'fieldValue' | 'blockLinkage' | 'fieldLinkage' | 'actionLinkage';
+export type FlowSurfaceReactionScene = 'form' | 'block' | 'action' | 'details' | 'subForm';
+export type FlowSurfaceFieldLinkageScene = Extract<FlowSurfaceReactionScene, 'form' | 'details' | 'subForm'>;
+export type FlowSurfaceReactionSlot = {
+    flowKey: string;
+    stepKey: string;
+    valuePath?: string | null;
+};
+export type FlowSurfaceReactionFilter = Record<string, any>;
+export type FlowSurfaceValueExpr = {
+    source: 'literal';
+    value: any;
+} | {
+    source: 'path';
+    path: string;
+} | {
+    source: 'runjs';
+    code: string;
+    version?: 'v1' | 'v2';
+};
+export type FlowSurfaceFieldValueRule = {
+    key?: string;
+    title?: string;
+    enabled?: boolean;
+    targetPath: string;
+    mode?: 'default' | 'assign';
+    when?: FlowSurfaceReactionFilter;
+    value: FlowSurfaceValueExpr;
+};
+export type FlowSurfaceBlockLinkageAction = {
+    key?: string;
+    type: 'setBlockState';
+    state: 'visible' | 'hidden';
+} | {
+    key?: string;
+    type: 'runjs';
+    code: string;
+    version?: 'v1' | 'v2';
+};
+export type FlowSurfaceActionLinkageAction = {
+    key?: string;
+    type: 'setActionState';
+    state: 'visible' | 'hidden' | 'hiddenText' | 'enabled' | 'disabled';
+} | {
+    key?: string;
+    type: 'runjs';
+    code: string;
+    version?: 'v1' | 'v2';
+};
+export type FlowSurfaceFieldLinkageAssignItem = {
+    key?: string;
+    enabled?: boolean;
+    targetPath: string;
+    when?: FlowSurfaceReactionFilter;
+    value: FlowSurfaceValueExpr;
+};
+export type FlowSurfaceFieldLinkageAction = {
+    key?: string;
+    type: 'setFieldState';
+    fieldPaths: string[];
+    state: 'visible' | 'hidden' | 'hiddenReservedValue' | 'required' | 'notRequired' | 'disabled' | 'enabled';
+} | {
+    key?: string;
+    type: 'assignField';
+    items: FlowSurfaceFieldLinkageAssignItem[];
+} | {
+    key?: string;
+    type: 'setFieldDefaultValue';
+    items: FlowSurfaceFieldLinkageAssignItem[];
+} | {
+    key?: string;
+    type: 'runjs';
+    code: string;
+    version?: 'v1' | 'v2';
+};
+export type FlowSurfaceFieldUidToPathResolver = (fieldUid: string) => string | undefined;
+export type FlowSurfaceFieldPathToUidResolver = (fieldPath: string) => string | undefined;
+export type FlowSurfaceBlockLinkageRule = {
+    key?: string;
+    title?: string;
+    enabled?: boolean;
+    when?: FlowSurfaceReactionFilter;
+    then: FlowSurfaceBlockLinkageAction[];
+};
+export type FlowSurfaceActionLinkageRule = {
+    key?: string;
+    title?: string;
+    enabled?: boolean;
+    when?: FlowSurfaceReactionFilter;
+    then: FlowSurfaceActionLinkageAction[];
+};
+export type FlowSurfaceFieldLinkageRule = {
+    key?: string;
+    title?: string;
+    enabled?: boolean;
+    when?: FlowSurfaceReactionFilter;
+    then: FlowSurfaceFieldLinkageAction[];
+};
+export type FlowSurfaceReactionTargetSummary = {
+    uid: string;
+    publicPath?: string;
+};
+export type FlowSurfaceReactionResolvedTargetKind = 'block' | 'action' | 'fieldHost';
+export type FlowSurfaceResolvedReactionCapability = {
+    kind: FlowSurfaceReactionKind;
+    resolvedScene: FlowSurfaceReactionScene;
+    resolvedSlot: FlowSurfaceReactionSlot;
+};
+export type FlowSurfaceResolvedReactionTarget = {
+    target: FlowSurfaceReactionTargetSummary;
+    node: any;
+    use?: string;
+    targetKind: FlowSurfaceReactionResolvedTargetKind;
+    capabilities: FlowSurfaceResolvedReactionCapability[];
+};
+export type FlowSurfaceResolveReactionTargetValues = {
+    target: FlowSurfaceWriteTarget | FlowSurfaceReactionTargetSummary;
+    node?: any;
+    use?: string;
+    publicPath?: string;
+};
+export type FlowSurfaceResolveReactionCapabilityResult = FlowSurfaceResolvedReactionTarget & FlowSurfaceResolvedReactionCapability;
+export type FlowSurfaceReactionWriteValues<T> = {
+    target: FlowSurfaceWriteTarget;
+    rules: T[];
+    expectedFingerprint?: string;
+    verify?: boolean;
+};
+export type FlowSurfaceReactionWriteResult<T> = {
+    target: FlowSurfaceReactionTargetSummary;
+    resolvedScene: FlowSurfaceReactionScene;
+    resolvedSlot: FlowSurfaceReactionSlot;
+    fingerprint: string;
+    normalizedRules: T[];
+    canonicalRules: any[];
+};
+export type FlowSurfaceFieldOption = {
+    path: string;
+    label: string;
+    interface?: string;
+    type?: string;
+    supportsDefault?: boolean;
+    supportsAssign?: boolean;
+    supportsState?: string[];
+};
+export type FlowSurfaceReactionCapabilityBase<TKind extends FlowSurfaceReactionKind, TRule> = {
+    kind: TKind;
+    resolvedScene: FlowSurfaceReactionScene;
+    resolvedSlot: FlowSurfaceReactionSlot;
+    fingerprint: string;
+    normalizedRules: TRule[];
+    canonicalRules: any[];
+    context: FlowSurfaceContextResponse;
+};
+export type FlowSurfaceFieldValueCapability = FlowSurfaceReactionCapabilityBase<'fieldValue', FlowSurfaceFieldValueRule> & {
+    targetFields: FlowSurfaceFieldOption[];
+    valueExprMeta: {
+        supportedSources: Array<'literal' | 'path' | 'runjs'>;
+        runjsScene: 'fieldValue';
+    };
+};
+export type FlowSurfaceLinkageCapability = (FlowSurfaceReactionCapabilityBase<'blockLinkage', FlowSurfaceBlockLinkageRule> & {
+    supportedActions: Array<Record<string, any>>;
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+    };
+}) | (FlowSurfaceReactionCapabilityBase<'actionLinkage', FlowSurfaceActionLinkageRule> & {
+    supportedActions: Array<Record<string, any>>;
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+    };
+}) | (FlowSurfaceReactionCapabilityBase<'fieldLinkage', FlowSurfaceFieldLinkageRule> & {
+    supportedActions: Array<Record<string, any>>;
+    targetFields: FlowSurfaceFieldOption[];
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+    };
+    valueExprMeta?: {
+        supportedSources: Array<'literal' | 'path' | 'runjs'>;
+        runjsScene: 'linkage';
+    };
+});
+export type FlowSurfaceReactionCapability = FlowSurfaceFieldValueCapability | FlowSurfaceLinkageCapability;
+export type FlowSurfaceReactionUnavailableCapability = {
+    kind: FlowSurfaceReactionKind;
+    code: string;
+    reason: string;
+};
+export type FlowSurfaceReactionRuleNormalizerInput = {
+    kind: FlowSurfaceReactionKind;
+    resolvedScene: FlowSurfaceReactionScene;
+    resolvedSlot: FlowSurfaceReactionSlot;
+    canonicalRules: any[];
+    node: any;
+    context: FlowSurfaceContextResponse;
+};
+export type FlowSurfaceReactionRuleNormalizer = (input: FlowSurfaceReactionRuleNormalizerInput) => any[];
+export type FlowSurfaceReactionRuleNormalizers = Partial<Record<FlowSurfaceReactionKind, FlowSurfaceReactionRuleNormalizer>>;
+export type FlowSurfaceGetReactionMetaValues = {
+    target: FlowSurfaceWriteTarget;
+};
+export type FlowSurfaceGetReactionMetaResult = {
+    target: FlowSurfaceReactionTargetSummary;
+    capabilities: FlowSurfaceReactionCapability[];
+    unavailable: FlowSurfaceReactionUnavailableCapability[];
+};
+export type FlowSurfaceApplyBlueprintReactionItem = {
+    type: 'setFieldValueRules';
+    target: string;
+    rules: FlowSurfaceFieldValueRule[];
+    expectedFingerprint?: string;
+} | {
+    type: 'setBlockLinkageRules';
+    target: string;
+    rules: FlowSurfaceBlockLinkageRule[];
+    expectedFingerprint?: string;
+} | {
+    type: 'setFieldLinkageRules';
+    target: string;
+    rules: FlowSurfaceFieldLinkageRule[];
+    expectedFingerprint?: string;
+} | {
+    type: 'setActionLinkageRules';
+    target: string;
+    rules: FlowSurfaceActionLinkageRule[];
+    expectedFingerprint?: string;
+};
+export type FlowSurfaceBuildReactionMetaCapabilitiesInput = {
+    resolvedTarget: FlowSurfaceResolvedReactionTarget;
+    context: FlowSurfaceContextResponse;
+    normalizeRules?: FlowSurfaceReactionRuleNormalizers;
+};