@teleporthq/teleport-plugin-next-workflows 0.45.14 → 0.45.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleporthq/teleport-plugin-next-workflows",
-  "version": "0.45.14",
+  "version": "0.45.16",
   "description": "A plugin for workflow code generation in Next.js projects.",
   "author": "teleportHQ",
   "license": "MIT",
@@ -69,5 +69,5 @@
     "@teleporthq/teleport-shared": "^0.45.0",
     "@teleporthq/teleport-types": "^0.45.0"
   },
-  "gitHead": "c6b7eefde3d386aba19edc7ffa850879d7e1ce23"
+  "gitHead": "ff4b04c211701b9bc5fdce1f32e42226241b0792"
 }

package/src/api-route-generator.ts

@@ -443,6 +443,8 @@ module.exports = async function handler(req, res) {
       // the caller as if that branch had run (a custom node answers the output
       // of the last node it ran).
       if (context.__skippedNodes && context.__skippedNodes[node.id]) continue;
+      // A node of a loop body ran inside its loop, an if-statement included.
+      if (context.__loopBodyNodeIds && context.__loopBodyNodeIds[node.id]) continue;
       const resolved = resolveNodeConfig(node, context);
       // Every data node lives in a SERVER segment, so this guard — which turns an
       // unresolved {{…}} into a validation error instead of letting the literal
@@ -458,118 +460,34 @@ module.exports = async function handler(req, res) {
       if (node.type === 'general-if-statement') {
         const condResult = utils.evaluateCondition(resolved, context, node.config);
         context[node.id] = { result: condResult };
-        var skipHandle = condResult ? 'false' : 'true';
-        var segEdgesIf = SEGMENT_CONFIG.edges || [];
-        var skipEdge = segEdgesIf.find(function(e) { return e.source === node.id && e.sourceHandle === skipHandle; });
-        if (skipEdge) {
-          // BFS to collect all nodes in the non-taken branch
-          var skipIds = {};
-          var skipQueue = [skipEdge.target];
-          while (skipQueue.length > 0) {
-            var sid = skipQueue.shift();
-            if (skipIds[sid] || sid === node.id) continue;
-            skipIds[sid] = true;
-            segEdgesIf.forEach(function(e) {
-              if (e.source === sid && !skipIds[e.target] && e.target !== node.id) skipQueue.push(e.target);
-            });
-          }
-          if (!context.__skippedNodes) context.__skippedNodes = {};
-          Object.assign(context.__skippedNodes, skipIds);
-        }
+        if (!context.__skippedNodes) context.__skippedNodes = {};
+        Object.assign(context.__skippedNodes, utils.nonTakenBranchNodeIds(SEGMENT_CONFIG.edges, node.id, condResult));
         continue;
       }
 
-      // Loop nodes must be handled specially: iterate over the collection,
-      // execute loop body nodes for each item, then continue after the loop.
+      // A loop runs its body once per pass of its type, a loop inside the body
+      // included (see runServerLoop in the server runtime).
       if (node.type === 'general-loop') {
-        const loopEdges = SEGMENT_CONFIG.edges.filter(function(e) { return e.source === node.id; });
-        const loopBodyEdge = loopEdges.find(function(e) { return e.sourceHandle === 'loop'; });
-        const exitEdge = loopEdges.find(function(e) { return e.sourceHandle === 'exit'; });
-
-        // Collect loop body node IDs by following loop-body edges
-        const bodyNodeIds = {};
-        if (loopBodyEdge) {
-          const queue = [loopBodyEdge.target];
-          while (queue.length > 0) {
-            const nid = queue.shift();
-            if (bodyNodeIds[nid] || nid === node.id) continue;
-            bodyNodeIds[nid] = true;
-            SEGMENT_CONFIG.edges.forEach(function(e) {
-              if (e.source === nid && (e.sourceHandle === 'loop-body-out' || !e.sourceHandle)) {
-                if (e.target !== node.id) queue.push(e.target);
-              }
-            });
-          }
-        }
-        const bodyNodes = sortedNodes.filter(function(n) { return bodyNodeIds[n.id]; });
-        // For loopType=map, the schema (general-loop in node-context-schemas.json)
-        // defines results as the array of last body node outputs (same as
-        // Array.prototype.map). Pick the last body node so downstream nodes
-        // (e.g. state-update-global-state) consume the transformed value
-        // instead of the per-iteration scaffolding object.
-        const __loopType = resolved.loopType || 'forEach';
-        const __lastBodyNode = bodyNodes[bodyNodes.length - 1];
-
-        // Resolve the collection to iterate over. unwrapWorkflowCollection
-        // handles the common envelope shape that helper nodes return —
-        // transform-array { result, ... }, integration-airtable { records, ... },
-        // utility-semantic-search { matches, ... } — by unwrapping a single
-        // array property when the upstream binding pointed at the parent node
-        // instead of the inner field. See runtime-utils for the full rules.
-        var collection = utils.unwrapWorkflowCollection(resolved.collection);
-        var loopResults = [];
-
-        // Track this loop's body scope so general-custom-js (and any handler
-        // that consults the scope stack) can build the params / innerParams
-        // arrays the workflow editor advertises: params = nodes BEFORE the
-        // outermost loop, innerParamsN = nodes inside the loop at depth N.
-        if (!context.__loopScopeStack) context.__loopScopeStack = [];
-        context.__loopScopeStack.push({ loopNodeId: node.id, bodyNodeIds: bodyNodeIds });
-        // Persistent registry of every loop scaffold node we've entered, so
-        // a sibling that runs AFTER an inner loop completes still recognises
-        // that inner loop id as scaffolding (not as a regular workflow node).
-        if (!context.__loopNodeIds) context.__loopNodeIds = {};
-        context.__loopNodeIds[node.id] = true;
-
-        for (var li = 0; li < collection.length; li++) {
-          context[node.id] = utils.loopIterationContext(collection, li);
-          for (var bi = 0; bi < bodyNodes.length; bi++) {
-            var bNode = bodyNodes[bi];
-            var bResolved = resolveNodeConfig(bNode, context);
-            bResolved.__nodeId = bNode.id;
-            if (bNode.type === 'general-if-statement') {
-              context[bNode.id] = { result: utils.evaluateCondition(bResolved, context, bNode.config) };
-              continue;
-            }
-            var bHandler = nodeHandlers[bNode.type];
-            if (!bHandler) continue;
-            if (utils.isFireAndForgetNode(bNode)) {
-              utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(bNode, bHandler, bResolved, context));
-              context[bNode.id] = null;
-              continue;
-            }
-            var bResult = await bHandler(bResolved, context);
-            if (bResult && (bResult.success === false || (typeof bResult.error === 'string' && bResult.error))) {
-              throw new Error(bResult.error || 'Loop body node execution failed');
-            }
-            context[bNode.id] = bResult;
+        const bodyNodeIds = await utils.runServerLoop(node, resolved, sortedNodes, SEGMENT_CONFIG.edges, context, async function(bNode, bResolved) {
+          var bHandler = nodeHandlers[bNode.type];
+          if (!bHandler) return;
+          if (utils.isFireAndForgetNode(bNode)) {
+            utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(bNode, bHandler, bResolved, context));
+            context[bNode.id] = null;
+            return;
           }
-          if (__loopType === 'map') {
-            loopResults.push(__lastBodyNode ? context[__lastBodyNode.id] : context[node.id]);
+          var bResult = await bHandler(bResolved, context);
+          if (bResult && (bResult.success === false || (typeof bResult.error === 'string' && bResult.error))) {
+            throw new Error(bResult.error || 'Loop body node execution failed');
           }
-        }
-
-        context.__loopScopeStack.pop();
-
-        context[node.id] = { completed: true, iterations: collection.length, results: loopResults };
-        // Store body node IDs so the outer loop can skip them
+          context[bNode.id] = bResult;
+        });
+        // The walk below must not run a body node again.
         if (!context.__loopBodyNodeIds) context.__loopBodyNodeIds = {};
         Object.assign(context.__loopBodyNodeIds, bodyNodeIds);
         continue;
       }
 
-      // Skip nodes that were part of a loop body (already executed inside the loop)
-      if (context.__loopBodyNodeIds && context.__loopBodyNodeIds[node.id]) continue;
 
       // Switch nodes evaluate a value, match a case, execute that branch, skip all others
       if (node.type === 'general-switch') {
@@ -865,6 +783,8 @@ module.exports = async function handler(req, res) {
     for (let i = 0; i < sortedNodes.length; i++) {
       const node = sortedNodes[i];
       if (executed[node.id]) continue;
+      // The branch an if-statement or a switch did not take never runs.
+      if (context.__skippedNodes && context.__skippedNodes[node.id]) continue;
       const resolved = resolveNodeConfig(node, context);
       // See the non-streaming segment above — without this the unresolved-token
       // guard never runs on the server, which is where every data node executes.
@@ -877,71 +797,27 @@ module.exports = async function handler(req, res) {
         const condResult = utils.evaluateCondition(resolved, context, node.config);
         context[node.id] = { result: condResult };
         executed[node.id] = true;
+        if (!context.__skippedNodes) context.__skippedNodes = {};
+        Object.assign(context.__skippedNodes, utils.nonTakenBranchNodeIds(SEGMENT_CONFIG.edges, node.id, condResult));
         if (streamStarted) {
           __streamNodeResult(res, node.id, context[node.id]);
         }
         continue;
       }
 
-      // Loop nodes in streaming segments
+      // Loop nodes in streaming segments: same runner as the regular-segment
+      // loop above, a loop inside the body included.
       if (node.type === 'general-loop') {
-        var ssLoopEdges = SEGMENT_CONFIG.edges.filter(function(e) { return e.source === node.id; });
-        var ssLoopBodyEdge = ssLoopEdges.find(function(e) { return e.sourceHandle === 'loop'; });
-        var ssBodyNodeIds = {};
-        if (ssLoopBodyEdge) {
-          var sslq = [ssLoopBodyEdge.target];
-          while (sslq.length > 0) {
-            var sslnid = sslq.shift();
-            if (ssBodyNodeIds[sslnid] || sslnid === node.id) continue;
-            ssBodyNodeIds[sslnid] = true;
-            SEGMENT_CONFIG.edges.forEach(function(e) {
-              if (e.source === sslnid && (e.sourceHandle === 'loop-body-out' || !e.sourceHandle)) {
-                if (e.target !== node.id) sslq.push(e.target);
-              }
-            });
+        var ssBodyNodeIds = await utils.runServerLoop(node, resolved, sortedNodes, SEGMENT_CONFIG.edges, context, async function(ssbNode, ssbRes) {
+          var ssbHandler = nodeHandlers[ssbNode.type];
+          if (!ssbHandler) return;
+          if (utils.isFireAndForgetNode(ssbNode)) {
+            utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(ssbNode, ssbHandler, ssbRes, context));
+            context[ssbNode.id] = null;
+            return;
           }
-        }
-        var ssBodyNodes = sortedNodes.filter(function(n) { return ssBodyNodeIds[n.id]; });
-        // See the regular-segment loop above: loopType=map must publish the
-        // last body node output as results[i] so the schema contract holds.
-        var ssLoopType = resolved.loopType || 'forEach';
-        var ssLastBodyNode = ssBodyNodes[ssBodyNodes.length - 1];
-        // Same envelope unwrap as the regular-segment loop above.
-        var ssLoopCollection = utils.unwrapWorkflowCollection(resolved.collection);
-        var ssLoopResults = [];
-        // Same loop-scope tracking as the regular-segment loop above. Custom-js
-        // bodies can read context.__loopScopeStack to recover the params /
-        // innerParams contract documented in workflow-utils.ts.
-        if (!context.__loopScopeStack) context.__loopScopeStack = [];
-        context.__loopScopeStack.push({ loopNodeId: node.id, bodyNodeIds: ssBodyNodeIds });
-        if (!context.__loopNodeIds) context.__loopNodeIds = {};
-        context.__loopNodeIds[node.id] = true;
-        for (var ssli = 0; ssli < ssLoopCollection.length; ssli++) {
-          context[node.id] = utils.loopIterationContext(ssLoopCollection, ssli);
-          for (var ssbi = 0; ssbi < ssBodyNodes.length; ssbi++) {
-            var ssbNode = ssBodyNodes[ssbi];
-            var ssbRes = resolveNodeConfig(ssbNode, context);
-            ssbRes.__nodeId = ssbNode.id;
-            if (ssbNode.type === 'general-if-statement') {
-              context[ssbNode.id] = { result: utils.evaluateCondition(ssbRes, context, ssbNode.config) };
-              continue;
-            }
-            var ssbHandler = nodeHandlers[ssbNode.type];
-            if (!ssbHandler) continue;
-            if (utils.isFireAndForgetNode(ssbNode)) {
-              utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(ssbNode, ssbHandler, ssbRes, context));
-              context[ssbNode.id] = null;
-              continue;
-            }
-            var ssbResult = await ssbHandler(ssbRes, context);
-            context[ssbNode.id] = ssbResult;
-          }
-          if (ssLoopType === 'map') {
-            ssLoopResults.push(ssLastBodyNode ? context[ssLastBodyNode.id] : context[node.id]);
-          }
-        }
-        context.__loopScopeStack.pop();
-        context[node.id] = { completed: true, iterations: ssLoopCollection.length, results: ssLoopResults };
+          context[ssbNode.id] = await ssbHandler(ssbRes, context);
+        });
         Object.keys(ssBodyNodeIds).forEach(function(k) { executed[k] = true; });
         executed[node.id] = true;
         if (streamStarted) {
@@ -1668,11 +1544,11 @@ const generateNodeExecutionLoop = (
   // top-level one does: its handler only hands back the marker.
   const loopBodyCustomNodeBlock = options?.hasCustomNodes
     ? `
-            if (bResult && bResult.__customNode) {
-              var bcnFn = typeof __customNodes !== 'undefined' ? __customNodes[bResult.customNodeId] : null;
-              context[bNode.id] = bcnFn ? await bcnFn(context, bResult.parameters, nodeHandlers) : null;
-              continue;
-            }`
+          if (bResult && bResult.__customNode) {
+            var bcnFn = typeof __customNodes !== 'undefined' ? __customNodes[bResult.customNodeId] : null;
+            context[bNode.id] = bcnFn ? await bcnFn(context, bResult.parameters, nodeHandlers) : null;
+            return;
+          }`
     : ''
 
   return `    var sortedNodes = ${configVar}.nodes.slice().sort(function(a, b) { return a.stepNumber - b.stepNumber; });
@@ -1682,6 +1558,8 @@ ${resumeBlock}
       // Never resolved nor run on a non-taken branch, an if-statement included
       // (see the segment executor above).
       if (context.__skippedNodes && context.__skippedNodes[node.id]) continue;
+      // A node of a loop body ran inside its loop, an if-statement included.
+      if (context.__loopBodyNodeIds && context.__loopBodyNodeIds[node.id]) continue;
       var resolved = resolveNodeConfig(node, context);
       // See the other segment executors — the unresolved-token guard must run
       // wherever data nodes execute, and they all execute on the server.
@@ -1692,102 +1570,33 @@ ${resumeBlock}
       if (node.type === 'general-if-statement') {
         var condResult = utils.evaluateCondition(resolved, context, node.config);
         context[node.id] = { result: condResult };
-        var skipHandle = condResult ? 'false' : 'true';
-        var cfgEdges = ${configVar}.edges || [];
-        var skipEdge = cfgEdges.find(function(e) { return e.source === node.id && e.sourceHandle === skipHandle; });
-        if (skipEdge) {
-          var skipIds = {};
-          var skipQueue = [skipEdge.target];
-          while (skipQueue.length > 0) {
-            var sid = skipQueue.shift();
-            if (skipIds[sid] || sid === node.id) continue;
-            skipIds[sid] = true;
-            cfgEdges.forEach(function(e) {
-              if (e.source === sid && !skipIds[e.target] && e.target !== node.id) skipQueue.push(e.target);
-            });
-          }
-          if (!context.__skippedNodes) context.__skippedNodes = {};
-          Object.assign(context.__skippedNodes, skipIds);
-        }
+        if (!context.__skippedNodes) context.__skippedNodes = {};
+        Object.assign(context.__skippedNodes, utils.nonTakenBranchNodeIds(${configVar}.edges, node.id, condResult));
         continue;
       }
 
+      // Same runner as the segment routes, a loop inside the body included
+      // (see runServerLoop in the server runtime).
       if (node.type === 'general-loop') {
-        var loopEdges = ${configVar}.edges.filter(function(e) { return e.source === node.id; });
-        var loopBodyEdge = loopEdges.find(function(e) { return e.sourceHandle === 'loop'; });
-
-        var bodyNodeIds = {};
-        if (loopBodyEdge) {
-          var lQueue = [loopBodyEdge.target];
-          while (lQueue.length > 0) {
-            var nid = lQueue.shift();
-            if (bodyNodeIds[nid] || nid === node.id) continue;
-            bodyNodeIds[nid] = true;
-            ${configVar}.edges.forEach(function(e) {
-              if (e.source === nid && (e.sourceHandle === 'loop-body-out' || !e.sourceHandle)) {
-                if (e.target !== node.id) lQueue.push(e.target);
-              }
-            });
+        var bodyNodeIds = await utils.runServerLoop(node, resolved, sortedNodes, ${configVar}.edges, context, async function(bNode, bResolved) {
+          var bHandler = nodeHandlers[bNode.type];
+          if (!bHandler) return;
+          if (utils.isFireAndForgetNode(bNode)) {
+            utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(bNode, bHandler, bResolved, context));
+            context[bNode.id] = null;
+            return;
           }
-        }
-        var bodyNodes = sortedNodes.filter(function(n) { return bodyNodeIds[n.id]; });
-        // For loopType=map, the schema (general-loop in node-context-schemas.json)
-        // defines results as the array of last body node outputs (same as
-        // Array.prototype.map). Pick the last body node so downstream nodes
-        // (e.g. state-update-global-state) consume the transformed value.
-        var __wfLoopType = resolved.loopType || 'forEach';
-        var __wfLastBodyNode = bodyNodes[bodyNodes.length - 1];
-
-        // Same envelope unwrap as the regular-segment loop above.
-        var collection = utils.unwrapWorkflowCollection(resolved.collection);
-        var loopResults = [];
-
-        // Same loop-scope tracking as the regular-segment loop above so
-        // general-custom-js inside the loop body sees the right params /
-        // innerParams. Required for webhook + cron routes.
-        if (!context.__loopScopeStack) context.__loopScopeStack = [];
-        context.__loopScopeStack.push({ loopNodeId: node.id, bodyNodeIds: bodyNodeIds });
-        if (!context.__loopNodeIds) context.__loopNodeIds = {};
-        context.__loopNodeIds[node.id] = true;
-
-        for (var li = 0; li < collection.length; li++) {
-          context[node.id] = utils.loopIterationContext(collection, li);
-          for (var bi = 0; bi < bodyNodes.length; bi++) {
-            var bNode = bodyNodes[bi];
-            var bResolved = resolveNodeConfig(bNode, context);
-            bResolved.__nodeId = bNode.id;
-            if (bNode.type === 'general-if-statement') {
-              context[bNode.id] = { result: utils.evaluateCondition(bResolved, context, bNode.config) };
-              continue;
-            }
-            var bHandler = nodeHandlers[bNode.type];
-            if (!bHandler) continue;
-            if (utils.isFireAndForgetNode(bNode)) {
-              utils.registerPendingNodePromise(context, utils.startFireAndForgetNode(bNode, bHandler, bResolved, context));
-              context[bNode.id] = null;
-              continue;
-            }
-            var bResult = await bHandler(bResolved, context);${loopBodyCustomNodeBlock}
-            if (bResult && (bResult.success === false || (typeof bResult.error === 'string' && bResult.error))) {
-              throw new Error(bResult.error || 'Loop body node execution failed');
-            }
-            context[bNode.id] = bResult;
-          }
-          if (__wfLoopType === 'map') {
-            loopResults.push(__wfLastBodyNode ? context[__wfLastBodyNode.id] : context[node.id]);
+          var bResult = await bHandler(bResolved, context);${loopBodyCustomNodeBlock}
+          if (bResult && (bResult.success === false || (typeof bResult.error === 'string' && bResult.error))) {
+            throw new Error(bResult.error || 'Loop body node execution failed');
           }
-        }
-
-        context.__loopScopeStack.pop();
-
-        context[node.id] = { completed: true, iterations: collection.length, results: loopResults };
+          context[bNode.id] = bResult;
+        });
         if (!context.__loopBodyNodeIds) context.__loopBodyNodeIds = {};
         Object.assign(context.__loopBodyNodeIds, bodyNodeIds);
         continue;
       }
 
-      if (context.__loopBodyNodeIds && context.__loopBodyNodeIds[node.id]) continue;
-
       if (node.type === 'general-switch') {
         // Only an authored case expression is compiled (see matchSwitchCase).
         var swMatchedCase = utils.matchSwitchCase(node.config, resolved, context);

package/src/executor-generator.ts

@@ -161,6 +161,81 @@ function loopIterationContext(collection, index) {
   };
 }
 
+// How every loop type steps, for the client executor and for each server
+// route alike. next(context) hands back what one pass publishes before its
+// body runs ({ key, value }, stored as context[key]), or null once the loop is
+// over. A collection is walked under the loop's own id; a counted or a
+// conditional loop publishes its counter under "<loopId>_iter". A while / until
+// condition is tested before every pass, against the context of that pass.
+var DEFAULT_LOOP_MAX_ITERATIONS = 1000;
+
+function createLoopSteps(loopNode, config, context, collection) {
+  var loopType = config.loopType || 'forEach';
+  var iterKey = loopNode.id + '_iter';
+  var passes = 0;
+  var next;
+  if (loopType === 'forEach' || loopType === 'map') {
+    next = function() {
+      return passes < collection.length
+        ? { key: loopNode.id, value: loopIterationContext(collection, passes) }
+        : null;
+    };
+  } else if (loopType === 'for') {
+    var cursor = Number(resolveValue(config.startIndex, context)) || 0;
+    var end = Number(resolveValue(config.endIndex, context)) || 0;
+    var step = Number(resolveValue(config.step, context)) || 1;
+    next = function() {
+      if (!(step > 0 ? cursor < end : cursor > end)) return null;
+      var index = cursor;
+      cursor += step;
+      return { key: iterKey, value: { index: index } };
+    };
+  } else {
+    var maxIterations = Number(resolveValue(config.maxIterations, context)) || DEFAULT_LOOP_MAX_ITERATIONS;
+    var authoredCondition = loopNode.config && loopNode.config.condition;
+    next = function(passContext) {
+      if (passes >= maxIterations) return null;
+      var scaffold = { iteration: passes };
+      var testContext = Object.assign({}, passContext);
+      testContext[iterKey] = scaffold;
+      var condition = resolveValue(config.condition, testContext);
+      // Only the authored condition is compiled (see runExpression).
+      var holds = runExpression(authoredCondition, condition, ['context'], [testContext], testContext);
+      if (loopType === 'until' ? holds : !holds) return null;
+      return { key: iterKey, value: scaffold };
+    };
+  }
+  return {
+    next: function(passContext) {
+      var pass = next(passContext || context);
+      if (pass) passes++;
+      return pass;
+    },
+    iterations: function() { return passes; }
+  };
+}
+
+// The nodes of the branch an if-statement did NOT take: everything reachable
+// from that branch's edge, never walking back through the if itself nor past
+// stopAtId (the loop a body belongs to, whose loop-back edge leads out of it).
+function nonTakenBranchNodeIds(edges, ifNodeId, conditionHeld, stopAtId) {
+  var skipHandle = conditionHeld ? 'false' : 'true';
+  var all = edges || [];
+  var skipEdge = all.find(function(e) { return e.source === ifNodeId && e.sourceHandle === skipHandle; });
+  var skipIds = {};
+  if (!skipEdge) return skipIds;
+  var queue = [skipEdge.target];
+  while (queue.length > 0) {
+    var id = queue.shift();
+    if (skipIds[id] || id === ifNodeId || id === stopAtId) continue;
+    skipIds[id] = true;
+    all.forEach(function(e) {
+      if (e.source === id && !skipIds[e.target]) queue.push(e.target);
+    });
+  }
+  return skipIds;
+}
+
 function resolveCtxRef(ref, context) {
   var elem = context.triggerElement;
   if (!elem || typeof elem.getAttribute !== 'function') return undefined;
@@ -1496,35 +1571,15 @@ async function executeLoop(loopNode, config, allNodes, edges, context, nodeHandl
     context[loopNode.id] = loopType === 'map'
       ? { results: results, iterations: collection.length }
       : { completed: true, iterations: collection.length };
-  } else if (loopType === 'for') {
-    const start = resolveValue(config.startIndex, context) || 0;
-    const end = resolveValue(config.endIndex, context) || 0;
-    const step = resolveValue(config.step, context) || 1;
-    let count = 0;
-    for (let fi = start; step > 0 ? fi < end : fi > end; fi += step) {
-      const forCtx = Object.assign({}, context);
-      forCtx[loopNode.id + '_iter'] = { index: fi };
-      await executeNodes(bodyNodes, edges, forCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
-      Object.assign(context, forCtx);
-      count++;
-    }
-    context[loopNode.id] = { completed: true, iterations: count };
   } else {
-    const maxIter = resolveValue(config.maxIterations, context) || 1000;
-    let iter = 0;
-    while (iter < maxIter) {
-      const whileCtx = Object.assign({}, context);
-      whileCtx[loopNode.id + '_iter'] = { iteration: iter };
-      const condStr = resolveValue(config.condition, whileCtx);
-      // Only the authored condition is compiled (see runExpression).
-      const condResult = runExpression(loopNode.config && loopNode.config.condition, condStr, ['context'], [whileCtx], whileCtx);
-      if (loopType === 'while' && !condResult) break;
-      if (loopType === 'until' && condResult) break;
-      await executeNodes(bodyNodes, edges, whileCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
-      Object.assign(context, whileCtx);
-      iter++;
+    const steps = createLoopSteps(loopNode, config, context);
+    for (let pass = steps.next(context); pass; pass = steps.next(context)) {
+      const passCtx = Object.assign({}, context);
+      passCtx[pass.key] = pass.value;
+      await executeNodes(bodyNodes, edges, passCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
+      Object.assign(context, passCtx);
     }
-    context[loopNode.id] = { completed: true, iterations: iter };
+    context[loopNode.id] = { completed: true, iterations: steps.iterations() };
   }
   } finally {
     context.__loopScopeStack.pop();
@@ -1820,6 +1875,8 @@ module.exports = {
   resolveRichTextContext,
   unwrapWorkflowCollection,
   loopIterationContext,
+  createLoopSteps,
+  nonTakenBranchNodeIds,
   snapshotIncomingContext,
   segmentReply,
   withoutCredentialColumns,

package/src/server-runtime-code.ts

@@ -860,7 +860,74 @@ function handOffPendingNodePromises(context) {
   return Promise.resolve();
 }
 
+// One loop of a server route, a loop inside its body included: every route
+// kind runs its loops through here and differs only in runBodyNode(node,
+// resolvedConfig), which runs one ordinary body node and stores its result.
+// The body is walked in step order, once per pass of the loop type (see
+// createLoopSteps). An if-statement skips the branch it does not take for
+// that pass only; a loop found in the body runs all of its own passes on
+// every pass of this one, and its body nodes belong to it alone.
+// Returns every node id between the loop and its loop-back edge (the bodies
+// of inner loops included), which the route must not run again.
+async function runServerLoop(loopNode, config, sortedNodes, edges, context, runBodyNode) {
+  var bodyNodeIds = {};
+  utils.getLoopBodyNodeIds(loopNode.id, edges).forEach(function(id) { bodyNodeIds[id] = true; });
+  var innerLoopBodyIds = {};
+  sortedNodes.forEach(function(n) {
+    if (!bodyNodeIds[n.id] || n.type !== 'general-loop') return;
+    utils.getLoopBodyNodeIds(n.id, edges).forEach(function(id) { innerLoopBodyIds[id] = true; });
+  });
+  var bodyNodes = sortedNodes.filter(function(n) { return bodyNodeIds[n.id] && !innerLoopBodyIds[n.id]; });
+  // A map loop publishes the output of its last body node per pass, as
+  // Array.prototype.map does (general-loop in node-context-schemas.json).
+  var isMap = (config.loopType || 'forEach') === 'map';
+  var lastBodyNode = bodyNodes[bodyNodes.length - 1];
+  // A helper node's envelope ({ result }, { records }, { matches }) is
+  // unwrapped to the one array it holds.
+  var collection = utils.unwrapWorkflowCollection(config.collection);
+  var results = [];
+
+  // The scope stack lets custom JavaScript tell the nodes before the outermost
+  // loop (params) from those inside a loop at each depth (innerParams); the
+  // registry keeps a finished inner loop recognisable as scaffolding.
+  if (!context.__loopScopeStack) context.__loopScopeStack = [];
+  context.__loopScopeStack.push({ loopNodeId: loopNode.id, bodyNodeIds: bodyNodeIds });
+  if (!context.__loopNodeIds) context.__loopNodeIds = {};
+  context.__loopNodeIds[loopNode.id] = true;
+
+  var steps = utils.createLoopSteps(loopNode, config, context, collection);
+  for (var pass = steps.next(context); pass; pass = steps.next(context)) {
+    context[pass.key] = pass.value;
+    var skippedThisPass = {};
+    for (var i = 0; i < bodyNodes.length; i++) {
+      var bodyNode = bodyNodes[i];
+      if (skippedThisPass[bodyNode.id]) continue;
+      var resolved = utils.resolveNodeConfig(bodyNode, context);
+      resolved.__nodeId = bodyNode.id;
+      if (bodyNode.type === 'general-if-statement') {
+        var held = utils.evaluateCondition(resolved, context, bodyNode.config);
+        context[bodyNode.id] = { result: held };
+        Object.assign(skippedThisPass, utils.nonTakenBranchNodeIds(edges, bodyNode.id, held, loopNode.id));
+        continue;
+      }
+      if (bodyNode.type === 'general-loop') {
+        await runServerLoop(bodyNode, resolved, sortedNodes, edges, context, runBodyNode);
+        continue;
+      }
+      await runBodyNode(bodyNode, resolved);
+    }
+    if (isMap) {
+      results.push(lastBodyNode ? context[lastBodyNode.id] : context[loopNode.id]);
+    }
+  }
+
+  context.__loopScopeStack.pop();
+  context[loopNode.id] = { completed: true, iterations: steps.iterations(), results: results };
+  return bodyNodeIds;
+}
+
 module.exports = Object.assign({}, utils, {
+  runServerLoop: runServerLoop,
   handOffPendingNodePromises: handOffPendingNodePromises,
   claimSegmentContext: claimSegmentContext,
   segmentReply: segmentReply,