@burdenoff/fluidgrids-fe-sdk 2026.1101.1 → 2026.1101.2

package/dist/chunk-472HJ3S3.js

@@ -0,0 +1,3929 @@
+import { CodeEditorField, normalizeCodeLanguage } from './chunk-AASHQI77.js';
+import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-IA2ZCHNQ.js';
+import { Popover, PopoverTrigger, PopoverContent } from './chunk-GTEBQQ7J.js';
+import { isAgentNodeType, AgentDefinitionSelectField } from './chunk-YKFR7BZJ.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-NZJWKVER.js';
+import { useBuilderReadOnly } from './chunk-OCJTTHTS.js';
+import { useRunFromNodeEligibilityQuery, PreviewScheduleDocument, WebhookTestListenerDocument, StopWebhookTestListenerDocument, ListenForWebhookTestEventDocument } from './chunk-IHEV5HTD.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClientSafe, getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useId, useState, useMemo, useRef, useEffect, useContext, useCallback } from 'react';
+import { Icon } from '@iconify/react';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { gql } from '@apollo/client';
+import cronstrue from 'cronstrue';
+import { digest } from 'ohash';
+import { X, Plus } from 'lucide-react';
+
+// src/builder/components/ndv/layering.ts
+var NDV_Z_INDEX = 1e3;
+var NDV_OVERLAY_Z_INDEX = NDV_Z_INDEX + 1;
+
+// src/builder/lib/loop-return-status.ts
+function loopReturnStatus(nodeId, edges, loopHandle = "loop") {
+  const enabled = edges.filter(
+    (edge) => edge.disabled !== true && edge.data?.disabled !== true
+  );
+  const queue = enabled.filter(
+    (edge) => (edge.source ?? edge.from) === nodeId && (edge.sourceHandle ?? edge.fromHandle ?? "loop") === loopHandle
+  ).map((edge) => edge.target ?? edge.to).filter((target) => typeof target === "string");
+  const visited = /* @__PURE__ */ new Set();
+  let returns = false;
+  let exits = false;
+  for (let index = 0; index < queue.length; index++) {
+    const current = queue[index];
+    if (current === nodeId) {
+      returns = true;
+      continue;
+    }
+    if (!current || visited.has(current)) continue;
+    visited.add(current);
+    const outgoing = enabled.filter(
+      (edge) => (edge.source ?? edge.from) === current
+    );
+    if (outgoing.length === 0) exits = true;
+    for (const edge of outgoing) {
+      const target = edge.target ?? edge.to;
+      if (target) queue.push(target);
+    }
+  }
+  if (!returns) return "missing-return";
+  return exits ? "conditional-exit" : "connected";
+}
+var SECTION_LABEL = "text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground";
+var RESUME_URL_EXPRESSION = "${RunContext.resumeWebhookUrl}";
+function WaitResumeUrlField() {
+  const tr = useTr();
+  const [copied, setCopied] = useState(false);
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(RESUME_URL_EXPRESSION);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    } catch {
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "ndv-wait-resume-url", children: [
+    /* @__PURE__ */ jsx("div", { className: SECTION_LABEL, children: tr("fluidgrids.builder.waitResumeUrl.label", "Resume URL") }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-stretch gap-2", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          readOnly: true,
+          value: RESUME_URL_EXPRESSION,
+          onFocus: (e) => e.currentTarget.select(),
+          className: "min-w-0 flex-1 rounded-md border border-border bg-muted/40 px-3 py-2 font-mono text-xs text-foreground outline-none focus:border-primary"
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: handleCopy,
+          className: cn(
+            "inline-flex shrink-0 items-center gap-1.5 rounded-md border border-border px-3 py-2 text-xs font-medium transition-colors",
+            copied ? "border-primary bg-primary/10 text-primary" : "bg-background text-foreground hover:bg-muted"
+          ),
+          "aria-label": tr(
+            "fluidgrids.builder.waitResumeUrl.copyAriaLabel",
+            "Copy resume URL expression"
+          ),
+          children: [
+            /* @__PURE__ */ jsx(
+              Icon,
+              {
+                icon: copied ? "mdi:check" : "mdi:content-copy",
+                className: "h-4 w-4"
+              }
+            ),
+            copied ? tr("fluidgrids.builder.waitResumeUrl.copied", "Copied") : tr("fluidgrids.builder.waitResumeUrl.copy", "Copy")
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: tr(
+      "fluidgrids.builder.waitResumeUrl.help",
+      "Each run gets its own signed, single-use resume URL. Use this expression in an earlier node (an email or message) to send the link; the run continues when it is called. The URL for a finished or waiting run appears on this node's output as _resumeUrl."
+    ) })
+  ] });
+}
+var POLL_INTERVAL_MS = 2e3;
+function useWebhookTestListener(target, onReceived) {
+  const [listener, setListener] = useState(
+    null
+  );
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const tr = useTr();
+  const { bus, workspaceId } = useFluidGridsAnalytics();
+  const pollTimer = useRef(null);
+  const openId = useRef(null);
+  const generation = useRef(0);
+  const onReceivedRef = useRef(onReceived);
+  onReceivedRef.current = onReceived;
+  const workflowKey = target?.workflowKey;
+  const version = target?.version;
+  const triggerNodeId = target?.triggerNodeId;
+  const clearPoll = useCallback(() => {
+    if (pollTimer.current) {
+      clearTimeout(pollTimer.current);
+      pollTimer.current = null;
+    }
+  }, []);
+  const poll = useCallback(
+    (id) => {
+      clearPoll();
+      pollTimer.current = setTimeout(async () => {
+        const client = getFluidGridsClientSafe();
+        if (!client || openId.current !== id) return;
+        try {
+          const result = await client.query({
+            query: WebhookTestListenerDocument,
+            variables: { id },
+            fetchPolicy: "network-only"
+          });
+          const latest = result.data?.webhookTestListener;
+          if (openId.current !== id) return;
+          if (!latest) {
+            openId.current = null;
+            setListener(null);
+            return;
+          }
+          const status = latest.status;
+          setListener(
+            (current) => current && current.id === id ? {
+              ...current,
+              status,
+              runId: latest.runId ?? null,
+              error: latest.error ?? null
+            } : current
+          );
+          if (status === "LISTENING") {
+            poll(id);
+            return;
+          }
+          openId.current = null;
+          if (status === "RECEIVED" && latest.runId) {
+            onReceivedRef.current(latest.runId);
+          }
+        } catch {
+          if (openId.current === id) poll(id);
+        }
+      }, POLL_INTERVAL_MS);
+    },
+    [clearPoll]
+  );
+  const stopAbandoned = useCallback((id) => {
+    void getFluidGridsClientSafe()?.mutate({ mutation: StopWebhookTestListenerDocument, variables: { id } }).catch(() => void 0);
+  }, []);
+  const stopOpenListener = useCallback(() => {
+    const id = openId.current;
+    openId.current = null;
+    clearPoll();
+    if (id) stopAbandoned(id);
+  }, [clearPoll, stopAbandoned]);
+  const listen = useCallback(async () => {
+    const client = getFluidGridsClientSafe();
+    if (!client || !workflowKey || !version || !triggerNodeId) return;
+    stopOpenListener();
+    const armedFor = generation.current;
+    setBusy(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await client.mutate({
+          mutation: ListenForWebhookTestEventDocument,
+          variables: { input: { workflowKey, version, triggerNodeId } }
+        })
+      );
+      const armed = result.data?.listenForWebhookTestEvent;
+      if (!armed) throw new Error("The test listener could not be started");
+      if (generation.current !== armedFor) {
+        stopAbandoned(armed.id);
+        return;
+      }
+      openId.current = armed.id;
+      setListener({
+        id: armed.id,
+        status: armed.status,
+        testUrl: armed.testUrl ?? null,
+        expiresAt: armed.expiresAt,
+        runId: armed.runId ?? null,
+        error: armed.error ?? null
+      });
+      poll(armed.id);
+    } catch (err) {
+      if (generation.current === armedFor) {
+        openRunQuotaUpgradePrompt(err, tr, {
+          bus,
+          workspaceId,
+          surface: "webhook-test"
+        });
+        setError(describeOperationError(err));
+      }
+    } finally {
+      if (generation.current === armedFor) setBusy(false);
+    }
+  }, [
+    workflowKey,
+    version,
+    triggerNodeId,
+    poll,
+    stopOpenListener,
+    stopAbandoned,
+    tr,
+    bus,
+    workspaceId
+  ]);
+  const stop = useCallback(async () => {
+    const id = openId.current;
+    const client = getFluidGridsClientSafe();
+    if (!id || !client) return;
+    clearPoll();
+    const stoppedFor = generation.current;
+    setBusy(true);
+    try {
+      const result = await client.mutate({ mutation: StopWebhookTestListenerDocument, variables: { id } });
+      const stopped = result.data?.stopWebhookTestListener;
+      if (generation.current !== stoppedFor) return;
+      if (!stopped) throw new Error("The test listener could not be stopped");
+      const closedHere = openId.current === id;
+      if (closedHere) openId.current = null;
+      const status = stopped.status;
+      setListener(
+        (current) => current && current.id === id ? {
+          ...current,
+          status,
+          runId: stopped.runId ?? null,
+          error: stopped.error ?? null
+        } : current
+      );
+      if (closedHere && status === "RECEIVED" && stopped.runId) {
+        onReceivedRef.current(stopped.runId);
+      }
+    } catch (err) {
+      if (generation.current !== stoppedFor) return;
+      setError(describeOperationError(err));
+      if (openId.current === id) poll(id);
+    } finally {
+      if (generation.current === stoppedFor) setBusy(false);
+    }
+  }, [clearPoll, poll]);
+  useEffect(() => {
+    setListener(null);
+    setError(null);
+    setBusy(false);
+    return () => {
+      generation.current += 1;
+      stopOpenListener();
+    };
+  }, [workflowKey, version, triggerNodeId, stopOpenListener]);
+  return { listener, busy, error, listen, stop };
+}
+var SECTION_LABEL2 = "text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground";
+function isSafeHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "https:" || parsed.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function CopyableUrl({
+  url,
+  copyAriaLabel,
+  testId,
+  openLabel
+}) {
+  const tr = useTr();
+  const [copied, setCopied] = useState(false);
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(url);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    } catch {
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-stretch gap-2", children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        readOnly: true,
+        value: url,
+        "data-testid": testId,
+        onFocus: (e) => e.currentTarget.select(),
+        className: "min-w-0 flex-1 rounded-md border border-border bg-muted/40 px-3 py-2 font-mono text-xs text-foreground outline-none focus:border-primary"
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: handleCopy,
+        className: cn(
+          "inline-flex shrink-0 items-center gap-1.5 rounded-md border border-border px-3 py-2 text-xs font-medium transition-colors",
+          copied ? "border-primary bg-primary/10 text-primary" : "bg-background text-foreground hover:bg-muted"
+        ),
+        "aria-label": copyAriaLabel,
+        children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: copied ? "mdi:check" : "mdi:content-copy",
+              className: "h-4 w-4"
+            }
+          ),
+          copied ? tr("fluidgrids.builder.webhookUrlField.copied", "Copied") : tr("fluidgrids.builder.webhookUrlField.copy", "Copy")
+        ]
+      }
+    ),
+    openLabel && /* @__PURE__ */ jsxs(
+      "a",
+      {
+        href: url,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        "data-testid": `${testId}-open`,
+        className: "inline-flex shrink-0 items-center gap-1.5 rounded-md border border-border bg-background px-3 py-2 text-xs font-medium text-foreground transition-colors hover:bg-muted",
+        children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:open-in-new", className: "h-4 w-4" }),
+          openLabel
+        ]
+      }
+    )
+  ] });
+}
+function WebhookUrlField({ webhookUrl, loading }) {
+  const tr = useTr();
+  const isActiveVersion = useFlowStore((s) => s.workflow.status === "ACTIVE");
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "ndv-webhook-url", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL2, children: tr(
+        "fluidgrids.builder.webhookUrlField.productionLabel",
+        "Production URL"
+      ) }),
+      webhookUrl && isActiveVersion && /* @__PURE__ */ jsx("span", { className: "rounded-full bg-primary/10 px-2 py-0.5 text-[10px] font-medium text-primary", children: tr("fluidgrids.builder.webhookUrlField.live", "Live") })
+    ] }),
+    webhookUrl ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        CopyableUrl,
+        {
+          url: webhookUrl,
+          testId: "ndv-webhook-production-url",
+          copyAriaLabel: tr(
+            "fluidgrids.builder.webhookUrlField.copyAriaLabel",
+            "Copy webhook URL"
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx("p", { className: "text-[11px] text-muted-foreground", children: isActiveVersion ? tr(
+        "fluidgrids.builder.webhookUrlField.activeHint",
+        "Requests to this URL run this version of the workflow."
+      ) : tr(
+        "fluidgrids.builder.webhookUrlField.inactiveHint",
+        "Requests to this URL run the workflow's active version only. Activate this version to make it live, or use a test URL to try it."
+      ) })
+    ] }) : /* @__PURE__ */ jsx("div", { className: "rounded-md border border-dashed border-border bg-muted/40 px-3 py-2 text-xs text-muted-foreground", children: loading ? tr(
+      "fluidgrids.builder.webhookUrlField.loading",
+      "Loading webhook URL\u2026"
+    ) : tr(
+      "fluidgrids.builder.webhookUrlField.unsaved",
+      "Save the workflow to generate its webhook URL."
+    ) })
+  ] });
+}
+function FormUrlField({ formUrl, loading, error }) {
+  const tr = useTr();
+  const safeUrl = formUrl && isSafeHttpUrl(formUrl) ? formUrl : null;
+  let message = null;
+  if (!safeUrl || error) {
+    if (error || formUrl) {
+      message = tr(
+        "fluidgrids.builder.formUrlField.error",
+        "Unable to load a safe trigger URL."
+      );
+    } else if (loading) {
+      message = tr(
+        "fluidgrids.builder.formUrlField.loading",
+        "Loading form URL\u2026"
+      );
+    } else {
+      message = tr(
+        "fluidgrids.builder.formUrlField.unsaved",
+        "Save the workflow to generate its form URL."
+      );
+    }
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "ndv-form-url", children: [
+    /* @__PURE__ */ jsx("div", { className: SECTION_LABEL2, children: tr("fluidgrids.builder.formUrlField.label", "Form URL") }),
+    safeUrl && !error ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        CopyableUrl,
+        {
+          url: safeUrl,
+          testId: "ndv-form-url-value",
+          copyAriaLabel: tr(
+            "fluidgrids.builder.formUrlField.copyAriaLabel",
+            "Copy form URL"
+          ),
+          openLabel: tr("fluidgrids.builder.formUrlField.open", "Open form")
+        }
+      ),
+      /* @__PURE__ */ jsx("p", { className: "text-[11px] text-muted-foreground", children: tr(
+        "fluidgrids.builder.formUrlField.hint",
+        "Share this link to collect submissions; each submission starts the workflow's active version."
+      ) })
+    ] }) : /* @__PURE__ */ jsx("div", { className: "rounded-md border border-dashed border-border bg-muted/40 px-3 py-2 text-xs text-muted-foreground", children: message })
+  ] });
+}
+function useSecondsLeft(expiresAt) {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!expiresAt) return;
+    const timer = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(timer);
+  }, [expiresAt]);
+  if (!expiresAt) return 0;
+  return Math.max(0, Math.ceil((Date.parse(expiresAt) - now) / 1e3));
+}
+function WebhookTestListenerField({
+  nodeId
+}) {
+  const readOnly = useBuilderReadOnly();
+  return readOnly ? null : /* @__PURE__ */ jsx(WebhookTestListenerControls, { nodeId });
+}
+function WebhookTestListenerControls({
+  nodeId
+}) {
+  const tr = useTr();
+  const workflowKey = useFlowStore((s) => s.workflow.workflowKey);
+  const version = useFlowStore((s) => s.workflow.version);
+  const requestFollowRun = useFlowStore(
+    (s) => s.actions.execution.requestFollowRun
+  );
+  const saved = !!workflowKey && !!version && !!nodeId;
+  const target = saved ? { workflowKey, version, triggerNodeId: nodeId } : null;
+  const { listener, busy, error, listen, stop } = useWebhookTestListener(
+    target,
+    (runId) => {
+      if (nodeId) requestFollowRun(runId, nodeId);
+    }
+  );
+  const listening = listener?.status === "LISTENING";
+  const secondsLeft = useSecondsLeft(listening ? listener.expiresAt : null);
+  const outcome = (() => {
+    switch (listener?.status) {
+      case "RECEIVED":
+        return tr(
+          "fluidgrids.builder.webhookTestListener.received",
+          "Test event received \u2014 the run is shown on the canvas."
+        );
+      case "EXPIRED":
+        return tr(
+          "fluidgrids.builder.webhookTestListener.expired",
+          "Stopped listening: no test event arrived in time."
+        );
+      case "STOPPED":
+        return tr(
+          "fluidgrids.builder.webhookTestListener.stopped",
+          "Stopped listening."
+        );
+      case "FAILED":
+        return listener.error ?? tr(
+          "fluidgrids.builder.webhookTestListener.failed",
+          "The test event arrived but the run could not be started."
+        );
+      default:
+        return null;
+    }
+  })();
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "ndv-webhook-test", children: [
+    /* @__PURE__ */ jsx("div", { className: SECTION_LABEL2, children: tr("fluidgrids.builder.webhookTestListener.label", "Test URL") }),
+    !saved ? /* @__PURE__ */ jsx("div", { className: "rounded-md border border-dashed border-border bg-muted/40 px-3 py-2 text-xs text-muted-foreground", children: tr(
+      "fluidgrids.builder.webhookTestListener.unsaved",
+      "Save the workflow to test this webhook."
+    ) }) : listening && listener.testUrl ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        CopyableUrl,
+        {
+          url: listener.testUrl,
+          testId: "ndv-webhook-test-url",
+          copyAriaLabel: tr(
+            "fluidgrids.builder.webhookTestListener.copyAriaLabel",
+            "Copy test URL"
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-2", children: [
+        /* @__PURE__ */ jsxs(
+          "p",
+          {
+            className: "flex items-center gap-1.5 text-[11px] text-muted-foreground",
+            "data-testid": "ndv-webhook-test-status",
+            children: [
+              /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: "mdi:access-point",
+                  className: "h-3.5 w-3.5 text-primary"
+                }
+              ),
+              tr(
+                "fluidgrids.builder.webhookTestListener.listening",
+                "Listening for one test event to version {{version}} \u2014 {{seconds}}s left",
+                { version, seconds: secondsLeft }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => void stop(),
+            disabled: busy,
+            "data-testid": "ndv-webhook-test-stop",
+            className: "shrink-0 rounded-md border border-border bg-background px-3 py-1.5 text-xs font-medium text-foreground hover:bg-muted disabled:opacity-50",
+            children: tr("fluidgrids.builder.webhookTestListener.stop", "Stop")
+          }
+        )
+      ] })
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => void listen(),
+          disabled: busy,
+          "data-testid": "ndv-webhook-test-listen",
+          className: "inline-flex items-center gap-1.5 rounded-md border border-border bg-background px-3 py-2 text-xs font-medium text-foreground hover:bg-muted disabled:opacity-50",
+          children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:access-point", className: "h-4 w-4" }),
+            tr(
+              "fluidgrids.builder.webhookTestListener.listen",
+              "Listen for test event"
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          className: "text-[11px] text-muted-foreground",
+          "data-testid": "ndv-webhook-test-status",
+          children: outcome ?? tr(
+            "fluidgrids.builder.webhookTestListener.hint",
+            "Creates a one-time URL for the saved version {{version}}. Unsaved changes are not included.",
+            { version }
+          )
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx("p", { className: "text-[11px] text-destructive", role: "alert", children: error })
+  ] });
+}
+var LIST_WORKFLOWS_QUERY = gql`
+  query ListWorkflowDefinitionsForPicker($limit: Int, $offset: Int) {
+    workflowDefinitions(input: { limit: $limit, offset: $offset }) {
+      items {
+        id
+        workflowKey
+        name
+        version
+        status
+      }
+    }
+  }
+`;
+function formatVersion(version) {
+  return /^v/i.test(version) ? version : `v${version}`;
+}
+function WorkflowPickerField({
+  value,
+  onChange,
+  testId
+}) {
+  const tr = useTr();
+  const [workflows, setWorkflows] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [failed, setFailed] = useState(false);
+  const [search, setSearch] = useState("");
+  const [open, setOpen] = useState(false);
+  const load = useCallback(async () => {
+    const client = getFluidGridsClient();
+    if (!client) {
+      setFailed(true);
+      return;
+    }
+    setLoading(true);
+    try {
+      const result = await client.query({
+        query: LIST_WORKFLOWS_QUERY,
+        variables: { limit: 200, offset: 0 },
+        fetchPolicy: "cache-first"
+      });
+      const data = result.data;
+      setWorkflows(
+        (data?.workflowDefinitions?.items ?? []).map((w) => ({
+          workflowKey: w.workflowKey,
+          name: w.name || w.workflowKey,
+          version: w.version,
+          status: w.status
+        }))
+      );
+      setFailed(false);
+    } catch {
+      setFailed(true);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void load();
+  }, [load]);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    const existing = byKey.get(workflow.workflowKey);
+    if (!existing || workflow.status === "ACTIVE" && existing.status !== "ACTIVE") {
+      byKey.set(workflow.workflowKey, workflow);
+    }
+  }
+  const options = [...byKey.values()].filter((w) => {
+    const needle = search.trim().toLowerCase();
+    if (!needle) return true;
+    return w.name.toLowerCase().includes(needle) || w.workflowKey.toLowerCase().includes(needle);
+  });
+  const selected = byKey.get(value);
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", "data-testid": testId, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setOpen((o) => !o),
+        className: "flex items-center justify-between gap-2 rounded-md border border-input bg-background px-2.5 py-1.5 text-left text-sm outline-none transition-colors hover:border-primary",
+        children: [
+          /* @__PURE__ */ jsx("span", { className: cn("truncate", !value && "text-muted-foreground"), children: selected ? `${selected.name} (${selected.workflowKey.slice(0, 8)}\u2026)` : value || tr(
+            "fluidgrids.builder.workflowPicker.placeholder",
+            "Select a workflow to call"
+          ) }),
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: open ? "mdi:chevron-up" : "mdi:chevron-down",
+              className: "h-4 w-4 shrink-0 text-muted-foreground"
+            }
+          )
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsxs("div", { className: "rounded-md border border-border bg-background p-2", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          autoFocus: true,
+          value: search,
+          onChange: (e) => setSearch(e.target.value),
+          placeholder: tr(
+            "fluidgrids.builder.workflowPicker.search",
+            "Search workflows"
+          ),
+          className: "mb-2 w-full rounded-md border border-input bg-background px-2 py-1 text-sm outline-none focus:border-primary"
+        }
+      ),
+      loading && /* @__PURE__ */ jsx("div", { className: "px-2 py-1.5 text-xs text-muted-foreground", children: tr("fluidgrids.builder.workflowPicker.loading", "Loading\u2026") }),
+      !loading && options.length === 0 && /* @__PURE__ */ jsx("div", { className: "px-2 py-1.5 text-xs text-muted-foreground", children: failed ? tr(
+        "fluidgrids.builder.workflowPicker.failed",
+        "Could not load workflows \u2014 enter a workflow key below."
+      ) : tr(
+        "fluidgrids.builder.workflowPicker.empty",
+        "No workflows found"
+      ) }),
+      /* @__PURE__ */ jsx("div", { className: "max-h-48 overflow-y-auto", children: options.map((workflow) => /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => {
+            onChange(workflow.workflowKey);
+            setOpen(false);
+            setSearch("");
+          },
+          className: cn(
+            "flex w-full flex-col items-start gap-0.5 rounded px-2 py-1.5 text-left hover:bg-muted",
+            workflow.workflowKey === value && "bg-muted"
+          ),
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "text-sm text-foreground", children: workflow.name }),
+            /* @__PURE__ */ jsxs("span", { className: "font-mono text-[10px] text-muted-foreground", children: [
+              workflow.workflowKey,
+              " \xB7 ",
+              formatVersion(workflow.version),
+              " \xB7",
+              " ",
+              workflow.status
+            ] })
+          ]
+        },
+        workflow.workflowKey
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        value,
+        onChange: (e) => onChange(e.target.value),
+        placeholder: tr(
+          "fluidgrids.builder.workflowPicker.manual",
+          "\u2026or paste a workflow key"
+        ),
+        className: "w-full rounded-md border border-input bg-background px-2.5 py-1.5 font-mono text-xs outline-none focus:border-primary"
+      }
+    )
+  ] });
+}
+var LOAD_NODE_OPTIONS = gql`
+  query LoadNodeOptions(
+    $nodeType: String!
+    $nodeVersion: String!
+    $operationName: String!
+    $resultPath: String
+    $labelField: String!
+    $valueField: String!
+    $connectionId: ID
+    $args: JSON
+  ) {
+    loadNodeOptions(
+      nodeType: $nodeType
+      nodeVersion: $nodeVersion
+      operationName: $operationName
+      resultPath: $resultPath
+      labelField: $labelField
+      valueField: $valueField
+      connectionId: $connectionId
+      args: $args
+    ) {
+      label
+      value
+    }
+  }
+`;
+var CACHE_TTL_MS = 3 * 60 * 1e3;
+var clientCaches = /* @__PURE__ */ new WeakMap();
+function requestLoadNodeOptions(variables, publish, refresh = false, getClient = getFluidGridsClient) {
+  let cancelled = false;
+  const cancel = () => {
+    cancelled = true;
+  };
+  if (!variables) {
+    publish({ options: [], loading: false, error: null });
+    return cancel;
+  }
+  publish({ options: [], loading: true, error: null });
+  void (async () => {
+    try {
+      const client = getClient();
+      let cache = clientCaches.get(client);
+      if (!cache) {
+        cache = /* @__PURE__ */ new Map();
+        clientCaches.set(client, cache);
+      }
+      const key = JSON.stringify(variables);
+      const cached = cache.get(key);
+      if (!refresh && cached?.options && cached.expiresAt > Date.now()) {
+        publish({ options: cached.options, loading: false, error: null });
+        return;
+      }
+      const entry = { expiresAt: 0 };
+      cache.set(key, entry);
+      const result = await client.query({
+        query: LOAD_NODE_OPTIONS,
+        variables,
+        fetchPolicy: "network-only"
+      });
+      if (cancelled) return;
+      const options = result.data?.loadNodeOptions ?? [];
+      if (cache.get(key) === entry) {
+        entry.options = options;
+        entry.expiresAt = Date.now() + CACHE_TTL_MS;
+      }
+      publish({ options, loading: false, error: null });
+    } catch (error) {
+      if (cancelled) return;
+      publish({
+        options: [],
+        loading: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  })();
+  return cancel;
+}
+
+// src/hooks/useLoadNodeOptions.ts
+function useLoadNodeOptions(nodeType, nodeVersion, spec, connectionId) {
+  const [published, setPublished] = useState();
+  const [nonce, setNonce] = useState(0);
+  const refreshRequested = useRef(false);
+  const specRef = useRef(spec);
+  const specKey = JSON.stringify(spec ?? null);
+  const context = useContext(FluidGridsContext);
+  const client = context?.workspaceClient ?? getFluidGridsClientSafe();
+  const requestKey = JSON.stringify([
+    nodeType,
+    nodeVersion,
+    specKey,
+    connectionId,
+    nonce
+  ]);
+  useEffect(() => {
+    specRef.current = spec;
+  }, [spec]);
+  useEffect(() => {
+    const currentSpec = specRef.current;
+    const refresh = refreshRequested.current;
+    refreshRequested.current = false;
+    const variables = nodeType && nodeVersion && currentSpec && connectionId ? {
+      nodeType,
+      nodeVersion,
+      operationName: currentSpec.operation,
+      resultPath: currentSpec.resultPath ?? null,
+      labelField: currentSpec.labelField,
+      valueField: currentSpec.valueField,
+      connectionId,
+      args: currentSpec.staticArgs ?? {}
+    } : void 0;
+    return requestLoadNodeOptions(
+      variables,
+      (result2) => setPublished({ requestKey, client, result: result2 }),
+      refresh,
+      client ? () => client : void 0
+    );
+  }, [nodeType, nodeVersion, specKey, connectionId, nonce, client, requestKey]);
+  const result = published?.requestKey === requestKey && published.client === client ? published.result : {
+    options: [],
+    loading: Boolean(nodeType && nodeVersion && spec && connectionId),
+    error: null
+  };
+  return {
+    ...result,
+    refetch: () => {
+      refreshRequested.current = true;
+      setNonce((value) => value + 1);
+    }
+  };
+}
+var EMPTY_VALUES = {};
+var EMPTY_PARAMETERS = [];
+function OptionListInput({
+  value,
+  onChange,
+  className,
+  testId,
+  fieldName,
+  label
+}) {
+  const tr = useTr();
+  const [draft, setDraft] = useState(() => optionListText(value));
+  const [invalid, setInvalid] = useState(
+    () => optionListValues(value) === void 0
+  );
+  const [edited, setEdited] = useState(false);
+  useEffect(() => {
+    setDraft(optionListText(value));
+    setInvalid(optionListValues(value) === void 0);
+    setEdited(false);
+  }, [value]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        value: draft,
+        onChange: (event) => {
+          setDraft(event.target.value);
+          setEdited(true);
+          setInvalid(optionListValues(event.target.value) === void 0);
+        },
+        onBlur: () => {
+          const values = optionListValues(draft);
+          if (edited && values !== void 0) onChange(values);
+        },
+        placeholder: tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsListPlaceholder",
+          "Comma-separated IDs or a JSON array of IDs"
+        ),
+        "aria-label": label ?? fieldName,
+        "aria-invalid": invalid,
+        "data-testid": testId,
+        className,
+        rows: 2
+      }
+    ),
+    invalid && /* @__PURE__ */ jsx("span", { role: "alert", className: "text-[11px] text-destructive", children: tr(
+      "fluidgrids.builder.nodeParamsForm.loadOptionsInvalidList",
+      "Enter comma-separated IDs or a JSON array of strings. The saved value has not changed."
+    ) })
+  ] });
+}
+function NodeLoadOptionsSelect({
+  nodeType,
+  nodeVersion,
+  spec,
+  connectionId,
+  value,
+  onChange,
+  className,
+  testId,
+  parameterValues = EMPTY_VALUES,
+  parameterDefaults = EMPTY_VALUES,
+  unavailableParameters = EMPTY_PARAMETERS,
+  multiple = false,
+  fieldName = "Options",
+  label
+}) {
+  const tr = useTr();
+  const [manual, setManual] = useState(false);
+  const resolved = useMemo(
+    () => resolveLoadOptionsSpec(
+      spec,
+      parameterValues,
+      parameterDefaults,
+      unavailableParameters
+    ),
+    [spec, parameterValues, parameterDefaults, unavailableParameters]
+  );
+  const { options, loading, error } = useLoadNodeOptions(
+    nodeType,
+    nodeVersion,
+    resolved.spec,
+    connectionId
+  );
+  const listValues = multiple ? optionListValues(value) : [];
+  const selectedValues = multiple ? listValues ?? [] : typeof value === "string" && value ? [value] : [];
+  const waiting = resolved.missingParameters.length > 0;
+  const useManual = manual || !connectionId || waiting || !!error || multiple && listValues === void 0;
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+    useManual ? multiple ? /* @__PURE__ */ jsx(
+      OptionListInput,
+      {
+        value,
+        onChange,
+        className,
+        testId,
+        fieldName,
+        label
+      }
+    ) : /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "text",
+        value: typeof value === "string" ? value : "",
+        onChange: (event) => onChange(event.target.value),
+        placeholder: tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsErrorPlaceholder",
+          "Enter a value"
+        ),
+        "aria-label": label ?? fieldName,
+        "data-testid": testId,
+        className
+      }
+    ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          multiple,
+          value: multiple ? selectedValues : selectedValues[0] ?? "",
+          onChange: (event) => onChange(
+            multiple ? Array.from(
+              event.target.selectedOptions,
+              (option) => option.value
+            ) : event.target.value
+          ),
+          disabled: loading,
+          "aria-label": label ?? fieldName,
+          "data-testid": testId,
+          className: cn(className, loading && "opacity-60"),
+          children: [
+            !multiple && /* @__PURE__ */ jsx("option", { value: "", children: loading ? tr(
+              "fluidgrids.builder.nodeParamsForm.loadOptionsLoading",
+              "Loading\u2026"
+            ) : tr(
+              "fluidgrids.builder.nodeParamsForm.selectPlaceholder",
+              "Select\u2026"
+            ) }),
+            selectedValues.filter(
+              (selected) => !options.some((option) => option.value === selected)
+            ).map((selected) => /* @__PURE__ */ jsx("option", { value: selected, children: selected }, selected)),
+            options.map((option) => /* @__PURE__ */ jsx("option", { value: option.value, children: option.label }, option.value))
+          ]
+        }
+      ),
+      multiple && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("span", { className: "text-[11px] text-muted-foreground", children: loading ? tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsLoading",
+          "Loading\u2026"
+        ) : tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsMultipleHelp",
+          "Choose multiple values with Ctrl or Command. Saved IDs remain available."
+        ) }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            disabled: loading,
+            onClick: () => onChange([]),
+            className: "w-fit text-xs underline",
+            children: tr(
+              "fluidgrids.builder.nodeParamsForm.loadOptionsClear",
+              "Clear selection"
+            )
+          }
+        )
+      ] })
+    ] }),
+    !connectionId ? /* @__PURE__ */ jsx("span", { className: "text-[11px] text-muted-foreground", children: tr(
+      "fluidgrids.builder.nodeParamsForm.loadOptionsNoConnection",
+      "Connect an account above to load options, or type a value"
+    ) }) : waiting ? /* @__PURE__ */ jsxs("span", { className: "text-[11px] text-muted-foreground", children: [
+      tr(
+        "fluidgrids.builder.nodeParamsForm.loadOptionsMissingParameters",
+        "Set fixed values for these parameters to load options:"
+      ),
+      " ",
+      resolved.missingParameters.join(", ")
+    ] }) : error ? /* @__PURE__ */ jsx("span", { className: "text-[11px] text-destructive", children: tr(
+      "fluidgrids.builder.nodeParamsForm.loadOptionsError",
+      "Couldn't load options \u2014 enter a value manually."
+    ) }) : /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => setManual((current) => !current),
+        className: "w-fit text-xs underline",
+        children: manual ? tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsChoose",
+          "Choose from list"
+        ) : tr(
+          "fluidgrids.builder.nodeParamsForm.loadOptionsManual",
+          "Enter IDs manually"
+        )
+      }
+    )
+  ] });
+}
+
+// src/builder/lib/boolean-parameter.ts
+function booleanParameterValue(value) {
+  if (typeof value !== "string") return value;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  return value;
+}
+function StructuredParameterInput({
+  name,
+  label,
+  schema,
+  value,
+  onChange,
+  className,
+  testId
+}) {
+  const tr = useTr();
+  const descriptionId = useId();
+  const [draft, setDraft] = useState(() => ({
+    value,
+    text: formatParameterValue(value)
+  }));
+  const text = Object.is(draft.value, value) ? draft.text : formatParameterValue(value);
+  const result = parseParameterValue(schema, text);
+  const type = structuredParameterType(schema);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        "aria-label": label ?? name,
+        "aria-describedby": descriptionId,
+        "aria-invalid": !result.valid,
+        value: text,
+        rows: 4,
+        spellCheck: false,
+        className,
+        "data-testid": testId,
+        placeholder: type === "array" ? "[]" : "{}",
+        onChange: (event) => {
+          const nextText = event.target.value;
+          const nextResult = parseParameterValue(schema, nextText);
+          const nextValue = nextResult.valid ? nextResult.value : nextText;
+          setDraft({ value: nextValue, text: nextText });
+          onChange(nextValue);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        id: descriptionId,
+        role: result.valid ? void 0 : "alert",
+        className: result.valid ? "text-[11px] text-muted-foreground" : "text-[11px] text-destructive",
+        children: result.valid ? type === "array" ? tr(
+          "fluidgrids.builder.nodeParamsForm.arrayHint",
+          "Enter a JSON array. String lists also accept comma-separated values."
+        ) : tr(
+          "fluidgrids.builder.nodeParamsForm.objectHint",
+          "Enter a JSON object."
+        ) : tr(
+          "fluidgrids.builder.nodeParamsForm.structuredInputInvalid",
+          result.error
+        )
+      }
+    )
+  ] });
+}
+function JsonMappingInput({
+  name,
+  label,
+  value,
+  onChange
+}) {
+  const tr = useTr();
+  const descriptionId = useId();
+  const serialized = JSON.stringify(value, null, 2);
+  const [text, setText] = useState(serialized);
+  const result = parseMappingValue(text);
+  const changed = text !== serialized;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        "aria-label": label ?? name,
+        "aria-describedby": descriptionId,
+        "aria-invalid": !result.valid,
+        className: "w-full rounded-md border border-input bg-background px-2.5 py-1.5 font-mono text-sm outline-none focus:border-primary",
+        rows: 4,
+        spellCheck: false,
+        value: text,
+        onChange: (event) => setText(event.target.value)
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        id: descriptionId,
+        role: result.valid ? void 0 : "alert",
+        className: result.valid ? "text-[11px] text-muted-foreground" : "text-[11px] text-destructive",
+        children: result.valid ? tr(
+          "fluidgrids.builder.nodeParamsForm.jsonMappingHint",
+          "JSON mapping. Apply changes before saving the workflow. Nested expressions are preserved."
+        ) : tr(
+          "fluidgrids.builder.nodeParamsForm.jsonMappingInvalid",
+          result.error
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "rounded-md border border-input px-2 py-1 text-xs disabled:opacity-50",
+          disabled: !changed || !result.valid,
+          onClick: () => {
+            if (!result.valid) return;
+            onChange(result.value);
+            setText(JSON.stringify(result.value, null, 2));
+          },
+          children: tr(
+            "fluidgrids.builder.nodeParamsForm.applyJsonMapping",
+            "Apply mapping"
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "rounded-md border border-input px-2 py-1 text-xs disabled:opacity-50",
+          disabled: !changed,
+          onClick: () => setText(serialized),
+          children: tr("fluidgrids.builder.nodeParamsForm.resetJsonMapping", "Reset")
+        }
+      )
+    ] })
+  ] });
+}
+function MappedParameterInput({
+  name,
+  label,
+  value,
+  onChange,
+  nodeId,
+  placeholder
+}) {
+  if (value !== void 0 && typeof value !== "string") {
+    return /* @__PURE__ */ jsx(
+      JsonMappingInput,
+      {
+        name,
+        label,
+        value,
+        onChange
+      },
+      JSON.stringify(value)
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    ExpressionEditor,
+    {
+      value: value ?? "",
+      onChange,
+      rows: 2,
+      nodeId,
+      placeholder,
+      ariaLabel: label ?? name
+    }
+  );
+}
+var SCHEDULE_RULE_FIELDS = [
+  "seconds",
+  "minutes",
+  "hours",
+  "days",
+  "weeks",
+  "months",
+  "cronExpression"
+];
+var LEGACY_INTERVAL_UNITS = [
+  "minutes",
+  "hours",
+  "days",
+  "weeks"
+];
+var LEGACY_DEFAULT_UNIT = "hours";
+var DEFAULT_TIMEZONE = "UTC";
+var RRULE_WEEKDAYS = [
+  "SU",
+  "MO",
+  "TU",
+  "WE",
+  "TH",
+  "FR",
+  "SA"
+];
+var INTERVAL_KEY = {
+  seconds: "secondsInterval",
+  minutes: "minutesInterval",
+  hours: "hoursInterval",
+  days: "daysInterval",
+  weeks: "weeksInterval",
+  months: "monthsInterval"
+};
+var DEFAULT_INTERVAL = {
+  seconds: 30,
+  minutes: 5,
+  hours: 1,
+  days: 1,
+  weeks: 1,
+  months: 1
+};
+function defaultScheduleRule() {
+  return {
+    field: "days",
+    daysInterval: 1,
+    triggerAtHour: 0,
+    triggerAtMinute: 0
+  };
+}
+function isScheduleRuleField(value) {
+  return typeof value === "string" && SCHEDULE_RULE_FIELDS.some((field) => field === value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toNumber(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") return void 0;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function toWeekdayList(value) {
+  if (Array.isArray(value)) {
+    return value.map(toNumber).filter((day) => day !== void 0);
+  }
+  const single = toNumber(value);
+  return single === void 0 ? void 0 : [single];
+}
+function toTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function isPositiveInteger(value) {
+  return value !== void 0 && Number.isInteger(value) && value >= 1;
+}
+function intervalOf(rule) {
+  if (rule.field === "cronExpression") return 1;
+  const own = rule[INTERVAL_KEY[rule.field]];
+  return typeof own === "number" ? own : DEFAULT_INTERVAL[rule.field];
+}
+function normalizeScheduleRule(raw) {
+  const field = isScheduleRuleField(raw.field) ? raw.field : "days";
+  switch (field) {
+    case "seconds":
+      return {
+        field,
+        secondsInterval: toNumber(raw.secondsInterval) ?? DEFAULT_INTERVAL.seconds
+      };
+    case "minutes":
+      return {
+        field,
+        minutesInterval: toNumber(raw.minutesInterval) ?? DEFAULT_INTERVAL.minutes
+      };
+    case "hours":
+      return {
+        field,
+        hoursInterval: toNumber(raw.hoursInterval) ?? DEFAULT_INTERVAL.hours,
+        triggerAtMinute: toNumber(raw.triggerAtMinute) ?? 0
+      };
+    case "days":
+      return {
+        field,
+        daysInterval: toNumber(raw.daysInterval) ?? DEFAULT_INTERVAL.days,
+        triggerAtHour: toNumber(raw.triggerAtHour) ?? 0,
+        triggerAtMinute: toNumber(raw.triggerAtMinute) ?? 0
+      };
+    case "weeks":
+      return {
+        field,
+        weeksInterval: toNumber(raw.weeksInterval) ?? DEFAULT_INTERVAL.weeks,
+        triggerAtDay: toWeekdayList(raw.triggerAtDay) ?? [0],
+        triggerAtHour: toNumber(raw.triggerAtHour) ?? 0,
+        triggerAtMinute: toNumber(raw.triggerAtMinute) ?? 0
+      };
+    case "months":
+      return {
+        field,
+        monthsInterval: toNumber(raw.monthsInterval) ?? DEFAULT_INTERVAL.months,
+        triggerAtDayOfMonth: toNumber(raw.triggerAtDayOfMonth) ?? 1,
+        triggerAtHour: toNumber(raw.triggerAtHour) ?? 0,
+        triggerAtMinute: toNumber(raw.triggerAtMinute) ?? 0
+      };
+    case "cronExpression":
+      return { field, expression: toTrimmedString(raw.expression) };
+  }
+}
+function rulesFromLegacyState(state) {
+  const cronExpression = toTrimmedString(state.cronExpression);
+  const interval = toNumber(state.interval);
+  const intervalMode = state.mode === "interval" || cronExpression === "" && interval !== void 0 && interval > 0;
+  if (intervalMode) {
+    const unit = isScheduleRuleField(state.unit) && LEGACY_INTERVAL_UNITS.includes(state.unit) ? state.unit : LEGACY_DEFAULT_UNIT;
+    const raw = { field: unit };
+    if (unit !== "cronExpression" && interval !== void 0 && interval > 0) {
+      raw[INTERVAL_KEY[unit]] = interval;
+    }
+    return [normalizeScheduleRule(raw)];
+  }
+  if (cronExpression !== "") {
+    return [{ field: "cronExpression", expression: cronExpression }];
+  }
+  return [defaultScheduleRule()];
+}
+function normalizeScheduleState(state) {
+  const source = isRecord(state) ? state : {};
+  let rules;
+  if (Array.isArray(source.rules)) {
+    rules = source.rules.filter(isRecord).map(normalizeScheduleRule);
+    if (rules.length === 0) rules = [defaultScheduleRule()];
+  } else {
+    rules = rulesFromLegacyState(source);
+  }
+  const timezone = toTrimmedString(source.timezone) || DEFAULT_TIMEZONE;
+  const misfirePolicy = typeof source.misfirePolicy === "string" && source.misfirePolicy.trim().toLowerCase() === "coalesce" ? "coalesce" : "skip";
+  const grace = toNumber(source.misfireGraceSeconds);
+  const misfireGraceSeconds = grace !== void 0 && Number.isInteger(grace) && grace >= 0 ? grace : 0;
+  return { rules, timezone, misfirePolicy, misfireGraceSeconds };
+}
+function isLegacyScheduleState(state) {
+  if (!isRecord(state) || Array.isArray(state.rules)) return false;
+  return state.mode !== void 0 || toTrimmedString(state.cronExpression) !== "" || toNumber(state.interval) !== void 0;
+}
+function inRange(value, min, max) {
+  return value !== void 0 && Number.isInteger(value) && value >= min && value <= max;
+}
+function describeCron(expression) {
+  const text = expression.trim();
+  if (text === "") return null;
+  const fieldCount = text.split(/\s+/).length;
+  if (fieldCount !== 5 && fieldCount !== 6) return null;
+  try {
+    return cronstrue.toString(text, { throwExceptionOnParseError: true });
+  } catch {
+    return null;
+  }
+}
+function validateRule(rule) {
+  const issues = [];
+  switch (rule.field) {
+    case "seconds":
+      if (!inRange(rule.secondsInterval, 1, 59)) issues.push("secondsRange");
+      break;
+    case "minutes":
+      if (!inRange(rule.minutesInterval, 1, 59)) issues.push("minutesRange");
+      break;
+    case "hours":
+      if (!inRange(rule.hoursInterval, 1, 23)) issues.push("hoursRange");
+      break;
+    case "days":
+      if (!inRange(rule.daysInterval, 1, 31)) issues.push("daysRange");
+      break;
+    case "weeks": {
+      if (!isPositiveInteger(rule.weeksInterval)) issues.push("weeksMin");
+      const days = rule.triggerAtDay;
+      if (days === void 0 || days.length === 0)
+        issues.push("weekdaysRequired");
+      else {
+        if (!days.every((day) => inRange(day, 0, 6)))
+          issues.push("weekdaysRange");
+        if (new Set(days).size !== days.length) issues.push("weekdaysRepeat");
+      }
+      break;
+    }
+    case "months":
+      if (!isPositiveInteger(rule.monthsInterval)) issues.push("monthsMin");
+      if (rule.triggerAtDayOfMonth !== void 0 && !inRange(rule.triggerAtDayOfMonth, 1, 31)) {
+        issues.push("dayOfMonthRange");
+      }
+      break;
+    case "cronExpression": {
+      const text = (rule.expression ?? "").trim();
+      if (text === "") return ["cronRequired"];
+      const fieldCount = text.split(/\s+/).length;
+      if (fieldCount !== 5 && fieldCount !== 6) return ["cronFieldCount"];
+      return describeCron(text) === null ? ["cronInvalid"] : [];
+    }
+  }
+  if (rule.triggerAtHour !== void 0 && !inRange(rule.triggerAtHour, 0, 23)) {
+    issues.push("hourRange");
+  }
+  if (rule.triggerAtMinute !== void 0 && !inRange(rule.triggerAtMinute, 0, 59)) {
+    issues.push("minuteRange");
+  }
+  return issues;
+}
+function stableInt(seed, range) {
+  const base64 = digest(seed).replace(/-/g, "+").replace(/_/g, "/");
+  const bytes = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
+  const value = (bytes.charCodeAt(0) << 24 >>> 0) + (bytes.charCodeAt(1) << 16) + (bytes.charCodeAt(2) << 8) + bytes.charCodeAt(3);
+  return value % range;
+}
+function fillerFromKey(nodeKey) {
+  return {
+    second: stableInt(`${nodeKey}:second`, 60),
+    minute: stableInt(`${nodeKey}:minute`, 60),
+    hour: stableInt(`${nodeKey}:hour`, 24),
+    dayOfMonth: 1 + stableInt(`${nodeKey}:dayOfMonth`, 28)
+  };
+}
+function isCronExact(rule) {
+  const interval = intervalOf(rule);
+  switch (rule.field) {
+    case "seconds":
+    case "cronExpression":
+      return true;
+    case "minutes":
+      return isPositiveInteger(interval) && 60 % interval === 0;
+    case "hours":
+      return isPositiveInteger(interval) && 24 % interval === 0;
+    case "days":
+    case "weeks":
+      return interval === 1;
+    case "months":
+      return isPositiveInteger(interval) && 12 % interval === 0;
+  }
+}
+function resolveAnchors(rule, filler) {
+  return {
+    second: filler.second,
+    minute: rule.triggerAtMinute ?? filler.minute,
+    hour: rule.triggerAtHour ?? filler.hour,
+    dayOfMonth: rule.triggerAtDayOfMonth ?? filler.dayOfMonth
+  };
+}
+function sortedWeekdays(rule) {
+  return [...rule.triggerAtDay ?? []].sort((a, b) => a - b);
+}
+function toCronExpression(rule, filler) {
+  if (!isCronExact(rule)) {
+    throw new Error(
+      `Schedule rule "every ${intervalOf(rule)} ${rule.field}" has no exact cron expression; use an RRULE`
+    );
+  }
+  const interval = intervalOf(rule);
+  const { second, minute, hour, dayOfMonth } = resolveAnchors(rule, filler);
+  switch (rule.field) {
+    case "seconds":
+      return `*/${interval} * * * * *`;
+    case "minutes":
+      return `${second} */${interval} * * * *`;
+    case "hours":
+      return `${second} ${minute} */${interval} * * *`;
+    case "days":
+      return `${second} ${minute} ${hour} * * *`;
+    case "weeks": {
+      const days = sortedWeekdays(rule);
+      return `${second} ${minute} ${hour} * * ${days.length === 0 ? "*" : days.join(",")}`;
+    }
+    case "months":
+      return `${second} ${minute} ${hour} ${dayOfMonth} */${interval} *`;
+    case "cronExpression":
+      return (rule.expression ?? "").trim();
+  }
+}
+function toRRule(rule, filler) {
+  const interval = intervalOf(rule);
+  const { second, minute, hour, dayOfMonth } = resolveAnchors(rule, filler);
+  switch (rule.field) {
+    case "minutes":
+      return `FREQ=MINUTELY;INTERVAL=${interval};BYSECOND=${second}`;
+    case "hours":
+      return `FREQ=HOURLY;INTERVAL=${interval};BYMINUTE=${minute};BYSECOND=${second}`;
+    case "days":
+      return `FREQ=DAILY;INTERVAL=${interval};BYHOUR=${hour};BYMINUTE=${minute};BYSECOND=${second}`;
+    case "weeks": {
+      const byDay = sortedWeekdays(rule).map((day) => RRULE_WEEKDAYS[day]).filter((code) => code !== void 0);
+      const byDayPart = byDay.length === 0 ? "" : `;BYDAY=${byDay.join(",")}`;
+      return `FREQ=WEEKLY;INTERVAL=${interval}${byDayPart};BYHOUR=${hour};BYMINUTE=${minute};BYSECOND=${second}`;
+    }
+    case "months":
+      return `FREQ=MONTHLY;INTERVAL=${interval};BYMONTHDAY=${dayOfMonth};BYHOUR=${hour};BYMINUTE=${minute};BYSECOND=${second}`;
+    case "seconds":
+    case "cronExpression":
+      throw new Error(
+        `Schedule rule field "${rule.field}" is always expressed as cron`
+      );
+  }
+}
+function ruleToScheduleSpec(rule, nodeKey) {
+  const filler = fillerFromKey(nodeKey);
+  if (isCronExact(rule)) {
+    return {
+      scheduleType: "CRON",
+      cronExpression: toCronExpression(rule, filler)
+    };
+  }
+  return { scheduleType: "RRULE", rrule: toRRule(rule, filler) };
+}
+function scheduleNodeKey(workflowKey, nodeId, ruleIndex) {
+  return `${workflowKey || "draft"}:${nodeId}:${ruleIndex}`;
+}
+function CronExpressionField({
+  value,
+  onChange,
+  className,
+  testId,
+  ariaLabel
+}) {
+  const tr = useTr();
+  const text = value.trim();
+  const description = text === "" ? null : describeCron(text);
+  const invalid = text !== "" && description === null;
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "text",
+        value,
+        onChange: (event) => onChange(event.target.value),
+        placeholder: tr(
+          "fluidgrids.builder.scheduleRules.cronPlaceholder",
+          "eg. 0 15 * 1 sun"
+        ),
+        "aria-label": ariaLabel,
+        "aria-invalid": invalid,
+        spellCheck: false,
+        "data-testid": testId,
+        className: cn(className, "font-mono", invalid && "border-destructive")
+      }
+    ),
+    description && /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: "text-[11px] leading-snug text-muted-foreground",
+        "data-testid": testId ? `${testId}-description` : void 0,
+        children: description
+      }
+    ),
+    invalid && /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: "text-[11px] leading-snug text-destructive",
+        "data-testid": testId ? `${testId}-error` : void 0,
+        children: tr(
+          "fluidgrids.builder.scheduleRules.cronInvalid",
+          "Invalid cron expression"
+        )
+      }
+    )
+  ] });
+}
+var rowInput = "rounded-md border border-input bg-background px-2 py-1 text-xs outline-none focus:border-primary";
+var selectCx = "scheme-normal dark:scheme-dark [&_option]:bg-bg-surface [&_option]:text-text-primary";
+function isNumericOption(value) {
+  return /^-?\d+$/.test(value);
+}
+function optionValue(spec, raw) {
+  const numeric = (spec.options ?? []).every(isNumericOption);
+  return numeric && isNumericOption(raw) ? Number(raw) : raw;
+}
+function stringValue(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+function pad(value) {
+  return String(value ?? 0).padStart(2, "0");
+}
+function issueMessage(tr, issue) {
+  switch (issue) {
+    case "secondsRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.secondsRange",
+        "Seconds must be between 1 and 59"
+      );
+    case "minutesRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.minutesRange",
+        "Minutes must be between 1 and 59"
+      );
+    case "hoursRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.hoursRange",
+        "Hours must be between 1 and 23"
+      );
+    case "daysRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.daysRange",
+        "Days must be between 1 and 31"
+      );
+    case "weeksMin":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.weeksMin",
+        "Weeks must be at least 1"
+      );
+    case "monthsMin":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.monthsMin",
+        "Months must be at least 1"
+      );
+    case "dayOfMonthRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.dayOfMonthRange",
+        "Day of month must be between 1 and 31"
+      );
+    case "weekdaysRequired":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.weekdaysRequired",
+        "Select at least one weekday"
+      );
+    case "weekdaysRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.weekdaysRange",
+        "Weekdays must be Sunday to Saturday"
+      );
+    case "weekdaysRepeat":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.weekdaysRepeat",
+        "Weekdays must not repeat"
+      );
+    case "hourRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.hourRange",
+        "Hour must be between 0 and 23"
+      );
+    case "minuteRange":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.minuteRange",
+        "Minute must be between 0 and 59"
+      );
+    case "cronRequired":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.cronRequired",
+        "Enter a cron expression"
+      );
+    case "cronFieldCount":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.cronFieldCount",
+        "A cron expression has 5 or 6 fields"
+      );
+    case "cronInvalid":
+      return tr(
+        "fluidgrids.builder.scheduleRules.issue.cronInvalid",
+        "Invalid cron expression"
+      );
+  }
+}
+function ruleSummary(tr, rule, weekdayLabels = {}) {
+  const at = `${pad(rule.triggerAtHour)}:${pad(rule.triggerAtMinute)}`;
+  switch (rule.field) {
+    case "seconds":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.seconds",
+        "Every {{n}} seconds",
+        { n: rule.secondsInterval ?? 30 }
+      );
+    case "minutes":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.minutes",
+        "Every {{n}} minutes",
+        { n: rule.minutesInterval ?? 5 }
+      );
+    case "hours":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.hours",
+        "Every {{n}} hours at minute {{minute}}",
+        { n: rule.hoursInterval ?? 1, minute: pad(rule.triggerAtMinute) }
+      );
+    case "days":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.days",
+        "Every {{n}} days at {{time}}",
+        { n: rule.daysInterval ?? 1, time: at }
+      );
+    case "weeks": {
+      const days = (rule.triggerAtDay ?? []).map((day) => weekdayLabels[String(day)] ?? String(day)).join(", ");
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.weeks",
+        "Every {{n}} weeks on {{days}} at {{time}}",
+        { n: rule.weeksInterval ?? 1, days, time: at }
+      );
+    }
+    case "months":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.months",
+        "Every {{n}} months on day {{day}} at {{time}}",
+        {
+          n: rule.monthsInterval ?? 1,
+          day: rule.triggerAtDayOfMonth ?? 1,
+          time: at
+        }
+      );
+    case "cronExpression":
+      return tr(
+        "fluidgrids.builder.scheduleRules.summary.cron",
+        "Cron: {{expression}}",
+        { expression: rule.expression ?? "" }
+      );
+  }
+}
+function ScheduleRulesEditor({
+  rules,
+  ruleFields,
+  onChange,
+  testIdPrefix = "ndv"
+}) {
+  const tr = useTr();
+  const specs = paramsFromOperation({ name: "rule", input_fields: ruleFields });
+  const defaults = Object.fromEntries(
+    specs.map((spec) => [spec.name, spec.defaultValue])
+  );
+  const weekdayLabels = specs.find((spec) => spec.name === "triggerAtDay")?.optionLabels ?? {};
+  const setRow = (index, row) => {
+    const next = rules.slice();
+    next[index] = row;
+    onChange(next);
+  };
+  const patchRow = (index, name, value) => {
+    const row = { ...rules[index] ?? {} };
+    if (value === void 0 || value === "") delete row[name];
+    else row[name] = value;
+    setRow(
+      index,
+      name === "field" ? { ...normalizeScheduleRule({ field: value }) } : row
+    );
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex flex-col gap-2",
+      "data-testid": `${testIdPrefix}-schedule-rules`,
+      children: [
+        rules.map((row, index) => {
+          const rule = normalizeScheduleRule(asRecord(row) ?? {});
+          const issues = validateRule(rule);
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "rounded-md border border-border/70 bg-muted/10 p-2",
+              "data-testid": `${testIdPrefix}-schedule-rule-${index}`,
+              children: [
+                /* @__PURE__ */ jsxs("div", { className: "mb-1.5 flex items-center gap-1.5", children: [
+                  /* @__PURE__ */ jsxs("span", { className: "text-[10px] font-semibold text-muted-foreground", children: [
+                    index + 1,
+                    "."
+                  ] }),
+                  /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      className: "flex-1 truncate text-[11px] text-muted-foreground",
+                      "data-testid": `${testIdPrefix}-schedule-rule-summary`,
+                      children: ruleSummary(tr, rule, weekdayLabels)
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => onChange(rules.filter((_, i) => i !== index)),
+                      disabled: rules.length === 1,
+                      title: tr(
+                        "fluidgrids.builder.scheduleRules.removeRule",
+                        "Remove rule"
+                      ),
+                      "aria-label": tr(
+                        "fluidgrids.builder.scheduleRules.removeRule",
+                        "Remove rule"
+                      ),
+                      className: "rounded p-0.5 text-muted-foreground hover:text-[var(--color-status-error-text)] disabled:opacity-30",
+                      "data-testid": `${testIdPrefix}-schedule-rule-remove`,
+                      children: /* @__PURE__ */ jsx(Icon, { icon: "mynaui:trash", className: "size-3.5" })
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsx("div", { className: "grid gap-2 sm:grid-cols-2", children: specs.filter((spec) => isParamVisible(spec, row, defaults)).map((spec) => {
+                  const current = row[spec.name] ?? spec.defaultValue;
+                  const label = spec.label ?? spec.name;
+                  const testId = `${testIdPrefix}-schedule-rule-${index}-${spec.name}`;
+                  const isCron = spec.name === "expression" && rule.field === "cronExpression";
+                  return /* @__PURE__ */ jsxs(
+                    "label",
+                    {
+                      className: cn(
+                        "flex flex-col gap-1",
+                        (isCron || spec.type === "multiOptions") && "sm:col-span-2"
+                      ),
+                      children: [
+                        /* @__PURE__ */ jsxs("span", { className: "text-[11px] font-medium text-foreground", children: [
+                          label,
+                          spec.required && /* @__PURE__ */ jsx("span", { className: "ml-0.5 text-destructive", children: "*" })
+                        ] }),
+                        isCron ? /* @__PURE__ */ jsx(
+                          CronExpressionField,
+                          {
+                            value: stringValue(row[spec.name]),
+                            onChange: (value) => patchRow(index, spec.name, value),
+                            className: cn(rowInput, "w-full"),
+                            testId,
+                            ariaLabel: label
+                          }
+                        ) : spec.type === "multiOptions" && spec.options ? /* @__PURE__ */ jsx(
+                          "div",
+                          {
+                            className: "flex flex-wrap gap-x-3 gap-y-1",
+                            role: "group",
+                            "aria-label": label,
+                            "data-testid": testId,
+                            children: spec.options.map((option) => {
+                              const selected = Array.isArray(current) ? current.map(String) : [stringValue(current)];
+                              const checked = selected.includes(option);
+                              return /* @__PURE__ */ jsxs(
+                                "label",
+                                {
+                                  className: "flex cursor-pointer items-center gap-1 text-xs",
+                                  children: [
+                                    /* @__PURE__ */ jsx(
+                                      "input",
+                                      {
+                                        type: "checkbox",
+                                        checked,
+                                        onChange: (event) => {
+                                          const nextSet = new Set(selected);
+                                          if (event.target.checked)
+                                            nextSet.add(option);
+                                          else nextSet.delete(option);
+                                          const ordered = spec.options.filter(
+                                            (o) => nextSet.has(o)
+                                          );
+                                          patchRow(
+                                            index,
+                                            spec.name,
+                                            ordered.map((o) => optionValue(spec, o))
+                                          );
+                                        },
+                                        className: "size-3.5",
+                                        "data-testid": `${testId}-${option}`
+                                      }
+                                    ),
+                                    /* @__PURE__ */ jsx("span", { children: spec.optionLabels?.[option] ?? option })
+                                  ]
+                                },
+                                option
+                              );
+                            })
+                          }
+                        ) : spec.options && spec.options.length > 0 ? /* @__PURE__ */ jsx(
+                          "select",
+                          {
+                            value: stringValue(current),
+                            onChange: (event) => patchRow(
+                              index,
+                              spec.name,
+                              optionValue(spec, event.target.value)
+                            ),
+                            "aria-label": label,
+                            "data-testid": testId,
+                            className: cn(rowInput, selectCx),
+                            children: spec.options.map((option) => /* @__PURE__ */ jsx("option", { value: option, children: spec.optionLabels?.[option] ?? option }, option))
+                          }
+                        ) : spec.type === "integer" || spec.type === "number" ? /* @__PURE__ */ jsx(
+                          "input",
+                          {
+                            type: "number",
+                            step: spec.type === "integer" ? "1" : "any",
+                            value: stringValue(row[spec.name]),
+                            placeholder: spec.defaultValue !== void 0 ? String(spec.defaultValue) : void 0,
+                            onChange: (event) => patchRow(
+                              index,
+                              spec.name,
+                              coerceNumber(spec.type, event.target.value)
+                            ),
+                            "aria-label": label,
+                            "data-testid": testId,
+                            className: rowInput
+                          }
+                        ) : /* @__PURE__ */ jsx(
+                          "input",
+                          {
+                            type: "text",
+                            value: stringValue(row[spec.name]),
+                            onChange: (event) => patchRow(index, spec.name, event.target.value),
+                            "aria-label": label,
+                            "data-testid": testId,
+                            className: rowInput
+                          }
+                        ),
+                        spec.description && /* @__PURE__ */ jsx("span", { className: "text-[10px] leading-snug text-muted-foreground", children: spec.description })
+                      ]
+                    },
+                    spec.name
+                  );
+                }) }),
+                issues.length > 0 && /* @__PURE__ */ jsx(
+                  "ul",
+                  {
+                    className: "mt-1.5 flex flex-col gap-0.5 text-[11px] leading-snug text-destructive",
+                    "data-testid": `${testIdPrefix}-schedule-rule-${index}-issues`,
+                    children: issues.map((issue) => /* @__PURE__ */ jsx("li", { children: issueMessage(tr, issue) }, issue))
+                  }
+                )
+              ]
+            },
+            index
+          );
+        }),
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => onChange([...rules, { ...defaultScheduleRule() }]),
+            className: "flex w-fit items-center gap-1 text-[11px] font-medium text-primary hover:underline",
+            "data-testid": `${testIdPrefix}-schedule-add-rule`,
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "basil:add-solid", className: "size-3.5" }),
+              " ",
+              tr("fluidgrids.builder.scheduleRules.addRule", "Add Rule")
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var rowInput2 = "rounded-md border border-input bg-background px-2 py-1 text-xs text-foreground outline-none focus:border-primary";
+function serialiseRows(rows, previous) {
+  const rules = rows.map(ruleFromRow);
+  return Array.isArray(previous) ? rules : JSON.stringify(rules, null, 2);
+}
+function textOf(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  return JSON.stringify(value, null, 2);
+}
+function AssertRulesEditor({
+  value,
+  onChange,
+  testIdPrefix = "ndv"
+}) {
+  const tr = useTr();
+  const initial = readAssertRulesSetting(value);
+  const [rows, setRows] = useState(
+    () => rowsFromRules(initial ?? [])
+  );
+  const [jsonView, setJsonView] = useState(initial === null);
+  const [jsonText, setJsonText] = useState(() => textOf(value));
+  const written = useRef(value);
+  useEffect(() => {
+    if (value === written.current) return;
+    written.current = value;
+    const parsed = readAssertRulesSetting(value);
+    setJsonText(textOf(value));
+    if (parsed === null) {
+      setJsonView(true);
+    } else {
+      setRows(rowsFromRules(parsed));
+    }
+  }, [value]);
+  const write = (next) => {
+    written.current = next;
+    onChange(next);
+  };
+  const setRowList = (next) => {
+    setRows(next);
+    const serialised = serialiseRows(next, value);
+    setJsonText(textOf(serialised));
+    write(serialised);
+  };
+  const setRow = (index, patch) => {
+    const next = rows.slice();
+    const current = next[index];
+    if (!current) return;
+    next[index] = { ...current, ...patch };
+    setRowList(next);
+  };
+  const parsedJson = jsonView ? readAssertRulesSetting(jsonText) : null;
+  const check = normaliseAssertRules(
+    jsonView ? parsedJson ?? [] : rows.map(ruleFromRow)
+  );
+  const problem = jsonView && parsedJson === null ? {
+    key: "fluidgrids.builder.assertRules.invalidJson",
+    fallback: "The rules must be a JSON array."
+  } : "problem" in check ? describeAssertRuleProblem(check.problem) : null;
+  const toggleView = () => {
+    if (jsonView) {
+      const parsed = readAssertRulesSetting(jsonText);
+      if (parsed === null) return;
+      setRows(rowsFromRules(parsed));
+      setJsonView(false);
+    } else {
+      setJsonText(textOf(serialiseRows(rows, value)));
+      setJsonView(true);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex flex-col gap-2",
+      "data-testid": `${testIdPrefix}-assert-rules`,
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "flex items-center justify-end", children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: toggleView,
+            disabled: jsonView && parsedJson === null,
+            className: "text-[11px] text-primary hover:underline disabled:opacity-50",
+            "data-testid": `${testIdPrefix}-assert-rules-view`,
+            children: jsonView ? tr("fluidgrids.builder.assertRules.showRows", "Edit as rows") : tr("fluidgrids.builder.assertRules.showJson", "Edit as JSON")
+          }
+        ) }),
+        jsonView ? /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            value: jsonText,
+            rows: 8,
+            spellCheck: false,
+            "aria-label": tr(
+              "fluidgrids.builder.assertRules.jsonLabel",
+              "Rules (JSON array)"
+            ),
+            onChange: (event) => {
+              setJsonText(event.target.value);
+              write(
+                Array.isArray(value) ? readAssertRulesSetting(event.target.value) ?? value : event.target.value
+              );
+            },
+            className: cn(rowInput2, "w-full font-mono"),
+            "data-testid": `${testIdPrefix}-assert-rules-json`
+          }
+        ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          rows.length === 0 && /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: tr(
+            "fluidgrids.builder.assertRules.empty",
+            "Add at least one rule."
+          ) }),
+          rows.map((row, index) => {
+            const operand = operatorSpec(row.operator)?.operand ?? "expected";
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: "rounded-md border border-border p-2",
+                "data-testid": `${testIdPrefix}-assert-rule-${index}`,
+                children: [
+                  /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+                    /* @__PURE__ */ jsxs("span", { className: "text-[10px] font-semibold text-muted-foreground", children: [
+                      index + 1,
+                      "."
+                    ] }),
+                    /* @__PURE__ */ jsx(
+                      "input",
+                      {
+                        type: "text",
+                        value: row.path,
+                        placeholder: tr(
+                          "fluidgrids.builder.assertRules.pathPlaceholder",
+                          "path, e.g. body.items.0.id (empty = whole input)"
+                        ),
+                        "aria-label": tr(
+                          "fluidgrids.builder.assertRules.path",
+                          "Path"
+                        ),
+                        onChange: (event) => setRow(index, { path: event.target.value }),
+                        className: cn(rowInput2, "min-w-0 flex-1 font-mono")
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      "select",
+                      {
+                        value: row.operator,
+                        "aria-label": tr(
+                          "fluidgrids.builder.assertRules.operator",
+                          "Operator"
+                        ),
+                        onChange: (event) => setRow(index, { operator: event.target.value }),
+                        className: rowInput2,
+                        children: ASSERT_OPERATORS.map((spec) => /* @__PURE__ */ jsx("option", { value: spec.wire, children: tr(
+                          `fluidgrids.builder.assertRules.op.${spec.wire}`,
+                          spec.label
+                        ) }, spec.wire))
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      "button",
+                      {
+                        type: "button",
+                        onClick: () => setRowList(rows.filter((_, i) => i !== index)),
+                        title: tr(
+                          "fluidgrids.builder.assertRules.remove",
+                          "Remove rule"
+                        ),
+                        className: "rounded p-0.5 text-muted-foreground hover:text-[var(--color-status-error-text)]",
+                        children: /* @__PURE__ */ jsx(X, { className: "size-4" })
+                      }
+                    )
+                  ] }),
+                  operand === "expected" && /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      type: "text",
+                      value: row.expected,
+                      placeholder: row.operator === "matches" ? tr(
+                        "fluidgrids.builder.assertRules.regexPlaceholder",
+                        "regular expression, e.g. ^ord_"
+                      ) : tr(
+                        "fluidgrids.builder.assertRules.expectedPlaceholder",
+                        'expected value as JSON, e.g. 42, "ok" or {"a": 1}'
+                      ),
+                      "aria-label": tr(
+                        "fluidgrids.builder.assertRules.expected",
+                        "Expected"
+                      ),
+                      onChange: (event) => setRow(index, { expected: event.target.value }),
+                      className: cn(rowInput2, "mt-1.5 w-full font-mono")
+                    }
+                  ),
+                  operand === "range" && /* @__PURE__ */ jsxs("div", { className: "mt-1.5 flex gap-1.5", children: [
+                    /* @__PURE__ */ jsx(
+                      "input",
+                      {
+                        type: "text",
+                        inputMode: "decimal",
+                        value: row.min,
+                        placeholder: tr(
+                          "fluidgrids.builder.assertRules.min",
+                          "min"
+                        ),
+                        "aria-label": tr(
+                          "fluidgrids.builder.assertRules.min",
+                          "min"
+                        ),
+                        onChange: (event) => setRow(index, { min: event.target.value }),
+                        className: cn(rowInput2, "w-full")
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      "input",
+                      {
+                        type: "text",
+                        inputMode: "decimal",
+                        value: row.max,
+                        placeholder: tr(
+                          "fluidgrids.builder.assertRules.max",
+                          "max"
+                        ),
+                        "aria-label": tr(
+                          "fluidgrids.builder.assertRules.max",
+                          "max"
+                        ),
+                        onChange: (event) => setRow(index, { max: event.target.value }),
+                        className: cn(rowInput2, "w-full")
+                      }
+                    )
+                  ] }),
+                  /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      type: "text",
+                      value: row.message,
+                      placeholder: tr(
+                        "fluidgrids.builder.assertRules.messagePlaceholder",
+                        "message when it does not hold (optional)"
+                      ),
+                      "aria-label": tr(
+                        "fluidgrids.builder.assertRules.message",
+                        "Message"
+                      ),
+                      onChange: (event) => setRow(index, { message: event.target.value }),
+                      className: cn(rowInput2, "mt-1.5 w-full")
+                    }
+                  )
+                ]
+              },
+              index
+            );
+          }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => setRowList([...rows, emptyAssertRuleRow()]),
+              className: "flex items-center gap-1 self-start text-xs text-primary hover:underline",
+              "data-testid": `${testIdPrefix}-assert-rule-add`,
+              children: [
+                /* @__PURE__ */ jsx(Plus, { className: "size-3.5" }),
+                tr("fluidgrids.builder.assertRules.add", "Add rule")
+              ]
+            }
+          )
+        ] }),
+        problem && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-[11px] text-[var(--color-status-error-text)]",
+            role: "alert",
+            "data-testid": `${testIdPrefix}-assert-rules-problem`,
+            children: tr(problem.key, problem.fallback)
+          }
+        )
+      ]
+    }
+  );
+}
+function formatRunInZone(date, timezone) {
+  try {
+    return new Intl.DateTimeFormat(void 0, {
+      timeZone: timezone || "UTC",
+      dateStyle: "medium",
+      timeStyle: "medium"
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function ScheduleNextRuns({
+  preview,
+  timezone,
+  testId = "ndv-schedule-next-runs"
+}) {
+  const tr = useTr();
+  if (!preview.previewed && !preview.loading) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "rounded-md border border-border/70 bg-muted/10 p-2",
+      "data-testid": testId,
+      "aria-busy": preview.loading,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "mb-1 flex items-center gap-1.5 text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:calendar-clock-outline", className: "size-3.5" }),
+          tr("fluidgrids.builder.scheduleRules.nextRunsTitle", "Next runs"),
+          preview.loading && /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:loading",
+              className: "ml-auto size-3.5 animate-spin",
+              "aria-hidden": true
+            }
+          )
+        ] }),
+        preview.error ? /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-[11px] leading-snug text-destructive",
+            "data-testid": `${testId}-error`,
+            children: tr(
+              "fluidgrids.builder.scheduleRules.nextRunsError",
+              "The scheduler could not preview this schedule: {{message}}",
+              { message: preview.error.message }
+            )
+          }
+        ) : preview.runs.length === 0 ? !preview.loading && /* @__PURE__ */ jsx("p", { className: "text-[11px] leading-snug text-muted-foreground", children: tr(
+          "fluidgrids.builder.scheduleRules.nextRunsEmpty",
+          "No upcoming runs for these rules."
+        ) }) : /* @__PURE__ */ jsx("ol", { className: "flex flex-col gap-0.5 text-xs text-foreground", children: preview.runs.map((run) => /* @__PURE__ */ jsxs(
+          "li",
+          {
+            className: "flex items-center gap-2",
+            "data-testid": `${testId}-item`,
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "\u2022" }),
+              /* @__PURE__ */ jsx("time", { dateTime: run.toISOString(), children: formatRunInZone(run, timezone) })
+            ]
+          },
+          run.toISOString()
+        )) })
+      ]
+    }
+  );
+}
+var SCHEDULE_PREVIEW_COUNT = 5;
+var DEBOUNCE_MS = 400;
+var IDLE = {
+  runs: [],
+  loading: false,
+  error: null,
+  previewed: false
+};
+function schedulePreviewVariables(rules, timezone, workflowKey, nodeId, now = /* @__PURE__ */ new Date()) {
+  const variables = [];
+  rules.forEach((raw, index) => {
+    const rule = normalizeScheduleRule(raw);
+    if (validateRule(rule).length > 0) return;
+    const spec = ruleToScheduleSpec(
+      rule,
+      scheduleNodeKey(workflowKey, nodeId, index)
+    );
+    variables.push({
+      scheduleType: spec.scheduleType === "CRON" ? "CRON" /* Cron */ : "RRULE" /* Rrule */,
+      ...spec.scheduleType === "CRON" ? { cronExpression: spec.cronExpression } : { rrule: spec.rrule, startDate: now.toISOString() },
+      timezone: timezone || "UTC",
+      count: SCHEDULE_PREVIEW_COUNT
+    });
+  });
+  return variables;
+}
+function mergePreviewRuns(lists, limit = SCHEDULE_PREVIEW_COUNT) {
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (const iso of lists.flat()) {
+    const date = new Date(iso);
+    const time = date.getTime();
+    if (Number.isNaN(time) || seen.has(time)) continue;
+    seen.add(time);
+    runs.push(date);
+  }
+  return runs.sort((a, b) => a.getTime() - b.getTime()).slice(0, limit);
+}
+async function requestSchedulePreview(client, variables) {
+  const results = await Promise.all(
+    variables.map(
+      (vars) => client.query({
+        query: PreviewScheduleDocument,
+        variables: vars,
+        fetchPolicy: "network-only"
+      })
+    )
+  );
+  return mergePreviewRuns(
+    results.map((result) => result.data?.previewSchedule.nextExecutions ?? [])
+  );
+}
+function useSchedulePreview(rules, timezone, workflowKey, nodeId) {
+  const [state, setState] = useState(IDLE);
+  const context = useContext(FluidGridsContext);
+  const client = context?.workspaceClient ?? getFluidGridsClientSafe();
+  const requestKey = JSON.stringify([rules, timezone, workflowKey, nodeId]);
+  const latest = useRef(0);
+  useEffect(() => {
+    if (!nodeId || !client) {
+      setState(IDLE);
+      return;
+    }
+    const variables = schedulePreviewVariables(
+      rules,
+      timezone,
+      workflowKey,
+      nodeId
+    );
+    if (variables.length === 0) {
+      setState(IDLE);
+      return;
+    }
+    const ticket = ++latest.current;
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    const timer = setTimeout(() => {
+      requestSchedulePreview(client, variables).then((runs) => {
+        if (latest.current !== ticket) return;
+        setState({ runs, loading: false, error: null, previewed: true });
+      }).catch((error) => {
+        if (latest.current !== ticket) return;
+        setState({
+          runs: [],
+          loading: false,
+          error: error instanceof Error ? error : new Error(String(error)),
+          previewed: true
+        });
+      });
+    }, DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [requestKey, client]);
+  return state;
+}
+var TIMEZONE_ALIASES = {
+  "Africa/Asmera": "Africa/Asmara",
+  "America/Buenos_Aires": "America/Argentina/Buenos_Aires",
+  "America/Catamarca": "America/Argentina/Catamarca",
+  "America/Cordoba": "America/Argentina/Cordoba",
+  "America/Godthab": "America/Nuuk",
+  "America/Indianapolis": "America/Indiana/Indianapolis",
+  "America/Jujuy": "America/Argentina/Jujuy",
+  "America/Louisville": "America/Kentucky/Louisville",
+  "America/Mendoza": "America/Argentina/Mendoza",
+  "Asia/Ashkhabad": "Asia/Ashgabat",
+  "Asia/Calcutta": "Asia/Kolkata",
+  "Asia/Dacca": "Asia/Dhaka",
+  "Asia/Katmandu": "Asia/Kathmandu",
+  "Asia/Macao": "Asia/Macau",
+  "Asia/Rangoon": "Asia/Yangon",
+  "Asia/Saigon": "Asia/Ho_Chi_Minh",
+  "Asia/Thimbu": "Asia/Thimphu",
+  "Asia/Ujung_Pandang": "Asia/Makassar",
+  "Asia/Ulan_Bator": "Asia/Ulaanbaatar",
+  "Atlantic/Faeroe": "Atlantic/Faroe",
+  "Europe/Kiev": "Europe/Kyiv",
+  "Pacific/Enderbury": "Pacific/Kanton",
+  "Pacific/Ponape": "Pacific/Pohnpei",
+  "Pacific/Truk": "Pacific/Chuuk"
+};
+var LEGACY_IDS_BY_ZONE = (() => {
+  const byZone = /* @__PURE__ */ new Map();
+  for (const [legacy, current] of Object.entries(TIMEZONE_ALIASES)) {
+    byZone.set(current, [...byZone.get(current) ?? [], legacy]);
+  }
+  return byZone;
+})();
+function isKnownTimezone(zone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function canonicalTimezone(zone) {
+  const current = TIMEZONE_ALIASES[zone];
+  if (current === void 0) return zone;
+  return isKnownTimezone(current) ? current : zone;
+}
+function supportedTimezones() {
+  let zones = [];
+  try {
+    zones = Intl.supportedValuesOf("timeZone");
+  } catch {
+    zones = [];
+  }
+  const current = new Set(zones.map(canonicalTimezone));
+  current.delete("UTC");
+  return ["UTC", ...[...current].sort()];
+}
+function timezoneOffsetLabel(zone, at = /* @__PURE__ */ new Date()) {
+  try {
+    const part = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      timeZoneName: "longOffset"
+    }).formatToParts(at).find((p) => p.type === "timeZoneName")?.value;
+    if (!part) return "";
+    const offset = part === "GMT" ? "+00:00" : part.replace(/^GMT/, "");
+    return `(UTC${offset})`;
+  } catch {
+    return "";
+  }
+}
+function filterTimezones(zones, query) {
+  const needle = query.trim().toLowerCase().replace(/\s+/g, "_");
+  if (needle === "") return [...zones];
+  const matches = (id) => id.toLowerCase().includes(needle);
+  return zones.filter(
+    (zone) => matches(zone) || (LEGACY_IDS_BY_ZONE.get(zone) ?? []).some(matches)
+  );
+}
+function TimezoneSelect({
+  value,
+  onChange,
+  className,
+  testId
+}) {
+  const tr = useTr();
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const zones = useMemo(supportedTimezones, []);
+  const matches = useMemo(() => filterTimezones(zones, query), [zones, query]);
+  const current = value || "UTC";
+  const offset = timezoneOffsetLabel(current);
+  const select = (zone) => {
+    onChange(zone);
+    setOpen(false);
+    setQuery("");
+  };
+  return /* @__PURE__ */ jsxs(
+    Popover,
+    {
+      open,
+      onOpenChange: (next) => {
+        setOpen(next);
+        if (!next) setQuery("");
+      },
+      children: [
+        /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            role: "combobox",
+            "aria-expanded": open,
+            "aria-haspopup": "listbox",
+            "aria-label": tr(
+              "fluidgrids.builder.scheduleRules.timezoneLabel",
+              "Timezone"
+            ),
+            "data-testid": testId,
+            className: cn(
+              className,
+              "flex items-center justify-between gap-2 text-left"
+            ),
+            children: [
+              /* @__PURE__ */ jsxs("span", { className: "truncate", children: [
+                current,
+                offset && /* @__PURE__ */ jsx("span", { className: "ml-1 text-muted-foreground", children: offset })
+              ] }),
+              /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: "mdi:unfold-more-horizontal",
+                  className: "size-4 shrink-0 text-muted-foreground"
+                }
+              )
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(
+          PopoverContent,
+          {
+            align: "start",
+            className: "w-[var(--radix-popover-trigger-width)] min-w-64 p-0",
+            style: { zIndex: NDV_OVERLAY_Z_INDEX },
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 border-b border-border px-3", children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:magnify",
+                    className: "size-4 shrink-0 text-muted-foreground"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "text",
+                    value: query,
+                    onChange: (event) => setQuery(event.target.value),
+                    onKeyDown: (event) => {
+                      if (event.key === "Enter" && matches[0]) {
+                        event.preventDefault();
+                        select(matches[0]);
+                      }
+                    },
+                    placeholder: tr(
+                      "fluidgrids.builder.scheduleRules.timezoneSearch",
+                      "Search timezones\u2026"
+                    ),
+                    "aria-label": tr(
+                      "fluidgrids.builder.scheduleRules.timezoneSearch",
+                      "Search timezones\u2026"
+                    ),
+                    autoFocus: true,
+                    "data-testid": testId ? `${testId}-search` : void 0,
+                    className: "h-9 flex-1 border-0 bg-transparent text-sm outline-none placeholder:text-muted-foreground"
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs(
+                "ul",
+                {
+                  role: "listbox",
+                  "aria-label": tr(
+                    "fluidgrids.builder.scheduleRules.timezoneLabel",
+                    "Timezone"
+                  ),
+                  className: "max-h-64 overflow-y-auto py-1",
+                  children: [
+                    matches.length === 0 && /* @__PURE__ */ jsx("li", { className: "py-4 text-center text-xs text-muted-foreground", children: tr(
+                      "fluidgrids.builder.scheduleRules.timezoneEmpty",
+                      "No timezone matches"
+                    ) }),
+                    matches.slice(0, 400).map((zone) => /* @__PURE__ */ jsx("li", { role: "option", "aria-selected": zone === current, children: /* @__PURE__ */ jsxs(
+                      "button",
+                      {
+                        type: "button",
+                        onClick: () => select(zone),
+                        "data-testid": testId ? `${testId}-option` : void 0,
+                        "data-value": zone,
+                        className: cn(
+                          "flex w-full cursor-pointer items-center justify-between gap-2 px-3 py-1.5 text-left text-sm hover:bg-muted",
+                          zone === current && "bg-muted/60"
+                        ),
+                        children: [
+                          /* @__PURE__ */ jsx("span", { className: "truncate", children: zone }),
+                          /* @__PURE__ */ jsx("span", { className: "shrink-0 text-[11px] text-muted-foreground", children: timezoneOffsetLabel(zone) }),
+                          zone === current && /* @__PURE__ */ jsx(Icon, { icon: "mdi:check", className: "size-3.5 shrink-0" })
+                        ]
+                      }
+                    ) }, zone))
+                  ]
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var PLATFORM_EVENT_MODULE_FIELD = "platform-event-module";
+var PLATFORM_EVENT_RECORD_TYPE_FIELD = "platform-event-record-type";
+var PLATFORM_EVENT_SOURCES_QUERY = gql`
+  query PlatformEventSources {
+    platformEventSources {
+      module
+      recordTypes {
+        name
+        actions
+      }
+    }
+  }
+`;
+var CACHE_TTL_MS2 = 3 * 60 * 1e3;
+var caches = /* @__PURE__ */ new WeakMap();
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPlatformEventSources(data) {
+  const list = isRecord2(data) ? data.platformEventSources : void 0;
+  if (!Array.isArray(list)) return [];
+  const sources = [];
+  for (const item of list) {
+    if (!isRecord2(item) || typeof item.module !== "string") continue;
+    const recordTypes = Array.isArray(item.recordTypes) ? item.recordTypes.flatMap(
+      (type) => isRecord2(type) && typeof type.name === "string" ? [
+        {
+          name: type.name,
+          actions: Array.isArray(type.actions) ? type.actions.filter(
+            (action) => typeof action === "string"
+          ) : []
+        }
+      ] : []
+    ) : [];
+    sources.push({ module: item.module, recordTypes });
+  }
+  return sources;
+}
+function fetchPlatformEventSources(getClient = getFluidGridsClient, now = Date.now) {
+  const client = getClient();
+  const cached = caches.get(client);
+  if (cached && cached.expiresAt > now()) return cached.sources;
+  const sources = client.query({ query: PLATFORM_EVENT_SOURCES_QUERY, fetchPolicy: "network-only" }).then((result) => readPlatformEventSources(result.data));
+  const entry = { sources, expiresAt: now() + CACHE_TTL_MS2 };
+  caches.set(client, entry);
+  sources.catch(() => {
+    if (caches.get(client) === entry) caches.delete(client);
+  });
+  return sources;
+}
+function recordTypesOf(sources, module) {
+  const wanted = module.trim().toLowerCase();
+  return sources.find((source) => source.module === wanted)?.recordTypes ?? [];
+}
+function filterNames(names, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return [...names];
+  return names.filter((name) => name.toLowerCase().includes(needle));
+}
+function isTypedName(kind, text) {
+  return kind === "module" ? /^[a-z][a-z0-9-]{0,127}$/.test(text.trim().toLowerCase()) : /^[A-Z]\w{0,127}$/.test(text.trim());
+}
+function usePlatformEventSources() {
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    let cancelled = false;
+    fetchPlatformEventSources().then((sources) => {
+      if (!cancelled) setState({ status: "ready", sources });
+    }).catch(() => {
+      if (!cancelled) setState({ status: "failed" });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return state;
+}
+function PlatformEventSourceSelect({
+  kind,
+  value,
+  module = "",
+  required = false,
+  onChange,
+  className,
+  testId,
+  label
+}) {
+  const tr = useTr();
+  const state = usePlatformEventSources();
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const names = useMemo(() => {
+    if (state.status !== "ready") return [];
+    return kind === "module" ? state.sources.map((source) => source.module) : recordTypesOf(state.sources, module).map((type) => type.name);
+  }, [state, kind, module]);
+  const actionsByType = useMemo(() => {
+    if (state.status !== "ready" || kind !== "recordType") return null;
+    return new Map(
+      recordTypesOf(state.sources, module).map((type) => [
+        type.name,
+        type.actions
+      ])
+    );
+  }, [state, kind, module]);
+  const matches = useMemo(() => filterNames(names, query), [names, query]);
+  const typed = query.trim();
+  const canUseTyped = typed !== "" && isTypedName(kind, typed) && !names.includes(kind === "module" ? typed.toLowerCase() : typed);
+  const fieldLabel = label ?? (kind === "module" ? tr("fluidgrids.builder.platformEventSource.moduleLabel", "Module") : tr(
+    "fluidgrids.builder.platformEventSource.recordTypeLabel",
+    "Record Type"
+  ));
+  const emptyText = kind === "module" ? tr(
+    "fluidgrids.builder.platformEventSource.modulePlaceholder",
+    "Select a module"
+  ) : required ? tr(
+    "fluidgrids.builder.platformEventSource.recordTypePlaceholder",
+    "Select a record type"
+  ) : tr(
+    "fluidgrids.builder.platformEventSource.anyRecordType",
+    "Any record type"
+  );
+  const select = (next) => {
+    onChange(next);
+    setOpen(false);
+    setQuery("");
+  };
+  const notice = state.status === "failed" ? tr(
+    "fluidgrids.builder.platformEventSource.loadFailed",
+    "The list could not be loaded. Type the name instead."
+  ) : kind === "recordType" && !module.trim() ? tr(
+    "fluidgrids.builder.platformEventSource.pickModuleFirst",
+    "Pick a module first to see its record types."
+  ) : null;
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+    /* @__PURE__ */ jsxs(
+      Popover,
+      {
+        open,
+        onOpenChange: (next) => {
+          setOpen(next);
+          if (!next) setQuery("");
+        },
+        children: [
+          /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              role: "combobox",
+              "aria-expanded": open,
+              "aria-haspopup": "listbox",
+              "aria-label": fieldLabel,
+              "data-testid": testId,
+              className: cn(
+                className,
+                "flex items-center justify-between gap-2 text-left"
+              ),
+              children: [
+                /* @__PURE__ */ jsx("span", { className: cn("truncate", !value && "text-muted-foreground"), children: value || emptyText }),
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:unfold-more-horizontal",
+                    className: "size-4 shrink-0 text-muted-foreground"
+                  }
+                )
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsxs(
+            PopoverContent,
+            {
+              align: "start",
+              className: "w-[var(--radix-popover-trigger-width)] min-w-64 p-0",
+              style: { zIndex: NDV_OVERLAY_Z_INDEX },
+              children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 border-b border-border px-3", children: [
+                  /* @__PURE__ */ jsx(
+                    Icon,
+                    {
+                      icon: "mdi:magnify",
+                      className: "size-4 shrink-0 text-muted-foreground"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      type: "text",
+                      value: query,
+                      onChange: (event) => setQuery(event.target.value),
+                      onKeyDown: (event) => {
+                        if (event.key !== "Enter") return;
+                        event.preventDefault();
+                        if (matches[0]) select(matches[0]);
+                        else if (canUseTyped)
+                          select(kind === "module" ? typed.toLowerCase() : typed);
+                      },
+                      placeholder: tr(
+                        "fluidgrids.builder.platformEventSource.search",
+                        "Search or type a name\u2026"
+                      ),
+                      "aria-label": tr(
+                        "fluidgrids.builder.platformEventSource.search",
+                        "Search or type a name\u2026"
+                      ),
+                      autoFocus: true,
+                      "data-testid": testId ? `${testId}-search` : void 0,
+                      className: "h-9 flex-1 border-0 bg-transparent text-sm outline-none placeholder:text-muted-foreground"
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxs(
+                  "ul",
+                  {
+                    role: "listbox",
+                    "aria-label": fieldLabel,
+                    className: "max-h-64 overflow-y-auto py-1",
+                    children: [
+                      kind === "recordType" && !required && /* @__PURE__ */ jsx("li", { role: "option", "aria-selected": value === "", children: /* @__PURE__ */ jsx(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: () => select(""),
+                          "data-testid": testId ? `${testId}-any` : void 0,
+                          className: cn(
+                            "flex w-full cursor-pointer items-center justify-between gap-2 px-3 py-1.5 text-left text-sm italic text-muted-foreground hover:bg-muted",
+                            value === "" && "bg-muted/60"
+                          ),
+                          children: tr(
+                            "fluidgrids.builder.platformEventSource.anyRecordType",
+                            "Any record type"
+                          )
+                        }
+                      ) }),
+                      state.status === "loading" && /* @__PURE__ */ jsx("li", { className: "py-3 text-center text-xs text-muted-foreground", children: tr(
+                        "fluidgrids.builder.platformEventSource.loading",
+                        "Loading\u2026"
+                      ) }),
+                      state.status === "ready" && matches.length === 0 && !canUseTyped && /* @__PURE__ */ jsx("li", { className: "py-3 text-center text-xs text-muted-foreground", children: tr(
+                        "fluidgrids.builder.platformEventSource.empty",
+                        "Nothing matches. Type the full name to use it."
+                      ) }),
+                      matches.map((name) => {
+                        const actions = actionsByType?.get(name);
+                        return /* @__PURE__ */ jsx("li", { role: "option", "aria-selected": name === value, children: /* @__PURE__ */ jsxs(
+                          "button",
+                          {
+                            type: "button",
+                            onClick: () => select(name),
+                            "data-testid": testId ? `${testId}-option` : void 0,
+                            "data-value": name,
+                            className: cn(
+                              "flex w-full cursor-pointer items-center justify-between gap-2 px-3 py-1.5 text-left text-sm hover:bg-muted",
+                              name === value && "bg-muted/60"
+                            ),
+                            children: [
+                              /* @__PURE__ */ jsx("span", { className: "truncate font-mono text-xs", children: name }),
+                              actions && actions.length > 0 && /* @__PURE__ */ jsx("span", { className: "shrink-0 text-[11px] text-muted-foreground", children: actions.join(", ") }),
+                              name === value && /* @__PURE__ */ jsx(Icon, { icon: "mdi:check", className: "size-3.5 shrink-0" })
+                            ]
+                          }
+                        ) }, name);
+                      }),
+                      canUseTyped && /* @__PURE__ */ jsx("li", { role: "option", "aria-selected": false, children: /* @__PURE__ */ jsxs(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: () => select(kind === "module" ? typed.toLowerCase() : typed),
+                          "data-testid": testId ? `${testId}-typed` : void 0,
+                          className: "flex w-full cursor-pointer items-center gap-2 px-3 py-1.5 text-left text-sm hover:bg-muted",
+                          children: [
+                            /* @__PURE__ */ jsx(Icon, { icon: "mdi:keyboard-outline", className: "size-3.5" }),
+                            /* @__PURE__ */ jsxs("span", { children: [
+                              tr(
+                                "fluidgrids.builder.platformEventSource.useTyped",
+                                "Use"
+                              ),
+                              " ",
+                              /* @__PURE__ */ jsx("span", { className: "font-mono text-xs", children: kind === "module" ? typed.toLowerCase() : typed })
+                            ] })
+                          ]
+                        }
+                      ) })
+                    ]
+                  }
+                )
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    notice && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: notice })
+  ] });
+}
+var SECTION_LABEL3 = "text-[11px] font-semibold uppercase tracking-[0.12em] text-muted-foreground";
+function NodeParamsForm({
+  config,
+  nodeType,
+  testIdPrefix = "ndv"
+}) {
+  const formId = useId();
+  const tr = useTr();
+  const edges = useFlowStore((state) => state.workflow.edges);
+  const loopStatus = (nodeType === "internal:loop" || nodeType === "loop") && config.node ? loopReturnStatus(
+    config.node.id,
+    edges,
+    typeof config.argsState.loopHandle === "string" ? config.argsState.loopHandle : "loop"
+  ) : void 0;
+  const {
+    params,
+    argsState,
+    mapping,
+    pickerFields,
+    connectionAdapters,
+    selectedConnections,
+    isWebhookTrigger,
+    isFormTrigger,
+    formUrl,
+    triggerUrlError,
+    isWebhookWait,
+    webhookUrl,
+    webhookUrlLoading,
+    currentEdge,
+    modeByField,
+    dragField,
+    setDragField,
+    writeFixed,
+    writeMapping,
+    handleConnectionsChange,
+    toggleMode,
+    handleDropOnParam
+  } = config;
+  const loadOptionsConnectionId = (() => {
+    const adapterNames = new Set(connectionAdapters.map((a) => a.name));
+    return selectedConnections.find((c) => adapterNames.has(c.adapter))?.connectionId ?? selectedConnections[0]?.connectionId;
+  })();
+  const parameterDefaults = Object.fromEntries(
+    params.map((parameter) => [parameter.name, parameter.defaultValue])
+  );
+  const visibleParams = params.filter(
+    (p) => mapping[p.name] !== void 0 || isParamVisible(p, argsState, parameterDefaults)
+  );
+  const scheduleParam = params.find((p) => p.type === "schedule-rules");
+  const scheduleIsLegacy = Boolean(scheduleParam) && isLegacyScheduleState(argsState);
+  const scheduleRules = scheduleParam ? Array.isArray(argsState[scheduleParam.name]) ? argsState[scheduleParam.name] : normalizeScheduleState(argsState).rules.map((rule) => ({ ...rule })) : [];
+  const scheduleTimezone = typeof argsState.timezone === "string" && argsState.timezone.trim() ? argsState.timezone : "UTC";
+  const workflowKey = useFlowStore((s) => s.workflow.workflowKey);
+  const schedulePreview = useSchedulePreview(
+    scheduleRules,
+    scheduleTimezone,
+    workflowKey || void 0,
+    scheduleParam ? config.node?.id : void 0
+  );
+  const nodeVersion = (() => {
+    const data = asRecord(config.node?.data);
+    const nodeData = asRecord(data?.nodeData);
+    const fromManifest = nodeData?.version;
+    const fromData = data?.version;
+    if (typeof fromManifest === "string") return fromManifest;
+    if (typeof fromData === "string") return fromData;
+    return "1.0.0";
+  })();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    loopStatus === "missing-return" && /* @__PURE__ */ jsx(
+      "p",
+      {
+        role: "status",
+        "data-testid": `${testIdPrefix}-loop-return-hint`,
+        className: "text-xs text-muted-foreground",
+        children: tr(
+          "fluidgrids.builder.loopPanel.missingReturn",
+          "No Loop Body return path is connected. Only the first batch will run unless you connect a body node back to this Loop. An intentional early exit is allowed; Done does not run on that exit."
+        )
+      }
+    ),
+    loopStatus === "conditional-exit" && /* @__PURE__ */ jsx(
+      "p",
+      {
+        role: "status",
+        "data-testid": `${testIdPrefix}-loop-return-hint`,
+        className: "text-xs text-muted-foreground",
+        children: tr(
+          "fluidgrids.builder.loopPanel.conditionalExit",
+          "A return path and a possible early exit are connected. Conditional exits are allowed; Done runs only when the Loop finishes or reaches its safety limit."
+        )
+      }
+    ),
+    isWebhookTrigger && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        WebhookUrlField,
+        {
+          webhookUrl,
+          loading: webhookUrlLoading
+        }
+      ),
+      /* @__PURE__ */ jsx(WebhookTestListenerField, { nodeId: config.node?.id })
+    ] }),
+    isFormTrigger && /* @__PURE__ */ jsx(
+      FormUrlField,
+      {
+        formUrl,
+        loading: webhookUrlLoading,
+        error: triggerUrlError
+      }
+    ),
+    isWebhookWait && /* @__PURE__ */ jsx(WaitResumeUrlField, {}),
+    isAgentNodeType(nodeType) && /* @__PURE__ */ jsx(
+      AgentDefinitionSelectField,
+      {
+        value: typeof argsState.agentDefinitionId === "string" ? argsState.agentDefinitionId : null,
+        onChange: (next) => writeFixed("agentDefinitionId", next),
+        sectionLabelClassName: SECTION_LABEL3,
+        testIdPrefix
+      }
+    ),
+    connectionAdapters.length > 0 && /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": `${testIdPrefix}-connections`, children: [
+      /* @__PURE__ */ jsx("div", { className: SECTION_LABEL3, children: tr(
+        "fluidgrids.builder.nodeParamsForm.connectionsSection",
+        "Connections"
+      ) }),
+      /* @__PURE__ */ jsx(
+        ConnectionSelector,
+        {
+          adapters: connectionAdapters,
+          selectedConnections,
+          onChange: handleConnectionsChange,
+          compact: true
+        }
+      )
+    ] }),
+    !currentEdge && /* @__PURE__ */ jsx("div", { className: "rounded-md border border-dashed border-border bg-muted/40 px-3 py-2 text-xs text-muted-foreground", children: tr(
+      "fluidgrids.builder.nodeParamsForm.noUpstreamNode",
+      "No upstream node connected \u2014 set fixed values below, or connect a node to map fields with expressions."
+    ) }),
+    params.length === 0 ? /* @__PURE__ */ jsx("div", { className: "py-6 text-center text-xs text-muted-foreground", children: tr(
+      "fluidgrids.builder.nodeParamsForm.noParameters",
+      "This operation has no input parameters."
+    ) }) : visibleParams.map((p) => {
+      if (p.type === "schedule-rules") {
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "flex flex-col gap-2",
+            "data-testid": `${testIdPrefix}-param-${p.name}`,
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "rounded-md border border-dashed border-border bg-muted/40 px-3 py-2 text-xs text-muted-foreground", children: tr(
+                "fluidgrids.builder.scheduleRules.notice",
+                "This workflow will run on the schedule you define here once you activate it. For testing, you can also trigger it manually from the canvas."
+              ) }),
+              /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: p.label ?? tr(
+                "fluidgrids.builder.scheduleRules.rulesLabel",
+                "Trigger Rules"
+              ) }),
+              scheduleIsLegacy && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "text-[11px] leading-snug text-muted-foreground",
+                  "data-testid": `${testIdPrefix}-schedule-legacy-note`,
+                  children: tr(
+                    "fluidgrids.builder.scheduleRules.legacyNote",
+                    "Converted from the previous schedule settings \u2014 save the workflow to keep the new rules."
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ScheduleRulesEditor,
+                {
+                  rules: scheduleRules,
+                  ruleFields: p.fields,
+                  onChange: (rules) => writeFixed(p.name, rules),
+                  testIdPrefix
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ScheduleNextRuns,
+                {
+                  preview: schedulePreview,
+                  timezone: scheduleTimezone,
+                  testId: `${testIdPrefix}-schedule-next-runs`
+                }
+              ),
+              p.description && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: p.description })
+            ]
+          },
+          p.name
+        );
+      }
+      if (p.type === "condition") {
+        return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: p.name === "conditionTree" ? tr(
+            "fluidgrids.builder.nodeParamsForm.conditionsLabel",
+            "Conditions"
+          ) : p.label ?? p.name }),
+          /* @__PURE__ */ jsx(
+            ConditionTreeBuilder,
+            {
+              value: argsState[p.name],
+              fields: pickerFields,
+              onChange: (tree) => writeFixed(p.name, tree)
+            }
+          ),
+          p.description && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: p.description })
+        ] }, p.name);
+      }
+      if (p.type === "switch-rules") {
+        const rules = Array.isArray(argsState[p.name]) ? argsState[p.name] : [];
+        const fallbackHandle = typeof argsState.fallbackHandle === "string" ? argsState.fallbackHandle : "default";
+        return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: tr(
+            "fluidgrids.builder.nodeParamsForm.routingRulesLabel",
+            "Routing rules"
+          ) }),
+          /* @__PURE__ */ jsx(
+            SwitchRulesEditor,
+            {
+              rules,
+              fallbackHandle,
+              fields: pickerFields,
+              onChange: (next) => {
+                writeFixed(p.name, next.rules);
+                writeFixed("cases", casesFromRules(next.rules));
+                writeFixed("fallbackHandle", next.fallbackHandle);
+              }
+            }
+          )
+        ] }, p.name);
+      }
+      if (nodeType === "internal:assert" && p.name === "rules") {
+        return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+            /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: tr(
+              "fluidgrids.builder.nodeParamsForm.assertRulesLabel",
+              "Rules"
+            ) }),
+            p.required && /* @__PURE__ */ jsx("span", { className: "text-destructive", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsx(
+            AssertRulesEditor,
+            {
+              value: argsState[p.name],
+              onChange: (next) => writeFixed(p.name, next),
+              testIdPrefix
+            }
+          )
+        ] }, p.name);
+      }
+      if (p.type === "workflow" || nodeType === "internal:subworkflow" && p.name === "workflowKey") {
+        return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+            /* @__PURE__ */ jsx("label", { className: "text-xs font-medium text-foreground", children: tr(
+              "fluidgrids.builder.nodeParamsForm.workflowLabel",
+              "Workflow to call"
+            ) }),
+            p.required && /* @__PURE__ */ jsx("span", { className: "text-destructive", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsx(
+            WorkflowPickerField,
+            {
+              value: typeof argsState[p.name] === "string" ? argsState[p.name] : "",
+              onChange: (workflowKey2) => writeFixed(p.name, workflowKey2),
+              testId: `${testIdPrefix}-workflow-picker`
+            }
+          ),
+          p.description && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: p.description })
+        ] }, p.name);
+      }
+      const mode = modeByField[p.name] ?? (mapping[p.name] !== void 0 ? "expression" : "fixed");
+      const exprValue = mapping[p.name];
+      const fixedValue = argsState[p.name];
+      const structuredType = structuredParameterType(p.schema ?? p.type);
+      const optionList = Boolean(p.loadOptions) && isStringOptionList(p.schema ?? p.type);
+      const booleanChecked = p.type === "boolean" && booleanParameterValue(fixedValue) === true;
+      const isCodeParam = p.type === "code" || nodeType === "internal:code" && p.name === "code";
+      const highlight = dragField === p.name;
+      const controlId = `${formId}-param-${p.name}`;
+      const nativeControl = mode !== "expression" && !isCodeParam && !(structuredType && !optionList) && !p.loadOptions && p.type !== PLATFORM_EVENT_MODULE_FIELD && p.type !== PLATFORM_EVENT_RECORD_TYPE_FIELD;
+      const inputCx = cn(
+        "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"
+      );
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "flex flex-col gap-1.5",
+          onDragOver: (e) => e.preventDefault(),
+          onDragEnter: () => setDragField(p.name),
+          onDragLeave: () => setDragField((f) => f === p.name ? null : f),
+          onDrop: handleDropOnParam(p.name),
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+              /* @__PURE__ */ jsx(
+                "label",
+                {
+                  htmlFor: nativeControl ? controlId : void 0,
+                  className: "text-xs font-medium text-foreground",
+                  title: p.label && p.label !== p.name ? p.name : void 0,
+                  children: p.label ?? p.name
+                }
+              ),
+              p.required && /* @__PURE__ */ jsx("span", { className: "text-destructive", children: "*" }),
+              /* @__PURE__ */ jsx("span", { className: "ml-auto text-[10px] uppercase tracking-wide text-muted-foreground", children: p.type }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => toggleMode(p.name, mode),
+                  title: mode === "expression" ? tr(
+                    "fluidgrids.builder.nodeParamsForm.switchToFixed",
+                    "Switch to a fixed value"
+                  ) : tr(
+                    "fluidgrids.builder.nodeParamsForm.switchToExpression",
+                    "Switch to an expression"
+                  ),
+                  "data-testid": `${testIdPrefix}-mode-${p.name}`,
+                  className: cn(
+                    "ml-1 rounded p-0.5 hover:text-foreground",
+                    mode === "expression" ? "text-primary" : "text-muted-foreground"
+                  ),
+                  children: /* @__PURE__ */ jsx(
+                    Icon,
+                    {
+                      icon: mode === "expression" ? "mdi:variable" : "mdi:form-textbox",
+                      className: "size-3.5"
+                    }
+                  )
+                }
+              )
+            ] }),
+            mode === "expression" ? /* @__PURE__ */ jsx(
+              "div",
+              {
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                className: cn(
+                  !currentEdge && "pointer-events-none opacity-50"
+                ),
+                children: /* @__PURE__ */ jsx(
+                  MappedParameterInput,
+                  {
+                    name: p.name,
+                    label: p.label,
+                    value: exprValue,
+                    onChange: (value) => writeMapping(p.name, value),
+                    nodeId: config.node?.id,
+                    placeholder: currentEdge ? tr(
+                      "fluidgrids.builder.nodeParamsForm.expressionPlaceholder",
+                      "Drop a field or type ${output.\u2026} or {{ $json.\u2026 }}"
+                    ) : tr(
+                      "fluidgrids.builder.nodeParamsForm.expressionDisabledPlaceholder",
+                      "Connect an upstream node to use expressions"
+                    )
+                  },
+                  `${config.node?.id}:${currentEdge?.id}:${p.name}`
+                )
+              }
+            ) : isCodeParam ? /* @__PURE__ */ jsx(
+              CodeEditorField,
+              {
+                value: typeof fixedValue === "string" ? fixedValue : "",
+                language: normalizeCodeLanguage(
+                  argsState.runtime ?? params.find((f) => f.name === "runtime")?.defaultValue
+                ),
+                placeholder: typeof p.defaultValue === "string" ? p.defaultValue : p.placeholder ?? p.description,
+                label: p.label ?? p.name,
+                onChange: (v) => writeFixed(p.name, v),
+                "data-testid": `${testIdPrefix}-param-${p.name}`
+              }
+            ) : structuredType && !optionList ? /* @__PURE__ */ jsx(
+              StructuredParameterInput,
+              {
+                name: p.name,
+                label: p.label,
+                schema: p.schema ?? p.type,
+                value: fixedValue,
+                onChange: (value) => writeFixed(p.name, value),
+                className: cn(inputCx, "font-mono"),
+                testId: `${testIdPrefix}-param-${p.name}`
+              },
+              `${config.node?.id}:${config.currentOp?.name}:${p.name}`
+            ) : p.loadOptions ? /* @__PURE__ */ jsx(
+              NodeLoadOptionsSelect,
+              {
+                nodeType,
+                nodeVersion,
+                spec: p.loadOptions,
+                parameterValues: Object.fromEntries(
+                  params.map((parameter) => [
+                    parameter.name,
+                    argsState[parameter.name]
+                  ])
+                ),
+                parameterDefaults: Object.fromEntries(
+                  params.map((parameter) => [
+                    parameter.name,
+                    parameter.defaultValue
+                  ])
+                ),
+                unavailableParameters: params.filter(
+                  (parameter) => (modeByField[parameter.name] ?? (mapping[parameter.name] !== void 0 ? "expression" : "fixed")) === "expression"
+                ).map((parameter) => parameter.name),
+                multiple: optionList,
+                fieldName: p.name,
+                label: p.label,
+                connectionId: loadOptionsConnectionId,
+                value: fixedValue,
+                onChange: (v) => writeFixed(p.name, v),
+                className: inputCx,
+                testId: `${testIdPrefix}-param-${p.name}`
+              }
+            ) : p.type === "boolean" ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+              /* @__PURE__ */ jsxs("label", { className: "flex w-fit cursor-pointer items-center gap-2 text-sm", children: [
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "checkbox",
+                    checked: booleanChecked,
+                    onChange: (event) => writeFixed(p.name, event.target.checked),
+                    id: controlId,
+                    "data-testid": `${testIdPrefix}-param-${p.name}`,
+                    className: "size-4"
+                  }
+                ),
+                /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: fixedValue === void 0 ? tr(
+                  "fluidgrids.builder.nodeParamsForm.booleanNotSet",
+                  "Not set (default)"
+                ) : booleanChecked ? "true" : "false" })
+              ] }),
+              !p.required && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => {
+                    if (fixedValue !== void 0)
+                      writeFixed(p.name, void 0);
+                  },
+                  "aria-disabled": fixedValue === void 0,
+                  "aria-label": tr(
+                    "fluidgrids.builder.nodeParamsForm.unsetBooleanLabel",
+                    "Not set: {{field}}",
+                    { field: p.label ?? p.name }
+                  ),
+                  "data-testid": `${testIdPrefix}-param-${p.name}-unset`,
+                  className: "rounded px-1 text-xs text-muted-foreground underline-offset-2 hover:text-foreground hover:underline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary aria-disabled:opacity-50",
+                  children: tr(
+                    "fluidgrids.builder.nodeParamsForm.unsetBoolean",
+                    "Not set"
+                  )
+                }
+              )
+            ] }) : p.type === PLATFORM_EVENT_MODULE_FIELD ? /* @__PURE__ */ jsx(
+              PlatformEventSourceSelect,
+              {
+                kind: "module",
+                value: typeof fixedValue === "string" ? fixedValue : "",
+                required: p.required,
+                label: p.label,
+                onChange: (next) => {
+                  const previous = argsState[p.name];
+                  writeFixed(p.name, next || void 0);
+                  const typeField = params.find(
+                    (f) => f.type === PLATFORM_EVENT_RECORD_TYPE_FIELD
+                  );
+                  if (typeField && previous !== next)
+                    writeFixed(typeField.name, void 0);
+                },
+                className: inputCx,
+                testId: `${testIdPrefix}-param-${p.name}`
+              }
+            ) : p.type === PLATFORM_EVENT_RECORD_TYPE_FIELD ? /* @__PURE__ */ jsx(
+              PlatformEventSourceSelect,
+              {
+                kind: "recordType",
+                value: typeof fixedValue === "string" ? fixedValue : "",
+                module: (() => {
+                  const moduleField = params.find(
+                    (f) => f.type === PLATFORM_EVENT_MODULE_FIELD
+                  );
+                  const module = moduleField ? argsState[moduleField.name] : void 0;
+                  return typeof module === "string" ? module : "";
+                })(),
+                required: p.required,
+                label: p.label,
+                onChange: (next) => writeFixed(p.name, next || void 0),
+                className: inputCx,
+                testId: `${testIdPrefix}-param-${p.name}`
+              }
+            ) : p.type === "timezone" ? /* @__PURE__ */ jsx(
+              TimezoneSelect,
+              {
+                value: typeof fixedValue === "string" ? fixedValue : "",
+                onChange: (zone) => writeFixed(p.name, zone),
+                className: inputCx,
+                testId: `${testIdPrefix}-param-${p.name}`
+              }
+            ) : p.type === "multiOptions" && p.options && p.options.length > 0 ? /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "flex flex-wrap gap-x-3 gap-y-1",
+                role: "group",
+                "aria-label": p.label ?? p.name,
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                children: p.options.map((o) => {
+                  const selected = Array.isArray(fixedValue) ? fixedValue.map(String) : [];
+                  const checked = selected.includes(o);
+                  return /* @__PURE__ */ jsxs(
+                    "label",
+                    {
+                      className: "flex cursor-pointer items-center gap-1 text-sm",
+                      children: [
+                        /* @__PURE__ */ jsx(
+                          "input",
+                          {
+                            type: "checkbox",
+                            checked,
+                            onChange: (event) => {
+                              const next = new Set(selected);
+                              if (event.target.checked) next.add(o);
+                              else next.delete(o);
+                              const ordered = p.options.filter(
+                                (option) => next.has(option)
+                              );
+                              writeFixed(
+                                p.name,
+                                ordered.length > 0 ? ordered : void 0
+                              );
+                            },
+                            className: "size-4",
+                            "data-testid": `${testIdPrefix}-param-${p.name}-${o}`
+                          }
+                        ),
+                        /* @__PURE__ */ jsx("span", { children: optionText(p, o) })
+                      ]
+                    },
+                    o
+                  );
+                })
+              }
+            ) : p.options && p.options.length > 0 ? /* @__PURE__ */ jsxs(
+              "select",
+              {
+                value: typeof fixedValue === "string" ? fixedValue : "",
+                onChange: (e) => writeFixed(p.name, e.target.value),
+                "aria-label": p.label ?? p.name,
+                id: controlId,
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                className: cn(
+                  inputCx,
+                  "scheme-normal dark:scheme-dark [&_option]:bg-bg-surface [&_option]:text-text-primary"
+                ),
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "", children: p.defaultValue !== void 0 ? `Default (${optionText(p, String(p.defaultValue))})` : tr(
+                    "fluidgrids.builder.nodeParamsForm.selectPlaceholder",
+                    "Select\u2026"
+                  ) }),
+                  p.options.map((o) => /* @__PURE__ */ jsx("option", { value: o, children: optionText(p, o) }, o))
+                ]
+              }
+            ) : p.type === "integer" || p.type === "number" ? /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                step: p.type === "integer" ? "1" : "any",
+                value: typeof fixedValue === "number" ? String(fixedValue) : "",
+                placeholder: p.defaultValue !== void 0 ? `Default: ${String(p.defaultValue)}` : p.placeholder ?? tr(
+                  "fluidgrids.builder.nodeParamsForm.numberPlaceholder",
+                  "Enter a number"
+                ),
+                "aria-label": p.label ?? p.name,
+                onChange: (e) => writeFixed(p.name, coerceNumber(p.type, e.target.value)),
+                id: controlId,
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                className: inputCx
+              }
+            ) : p.type === "string" && p.isMultiline && !p.secret ? /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                rows: 4,
+                value: fixedValue === void 0 || fixedValue === null ? "" : String(fixedValue),
+                placeholder: p.defaultValue !== void 0 ? `Default: ${String(p.defaultValue)}` : p.placeholder ?? tr(
+                  "fluidgrids.builder.nodeParamsForm.textPlaceholder",
+                  "Enter a value"
+                ),
+                onChange: (event) => writeFixed(p.name, event.target.value),
+                "aria-label": p.label ?? p.name,
+                id: controlId,
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                className: cn(inputCx, "min-h-24 resize-y")
+              }
+            ) : /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: p.secret ? "password" : "text",
+                autoComplete: p.secret ? "new-password" : void 0,
+                ...p.secret ? { "data-agent-sensitive": "" } : {},
+                value: fixedValue === void 0 || fixedValue === null ? "" : String(fixedValue),
+                placeholder: p.defaultValue !== void 0 ? `Default: ${String(p.defaultValue)}` : p.placeholder ?? tr(
+                  "fluidgrids.builder.nodeParamsForm.textPlaceholder",
+                  "Enter a value"
+                ),
+                onChange: (e) => writeFixed(p.name, e.target.value),
+                "aria-label": p.label ?? p.name,
+                id: controlId,
+                "data-testid": `${testIdPrefix}-param-${p.name}`,
+                className: inputCx
+              }
+            ),
+            p.description && /* @__PURE__ */ jsx("span", { className: "text-[11px] leading-snug text-muted-foreground", children: p.description })
+          ]
+        },
+        p.name
+      );
+    })
+  ] });
+}
+function ReadOnlyFieldset({
+  className,
+  children
+}) {
+  const readOnly = useBuilderReadOnly();
+  return /* @__PURE__ */ jsx(
+    "fieldset",
+    {
+      disabled: readOnly,
+      "data-readonly": readOnly ? "true" : void 0,
+      className: cn("m-0 min-w-0 border-0 p-0", className),
+      children
+    }
+  );
+}
+
+// src/builder/lib/continuation.ts
+var BLOCKED = {
+  eligible: false,
+  action: null,
+  blockers: [],
+  blockerReason: null,
+  reason: null
+};
+function blocked(blockerReason, reason, blockers = [], targetStatus = null) {
+  return {
+    ...BLOCKED,
+    targetStatus,
+    blockerReason,
+    blockers,
+    reason
+  };
+}
+function sourceMetadata(input) {
+  const source = input.sourceRun;
+  return {
+    runId: source?.runId ?? input.sourceRunId ?? null,
+    workflowKey: source?.workflowKey ?? input.sourceRunWorkflowKey ?? null,
+    version: source?.version ?? source?.workflowVersion ?? input.sourceRunVersion ?? null,
+    sourceMode: source?.sourceMode ?? null
+  };
+}
+function getContinuationEligibility(input) {
+  const source = sourceMetadata(input);
+  if (!source.runId) {
+    return blocked(
+      "missing-source-run",
+      "Load a completed or failed run before continuing from this node."
+    );
+  }
+  if (source.sourceMode === "PRODUCTION") {
+    return blocked(
+      "production-source-run",
+      "Production run output cannot be reused for TEST continuation."
+    );
+  }
+  if (!source.workflowKey || !source.version || source.workflowKey !== input.workflowKey || source.version !== input.workflowVersion) {
+    return blocked(
+      "incompatible-source-run",
+      "The selected run belongs to a different workflow version."
+    );
+  }
+  const nodeIds = new Set(input.nodes.map((node) => node.id));
+  if (!nodeIds.has(input.targetNodeId)) {
+    return blocked(
+      "missing-target",
+      "The selected node is not present in this workflow.",
+      [input.targetNodeId]
+    );
+  }
+  const logsByNode = /* @__PURE__ */ new Map();
+  for (const log of input.logs) {
+    if (log.runId === source.runId) logsByNode.set(log.nodeId, log);
+  }
+  const targetLog = logsByNode.get(input.targetNodeId);
+  const targetStatus = targetLog?.status?.toLowerCase() ?? null;
+  const action = targetStatus === "failed" ? "retry" : targetStatus === null || targetStatus === "completed" ? "continue" : null;
+  if (!action) {
+    return blocked(
+      "target-not-terminal",
+      "Continue is available only for completed or failed nodes.",
+      [input.targetNodeId],
+      targetStatus
+    );
+  }
+  const predecessors = /* @__PURE__ */ new Map();
+  for (const edge of input.edges) {
+    const parents = predecessors.get(edge.target) ?? [];
+    if (!parents.includes(edge.source)) parents.push(edge.source);
+    predecessors.set(edge.target, parents);
+  }
+  const ancestors = /* @__PURE__ */ new Set();
+  const cycleNodes = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set([input.targetNodeId]);
+  const visited = /* @__PURE__ */ new Set();
+  const visitAncestor = (nodeId) => {
+    if (visiting.has(nodeId)) {
+      cycleNodes.add(nodeId);
+      return;
+    }
+    if (visited.has(nodeId)) return;
+    ancestors.add(nodeId);
+    visiting.add(nodeId);
+    for (const parentId of predecessors.get(nodeId) ?? []) {
+      visitAncestor(parentId);
+    }
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+  };
+  for (const parentId of predecessors.get(input.targetNodeId) ?? []) {
+    visitAncestor(parentId);
+  }
+  if (cycleNodes.size > 0) {
+    return blocked(
+      "cycle",
+      "This workflow has a cycle upstream of the selected node, so continuation is disabled.",
+      [...cycleNodes].sort(),
+      targetStatus
+    );
+  }
+  for (const ancestorId of ancestors) {
+    if (!nodeIds.has(ancestorId) || !logsByNode.has(ancestorId)) {
+      return blocked(
+        "missing-ancestor-log",
+        "Every upstream node must have a result in the selected run.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+    const ancestor = logsByNode.get(ancestorId);
+    if (ancestor?.status.toLowerCase() !== "completed") {
+      return blocked(
+        "ancestor-not-completed",
+        "Every upstream node must be completed before continuing.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+    if (ancestor.output == null) {
+      return blocked(
+        "ancestor-missing-output",
+        "Every completed upstream node must have output data before continuing.",
+        [ancestorId],
+        targetStatus
+      );
+    }
+  }
+  return {
+    eligible: true,
+    action,
+    targetStatus,
+    blockers: [],
+    blockerReason: null,
+    reason: null
+  };
+}
+function NodeExecutionActions({
+  targetNodeId,
+  nodes,
+  edges,
+  logs,
+  workflowKey,
+  workflowVersion,
+  sourceRun,
+  onExecuteStep,
+  onContinueFromNode,
+  isExecuting = false,
+  className,
+  testIdPrefix = "node-execution"
+}) {
+  const tr = useTr();
+  const [pendingAction, setPendingAction] = useState(null);
+  const localEligibility = useMemo(
+    () => getContinuationEligibility({
+      nodes,
+      edges,
+      logs,
+      targetNodeId,
+      workflowKey,
+      workflowVersion,
+      sourceRun
+    }),
+    [nodes, edges, logs, targetNodeId, workflowKey, workflowVersion, sourceRun]
+  );
+  const sourceRunId = sourceRun?.runId;
+  const queryIdentity = `${sourceRunId ?? ""}:${targetNodeId}`;
+  const sourceStateVersion = useMemo(
+    () => logs.filter((log) => !sourceRun || log.runId === sourceRun.runId).map(
+      (log) => `${log.nodeId}:${log.status}:${log.output == null ? "empty" : "ready"}`
+    ).sort().join("|"),
+    [logs, sourceRun]
+  );
+  const queryIdentityRef = useRef(queryIdentity);
+  const {
+    data: eligibilityData,
+    loading: eligibilityLoading,
+    error: eligibilityError,
+    refetch: refetchEligibility
+  } = useRunFromNodeEligibilityQuery({
+    variables: {
+      input: {
+        sourceRunId: sourceRun?.runId ?? "",
+        nodeId: targetNodeId
+      }
+    },
+    skip: !sourceRun,
+    fetchPolicy: "network-only",
+    nextFetchPolicy: "network-only"
+  });
+  useEffect(() => {
+    if (sourceRunId === void 0) {
+      queryIdentityRef.current = queryIdentity;
+      return;
+    }
+    if (queryIdentityRef.current !== queryIdentity) {
+      queryIdentityRef.current = queryIdentity;
+      return;
+    }
+    void refetchEligibility();
+  }, [queryIdentity, refetchEligibility, sourceRunId, sourceStateVersion]);
+  const serverEligibility = sourceRun && !eligibilityLoading && !eligibilityError && eligibilityData?.runFromNodeEligibility ? (() => {
+    const result = eligibilityData.runFromNodeEligibility;
+    const targetStatus = result.targetStatus?.toLowerCase() ?? null;
+    return {
+      eligible: result.eligible,
+      action: targetStatus === "failed" ? "retry" : result.eligible ? "continue" : null,
+      targetStatus,
+      blockers: result.blockedNodeIds.length ? result.blockedNodeIds : result.blockers,
+      blockerReason: null,
+      reason: result.reason ?? null
+    };
+  })() : null;
+  const eligibility = sourceRun ? serverEligibility ?? {
+    eligible: false,
+    action: null,
+    reason: eligibilityError ? tr(
+      "fluidgrids.builder.nodeExecutionActions.queryError",
+      "Unable to verify continuation readiness. Try loading the run again."
+    ) : tr(
+      "fluidgrids.builder.nodeExecutionActions.checking",
+      "Checking continuation readiness\u2026"
+    )
+  } : localEligibility;
+  const runAction = async (action, callback) => {
+    setPendingAction(action);
+    try {
+      await callback();
+    } finally {
+      setPendingAction(null);
+    }
+  };
+  const executePending = pendingAction === "execute" || isExecuting;
+  const continuePending = pendingAction === "continue";
+  const continuationLabel = eligibility.action === "retry" ? tr(
+    "fluidgrids.builder.nodeExecutionActions.retryFromHere",
+    "Retry from here"
+  ) : tr(
+    "fluidgrids.builder.nodeExecutionActions.continueFromHere",
+    "Continue from here"
+  );
+  const blockerLabel = eligibility.reason ? tr(
+    "fluidgrids.builder.nodeExecutionActions.blocked",
+    "Unavailable: {{reason}}",
+    { reason: eligibility.reason }
+  ) : tr(
+    "fluidgrids.builder.nodeExecutionActions.noSourceRun",
+    "Load a run to enable continuation."
+  );
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: cn(
+        "shrink-0 border-t border-border bg-muted/20 px-3 py-2",
+        className
+      ),
+      "aria-label": tr(
+        "fluidgrids.builder.nodeExecutionActions.ariaLabel",
+        "Node execution actions"
+      ),
+      "data-testid": `${testIdPrefix}-execution-actions`,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-[10px] font-semibold uppercase tracking-[0.12em] text-muted-foreground", children: tr("fluidgrids.builder.nodeExecutionActions.heading", "Execution") }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              "data-agent": "confirm",
+              type: "button",
+              onClick: () => {
+                void runAction("execute", () => onExecuteStep(targetNodeId));
+              },
+              disabled: executePending || continuePending,
+              title: tr(
+                "fluidgrids.builder.nodeExecutionActions.executeStepHint",
+                "Run only this node as a fresh TEST execution."
+              ),
+              className: "inline-flex items-center gap-1 rounded-md border border-border bg-background px-2 py-1 text-xs font-medium text-foreground transition-colors hover:bg-muted disabled:cursor-not-allowed disabled:opacity-50",
+              "data-testid": `${testIdPrefix}-execute-step`,
+              children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: executePending ? "svg-spinners:ring-resize" : "mdi:play",
+                    className: "size-3.5"
+                  }
+                ),
+                tr(
+                  "fluidgrids.builder.nodeExecutionActions.executeStep",
+                  "Execute step"
+                )
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              "data-agent": "confirm",
+              type: "button",
+              onClick: () => {
+                if (!eligibility.eligible || !sourceRun) return;
+                void runAction(
+                  "continue",
+                  () => onContinueFromNode(sourceRun.runId, targetNodeId)
+                );
+              },
+              disabled: !eligibility.eligible || !sourceRun || executePending || continuePending,
+              title: eligibility.eligible ? continuationLabel : blockerLabel,
+              className: "inline-flex items-center gap-1 rounded-md border border-primary/30 bg-primary/5 px-2 py-1 text-xs font-medium text-primary transition-colors hover:bg-primary/10 disabled:cursor-not-allowed disabled:opacity-50",
+              "data-testid": `${testIdPrefix}-continue-from-here`,
+              children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: continuePending ? "svg-spinners:ring-resize" : "mdi:skip-forward",
+                    className: "size-3.5"
+                  }
+                ),
+                continuePending ? tr("fluidgrids.builder.nodeExecutionActions.running", "Running\u2026") : continuationLabel
+              ]
+            }
+          )
+        ] }),
+        !eligibility.eligible && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-1 text-[10px] leading-snug text-muted-foreground",
+            "data-testid": `${testIdPrefix}-continuation-blocker`,
+            children: blockerLabel
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { NDV_Z_INDEX, NodeExecutionActions, NodeParamsForm, ReadOnlyFieldset };