@burdenoff/fluidgrids-fe-sdk 2026.1023.2 → 2026.1023.4

package/dist/{ExecutionDetailPage-K3MPJLTL.js → ExecutionDetailPage-FDX242B5.js}

@@ -1,4 +1,4 @@
-export { ExecutionDetailPage } from './chunk-MP7MRTB4.js';
+export { ExecutionDetailPage } from './chunk-VMVY65DC.js';
 import './chunk-XCQROWIZ.js';
 import './chunk-LLPLOWMA.js';
 import './chunk-QBFAJNUC.js';

package/dist/{chunk-YTLPI7UV.js → chunk-EB344COE.js}

@@ -11,9 +11,25 @@ import { Tabs, TabsList, TabsTrigger, TabsContent, Input, Switch, Select, Select
 import { toast } from 'sonner';
 import { jsxs, jsx } from 'react/jsx-runtime';
 
+// src/modules/settings/utils/error-trigger.ts
+var ERROR_TRIGGER_NODE_TYPE = "internal:error-trigger";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function hasErrorTriggerNode(definitionJson) {
+  const definition = asRecord(definitionJson);
+  const dataNodes = asRecord(definition?.data)?.nodes;
+  const nodes = Array.isArray(dataNodes) ? dataNodes : definition?.nodes;
+  return Array.isArray(nodes) && nodes.some((node) => asRecord(node)?.type === ERROR_TRIGGER_NODE_TYPE);
+}
+
+// src/modules/settings/utils/optional-positive-int.ts
+function parseOptionalPositiveInt(value) {
+  if (value.trim() === "") return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? Math.max(1, parsed) : void 0;
+}
 var DEFAULT_EXECUTION_SETTINGS = {
-  timeout: 300,
-  maxParallelism: 5,
   onError: "stop"
 };
 var DEFAULT_SETTINGS = {
@@ -183,6 +199,15 @@ function ExecutionTab({ workflowKey }) {
   }, [workflow?.definitionJson]);
   const [form, setForm] = useState(persistedConfig);
   useEffect(() => setForm(persistedConfig), [persistedConfig]);
+  const selectedErrorWorkflowKey = form.errorWorkflowKey;
+  const { data: errorWorkflowData } = useWorkflowDefinitionQuery({
+    variables: { workflowKey: selectedErrorWorkflowKey ?? "" },
+    skip: !selectedErrorWorkflowKey
+  });
+  const selectedErrorWorkflow = errorWorkflowData?.workflowDefinition;
+  const errorWorkflowLacksTrigger = Boolean(
+    selectedErrorWorkflowKey && selectedErrorWorkflow && !hasErrorTriggerNode(selectedErrorWorkflow.definitionJson)
+  );
   const handleSave = useCallback(async () => {
     if (!workflow?.id) return;
     try {
@@ -267,7 +292,7 @@ function ExecutionTab({ workflowKey }) {
           ),
           description: tr(
             "fluidgrids.settings.execution.defaultTimeoutDescription",
-            "Maximum time this workflow's execution can run (in seconds)"
+            "Stop a run that keeps running longer than this. Time a run spends paused (a Wait over a minute, an approval, a person's answer) does not count. Leave empty for no limit."
           ),
           children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
             /* @__PURE__ */ jsx(
@@ -275,10 +300,18 @@ function ExecutionTab({ workflowKey }) {
               {
                 type: "number",
                 min: 1,
-                value: form.timeout ?? DEFAULT_EXECUTION_SETTINGS.timeout,
+                value: form.timeout ?? "",
+                placeholder: tr(
+                  "fluidgrids.settings.execution.timeoutPlaceholder",
+                  "No timeout"
+                ),
+                "aria-label": tr(
+                  "fluidgrids.settings.execution.defaultTimeoutLabel",
+                  "Timeout"
+                ),
                 onChange: (e) => setForm((f) => ({
                   ...f,
-                  timeout: Math.max(1, parseInt(e.target.value, 10) || 1)
+                  timeout: parseOptionalPositiveInt(e.target.value)
                 })),
                 disabled: loading,
                 className: "w-[100px] text-right"
@@ -295,25 +328,33 @@ function ExecutionTab({ workflowKey }) {
         SettingRow,
         {
           label: tr(
-            "fluidgrids.settings.execution.concurrencyLimitLabel",
-            "Concurrency Limit"
+            "fluidgrids.settings.execution.maxParallelLabel",
+            "Max parallel executions"
           ),
           description: tr(
-            "fluidgrids.settings.execution.concurrencyLimitDescription",
-            "Maximum number of this workflow's executions running simultaneously"
+            "fluidgrids.settings.execution.maxParallelDescription",
+            "How many production runs of this workflow may run at once. Extra runs wait in a queue and start in order; manual test runs are never held back. Leave empty for no limit."
           ),
           children: /* @__PURE__ */ jsx(
             Input,
             {
               type: "number",
               min: 1,
-              value: form.maxParallelism ?? DEFAULT_EXECUTION_SETTINGS.maxParallelism,
+              value: form.maxParallelism ?? "",
+              placeholder: tr(
+                "fluidgrids.settings.execution.maxParallelPlaceholder",
+                "No limit"
+              ),
+              "aria-label": tr(
+                "fluidgrids.settings.execution.maxParallelLabel",
+                "Max parallel executions"
+              ),
               onChange: (e) => setForm((f) => ({
                 ...f,
-                maxParallelism: Math.max(1, parseInt(e.target.value, 10) || 1)
+                maxParallelism: parseOptionalPositiveInt(e.target.value)
               })),
               disabled: loading,
-              className: "w-[80px] text-right"
+              className: "w-[100px] text-right"
             }
           )
         }
@@ -357,34 +398,50 @@ function ExecutionTab({ workflowKey }) {
           ),
           description: tr(
             "fluidgrids.settings.execution.errorWorkflowDescription",
-            "Workflow key to run when this workflow's execution fails (optional)"
+            "Runs when a production run of this workflow fails, starting at that workflow's Error Trigger (optional)"
           ),
-          children: /* @__PURE__ */ jsxs(
-            Select,
-            {
-              value: form.errorWorkflowKey ?? "__none__",
-              onValueChange: (val) => setForm((f) => ({
-                ...f,
-                errorWorkflowKey: val === "__none__" ? void 0 : val
-              })),
-              disabled: loading || otherWorkflowsLoading,
-              children: [
-                /* @__PURE__ */ jsx(SelectTrigger, { className: "w-[220px] bg-background-secondary border-border-secondary", children: /* @__PURE__ */ jsx(
-                  SelectValue,
-                  {
-                    placeholder: tr(
-                      "fluidgrids.settings.execution.errorWorkflowPlaceholder",
+          children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-end gap-1", children: [
+            /* @__PURE__ */ jsxs(
+              Select,
+              {
+                value: form.errorWorkflowKey ?? "__none__",
+                onValueChange: (val) => setForm((f) => ({
+                  ...f,
+                  errorWorkflowKey: val === "__none__" ? void 0 : val
+                })),
+                disabled: loading || otherWorkflowsLoading,
+                children: [
+                  /* @__PURE__ */ jsx(SelectTrigger, { className: "w-[220px] bg-background-secondary border-border-secondary", children: /* @__PURE__ */ jsx(
+                    SelectValue,
+                    {
+                      placeholder: tr(
+                        "fluidgrids.settings.execution.errorWorkflowPlaceholder",
+                        "None"
+                      )
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsxs(SelectContent, { children: [
+                    /* @__PURE__ */ jsx(SelectItem, { value: "__none__", children: tr(
+                      "fluidgrids.settings.execution.errorWorkflowNone",
                       "None"
-                    )
-                  }
-                ) }),
-                /* @__PURE__ */ jsxs(SelectContent, { children: [
-                  /* @__PURE__ */ jsx(SelectItem, { value: "__none__", children: tr("fluidgrids.settings.execution.errorWorkflowNone", "None") }),
-                  errorWorkflowOptions.map((w) => /* @__PURE__ */ jsx(SelectItem, { value: w.workflowKey, children: w.name }, w.workflowKey))
-                ] })
-              ]
-            }
-          )
+                    ) }),
+                    errorWorkflowOptions.map((w) => /* @__PURE__ */ jsx(SelectItem, { value: w.workflowKey, children: w.name }, w.workflowKey))
+                  ] })
+                ]
+              }
+            ),
+            errorWorkflowLacksTrigger && /* @__PURE__ */ jsx(
+              "p",
+              {
+                className: "max-w-[260px] text-right text-xs text-status-warning-text",
+                "data-testid": "error-workflow-no-trigger",
+                children: tr(
+                  "fluidgrids.settings.execution.errorWorkflowNoTrigger",
+                  "This workflow has no Error Trigger, so it will not start. Add an Error Trigger node to it."
+                )
+              }
+            )
+          ] })
         }
       ),
       /* @__PURE__ */ jsx(

package/dist/{chunk-MP7MRTB4.js → chunk-VMVY65DC.js}

@@ -674,7 +674,7 @@ function RunHumanRequests({ requests }) {
       children: [
         /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-sm font-medium text-text-primary", children: [
           /* @__PURE__ */ jsx(Icon, { icon: "mdi:account-clock-outline", width: 18 }),
-          tr("fluidgrids.humanResponse.runHeading", "Waiting on people")
+          requests.some((request) => request.status === "PENDING") ? tr("fluidgrids.humanResponse.runHeading", "Waiting on people") : tr("fluidgrids.humanResponse.runHeadingDone", "People asked")
         ] }),
         requests.map((request) => /* @__PURE__ */ jsx(RunHumanRequestRow, { request }, request.id))
       ]
@@ -723,6 +723,57 @@ function RunHumanRequestRow({ request }) {
     }
   );
 }
+
+// src/modules/executions/utils/run-queue-marker.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRunQueueMarker(context) {
+  if (!isRecord(context)) return null;
+  const marker = context.concurrency;
+  if (!isRecord(marker)) return null;
+  const { queuedAt, checkedAt, limit, active, position } = marker;
+  if (typeof queuedAt !== "string" || typeof checkedAt !== "string" || typeof limit !== "number" || typeof active !== "number" || typeof position !== "number") {
+    return null;
+  }
+  return { queuedAt, checkedAt, limit, active, position };
+}
+function RunQueuedBanner({
+  status,
+  context
+}) {
+  const tr = useTr();
+  if (status !== "PENDING") return null;
+  const marker = readRunQueueMarker(context);
+  if (!marker) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "mb-6 rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "run-queued-banner",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-sm font-medium text-text-primary", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:tray-full", width: 18 }),
+          tr("fluidgrids.executions.queued.heading", "Queued")
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-text-secondary", children: tr(
+          "fluidgrids.executions.queued.body",
+          "This workflow allows {{limit}} runs at a time and {{active}} are in progress. This run is number {{position}} in line and starts automatically when a slot frees up.",
+          {
+            limit: String(marker.limit),
+            active: String(marker.active),
+            position: String(marker.position)
+          }
+        ) }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-text-tertiary", children: tr(
+          "fluidgrids.executions.queued.since",
+          "Queued since {{time}} \xB7 change the limit in the workflow's Settings (Max parallel executions)",
+          { time: new Date(marker.queuedAt).toLocaleString() }
+        ) })
+      ]
+    }
+  );
+}
 function ExecutionDetailPage() {
   const tr = useTr();
   const { runId } = useParams();
@@ -1311,6 +1362,7 @@ function ExecutionDetailPage() {
       ] }),
       /* @__PURE__ */ jsx("p", { className: "text-[var(--color-status-error-text)]", children: execution.errorMessage })
     ] }),
+    /* @__PURE__ */ jsx(RunQueuedBanner, { status: execution.status, context: execution.context }),
     /* @__PURE__ */ jsx(RunHumanRequests, { requests: humanRequests }),
     /* @__PURE__ */ jsx("div", { className: "border-b border-border-secondary mb-6", children: /* @__PURE__ */ jsx("nav", { className: "flex gap-4 -mb-px", children: tabs.map((tab) => /* @__PURE__ */ jsxs(
       "button",

package/dist/executions.js

@@ -1,6 +1,6 @@
 import './chunk-AD3BXTJS.js';
 export { ExecutionsListPage } from './chunk-OKWH2CHF.js';
-export { ExecutionDetailPage } from './chunk-MP7MRTB4.js';
+export { ExecutionDetailPage } from './chunk-VMVY65DC.js';
 import './chunk-XCQROWIZ.js';
 import './chunk-LLPLOWMA.js';
 import './chunk-QBFAJNUC.js';

package/dist/index.js

@@ -5,14 +5,14 @@ export { FirstWorkflowChecklist, FirstWorkflowChecklistView, WorkflowsList } fro
 export { GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, firstWorkflowProgress, isGuidedTourIntent, pickGuidedTour } from './chunk-YGBDZ424.js';
 import './chunk-AD3BXTJS.js';
 export { ExecutionsListPage } from './chunk-OKWH2CHF.js';
-import { usePendingHumanRequests, HumanRequestCard } from './chunk-MP7MRTB4.js';
-export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests } from './chunk-MP7MRTB4.js';
+import { usePendingHumanRequests, HumanRequestCard } from './chunk-VMVY65DC.js';
+export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests } from './chunk-VMVY65DC.js';
 import { TagFilterSelect } from './chunk-XCQROWIZ.js';
 import './chunk-LLPLOWMA.js';
 export { HistoryPage } from './chunk-UKMXGBU3.js';
 export { NodesPage, fetchAllNodesWithManifests, useLazyNodeManifest, useNodeEndpoint, useNodeEndpoints, useNodeManifest } from './chunk-HAYSY6TZ.js';
 export { DataSinkDashboardPage, ErrorAnalyticsPage, InsightsPage } from './chunk-KAOLPDNX.js';
-export { SettingsPage } from './chunk-YTLPI7UV.js';
+export { SettingsPage } from './chunk-EB344COE.js';
 export { FLUIDGRIDS_FLAGS, useDataSinkData, useDataSinks, useFluidGridsFlag, useInsightsData, useLogStreamDestinationActions, useLogStreamDestinations, useRunReplayActions } from './chunk-2QTKDR23.js';
 import './chunk-QBFAJNUC.js';
 import { ThemeProvider, extractTemplateGraph } from './chunk-3BK65TDZ.js';
@@ -81,7 +81,7 @@ var ExecutionsListPage2 = lazy(
   }))
 );
 var ExecutionDetailPage2 = lazy(
-  () => import('./ExecutionDetailPage-K3MPJLTL.js').then((m) => ({
+  () => import('./ExecutionDetailPage-FDX242B5.js').then((m) => ({
     default: m.ExecutionDetailPage
   }))
 );

package/dist/settings.js

@@ -1,4 +1,4 @@
-export { SettingsPage } from './chunk-YTLPI7UV.js';
+export { SettingsPage } from './chunk-EB344COE.js';
 import './chunk-2QTKDR23.js';
 import './chunk-QBFAJNUC.js';
 import './chunk-4VJ3MDOV.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fluidgrids-fe-sdk",
-  "version": "2026.1023.2",
+  "version": "2026.1023.4",
   "description": "FluidGrids Workflow Builder SDK - Embeddable visual workflow automation",
   "type": "module",
   "imports": {