@burdenoff/fluidgrids-fe-sdk 2026.1110.2 → 2026.1110.3

package/dist/{chunk-5V7PMLQN.js → chunk-XIB26SW6.js}

@@ -1,8 +1,8 @@
-import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-PI4AW4T2.js';
+import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, nodeTitle, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-24VHW3ZF.js';
 import { CodeEditorField, normalizeCodeLanguage } from './chunk-KZCNJAMK.js';
 import { readAssertRulesSetting, rowsFromRules, normaliseAssertRules, ruleFromRow, describeAssertRuleProblem, operatorSpec, ASSERT_OPERATORS, emptyAssertRuleRow } from './chunk-JDLQ6QIB.js';
-import { AgentDefinitionSelectField, ConnectionSelector } from './chunk-ZZBZPBO5.js';
-import { isAgentNodeType } from './chunk-WZ3EJVS6.js';
+import { AgentDefinitionSelectField, ConnectionSelector } from './chunk-7XJKLVRJ.js';
+import { useResource, describeSchedule, NativeSelect, StatusPill, FieldError, isAgentNodeType, triggerSchedule, pauseSchedule, unpauseSchedule, backfillSchedule } from './chunk-42PMXPHK.js';
 import { FluidGridsContext, isParamVisible, structuredParameterType, useRunGuard, formatParameterValue, parseParameterValue, useFluidGridsAnalytics, openRunQuotaUpgradePrompt } from './chunk-DDINUPO3.js';
 import { useBuilderReadOnly } from './chunk-SDZEAIIE.js';
 import { useFlowStore } from './chunk-K2X63CR2.js';
@@ -10,20 +10,443 @@ import { getGlobalStoreClient } from './chunk-TYI2XOSI.js';
 import { cn } from './chunk-JL7CASN5.js';
 import { useRunFromNodeEligibilityQuery, PreviewScheduleDocument, WebhookTestListenerDocument, StopWebhookTestListenerDocument, ListenForWebhookTestEventDocument } from './chunk-A6Q4FWB6.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { getFluidGridsClientSafe, getFluidGridsClient } from './chunk-PDODDDHY.js';
+import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
 import { cn as cn$1 } from '@burdenoff/fe-libs/utils';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import * as React from 'react';
-import { useContext, useId, useState, useMemo, useRef, useEffect, useCallback } from 'react';
-import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { useState, useContext, useId, useRef, useCallback, useEffect, useMemo } from 'react';
 import { Icon } from '@iconify/react';
+import { Button } from '@burdenoff/fe-libs/button';
+import { Label, Input, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuItem, Card, Button as Button$1 } from '@burdenoff/fe-libs/ui';
+import { toast } from 'sonner';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { gql } from '@apollo/client';
-import { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuItem, Card, Button } from '@burdenoff/fe-libs/ui';
 import cronstrue from 'cronstrue';
 import { digest } from 'ohash';
 import { X, Plus } from 'lucide-react';
 
+function TabButton({
+  active,
+  onClick,
+  children,
+  testId
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick,
+      "data-testid": testId,
+      className: cn$1(
+        "-mb-px border-b-2 py-2.5 text-sm transition-colors",
+        active ? "border-primary font-medium text-foreground" : "border-transparent text-muted-foreground hover:text-foreground"
+      ),
+      children
+    }
+  );
+}
+var SCHEDULE_NODE_TYPE = "internal:schedule";
+var OVERLAP_POLICIES = [
+  "SKIP" /* Skip */,
+  "BUFFER_ONE" /* BufferOne */,
+  "BUFFER_ALL" /* BufferAll */,
+  "CANCEL_OTHER" /* CancelOther */,
+  "TERMINATE_OTHER" /* TerminateOther */,
+  "ALLOW_ALL" /* AllowAll */
+];
+var MAX_BACKFILL = 1e3;
+function overlapPolicyOf(value) {
+  return OVERLAP_POLICIES.find((policy) => policy === value) ?? null;
+}
+function secondsOf(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+    return value;
+  if (typeof value !== "string") return null;
+  const match = /^(\d+)\s*(s|m|h|d)?$/.exec(value.trim());
+  if (!match) return null;
+  const unit = { s: 1, m: 60, h: 3600, d: 86400 }[match[2] ?? "s"] ?? 1;
+  return Number(match[1]) * unit;
+}
+function SchedulePanel({
+  state,
+  writeField,
+  workflowKey,
+  triggerNodeId,
+  canExecute,
+  canUpdate
+}) {
+  const tr = useTr();
+  const policy = overlapPolicyOf(state.overlapPolicy);
+  const catchup = secondsOf(state.catchupWindow);
+  const limited = typeof state.limitedActions === "number" ? state.limitedActions : null;
+  const describe = useResource(
+    workflowKey ? `schedule:${workflowKey}:${triggerNodeId}` : null,
+    !!workflowKey,
+    () => describeSchedule(workflowKey ?? "", triggerNodeId)
+  );
+  const [note, setNote] = useState("");
+  const [from, setFrom] = useState("");
+  const [to, setTo] = useState("");
+  const [busy, setBusy] = useState(null);
+  const [error, setError] = useState(null);
+  const act = async (name, run) => {
+    setBusy(name);
+    setError(null);
+    try {
+      await run();
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(null);
+    }
+  };
+  const live = describe.data;
+  const backfillFrom = from ? new Date(from) : null;
+  const backfillTo = to ? new Date(to) : null;
+  const backfillValid = !!backfillFrom && !!backfillTo && !Number.isNaN(backfillFrom.getTime()) && !Number.isNaN(backfillTo.getTime()) && backfillFrom < backfillTo && backfillTo.getTime() <= Date.now();
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-5 p-4", "data-testid": "schedule-panel", children: [
+    /* @__PURE__ */ jsxs("section", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsx("h4", { className: "text-sm font-semibold text-foreground", children: tr("fluidgrids.builder.schedule.policy", "Policy") }),
+      /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ jsx(Label, { htmlFor: "schedule-overlap", children: tr(
+          "fluidgrids.builder.schedule.overlap",
+          "When the previous run is still open"
+        ) }),
+        /* @__PURE__ */ jsxs(
+          NativeSelect,
+          {
+            id: "schedule-overlap",
+            value: policy ?? "",
+            disabled: !canUpdate,
+            onChange: (value) => writeField("overlapPolicy", overlapPolicyOf(value) ?? void 0),
+            testId: "schedule-overlap",
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "", children: tr(
+                "fluidgrids.builder.schedule.overlapLegacy",
+                "Start every run (no policy)"
+              ) }),
+              /* @__PURE__ */ jsx("option", { value: "SKIP" /* Skip */, children: tr("fluidgrids.builder.schedule.skip", "Skip the fire") }),
+              /* @__PURE__ */ jsx("option", { value: "BUFFER_ONE" /* BufferOne */, children: tr(
+                "fluidgrids.builder.schedule.bufferOne",
+                "Run once after it ends"
+              ) }),
+              /* @__PURE__ */ jsx("option", { value: "BUFFER_ALL" /* BufferAll */, children: tr(
+                "fluidgrids.builder.schedule.bufferAll",
+                "Run every missed fire after it ends"
+              ) }),
+              /* @__PURE__ */ jsx("option", { value: "CANCEL_OTHER" /* CancelOther */, children: tr(
+                "fluidgrids.builder.schedule.cancelOther",
+                "Cancel it and start"
+              ) }),
+              /* @__PURE__ */ jsx("option", { value: "TERMINATE_OTHER" /* TerminateOther */, children: tr(
+                "fluidgrids.builder.schedule.terminateOther",
+                "Terminate it and start"
+              ) }),
+              /* @__PURE__ */ jsx("option", { value: "ALLOW_ALL" /* AllowAll */, children: tr("fluidgrids.builder.schedule.allowAll", "Start anyway") })
+            ]
+          }
+        ),
+        !policy && canUpdate && /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            variant: "link",
+            className: "h-auto p-0 text-xs",
+            onClick: () => writeField("overlapPolicy", "SKIP" /* Skip */),
+            "data-testid": "schedule-use-policy",
+            children: tr(
+              "fluidgrids.builder.schedule.usePolicy",
+              "Use a policy (skip while a run is open)"
+            )
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+        /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "schedule-catchup", children: tr(
+            "fluidgrids.builder.schedule.catchup",
+            "Catch-up window (seconds)"
+          ) }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "schedule-catchup",
+              inputMode: "numeric",
+              disabled: !canUpdate,
+              value: catchup === null ? "" : String(catchup),
+              onChange: (event) => {
+                const value = event.target.value.trim();
+                writeField(
+                  "catchupWindow",
+                  value === "" ? void 0 : /^\d+$/.test(value) ? Math.min(Number(value), 604800) : state.catchupWindow
+                );
+              },
+              "data-testid": "schedule-catchup"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "schedule-limited", children: tr(
+            "fluidgrids.builder.schedule.limited",
+            "Stop after this many runs (optional)"
+          ) }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "schedule-limited",
+              inputMode: "numeric",
+              disabled: !canUpdate,
+              value: limited === null ? "" : String(limited),
+              onChange: (event) => {
+                const value = event.target.value.trim();
+                writeField(
+                  "limitedActions",
+                  value === "" ? void 0 : /^\d+$/.test(value) ? Number(value) : state.limitedActions
+                );
+              },
+              "data-testid": "schedule-limited"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm text-foreground", children: [
+        tr(
+          "fluidgrids.builder.schedule.pauseOnFailure",
+          "Pause the schedule when a run it started fails"
+        ),
+        /* @__PURE__ */ jsx(
+          Switch,
+          {
+            checked: state.pauseOnFailure === true,
+            disabled: !canUpdate,
+            onCheckedChange: (checked) => writeField("pauseOnFailure", checked ? true : void 0),
+            "data-testid": "schedule-pause-on-failure"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: tr(
+        "fluidgrids.builder.schedule.saveHint",
+        "Policy changes apply when the workflow is saved and activated."
+      ) })
+    ] }),
+    !workflowKey ? /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: tr(
+      "fluidgrids.builder.schedule.unsaved",
+      "Save the workflow to see and control its schedule."
+    ) }) : /* @__PURE__ */ jsxs("section", { className: "space-y-3", "data-testid": "schedule-live", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+        /* @__PURE__ */ jsx("h4", { className: "text-sm font-semibold text-foreground", children: tr("fluidgrids.builder.schedule.live", "Schedule") }),
+        live && /* @__PURE__ */ jsx(
+          StatusPill,
+          {
+            tone: live.state.paused ? "warning" : "success",
+            testId: "schedule-state",
+            children: live.state.paused ? tr("fluidgrids.builder.schedule.paused", "Paused") : tr("fluidgrids.builder.schedule.active", "Active")
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            variant: "ghost",
+            className: "ml-auto",
+            onClick: () => void describe.refetch(),
+            children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:refresh", width: 14 })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(
+        FieldError,
+        {
+          message: describe.error,
+          testId: "schedule-describe-error"
+        }
+      ),
+      live?.state.paused && live.state.note && /* @__PURE__ */ jsx("p", { className: "text-sm text-foreground", "data-testid": "schedule-note", children: live.state.note }),
+      live && /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("p", { className: "mb-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground", children: tr("fluidgrids.builder.schedule.next", "Next fire times") }),
+          /* @__PURE__ */ jsxs(
+            "ul",
+            {
+              className: "space-y-0.5 font-mono text-xs text-foreground",
+              "data-testid": "schedule-next",
+              children: [
+                live.nextFireTimes.slice(0, 5).map((time) => /* @__PURE__ */ jsx("li", { children: new Date(time).toLocaleString() }, time)),
+                live.nextFireTimes.length === 0 && /* @__PURE__ */ jsx("li", { children: "\u2014" })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("p", { className: "mb-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground", children: tr("fluidgrids.builder.schedule.recent", "Recent actions") }),
+          /* @__PURE__ */ jsxs(
+            "ul",
+            {
+              className: "space-y-0.5 text-xs text-foreground",
+              "data-testid": "schedule-recent",
+              children: [
+                live.recentActions.slice(0, 5).map((tick) => /* @__PURE__ */ jsxs("li", { children: [
+                  /* @__PURE__ */ jsx("span", { className: "font-mono", children: new Date(tick.dueAt).toLocaleString() }),
+                  " ",
+                  "\xB7 ",
+                  tick.kind,
+                  " \xB7 ",
+                  tick.outcome
+                ] }, tick.id)),
+                live.recentActions.length === 0 && /* @__PURE__ */ jsx("li", { children: "\u2014" })
+              ]
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", children: [
+        canExecute && /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            disabled: busy !== null,
+            onClick: () => void act("trigger", async () => {
+              const result = await triggerSchedule({
+                workflowKey,
+                triggerNodeId
+              });
+              toast.success(
+                result.runId ? tr(
+                  "fluidgrids.builder.schedule.triggered",
+                  "Run started"
+                ) : tr(
+                  "fluidgrids.builder.schedule.triggeredOutcome",
+                  "Tick recorded: {{outcome}}",
+                  { outcome: result.tick.outcome }
+                )
+              );
+              await describe.refetch();
+            }),
+            "data-testid": "schedule-trigger",
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:play", className: "mr-1", width: 14 }),
+              tr("fluidgrids.builder.schedule.trigger", "Trigger now")
+            ]
+          }
+        ),
+        canUpdate && live && !live.state.paused && /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            disabled: busy !== null,
+            onClick: () => void act("pause", async () => {
+              describe.set(
+                await pauseSchedule({ workflowKey, triggerNodeId, note })
+              );
+              setNote("");
+            }),
+            "data-testid": "schedule-pause",
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:pause", className: "mr-1", width: 14 }),
+              tr("fluidgrids.builder.schedule.pause", "Pause")
+            ]
+          }
+        ),
+        canUpdate && live?.state.paused && /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            disabled: busy !== null,
+            onClick: () => void act(
+              "unpause",
+              async () => describe.set(
+                await unpauseSchedule({ workflowKey, triggerNodeId })
+              )
+            ),
+            "data-testid": "schedule-unpause",
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:play-pause", className: "mr-1", width: 14 }),
+              tr("fluidgrids.builder.schedule.unpause", "Unpause")
+            ]
+          }
+        )
+      ] }),
+      canUpdate && live && !live.state.paused && /* @__PURE__ */ jsx(
+        Input,
+        {
+          value: note,
+          maxLength: 1e3,
+          placeholder: tr(
+            "fluidgrids.builder.schedule.notePlaceholder",
+            "Note for the pause (optional)"
+          ),
+          onChange: (event) => setNote(event.target.value),
+          "data-testid": "schedule-pause-note"
+        }
+      ),
+      canExecute && /* @__PURE__ */ jsxs("div", { className: "space-y-2 rounded-md border border-border p-3", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-xs font-semibold uppercase tracking-wide text-muted-foreground", children: tr("fluidgrids.builder.schedule.backfill", "Backfill") }),
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-2 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              type: "datetime-local",
+              value: from,
+              onChange: (event) => setFrom(event.target.value),
+              "aria-label": tr("fluidgrids.builder.schedule.from", "From"),
+              "data-testid": "schedule-backfill-from"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              type: "datetime-local",
+              value: to,
+              onChange: (event) => setTo(event.target.value),
+              "aria-label": tr("fluidgrids.builder.schedule.to", "To"),
+              "data-testid": "schedule-backfill-to"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            disabled: !backfillValid || busy !== null,
+            onClick: () => void act("backfill", async () => {
+              if (!backfillFrom || !backfillTo) return;
+              const result = await backfillSchedule({
+                workflowKey,
+                triggerNodeId,
+                from: backfillFrom.toISOString(),
+                to: backfillTo.toISOString()
+              });
+              toast.success(
+                tr(
+                  "fluidgrids.builder.schedule.backfilled",
+                  "{{queued}} of {{fireTimes}} fire times queued",
+                  { queued: result.queued, fireTimes: result.fireTimes }
+                )
+              );
+              await describe.refetch();
+            }),
+            "data-testid": "schedule-backfill",
+            children: tr(
+              "fluidgrids.builder.schedule.runBackfill",
+              "Run the fire times in this range"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: tr(
+          "fluidgrids.builder.schedule.backfillHint",
+          "At most {{max}} past fire times; each started run counts toward the monthly runs.",
+          { max: MAX_BACKFILL }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsx(FieldError, { message: error, testId: "schedule-error" })
+    ] })
+  ] });
+}
 function ReadOnlyFieldset({
   className,
   children
@@ -4476,7 +4899,7 @@ function ChannelAuthButton({
   const tr = useTr();
   const providerKey = PLATFORM_TO_PROVIDER_KEY[channel.platform] || channel.platform.toLowerCase();
   return /* @__PURE__ */ jsxs(
-    Button,
+    Button$1,
     {
       type: "button",
       variant: "outline",
@@ -4562,7 +4985,7 @@ function ChannelLinkAction({
   const linking = state.kind === "linking";
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsxs(
-      Button,
+      Button$1,
       {
         type: "button",
         variant: "outline",
@@ -4884,7 +5307,7 @@ function NodeParamsForm({
       const highlight = dragField === p.name;
       const controlId = `${formId}-param-${p.name}`;
       const nativeControl = mode !== "expression" && !isCodeParam && !(structuredType && !optionList) && !p.loadOptions && !isChannelPicker && p.type !== PLATFORM_EVENT_MODULE_FIELD && p.type !== PLATFORM_EVENT_RECORD_TYPE_FIELD && p.type !== TIMECAMPUS_TIME_TRIGGER_FIELD;
-      const inputCx = cn$1(
+      const inputCx2 = cn$1(
         "w-full rounded-md border bg-background px-2.5 py-1.5 text-sm outline-none transition-colors disabled:opacity-50",
         highlight ? "border-primary ring-1 ring-primary" : "border-input focus:border-primary"
       );
@@ -4982,7 +5405,7 @@ function NodeParamsForm({
                 schema: p.schema ?? p.type,
                 value: fixedValue,
                 onChange: (value) => writeFixed(p.name, value),
-                className: cn$1(inputCx, "font-mono"),
+                className: cn$1(inputCx2, "font-mono"),
                 testId: `${testIdPrefix}-param-${p.name}`
               },
               `${config.node?.id}:${config.currentOp?.name}:${p.name}`
@@ -5013,7 +5436,7 @@ function NodeParamsForm({
                 connectionId: loadOptionsConnectionId,
                 value: fixedValue,
                 onChange: (v) => writeFixed(p.name, v),
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : isChannelPicker ? /* @__PURE__ */ jsx(
@@ -5030,7 +5453,7 @@ function NodeParamsForm({
                 ),
                 nodeId: config.node?.id,
                 label: p.label ?? p.name,
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : p.type === "boolean" ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
@@ -5089,7 +5512,7 @@ function NodeParamsForm({
                   if (typeField && previous !== next)
                     writeFixed(typeField.name, void 0);
                 },
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : p.type === PLATFORM_EVENT_RECORD_TYPE_FIELD ? /* @__PURE__ */ jsx(
@@ -5107,7 +5530,7 @@ function NodeParamsForm({
                 required: p.required,
                 label: p.label,
                 onChange: (next) => writeFixed(p.name, next || void 0),
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : p.type === TIMECAMPUS_TIME_TRIGGER_FIELD ? /* @__PURE__ */ jsx(
@@ -5116,7 +5539,7 @@ function NodeParamsForm({
                 value: fixedValue,
                 label: p.label,
                 onChange: (next) => writeFixed(p.name, next || void 0),
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : p.type === "timezone" ? /* @__PURE__ */ jsx(
@@ -5124,7 +5547,7 @@ function NodeParamsForm({
               {
                 value: typeof fixedValue === "string" ? fixedValue : "",
                 onChange: (zone) => writeFixed(p.name, zone),
-                className: inputCx,
+                className: inputCx2,
                 testId: `${testIdPrefix}-param-${p.name}`
               }
             ) : p.type === "multiOptions" && p.options && p.options.length > 0 ? /* @__PURE__ */ jsx(
@@ -5179,7 +5602,7 @@ function NodeParamsForm({
                 id: controlId,
                 "data-testid": `${testIdPrefix}-param-${p.name}`,
                 className: cn$1(
-                  inputCx,
+                  inputCx2,
                   "scheme-normal dark:scheme-dark [&_option]:bg-bg-surface [&_option]:text-text-primary"
                 ),
                 children: [
@@ -5204,7 +5627,7 @@ function NodeParamsForm({
                 onChange: (e) => writeFixed(p.name, coerceNumber(p.type, e.target.value)),
                 id: controlId,
                 "data-testid": `${testIdPrefix}-param-${p.name}`,
-                className: inputCx
+                className: inputCx2
               }
             ) : p.type === "string" && p.isMultiline && !p.secret ? /* @__PURE__ */ jsx(
               "textarea",
@@ -5219,7 +5642,7 @@ function NodeParamsForm({
                 "aria-label": p.label ?? p.name,
                 id: controlId,
                 "data-testid": `${testIdPrefix}-param-${p.name}`,
-                className: cn$1(inputCx, "min-h-24 resize-y")
+                className: cn$1(inputCx2, "min-h-24 resize-y")
               }
             ) : /* @__PURE__ */ jsx(
               "input",
@@ -5236,7 +5659,7 @@ function NodeParamsForm({
                 "aria-label": p.label ?? p.name,
                 id: controlId,
                 "data-testid": `${testIdPrefix}-param-${p.name}`,
-                className: inputCx
+                className: inputCx2
               }
             ),
             p.description && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: p.description })
@@ -5247,6 +5670,677 @@ function NodeParamsForm({
     })
   ] });
 }
+var RUNNER_FIELDS = gql`
+  fragment SandboxRunnerFields on SandboxRunner {
+    id
+    name
+    status
+    hostname
+    os
+    arch
+    driver
+    version
+    capacity
+    privateNetwork {
+      target
+      ports
+      nodes
+    }
+    tokenPrefix
+    lastSeenAt
+    connectedAt
+    createdBy
+    createdAt
+  }
+`;
+var LIST_RUNNERS = gql`
+  ${RUNNER_FIELDS}
+  query SandboxRunners {
+    sandboxRunners(context: {}) {
+      ...SandboxRunnerFields
+    }
+  }
+`;
+var CREATE_RUNNER = gql`
+  ${RUNNER_FIELDS}
+  mutation CreateSandboxRunner($name: String!) {
+    createSandboxRunner(input: { name: $name, context: {} }) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+var ROTATE_RUNNER_TOKEN = gql`
+  ${RUNNER_FIELDS}
+  mutation RotateSandboxRunnerToken($id: ID!) {
+    rotateSandboxRunnerToken(id: $id, context: {}) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+var DELETE_RUNNER = gql`
+  mutation DeleteSandboxRunner($id: ID!) {
+    deleteSandboxRunner(id: $id, context: {})
+  }
+`;
+var RUNNER_INSTALL_SCRIPT_URL = "https://www.fluidgrids.ai/downloads/runner/install.sh";
+function runnerInstallCommand(bridgeUrl) {
+  const base = `curl -fsSL ${RUNNER_INSTALL_SCRIPT_URL} | sh`;
+  return bridgeUrl && bridgeUrl !== DEFAULT_BRIDGE_URL ? `${base} -s -- --url ${bridgeUrl}` : base;
+}
+var DEFAULT_BRIDGE_URL = "wss://graphqlworkspaces.burdenoff.com/runner-bridge";
+function useRunners(options) {
+  const [runners, setRunners] = useState([]);
+  const [loading, setLoading] = useState(!options?.skip);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  const fetchRunners = useCallback(async () => {
+    if (options?.skip) return;
+    try {
+      const result = await getFluidGridsClient().query({ query: LIST_RUNNERS, fetchPolicy: "network-only" });
+      if (!mounted.current) return;
+      setRunners(result.data?.sandboxRunners ?? []);
+      setError(null);
+    } catch (err) {
+      if (mounted.current) setError(err);
+    } finally {
+      if (mounted.current) setLoading(false);
+    }
+  }, [options?.skip]);
+  useEffect(() => {
+    mounted.current = true;
+    void fetchRunners();
+    const pollMs = options?.pollMs ?? 1e4;
+    const timer = pollMs > 0 ? setInterval(fetchRunners, pollMs) : null;
+    return () => {
+      mounted.current = false;
+      if (timer) clearInterval(timer);
+    };
+  }, [fetchRunners, options?.pollMs]);
+  return { runners, loading, error, refetch: fetchRunners };
+}
+function useRunnerActions() {
+  const [busy, setBusy] = useState(false);
+  const run = useCallback(async (fn) => {
+    setBusy(true);
+    try {
+      return await fn();
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const createRunner = useCallback(
+    (name) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: CREATE_RUNNER, variables: { name } })
+      );
+      if (!result.data?.createSandboxRunner)
+        throw new Error("No runner returned");
+      return result.data.createSandboxRunner;
+    }),
+    [run]
+  );
+  const rotateToken = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: ROTATE_RUNNER_TOKEN, variables: { id } })
+      );
+      if (!result.data?.rotateSandboxRunnerToken)
+        throw new Error("No runner returned");
+      return result.data.rotateSandboxRunnerToken;
+    }),
+    [run]
+  );
+  const deleteRunner = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: DELETE_RUNNER,
+          variables: { id }
+        })
+      );
+      return result.data?.deleteSandboxRunner === true;
+    }),
+    [run]
+  );
+  return { createRunner, rotateToken, deleteRunner, busy };
+}
+var STYLES = {
+  ONLINE: "border-status-success-border bg-status-success-bg-subtle text-status-success-text",
+  OFFLINE: "border-border-default bg-bg-sunken text-text-muted",
+  NEVER_CONNECTED: "border-status-warning-border bg-status-warning-bg-subtle text-status-warning-text"
+};
+function RunnerStatusPill({
+  status,
+  className
+}) {
+  const tr = useTr();
+  const label = status === "ONLINE" ? tr("fluidgrids.runners.online", "Online") : status === "OFFLINE" ? tr("fluidgrids.runners.offline", "Offline") : tr("fluidgrids.runners.neverConnected", "Not connected yet");
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn$1(
+        "inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium",
+        STYLES[status],
+        className
+      ),
+      "data-testid": "runner-status",
+      "data-status": status,
+      children: label
+    }
+  );
+}
+var CLOUD = "__fluidgrids_cloud__";
+function RunOnSection({
+  value,
+  onChange,
+  sectionLabelClassName
+}) {
+  const tr = useTr();
+  const { runners, loading } = useRunners({ pollMs: 15e3 });
+  const selected = value ? runners.find((r) => r.id === value.runnerId) : void 0;
+  return /* @__PURE__ */ jsxs("section", { className: "space-y-2", "data-testid": "ndv-settings-run-on", children: [
+    /* @__PURE__ */ jsx("div", { className: sectionLabelClassName, children: tr("fluidgrids.builder.nodeSettings.runOn", "Run on") }),
+    /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: value?.runnerId ?? CLOUD,
+        onValueChange: (v) => onChange(v === CLOUD ? null : { kind: "runner", runnerId: v }),
+        children: [
+          /* @__PURE__ */ jsx(
+            SelectTrigger,
+            {
+              className: "w-full",
+              "data-testid": "ndv-settings-run-on-select",
+              children: /* @__PURE__ */ jsx(SelectValue, {})
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            SelectContent,
+            {
+              style: { zIndex: 1100 },
+              "data-testid": "ndv-settings-run-on-options",
+              children: [
+                /* @__PURE__ */ jsx(SelectItem, { value: CLOUD, "data-testid": "run-on-cloud", children: tr(
+                  "fluidgrids.builder.nodeSettings.runOnCloud",
+                  "FluidGrids Cloud (default)"
+                ) }),
+                runners.map((runner) => /* @__PURE__ */ jsxs(
+                  SelectItem,
+                  {
+                    value: runner.id,
+                    "data-testid": "run-on-runner-option",
+                    children: [
+                      runner.name,
+                      runner.status !== "ONLINE" ? ` (${runner.status === "OFFLINE" ? tr("fluidgrids.runners.offline", "Offline") : tr("fluidgrids.runners.neverConnected", "Not connected yet")})` : ""
+                    ]
+                  },
+                  runner.id
+                )),
+                value && !loading && !selected && /* @__PURE__ */ jsx(SelectItem, { value: value.runnerId, disabled: true, children: tr(
+                  "fluidgrids.builder.nodeSettings.runOnMissing",
+                  "Removed runner"
+                ) })
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    value ? /* @__PURE__ */ jsxs("div", { className: "space-y-1 text-xs text-text-secondary", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-2", children: [
+        selected && /* @__PURE__ */ jsx(RunnerStatusPill, { status: selected.status }),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.runOnRunnerHint",
+          "This node runs on your runner, in a local sandbox. If the runner is offline the node fails \u2014 it never falls back to FluidGrids Cloud. The node's input and the credentials it uses are sent to that machine."
+        ) })
+      ] }),
+      selected && /* @__PURE__ */ jsx("p", { "data-testid": "run-on-private-network", children: (selected.privateNetwork ?? []).length === 0 ? tr(
+        "fluidgrids.builder.nodeSettings.runOnPublicOnly",
+        "On this runner, nodes reach the public internet only. Private destinations are opened on the runner machine (fluidgrids-runner network allow)."
+      ) : tr(
+        "fluidgrids.builder.nodeSettings.runOnPrivateNetwork",
+        "This runner opens {{count}} private destination(s) \u2014 see Runners for which nodes may use them.",
+        { count: (selected.privateNetwork ?? []).length }
+      ) })
+    ] }) : /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: runners.length === 0 && !loading ? tr(
+      "fluidgrids.builder.nodeSettings.runOnNoRunners",
+      "Runs in FluidGrids Cloud. Add a runner under Workflows \u2192 Runners to run nodes on your own machine."
+    ) : tr(
+      "fluidgrids.builder.nodeSettings.runOnCloudHint",
+      "Runs in FluidGrids Cloud."
+    ) })
+  ] });
+}
+var SECTION_LABEL4 = "text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground";
+var inputCx = "w-full rounded-md border border-input bg-background px-2.5 py-1.5 text-sm outline-none transition-colors focus:border-primary disabled:opacity-50";
+function msToSeconds(ms, fallbackMs) {
+  return Math.round((ms ?? fallbackMs) / 1e3 * 10) / 10;
+}
+function secondsInputToMs(raw, minMs) {
+  const seconds = parseFloat(raw);
+  if (Number.isNaN(seconds)) return minMs;
+  return Math.max(minMs, Math.round(seconds * 1e3));
+}
+function NodeSettingsPanel({
+  config
+}) {
+  const tr = useTr();
+  const {
+    nodes,
+    node,
+    errorConfig,
+    writeErrorConfig,
+    notes,
+    writeNotes,
+    alwaysOutputData,
+    executeOnce,
+    runOn,
+    writeExecutionSettings
+  } = config;
+  const onError = errorConfig?.onError ?? "stop";
+  const retryEnabled = (errorConfig?.retryConfig?.maxRetries ?? 0) > 0;
+  const timeoutEnabled = !!errorConfig?.timeout?.duration;
+  const branchTargets = nodes.filter((n) => n.id !== node?.id);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-6", "data-testid": "ndv-settings-panel", children: [
+    /* @__PURE__ */ jsx(
+      RunOnSection,
+      {
+        value: runOn,
+        onChange: (next) => writeExecutionSettings({ runOn: next }),
+        sectionLabelClassName: SECTION_LABEL4
+      }
+    ),
+    /* @__PURE__ */ jsxs("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL4, children: tr("fluidgrids.builder.nodeSettings.retrySection", "Retry on Fail") }),
+      /* @__PURE__ */ jsxs("label", { className: "flex w-fit cursor-pointer items-center gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: retryEnabled,
+            onChange: (e) => writeErrorConfig({
+              retryConfig: e.target.checked ? {
+                maxRetries: errorConfig?.retryConfig?.maxRetries || 3,
+                retryDelay: errorConfig?.retryConfig?.retryDelay || 1e3,
+                backoffMultiplier: errorConfig?.retryConfig?.backoffMultiplier ?? 2,
+                maxDelay: errorConfig?.retryConfig?.maxDelay ?? 3e4
+              } : void 0
+            }),
+            "data-testid": "ndv-settings-retry-enabled",
+            className: "size-4"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.retryEnabledLabel",
+          "Retry this node on failure"
+        ) })
+      ] }),
+      retryEnabled && /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-3 pl-6", children: [
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.maxRetries",
+              "Max tries"
+            ),
+            children: /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 1,
+                max: 20,
+                value: errorConfig?.retryConfig?.maxRetries ?? 3,
+                onChange: (e) => writeErrorConfig({
+                  retryConfig: {
+                    ...errorConfig?.retryConfig ?? {
+                      retryDelay: 1e3,
+                      maxRetries: 3
+                    },
+                    maxRetries: Math.max(
+                      1,
+                      parseInt(e.target.value, 10) || 1
+                    )
+                  }
+                }),
+                "data-testid": "ndv-settings-max-retries",
+                className: inputCx
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.retryDelay",
+              "Wait (seconds)"
+            ),
+            children: /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 0,
+                step: 0.1,
+                value: msToSeconds(errorConfig?.retryConfig?.retryDelay, 1e3),
+                onChange: (e) => writeErrorConfig({
+                  retryConfig: {
+                    ...errorConfig?.retryConfig ?? {
+                      maxRetries: 3,
+                      retryDelay: 1e3
+                    },
+                    retryDelay: secondsInputToMs(e.target.value, 0)
+                  }
+                }),
+                "data-testid": "ndv-settings-retry-delay",
+                className: inputCx
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.backoffMultiplier",
+              "Backoff \xD7"
+            ),
+            children: /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 1,
+                step: 0.5,
+                value: errorConfig?.retryConfig?.backoffMultiplier ?? 2,
+                onChange: (e) => writeErrorConfig({
+                  retryConfig: {
+                    ...errorConfig?.retryConfig ?? {
+                      maxRetries: 3,
+                      retryDelay: 1e3
+                    },
+                    backoffMultiplier: parseFloat(e.target.value) || 1
+                  }
+                }),
+                "data-testid": "ndv-settings-backoff-multiplier",
+                className: inputCx
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.maxDelay",
+              "Max wait (seconds)"
+            ),
+            children: /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 0,
+                step: 1,
+                value: msToSeconds(errorConfig?.retryConfig?.maxDelay, 3e4),
+                onChange: (e) => writeErrorConfig({
+                  retryConfig: {
+                    ...errorConfig?.retryConfig ?? {
+                      maxRetries: 3,
+                      retryDelay: 1e3
+                    },
+                    maxDelay: secondsInputToMs(e.target.value, 0)
+                  }
+                }),
+                "data-testid": "ndv-settings-max-delay",
+                className: inputCx
+              }
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL4, children: tr("fluidgrids.builder.nodeSettings.onErrorSection", "On Error") }),
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          value: onError,
+          onChange: (e) => writeErrorConfig({
+            onError: e.target.value,
+            errorBranchId: e.target.value === "branch" ? errorConfig?.errorBranchId : void 0
+          }),
+          "data-testid": "ndv-settings-on-error",
+          className: cn$1(inputCx, "max-w-xs"),
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "stop", children: tr(
+              "fluidgrids.builder.nodeSettings.onErrorStop",
+              "Stop workflow (default)"
+            ) }),
+            /* @__PURE__ */ jsx("option", { value: "continue", children: tr(
+              "fluidgrids.builder.nodeSettings.onErrorContinue",
+              "Continue on fail"
+            ) }),
+            /* @__PURE__ */ jsx("option", { value: "branch", children: tr(
+              "fluidgrids.builder.nodeSettings.onErrorBranch",
+              "Route to error branch"
+            ) })
+          ]
+        }
+      ),
+      onError === "branch" && /* @__PURE__ */ jsx("div", { className: "pl-2", children: /* @__PURE__ */ jsx(
+        Field,
+        {
+          label: tr(
+            "fluidgrids.builder.nodeSettings.errorBranchTarget",
+            "Error branch target"
+          ),
+          children: /* @__PURE__ */ jsxs(
+            "select",
+            {
+              value: errorConfig?.errorBranchId ?? "",
+              onChange: (e) => writeErrorConfig({
+                errorBranchId: e.target.value || void 0
+              }),
+              "data-testid": "ndv-settings-error-branch-id",
+              className: cn$1(inputCx, "max-w-xs"),
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: tr(
+                  "fluidgrids.builder.nodeSettings.selectNode",
+                  "Select a node\u2026"
+                ) }),
+                branchTargets.map((n) => /* @__PURE__ */ jsx("option", { value: n.id, children: nodeTitle(n) }, n.id))
+              ]
+            }
+          )
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL4, children: tr("fluidgrids.builder.nodeSettings.timeoutSection", "Timeout") }),
+      /* @__PURE__ */ jsxs("label", { className: "flex w-fit cursor-pointer items-center gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: timeoutEnabled,
+            onChange: (e) => writeErrorConfig({
+              timeout: e.target.checked ? { duration: errorConfig?.timeout?.duration || 3e4 } : void 0
+            }),
+            "data-testid": "ndv-settings-timeout-enabled",
+            className: "size-4"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.timeoutEnabledLabel",
+          "Abort this node if it runs too long"
+        ) })
+      ] }),
+      timeoutEnabled && /* @__PURE__ */ jsxs("div", { className: "space-y-3 pl-6", children: [
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.timeoutDuration",
+              "Timeout (seconds)"
+            ),
+            children: /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 0.1,
+                step: 0.5,
+                value: msToSeconds(errorConfig?.timeout?.duration, 3e4),
+                onChange: (e) => writeErrorConfig({
+                  timeout: {
+                    ...errorConfig?.timeout ?? { duration: 3e4 },
+                    duration: secondsInputToMs(e.target.value, 100)
+                  }
+                }),
+                "data-testid": "ndv-settings-timeout-duration",
+                className: cn$1(inputCx, "max-w-[10rem]")
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.onTimeout",
+              "On timeout"
+            ),
+            children: /* @__PURE__ */ jsxs(
+              "select",
+              {
+                value: errorConfig?.timeout?.onTimeout ?? "stop",
+                onChange: (e) => writeErrorConfig({
+                  timeout: {
+                    ...errorConfig?.timeout ?? { duration: 3e4 },
+                    onTimeout: e.target.value,
+                    timeoutBranchId: e.target.value === "branch" ? errorConfig?.timeout?.timeoutBranchId : void 0
+                  }
+                }),
+                "data-testid": "ndv-settings-on-timeout",
+                className: cn$1(inputCx, "max-w-xs"),
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "stop", children: tr(
+                    "fluidgrids.builder.nodeSettings.onTimeoutStop",
+                    "Use Retry/On Error settings above"
+                  ) }),
+                  /* @__PURE__ */ jsx("option", { value: "continue", children: tr(
+                    "fluidgrids.builder.nodeSettings.onTimeoutContinue",
+                    "Continue on timeout"
+                  ) }),
+                  /* @__PURE__ */ jsx("option", { value: "branch", children: tr(
+                    "fluidgrids.builder.nodeSettings.onTimeoutBranch",
+                    "Route to a specific branch"
+                  ) })
+                ]
+              }
+            )
+          }
+        ),
+        errorConfig?.timeout?.onTimeout === "branch" && /* @__PURE__ */ jsx(
+          Field,
+          {
+            label: tr(
+              "fluidgrids.builder.nodeSettings.timeoutBranchTarget",
+              "Timeout branch target"
+            ),
+            children: /* @__PURE__ */ jsxs(
+              "select",
+              {
+                value: errorConfig?.timeout?.timeoutBranchId ?? "",
+                onChange: (e) => writeErrorConfig({
+                  timeout: {
+                    ...errorConfig?.timeout ?? { duration: 3e4 },
+                    timeoutBranchId: e.target.value || void 0
+                  }
+                }),
+                "data-testid": "ndv-settings-timeout-branch-id",
+                className: cn$1(inputCx, "max-w-xs"),
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "", children: tr(
+                    "fluidgrids.builder.nodeSettings.selectNode",
+                    "Select a node\u2026"
+                  ) }),
+                  branchTargets.map((n) => /* @__PURE__ */ jsx("option", { value: n.id, children: nodeTitle(n) }, n.id))
+                ]
+              }
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL4, children: tr("fluidgrids.builder.nodeSettings.otherSection", "Other") }),
+      /* @__PURE__ */ jsxs("label", { className: "flex w-fit cursor-pointer items-center gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: alwaysOutputData,
+            onChange: (e) => writeExecutionSettings({ alwaysOutputData: e.target.checked }),
+            "data-testid": "ndv-settings-always-output-data",
+            className: "size-4"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.alwaysOutputDataLabel",
+          "Always output data"
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "flex w-fit cursor-pointer items-center gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: executeOnce,
+            onChange: (e) => writeExecutionSettings({ executeOnce: e.target.checked }),
+            "data-testid": "ndv-settings-execute-once",
+            className: "size-4"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.executeOnceLabel",
+          "Execute once"
+        ) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL4, children: tr("fluidgrids.builder.nodeSettings.notesSection", "Notes") }),
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          value: notes,
+          onChange: (e) => writeNotes(e.target.value),
+          rows: 4,
+          placeholder: tr(
+            "fluidgrids.builder.nodeSettings.notesPlaceholder",
+            "Leave a note for teammates about what this node does\u2026"
+          ),
+          "data-testid": "ndv-settings-notes",
+          className: cn$1(inputCx, "resize-y")
+        }
+      )
+    ] })
+  ] });
+}
+function Field({
+  label,
+  children
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+    /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: label }),
+    children
+  ] });
+}
 
 // src/builder/lib/continuation.ts
 var BLOCKED = {
@@ -5591,4 +6685,4 @@ function NodeExecutionActions({
   );
 }
 
-export { NDV_Z_INDEX, NodeExecutionActions, NodeParamsForm, Popover, PopoverContent, PopoverTrigger, ReadOnlyFieldset, useGlobalStoreClient };
+export { NDV_Z_INDEX, NodeExecutionActions, NodeParamsForm, NodeSettingsPanel, Popover, PopoverContent, PopoverTrigger, RUNNER_INSTALL_SCRIPT_URL, ReadOnlyFieldset, RunOnSection, RunnerStatusPill, SCHEDULE_NODE_TYPE, SchedulePanel, TabButton, runnerInstallCommand, useGlobalStoreClient, useRunnerActions, useRunners };