n8n-editor-ui 1.81.2 → 1.82.0

package/dist/assets/{useCanvasOperations-C-zV2Jxd.js → useCanvasOperations-DvuQ2UqW.js}

@@ -1,5 +1,5 @@
-import { dK as createCompounder, dL as SetCache, dM as arrayIncludes, dN as cacheHas, dO as baseRest, dP as isArrayLikeObject, dQ as baseFlatten, bh as NodeConnectionType, bK as CanvasConnectionMode, dR as isValidCanvasConnectionMode, bL as isValidNodeConnectionType, bk as v4, dS as CORE_NODES_CATEGORY, dT as DEFAULT_SUBCATEGORY, p as useSettingsStore, dU as AI_TRANSFORM_NODE_TYPE, dV as sublimeSearch, ba as AI_SUBCATEGORY, bb as AI_CATEGORY_AGENTS, dW as sortBy, cY as i18n, dX as AI_CATEGORY_OTHER_TOOLS, dY as SEND_AND_WAIT_OPERATION, dZ as HUMAN_IN_THE_LOOP_CATEGORY, bo as useNodeTypesStore, aM as useTemplatesStore, d_ as AI_NODE_CREATOR_VIEW, d$ as AI_OTHERS_NODE_CREATOR_VIEW, e0 as AI_CATEGORY_DOCUMENT_LOADERS, e1 as AI_CATEGORY_LANGUAGE_MODELS, e2 as AI_CATEGORY_MEMORY, e3 as AI_CATEGORY_OUTPUTPARSER, e4 as AI_CATEGORY_RETRIEVERS, e5 as AI_CATEGORY_TEXT_SPLITTERS, e6 as AI_CATEGORY_TOOLS, e7 as AI_WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE, e8 as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, e9 as AI_CATEGORY_EMBEDDING, ea as AI_CATEGORY_VECTOR_STORES, eb as AI_UNCATEGORIZED_CATEGORY, ec as TRIGGER_NODE_CREATOR_VIEW, ed as MANUAL_TRIGGER_NODE_TYPE, ee as WEBHOOK_NODE_TYPE, ef as EMAIL_IMAP_NODE_TYPE, eg as SCHEDULE_TRIGGER_NODE_TYPE, eh as FORM_TRIGGER_NODE_TYPE, di as EXECUTE_WORKFLOW_TRIGGER_NODE_TYPE, b7 as CHAT_TRIGGER_NODE_TYPE, ei as OTHER_TRIGGER_NODES_SUBCATEGORY, ej as REGULAR_NODE_CREATOR_VIEW, ek as RSS_READ_NODE_TYPE, el as EMAIL_SEND_NODE_TYPE, em as TRANSFORM_DATA_SUBCATEGORY, en as FILTER_NODE_TYPE, eo as REMOVE_DUPLICATES_NODE_TYPE, ep as SPLIT_OUT_NODE_TYPE, eq as LIMIT_NODE_TYPE, er as SUMMARIZE_NODE_TYPE, es as AGGREGATE_NODE_TYPE, et as MERGE_NODE_TYPE, eu as HTML_NODE_TYPE, ev as MARKDOWN_NODE_TYPE, ew as XML_NODE_TYPE, ex as CRYPTO_NODE_TYPE, ey as EXTRACT_FROM_FILE_NODE_TYPE, ez as CONVERT_TO_FILE_NODE_TYPE, eA as COMPRESSION_NODE_TYPE, eB as EDIT_IMAGE_NODE_TYPE, eC as FLOWS_CONTROL_SUBCATEGORY, eD as IF_NODE_TYPE, eE as SPLIT_IN_BATCHES_NODE_TYPE, eF as HELPERS_SUBCATEGORY, eG as HTTP_REQUEST_NODE_TYPE, eH as CODE_NODE_TYPE, eI as HITL_SUBCATEGORY, g as useI18n, bc as AI_CATEGORY_CHAINS, eJ as SET_NODE_TYPE, eK as DATETIME_NODE_TYPE, S as defineStore, r as ref, q as computed, a0 as useCanvasStore, eL as AI_CATEGORY_ROOT_NODES, z as nextTick, bd as AI_CODE_NODE_TYPE, eM as AI_TRANSFORM_NODE_TYPE$1, T as STORES, U as useWorkflowsStore, as as useNDVStore, L as useUIStore, bJ as NODE_CREATOR_OPEN_SOURCES, eN as isVueFlowConnection, be as getNodeInputs, eO as CUSTOM_API_CALL_KEY, aT as useExternalHooks, ak as useTelemetry, $ as useRootStore, bu as useCredentialsStore, bx as useHistoryStore, E as useTagsStore, at as useExecutionsStore, a2 as useProjectsStore, a as useToast, a5 as useWorkflowHelpers, bp as useNodeHelpers, b6 as useClipboard, eP as MoveNodeCommand, eQ as RenameNodeCommand, eR as AddConnectionCommand, eS as RemoveNodeCommand, aB as STICKY_NODE_TYPE, dy as useDataSchema, eT as NODE_SIZE, eU as GRID_SIZE, eV as AddNodeCommand, eW as getNodeParameters, eX as getNewNodePosition, eY as DEFAULT_NODE_SIZE, eZ as CONFIGURATION_NODE_SIZE, bf as getConnectionTypes, bg as getNodeOutputs, e_ as generateOffsets, e$ as CONFIGURABLE_NODE_SIZE, f0 as PUSH_NODES_OFFSET, f1 as RemoveConnectionCommand, f2 as UPDATE_WEBHOOK_ID_NODE_TYPES, dc as generateNodesGraph, a9 as EnterpriseEditionFeature, bU as deepCopy, f3 as isPresent } from "./index-C06tkpld.js";
-import { c as capitalize, u as usePinnedData } from "./usePinnedData-Hq06xPoo.js";
+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-BGYw7Tle.js";
+import { c as capitalize, u as usePinnedData } from "./usePinnedData-DEotvVuQ.js";
 var camelCase = createCompounder(function(result, word, index) {
   word = word.toLowerCase();
   return result + (index ? capitalize(word) : word);
@@ -199,6 +199,194 @@ function insertSpacersBetweenEndpoints(endpoints, requiredEndpointsCount = 0, mi
   }
   return endpointsWithSpacers;
 }
+const SEQUENTIAL_BONUS = 60;
+const SEPARATOR_BONUS = 30;
+const CAMEL_BONUS = 30;
+const FIRST_LETTER_BONUS = 15;
+const LEADING_LETTER_PENALTY = -20;
+const MAX_LEADING_LETTER_PENALTY = -200;
+const UNMATCHED_LETTER_PENALTY = -5;
+function fuzzyMatchSimple(pattern, target) {
+  let patternIdx = 0;
+  let strIdx = 0;
+  while (patternIdx < pattern.length && strIdx < target.length) {
+    const patternChar = pattern.charAt(patternIdx).toLowerCase();
+    const targetChar = target.charAt(strIdx).toLowerCase();
+    if (patternChar === targetChar) {
+      patternIdx++;
+    }
+    ++strIdx;
+  }
+  return pattern.length !== 0 && target.length !== 0 && patternIdx === pattern.length;
+}
+function fuzzyMatchRecursive(pattern, target, patternCurIndex, targetCurrIndex, targetMatches, matches, maxMatches, nextMatch, recursionCount, recursionLimit) {
+  let outScore = 0;
+  if (++recursionCount >= recursionLimit) {
+    return { matched: false, outScore };
+  }
+  if (patternCurIndex === pattern.length || targetCurrIndex === target.length) {
+    return { matched: false, outScore };
+  }
+  let recursiveMatch = false;
+  let bestRecursiveMatches = [];
+  let bestRecursiveScore = 0;
+  let firstMatch = true;
+  while (patternCurIndex < pattern.length && targetCurrIndex < target.length) {
+    if (pattern[patternCurIndex].toLowerCase() === target[targetCurrIndex].toLowerCase()) {
+      if (nextMatch >= maxMatches) {
+        return { matched: false, outScore };
+      }
+      if (firstMatch && targetMatches) {
+        matches = [...targetMatches];
+        firstMatch = false;
+      }
+      const recursiveMatches = [];
+      const recursiveResult = fuzzyMatchRecursive(
+        pattern,
+        target,
+        patternCurIndex,
+        targetCurrIndex + 1,
+        matches,
+        recursiveMatches,
+        maxMatches,
+        nextMatch,
+        recursionCount,
+        recursionLimit
+      );
+      const recursiveScore = recursiveResult.outScore;
+      if (recursiveResult.matched) {
+        if (!recursiveMatch || recursiveScore > bestRecursiveScore) {
+          bestRecursiveMatches = [...recursiveMatches];
+          bestRecursiveScore = recursiveScore;
+        }
+        recursiveMatch = true;
+      }
+      matches[nextMatch++] = targetCurrIndex;
+      ++patternCurIndex;
+    }
+    ++targetCurrIndex;
+  }
+  const matched = patternCurIndex === pattern.length;
+  if (matched) {
+    outScore = 100;
+    if (!target.toLowerCase().startsWith("n8n")) {
+      let penalty = LEADING_LETTER_PENALTY * matches[0];
+      penalty = penalty < MAX_LEADING_LETTER_PENALTY ? MAX_LEADING_LETTER_PENALTY : penalty;
+      outScore += penalty;
+    }
+    const unmatched = target.length - nextMatch;
+    outScore += UNMATCHED_LETTER_PENALTY * unmatched;
+    for (let i = 0; i < nextMatch; i++) {
+      const currIdx = matches[i];
+      if (i > 0) {
+        const prevIdx = matches[i - 1];
+        if (currIdx === prevIdx + 1) {
+          outScore += SEQUENTIAL_BONUS;
+        }
+      }
+      if (currIdx > 0) {
+        const neighbor = target[currIdx - 1];
+        const curr = target[currIdx];
+        if (neighbor !== neighbor.toUpperCase() && curr !== curr.toLowerCase()) {
+          outScore += CAMEL_BONUS;
+        }
+        const isNeighbourSeparator = neighbor === "_" || neighbor === " ";
+        if (isNeighbourSeparator) {
+          outScore += SEPARATOR_BONUS;
+        }
+      } else {
+        outScore += FIRST_LETTER_BONUS;
+      }
+    }
+    if (recursiveMatch && (!matched || bestRecursiveScore > outScore)) {
+      matches = [...bestRecursiveMatches];
+      outScore = bestRecursiveScore;
+      return { matched: true, outScore };
+    } else if (matched) {
+      return { matched: true, outScore };
+    } else {
+      return { matched: false, outScore };
+    }
+  }
+  return { matched: false, outScore };
+}
+function fuzzyMatch(pattern, target) {
+  const recursionCount = 0;
+  const recursionLimit = 5;
+  const matches = [];
+  const maxMatches = 256;
+  return fuzzyMatchRecursive(
+    pattern,
+    target,
+    0,
+    0,
+    null,
+    matches,
+    maxMatches,
+    0,
+    recursionCount,
+    recursionLimit
+  );
+}
+function getValue(obj, prop) {
+  if (obj.hasOwnProperty(prop)) {
+    return obj[prop];
+  }
+  const segments = prop.split(".");
+  let result = obj;
+  let i = 0;
+  while (result && i < segments.length) {
+    const key = segments[i];
+    result = result[key];
+    i++;
+  }
+  return result;
+}
+function sublimeSearch(filter, data, keys) {
+  const results = data.reduce((accu, item) => {
+    let values = [];
+    keys.forEach(({ key, weight }) => {
+      const value = getValue(item, key);
+      if (Array.isArray(value)) {
+        values = values.concat(value.map((v) => ({ value: v, weight })));
+      } else if (typeof value === "string") {
+        values.push({
+          value,
+          weight
+        });
+      }
+    });
+    const itemMatch = values.reduce(
+      (result, { value, weight }) => {
+        if (!fuzzyMatchSimple(filter, value)) {
+          return result;
+        }
+        const match = fuzzyMatch(filter, value);
+        match.outScore *= weight;
+        const { matched, outScore } = match;
+        if (!result && matched) {
+          return match;
+        }
+        if (matched && result && outScore > result.outScore) {
+          return match;
+        }
+        return result;
+      },
+      null
+    );
+    if (itemMatch) {
+      accu.push({
+        score: itemMatch.outScore,
+        item
+      });
+    }
+    return accu;
+  }, []);
+  results.sort((a, b) => {
+    return b.score - a.score;
+  });
+  return results;
+}
 const SPLIT_LOWER_UPPER_RE = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu");
 const SPLIT_UPPER_UPPER_RE = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
 const SPLIT_SEPARATE_NUMBER_RE = new RegExp("(\\d)\\p{Ll}|(\\p{L})\\d", "u");
@@ -791,7 +979,7 @@ function RegularView(nodes) {
       // - add "HITL" to the "categories" property of the node's codex
       // - add "HITL": ["Human in the Loop"] to the "subcategories" property of the node's codex
       // node has to have the "sendAndWait" operation, if a new operation needs to be included here:
-      // - update getHumanInTheLoopActions in packages/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue
+      // - update getHumanInTheLoopActions in packages/frontend/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue
       {
         type: "subcategory",
         key: HITL_SUBCATEGORY,
@@ -1639,7 +1827,9 @@ function useCanvasOperations({ router }) {
     const newPosition = [position.x, position.y];
     workflowsStore.setNodePositionById(id, newPosition);
     if (trackHistory) {
-      historyStore.pushCommandToUndo(new MoveNodeCommand(node.name, oldPosition, newPosition));
+      historyStore.pushCommandToUndo(
+        new MoveNodeCommand(node.name, oldPosition, newPosition, Date.now())
+      );
     }
   }
   function revertUpdateNodePosition(nodeName, position) {
@@ -1660,7 +1850,7 @@ function useCanvasOperations({ router }) {
     const workflow = workflowsStore.getCurrentWorkflow(true);
     workflow.renameNode(currentName, newName);
     if (trackHistory) {
-      historyStore.pushCommandToUndo(new RenameNodeCommand(currentName, newName));
+      historyStore.pushCommandToUndo(new RenameNodeCommand(currentName, newName, Date.now()));
     }
     workflowsStore.renameNodeSelectedAndExecution({ old: currentName, new: newName });
     workflowsStore.setNodes(Object.values(workflow.nodes));
@@ -1694,18 +1884,21 @@ function useCanvasOperations({ router }) {
           if (!outgoingNodeId) continue;
           if (trackHistory) {
             historyStore.pushCommandToUndo(
-              new AddConnectionCommand([
-                {
-                  node: incomingConnection.node,
-                  type,
-                  index: incomingConnection.index
-                },
-                {
-                  node: outgoingConnection.node,
-                  type,
-                  index: outgoingConnection.index
-                }
-              ])
+              new AddConnectionCommand(
+                [
+                  {
+                    node: incomingConnection.node,
+                    type,
+                    index: incomingConnection.index
+                  },
+                  {
+                    node: outgoingConnection.node,
+                    type,
+                    index: outgoingConnection.index
+                  }
+                ],
+                Date.now()
+              )
             );
           }
           createConnection({
@@ -1742,7 +1935,7 @@ function useCanvasOperations({ router }) {
     workflowsStore.removeNodeExecutionDataById(id);
     workflowsStore.removeNodeById(id);
     if (trackHistory) {
-      historyStore.pushCommandToUndo(new RemoveNodeCommand(node));
+      historyStore.pushCommandToUndo(new RemoveNodeCommand(node, Date.now()));
       if (trackBulk) {
         historyStore.stopRecordingUndo();
       }
@@ -1789,6 +1982,9 @@ function useCanvasOperations({ router }) {
   function setNodeActiveByName(name) {
     ndvStore.activeNodeName = name;
   }
+  function clearNodeActive() {
+    ndvStore.activeNodeName = null;
+  }
   function setNodeParameters(id, parameters) {
     const node = workflowsStore.getNodeById(id);
     if (!node) {
@@ -1951,7 +2147,7 @@ function useCanvasOperations({ router }) {
     }
     workflowsStore.addNode(nodeData);
     if (options.trackHistory) {
-      historyStore.pushCommandToUndo(new AddNodeCommand(nodeData));
+      historyStore.pushCommandToUndo(new AddNodeCommand(nodeData, Date.now()));
     }
     if (!options.isAutoAdd) {
       createConnectionToLastInteractedWithNode(nodeData, options);
@@ -2282,7 +2478,8 @@ function useCanvasOperations({ router }) {
     if (trackHistory) {
       historyStore.pushCommandToUndo(
         new AddConnectionCommand(
-          mapCanvasConnectionToLegacyConnection(sourceNode, targetNode, connection)
+          mapCanvasConnectionToLegacyConnection(sourceNode, targetNode, connection),
+          Date.now()
         )
       );
     }
@@ -2384,7 +2581,7 @@ function useCanvasOperations({ router }) {
       connection: mappedConnection
     });
     if (trackHistory) {
-      historyStore.pushCommandToUndo(new RemoveConnectionCommand(mappedConnection));
+      historyStore.pushCommandToUndo(new RemoveConnectionCommand(mappedConnection, Date.now()));
       if (trackBulk) {
         historyStore.stopRecordingUndo();
       }
@@ -2914,6 +3111,7 @@ function useCanvasOperations({ router }) {
     revertUpdateNodePosition,
     setNodeActive,
     setNodeActiveByName,
+    clearNodeActive,
     setNodeSelected,
     toggleNodesDisabled,
     revertToggleNodeDisabled,

package/dist/assets/{useExecutionDebugging-CLBfRoGl.js → useExecutionDebugging-rI6MFxnv.js}

@@ -1,4 +1,4 @@
-import { b as useRouter, a as useToast, U as useWorkflowsStore, p as useSettingsStore, L as useUIStore, a6 as usePageRedirectionHelper, q as computed, a9 as EnterpriseEditionFeature, ap as h, bY as sanitizeHtml, af as MODAL_CONFIRM, V as VIEWS, $ as useRootStore, bZ as isFullExecutionResponse, b_ as DEBUG_PAYWALL_MODAL_KEY, ak as useTelemetry, g as useI18n, al as useMessage } from "./index-C06tkpld.js";
+import { b as useRouter, a as useToast, U as useWorkflowsStore, p as useSettingsStore, L as useUIStore, a6 as usePageRedirectionHelper, q as computed, a9 as EnterpriseEditionFeature, ap as h, bZ as sanitizeHtml, af as MODAL_CONFIRM, V as VIEWS, $ as useRootStore, b_ as isFullExecutionResponse, b$ as DEBUG_PAYWALL_MODAL_KEY, ak as useTelemetry, g as useI18n, al as useMessage } from "./index-BGYw7Tle.js";
 const useExecutionDebugging = () => {
   const telemetry = useTelemetry();
   const router = useRouter();

package/dist/assets/{useExecutionHelpers-7L4-5LnP.js → useExecutionHelpers-DQskduD9.js}

@@ -1,4 +1,4 @@
-import { dJ as dateFormat, b as useRouter, V as VIEWS, g as useI18n, ak as useTelemetry } from "./index-C06tkpld.js";
+import { dS as dateFormat, b as useRouter, V as VIEWS, g as useI18n, ak as useTelemetry } from "./index-BGYw7Tle.js";
 const convertToDisplayDateComponents = (fullDate) => {
   const mask = `d mmm${new Date(fullDate).getFullYear() === (/* @__PURE__ */ new Date()).getFullYear() ? "" : ", yyyy"}#HH:MM:ss`;
   const formattedDate = dateFormat(fullDate, mask);

package/dist/assets/{useImportCurlCommand-Cbk6CGT_.js → useImportCurlCommand-CBugVIsK.js}

@@ -1,6 +1,6 @@
-import { gq as require$$0, c0 as getDefaultExportFromCjs, a as useToast, l as unref, cq as assert, gr as CURL_IMPORT_NOT_SUPPORTED_PROTOCOLS, gs as CURL_IMPORT_NODES_PROTOCOLS, g as useI18n, gt as get } from "./index-C06tkpld.js";
+import { gy as require$$0, c1 as getDefaultExportFromCjs, a as useToast, l as unref, cs as assert, gz as CURL_IMPORT_NOT_SUPPORTED_PROTOCOLS, gA as CURL_IMPORT_NODES_PROTOCOLS, g as useI18n, gB as get } from "./index-BGYw7Tle.js";
 import { c as commonjsRequire } from "./_commonjs-dynamic-modules-TGKdzP3c.js";
-import { i as importCurlEventBus } from "./import-curl-pNf9q0qQ.js";
+import { i as importCurlEventBus } from "./import-curl-DUxX-cV3.js";
 class CCError extends Error {
 }
 const UTF8encoder = new TextEncoder();

package/dist/assets/{usePinnedData-Hq06xPoo.js → usePinnedData-DEotvVuQ.js}

@@ -1,4 +1,4 @@
-import { dr as baseSlice, ds as toString, bo as useNodeTypesStore, q as computed, l as unref, dt as isSubNodeType, $ as useRootStore, U as useWorkflowsStore, a as useToast, du as PIN_DATA_NODE_TYPES_DENYLIST, bg as getNodeOutputs, bh as NodeConnectionType, dv as jsonStringify, dw as toMegaBytes, dx as stringSizeInBytes, bz as jsonParse, g as useI18n, ak as useTelemetry, aT as useExternalHooks, dy as useDataSchema, dz as MAX_PINNED_DATA_SIZE, dA as MAX_WORKFLOW_SIZE, dB as MAX_EXPECTED_REQUEST_SIZE } from "./index-C06tkpld.js";
+import { dA as baseSlice, dB as toString, bp as useNodeTypesStore, q as computed, l as unref, dC as isSubNodeType, $ as useRootStore, U as useWorkflowsStore, a as useToast, dD as PIN_DATA_NODE_TYPES_DENYLIST, bh as getNodeOutputs, bi as NodeConnectionType, dE as jsonStringify, dF as toMegaBytes, dG as stringSizeInBytes, bA as jsonParse, g as useI18n, ak as useTelemetry, aU as useExternalHooks, dH as useDataSchema, dI as MAX_PINNED_DATA_SIZE, dJ as MAX_WORKFLOW_SIZE, dK as MAX_EXPECTED_REQUEST_SIZE } from "./index-BGYw7Tle.js";
 function castSlice(array, start, end) {
   var length = array.length;
   end = end === void 0 ? length : end;

package/dist/assets/{usePushConnection-QnDVQ8As.js → usePushConnection-XtMvldec.js}

@@ -1,7 +1,7 @@
-import { d7 as makeRestApiRequest, S as defineStore, $ as useRootStore, d as defineComponent, bV as resolveDirective, c as openBlock, h as createElementBlock, ax as withDirectives, j as createBaseVNode, t as toDisplayString, l as unref, g as useI18n, a5 as useWorkflowHelpers, bp as useNodeHelpers, a as useToast, bu as useCredentialsStore, bo as useNodeTypesStore, p as useSettingsStore, L as useUIStore, U as useWorkflowsStore, d8 as useAssistantStore, au as usePostHog, r as ref, bH as AI_CREDITS_EXPERIMENT, d9 as parse, da as hasTrimmedItem, db as codeNodeEditorEventBus, ag as WORKFLOW_SETTINGS_MODAL_KEY, dc as generateNodesGraph, ap as h, dd as getTriggerNodeServiceName, de as hasTrimmedData, aT as useExternalHooks, ak as useTelemetry, df as clearPopupWindowState } from "./index-C06tkpld.js";
-import { g as globalLinkActionsEventBus } from "./global-link-actions-DRfLF4y6.js";
-import { u as usePushConnectionStore } from "./pushConnection.store-BqZhZ7-T.js";
-import { g as getEasyAiWorkflowJson } from "./easyAiWorkflowUtils-KW1Ht6j8.js";
+import { d9 as makeRestApiRequest, S as defineStore, $ as useRootStore, d as defineComponent, bW as resolveDirective, c as openBlock, h as createElementBlock, ax as withDirectives, j as createBaseVNode, t as toDisplayString, l as unref, g as useI18n, a5 as useWorkflowHelpers, bq as useNodeHelpers, a as useToast, bv as useCredentialsStore, bp as useNodeTypesStore, p as useSettingsStore, L as useUIStore, U as useWorkflowsStore, da as useAssistantStore, au as usePostHog, r as ref, bI as AI_CREDITS_EXPERIMENT, db as parse, dc as hasTrimmedItem, dd as codeNodeEditorEventBus, ag as WORKFLOW_SETTINGS_MODAL_KEY, de as generateNodesGraph, ap as h, df as getTriggerNodeServiceName, dg as hasTrimmedData, aU as useExternalHooks, ak as useTelemetry, dh as clearPopupWindowState } from "./index-BGYw7Tle.js";
+import { g as globalLinkActionsEventBus } from "./global-link-actions-B95GMIG5.js";
+import { u as usePushConnectionStore } from "./pushConnection.store-BGGIKcjm.js";
+import { g as getEasyAiWorkflowJson } from "./easyAiWorkflowUtils-K9DVRQP8.js";
 const GET_STATUS_ENDPOINT = "/orchestration/worker/status";
 const sendGetWorkerStatus = async (context) => {
   await makeRestApiRequest(context, "POST", GET_STATUS_ENDPOINT);

package/dist/assets/{useRunWorkflow-BJon34Vp.js → useRunWorkflow-CPV3na7d.js}

@@ -1,16 +1,190 @@
-import { bp as useNodeHelpers, a5 as useWorkflowHelpers, a as useToast, p as useSettingsStore, $ as useRootStore, L as useUIStore, U as useWorkflowsStore, at as useExecutionsStore, bh as NodeConnectionType, b7 as CHAT_TRIGGER_NODE_TYPE, bj as get, dn as SINGLE_WEBHOOK_TRIGGERS, dp as displayForm, dq as isEmpty, dc as generateNodesGraph, g as useI18n, ak as useTelemetry, aT as useExternalHooks } from "./index-C06tkpld.js";
-import { u as usePushConnectionStore } from "./pushConnection.store-BqZhZ7-T.js";
-const getDirtyNodeNames = (runData, getParametersLastUpdate) => {
-  const dirtyNodeNames = Object.entries(runData).reduce((acc, [nodeName, tasks]) => {
-    if (!tasks.length) return acc;
-    const updatedAt = getParametersLastUpdate(nodeName) ?? 0;
-    if (updatedAt > tasks[0].startTime) {
-      acc.push(nodeName);
+import { by as useHistoryStore, U as useWorkflowsStore, p as useSettingsStore, q as computed, dq as CanvasNodeDirtiness, bi as NodeConnectionType, dr as BulkCommand, ds as AddConnectionCommand, dt as RemoveConnectionCommand, du as RemoveNodeCommand, dv as AddNodeCommand, dw as EnableNodeToggleCommand, bq as useNodeHelpers, a5 as useWorkflowHelpers, a as useToast, $ as useRootStore, L as useUIStore, at as useExecutionsStore, b8 as CHAT_TRIGGER_NODE_TYPE, bk as get, dx as SINGLE_WEBHOOK_TRIGGERS, dy as displayForm, dz as isEmpty, de as generateNodesGraph, g as useI18n, ak as useTelemetry, aU as useExternalHooks } from "./index-BGYw7Tle.js";
+import { u as usePushConnectionStore } from "./pushConnection.store-BGGIKcjm.js";
+function shouldCommandMarkDirty(command, nodeName, siblingCommands, getIncomingConnections, getOutgoingConnectors) {
+  if (command instanceof BulkCommand) {
+    return command.commands.some(
+      (cmd) => shouldCommandMarkDirty(
+        cmd,
+        nodeName,
+        command.commands,
+        getIncomingConnections,
+        getOutgoingConnectors
+      )
+    );
+  }
+  if (command instanceof AddConnectionCommand) {
+    return command.connectionData[1]?.node === nodeName;
+  }
+  if (command instanceof RemoveConnectionCommand) {
+    const [from, to] = command.connectionData;
+    if (to.node !== nodeName) {
+      return false;
     }
-    return acc;
-  }, []);
-  return dirtyNodeNames.length ? dirtyNodeNames : void 0;
-};
+    return siblingCommands.some(
+      (sibling) => sibling instanceof RemoveNodeCommand && sibling.node.name === from.node
+    );
+  }
+  const incomingNodes = Object.values(getIncomingConnections(nodeName)).flat().flat().filter((connection) => connection !== null).map((connection) => connection.node);
+  if (command instanceof AddNodeCommand) {
+    return incomingNodes.includes(command.node.name);
+  }
+  if (command instanceof EnableNodeToggleCommand) {
+    return incomingNodes.includes(command.nodeName) && (command.newState || Object.keys(getOutgoingConnectors(command.nodeName)).some(
+      (type) => type !== NodeConnectionType.Main
+    ));
+  }
+  return false;
+}
+function findLoop(nodeName, visited, getIncomingConnections) {
+  const index = visited.indexOf(nodeName);
+  if (index >= 0) {
+    return visited.slice(index);
+  }
+  const newVisited = [...visited, nodeName];
+  for (const [type, typeConnections] of Object.entries(getIncomingConnections(nodeName))) {
+    if (type !== NodeConnectionType.Main) {
+      continue;
+    }
+    for (const connections of typeConnections) {
+      for (const { node } of connections ?? []) {
+        const loop = findLoop(node, newVisited, getIncomingConnections);
+        if (loop) {
+          return loop;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function useNodeDirtiness() {
+  const historyStore = useHistoryStore();
+  const workflowsStore = useWorkflowsStore();
+  const settingsStore = useSettingsStore();
+  function getParentSubNodes(nodeName) {
+    return Object.entries(workflowsStore.incomingConnectionsByNodeName(nodeName)).filter(([type]) => type !== NodeConnectionType.Main).flatMap(([, typeConnections]) => typeConnections.flat().filter((conn) => conn !== null));
+  }
+  function getDirtinessByParametersUpdate(nodeName, after) {
+    if ((workflowsStore.getParametersLastUpdate(nodeName) ?? 0) > after) {
+      return CanvasNodeDirtiness.PARAMETERS_UPDATED;
+    }
+    for (const connection of getParentSubNodes(nodeName)) {
+      if (getDirtinessByParametersUpdate(connection.node, after) !== void 0) {
+        return CanvasNodeDirtiness.UPSTREAM_DIRTY;
+      }
+    }
+    return void 0;
+  }
+  function getDirtinessByConnectionsUpdate(nodeName, after) {
+    for (let i = historyStore.undoStack.length - 1; i >= 0; i--) {
+      const command = historyStore.undoStack[i];
+      if (command.getTimestamp() < after) {
+        break;
+      }
+      if (shouldCommandMarkDirty(
+        command,
+        nodeName,
+        [],
+        workflowsStore.incomingConnectionsByNodeName,
+        workflowsStore.outgoingConnectionsByNodeName
+      )) {
+        return CanvasNodeDirtiness.INCOMING_CONNECTIONS_UPDATED;
+      }
+    }
+    for (const connection of getParentSubNodes(nodeName)) {
+      if (getDirtinessByConnectionsUpdate(connection.node, after) !== void 0) {
+        return CanvasNodeDirtiness.UPSTREAM_DIRTY;
+      }
+    }
+    return void 0;
+  }
+  const depthByName = computed(() => {
+    const depth = {};
+    function setDepthRecursively(nodeName, current, visited) {
+      if (visited.has(nodeName)) {
+        return;
+      }
+      const myVisited = new Set(visited);
+      myVisited.add(nodeName);
+      for (const [type, typeConnections] of Object.entries(
+        workflowsStore.outgoingConnectionsByNodeName(nodeName)
+      )) {
+        if (type !== NodeConnectionType.Main) {
+          continue;
+        }
+        for (const connections of typeConnections) {
+          for (const { node } of connections ?? []) {
+            if (!depth[node] || depth[node] > current) {
+              depth[node] = current;
+            }
+            setDepthRecursively(node, current + 1, myVisited);
+          }
+        }
+      }
+    }
+    for (const startNode of workflowsStore.allNodes) {
+      const hasIncomingNode = Object.keys(workflowsStore.incomingConnectionsByNodeName(startNode.name)).length > 0;
+      if (hasIncomingNode) {
+        continue;
+      }
+      depth[startNode.name] = 0;
+      setDepthRecursively(startNode.name, 1, /* @__PURE__ */ new Set());
+    }
+    return depth;
+  });
+  const dirtinessByName = computed(() => {
+    if (settingsStore.partialExecutionVersion === 1) {
+      return {};
+    }
+    const dirtiness = {};
+    const runDataByNode = workflowsStore.getWorkflowRunData ?? {};
+    function setDirtiness(nodeName, value) {
+      dirtiness[nodeName] = dirtiness[nodeName] ?? value;
+      const loop = findLoop(nodeName, [], workflowsStore.incomingConnectionsByNodeName);
+      if (!loop) {
+        return;
+      }
+      const loopEntryNodeName = [...loop].sort(
+        (a, b) => (depthByName.value[a] ?? Number.MAX_SAFE_INTEGER) - (depthByName.value[b] ?? Number.MAX_SAFE_INTEGER)
+      )?.[0];
+      if (loopEntryNodeName && depthByName.value[loopEntryNodeName]) {
+        dirtiness[loopEntryNodeName] = dirtiness[loopEntryNodeName] ?? CanvasNodeDirtiness.UPSTREAM_DIRTY;
+      }
+    }
+    for (const [nodeName, runData] of Object.entries(runDataByNode)) {
+      const runAt = runData[0]?.startTime ?? 0;
+      if (!runAt) {
+        continue;
+      }
+      const parameterUpdate = getDirtinessByParametersUpdate(nodeName, runAt);
+      if (parameterUpdate) {
+        setDirtiness(nodeName, parameterUpdate);
+        continue;
+      }
+      const connectionUpdate = getDirtinessByConnectionsUpdate(nodeName, runAt);
+      if (connectionUpdate) {
+        setDirtiness(nodeName, connectionUpdate);
+        continue;
+      }
+      const hasInputPinnedDataChanged = Object.values(
+        workflowsStore.incomingConnectionsByNodeName(nodeName)
+      ).flat().flat().filter((connection) => connection !== null).some((connection) => {
+        const pinnedDataLastUpdatedAt = workflowsStore.getPinnedDataLastUpdate(connection.node) ?? 0;
+        return pinnedDataLastUpdatedAt > runAt;
+      });
+      if (hasInputPinnedDataChanged) {
+        setDirtiness(nodeName, CanvasNodeDirtiness.PINNED_DATA_UPDATED);
+        continue;
+      }
+      const pinnedDataLastRemovedAt = workflowsStore.getPinnedDataLastRemovedAt(nodeName) ?? 0;
+      if (pinnedDataLastRemovedAt > runAt) {
+        setDirtiness(nodeName, CanvasNodeDirtiness.PINNED_DATA_UPDATED);
+        continue;
+      }
+    }
+    return dirtiness;
+  });
+  return { dirtinessByName };
+}
 function useRunWorkflow(useRunWorkflowOpts) {
   const nodeHelpers = useNodeHelpers();
   const workflowHelpers = useWorkflowHelpers({ router: useRunWorkflowOpts.router });
@@ -24,6 +198,7 @@ function useRunWorkflow(useRunWorkflowOpts) {
   const uiStore = useUIStore();
   const workflowsStore = useWorkflowsStore();
   const executionsStore = useExecutionsStore();
+  const { dirtinessByName } = useNodeDirtiness();
   async function runWorkflowApi(runData) {
     if (!pushConnectionStore.isConnected) {
       throw new Error(i18n.baseText("workflowRun.noActiveConnectionToTheServer"));
@@ -122,6 +297,8 @@ function useRunWorkflow(useRunWorkflowOpts) {
           }
         }
       }
+      const isPartialExecution = options.destinationNode !== void 0;
+      const version = settingsStore.partialExecutionVersion;
       const startNodes = startNodeNames.map((name) => {
         let sourceData = get(runData, [name, 0, "source", 0], null);
         if (sourceData === null) {
@@ -152,9 +329,6 @@ function useRunWorkflow(useRunWorkflowOpts) {
         });
         return void 0;
       }
-      const isPartialExecution = options.destinationNode !== void 0;
-      const settingsStore2 = useSettingsStore();
-      const version = settingsStore2.partialExecutionVersion;
       const startRunData = {
         workflowData,
         // With the new partial execution version the backend decides what run
@@ -177,10 +351,10 @@ function useRunWorkflow(useRunWorkflowOpts) {
         startRunData.destinationNode = options.destinationNode;
       }
       if (startRunData.runData) {
-        startRunData.dirtyNodeNames = getDirtyNodeNames(
-          startRunData.runData,
-          workflowsStore.getParametersLastUpdate
+        const nodeNames = Object.entries(dirtinessByName.value).flatMap(
+          ([nodeName, dirtiness]) => dirtiness ? [nodeName] : []
         );
+        startRunData.dirtyNodeNames = nodeNames.length > 0 ? nodeNames : void 0;
       }
       const executionData = {
         id: "__IN_PROGRESS__",
@@ -342,5 +516,6 @@ function useRunWorkflow(useRunWorkflowOpts) {
   };
 }
 export {
+  useNodeDirtiness as a,
   useRunWorkflow as u
 };

package/dist/assets/{useTestDefinitionForm-C0uFCVbQ.js → useTestDefinitionForm-ClopiqsS.js}

@@ -1,4 +1,4 @@
-import { bW as useTestDefinitionStore, r as ref, q as computed } from "./index-C06tkpld.js";
+import { bX as useTestDefinitionStore, r as ref, q as computed } from "./index-BGYw7Tle.js";
 function useTestDefinitionForm() {
   const evaluationsStore = useTestDefinitionStore();
   const state = ref({

package/dist/assets/{useWorkflowActivate-1kRXyIJ4.js → useWorkflowActivate-Dlae1S8s.js}

@@ -1,4 +1,4 @@
-import { r as ref, b as useRouter, a5 as useWorkflowHelpers, U as useWorkflowsStore, L as useUIStore, a as useToast, a3 as useNpsSurveyStore, Y as PLACEHOLDER_EMPTY_WORKFLOW_ID, aT as useExternalHooks, aI as useStorage, dl as LOCAL_STORAGE_ACTIVATION_FLAG, dm as WORKFLOW_ACTIVE_MODAL_KEY, ak as useTelemetry, g as useI18n } from "./index-C06tkpld.js";
+import { r as ref, b as useRouter, a5 as useWorkflowHelpers, U as useWorkflowsStore, L as useUIStore, a as useToast, a3 as useNpsSurveyStore, Y as PLACEHOLDER_EMPTY_WORKFLOW_ID, aU as useExternalHooks, aJ as useStorage, dn as LOCAL_STORAGE_ACTIVATION_FLAG, dp as WORKFLOW_ACTIVE_MODAL_KEY, ak as useTelemetry, g as useI18n } from "./index-BGYw7Tle.js";
 function useWorkflowActivate() {
   const updatingWorkflowActivation = ref(false);
   const router = useRouter();

package/dist/index.html

@@ -16,8 +16,8 @@
 		<script>!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.async=!0,p.src=s.api_host+"/static/array.js",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="capture identify alias people.set people.set_once set_config register register_once unregister opt_out_capturing has_opted_out_capturing opt_in_capturing reset isFeatureEnabled getFeatureFlag onFeatureFlags reloadFeatureFlags".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[])</script>
 
 		<title>n8n.io - Workflow Automation</title>
-		<script type="module" crossorigin src="/{{BASE_PATH}}/assets/index-C06tkpld.js"></script>
-		<link rel="stylesheet" crossorigin href="/{{BASE_PATH}}/assets/index-CKK_xS1q.css">
+		<script type="module" crossorigin src="/{{BASE_PATH}}/assets/index-BGYw7Tle.js"></script>
+		<link rel="stylesheet" crossorigin href="/{{BASE_PATH}}/assets/index-DvUG3hgI.css">
 	</head>
 	<body>
 		<noscript>