n8n-editor-ui 1.83.2 → 1.85.0

package/dist/assets/{useCanvasOperations-Ch4-PXXM.js → useCanvasOperations-CY1OrN2X.js}

@@ -1,5 +1,41 @@
-import { dT as createCompounder, dU as SetCache, dV as arrayIncludes, dW as cacheHas, dX as baseRest, dY as isArrayLikeObject, dZ as baseFlatten, bi as NodeConnectionType, bL as CanvasConnectionMode, d_ as isValidCanvasConnectionMode, bM as isValidNodeConnectionType, bl as v4, d$ as CORE_NODES_CATEGORY, e0 as DEFAULT_SUBCATEGORY, p as useSettingsStore, e1 as AI_TRANSFORM_NODE_TYPE, bb as AI_SUBCATEGORY, bc as AI_CATEGORY_AGENTS, e2 as sortBy, c_ as i18n, e3 as AI_CATEGORY_OTHER_TOOLS, e4 as SEND_AND_WAIT_OPERATION, e5 as HUMAN_IN_THE_LOOP_CATEGORY, bp as useNodeTypesStore, aN as useTemplatesStore, e6 as AI_NODE_CREATOR_VIEW, e7 as AI_OTHERS_NODE_CREATOR_VIEW, e8 as AI_CATEGORY_DOCUMENT_LOADERS, e9 as AI_CATEGORY_LANGUAGE_MODELS, ea as AI_CATEGORY_MEMORY, eb as AI_CATEGORY_OUTPUTPARSER, ec as AI_CATEGORY_RETRIEVERS, ed as AI_CATEGORY_TEXT_SPLITTERS, ee as AI_CATEGORY_TOOLS, ef as AI_WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE, eg as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, eh as AI_CATEGORY_EMBEDDING, ei as AI_CATEGORY_VECTOR_STORES, ej as AI_UNCATEGORIZED_CATEGORY, ek as TRIGGER_NODE_CREATOR_VIEW, el as MANUAL_TRIGGER_NODE_TYPE, em as WEBHOOK_NODE_TYPE, en as EMAIL_IMAP_NODE_TYPE, eo as SCHEDULE_TRIGGER_NODE_TYPE, ep as FORM_TRIGGER_NODE_TYPE, dk as EXECUTE_WORKFLOW_TRIGGER_NODE_TYPE, b8 as CHAT_TRIGGER_NODE_TYPE, eq as OTHER_TRIGGER_NODES_SUBCATEGORY, er as REGULAR_NODE_CREATOR_VIEW, es as RSS_READ_NODE_TYPE, et as EMAIL_SEND_NODE_TYPE, eu as TRANSFORM_DATA_SUBCATEGORY, ev as FILTER_NODE_TYPE, ew as REMOVE_DUPLICATES_NODE_TYPE, ex as SPLIT_OUT_NODE_TYPE, ey as LIMIT_NODE_TYPE, ez as SUMMARIZE_NODE_TYPE, eA as AGGREGATE_NODE_TYPE, eB as MERGE_NODE_TYPE, eC as HTML_NODE_TYPE, eD as MARKDOWN_NODE_TYPE, eE as XML_NODE_TYPE, eF as CRYPTO_NODE_TYPE, eG as EXTRACT_FROM_FILE_NODE_TYPE, eH as CONVERT_TO_FILE_NODE_TYPE, eI as COMPRESSION_NODE_TYPE, eJ as EDIT_IMAGE_NODE_TYPE, eK as FLOWS_CONTROL_SUBCATEGORY, eL as IF_NODE_TYPE, eM as SPLIT_IN_BATCHES_NODE_TYPE, eN as HELPERS_SUBCATEGORY, eO as HTTP_REQUEST_NODE_TYPE, eP as CODE_NODE_TYPE, eQ as HITL_SUBCATEGORY, g as useI18n, bd as AI_CATEGORY_CHAINS, eR as SET_NODE_TYPE, eS as DATETIME_NODE_TYPE, S as defineStore, r as ref, q as computed, a0 as useCanvasStore, eT as AI_CATEGORY_ROOT_NODES, z as nextTick, be as AI_CODE_NODE_TYPE, eU as AI_TRANSFORM_NODE_TYPE$1, T as STORES, U as useWorkflowsStore, as as useNDVStore, L as useUIStore, bK as NODE_CREATOR_OPEN_SOURCES, eV as isVueFlowConnection, bf as getNodeInputs, eW as CUSTOM_API_CALL_KEY, aU as useExternalHooks, ak as useTelemetry, $ as useRootStore, bv as useCredentialsStore, by as useHistoryStore, E as useTagsStore, at as useExecutionsStore, a2 as useProjectsStore, a as useToast, a5 as useWorkflowHelpers, bq as useNodeHelpers, b7 as useClipboard, eX as MoveNodeCommand, eY as RenameNodeCommand, ds as AddConnectionCommand, du as RemoveNodeCommand, aC as STICKY_NODE_TYPE, dH as useDataSchema, eZ as NODE_SIZE, e_ as GRID_SIZE, dv as AddNodeCommand, e$ as getNodeParameters, f0 as getNewNodePosition, f1 as DEFAULT_NODE_SIZE, f2 as CONFIGURATION_NODE_SIZE, bg as getConnectionTypes, bh as getNodeOutputs, f3 as generateOffsets, f4 as CONFIGURABLE_NODE_SIZE, f5 as PUSH_NODES_OFFSET, dt as RemoveConnectionCommand, f6 as UPDATE_WEBHOOK_ID_NODE_TYPES, de as generateNodesGraph, a9 as EnterpriseEditionFeature, bV as deepCopy, f7 as isPresent } from "./index-ntAcmC2q.js";
-import { c as capitalize, u as usePinnedData } from "./usePinnedData-CvnROquX.js";
+import { dS as baseSlice, dT as toString, dU as createCompounder, dV as SetCache, dW as arrayIncludes, dX as cacheHas, dY as baseRest, dZ as isArrayLikeObject, d_ as baseFlatten, bu as useNodeTypesStore, q as computed, m as unref, d$ as isSubNodeType, a0 as useRootStore, T as useWorkflowsStore, a as useToast, e0 as PIN_DATA_NODE_TYPES_DENYLIST, e1 as jsonStringify, c as useI18n, e2 as toMegaBytes, e3 as stringSizeInBytes, ah as useTelemetry, aQ as useExternalHooks, bL as jsonParse, e4 as useDataSchema, bs as getNodeOutputs, be as NodeConnectionTypes, e5 as MAX_PINNED_DATA_SIZE, e6 as MAX_WORKFLOW_SIZE, e7 as MAX_EXPECTED_REQUEST_SIZE, e8 as CORE_NODES_CATEGORY, e9 as DEFAULT_SUBCATEGORY, bi as v4, p as useSettingsStore, ea as AI_TRANSFORM_NODE_TYPE, bm as AI_SUBCATEGORY, eb as HUMAN_IN_THE_LOOP_CATEGORY, bn as AI_CATEGORY_AGENTS, ec as sortBy, d8 as i18n, ed as AI_CATEGORY_OTHER_TOOLS, ee as SEND_AND_WAIT_OPERATION, ef as AI_CATEGORY_DOCUMENT_LOADERS, eg as AI_CATEGORY_LANGUAGE_MODELS, eh as AI_CATEGORY_MEMORY, ei as AI_CATEGORY_OUTPUTPARSER, ej as AI_CATEGORY_RETRIEVERS, ek as AI_CATEGORY_TEXT_SPLITTERS, el as AI_WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE, em as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, en as AI_CATEGORY_TOOLS, eo as AI_CATEGORY_EMBEDDING, ep as AI_CATEGORY_VECTOR_STORES, eq as AI_UNCATEGORIZED_CATEGORY, er as AI_OTHERS_NODE_CREATOR_VIEW, aO as useTemplatesStore, es as AI_NODE_CREATOR_VIEW, et as RSS_READ_NODE_TYPE, eu as EMAIL_SEND_NODE_TYPE, ev as SET_NODE_TYPE, ew as CODE_NODE_TYPE, ex as DATETIME_NODE_TYPE, ey as FILTER_NODE_TYPE, ez as REMOVE_DUPLICATES_NODE_TYPE, eA as SPLIT_OUT_NODE_TYPE, eB as LIMIT_NODE_TYPE, eC as SUMMARIZE_NODE_TYPE, eD as AGGREGATE_NODE_TYPE, eE as MERGE_NODE_TYPE, eF as HTML_NODE_TYPE, eG as MARKDOWN_NODE_TYPE, eH as XML_NODE_TYPE, eI as CRYPTO_NODE_TYPE, eJ as EXTRACT_FROM_FILE_NODE_TYPE, eK as CONVERT_TO_FILE_NODE_TYPE, eL as COMPRESSION_NODE_TYPE, eM as EDIT_IMAGE_NODE_TYPE, eN as TRANSFORM_DATA_SUBCATEGORY, eO as IF_NODE_TYPE, eP as SPLIT_IN_BATCHES_NODE_TYPE, eQ as FLOWS_CONTROL_SUBCATEGORY, eR as HTTP_REQUEST_NODE_TYPE, eS as WEBHOOK_NODE_TYPE, eT as HELPERS_SUBCATEGORY, eU as HITL_SUBCATEGORY, eV as TRIGGER_NODE_CREATOR_VIEW, eW as REGULAR_NODE_CREATOR_VIEW, eX as MANUAL_TRIGGER_NODE_TYPE, eY as EMAIL_IMAP_NODE_TYPE, eZ as SCHEDULE_TRIGGER_NODE_TYPE, e_ as FORM_TRIGGER_NODE_TYPE, dw as EXECUTE_WORKFLOW_TRIGGER_NODE_TYPE, bt as CHAT_TRIGGER_NODE_TYPE, e$ as OTHER_TRIGGER_NODES_SUBCATEGORY, bo as AI_CATEGORY_CHAINS, S as defineStore, r as ref, a1 as useCanvasStore, f0 as AI_CATEGORY_ROOT_NODES, z as nextTick, bp as AI_CODE_NODE_TYPE, f1 as AI_TRANSFORM_NODE_TYPE$1, f2 as isValidCanvasConnectionMode, bV as CanvasConnectionMode, bU as isValidNodeConnectionType, at as useNDVStore, L as useUIStore, f3 as isVueFlowConnection, bq as getNodeInputs, f4 as CUSTOM_API_CALL_KEY, X as STORES, bY as NODE_CREATOR_OPEN_SOURCES, bD as useCredentialsStore, bG as useHistoryStore, E as useTagsStore, au as useExecutionsStore, a3 as useProjectsStore, a6 as useWorkflowHelpers, bv as useNodeHelpers, b8 as useClipboard, f5 as UPDATE_WEBHOOK_ID_NODE_TYPES, dq as generateNodesGraph, f6 as getNewNodePosition, dD as AddConnectionCommand, az as STICKY_NODE_TYPE, dE as RemoveConnectionCommand, ab as EnterpriseEditionFeature, c1 as deepCopy, f7 as isPresent, dF as RemoveNodeCommand, f8 as RenameNodeCommand, f9 as MoveNodeCommand, fa as DEFAULT_NODE_SIZE, fb as CONFIGURATION_NODE_SIZE, br as getConnectionTypes, fc as generateOffsets, fd as CONFIGURABLE_NODE_SIZE, fe as PUSH_NODES_OFFSET, dG as AddNodeCommand, ff as NODE_SIZE, fg as GRID_SIZE, fh as getNodeParameters } from "./index-CDluwnbb.js";
+function castSlice(array, start, end) {
+  var length = array.length;
+  end = end === void 0 ? length : end;
+  return false ? array : baseSlice(array, start, end);
+}
+var rsAstralRange$1 = "\\ud800-\\udfff", rsComboMarksRange$1 = "\\u0300-\\u036f", reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f", rsComboSymbolsRange$1 = "\\u20d0-\\u20ff", rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1, rsVarRange$1 = "\\ufe0e\\ufe0f";
+var rsZWJ$1 = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ$1 + rsAstralRange$1 + rsComboRange$1 + rsVarRange$1 + "]");
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+function asciiToArray(string) {
+  return string.split("");
+}
+var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsVarRange = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange + "]", rsCombo = "[" + rsComboRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ = "\\u200d";
+var reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeToArray(string) {
+  return string.match(reUnicode) || [];
+}
+function stringToArray(string) {
+  return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
+}
+function createCaseFirst(methodName) {
+  return function(string) {
+    string = toString(string);
+    var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
+    var chr = strSymbols ? strSymbols[0] : string.charAt(0);
+    var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
+    return chr[methodName]() + trailing;
+  };
+}
+var upperFirst = createCaseFirst("toUpperCase");
+function capitalize(string) {
+  return upperFirst(toString(string).toLowerCase());
+}
 var camelCase = createCompounder(function(result, word, index) {
   word = word.toLowerCase();
   return result + (index ? capitalize(word) : word);
@@ -36,168 +72,235 @@ function baseDifference(array, values, iteratee, comparator) {
 var difference = baseRest(function(array, values) {
   return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
 });
-function mapLegacyConnectionsToCanvasConnections(legacyConnections, nodes) {
-  const mappedConnections = [];
-  Object.keys(legacyConnections).forEach((fromNodeName) => {
-    const fromId = nodes.find((node) => node.name === fromNodeName)?.id ?? "";
-    const fromConnectionTypes = Object.keys(
-      legacyConnections[fromNodeName]
-    );
-    fromConnectionTypes.forEach((fromConnectionType) => {
-      const fromPorts = legacyConnections[fromNodeName][fromConnectionType];
-      fromPorts?.forEach((toPorts, fromIndex) => {
-        toPorts?.forEach((toPort) => {
-          const toNodeName = toPort.node;
-          const toId = nodes.find((node) => node.name === toNodeName)?.id ?? "";
-          const toConnectionType = toPort.type;
-          const toIndex = toPort.index;
-          const sourceHandle = createCanvasConnectionHandleString({
-            mode: CanvasConnectionMode.Output,
-            type: fromConnectionType,
-            index: fromIndex
-          });
-          const targetHandle = createCanvasConnectionHandleString({
-            mode: CanvasConnectionMode.Input,
-            type: toConnectionType,
-            index: toIndex
-          });
-          const connectionId = createCanvasConnectionId({
-            source: fromId,
-            sourceHandle,
-            target: toId,
-            targetHandle
-          });
-          if (fromId && toId) {
-            mappedConnections.push({
-              id: connectionId,
-              source: fromId,
-              target: toId,
-              sourceHandle,
-              targetHandle,
-              data: {
-                source: {
-                  node: fromNodeName,
-                  index: fromIndex,
-                  type: fromConnectionType
-                },
-                target: {
-                  node: toNodeName,
-                  index: toIndex,
-                  type: toConnectionType
-                }
-              }
-            });
-          }
-        });
-      });
-    });
-  });
-  return mappedConnections;
-}
-function mapLegacyConnectionToCanvasConnection(sourceNode, targetNode, legacyConnection) {
-  const source = sourceNode.id;
-  const sourceHandle = createCanvasConnectionHandleString({
-    mode: CanvasConnectionMode.Output,
-    type: legacyConnection[0].type,
-    index: legacyConnection[0].index
+function useNodeType(options = {}) {
+  const nodeTypesStore = useNodeTypesStore();
+  const nodeType = computed(() => {
+    if (options.nodeType) {
+      return unref(options.nodeType);
+    }
+    const activeNode = unref(options.node);
+    if (activeNode) {
+      return nodeTypesStore.getNodeType(activeNode.type, activeNode.typeVersion);
+    }
+    return null;
   });
-  const target = targetNode.id;
-  const targetHandle = createCanvasConnectionHandleString({
-    mode: CanvasConnectionMode.Input,
-    type: legacyConnection[1].type,
-    index: legacyConnection[1].index
+  const isSubNodeType$1 = computed(() => isSubNodeType(nodeType.value));
+  const isMultipleOutputsNodeType = computed(() => {
+    const outputs = nodeType.value?.outputs;
+    if (typeof outputs === "string") return false;
+    return (outputs ?? []).length > 1;
   });
   return {
-    source,
-    sourceHandle,
-    target,
-    targetHandle
+    nodeType,
+    isSubNodeType: isSubNodeType$1,
+    isMultipleOutputsNodeType
   };
 }
-function parseCanvasConnectionHandleString(handle) {
-  const [mode, type, index] = (handle ?? "").split("/");
-  const resolvedMode = isValidCanvasConnectionMode(mode) ? mode : CanvasConnectionMode.Output;
-  const resolvedType = isValidNodeConnectionType(type) ? type : NodeConnectionType.Main;
-  let resolvedIndex = parseInt(index, 10);
-  if (isNaN(resolvedIndex)) {
-    resolvedIndex = 0;
+function usePinnedData(node, options = {}) {
+  const rootStore = useRootStore();
+  const workflowsStore = useWorkflowsStore();
+  const toast = useToast();
+  const i18n2 = useI18n();
+  const telemetry = useTelemetry();
+  const externalHooks = useExternalHooks();
+  const { getInputDataWithPinned } = useDataSchema();
+  const { isSubNodeType: isSubNodeType2, isMultipleOutputsNodeType } = useNodeType({
+    node
+  });
+  const data = computed(() => {
+    const targetNode = unref(node);
+    return targetNode ? workflowsStore.pinDataByNodeName(targetNode.name) : void 0;
+  });
+  const hasData = computed(() => {
+    const targetNode = unref(node);
+    return !!targetNode && typeof data.value !== "undefined";
+  });
+  const isValidNodeType = computed(() => {
+    const targetNode = unref(node);
+    return !!targetNode && !isSubNodeType2.value && !isMultipleOutputsNodeType.value && !PIN_DATA_NODE_TYPES_DENYLIST.includes(targetNode.type);
+  });
+  function canPinNode(checkDataEmpty = false, outputIndex) {
+    const targetNode = unref(node);
+    if (targetNode === null || PIN_DATA_NODE_TYPES_DENYLIST.includes(targetNode.type)) return false;
+    const nodeType = useNodeTypesStore().getNodeType(targetNode.type, targetNode.typeVersion);
+    const dataToPin = getInputDataWithPinned(targetNode);
+    if (!nodeType || checkDataEmpty && dataToPin.length === 0) return false;
+    const workflow = workflowsStore.getCurrentWorkflow();
+    const outputs = getNodeOutputs(workflow, targetNode, nodeType).map(
+      (output) => typeof output === "string" ? { type: output } : output
+    );
+    const mainOutputs = outputs.filter(
+      (output) => output.type === NodeConnectionTypes.Main && output.category !== "error"
+    );
+    let indexAcceptable = true;
+    if (outputIndex !== void 0) {
+      const output = outputs[outputIndex];
+      if (outputs[outputIndex] === void 0) return false;
+      indexAcceptable = output.type === NodeConnectionTypes.Main && output.category !== "error";
+    }
+    return mainOutputs.length === 1 && indexAcceptable;
   }
-  return {
-    mode: resolvedMode,
-    type: resolvedType,
-    index: resolvedIndex
-  };
-}
-function createCanvasConnectionHandleString({
-  mode,
-  type = NodeConnectionType.Main,
-  index = 0
-}) {
-  return `${mode}/${type}/${index}`;
-}
-function createCanvasConnectionId(connection) {
-  return `[${connection.source}/${connection.sourceHandle}][${connection.target}/${connection.targetHandle}]`;
-}
-function mapCanvasConnectionToLegacyConnection(sourceNode, targetNode, connection) {
-  const sourceNodeName = sourceNode?.name ?? "";
-  const { type: sourceType, index: sourceIndex } = parseCanvasConnectionHandleString(
-    connection.sourceHandle
-  );
-  const targetNodeName = targetNode?.name ?? "";
-  const { type: targetType, index: targetIndex } = parseCanvasConnectionHandleString(
-    connection.targetHandle
-  );
-  return [
-    {
-      node: sourceNodeName,
-      type: sourceType,
-      index: sourceIndex
-    },
-    {
-      node: targetNodeName,
-      type: targetType,
-      index: targetIndex
+  function isValidJSON(data2) {
+    try {
+      JSON.parse(data2);
+      return true;
+    } catch (error) {
+      const title = i18n2.baseText("runData.editOutputInvalid");
+      const toRemove = new RegExp(/JSON\.parse:|of the JSON data/, "g");
+      const message = error.message.replace(toRemove, "").trim();
+      const positionMatchRegEx = /at position (\d+)/;
+      const positionMatch = error.message.match(positionMatchRegEx);
+      error.message = message.charAt(0).toUpperCase() + message.slice(1);
+      error.message = error.message.replace(
+        "Unexpected token ' in JSON",
+        i18n2.baseText("runData.editOutputInvalid.singleQuote")
+      );
+      if (positionMatch) {
+        const position = parseInt(positionMatch[1], 10);
+        const lineBreaksUpToPosition = (data2.slice(0, position).match(/\n/g) || []).length;
+        error.message = error.message.replace(
+          positionMatchRegEx,
+          i18n2.baseText("runData.editOutputInvalid.atPosition", {
+            interpolate: {
+              position: `${position}`
+            }
+          })
+        );
+        error.message = `${i18n2.baseText("runData.editOutputInvalid.onLine", {
+          interpolate: {
+            line: `${lineBreaksUpToPosition + 1}`
+          }
+        })} ${error.message}`;
+      }
+      toast.showError(error, title);
+      return false;
     }
-  ];
-}
-function mapLegacyEndpointsToCanvasConnectionPort(endpoints, endpointNames = []) {
-  if (typeof endpoints === "string") {
-    console.warn("Node endpoints have not been evaluated", endpoints);
-    return [];
   }
-  return endpoints.map((endpoint, endpointIndex) => {
-    const typeValue = typeof endpoint === "string" ? endpoint : endpoint.type;
-    const type = isValidNodeConnectionType(typeValue) ? typeValue : NodeConnectionType.Main;
-    const label = typeof endpoint === "string" ? endpointNames[endpointIndex] : endpoint.displayName;
-    const index = endpoints.slice(0, endpointIndex + 1).filter((e) => (typeof e === "string" ? e : e.type) === type).length - 1;
-    const required = typeof endpoint === "string" ? false : endpoint.required;
-    const maxConnections = typeof endpoint === "string" ? void 0 : endpoint.maxConnections;
-    return {
-      type,
-      index,
-      label,
-      ...maxConnections ? { maxConnections } : {},
-      ...required ? { required } : {}
+  function getMaxPinnedDataSize() {
+    return window.maxPinnedDataSize ?? MAX_PINNED_DATA_SIZE;
+  }
+  function isValidSize(data2) {
+    const targetNode = unref(node);
+    if (!targetNode) {
+      return false;
+    }
+    if (typeof data2 === "object") data2 = JSON.stringify(data2);
+    const { pinData: currentPinData, ...workflow } = workflowsStore.getCurrentWorkflow();
+    const workflowJson = jsonStringify(workflow, { replaceCircularRefs: true });
+    const newPinData = { ...currentPinData, [targetNode.name]: data2 };
+    const newPinDataSize = workflowsStore.getPinDataSize(newPinData);
+    if (newPinDataSize > getMaxPinnedDataSize()) {
+      toast.showError(
+        new Error(
+          i18n2.baseText("ndv.pinData.error.tooLarge.description", {
+            interpolate: {
+              size: toMegaBytes(newPinDataSize),
+              limit: toMegaBytes(getMaxPinnedDataSize())
+            }
+          })
+        ),
+        i18n2.baseText("ndv.pinData.error.tooLarge.title")
+      );
+      return false;
+    }
+    const workflowSize = stringSizeInBytes(workflowJson) + newPinDataSize;
+    const limit = MAX_WORKFLOW_SIZE - MAX_EXPECTED_REQUEST_SIZE;
+    if (workflowSize > limit) {
+      toast.showError(
+        new Error(
+          i18n2.baseText("ndv.pinData.error.tooLargeWorkflow.description", {
+            interpolate: { size: toMegaBytes(workflowSize), limit: toMegaBytes(limit) }
+          })
+        ),
+        i18n2.baseText("ndv.pinData.error.tooLargeWorkflow.title")
+      );
+      return false;
+    }
+    return true;
+  }
+  function onSetDataSuccess({ source }) {
+    const targetNode = unref(node);
+    const displayMode = unref(options.displayMode);
+    const runIndex = unref(options.runIndex);
+    const telemetryPayload = {
+      pinning_source: source,
+      node_type: targetNode?.type,
+      push_ref: rootStore.pushRef,
+      data_size: stringSizeInBytes(data.value),
+      view: displayMode,
+      run_index: runIndex
     };
-  });
-}
-function checkOverlap(node1, node2) {
-  return !// node1 is completely to the left of node2
-  (node1.x + node1.width <= node2.x || // node2 is completely to the left of node1
-  node2.x + node2.width <= node1.x || // node1 is completely above node2
-  node1.y + node1.height <= node2.y || // node2 is completely above node1
-  node2.y + node2.height <= node1.y);
-}
-function insertSpacersBetweenEndpoints(endpoints, requiredEndpointsCount = 0, minEndpointsCount = 4) {
-  const endpointsWithSpacers = [...endpoints];
-  const optionalNonMainInputsCount = endpointsWithSpacers.length - requiredEndpointsCount;
-  const spacerCount = minEndpointsCount - requiredEndpointsCount - optionalNonMainInputsCount;
-  if (endpointsWithSpacers.length < minEndpointsCount) {
-    for (let i = 0; i < spacerCount; i++) {
-      endpointsWithSpacers.splice(requiredEndpointsCount + i, 0, null);
+    void externalHooks.run("runData.onDataPinningSuccess", telemetryPayload);
+    telemetry.track("Ndv data pinning success", telemetryPayload);
+  }
+  function onSetDataError({
+    errorType,
+    source
+  }) {
+    const targetNode = unref(node);
+    const displayMode = unref(options.displayMode);
+    const runIndex = unref(options.runIndex);
+    telemetry.track("Ndv data pinning failure", {
+      pinning_source: source,
+      node_type: targetNode?.type,
+      push_ref: rootStore.pushRef,
+      data_size: stringSizeInBytes(data.value),
+      view: displayMode,
+      run_index: runIndex,
+      error_type: errorType
+    });
+  }
+  function setData(data2, source) {
+    const targetNode = unref(node);
+    if (!targetNode) {
+      return;
+    }
+    if (typeof data2 === "string") {
+      if (!isValidJSON(data2)) {
+        onSetDataError({ errorType: "invalid-json", source });
+        throw new Error("Invalid JSON");
+      }
+      data2 = jsonParse(data2);
+    }
+    if (!isValidSize(data2)) {
+      onSetDataError({ errorType: "data-too-large", source });
+      throw new Error("Data too large");
     }
+    workflowsStore.pinData({ node: targetNode, data: data2 });
+    onSetDataSuccess({ source });
   }
-  return endpointsWithSpacers;
+  function onUnsetData({ source }) {
+    const targetNode = unref(node);
+    const runIndex = unref(options.runIndex);
+    telemetry.track("User unpinned ndv data", {
+      node_type: targetNode?.type,
+      push_ref: rootStore.pushRef,
+      run_index: runIndex,
+      source,
+      data_size: stringSizeInBytes(data.value)
+    });
+  }
+  function unsetData(source) {
+    const targetNode = unref(node);
+    if (!targetNode) {
+      return;
+    }
+    onUnsetData({ source });
+    workflowsStore.unpinData({ node: targetNode });
+  }
+  return {
+    data,
+    hasData,
+    isValidNodeType,
+    canPinNode,
+    setData,
+    onSetDataSuccess,
+    onSetDataError,
+    unsetData,
+    onUnsetData,
+    isValidJSON,
+    isValidSize
+  };
 }
 const SEQUENTIAL_BONUS = 60;
 const SEPARATOR_BONUS = 30;
@@ -663,7 +766,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_DOCUMENT_LOADERS,
           info: getSubcategoryInfo(AI_CATEGORY_DOCUMENT_LOADERS),
           icon: "file-import",
-          ...getAISubcategoryProperties(NodeConnectionType.AiDocument)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiDocument)
         }
       },
       {
@@ -673,7 +776,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_LANGUAGE_MODELS,
           info: getSubcategoryInfo(AI_CATEGORY_LANGUAGE_MODELS),
           icon: "language",
-          ...getAISubcategoryProperties(NodeConnectionType.AiLanguageModel)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiLanguageModel)
         }
       },
       {
@@ -683,7 +786,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_MEMORY,
           info: getSubcategoryInfo(AI_CATEGORY_MEMORY),
           icon: "brain",
-          ...getAISubcategoryProperties(NodeConnectionType.AiMemory)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiMemory)
         }
       },
       {
@@ -693,7 +796,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_OUTPUTPARSER,
           info: getSubcategoryInfo(AI_CATEGORY_OUTPUTPARSER),
           icon: "list",
-          ...getAISubcategoryProperties(NodeConnectionType.AiOutputParser)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiOutputParser)
         }
       },
       {
@@ -703,7 +806,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_RETRIEVERS,
           info: getSubcategoryInfo(AI_CATEGORY_RETRIEVERS),
           icon: "search",
-          ...getAISubcategoryProperties(NodeConnectionType.AiRetriever)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiRetriever)
         }
       },
       {
@@ -713,7 +816,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_TEXT_SPLITTERS,
           info: getSubcategoryInfo(AI_CATEGORY_TEXT_SPLITTERS),
           icon: "grip-lines-vertical",
-          ...getAISubcategoryProperties(NodeConnectionType.AiTextSplitter)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiTextSplitter)
         }
       },
       {
@@ -724,7 +827,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_TOOLS,
           info: getSubcategoryInfo(AI_CATEGORY_TOOLS),
           icon: "tools",
-          ...getAISubcategoryProperties(NodeConnectionType.AiTool),
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiTool),
           sections: [
             {
               key: "popular",
@@ -741,7 +844,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_EMBEDDING,
           info: getSubcategoryInfo(AI_CATEGORY_EMBEDDING),
           icon: "vector-square",
-          ...getAISubcategoryProperties(NodeConnectionType.AiEmbedding)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiEmbedding)
         }
       },
       {
@@ -751,7 +854,7 @@ function AINodesView(_nodes) {
           title: AI_CATEGORY_VECTOR_STORES,
           info: getSubcategoryInfo(AI_CATEGORY_VECTOR_STORES),
           icon: "project-diagram",
-          ...getAISubcategoryProperties(NodeConnectionType.AiVectorStore)
+          ...getAISubcategoryProperties(NodeConnectionTypes.AiVectorStore)
         }
       },
       {
@@ -1442,6 +1545,169 @@ const useViewStacks = defineStore("nodeCreatorViewStacks", () => {
     popViewStack
   };
 });
+function mapLegacyConnectionsToCanvasConnections(legacyConnections, nodes) {
+  const mappedConnections = [];
+  Object.keys(legacyConnections).forEach((fromNodeName) => {
+    const fromId = nodes.find((node) => node.name === fromNodeName)?.id ?? "";
+    const fromConnectionTypes = Object.keys(
+      legacyConnections[fromNodeName]
+    );
+    fromConnectionTypes.forEach((fromConnectionType) => {
+      const fromPorts = legacyConnections[fromNodeName][fromConnectionType];
+      fromPorts?.forEach((toPorts, fromIndex) => {
+        toPorts?.forEach((toPort) => {
+          const toNodeName = toPort.node;
+          const toId = nodes.find((node) => node.name === toNodeName)?.id ?? "";
+          const toConnectionType = toPort.type;
+          const toIndex = toPort.index;
+          const sourceHandle = createCanvasConnectionHandleString({
+            mode: CanvasConnectionMode.Output,
+            type: fromConnectionType,
+            index: fromIndex
+          });
+          const targetHandle = createCanvasConnectionHandleString({
+            mode: CanvasConnectionMode.Input,
+            type: toConnectionType,
+            index: toIndex
+          });
+          const connectionId = createCanvasConnectionId({
+            source: fromId,
+            sourceHandle,
+            target: toId,
+            targetHandle
+          });
+          if (fromId && toId) {
+            mappedConnections.push({
+              id: connectionId,
+              source: fromId,
+              target: toId,
+              sourceHandle,
+              targetHandle,
+              data: {
+                source: {
+                  node: fromNodeName,
+                  index: fromIndex,
+                  type: fromConnectionType
+                },
+                target: {
+                  node: toNodeName,
+                  index: toIndex,
+                  type: toConnectionType
+                }
+              }
+            });
+          }
+        });
+      });
+    });
+  });
+  return mappedConnections;
+}
+function mapLegacyConnectionToCanvasConnection(sourceNode, targetNode, legacyConnection) {
+  const source = sourceNode.id;
+  const sourceHandle = createCanvasConnectionHandleString({
+    mode: CanvasConnectionMode.Output,
+    type: legacyConnection[0].type,
+    index: legacyConnection[0].index
+  });
+  const target = targetNode.id;
+  const targetHandle = createCanvasConnectionHandleString({
+    mode: CanvasConnectionMode.Input,
+    type: legacyConnection[1].type,
+    index: legacyConnection[1].index
+  });
+  return {
+    source,
+    sourceHandle,
+    target,
+    targetHandle
+  };
+}
+function parseCanvasConnectionHandleString(handle) {
+  const [mode, type, index] = (handle ?? "").split("/");
+  const resolvedMode = isValidCanvasConnectionMode(mode) ? mode : CanvasConnectionMode.Output;
+  const resolvedType = isValidNodeConnectionType(type) ? type : NodeConnectionTypes.Main;
+  let resolvedIndex = parseInt(index, 10);
+  if (isNaN(resolvedIndex)) {
+    resolvedIndex = 0;
+  }
+  return {
+    mode: resolvedMode,
+    type: resolvedType,
+    index: resolvedIndex
+  };
+}
+function createCanvasConnectionHandleString({
+  mode,
+  type = NodeConnectionTypes.Main,
+  index = 0
+}) {
+  return `${mode}/${type}/${index}`;
+}
+function createCanvasConnectionId(connection) {
+  return `[${connection.source}/${connection.sourceHandle}][${connection.target}/${connection.targetHandle}]`;
+}
+function mapCanvasConnectionToLegacyConnection(sourceNode, targetNode, connection) {
+  const sourceNodeName = sourceNode?.name ?? "";
+  const { type: sourceType, index: sourceIndex } = parseCanvasConnectionHandleString(
+    connection.sourceHandle
+  );
+  const targetNodeName = targetNode?.name ?? "";
+  const { type: targetType, index: targetIndex } = parseCanvasConnectionHandleString(
+    connection.targetHandle
+  );
+  return [
+    {
+      node: sourceNodeName,
+      type: sourceType,
+      index: sourceIndex
+    },
+    {
+      node: targetNodeName,
+      type: targetType,
+      index: targetIndex
+    }
+  ];
+}
+function mapLegacyEndpointsToCanvasConnectionPort(endpoints, endpointNames = []) {
+  if (typeof endpoints === "string") {
+    console.warn("Node endpoints have not been evaluated", endpoints);
+    return [];
+  }
+  return endpoints.map((endpoint, endpointIndex) => {
+    const typeValue = typeof endpoint === "string" ? endpoint : endpoint.type;
+    const type = isValidNodeConnectionType(typeValue) ? typeValue : NodeConnectionTypes.Main;
+    const label = typeof endpoint === "string" ? endpointNames[endpointIndex] : endpoint.displayName;
+    const index = endpoints.slice(0, endpointIndex + 1).filter((e) => (typeof e === "string" ? e : e.type) === type).length - 1;
+    const required = typeof endpoint === "string" ? false : endpoint.required;
+    const maxConnections = typeof endpoint === "string" ? void 0 : endpoint.maxConnections;
+    return {
+      type,
+      index,
+      label,
+      ...maxConnections ? { maxConnections } : {},
+      ...required ? { required } : {}
+    };
+  });
+}
+function checkOverlap(node1, node2) {
+  return !// node1 is completely to the left of node2
+  (node1.x + node1.width <= node2.x || // node2 is completely to the left of node1
+  node2.x + node2.width <= node1.x || // node1 is completely above node2
+  node1.y + node1.height <= node2.y || // node2 is completely above node1
+  node2.y + node2.height <= node1.y);
+}
+function insertSpacersBetweenEndpoints(endpoints, requiredEndpointsCount = 0, minEndpointsCount = 4) {
+  const endpointsWithSpacers = [...endpoints];
+  const optionalNonMainInputsCount = endpointsWithSpacers.length - requiredEndpointsCount;
+  const spacerCount = minEndpointsCount - requiredEndpointsCount - optionalNonMainInputsCount;
+  if (endpointsWithSpacers.length < minEndpointsCount) {
+    for (let i = 0; i < spacerCount; i++) {
+      endpointsWithSpacers.splice(requiredEndpointsCount + i, 0, null);
+    }
+  }
+  return endpointsWithSpacers;
+}
 const useNodeCreatorStore = defineStore(STORES.NODE_CREATOR, () => {
   const workflowsStore = useWorkflowsStore();
   const ndvStore = useNDVStore();
@@ -1548,7 +1814,7 @@ const useNodeCreatorStore = defineStore(STORES.NODE_CREATOR, () => {
     uiStore.lastInteractedWithNodeHandle = connection.sourceHandle ?? null;
     uiStore.lastInteractedWithNodeId = sourceNode.id;
     const isOutput = mode === CanvasConnectionMode.Output;
-    const isScopedConnection = type !== NodeConnectionType.Main;
+    const isScopedConnection = type !== NodeConnectionTypes.Main;
     setNodeCreatorState({
       source: eventSource,
       createNodeActive: true,
@@ -1807,6 +2073,20 @@ function useCanvasOperations({ router }) {
   const triggerNodes = computed(() => {
     return workflowsStore.workflowTriggerNodes;
   });
+  function tidyUp({ result, source, target }) {
+    updateNodesPosition(
+      result.nodes.map(({ id, x, y }) => ({ id, position: { x, y } })),
+      { trackBulk: true, trackHistory: true }
+    );
+    trackTidyUp({ result, source, target });
+  }
+  function trackTidyUp({ result, source, target }) {
+    telemetry.track("User tidied up canvas", {
+      source,
+      target,
+      nodes_count: result.nodes.length
+    });
+  }
   function updateNodesPosition(events, { trackHistory = false, trackBulk = true } = {}) {
     if (trackHistory && trackBulk) {
       historyStore.startRecordingUndo();
@@ -2218,13 +2498,13 @@ function useCanvasOperations({ router }) {
         source: lastInteractedWithNodeId,
         sourceHandle: createCanvasConnectionHandleString({
           mode: CanvasConnectionMode.Output,
-          type: NodeConnectionType.Main,
+          type: NodeConnectionTypes.Main,
           index: 0
         }),
         target: node.id,
         targetHandle: createCanvasConnectionHandleString({
           mode: CanvasConnectionMode.Input,
-          type: NodeConnectionType.Main,
+          type: NodeConnectionTypes.Main,
           index: 0
         })
       });
@@ -2237,7 +2517,7 @@ function useCanvasOperations({ router }) {
           source: node.id,
           sourceHandle: createCanvasConnectionHandleString({
             mode: CanvasConnectionMode.Input,
-            type: NodeConnectionType.Main,
+            type: NodeConnectionTypes.Main,
             index: 0
           }),
           target: lastInteractedWithNodeConnection.target,
@@ -2341,7 +2621,7 @@ function useCanvasOperations({ router }) {
     const { type: connectionType, index: connectionIndex } = parseCanvasConnectionHandleString(
       lastInteractedWithNodeHandle ?? lastInteractedWithNodeConnection?.sourceHandle ?? ""
     );
-    const nodeSize = connectionType === NodeConnectionType.Main ? DEFAULT_NODE_SIZE : CONFIGURATION_NODE_SIZE;
+    const nodeSize = connectionType === NodeConnectionTypes.Main ? DEFAULT_NODE_SIZE : CONFIGURATION_NODE_SIZE;
     if (lastInteractedWithNode) {
       const lastInteractedWithNodeTypeDescription = nodeTypesStore.getNodeType(
         lastInteractedWithNode.type,
@@ -2352,8 +2632,8 @@ function useCanvasOperations({ router }) {
       );
       const newNodeInsertPosition = uiStore.lastCancelledConnectionPosition;
       if (newNodeInsertPosition) {
-        const xOffset = connectionType === NodeConnectionType.Main ? 0 : -nodeSize[0] / 2;
-        const yOffset = connectionType === NodeConnectionType.Main ? -nodeSize[1] / 2 : 0;
+        const xOffset = connectionType === NodeConnectionTypes.Main ? 0 : -nodeSize[0] / 2;
+        const yOffset = connectionType === NodeConnectionTypes.Main ? -nodeSize[1] / 2 : 0;
         position = [newNodeInsertPosition[0] + xOffset, newNodeInsertPosition[1] + yOffset];
         uiStore.lastCancelledConnectionPosition = void 0;
       } else if (lastInteractedWithNodeTypeDescription && lastInteractedWithNodeObject) {
@@ -2365,7 +2645,7 @@ function useCanvasOperations({ router }) {
         const lastInteractedWithNodeInputTypes = getConnectionTypes(
           lastInteractedWithNodeInputs
         );
-        const lastInteractedWithNodeScopedInputTypes = (lastInteractedWithNodeInputTypes || []).filter((input) => input !== NodeConnectionType.Main);
+        const lastInteractedWithNodeScopedInputTypes = (lastInteractedWithNodeInputTypes || []).filter((input) => input !== NodeConnectionTypes.Main);
         const lastInteractedWithNodeOutputs = getNodeOutputs(
           editableWorkflowObject.value,
           lastInteractedWithNodeObject,
@@ -2375,7 +2655,7 @@ function useCanvasOperations({ router }) {
           lastInteractedWithNodeOutputs
         );
         const lastInteractedWithNodeMainOutputs = lastInteractedWithNodeOutputTypes.filter(
-          (output) => output === NodeConnectionType.Main
+          (output) => output === NodeConnectionTypes.Main
         );
         let yOffset = 0;
         if (lastInteractedWithNodeConnection) {
@@ -2402,7 +2682,7 @@ function useCanvasOperations({ router }) {
         }
         const outputTypes = getConnectionTypes(outputs);
         pushOffsets = [100, 0];
-        if (outputTypes.length > 0 && outputTypes.every((outputName) => outputName !== NodeConnectionType.Main)) {
+        if (outputTypes.length > 0 && outputTypes.every((outputName) => outputName !== NodeConnectionTypes.Main)) {
           const scopedConnectionIndex = lastInteractedWithNodeScopedInputTypes.findIndex(
             (inputType) => outputs[0] === inputType
           );
@@ -2416,7 +2696,7 @@ function useCanvasOperations({ router }) {
           ];
         } else {
           let pushOffset = PUSH_NODES_OFFSET;
-          if (!!lastInteractedWithNodeInputTypes.find((input) => input !== NodeConnectionType.Main)) {
+          if (!!lastInteractedWithNodeInputTypes.find((input) => input !== NodeConnectionTypes.Main)) {
             pushOffset += 140;
           }
           position = [
@@ -3075,7 +3355,9 @@ function useCanvasOperations({ router }) {
   }
   async function toggleChatOpen(source) {
     const workflow = workflowsStore.getCurrentWorkflow();
-    workflowsStore.setPanelOpen("chat", !workflowsStore.isChatPanelOpen);
+    workflowsStore.setPanelState(
+      workflowsStore.chatPanelState === "closed" ? "attached" : "closed"
+    );
     const payload = {
       workflow_id: workflow.id,
       button_type: source
@@ -3108,6 +3390,7 @@ function useCanvasOperations({ router }) {
     revertAddNode,
     updateNodesPosition,
     updateNodePosition,
+    tidyUp,
     revertUpdateNodePosition,
     setNodeActive,
     setNodeActiveByName,
@@ -3148,23 +3431,27 @@ function useCanvasOperations({ router }) {
   };
 }
 export {
-  AIView as A,
+  AINodesView as A,
   RegularView as R,
   TriggerView as T,
-  useCanvasOperations as a,
-  checkOverlap as b,
+  useNodeCreatorStore as a,
+  useCanvasOperations as b,
   createCanvasConnectionHandleString as c,
-  mapLegacyConnectionsToCanvasConnections as d,
-  useViewStacks as e,
-  formatTriggerActionName as f,
-  camelCase as g,
-  useKeyboardNavigation as h,
+  capitalize as d,
+  checkOverlap as e,
+  mapLegacyConnectionsToCanvasConnections as f,
+  useNodeType as g,
+  upperFirst as h,
   insertSpacersBetweenEndpoints as i,
-  flattenCreateElements as j,
-  AINodesView as k,
+  formatTriggerActionName as j,
+  useViewStacks as k,
+  camelCase as l,
   mapLegacyEndpointsToCanvasConnectionPort as m,
+  useKeyboardNavigation as n,
+  AIView as o,
   parseCanvasConnectionHandleString as p,
+  flattenCreateElements as q,
   sortNodeCreateElements as s,
   transformNodeType as t,
-  useNodeCreatorStore as u
+  usePinnedData as u
 };