@particle-academy/fancy-flow 0.18.0 → 0.20.0

package/dist/index.cjs

@@ -4871,6 +4871,28 @@ var addEdge = (edgeParams, edges, options = {}) => {
   }
   return edges.concat(edge);
 };
+var reconnectEdge = (oldEdge, newConnection, edges, options = { shouldReplaceId: true }) => {
+  const { id: oldEdgeId, ...rest } = oldEdge;
+  if (!newConnection.source || !newConnection.target) {
+    options.onError?.("006", errorMessages["error006"]());
+    return edges;
+  }
+  const foundEdge = edges.find((e) => e.id === oldEdge.id);
+  if (!foundEdge) {
+    options.onError?.("007", errorMessages["error007"](oldEdgeId));
+    return edges;
+  }
+  const edgeIdGenerator = options.getEdgeId || getEdgeId;
+  const edge = {
+    ...rest,
+    id: options.shouldReplaceId ? edgeIdGenerator(newConnection) : oldEdgeId,
+    source: newConnection.source,
+    target: newConnection.target,
+    sourceHandle: newConnection.sourceHandle,
+    targetHandle: newConnection.targetHandle
+  };
+  return edges.filter((e) => e.id !== oldEdgeId).concat(edge);
+};
 function getStraightPath({ sourceX, sourceY, targetX, targetY }) {
   const [labelX, labelY, offsetX, offsetY] = getEdgeCenter({
     sourceX,
@@ -7509,6 +7531,12 @@ function addEdge2(edgeParams, edges, options = {}) {
     onError: options.onError ?? defaultOnError
   });
 }
+function reconnectEdge2(oldEdge, newConnection, edges, options = { shouldReplaceId: true }) {
+  return reconnectEdge(oldEdge, newConnection, edges, {
+    ...options,
+    onError: options.onError ?? defaultOnError
+  });
+}
 var isNode = (element) => isNodeBase(element);
 var isEdge = (element) => isEdgeBase(element);
 function fixedForwardRef(render) {
@@ -10996,8 +11024,117 @@ function useFlowState(initial) {
   const onConnect = ReactExports.useCallback((connection) => {
     setEdges((es) => addEdge2(connection, es));
   }, []);
+  const setGraph = ReactExports.useCallback((graph) => {
+    setNodes(graph.nodes);
+    setEdges(graph.edges);
+  }, []);
   const toGraph = ReactExports.useCallback(() => ({ nodes, edges }), [nodes, edges]);
-  return { nodes, edges, setNodes, setEdges, onNodesChange, onEdgesChange, onConnect, toGraph };
+  return { nodes, edges, setNodes, setEdges, setGraph, onNodesChange, onEdgesChange, onConnect, toGraph };
+}
+
+// src/runtime/history.ts
+function createHistory(limit = 100) {
+  let past = [];
+  let future = [];
+  return {
+    push(graph) {
+      past.push(graph);
+      if (past.length > limit) past.shift();
+      future = [];
+    },
+    undo(current) {
+      const prev = past.pop();
+      if (prev === void 0) return null;
+      future.push(current);
+      return prev;
+    },
+    redo(current) {
+      const next = future.pop();
+      if (next === void 0) return null;
+      past.push(current);
+      return next;
+    },
+    canUndo: () => past.length > 0,
+    canRedo: () => future.length > 0,
+    clear() {
+      past = [];
+      future = [];
+    },
+    size: () => ({ past: past.length, future: future.length })
+  };
+}
+
+// src/runtime/use-flow-history.ts
+function useFlowHistory(flow) {
+  const history = ReactExports.useRef(createHistory()).current;
+  const restoring = ReactExports.useRef(false);
+  const coalesced = ReactExports.useRef(false);
+  const [, bump] = ReactExports.useState(0);
+  const rerender = ReactExports.useCallback(() => bump((n) => n + 1), []);
+  const graphRef = ReactExports.useRef({ nodes: flow.nodes, edges: flow.edges });
+  graphRef.current = { nodes: flow.nodes, edges: flow.edges };
+  const capture = ReactExports.useCallback(() => {
+    if (restoring.current || coalesced.current) return;
+    coalesced.current = true;
+    queueMicrotask(() => {
+      coalesced.current = false;
+    });
+    history.push(graphRef.current);
+    rerender();
+  }, [history, rerender]);
+  const restore = ReactExports.useCallback(
+    (g) => {
+      if (!g) return;
+      restoring.current = true;
+      flow.setGraph(g);
+      queueMicrotask(() => {
+        restoring.current = false;
+      });
+      rerender();
+    },
+    [flow, rerender]
+  );
+  const undo = ReactExports.useCallback(() => restore(history.undo(graphRef.current)), [history, restore]);
+  const redo = ReactExports.useCallback(() => restore(history.redo(graphRef.current)), [history, restore]);
+  const wrapped = ReactExports.useMemo(
+    () => ({
+      ...flow,
+      setNodes: (next) => {
+        capture();
+        flow.setNodes(next);
+      },
+      setEdges: (next) => {
+        capture();
+        flow.setEdges(next);
+      },
+      setGraph: (g) => {
+        capture();
+        flow.setGraph(g);
+      },
+      onNodesChange: (changes) => {
+        if (!restoring.current && changes.some((c) => c.type === "remove")) capture();
+        flow.onNodesChange(changes);
+      },
+      onEdgesChange: (changes) => {
+        if (!restoring.current && changes.some((c) => c.type === "remove")) capture();
+        flow.onEdgesChange(changes);
+      },
+      onConnect: (conn) => {
+        capture();
+        flow.onConnect(conn);
+      }
+    }),
+    [flow, capture]
+  );
+  return {
+    flow: wrapped,
+    undo,
+    redo,
+    canUndo: history.canUndo(),
+    canRedo: history.canRedo(),
+    capture,
+    onNodeDragStart: capture
+  };
 }
 function useFlowRun({ maxFeed = 200 } = {}) {
   const [statuses, setStatuses] = ReactExports.useState({});
@@ -11414,6 +11551,65 @@ function duplicateNode(node, id2, offset = 40) {
     data: JSON.parse(JSON.stringify(node.data ?? {}))
   };
 }
+function cloneSubgraph(nodes, edges, opts) {
+  const offset = opts.offset ?? 40;
+  const idMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) idMap.set(n.id, opts.makeId());
+  const clonedNodes = nodes.map((n) => {
+    const cloned = duplicateNode(n, idMap.get(n.id), offset);
+    const parentId = n.parentId;
+    if (parentId && idMap.has(parentId)) cloned.parentId = idMap.get(parentId);
+    else if (parentId) delete cloned.parentId;
+    return cloned;
+  });
+  const clonedEdges = edges.filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((e) => ({ ...e, id: opts.makeId(), source: idMap.get(e.source), target: idMap.get(e.target) }));
+  return { nodes: clonedNodes, edges: clonedEdges, idMap };
+}
+function reconnectEdge3(edges, oldEdge, newConnection) {
+  return reconnectEdge2(oldEdge, newConnection, edges, { shouldReplaceId: false });
+}
+var nodeW = (n) => n.width ?? n.measured?.width ?? 0;
+var nodeH = (n) => n.height ?? n.measured?.height ?? 0;
+function alignNodes(nodes, edge) {
+  if (nodes.length < 2) return nodes;
+  const minL = Math.min(...nodes.map((n) => n.position.x));
+  const maxR = Math.max(...nodes.map((n) => n.position.x + nodeW(n)));
+  const minT = Math.min(...nodes.map((n) => n.position.y));
+  const maxB = Math.max(...nodes.map((n) => n.position.y + nodeH(n)));
+  const cx = (minL + maxR) / 2;
+  const cy = (minT + maxB) / 2;
+  return nodes.map((n) => {
+    let { x, y } = n.position;
+    if (edge === "left") x = minL;
+    else if (edge === "right") x = maxR - nodeW(n);
+    else if (edge === "hcenter") x = cx - nodeW(n) / 2;
+    else if (edge === "top") y = minT;
+    else if (edge === "bottom") y = maxB - nodeH(n);
+    else if (edge === "vcenter") y = cy - nodeH(n) / 2;
+    return { ...n, position: { x, y } };
+  });
+}
+function distributeNodes(nodes, axis) {
+  if (nodes.length < 3) return nodes;
+  const size = (n) => axis === "h" ? nodeW(n) : nodeH(n);
+  const coord = (n) => axis === "h" ? n.position.x : n.position.y;
+  const sorted = [...nodes].sort((a, b) => coord(a) - coord(b));
+  const start2 = coord(sorted[0]);
+  const last = sorted[sorted.length - 1];
+  const end = coord(last) + size(last);
+  const totalSize = sorted.reduce((s, n) => s + size(n), 0);
+  const gap = (end - start2 - totalSize) / (sorted.length - 1);
+  const posById = /* @__PURE__ */ new Map();
+  let cursor = start2;
+  for (const n of sorted) {
+    posById.set(n.id, cursor);
+    cursor += size(n) + gap;
+  }
+  return nodes.map((n) => {
+    const p = posById.get(n.id);
+    return { ...n, position: axis === "h" ? { ...n.position, x: p } : { ...n.position, y: p } };
+  });
+}
 var FlowEditorContext = ReactExports.createContext(null);
 var FlowEditorProvider = FlowEditorContext.Provider;
 function useFlowEditor() {
@@ -11453,13 +11649,16 @@ function FlowEditorInner({
   onSelectionChange,
   onDelete,
   onEdgeDelete,
+  confirmDelete,
   apiRef
 }) {
   const internal = useFlowState(initial);
   const runner = useFlowRun();
   const rf = useReactFlow();
   const controlled = value !== void 0;
-  const flow = controlled ? makeControlledFlowAdapter(value, onChange) : internal;
+  const baseFlow = controlled ? makeControlledFlowAdapter(value, onChange) : internal;
+  const hist = useFlowHistory(baseFlow);
+  const flow = hist.flow;
   const [, force] = ReactExports.useState(0);
   ReactExports.useEffect(() => onNodeKindsChanged(() => force((n) => n + 1)), []);
   const nodeTypes = ReactExports.useMemo(() => buildNodeTypes(), [listNodeKinds().length]);
@@ -11512,6 +11711,23 @@ function FlowEditorInner({
       window.removeEventListener("keydown", onKey);
     };
   }, [menu, labelEdit]);
+  ReactExports.useEffect(() => {
+    const onKey = (e) => {
+      const t = e.target;
+      if (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.isContentEditable)) return;
+      if (!(e.ctrlKey || e.metaKey)) return;
+      const key = e.key.toLowerCase();
+      if (key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        hist.undo();
+      } else if (key === "z" && e.shiftKey || key === "y") {
+        e.preventDefault();
+        hist.redo();
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [hist]);
   ReactExports.useEffect(() => {
     if (!controlled) onChange?.({ nodes: flow.nodes, edges: flow.edges });
   }, [flow.nodes, flow.edges, onChange, controlled]);
@@ -11536,16 +11752,116 @@ function FlowEditorInner({
     [flow]
   );
   const deleteNodes = ReactExports.useCallback(
-    (ids) => {
+    async (ids) => {
       if (ids.length === 0) return;
+      const targets = flow.nodes.filter((n) => ids.includes(n.id));
+      if (targets.length === 0) return;
+      if (confirmDelete) {
+        const attached = flow.edges.filter((e) => ids.includes(e.source) || ids.includes(e.target));
+        if (!await confirmDelete({ nodes: targets, edges: attached })) return;
+      }
       const doomed = new Set(ids);
-      flow.setNodes((all) => removeNodes({ nodes: all, edges: [] }, ids).nodes);
-      flow.setEdges((all) => removeNodes({ nodes: [], edges: all }, ids).edges);
+      flow.setGraph(removeNodes({ nodes: flow.nodes, edges: flow.edges }, ids));
       setSelectedId((cur) => cur !== null && doomed.has(cur) ? null : cur);
       onDelete?.(ids);
     },
-    [flow, onDelete]
+    [flow, onDelete, confirmDelete]
+  );
+  const deleteEdges = ReactExports.useCallback(
+    async (ids) => {
+      if (ids.length === 0) return;
+      const targets = flow.edges.filter((e) => ids.includes(e.id));
+      if (targets.length === 0) return;
+      if (confirmDelete && !await confirmDelete({ nodes: [], edges: targets })) return;
+      flow.setEdges((all) => removeEdges(all, ids));
+      setSelectedEdgeId((cur) => cur !== null && ids.includes(cur) ? null : cur);
+      onEdgeDelete?.(ids);
+    },
+    [flow, onEdgeDelete, confirmDelete]
+  );
+  const selectedNodes = ReactExports.useMemo(() => flow.nodes.filter((n) => n.selected), [flow.nodes]);
+  const selectedIds = ReactExports.useMemo(() => selectedNodes.map((n) => n.id), [selectedNodes]);
+  const clipboard = ReactExports.useRef(null);
+  const copySelection = ReactExports.useCallback(() => {
+    const sel = flow.nodes.filter((n) => n.selected);
+    if (sel.length === 0) return;
+    const ids = new Set(sel.map((n) => n.id));
+    const edges = flow.edges.filter((e) => ids.has(e.source) && ids.has(e.target));
+    clipboard.current = { nodes: sel.map((n) => ({ ...n })), edges: edges.map((e) => ({ ...e })) };
+  }, [flow]);
+  const pasteClipboard = ReactExports.useCallback(
+    (at) => {
+      const clip = clipboard.current;
+      if (!clip || clip.nodes.length === 0) return;
+      const { nodes: clones, edges: cloneEdges } = cloneSubgraph(clip.nodes, clip.edges, { makeId: newNodeId, offset: 40 });
+      let placed = clones;
+      if (at) {
+        const minX = Math.min(...clones.map((n) => n.position.x));
+        const minY = Math.min(...clones.map((n) => n.position.y));
+        placed = clones.map((n) => ({ ...n, position: { x: n.position.x - minX + at.x, y: n.position.y - minY + at.y } }));
+      }
+      flow.setGraph({
+        nodes: [...flow.nodes.map((n) => ({ ...n, selected: false })), ...placed.map((n) => ({ ...n, selected: true }))],
+        edges: [...flow.edges, ...cloneEdges]
+      });
+    },
+    [flow]
+  );
+  const duplicateSelected = ReactExports.useCallback(() => {
+    const sel = flow.nodes.filter((n) => n.selected);
+    if (sel.length === 0) return;
+    const ids = new Set(sel.map((n) => n.id));
+    const internal2 = flow.edges.filter((e) => ids.has(e.source) && ids.has(e.target));
+    const { nodes: clones, edges: cloneEdges } = cloneSubgraph(sel, internal2, { makeId: newNodeId, offset: 40 });
+    flow.setGraph({
+      nodes: [...flow.nodes.map((n) => ({ ...n, selected: false })), ...clones.map((n) => ({ ...n, selected: true }))],
+      edges: [...flow.edges, ...cloneEdges]
+    });
+  }, [flow]);
+  const alignSelected = ReactExports.useCallback(
+    (edge) => {
+      const sel = flow.nodes.filter((n) => n.selected);
+      if (sel.length < 2) return;
+      const byId = new Map(alignNodes(sel, edge).map((n) => [n.id, n]));
+      flow.setNodes((all) => all.map((n) => byId.get(n.id) ?? n));
+    },
+    [flow]
+  );
+  const distributeSelected = ReactExports.useCallback(
+    (axis) => {
+      const sel = flow.nodes.filter((n) => n.selected);
+      if (sel.length < 3) return;
+      const byId = new Map(distributeNodes(sel, axis).map((n) => [n.id, n]));
+      flow.setNodes((all) => all.map((n) => byId.get(n.id) ?? n));
+    },
+    [flow]
+  );
+  const onReconnect = ReactExports.useCallback(
+    (oldEdge, conn) => flow.setEdges((eds) => reconnectEdge3(eds, oldEdge, conn)),
+    [flow]
   );
+  ReactExports.useEffect(() => {
+    const onKey = (e) => {
+      const t = e.target;
+      if (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.isContentEditable)) return;
+      if (!(e.ctrlKey || e.metaKey)) return;
+      const key = e.key.toLowerCase();
+      if (key === "c") copySelection();
+      else if (key === "x") {
+        e.preventDefault();
+        copySelection();
+        deleteNodes(selectedIds);
+      } else if (key === "v") {
+        e.preventDefault();
+        pasteClipboard();
+      } else if (key === "d") {
+        e.preventDefault();
+        duplicateSelected();
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [copySelection, pasteClipboard, duplicateSelected, deleteNodes, selectedIds]);
   const api = ReactExports.useMemo(() => {
     const toWorkflow = () => exportWorkflow({ nodes: flow.nodes, edges: flow.edges }, metadata);
     return {
@@ -11556,6 +11872,8 @@ function FlowEditorInner({
       selected: selected2,
       selectedEdgeId,
       selectedEdge,
+      selectedIds,
+      selectedNodes,
       running: runner.running,
       statuses: runner.statuses,
       select: setSelectedId,
@@ -11564,18 +11882,8 @@ function FlowEditorInner({
       updateNode: (next) => flow.setNodes((all) => all.map((x) => x.id === next.id ? next : x)),
       deleteNodes,
       deleteSelected: () => deleteNodes(selectedId ? [selectedId] : []),
-      deleteEdges: (ids) => {
-        if (ids.length === 0) return;
-        flow.setEdges((all) => removeEdges(all, ids));
-        setSelectedEdgeId((cur) => cur !== null && ids.includes(cur) ? null : cur);
-        onEdgeDelete?.(ids);
-      },
-      deleteSelectedEdge: () => {
-        if (!selectedEdgeId) return;
-        flow.setEdges((all) => removeEdges(all, [selectedEdgeId]));
-        setSelectedEdgeId(null);
-        onEdgeDelete?.([selectedEdgeId]);
-      },
+      deleteEdges,
+      deleteSelectedEdge: () => deleteEdges(selectedEdgeId ? [selectedEdgeId] : []),
       setEdgeLabel: (id2, label) => flow.setEdges((all) => setEdgeLabel(all, id2, label)),
       duplicateNode: (id2) => {
         const src = flow.nodes.find((n) => n.id === id2);
@@ -11585,22 +11893,29 @@ function FlowEditorInner({
         setSelectedId(copy.id);
         return copy.id;
       },
-      setGraph: (graph) => {
-        flow.setNodes(graph.nodes);
-        flow.setEdges(graph.edges);
+      setGraph: (graph) => flow.setGraph(graph),
+      duplicateSelected,
+      alignSelected,
+      distributeSelected,
+      copy: copySelection,
+      cut: () => {
+        copySelection();
+        deleteNodes(selectedIds);
       },
+      paste: pasteClipboard,
       run: () => runner.run({ nodes: flow.nodes, edges: flow.edges }, executors),
       cancel: runner.cancel,
       reset: runner.reset,
       toWorkflow,
       exportWorkflow: () => downloadWorkflow(toWorkflow(), metadata),
-      importWorkflow: () => pickWorkflow((graph) => {
-        flow.setNodes(graph.nodes);
-        flow.setEdges(graph.edges);
-      }),
-      fitView: () => rf.fitView({ padding: 0.2 })
+      importWorkflow: () => pickWorkflow((graph) => flow.setGraph(graph)),
+      fitView: () => rf.fitView({ padding: 0.2 }),
+      undo: hist.undo,
+      redo: hist.redo,
+      canUndo: hist.canUndo,
+      canRedo: hist.canRedo
     };
-  }, [flow, selectedId, selected2, runner, executors, metadata, addNode, deleteNodes, rf]);
+  }, [flow, selectedId, selected2, selectedEdgeId, selectedEdge, selectedIds, selectedNodes, runner, executors, metadata, addNode, deleteNodes, deleteEdges, duplicateSelected, alignSelected, distributeSelected, copySelection, pasteClipboard, hist, rf]);
   ReactExports.useImperativeHandle(apiRef, () => api, [api]);
   const dropHandlers = paletteDropHandlers((kindName, evt) => {
     const point = rf.screenToFlowPosition({ x: evt.clientX, y: evt.clientY });
@@ -11611,6 +11926,31 @@ function FlowEditorInner({
   const toolbar = slots.toolbar ? slots.toolbar(api) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     startActions.map((a) => renderAction(a, api)),
     builtins.run !== false && /* @__PURE__ */ jsxRuntime.jsx(FlowRunControls, { running: api.running, onRun: api.run, onCancel: api.cancel, onReset: api.reset }),
+    builtins.history !== false && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-editor__sep" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: "ff-editor__btn",
+          "data-action": "undo",
+          title: "Undo (Ctrl+Z)",
+          disabled: !api.canUndo,
+          onClick: api.undo,
+          children: "\u21B6 Undo"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: "ff-editor__btn",
+          "data-action": "redo",
+          title: "Redo (Ctrl+Shift+Z)",
+          disabled: !api.canRedo,
+          onClick: api.redo,
+          children: "\u21B7 Redo"
+        }
+      )
+    ] }),
     (builtins.export !== false || builtins.import !== false) && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-editor__sep" }),
     builtins.export !== false && /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "export", onClick: api.exportWorkflow, children: "\u2193 Export" }),
     builtins.import !== false && /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "import", onClick: api.importWorkflow, children: "\u2191 Import" }),
@@ -11635,12 +11975,16 @@ function FlowEditorInner({
           onNodesChange: flow.onNodesChange,
           onEdgesChange: flow.onEdgesChange,
           onConnect: flow.onConnect,
+          onReconnect,
+          edgesReconnectable: true,
+          onNodeDragStart: hist.onNodeDragStart,
           onNodeClick: handleNodeClick2,
           onNodeContextMenu: builtins.contextMenu === false ? void 0 : handleNodeContextMenu,
           onEdgeClick: handleEdgeClick,
           onEdgeContextMenu: builtins.edgeContextMenu === false ? void 0 : handleEdgeContextMenu,
           onEdgesDelete: (deleted) => onEdgeDelete?.(deleted.map((e) => e.id)),
           onNodesDelete: (deleted) => onDelete?.(deleted.map((n) => n.id)),
+          onBeforeDelete: confirmDelete ? async ({ nodes, edges }) => confirmDelete({ nodes, edges }) : void 0,
           deleteKeyCode: ["Delete", "Backspace"],
           height: "100%",
           toolbar,
@@ -11811,6 +12155,8 @@ function makeControlledFlowAdapter(value, onChange) {
       const nextEdges = typeof next === "function" ? next(value.edges) : next;
       apply({ nodes: value.nodes, edges: nextEdges });
     },
+    // Atomic both-at-once commit — the reason this exists (see UseFlowStateReturn).
+    setGraph: (graph) => apply(graph),
     onNodesChange: (changes) => {
       apply({ nodes: applyNodeChanges(changes, value.nodes), edges: value.edges });
     },
@@ -11920,15 +12266,19 @@ exports.SubgraphNode = SubgraphNode;
 exports.TriggerNode = TriggerNode;
 exports.WORKFLOW_SCHEMA_URL = WORKFLOW_SCHEMA_URL;
 exports.WORKFLOW_SCHEMA_VERSION = WORKFLOW_SCHEMA_VERSION;
+exports.alignNodes = alignNodes;
 exports.applyStatusesToNodes = applyStatusesToNodes;
 exports.buildNodeTypes = buildNodeTypes;
 exports.categoryAccent = categoryAccent;
+exports.cloneSubgraph = cloneSubgraph;
 exports.createConnectionValidator = createConnectionValidator;
+exports.createHistory = createHistory;
 exports.decodePause = decodePause;
 exports.defaultConfigFor = defaultConfigFor;
 exports.defaultNodeTypes = defaultNodeTypes;
 exports.defaultPortCompatibility = defaultPortCompatibility;
 exports.defineNode = defineNode;
+exports.distributeNodes = distributeNodes;
 exports.encodePause = encodePause;
 exports.exportWorkflow = exportWorkflow;
 exports.getNodeKind = getNodeKind;
@@ -11941,6 +12291,7 @@ exports.onNodeKindsChanged = onNodeKindsChanged;
 exports.onRichInputAdapterChanged = onRichInputAdapterChanged;
 exports.paletteDropHandlers = paletteDropHandlers;
 exports.pauseForHuman = pauseForHuman;
+exports.reconnectEdge = reconnectEdge3;
 exports.registerBuiltinKinds = registerBuiltinKinds;
 exports.registerNodeKind = registerNodeKind;
 exports.registerRichInputAdapter = registerRichInputAdapter;
@@ -11949,6 +12300,7 @@ exports.resolvePortSpec = resolvePortSpec;
 exports.runFlow = runFlow;
 exports.useFlowEditor = useFlowEditor;
 exports.useFlowEditorOptional = useFlowEditorOptional;
+exports.useFlowHistory = useFlowHistory;
 exports.useFlowRun = useFlowRun;
 exports.useFlowState = useFlowState;
 exports.validateConfig = validateConfig;