@burdenoff/fluidgrids-fe-sdk 2026.1103.1 → 2026.1103.2

package/dist/{chunk-SA474Y5U.js → chunk-MY4HMUWU.js}

@@ -1,8 +1,8 @@
-import { Card, FluidGridsMark } from './chunk-6O2B5NAK.js';
+import { Card, FluidGridsMark } from './chunk-LTINUSLK.js';
 import { Input } from './chunk-IEVSFCFS.js';
 import { Button } from './chunk-BQXVT32O.js';
-import { useWorkflowDefinition } from './chunk-EFOJEQDS.js';
-import { FluidGridsProvider, useFlowStore } from './chunk-23LYGZ27.js';
+import { useWorkflowDefinition } from './chunk-QXACKASD.js';
+import { FluidGridsProvider, useFlowStore } from './chunk-YC76QFWZ.js';
 import { cn } from './chunk-JL7CASN5.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useRef, useEffect, useCallback } from 'react';

package/dist/{chunk-PBCBDSVA.js → chunk-N6XYVO7N.js}

@@ -1,4 +1,4 @@
-import { mergeStickyNotes, describeOperationError, throwIfResultError } from './chunk-23LYGZ27.js';
+import { mergeStickyNotes, describeOperationError, throwIfResultError } from './chunk-YC76QFWZ.js';
 import { WorkflowDefinitionDocument, WorkflowVersionDiffDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';

package/dist/{chunk-3Y4266JL.js → chunk-OBWB73Y7.js}

@@ -2,7 +2,7 @@ import { operatorSpec, normaliseAssertRules, describeAssertRuleProblem } from '.
 import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-PC3CICOW.js';
 import { notifyFluidGridsAiCreditsUpdated } from './chunk-Y53CVZVV.js';
 import { ErrorType } from './chunk-AOLY5INN.js';
-import { throwIfResultError, isForbiddenError } from './chunk-23LYGZ27.js';
+import { throwIfResultError, isForbiddenError } from './chunk-YC76QFWZ.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument, WorkflowTestCasesDocument, WorkflowTestRunsDocument, WorkflowTestRunDocument, CreateWorkflowTestCaseDocument, UpdateWorkflowTestCaseDocument, DeleteWorkflowTestCaseDocument, RunWorkflowTestsDocument, CreateWorkflowTestCaseFromRunDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-EFOJEQDS.js → chunk-QXACKASD.js}

@@ -1,4 +1,4 @@
-import { useFluidGridsAnalytics, throwIfResultError, emitWorkflowCreated, emitRunStarted, runTriggerFromMode, openRunQuotaUpgradePrompt, emitWorkflowPublished } from './chunk-23LYGZ27.js';
+import { useFluidGridsAnalytics, throwIfResultError, emitWorkflowCreated, emitRunStarted, runTriggerFromMode, openRunQuotaUpgradePrompt, emitWorkflowPublished } from './chunk-YC76QFWZ.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { WorkflowDefinitionsDocument, WorkflowDefinitionDocument, WorkflowVersionsDocument, CreateWorkflowDefinitionDocument, ImportWorkflowDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, DeleteWorkflowDefinitionDocument, DuplicateWorkflowDocument, RestoreWorkflowVersionDocument, TriggerWorkflowDocument, WorkflowRunsDocument, WorkflowRunDocument, DashboardSummaryDocument, ActivateWorkflowDefinitionDocument, DeactivateWorkflowDefinitionDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-P6IRD5SA.js → chunk-RFOKJE3A.js}

@@ -1,13 +1,13 @@
-import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-UETHT3KG.js';
-import { useDurableParityRunFields, useRunMetadata, useRunPending, ExecutionStatusBadge, NodeTimeline, RunLogViewer, setRunVersioningOverride } from './chunk-ZTJX5ONT.js';
-import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-QAXP5HON.js';
-import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-A4XNCGWT.js';
-import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-DLKGWGRN.js';
-import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-3Y4266JL.js';
+import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-G2FPOWN5.js';
+import { useDurableParityRunFields, useRunMetadata, useRunPending, ExecutionStatusBadge, NodeTimeline, RunLogViewer, setRunVersioningOverride } from './chunk-K6HD5GC7.js';
+import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-6WPW42TX.js';
+import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-H2KIJEYM.js';
+import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-BVCMAGLJ.js';
+import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-OBWB73Y7.js';
 import { buildNodeDisplayMap, formatRunVersion } from './chunk-PC3CICOW.js';
 import { AiCreditBalanceSlot } from './chunk-Y53CVZVV.js';
-import { useWorkflowVersions } from './chunk-EFOJEQDS.js';
-import { throwIfResultError, useDurableFunctionNodesEnabled, useDurableParityEnabled, runSignalTargets, canSignalRun, useWorkflowTestsEnabled, describeOperationError } from './chunk-23LYGZ27.js';
+import { useWorkflowVersions } from './chunk-QXACKASD.js';
+import { throwIfResultError, useDurableFunctionNodesEnabled, useDurableParityEnabled, runSignalTargets, canSignalRun, useWorkflowTestsEnabled, describeOperationError } from './chunk-YC76QFWZ.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ZUVFD5KV.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument } from './chunk-JTQFBZTV.js';

package/dist/{chunk-4XV2DAVO.js → chunk-SHYDX2LO.js}

@@ -1,10 +1,10 @@
-import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TEMPLATE_STORE_CATEGORIES, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-6O2B5NAK.js';
-import { QuotaExhaustedDialog } from './chunk-4FDMLKLL.js';
+import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TEMPLATE_STORE_CATEGORIES, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-LTINUSLK.js';
+import { QuotaExhaustedDialog } from './chunk-SIVS3XSV.js';
 import { templatesControls } from './chunk-FNZZ5JJL.js';
-import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-EFOJEQDS.js';
+import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-QXACKASD.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-23LYGZ27.js';
+import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-YC76QFWZ.js';
 import { SdkPermissionButton, FLUIDGRIDS_PERMISSIONS } from './chunk-ZUVFD5KV.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useEffect, useCallback, useMemo } from 'react';

package/dist/{chunk-4FDMLKLL.js → chunk-SIVS3XSV.js}

@@ -1,4 +1,4 @@
-import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-23LYGZ27.js';
+import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-YC76QFWZ.js';
 import { ExportWorkflowCodeDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';

package/dist/{chunk-W74MXVFX.js → chunk-SUIH376K.js}

@@ -1,4 +1,4 @@
-import { useFlowStore } from './chunk-23LYGZ27.js';
+import { useFlowStore } from './chunk-YC76QFWZ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { cn } from '@burdenoff/fe-libs/utils';

package/dist/{chunk-CXNJKM4D.js → chunk-UH7JKPUF.js}

@@ -1,5 +1,5 @@
 import { LOG_STREAM_DESTINATIONS, CREATE_LOG_STREAM_DESTINATION, UPDATE_LOG_STREAM_DESTINATION, DELETE_LOG_STREAM_DESTINATION, TEST_LOG_STREAM_DESTINATION, REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS, OBSERVABILITY_DASHBOARD_SUMMARY, OBSERVABILITY_FAILED_RUNS, OBSERVABILITY_DATA_SINKS, OBSERVABILITY_DATA_SINK_DATA } from './chunk-5ERAJC2I.js';
-import { throwIfResultError, describeOperationError, useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt, useFluidGridsFlag, FLUIDGRIDS_FLAGS } from './chunk-23LYGZ27.js';
+import { throwIfResultError, describeOperationError, useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt, useFluidGridsFlag, FLUIDGRIDS_FLAGS } from './chunk-YC76QFWZ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useCallback, useState, useMemo, useEffect } from 'react';

package/dist/{chunk-DQLSF6GB.js → chunk-UMULDJCK.js}

@@ -1,9 +1,9 @@
-import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-JCHE4V55.js';
+import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-52OIBKPO.js';
 import { registerLiveCanvasHandler } from './chunk-PIKYQE7P.js';
-import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-6O2B5NAK.js';
-import { canvasFromDefinition } from './chunk-PBCBDSVA.js';
-import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-EFOJEQDS.js';
-import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes, throwIfResultError } from './chunk-23LYGZ27.js';
+import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-LTINUSLK.js';
+import { canvasFromDefinition } from './chunk-N6XYVO7N.js';
+import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-QXACKASD.js';
+import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes, throwIfResultError } from './chunk-YC76QFWZ.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { WorkflowDefinitionDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-BDBSRN2O.js → chunk-UW5GY6LQ.js}

@@ -1,9 +1,9 @@
 import { CodeEditorField, normalizeCodeLanguage } from './chunk-AASHQI77.js';
-import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-TJ2PFY7I.js';
+import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-Y7MQ3LYB.js';
 import { Popover, PopoverTrigger, PopoverContent } from './chunk-GTEBQQ7J.js';
-import { isAgentNodeType, AgentDefinitionSelectField } from './chunk-A7QPQ6MO.js';
+import { isAgentNodeType, AgentDefinitionSelectField } from './chunk-VQZEGCRF.js';
 import { readAssertRulesSetting, rowsFromRules, normaliseAssertRules, ruleFromRow, describeAssertRuleProblem, operatorSpec, ASSERT_OPERATORS, emptyAssertRuleRow } from './chunk-JDLQ6QIB.js';
-import { useFlowStore, isParamVisible, ConnectionSelector, structuredParameterType, FluidGridsContext, ExpressionEditor, formatParameterValue, parseParameterValue, useFluidGridsAnalytics, throwIfResultError, openRunQuotaUpgradePrompt, describeOperationError } from './chunk-23LYGZ27.js';
+import { useFlowStore, isParamVisible, ConnectionSelector, structuredParameterType, useRunGuard, FluidGridsContext, ExpressionEditor, formatParameterValue, parseParameterValue, useFluidGridsAnalytics, throwIfResultError, openRunQuotaUpgradePrompt, describeOperationError } from './chunk-YC76QFWZ.js';
 import { useBuilderReadOnly } from './chunk-OCJTTHTS.js';
 import { useRunFromNodeEligibilityQuery, PreviewScheduleDocument, WebhookTestListenerDocument, StopWebhookTestListenerDocument, ListenForWebhookTestEventDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';
@@ -3822,7 +3822,10 @@ function NodeExecutionActions({
       setPendingAction(null);
     }
   };
-  const executePending = pendingAction === "execute" || isExecuting;
+  const stepGuard = useRunGuard(() => {
+    void runAction("execute", () => onExecuteStep(targetNodeId));
+  });
+  const executePending = pendingAction === "execute" || isExecuting || stepGuard.preparing;
   const continuePending = pendingAction === "continue";
   const continuationLabel = eligibility.action === "retry" ? tr(
     "fluidgrids.builder.nodeExecutionActions.retryFromHere",
@@ -3860,7 +3863,7 @@ function NodeExecutionActions({
               "data-agent": "confirm",
               type: "button",
               onClick: () => {
-                void runAction("execute", () => onExecuteStep(targetNodeId));
+                void stepGuard.requestRun();
               },
               disabled: executePending || continuePending,
               title: tr(
@@ -3913,6 +3916,7 @@ function NodeExecutionActions({
             }
           )
         ] }),
+        stepGuard.dialog,
         !eligibility.eligible && /* @__PURE__ */ jsx(
           "p",
           {

package/dist/{chunk-A7QPQ6MO.js → chunk-VQZEGCRF.js}

@@ -1,4 +1,4 @@
-import { useAgentDefinitions, useAgentDefinitionList, useConnections, describeOperationError } from './chunk-23LYGZ27.js';
+import { useAgentDefinitions, useAgentDefinitionList, useConnections, describeOperationError } from './chunk-YC76QFWZ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useCallback, useEffect } from 'react';
 import { Icon } from '@iconify/react';

package/dist/{chunk-6VODFT2Q.js → chunk-Y7BNGLRI.js}

@@ -1,8 +1,8 @@
-import { AgentsTab } from './chunk-A7QPQ6MO.js';
-import { ActionPoliciesTab } from './chunk-DLKGWGRN.js';
-import { LogStreamingTab } from './chunk-CXNJKM4D.js';
+import { AgentsTab } from './chunk-VQZEGCRF.js';
+import { ActionPoliciesTab } from './chunk-BVCMAGLJ.js';
+import { LogStreamingTab } from './chunk-UH7JKPUF.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, throwIfResultError, describeOperationError, useConnections } from './chunk-23LYGZ27.js';
+import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, throwIfResultError, describeOperationError, useConnections } from './chunk-YC76QFWZ.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ZUVFD5KV.js';
 import { getGlobalStoreClient } from './chunk-PXIFUMLA.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';

package/dist/{chunk-TJ2PFY7I.js → chunk-Y7MQ3LYB.js}

@@ -1,4 +1,4 @@
-import { structuredParameterType, parseParameterValue, liveInternalOperations, resolveNodeOperation, readDisplayOptions, getNodeDetail, useFlowStore, useNodeRegistryRevision, fieldsFromIO, pathToExpression, NODE_CONFIGS, resolveUiSpec, fieldsFromValue, declaredOutputFields, subscribeWorkflowSaved } from './chunk-23LYGZ27.js';
+import { structuredParameterType, parseParameterValue, liveInternalOperations, resolveNodeOperation, readDisplayOptions, getNodeDetail, useFlowStore, useNodeRegistryRevision, fieldsFromIO, pathToExpression, NODE_CONFIGS, resolveUiSpec, fieldsFromValue, declaredOutputFields, subscribeWorkflowSaved } from './chunk-YC76QFWZ.js';
 import { useBuilderReadOnly } from './chunk-OCJTTHTS.js';
 import { EventRegistrationsDocument } from './chunk-JTQFBZTV.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-23LYGZ27.js → chunk-YC76QFWZ.js}

@@ -23,7 +23,7 @@ import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { toast } from 'sonner';
 import { nodeCategoryColor, chartSeriesColor, chartSeriesIndex } from '@burdenoff/fe-libs/shared/utils';
 import { gql } from '@apollo/client';
-import { Textarea, Input, Button, Card, Dialog, DialogTrigger, DialogContent, DialogHeader, DialogTitle, DialogDescription, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuLabel, DropdownMenuItem, DropdownMenuSeparator } from '@burdenoff/fe-libs/ui';
+import { Textarea, Input, Button, Card, Dialog, DialogTrigger, DialogContent, DialogHeader, DialogTitle, DialogDescription, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuLabel, DropdownMenuItem, DropdownMenuSeparator, AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel } from '@burdenoff/fe-libs/ui';
 import * as AdaptiveCards from 'adaptivecards';
 import { formatDistanceToNow } from 'date-fns';
 import { ProviderIcon, ConnectionDialog } from '@burdenoff/fe-libs/connections';
@@ -33,6 +33,7 @@ import { useEventBus } from '@burdenoff/fe-libs/shared/events';
 import { ApolloProvider } from '@apollo/client/react';
 import { useShallow } from 'zustand/shallow';
 import { InfoCircledIcon } from '@radix-ui/react-icons';
+import { Button as Button$1 } from '@burdenoff/fe-libs/button';
 
 // src/feature-flags/durable-nodes.ts
 var DURABLE_FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
@@ -8674,6 +8675,348 @@ function useNodeExecution() {
     findTriggerNode
   };
 }
+function findEdges(node, connectedEdges) {
+  const outgoingEdges = connectedEdges.filter(
+    (edge) => edge.source === node.id
+  );
+  const incomingEdges = connectedEdges.filter(
+    (edge) => edge.target === node.id
+  );
+  return { outgoingEdges, incomingEdges };
+}
+function checkFlowTerminalNode(outgoingEdges, incomingEdges, isTrigger, type) {
+  if (isTrigger) {
+    return outgoingEdges.length >= 1;
+  }
+  switch (type) {
+    case "end" /* END */:
+      return incomingEdges.length >= 1;
+    default:
+      return false;
+  }
+}
+function checkLoneNode(outgoingEdges, incomingEdges, isTrigger) {
+  if (isTrigger) {
+    return outgoingEdges.length === 0;
+  }
+  return incomingEdges.length === 0;
+}
+function isFlowComplete(nodes, edges) {
+  const connectedEdges = getConnectedEdges(nodes, edges);
+  let isTriggerConnected = false;
+  let hasTriggerNode = false;
+  let hasEndNode = false;
+  let isEndConnected = false;
+  const nodesWithEmptyTarget = [];
+  for (const node of nodes) {
+    if (node.type === STICKY_NOTE_TYPE) continue;
+    const { outgoingEdges, incomingEdges } = findEdges(node, connectedEdges);
+    const isTrigger = isNodeTrigger(node);
+    if (isTrigger) {
+      hasTriggerNode = true;
+      if (checkFlowTerminalNode(
+        outgoingEdges,
+        incomingEdges,
+        true,
+        node.type
+      )) {
+        isTriggerConnected = true;
+      }
+    } else if (node.type === "end" /* END */) {
+      hasEndNode = true;
+      isEndConnected = checkFlowTerminalNode(
+        outgoingEdges,
+        incomingEdges,
+        false,
+        "end" /* END */
+      );
+    }
+    if (checkLoneNode(outgoingEdges, incomingEdges, isTrigger))
+      nodesWithEmptyTarget.push(node);
+  }
+  const hasAnyLoneNode = nodesWithEmptyTarget.length > 0;
+  const isEndValid = !hasEndNode || isEndConnected;
+  return hasTriggerNode && isTriggerConnected && isEndValid && !hasAnyLoneNode;
+}
+function useFlowValidator(onValidate) {
+  const [isValidating, setIsValidating] = useState(false);
+  const { getNodes, getEdges } = useReactFlow();
+  const validate = useCallback(async () => {
+    setIsValidating(true);
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    onValidate?.(isFlowComplete(getNodes(), getEdges()));
+    setIsValidating(false);
+  }, [getNodes, getEdges, onValidate]);
+  return [isValidating, validate];
+}
+
+// src/builder/lib/save-guards.ts
+function editingLeaseLocked() {
+  return isLocked(useEditLeaseStore.getState().phase);
+}
+function autosaveAllowedFor(workflow) {
+  return useSaveStatusStore.getState().autosaveEnabled && canAutosave(workflow);
+}
+function editStateFor(state) {
+  return editStateOf(
+    useSaveStatusStore.getState().baseline,
+    {
+      fingerprint: workflowFingerprint(state.workflow),
+      generation: state.loadGeneration,
+      editRevision: state.editRevision
+    },
+    Date.now()
+  );
+}
+function departingSave(state) {
+  const status = useSaveStatusStore.getState();
+  if (status.autosavePaused || editingLeaseLocked()) return null;
+  if (editStateFor(state) !== "dirty") return null;
+  if (!autosaveAllowedFor(state.workflow)) return null;
+  const { nodes, edges } = state.workflow;
+  if (!isFlowComplete(nodes, edges)) return null;
+  return snapshotForSave(state.workflow, state.loadGeneration);
+}
+function touchesSavedFields(state, previous) {
+  return state.workflow.nodes !== previous.workflow.nodes || state.workflow.edges !== previous.workflow.edges || state.workflow.name !== previous.workflow.name || state.workflow.alias !== previous.workflow.alias || state.workflow.status !== previous.workflow.status || state.loadGeneration !== previous.loadGeneration;
+}
+function unsavedState() {
+  const flow = useFlowStore.getState();
+  const status = useSaveStatusStore.getState();
+  return {
+    // Checked fresh: the dirty flag trails the last edit by a moment.
+    dirty: status.dirty || editStateFor(flow) === "dirty",
+    // A paused autosave (a refused save), or a page someone else is editing
+    // from, does not save on the way out either.
+    autosaveAllowed: autosaveAllowedFor(flow.workflow) && !status.autosavePaused && !editingLeaseLocked(),
+    incomplete: status.incomplete || !isFlowComplete(flow.workflow.nodes, flow.workflow.edges),
+    failed: status.failure !== null
+  };
+}
+function leavingLosesChanges() {
+  return leaveNeedsConfirmation(unsavedState());
+}
+function runPreparation() {
+  return runPreparationOf(unsavedState());
+}
+function savedEverythingBeforeLeaving() {
+  return editStateFor(useFlowStore.getState()) !== "dirty";
+}
+function watchLeavingLosesChanges(onChange, delayMs) {
+  let current;
+  let timer;
+  const report = (losesChanges) => {
+    if (losesChanges === current) return;
+    current = losesChanges;
+    onChange(losesChanges);
+  };
+  const settle = () => {
+    timer = void 0;
+    report(leavingLosesChanges());
+  };
+  const settleLater = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(settle, delayMs);
+  };
+  const settleNow = () => {
+    if (timer) clearTimeout(timer);
+    settle();
+  };
+  settle();
+  const unsubscribeFlow = useFlowStore.subscribe((state, previous) => {
+    if (!touchesSavedFields(state, previous)) return;
+    if (state.loadGeneration === previous.loadGeneration) report(true);
+    settleLater();
+  });
+  const unsubscribeStatus = useSaveStatusStore.subscribe(settleLater);
+  const unsubscribeLease = useEditLeaseStore.subscribe((state, previous) => {
+    if (isLocked(state.phase) !== isLocked(previous.phase)) settleNow();
+  });
+  return () => {
+    unsubscribeFlow();
+    unsubscribeStatus();
+    unsubscribeLease();
+    if (timer) clearTimeout(timer);
+  };
+}
+
+// src/builder/hooks/use-builder-save.ts
+function useManualSave() {
+  const tr = useTr();
+  const { saveToBackend } = useSaveWorkflow();
+  return useCallback(async () => {
+    const { nodes, edges } = useFlowStore.getState().workflow;
+    if (!isFlowComplete(nodes, edges)) {
+      toast.error(
+        tr(
+          "fluidgrids.builder.saveFlowButton.invalidToastTitle",
+          "Flow is invalid"
+        ),
+        {
+          description: tr(
+            "fluidgrids.builder.saveFlowButton.invalidToastDescription",
+            "Please check if the flow is complete and has no lone nodes"
+          )
+        }
+      );
+      return false;
+    }
+    return saveToBackend();
+  }, [saveToBackend, tr]);
+}
+function useGuardedNavigate() {
+  const navigate = useNavigate();
+  return useCallback(
+    (to, options) => {
+      if (leavingLosesChanges()) {
+        useSaveStatusStore.getState().actions.requestLeave({ to, options });
+        return;
+      }
+      navigate(to, options);
+    },
+    [navigate]
+  );
+}
+function useRunGuard(startRun) {
+  const { saveToBackend } = useSaveWorkflow();
+  const [confirmOpen, setConfirmOpen] = useState(false);
+  const [preparing, setPreparing] = useState(false);
+  const requestRun = useCallback(async () => {
+    const preparation = runPreparation();
+    if (preparation === "run") {
+      startRun();
+      return;
+    }
+    if (preparation === "save-first") {
+      setPreparing(true);
+      let saved = false;
+      try {
+        saved = await saveToBackend({ silent: true }) && savedEverythingBeforeLeaving();
+      } finally {
+        setPreparing(false);
+      }
+      if (saved) {
+        startRun();
+        return;
+      }
+    }
+    setConfirmOpen(true);
+  }, [saveToBackend, startRun]);
+  const dialog = /* @__PURE__ */ jsx(
+    UnsavedRunDialog,
+    {
+      open: confirmOpen,
+      onOpenChange: setConfirmOpen,
+      onRunSaved: () => {
+        setConfirmOpen(false);
+        startRun();
+      },
+      onSavedAndRunnable: () => {
+        setConfirmOpen(false);
+        startRun();
+      }
+    }
+  );
+  return { requestRun, preparing, dialog };
+}
+function UnsavedRunDialog({
+  open,
+  onOpenChange,
+  onRunSaved,
+  onSavedAndRunnable
+}) {
+  const tr = useTr();
+  const manualSave = useManualSave();
+  const [version, dbId, status, codeBuildId] = useFlowStore(
+    useShallow((s) => [
+      s.workflow.version,
+      s.workflow.dbId,
+      s.workflow.status,
+      s.workflow.codeBuildId
+    ])
+  );
+  const [saving, setSaving] = useState(false);
+  const hasSavedVersion = !!dbId;
+  const runsAfterSave = !hasSavedVersion || savesInPlace({ dbId, status, codeBuildId });
+  const save = useCallback(async () => {
+    setSaving(true);
+    try {
+      const saved = await manualSave();
+      if (!saved) return;
+      if (!runsAfterSave) {
+        onOpenChange(false);
+        return;
+      }
+      if (savedEverythingBeforeLeaving()) onSavedAndRunnable();
+    } finally {
+      setSaving(false);
+    }
+  }, [runsAfterSave, manualSave, onOpenChange, onSavedAndRunnable]);
+  return /* @__PURE__ */ jsx(
+    AlertDialog,
+    {
+      open,
+      onOpenChange: (next) => {
+        if (!next && saving) return;
+        onOpenChange(next);
+      },
+      children: /* @__PURE__ */ jsxs(AlertDialogContent, { "data-testid": "fluidgrids-unsaved-run-dialog", children: [
+        /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+          /* @__PURE__ */ jsx(AlertDialogTitle, { children: tr(
+            "fluidgrids.builder.runGuard.title",
+            "Run without your unsaved changes?"
+          ) }),
+          /* @__PURE__ */ jsxs(AlertDialogDescription, { children: [
+            hasSavedVersion ? tr(
+              "fluidgrids.builder.runGuard.description",
+              "This workflow has changes that are not saved. A run uses the saved version {{version}}, without them.",
+              { version }
+            ) : tr(
+              "fluidgrids.builder.runGuard.descriptionNotSaved",
+              "This workflow has not been saved yet. Save it before you run it."
+            ),
+            " ",
+            runsAfterSave ? null : tr(
+              "fluidgrids.builder.runGuard.newVersionHint",
+              "Saving keeps your changes as a new version and opens it; run that version."
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+          /* @__PURE__ */ jsx(AlertDialogCancel, { disabled: saving, children: tr("fluidgrids.builder.runGuard.cancelButton", "Cancel") }),
+          hasSavedVersion && /* @__PURE__ */ jsx(
+            Button$1,
+            {
+              "data-agent": "confirm",
+              variant: "outline",
+              onClick: onRunSaved,
+              disabled: saving,
+              children: tr(
+                "fluidgrids.builder.runGuard.runSavedButton",
+                "Run saved version"
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button$1,
+            {
+              "data-agent": "confirm",
+              onClick: () => void save(),
+              disabled: saving,
+              children: saving ? tr("fluidgrids.builder.runGuard.savingButton", "Saving\u2026") : runsAfterSave ? tr(
+                "fluidgrids.builder.runGuard.saveAndRunButton",
+                "Save and run"
+              ) : tr(
+                "fluidgrids.builder.runGuard.saveAsNewVersionButton",
+                "Save as new version"
+              )
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
 function buildOperationSeed(type, operationName, existingData) {
   const config = NODE_CONFIGS.find((c) => c.type === type);
   if (!config) return null;
@@ -9266,6 +9609,7 @@ var getNodeMetadata = (value) => {
         console.error("[NodeComponent] Execute step error:", error);
       });
     }, [executeStep, id]);
+    const stepGuard = useRunGuard(handleExecuteStep);
     const missingCredentials = useMemo(() => {
       const visibleAdapters = getVisibleConnectionAdapters(
         String(value?.type ?? ""),
@@ -9345,14 +9689,14 @@ var getNodeMetadata = (value) => {
             executionStatus,
             itemCount,
             isTrigger,
-            isExecuting: isThisNodeExecuting,
+            isExecuting: isThisNodeExecuting || stepGuard.preparing,
             inputHandles,
             outputHandles,
             isConnectable: typeof isConnectable === "boolean" ? isConnectable : void 0,
             onClick: handleCardClick,
             onDoubleClick: handleOpenNdv,
             onSettings: handleOpenNdv,
-            onExecute: handleExecuteStep,
+            onExecute: () => void stepGuard.requestRun(),
             onDelete: readOnly ? void 0 : handleDeleteNode,
             infoButton: /* @__PURE__ */ jsx(NodeInfoButtonWithModal, { metadata: nodeInfoMetadata }),
             disabled: isDisabled,
@@ -9369,7 +9713,8 @@ var getNodeMetadata = (value) => {
             nodeId: id,
             adapters: data?.nodeData?.nodeAdapters
           }
-        )
+        ),
+        stepGuard.dialog
       ] });
     }
     return /* @__PURE__ */ jsxs("div", { children: [
@@ -9384,9 +9729,9 @@ var getNodeMetadata = (value) => {
           itemCount,
           isTrigger,
           accent: roleAccent,
-          isExecuting: isThisNodeExecuting,
+          isExecuting: isThisNodeExecuting || stepGuard.preparing,
           onSettings: handleOpenNdv,
-          onExecute: handleExecuteStep,
+          onExecute: () => void stepGuard.requestRun(),
           onDelete: readOnly ? void 0 : handleDeleteNode,
           infoButton: /* @__PURE__ */ jsx(NodeInfoButtonWithModal, { metadata: nodeInfoMetadata }),
           disabled: isDisabled,
@@ -9441,6 +9786,7 @@ var getNodeMetadata = (value) => {
           ]
         }
       ),
+      stepGuard.dialog,
       /* @__PURE__ */ jsx(
         AdapterConnectors,
         {
@@ -9791,4 +10137,4 @@ function createNodeWithDefaultData(type, data) {
   return Object.assign(createNodeData(type, defaultData), data);
 }
 
-export { AUTOSAVE_DEBOUNCE_MS, AUTOSAVE_RETRY_DELAYS_MS, AVAILABLE_NODES, BILLING_PLANS_PATH, CODE_WORKFLOW_NODE_TYPE, ConnectionFormDialog, ConnectionSelector, DURABLE_FUNCTION_NODE_TYPES, EDIT_SESSION_ID, ExpressionEditor, FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, FluidGridsContext, FluidGridsProvider, NODES, NODES_METADATA, NODE_CONFIGS, NODE_OPERATION_DRAG_DATA_FORMAT, NODE_TYPES, NODE_TYPE_DRAG_DATA_FORMAT, NodePropertyPanel, NodeTypeIcon, PHASE_C_FLAGS_OFF, RUNS_QUOTA_NAME, RUN_CONTROL_NODE_TYPES, STICKY_NOTE_TYPE, WORKFLOWS_QUOTA_NAME, WORKFLOW_TEST_NODE_TYPES, bannerOf, blankWorkflowCreateInput, buildOperationSeed, buildStickyNode, builderPathOf, canAutosave, canRenderOperationPanel, canSignalRun, changedSourceFiles, childRunIdOf, classifyCreateRefusal, clearCodeWorkflowDefinitionCache, codeBuildIdOf, components_default, createConfiguredNode, createThenOpen, declaredOutputFields, declaredSignals, defaultSourcePath, describeOperationError, diagnosticsByPath, editStateOf, emitNodeInstalled, emitRunFailed, emitRunLimitHit, emitRunStarted, emitTemplateUsed, emitUpgradeClicked, emitWorkflowCreated, emitWorkflowLimitHit, emitWorkflowPublished, ensureNodeConfigsLoaded, fieldsFromIO, fieldsFromValue, filterPaletteNodes, findQuotaRefusal, findSaveConflict, forgetSessionForReload, formatParameterValue, getNodeDetail, getNodeMetadata, inAppLeaveTarget, interfaceFields, interfaceHandlers, isDurableFunctionNodeType, isEditableSourcePath, isForbiddenError, isImageIcon, isLocked, isNodeConfigsInitialized, isNodeTrigger, isNodeTypeHiddenFromPalette, isParamVisible, isQuotaExhaustedFailure, isRunControlNodeType, isTriggerOperation, leaseCallQueue, leaveNeedsConfirmation, listCustomBlocks, liveInternalOperations, loadDefinitionJson, mergeStickyNotes, nodeAccent, nodesOf, onNodeTypesUpdate, openRunQuotaUpgradePrompt, parseParameterValue, parseRawSignalPayload, pathToExpression, payloadFromCardValues, phaseAfterAcquire, phaseAfterTakeOver, projectLanguage, readCodeWorkflowState, readDisplayOptions, refetchStoreNodes, registerCustomBlock, registerWorkflowNodeTypes, releasesOnClose, rememberOwnStatusChange, rememberRevision, rememberSessionForReload, resolveInputHandles, resolveNodeOperation, resolveOperationName, resolveOutputHandles, resolvePhaseCFlags, resolveUiSpec, runPreparationOf, runSignalTargets, runTriggerFromMode, saveIndicatorOf, savesInPlace, sessionBeforeReload, shouldReleaseForIdle, signalPayloadCard, snapshotForSave, sourceLanguageOf, stripSubmitActions, structuredParameterType, subscribeWorkflowSaved, synchronizeOperationUpdate, throwIfResultError, tickAction, useAgentDefinitionList, useAgentDefinitions, useCodeWorkflowInterface, useConnection, useConnections, useConnectionsByProvider, useContinuousOptimisationEnabled, useCreateConnection, useDurableFunctionNodesEnabled, useDurableParityEnabled, useEditLeaseLocked, useEditLeaseStore, useFlowStore, useFluidGridsAnalytics, useFluidGridsContext, useFluidGridsFlag, useInitiateOAuth, useInsertNode, useIsValidConnection, useNodeExecution, useNodeRegistryRevision, usePaletteGates, usePhaseCFlags, useProviders, useSaveStatusStore, useSaveWorkflow, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled, workflowFingerprint };
+export { AUTOSAVE_DEBOUNCE_MS, AUTOSAVE_RETRY_DELAYS_MS, AVAILABLE_NODES, BILLING_PLANS_PATH, CODE_WORKFLOW_NODE_TYPE, ConnectionFormDialog, ConnectionSelector, DURABLE_FUNCTION_NODE_TYPES, EDIT_SESSION_ID, ExpressionEditor, FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, FluidGridsContext, FluidGridsProvider, NODES, NODES_METADATA, NODE_CONFIGS, NODE_OPERATION_DRAG_DATA_FORMAT, NODE_TYPES, NODE_TYPE_DRAG_DATA_FORMAT, NodePropertyPanel, NodeTypeIcon, PHASE_C_FLAGS_OFF, RUNS_QUOTA_NAME, RUN_CONTROL_NODE_TYPES, STICKY_NOTE_TYPE, WORKFLOWS_QUOTA_NAME, WORKFLOW_TEST_NODE_TYPES, autosaveAllowedFor, bannerOf, blankWorkflowCreateInput, buildOperationSeed, buildStickyNode, builderPathOf, canAutosave, canRenderOperationPanel, canSignalRun, changedSourceFiles, childRunIdOf, classifyCreateRefusal, clearCodeWorkflowDefinitionCache, codeBuildIdOf, components_default, createConfiguredNode, createThenOpen, declaredOutputFields, declaredSignals, defaultSourcePath, departingSave, describeOperationError, diagnosticsByPath, editStateFor, editingLeaseLocked, emitNodeInstalled, emitRunFailed, emitRunLimitHit, emitRunStarted, emitTemplateUsed, emitUpgradeClicked, emitWorkflowCreated, emitWorkflowLimitHit, emitWorkflowPublished, ensureNodeConfigsLoaded, fieldsFromIO, fieldsFromValue, filterPaletteNodes, findQuotaRefusal, findSaveConflict, forgetSessionForReload, formatParameterValue, getNodeDetail, getNodeMetadata, inAppLeaveTarget, interfaceFields, interfaceHandlers, isDurableFunctionNodeType, isEditableSourcePath, isFlowComplete, isForbiddenError, isImageIcon, isLocked, isNodeConfigsInitialized, isNodeTypeHiddenFromPalette, isParamVisible, isQuotaExhaustedFailure, isRunControlNodeType, isTriggerOperation, leaseCallQueue, leavingLosesChanges, listCustomBlocks, liveInternalOperations, loadDefinitionJson, mergeStickyNotes, nodeAccent, nodesOf, onNodeTypesUpdate, openRunQuotaUpgradePrompt, parseParameterValue, parseRawSignalPayload, pathToExpression, payloadFromCardValues, phaseAfterAcquire, phaseAfterTakeOver, projectLanguage, readCodeWorkflowState, readDisplayOptions, refetchStoreNodes, registerCustomBlock, registerWorkflowNodeTypes, releasesOnClose, rememberOwnStatusChange, rememberRevision, rememberSessionForReload, resolveInputHandles, resolveNodeOperation, resolveOperationName, resolveOutputHandles, resolvePhaseCFlags, resolveUiSpec, runSignalTargets, runTriggerFromMode, saveIndicatorOf, savedEverythingBeforeLeaving, sessionBeforeReload, shouldReleaseForIdle, signalPayloadCard, sourceLanguageOf, stripSubmitActions, structuredParameterType, subscribeWorkflowSaved, synchronizeOperationUpdate, throwIfResultError, tickAction, touchesSavedFields, useAgentDefinitionList, useAgentDefinitions, useCodeWorkflowInterface, useConnection, useConnections, useConnectionsByProvider, useContinuousOptimisationEnabled, useCreateConnection, useDurableFunctionNodesEnabled, useDurableParityEnabled, useEditLeaseLocked, useEditLeaseStore, useFlowStore, useFlowValidator, useFluidGridsAnalytics, useFluidGridsContext, useFluidGridsFlag, useGuardedNavigate, useInitiateOAuth, useInsertNode, useIsValidConnection, useManualSave, useNodeExecution, useNodeRegistryRevision, usePaletteGates, usePhaseCFlags, useProviders, useRunGuard, useSaveStatusStore, useSaveWorkflow, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled, watchLeavingLosesChanges, workflowFingerprint };