@burdenoff/fluidgrids-fe-sdk 2026.925.2 → 2026.930.1

package/dist/{chunk-6SXISR7B.js → chunk-VG2BTLUN.js}

@@ -7,10 +7,10 @@ import { GetMyNodeInstallationsDocument, BrowseWorkflowTemplatesDocument, Instal
 import { QuotaExhaustedDialog } from './chunk-AANIWER2.js';
 import { SdkPermissionGate, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-W23ZXNKU.js';
 import { cn as cn$1 } from './chunk-3ZYUGTIT.js';
-import { useWorkflowVersions, useRestoreWorkflowVersion, useActivateWorkflow, useDeleteWorkflow, useLazyWorkflowDefinition, useDeactivateWorkflow } from './chunk-H5LGKSBM.js';
+import { useWorkflowVersions, useRestoreWorkflowVersion, useActivateWorkflow, useDeleteWorkflow, useLazyWorkflowDefinition, useDeactivateWorkflow } from './chunk-GKSXZFDY.js';
 import { config, getFluidGridsConfig, validateTrustedOrigin, setFluidGridsConfig, resetFluidGridsConfig } from './chunk-U4AJLVHA.js';
-import { useFlowStore } from './chunk-YMD3T6J2.js';
-import { NodeEndpointConfigsDocument, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowRunDocument, FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, NodeSchemaIntrospectionDocument, useWorkflowPinnedDataQuery, usePinNodeDataMutation, useUnpinNodeDataMutation, EventRegistrationsDocument, NodeUsageStatusDocument, RemoveNodeFromWorkflowsDocument } from './chunk-UBKJDGYS.js';
+import { useFlowStore } from './chunk-NTJTPYCD.js';
+import { NodeEndpointConfigsDocument, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowRunDocument, FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, NodeSchemaIntrospectionDocument, useWorkflowPinnedDataQuery, usePinNodeDataMutation, useUnpinNodeDataMutation, useRunFromNodeEligibilityQuery, EventRegistrationsDocument, NodeUsageStatusDocument, RemoveNodeFromWorkflowsDocument } from './chunk-3P4YQ7DO.js';
 import { throwIfResultError, describeOperationError } from './chunk-LMO5ASOE.js';
 import { useTr, FluidGridsTranslationProvider, ENGLISH_FALLBACK_TRANSLATOR } from './chunk-7YWBH2A5.js';
 import { waitForFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, createFluidGridsClient, setFluidGridsClient, resetFluidGridsClient } from './chunk-5BDQNSP3.js';
@@ -3601,6 +3601,7 @@ function ConnectionSelector({
   ] });
 }
 var TRIGGER_WORKFLOW = TriggerWorkflowDocument;
+var EXECUTE_STEP = ExecuteStepDocument;
 var WORKFLOW_RUN = WorkflowRunDocument;
 var RUN_FROM_NODE = RunFromNodeDocument;
 var EXECUTION_DETAIL = ExecutionDetailDocument;
@@ -3640,6 +3641,10 @@ function useNodeExecution() {
   const startExecution = useFlowStore(
     (s) => s.actions.execution.startExecution
   );
+  const setRunMetadata = useFlowStore(
+    (s) => s.actions.execution.setRunMetadata
+  );
+  const setStepPlan = useFlowStore((s) => s.actions.execution.setStepPlan);
   const addLog = useFlowStore((s) => s.actions.execution.addLog);
   const updateLog = useFlowStore((s) => s.actions.execution.updateLog);
   const setNodeStatus = useFlowStore((s) => s.actions.execution.setNodeStatus);
@@ -3803,6 +3808,11 @@ function useNodeExecution() {
             }
             return;
           }
+          setRunMetadata({
+            runId,
+            workflowKey: run.workflowKey,
+            version: run.version
+          });
           if (run.nodeStates?.length) {
             processNodeStates(runId, run.nodeStates);
           }
@@ -3822,60 +3832,56 @@ function useNodeExecution() {
       };
       pollTimerRef.current = setTimeout(doPoll, 800);
     },
-    [processNodeStates, completeExecution, cleanup]
+    [processNodeStates, completeExecution, cleanup, setRunMetadata]
   );
-  const executeNode = useCallback(
-    async (stopAtNodeId) => {
-      const triggerNode = findTriggerNode();
-      if (!triggerNode) {
-        console.error("[useNodeExecution] No trigger node found in workflow");
-        return { success: false, error: "No trigger node found" };
-      }
+  const executeStep = useCallback(
+    async (nodeId) => {
       cleanup();
       clearLogs();
       const workflowKey = workflow.workflowKey || workflow.id;
       const version = workflow.version || "1.0.0";
       if (!workflowKey) {
         console.error(
-          "[useNodeExecution] Workflow must be saved before execution. No workflowKey found."
+          "[useNodeExecution] Workflow must be saved before step execution. No workflowKey found."
         );
         return {
           success: false,
           error: "Workflow must be saved before execution"
         };
       }
-      setNodeStatus(stopAtNodeId, "running");
+      setNodeStatus(nodeId, "running");
       try {
         const client = getFluidGridsClient();
         const result = throwIfResultError(
           await client.mutate({
-            mutation: TRIGGER_WORKFLOW,
+            mutation: EXECUTE_STEP,
             variables: {
               input: {
                 workflowKey,
                 version,
-                triggerNodeId: triggerNode.id,
-                triggerData: {},
-                context: {},
-                stopAtNodeId,
-                // Step execution from the builder is always a manual/debug
-                // run (BOFF-7511) — pinned node data only ever applies here,
-                // never on a PRODUCTION trigger (webhook, schedule, API).
-                mode: "TEST"
+                nodeId
               }
             }
           })
         );
-        const triggerResult = result.data?.triggerWorkflow;
-        if (triggerResult) {
-          const backendRunId = triggerResult.runId;
-          startExecution(stopAtNodeId, backendRunId);
+        const stepResult = result.data?.executeStep;
+        if (stepResult) {
+          const backendRunId = stepResult.runId;
+          startExecution(nodeId, backendRunId, {
+            workflowKey: stepResult.workflowKey,
+            version: stepResult.version
+          });
+          setStepPlan({
+            runId: backendRunId,
+            ...stepResult.plan,
+            sourceRunId: stepResult.plan.sourceRunId ?? null
+          });
           const initialLog = {
-            id: `${backendRunId}-${stopAtNodeId}`,
+            id: `${backendRunId}-${nodeId}`,
             runId: backendRunId,
-            nodeId: stopAtNodeId,
-            nodeType: workflow.nodes.find((n) => n.id === stopAtNodeId)?.type || "unknown",
-            nodeName: getNodeName(stopAtNodeId),
+            nodeId,
+            nodeType: workflow.nodes.find((node) => node.id === nodeId)?.type || "unknown",
+            nodeName: getNodeName(nodeId),
             status: "running",
             inputArgs: null,
             output: null,
@@ -3886,21 +3892,21 @@ function useNodeExecution() {
           };
           addLog(initialLog);
           pollRunUpdates(backendRunId);
-          return { success: true, runId: backendRunId };
+          return { success: true, runId: backendRunId, plan: stepResult.plan };
         }
-        console.error("[useNodeExecution] No result from trigger");
-        setNodeStatus(stopAtNodeId, "error");
-        return { success: false, error: "No result from trigger" };
+        console.error("[useNodeExecution] No result from executeStep");
+        setNodeStatus(nodeId, "error");
+        return { success: false, error: "No result from executeStep" };
       } catch (error) {
-        console.error("[useNodeExecution] Error triggering workflow:", error);
+        console.error("[useNodeExecution] Error executing step:", error);
         const errorMessage = describeOperationError(error);
         const errorRunId = nanoid$1();
         const errorLog = {
-          id: `${errorRunId}-${stopAtNodeId}`,
+          id: `${errorRunId}-${nodeId}`,
           runId: errorRunId,
-          nodeId: stopAtNodeId,
-          nodeType: workflow.nodes.find((n) => n.id === stopAtNodeId)?.type || "unknown",
-          nodeName: getNodeName(stopAtNodeId),
+          nodeId,
+          nodeType: workflow.nodes.find((node) => node.id === nodeId)?.type || "unknown",
+          nodeName: getNodeName(nodeId),
           status: "failed",
           inputArgs: null,
           output: null,
@@ -3910,16 +3916,16 @@ function useNodeExecution() {
           endTime: (/* @__PURE__ */ new Date()).toISOString()
         };
         addLog(errorLog);
-        setNodeStatus(stopAtNodeId, "error");
+        setNodeStatus(nodeId, "error");
         completeExecution();
         return { success: false, error: errorMessage };
       }
     },
     [
-      findTriggerNode,
       cleanup,
       clearLogs,
       startExecution,
+      setStepPlan,
       workflow,
       getNodeName,
       addLog,
@@ -3961,8 +3967,9 @@ function useNodeExecution() {
                 triggerNodeId: triggerNode.id,
                 triggerData: customTriggerData || {},
                 context: {},
-                // Builder "Test workflow" is always a manual/debug run
-                // (BOFF-7511) — see the note on executeNode above.
+                // Builder "Test workflow" is always a manual/debug run.
+                // Pinned node data only applies to TEST executions, never a
+                // production trigger (webhook, schedule, API).
                 mode: "TEST"
               }
             }
@@ -3971,7 +3978,10 @@ function useNodeExecution() {
         const triggerResult = result.data?.triggerWorkflow;
         if (triggerResult) {
           const backendRunId = triggerResult.runId;
-          startExecution(triggerNode.id, backendRunId);
+          startExecution(triggerNode.id, backendRunId, {
+            workflowKey: triggerResult.workflowKey,
+            version: triggerResult.version
+          });
           pollRunUpdates(backendRunId);
           return { success: true, runId: backendRunId };
         }
@@ -4030,7 +4040,7 @@ function useNodeExecution() {
                 sourceRunId,
                 nodeId,
                 // Run-from-node is a debug affordance — always TEST, same
-                // rule as executeNode/executeFullWorkflow above.
+                // rule as the other builder debug execution paths.
                 mode: "TEST"
               }
             }
@@ -4039,7 +4049,10 @@ function useNodeExecution() {
         const runFromNodeResult = result.data?.runFromNode;
         if (runFromNodeResult) {
           const backendRunId = runFromNodeResult.runId;
-          startExecution(nodeId, backendRunId);
+          startExecution(nodeId, backendRunId, {
+            workflowKey: runFromNodeResult.workflowKey,
+            version: runFromNodeResult.version
+          });
           pollRunUpdates(backendRunId);
           return { success: true, runId: backendRunId };
         }
@@ -4099,7 +4112,10 @@ function useNodeExecution() {
             reusedFromRunId: nodeState.reusedFromRunId ?? null
           };
         });
-        loadDebugRun(runId, logs);
+        loadDebugRun(runId, logs, {
+          workflowKey: run.workflowKey,
+          version: run.version
+        });
         return { success: true, runId };
       } catch (error) {
         console.error("[useNodeExecution] Error loading execution:", error);
@@ -4117,7 +4133,7 @@ function useNodeExecution() {
     };
   }, [cleanup, completeExecution]);
   return {
-    executeNode,
+    executeStep,
     executeFullWorkflow,
     executeFromNode,
     loadExecution,
@@ -6665,7 +6681,7 @@ var getNodeMetadata = (value) => {
         return updated;
       });
     }, [nodeType, id, edges, data, setNodes, zustandSetNodes]);
-    const { executeNode } = useNodeExecution();
+    const { executeStep } = useNodeExecution();
     const deleteNode = useDeleteNode();
     const handleDeleteNode = () => {
       deleteNode(id);
@@ -6723,11 +6739,11 @@ var getNodeMetadata = (value) => {
       openNdv({ nodeId: id, type: value?.type });
     }, [id, openNdv]);
     const handleExecuteStep = useCallback(() => {
-      executeNode(id).then((_result) => {
+      executeStep(id).then((_result) => {
       }).catch((error) => {
-        console.error("[NodeComponent] Execute error:", error);
+        console.error("[NodeComponent] Execute step error:", error);
       });
-    }, [executeNode, id]);
+    }, [executeStep, id]);
     const missingCredentials = useMemo(() => {
       const visibleAdapters = getVisibleConnectionAdapters(
         String(value?.type ?? ""),
@@ -23831,6 +23847,335 @@ function useMediaQuery(query) {
   }, [query]);
   return matches;
 }
+
+// src/builder/lib/continuation.ts
+var BLOCKED = {
+  eligible: false,
+  action: null,
+  blockers: [],
+  blockerReason: null,
+  reason: null
+};
+function blocked(blockerReason, reason, blockers = [], targetStatus = null) {
+  return {
+    ...BLOCKED,
+    targetStatus,
+    blockerReason,
+    blockers,
+    reason
+  };
+}
+function sourceMetadata(input) {
+  const source = input.sourceRun;
+  return {
+    runId: source?.runId ?? input.sourceRunId ?? null,
+    workflowKey: source?.workflowKey ?? input.sourceRunWorkflowKey ?? null,
+    version: source?.version ?? source?.workflowVersion ?? input.sourceRunVersion ?? null
+  };
+}
+function getContinuationEligibility(input) {
+  const source = sourceMetadata(input);
+  if (!source.runId) {
+    return blocked(
+      "missing-source-run",
+      "Load a completed or failed run before continuing from this node."
+    );
+  }
+  if (!source.workflowKey || !source.version || source.workflowKey !== input.workflowKey || source.version !== input.workflowVersion) {
+    return blocked(
+      "incompatible-source-run",
+      "The selected run belongs to a different workflow version."
+    );
+  }
+  const nodeIds = new Set(input.nodes.map((node) => node.id));
+  if (!nodeIds.has(input.targetNodeId)) {
+    return blocked(
+      "missing-target",
+      "The selected node is not present in this workflow.",
+      [input.targetNodeId]
+    );
+  }
+  const logsByNode = /* @__PURE__ */ new Map();
+  for (const log of input.logs) {
+    if (log.runId === source.runId) logsByNode.set(log.nodeId, log);
+  }
+  const targetLog = logsByNode.get(input.targetNodeId);
+  const targetStatus = targetLog?.status?.toLowerCase() ?? null;
+  const action = targetStatus === "failed" ? "retry" : targetStatus === null || targetStatus === "completed" ? "continue" : null;
+  if (!action) {
+    return blocked(
+      "target-not-terminal",
+      "Continue is available only for completed or failed nodes.",
+      [input.targetNodeId],
+      targetStatus
+    );
+  }
+  const predecessors = /* @__PURE__ */ new Map();
+  for (const edge of input.edges) {
+    const parents = predecessors.get(edge.target) ?? [];
+    if (!parents.includes(edge.source)) parents.push(edge.source);
+    predecessors.set(edge.target, parents);
+  }
+  const ancestors = /* @__PURE__ */ new Set();
+  const cycleNodes = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set([input.targetNodeId]);
+  const visited = /* @__PURE__ */ new Set();
+  const visitAncestor = (nodeId) => {
+    if (visiting.has(nodeId)) {
+      cycleNodes.add(nodeId);
+      return;
+    }
+    if (visited.has(nodeId)) return;
+    ancestors.add(nodeId);
+    visiting.add(nodeId);
+    for (const parentId of predecessors.get(nodeId) ?? []) {
+      visitAncestor(parentId);
+    }
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+  };
+  for (const parentId of predecessors.get(input.targetNodeId) ?? []) {
+    visitAncestor(parentId);
+  }
+  if (cycleNodes.size > 0) {
+    return blocked(
+      "cycle",
+      "This workflow has a cycle upstream of the selected node, so continuation is disabled.",
+      [...cycleNodes].sort(),
+      targetStatus
+    );
+  }
+  for (const ancestorId of ancestors) {
+    if (!nodeIds.has(ancestorId) || !logsByNode.has(ancestorId)) {
+      return blocked(
+        "missing-ancestor-log",
+        "Every upstream node must have a result in the selected run.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+    const ancestor = logsByNode.get(ancestorId);
+    if (ancestor?.status.toLowerCase() !== "completed") {
+      return blocked(
+        "ancestor-not-completed",
+        "Every upstream node must be completed before continuing.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+    if (ancestor.output == null) {
+      return blocked(
+        "ancestor-missing-output",
+        "Every completed upstream node must have output data before continuing.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+  }
+  return {
+    eligible: true,
+    action,
+    targetStatus,
+    blockers: [],
+    blockerReason: null,
+    reason: null
+  };
+}
+function NodeExecutionActions({
+  targetNodeId,
+  nodes,
+  edges,
+  logs,
+  workflowKey,
+  workflowVersion,
+  sourceRun,
+  onExecuteStep,
+  onContinueFromNode,
+  isExecuting = false,
+  className,
+  testIdPrefix = "node-execution"
+}) {
+  const tr = useTr();
+  const [pendingAction, setPendingAction] = useState(null);
+  const localEligibility = useMemo(
+    () => getContinuationEligibility({
+      nodes,
+      edges,
+      logs,
+      targetNodeId,
+      workflowKey,
+      workflowVersion,
+      sourceRun
+    }),
+    [nodes, edges, logs, targetNodeId, workflowKey, workflowVersion, sourceRun]
+  );
+  const queryIdentity = `${sourceRun?.runId ?? ""}:${targetNodeId}`;
+  const sourceStateVersion = useMemo(
+    () => logs.filter((log) => !sourceRun || log.runId === sourceRun.runId).map(
+      (log) => `${log.nodeId}:${log.status}:${log.output == null ? "empty" : "ready"}`
+    ).sort().join("|"),
+    [logs, sourceRun]
+  );
+  const queryIdentityRef = useRef(queryIdentity);
+  const {
+    data: eligibilityData,
+    loading: eligibilityLoading,
+    error: eligibilityError,
+    refetch: refetchEligibility
+  } = useRunFromNodeEligibilityQuery({
+    variables: {
+      input: {
+        sourceRunId: sourceRun?.runId ?? "",
+        nodeId: targetNodeId
+      }
+    },
+    skip: !sourceRun,
+    fetchPolicy: "network-only",
+    nextFetchPolicy: "network-only"
+  });
+  useEffect(() => {
+    if (!sourceRun) {
+      queryIdentityRef.current = queryIdentity;
+      return;
+    }
+    if (queryIdentityRef.current !== queryIdentity) {
+      queryIdentityRef.current = queryIdentity;
+      return;
+    }
+    void refetchEligibility();
+  }, [queryIdentity, refetchEligibility, sourceRun?.runId, sourceStateVersion]);
+  const serverEligibility = sourceRun && !eligibilityLoading && !eligibilityError && eligibilityData?.runFromNodeEligibility ? (() => {
+    const result = eligibilityData.runFromNodeEligibility;
+    const targetStatus = result.targetStatus?.toLowerCase() ?? null;
+    return {
+      eligible: result.eligible,
+      action: targetStatus === "failed" ? "retry" : result.eligible ? "continue" : null,
+      targetStatus,
+      blockers: result.blockedNodeIds.length ? result.blockedNodeIds : result.blockers,
+      blockerReason: null,
+      reason: result.reason ?? null
+    };
+  })() : null;
+  const eligibility = sourceRun ? serverEligibility ?? {
+    eligible: false,
+    action: null,
+    reason: eligibilityError ? tr(
+      "fluidgrids.builder.nodeExecutionActions.queryError",
+      "Unable to verify continuation readiness. Try loading the run again."
+    ) : tr(
+      "fluidgrids.builder.nodeExecutionActions.checking",
+      "Checking continuation readiness\u2026"
+    )
+  } : localEligibility;
+  const runAction = async (action, callback) => {
+    setPendingAction(action);
+    try {
+      await callback();
+    } finally {
+      setPendingAction(null);
+    }
+  };
+  const executePending = pendingAction === "execute" || isExecuting;
+  const continuePending = pendingAction === "continue";
+  const continuationLabel = eligibility.action === "retry" ? tr(
+    "fluidgrids.builder.nodeExecutionActions.retryFromHere",
+    "Retry from here"
+  ) : tr(
+    "fluidgrids.builder.nodeExecutionActions.continueFromHere",
+    "Continue from here"
+  );
+  const blockerLabel = eligibility.reason ? tr(
+    "fluidgrids.builder.nodeExecutionActions.blocked",
+    "Unavailable: {{reason}}",
+    { reason: eligibility.reason }
+  ) : tr(
+    "fluidgrids.builder.nodeExecutionActions.noSourceRun",
+    "Load a run to enable continuation."
+  );
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: cn(
+        "shrink-0 border-t border-border bg-muted/20 px-3 py-2",
+        className
+      ),
+      "aria-label": tr(
+        "fluidgrids.builder.nodeExecutionActions.ariaLabel",
+        "Node execution actions"
+      ),
+      "data-testid": `${testIdPrefix}-execution-actions`,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-[10px] font-semibold uppercase tracking-[0.12em] text-muted-foreground", children: tr("fluidgrids.builder.nodeExecutionActions.heading", "Execution") }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                void runAction("execute", () => onExecuteStep(targetNodeId));
+              },
+              disabled: executePending || continuePending,
+              title: tr(
+                "fluidgrids.builder.nodeExecutionActions.executeStepHint",
+                "Run only this node as a fresh TEST execution."
+              ),
+              className: "inline-flex items-center gap-1 rounded-md border border-border bg-background px-2 py-1 text-xs font-medium text-foreground transition-colors hover:bg-muted disabled:cursor-not-allowed disabled:opacity-50",
+              "data-testid": `${testIdPrefix}-execute-step`,
+              children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: executePending ? "svg-spinners:ring-resize" : "mdi:play",
+                    className: "size-3.5"
+                  }
+                ),
+                tr(
+                  "fluidgrids.builder.nodeExecutionActions.executeStep",
+                  "Execute step"
+                )
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                if (!eligibility.eligible || !sourceRun) return;
+                void runAction(
+                  "continue",
+                  () => onContinueFromNode(sourceRun.runId, targetNodeId)
+                );
+              },
+              disabled: !eligibility.eligible || !sourceRun || executePending || continuePending,
+              title: eligibility.eligible ? continuationLabel : blockerLabel,
+              className: "inline-flex items-center gap-1 rounded-md border border-primary/30 bg-primary/5 px-2 py-1 text-xs font-medium text-primary transition-colors hover:bg-primary/10 disabled:cursor-not-allowed disabled:opacity-50",
+              "data-testid": `${testIdPrefix}-continue-from-here`,
+              children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: continuePending ? "svg-spinners:ring-resize" : "mdi:skip-forward",
+                    className: "size-3.5"
+                  }
+                ),
+                continuePending ? tr("fluidgrids.builder.nodeExecutionActions.running", "Running\u2026") : continuationLabel
+              ]
+            }
+          )
+        ] }),
+        !eligibility.eligible && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-1 text-[10px] leading-snug text-muted-foreground",
+            "data-testid": `${testIdPrefix}-continuation-blocker`,
+            children: blockerLabel
+          }
+        )
+      ]
+    }
+  );
+}
 var SECTION_LABEL5 = "text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground";
 function NodeDetailView() {
   const tr = useTr();
@@ -23856,11 +24201,20 @@ function NodeDetailView() {
   const [inputView, setInputView] = useState("schema");
   const executionLogs = useFlowStore((s) => s.execution.logs);
   const currentRunId = useFlowStore((s) => s.execution.currentRunId);
+  const sourceRun = useFlowStore((s) => s.execution.sourceRun);
+  const isExecuting = useFlowStore((s) => s.execution.isExecuting);
+  const workflowNodes = useFlowStore((s) => s.workflow.nodes);
+  const workflowEdges = useFlowStore((s) => s.workflow.edges);
+  const workflowKey = useFlowStore((s) => s.workflow.workflowKey);
+  const workflowId = useFlowStore((s) => s.workflow.id);
+  const workflowVersion = useFlowStore((s) => s.workflow.version);
+  const stepPlan = useFlowStore((s) => s.execution.stepPlan);
   const nodeLog = useMemo(() => {
     if (!ndv?.nodeId) return null;
     const matches = executionLogs.filter((l) => l.nodeId === ndv.nodeId);
     return matches.length > 0 ? matches[matches.length - 1] : null;
   }, [executionLogs, ndv?.nodeId]);
+  const stepPlanForNode = stepPlan?.runId === currentRunId && stepPlan.targetNodeId === ndv?.nodeId ? stepPlan : null;
   const hasRealOutput = !!nodeLog?.output && Object.keys(nodeLog.output).length > 0;
   const hasRealInput = !!nodeLog?.inputArgs && Object.keys(nodeLog.inputArgs).length > 0;
   const realOutputFields = useMemo(
@@ -23899,18 +24253,7 @@ function NodeDetailView() {
       console.error("[NodeDetailView] Failed to toggle pinned data", err);
     }
   };
-  const { executeFromNode } = useNodeExecution();
-  const [runningFromHere, setRunningFromHere] = useState(false);
-  const canRunFromHere = !!currentRunId && nodeLog?.status === "completed";
-  const runFromHere = async () => {
-    if (!currentRunId || !ndv?.nodeId) return;
-    setRunningFromHere(true);
-    try {
-      await executeFromNode(currentRunId, ndv.nodeId);
-    } finally {
-      setRunningFromHere(false);
-    }
-  };
+  const { executeStep, executeFromNode } = useNodeExecution();
   const threePaneLayout = useMediaQuery("(min-width: 1024px)");
   const [pane, setPane] = useState("parameters");
   const panesRef = useRef(null);
@@ -23972,33 +24315,6 @@ function NodeDetailView() {
             /* @__PURE__ */ jsx(DialogTitle, { className: "truncate text-sm font-semibold leading-tight", children: nodeTitle(node) }),
             nodeSubtitle(node) && /* @__PURE__ */ jsx(DialogDescription, { className: "truncate text-xs leading-tight", children: nodeSubtitle(node) })
           ] }),
-          canRunFromHere && /* @__PURE__ */ jsxs(
-            "button",
-            {
-              type: "button",
-              onClick: runFromHere,
-              disabled: runningFromHere,
-              "data-testid": "ndv-run-from-here",
-              className: "flex items-center gap-1 rounded-md border border-primary/30 px-2 py-1 text-xs text-primary hover:bg-primary/10 disabled:opacity-50",
-              title: tr(
-                "fluidgrids.builder.nodeDetailView.runFromHereHint",
-                "Re-run from this node, reusing upstream outputs instead of re-executing them."
-              ),
-              children: [
-                /* @__PURE__ */ jsx(
-                  Icon,
-                  {
-                    icon: runningFromHere ? "svg-spinners:ring-resize" : "mdi:play",
-                    className: "size-3.5"
-                  }
-                ),
-                tr(
-                  "fluidgrids.builder.nodeDetailView.runFromHereButton",
-                  "Run from here"
-                )
-              ]
-            }
-          ),
           /* @__PURE__ */ jsx(
             "button",
             {
@@ -24025,6 +24341,28 @@ function NodeDetailView() {
             }
           )
         ] }),
+        ndv && /* @__PURE__ */ jsx(
+          NodeExecutionActions,
+          {
+            targetNodeId: ndv.nodeId,
+            nodes: workflowNodes,
+            edges: workflowEdges,
+            logs: executionLogs,
+            workflowKey: workflowKey || workflowId,
+            workflowVersion: workflowVersion || "1.0.0",
+            sourceRun,
+            isExecuting,
+            onExecuteStep: async (targetId) => {
+              await executeStep(targetId);
+            },
+            onContinueFromNode: async (sourceRunId, targetId) => {
+              await executeFromNode(sourceRunId, targetId);
+            },
+            testIdPrefix: "ndv",
+            className: "border-t-0 border-b"
+          }
+        ),
+        stepPlanForNode && /* @__PURE__ */ jsx(StepExecutionPlanSummary, { plan: stepPlanForNode }),
         !threePaneLayout && /* @__PURE__ */ jsxs(
           "div",
           {
@@ -24349,6 +24687,152 @@ function NodeDetailView() {
     }
   ) });
 }
+function StepExecutionPlanSummary({ plan }) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "shrink-0 border-b border-border bg-muted/30 px-4 py-2.5",
+      "data-testid": "ndv-step-execution-plan",
+      "aria-live": "polite",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-x-3 gap-y-1", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold text-foreground", children: tr(
+            "fluidgrids.builder.nodeDetailView.stepPlanTitle",
+            "TEST execution plan"
+          ) }),
+          /* @__PURE__ */ jsx(
+            PlanMetric,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanExecute",
+                "Execute"
+              ),
+              count: plan.executeNodeIds.length
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanMetric,
+            {
+              label: tr("fluidgrids.builder.nodeDetailView.stepPlanReuse", "Reuse"),
+              count: plan.reusedNodeIds.length
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanMetric,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanPinned",
+                "Pinned"
+              ),
+              count: plan.pinnedNodeIds.length
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanMetric,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanBlockers",
+                "Blockers"
+              ),
+              count: plan.blockers.length
+            }
+          )
+        ] }),
+        plan.sourceRunId && /* @__PURE__ */ jsxs("p", { className: "mt-1 text-[11px] text-muted-foreground", children: [
+          tr(
+            "fluidgrids.builder.nodeDetailView.stepPlanSource",
+            "Using compatible TEST data from run"
+          ),
+          " ",
+          /* @__PURE__ */ jsx("code", { className: "font-mono text-foreground", children: plan.sourceRunId })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "mt-2 grid gap-2 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsx(
+            PlanNodeList,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanExecuteNodes",
+                "Nodes to execute"
+              ),
+              nodeIds: plan.executeNodeIds,
+              emptyLabel: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanExecuteNodesEmpty",
+                "No nodes need execution."
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanNodeList,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanReusedNodes",
+                "Reused nodes"
+              ),
+              nodeIds: plan.reusedNodeIds,
+              emptyLabel: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanReusedNodesEmpty",
+                "No prior node data reused."
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanNodeList,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanPinnedNodes",
+                "Pinned nodes"
+              ),
+              nodeIds: plan.pinnedNodeIds,
+              emptyLabel: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanPinnedNodesEmpty",
+                "No pinned data used."
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PlanNodeList,
+            {
+              label: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanBlockerNodes",
+                "Blockers"
+              ),
+              nodeIds: plan.blockers,
+              emptyLabel: tr(
+                "fluidgrids.builder.nodeDetailView.stepPlanBlockerNodesEmpty",
+                "No blockers."
+              )
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function PlanMetric({ label, count: count2 }) {
+  return /* @__PURE__ */ jsxs("span", { className: "text-[11px] text-muted-foreground", children: [
+    label,
+    ": ",
+    /* @__PURE__ */ jsx("span", { className: "font-medium text-foreground", children: count2 })
+  ] });
+}
+function PlanNodeList({
+  label,
+  nodeIds,
+  emptyLabel
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "min-w-0 rounded-md border border-border bg-background/60 px-2 py-1.5", children: [
+    /* @__PURE__ */ jsx("p", { className: "text-[10px] font-semibold uppercase tracking-wide text-muted-foreground", children: label }),
+    nodeIds.length > 0 ? /* @__PURE__ */ jsx("div", { className: "mt-1 flex flex-wrap gap-1", children: nodeIds.map((nodeId) => /* @__PURE__ */ jsx(
+      "code",
+      {
+        className: "max-w-full truncate rounded bg-muted px-1 py-0.5 font-mono text-[10px] text-foreground",
+        children: nodeId
+      },
+      `${label}-${nodeId}`
+    )) }) : /* @__PURE__ */ jsx("p", { className: "mt-1 text-[10px] text-muted-foreground", children: emptyLabel })
+  ] });
+}
 function ResizeHandle({ onStart }) {
   return /* @__PURE__ */ jsx(
     "div",
@@ -24465,6 +24949,9 @@ function QuickConfigPanelInner({
   const close = useFlowStore((s) => s.actions.quickConfig.close);
   const openNdv = useFlowStore((s) => s.actions.ndv.open);
   const tr = useTr();
+  const { executeStep, executeFromNode } = useNodeExecution();
+  const workflow = useFlowStore((s) => s.workflow);
+  const execution = useFlowStore((s) => s.execution);
   const config2 = useNodeConfig({ nodeId});
   const {
     node,
@@ -24750,6 +25237,26 @@ function QuickConfigPanelInner({
                   )
                 }
               ),
+              /* @__PURE__ */ jsx(
+                NodeExecutionActions,
+                {
+                  targetNodeId: nodeId,
+                  nodes: workflow.nodes,
+                  edges: workflow.edges,
+                  logs: execution.logs,
+                  workflowKey: workflow.workflowKey || workflow.id,
+                  workflowVersion: workflow.version || "1.0.0",
+                  sourceRun: execution.sourceRun,
+                  isExecuting: execution.isExecuting,
+                  onExecuteStep: async (targetId) => {
+                    await executeStep(targetId);
+                  },
+                  onContinueFromNode: async (sourceRunId, targetId) => {
+                    await executeFromNode(sourceRunId, targetId);
+                  },
+                  testIdPrefix: "qc"
+                }
+              ),
               /* @__PURE__ */ jsx("p", { className: "shrink-0 border-t border-border px-3 py-1.5 text-[10px] leading-snug text-muted-foreground", children: tr(
                 "fluidgrids.builder.quickConfigPanel.footerHint",
                 "Changes apply instantly \xB7 double-click the node for the full editor"
@@ -26040,5 +26547,5 @@ var FlowBuilderPage = ({
 };
 
 export { Card2 as Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ConnectionFormDialog, ConnectionSelector, EntityTagPicker, FLUIDGRIDS_ENTITY_TYPES, FlowBuilderPage, FluidGridsMark, FluidGridsProvider, ProviderPicker, SchemaConnectionForm, ScopePicker, TemplateCard, buildNodeCheck, buildRequiredNodeTypes, listCustomBlocks, mergeStickyNotes, refetchStoreNodes, registerCustomBlock, resolveUiSpec, stripSubmitActions, tagLabel, useAvailableTags, useConnection, useConnectionDialog, useConnections, useConnectionsByProvider, useCreateConnection, useCreateTag, useDraftEntityTags, useEntityTags, useFluidGridsContext, useImportWorkflowTemplate, useInitiateOAuth, useInstalledNodes, useNodeExecution, useProviderByKey, useProviderCatalog, useProviders, useReplaceEntityTags, useSearchTags, useTagEntity, useUntagEntity, useWorkflowTemplates };
-//# sourceMappingURL=chunk-6SXISR7B.js.map
-//# sourceMappingURL=chunk-6SXISR7B.js.map
+//# sourceMappingURL=chunk-VG2BTLUN.js.map
+//# sourceMappingURL=chunk-VG2BTLUN.js.map