@burdenoff/fluidgrids-fe-sdk 2026.1107.1 → 2026.1108.2

package/dist/chunk-HPNZ3PYU.js

@@ -0,0 +1,1448 @@
+import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-RNYFPG7R.js';
+import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, searchFilterConflicts, WORKFLOW_ID_MAX_LENGTH, EMPTY_SEARCH_FILTER, buildSearchAttributeFilter, MAX_SEARCH_CONDITIONS, OPERATORS_BY_TYPE } from './chunk-JRR4VKYD.js';
+import { useResource, fetchSearchAttributes, NativeSelect, FieldError, RUN_CONTROL_DIALOG_STYLE, parseJsonInput, JsonField, fetchBatchOperations, StatusPill, fetchBatchOperation, cancelBatchOperation, startBatchTerminate, startBatchExport, startBatchOperation, jsonArg } from './chunk-YASVILWQ.js';
+import { useWorkflowDefinitions } from './chunk-KJB3WZVD.js';
+import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
+import { useDurableParityEnabled, usePhaseCFlags } from './chunk-GI6BQIQA.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-AR22A74Y.js';
+import { WorkflowBatchOperationUpdatedDocument } from './chunk-GOZR72NK.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-PDODDDHY.js';
+import { describeOperationError } from './chunk-JKLZ6YZ3.js';
+import { useExecutionsStore } from './chunk-UEG2WC3G.js';
+import { useRef, useState, useEffect, useMemo, useCallback } from 'react';
+import { useNavigate, useSearchParams } from 'react-router';
+import { Icon } from '@iconify/react';
+import { toast } from 'sonner';
+import { Button } from '@burdenoff/fe-libs/button';
+import { Input, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label, DialogFooter, Sheet, SheetContent, SheetHeader, SheetTitle, SheetDescription } from '@burdenoff/fe-libs/ui';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { cn } from '@burdenoff/fe-libs/utils';
+
+var OPERATOR_LABELS = {
+  EQ: "=",
+  NEQ: "\u2260",
+  IN: "in",
+  GT: ">",
+  GTE: "\u2265",
+  LT: "<",
+  LTE: "\u2264",
+  STARTS_WITH: "starts with",
+  CONTAINS: "contains"
+};
+function SearchAttributeFilterBar({
+  applied,
+  onApply,
+  conflicts
+}) {
+  const tr = useTr();
+  const definitions = useResource(
+    "search-attributes",
+    true,
+    fetchSearchAttributes
+  );
+  const [state, setState] = useState(EMPTY_SEARCH_FILTER);
+  const types = useMemo(
+    () => new Map(
+      (definitions.data ?? []).map((definition) => [
+        definition.name,
+        definition.type
+      ])
+    ),
+    [definitions.data]
+  );
+  const built = buildSearchAttributeFilter(state, types);
+  const names = [...types.keys()].sort();
+  const setRow = (index, patch) => setState((current) => ({
+    ...current,
+    rows: current.rows.map((row, i) => {
+      if (i !== index) return row;
+      const next = { ...row, ...patch };
+      const type = types.get(next.name);
+      if (type && !OPERATORS_BY_TYPE[type].includes(next.op))
+        next.op = OPERATORS_BY_TYPE[type][0];
+      return next;
+    })
+  }));
+  const addRow = () => {
+    const name = names[0];
+    if (!name) return;
+    const type = types.get(name);
+    setState((current) => ({
+      ...current,
+      rows: [
+        ...current.rows,
+        { name, op: type ? OPERATORS_BY_TYPE[type][0] : "EQ", value: "" }
+      ]
+    }));
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-4 space-y-3 rounded-lg border border-border-secondary bg-background-secondary p-3",
+      "data-testid": "search-attribute-filter",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:tag-search-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: tr("fluidgrids.runControl.searchFilter.title", "Search attributes") }),
+          state.rows.length > 1 && /* @__PURE__ */ jsxs(
+            NativeSelect,
+            {
+              value: state.combine,
+              onChange: (value) => setState((current) => ({
+                ...current,
+                combine: value === "or" ? "or" : "and"
+              })),
+              ariaLabel: tr(
+                "fluidgrids.runControl.searchFilter.combine",
+                "Match"
+              ),
+              testId: "search-filter-combine",
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "and", children: tr("fluidgrids.runControl.searchFilter.all", "all conditions") }),
+                /* @__PURE__ */ jsx("option", { value: "or", children: tr("fluidgrids.runControl.searchFilter.any", "any condition") })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: state.text,
+              onChange: (event) => setState((current) => ({ ...current, text: event.target.value })),
+              placeholder: tr(
+                "fluidgrids.runControl.searchFilter.text",
+                "Words in text attributes"
+              ),
+              className: "h-9 max-w-xs",
+              maxLength: 256,
+              "data-testid": "search-filter-text"
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: addRow,
+              disabled: names.length === 0 || state.rows.length >= MAX_SEARCH_CONDITIONS,
+              "data-testid": "search-filter-add",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "mr-1", width: 14 }),
+                tr("fluidgrids.runControl.searchFilter.add", "Condition")
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "ml-auto flex gap-2", children: [
+            applied && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "ghost",
+                onClick: () => {
+                  setState(EMPTY_SEARCH_FILTER);
+                  onApply(null);
+                },
+                "data-testid": "search-filter-clear",
+                children: tr("fluidgrids.runControl.searchFilter.clear", "Clear")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                onClick: () => onApply(built.filter),
+                disabled: built.incomplete > 0,
+                "data-testid": "search-filter-apply",
+                children: tr("fluidgrids.runControl.searchFilter.apply", "Apply")
+              }
+            )
+          ] })
+        ] }),
+        definitions.data && names.length === 0 && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-xs text-text-secondary",
+            "data-testid": "search-filter-no-definitions",
+            children: tr(
+              "fluidgrids.runControl.searchFilter.noDefinitions",
+              "No search attributes are defined. Define them in Settings \u2192 Run control."
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(FieldError, { message: definitions.error }),
+        state.rows.map((row, index) => {
+          const type = types.get(row.name);
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "flex flex-wrap items-center gap-2",
+              "data-testid": `search-filter-row-${index}`,
+              children: [
+                /* @__PURE__ */ jsx("div", { className: "w-44", children: /* @__PURE__ */ jsx(
+                  NativeSelect,
+                  {
+                    value: row.name,
+                    onChange: (name) => setRow(index, { name }),
+                    ariaLabel: tr(
+                      "fluidgrids.runControl.searchFilter.attribute",
+                      "Attribute"
+                    ),
+                    testId: `search-filter-name-${index}`,
+                    children: names.map((name) => /* @__PURE__ */ jsx("option", { value: name, children: name }, name))
+                  }
+                ) }),
+                /* @__PURE__ */ jsx("div", { className: "w-32", children: /* @__PURE__ */ jsx(
+                  NativeSelect,
+                  {
+                    value: row.op,
+                    onChange: (op) => setRow(index, {
+                      op: (type ? OPERATORS_BY_TYPE[type] : []).find(
+                        (item) => item === op
+                      ) ?? row.op
+                    }),
+                    ariaLabel: tr(
+                      "fluidgrids.runControl.searchFilter.operator",
+                      "Operator"
+                    ),
+                    testId: `search-filter-op-${index}`,
+                    children: (type ? OPERATORS_BY_TYPE[type] : []).map((op) => /* @__PURE__ */ jsx("option", { value: op, children: OPERATOR_LABELS[op] }, op))
+                  }
+                ) }),
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    value: row.value,
+                    onChange: (event) => setRow(index, { value: event.target.value }),
+                    placeholder: row.op === "IN" ? tr(
+                      "fluidgrids.runControl.searchFilter.listValue",
+                      "a, b, c"
+                    ) : type ?? "",
+                    className: "h-9 max-w-xs",
+                    "aria-label": tr(
+                      "fluidgrids.runControl.searchFilter.value",
+                      "Value"
+                    ),
+                    "data-testid": `search-filter-value-${index}`
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    size: "sm",
+                    variant: "ghost",
+                    "aria-label": tr(
+                      "fluidgrids.runControl.searchFilter.remove",
+                      "Remove condition"
+                    ),
+                    onClick: () => setState((current) => ({
+                      ...current,
+                      rows: current.rows.filter((_, i) => i !== index)
+                    })),
+                    children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:close", width: 14 })
+                  }
+                )
+              ]
+            },
+            index
+          );
+        }),
+        built.incomplete > 0 && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-xs text-[var(--color-status-warning-text)]",
+            "data-testid": "search-filter-incomplete",
+            children: tr(
+              "fluidgrids.runControl.searchFilter.incomplete",
+              "Give every condition a value of its attribute's type."
+            )
+          }
+        ),
+        applied && conflicts.length > 0 && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-xs text-[var(--color-status-warning-text)]",
+            "data-testid": "search-filter-conflicts",
+            children: tr(
+              "fluidgrids.runControl.searchFilter.conflicts",
+              "The attribute filter is not applied while these filters are set: {{filters}}. Clear them to use it.",
+              { filters: conflicts.join(", ") }
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/modules/run-control/utils/batch.ts
+var BATCH_MENU_OPERATIONS = [
+  "SIGNAL",
+  "CANCEL",
+  "TERMINATE",
+  "RESET",
+  "PAUSE_ACTIVITY",
+  "UNPAUSE_ACTIVITY",
+  "RESET_ACTIVITY",
+  "EXPORT"
+];
+var DURABLE_BATCH_OPERATIONS = /* @__PURE__ */ new Set([
+  "RESET",
+  "PAUSE_ACTIVITY",
+  "UNPAUSE_ACTIVITY",
+  "RESET_ACTIVITY"
+]);
+function allowedBatchOperations(gates, permissions) {
+  const allowed = /* @__PURE__ */ new Set();
+  if (!gates.runControl) return allowed;
+  if (permissions.canExecute)
+    for (const type of BATCH_MENU_OPERATIONS) {
+      if (type === "TERMINATE" || type === "EXPORT") continue;
+      if (DURABLE_BATCH_OPERATIONS.has(type) && !gates.runControlDurable)
+        continue;
+      allowed.add(type);
+    }
+  if (permissions.canDelete) allowed.add("TERMINATE");
+  if (gates.runArchival) allowed.add("EXPORT");
+  return allowed;
+}
+function batchMutationOf(type) {
+  if (type === "TERMINATE") return "terminate";
+  if (type === "EXPORT") return "export";
+  return "operation";
+}
+var MAX_BATCH_RUN_IDS = 1e3;
+function batchSelection(input, selection) {
+  if (selection.allMatching) {
+    const filter = { ...input };
+    delete filter.limit;
+    delete filter.offset;
+    return { filter };
+  }
+  return { runIds: selection.runIds.slice(0, MAX_BATCH_RUN_IDS) };
+}
+function needsActivitySelector(type) {
+  return type === "PAUSE_ACTIVITY" || type === "UNPAUSE_ACTIVITY" || type === "RESET_ACTIVITY";
+}
+function batchProgress(job) {
+  const done = job.succeeded + job.failed + job.skipped;
+  const total = Math.max(job.total, 0);
+  const finished = job.status === "COMPLETED" || job.status === "FAILED" || job.status === "CANCELLED";
+  const percent = total === 0 ? finished ? 100 : 0 : Math.min(100, Math.round(done / total * 100));
+  return { done, total, percent, finished };
+}
+var BATCH_POLL_INTERVAL_MS = 3e3;
+var OPERATION_TYPES = {
+  SIGNAL: "SIGNAL" /* Signal */,
+  CANCEL: "CANCEL" /* Cancel */,
+  TERMINATE: "TERMINATE" /* Terminate */,
+  RESET: "RESET" /* Reset */,
+  PAUSE_ACTIVITY: "PAUSE_ACTIVITY" /* PauseActivity */,
+  UNPAUSE_ACTIVITY: "UNPAUSE_ACTIVITY" /* UnpauseActivity */,
+  RESET_ACTIVITY: "RESET_ACTIVITY" /* ResetActivity */,
+  EXPORT: "EXPORT" /* Export */
+};
+function useBatchOperationLabels() {
+  const tr = useTr();
+  return {
+    SIGNAL: tr("fluidgrids.runControl.batch.op.signal", "Signal"),
+    CANCEL: tr("fluidgrids.runControl.batch.op.cancel", "Cancel"),
+    TERMINATE: tr("fluidgrids.runControl.batch.op.terminate", "Terminate"),
+    RESET: tr(
+      "fluidgrids.runControl.batch.op.reset",
+      "Reset to last clean task"
+    ),
+    PAUSE_ACTIVITY: tr(
+      "fluidgrids.runControl.batch.op.pauseActivity",
+      "Pause activities"
+    ),
+    UNPAUSE_ACTIVITY: tr(
+      "fluidgrids.runControl.batch.op.unpauseActivity",
+      "Unpause activities"
+    ),
+    RESET_ACTIVITY: tr(
+      "fluidgrids.runControl.batch.op.resetActivity",
+      "Reset activity attempts"
+    ),
+    EXPORT: tr("fluidgrids.runControl.batch.op.export", "Export to archive")
+  };
+}
+function BatchMenu({ allowed, onPick, onShowJobs }) {
+  const tr = useTr();
+  const labels = useBatchOperationLabels();
+  const offered = BATCH_MENU_OPERATIONS.filter((type) => allowed.has(type));
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+    /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+      /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "outline",
+          size: "sm",
+          disabled: offered.length === 0,
+          "data-testid": "batch-menu",
+          children: [
+            /* @__PURE__ */ jsx(
+              Icon,
+              {
+                icon: "mdi:layers-triple-outline",
+                className: "mr-1",
+                width: 14
+              }
+            ),
+            tr("fluidgrids.runControl.batch.menu", "Batch"),
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:chevron-down", className: "ml-1", width: 14 })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx(DropdownMenuContent, { style: RUN_CONTROL_DIALOG_STYLE, children: offered.map((type) => /* @__PURE__ */ jsx(
+        DropdownMenuItem,
+        {
+          onSelect: () => onPick(type),
+          "data-testid": `batch-op-${type}`,
+          children: labels[type]
+        },
+        type
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        onClick: onShowJobs,
+        "data-testid": "batch-jobs-button",
+        children: tr("fluidgrids.runControl.batch.jobs", "Batch jobs")
+      }
+    )
+  ] });
+}
+async function startJob(type, selection, common, payload) {
+  const mutation = batchMutationOf(type);
+  if (mutation === "terminate")
+    return startBatchTerminate({ ...selection, ...common });
+  if (mutation === "export")
+    return startBatchExport({ ...selection, ...common });
+  return startBatchOperation({
+    ...selection,
+    ...common,
+    type: OPERATION_TYPES[type],
+    payload
+  });
+}
+function BatchOperationDialog({
+  type,
+  input,
+  selection,
+  onClose,
+  onStarted
+}) {
+  const tr = useTr();
+  const labels = useBatchOperationLabels();
+  const [reason, setReason] = useState("");
+  const [rate, setRate] = useState("50");
+  const [signalName, setSignalName] = useState("");
+  const [signalPayload, setSignalPayload] = useState("");
+  const [pauseReason, setPauseReason] = useState("");
+  const [dryRun, setDryRun] = useState(null);
+  const [busy, setBusy] = useState(null);
+  const [error, setError] = useState(null);
+  const parsedPayload = parseJsonInput(signalPayload);
+  const maxOperationsPerSecond = Math.min(
+    50,
+    Math.max(1, Math.round(Number(rate) || 0))
+  );
+  const payload = () => {
+    if (type === "SIGNAL")
+      return {
+        signalName: signalName.trim(),
+        signalPayload: parsedPayload.ok ? jsonArg(parsedPayload.value) : null
+      };
+    if (type === "RESET")
+      return { resetTo: { type: "LAST_TASK" /* LastTask */ } };
+    if (needsActivitySelector(type)) return { selector: { all: true } };
+    return null;
+  };
+  const valid = reason.trim().length > 0 && Number.isFinite(Number(rate)) && (type !== "SIGNAL" || signalName.trim().length > 0 && parsedPayload.ok) && (type !== "PAUSE_ACTIVITY" || pauseReason.trim().length > 0);
+  const jobReason = type === "PAUSE_ACTIVITY" && pauseReason.trim() ? pauseReason.trim() : reason.trim();
+  const run = async (asDryRun) => {
+    if (!valid) return;
+    setBusy(asDryRun ? "dry" : "start");
+    setError(null);
+    try {
+      const chosen = batchSelection(input, selection);
+      const target = "filter" in chosen ? { filter: chosen.filter } : { runIds: chosen.runIds };
+      const job = await startJob(
+        type,
+        target,
+        { reason: jobReason, maxOperationsPerSecond, dryRun: asDryRun },
+        payload()
+      );
+      if (asDryRun) setDryRun(job);
+      else onStarted(job);
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(null);
+    }
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: true, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      "data-testid": "batch-dialog",
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: labels[type] }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: selection.allMatching ? tr(
+            "fluidgrids.runControl.batch.allMatching",
+            "Every run that matches the list's filters."
+          ) : tr(
+            "fluidgrids.runControl.batch.selected",
+            "{{count}} selected runs.",
+            { count: Math.min(selection.runIds.length, 1e3) }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          type === "SIGNAL" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "batch-signal-name", children: tr("fluidgrids.runControl.batch.signalName", "Signal name") }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  id: "batch-signal-name",
+                  value: signalName,
+                  onChange: (event) => setSignalName(event.target.value),
+                  "data-testid": "batch-signal-name"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx(
+              JsonField,
+              {
+                id: "batch-signal-payload",
+                label: tr(
+                  "fluidgrids.runControl.batch.signalPayload",
+                  "Payload (JSON, optional)"
+                ),
+                value: signalPayload,
+                onChange: setSignalPayload,
+                rows: 3,
+                error: parsedPayload.ok ? null : parsedPayload.error
+              }
+            )
+          ] }),
+          type === "PAUSE_ACTIVITY" && /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "batch-pause-reason", children: tr("fluidgrids.runControl.batch.pauseReason", "Pause reason") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "batch-pause-reason",
+                value: pauseReason,
+                onChange: (event) => setPauseReason(event.target.value),
+                "data-testid": "batch-pause-reason"
+              }
+            )
+          ] }),
+          needsActivitySelector(type) && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.runControl.batch.allActivities",
+            "Applies to every open activity of each run."
+          ) }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "batch-reason", children: tr("fluidgrids.runControl.batch.reason", "Reason") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "batch-reason",
+                value: reason,
+                maxLength: 1e3,
+                onChange: (event) => setReason(event.target.value),
+                "data-testid": "batch-reason"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "batch-rate", children: tr(
+              "fluidgrids.runControl.batch.rate",
+              "Runs per second (1 to 50)"
+            ) }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "batch-rate",
+                inputMode: "numeric",
+                value: rate,
+                onChange: (event) => setRate(event.target.value),
+                "data-testid": "batch-rate"
+              }
+            )
+          ] }),
+          dryRun && /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: "rounded-md bg-background-primary p-2 text-sm text-text-primary",
+              "data-testid": "batch-dry-run-result",
+              children: tr(
+                "fluidgrids.runControl.batch.dryRunResult",
+                "The job would select {{count}} runs.",
+                { count: dryRun.total }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "batch-error" })
+        ] }),
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: onClose, disabled: busy !== null, children: tr("fluidgrids.runControl.common.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              onClick: () => void run(true),
+              disabled: !valid || busy !== null,
+              "data-testid": "batch-dry-run",
+              children: busy === "dry" ? tr("fluidgrids.runControl.batch.counting", "Counting\u2026") : tr("fluidgrids.runControl.batch.dryRun", "Dry run")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => void run(false),
+              disabled: !valid || busy !== null,
+              "data-testid": "batch-start",
+              children: busy === "start" ? tr("fluidgrids.runControl.common.working", "Working\u2026") : tr("fluidgrids.runControl.batch.start", "Start job")
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+function statusTone(status) {
+  if (status === "COMPLETED") return "success";
+  if (status === "FAILED") return "error";
+  if (status === "CANCELLED") return "neutral";
+  return "info";
+}
+function isBatchMenuOperation(type) {
+  return BATCH_MENU_OPERATIONS.some((item) => item === type);
+}
+function useBatchJob(initial) {
+  const [job, setJob] = useState(initial);
+  const id = job?.id ?? null;
+  const finished = job ? batchProgress(job).finished : true;
+  useEffect(() => {
+    if (!id || finished) return;
+    let cancelled = false;
+    const subscription = getFluidGridsClient().subscribe({
+      query: WorkflowBatchOperationUpdatedDocument,
+      variables: { id }
+    }).subscribe({
+      next: ({ data }) => {
+        if (!cancelled && data?.workflowBatchOperationUpdated)
+          setJob(data.workflowBatchOperationUpdated);
+      },
+      // The timer below keeps the drawer current without the stream.
+      error: () => void 0
+    });
+    const timer = setInterval(() => {
+      fetchBatchOperation(id).then((next) => {
+        if (!cancelled) setJob(next);
+      }).catch(() => void 0);
+    }, BATCH_POLL_INTERVAL_MS);
+    return () => {
+      cancelled = true;
+      subscription.unsubscribe();
+      clearInterval(timer);
+    };
+  }, [id, finished]);
+  return { job, setJob };
+}
+function BatchProgressDrawer({
+  job: initial,
+  open,
+  onOpenChange,
+  canCancel
+}) {
+  const tr = useTr();
+  const labels = useBatchOperationLabels();
+  const { job, setJob } = useBatchJob(initial);
+  const [error, setError] = useState(null);
+  const jobs = useResource(
+    "batch-jobs",
+    open && !job,
+    () => fetchBatchOperations({ first: 20 })
+  );
+  useEffect(() => setJob(initial), [initial, setJob]);
+  const cancel = async () => {
+    if (!job) return;
+    try {
+      setJob(await cancelBatchOperation(job.id));
+    } catch (err) {
+      setError(describeOperationError(err));
+    }
+  };
+  const labelOf = (type) => isBatchMenuOperation(type) ? labels[type] : type;
+  return /* @__PURE__ */ jsx(Sheet, { open, onOpenChange, children: /* @__PURE__ */ jsxs(
+    SheetContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      className: "w-full sm:max-w-md",
+      "data-testid": "batch-drawer",
+      children: [
+        /* @__PURE__ */ jsxs(SheetHeader, { children: [
+          /* @__PURE__ */ jsx(SheetTitle, { children: job ? labelOf(job.type) : tr("fluidgrids.runControl.batch.jobs", "Batch jobs") }),
+          /* @__PURE__ */ jsx(SheetDescription, { children: job ? job.reason : tr(
+            "fluidgrids.runControl.batch.jobsDescription",
+            "The workspace's recent batch jobs."
+          ) })
+        ] }),
+        job ? /* @__PURE__ */ jsx(
+          BatchJobProgress,
+          {
+            job,
+            onCancel: canCancel ? () => void cancel() : void 0
+          }
+        ) : /* @__PURE__ */ jsxs("div", { className: "mt-4 space-y-2", children: [
+          /* @__PURE__ */ jsx(FieldError, { message: jobs.error }),
+          (jobs.data?.items ?? []).map((item) => /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: "w-full rounded-md border border-border-secondary p-2 text-left hover:bg-background-tertiary",
+              onClick: () => setJob(item),
+              "data-testid": `batch-job-${item.id}`,
+              children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-sm", children: [
+                  /* @__PURE__ */ jsx("span", { className: "font-medium text-text-primary", children: labelOf(item.type) }),
+                  /* @__PURE__ */ jsx(StatusPill, { tone: statusTone(item.status), children: item.status }),
+                  /* @__PURE__ */ jsxs("span", { className: "ml-auto text-xs text-text-secondary", children: [
+                    batchProgress(item).percent,
+                    "%"
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx("p", { className: "truncate text-xs text-text-secondary", children: item.reason })
+              ]
+            },
+            item.id
+          )),
+          jobs.data && jobs.data.items.length === 0 && /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr("fluidgrids.runControl.batch.noJobs", "No batch jobs yet.") })
+        ] }),
+        /* @__PURE__ */ jsx(FieldError, { message: error })
+      ]
+    }
+  ) });
+}
+function BatchJobProgress({
+  job,
+  onCancel
+}) {
+  const tr = useTr();
+  const progress = batchProgress(job);
+  return /* @__PURE__ */ jsxs("div", { className: "mt-4 space-y-3", "data-testid": "batch-progress", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        StatusPill,
+        {
+          tone: statusTone(job.status),
+          testId: "batch-progress-status",
+          children: job.status
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "span",
+        {
+          className: "text-sm text-text-secondary",
+          "data-testid": "batch-progress-count",
+          children: [
+            progress.done,
+            " / ",
+            progress.total
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "h-2 overflow-hidden rounded-full bg-background-tertiary", children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "h-full bg-[var(--color-status-info-bg)]",
+        style: { width: `${progress.percent}%` }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("dl", { className: "grid grid-cols-3 gap-2 text-center text-xs", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "text-text-secondary", children: tr("fluidgrids.runControl.batch.succeeded", "Succeeded") }),
+        /* @__PURE__ */ jsx("dd", { className: "text-base font-semibold text-text-primary", children: job.succeeded })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "text-text-secondary", children: tr("fluidgrids.runControl.batch.failed", "Failed") }),
+        /* @__PURE__ */ jsx("dd", { className: "text-base font-semibold text-text-primary", children: job.failed })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "text-text-secondary", children: tr("fluidgrids.runControl.batch.skipped", "Skipped") }),
+        /* @__PURE__ */ jsx("dd", { className: "text-base font-semibold text-text-primary", children: job.skipped })
+      ] })
+    ] }),
+    job.failureMessage && /* @__PURE__ */ jsx(FieldError, { message: job.failureMessage }),
+    job.errors.length > 0 && /* @__PURE__ */ jsx(
+      "ul",
+      {
+        className: "max-h-48 space-y-1 overflow-auto text-xs",
+        "data-testid": "batch-progress-errors",
+        children: job.errors.map((item) => /* @__PURE__ */ jsxs("li", { children: [
+          /* @__PURE__ */ jsx("code", { className: "font-mono", children: item.runId.slice(0, 12) }),
+          " ",
+          item.message
+        ] }, item.runId))
+      }
+    ),
+    onCancel && !progress.finished && !job.cancelRequestedAt && /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: onCancel,
+        "data-testid": "batch-cancel",
+        children: tr("fluidgrids.runControl.batch.cancel", "Cancel job")
+      }
+    )
+  ] });
+}
+var WORKFLOW_ID_FILTER_DEBOUNCE_MS = 350;
+var RUN_STATUSES = [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED"
+];
+function isRunStatus(value) {
+  return RUN_STATUSES.includes(value);
+}
+function RunsParityBar({
+  workflowId,
+  onWorkflowIdChange,
+  total,
+  counts,
+  countsError,
+  selectedStatus,
+  onSelectStatus
+}) {
+  const tr = useTr();
+  const statusLabels = runStatusLabels(tr);
+  const [draft, setDraft] = useState(workflowId);
+  useEffect(() => {
+    setDraft(workflowId);
+  }, [workflowId]);
+  useEffect(() => {
+    if (draft === workflowId) return;
+    const timer = setTimeout(
+      () => onWorkflowIdChange(draft),
+      WORKFLOW_ID_FILTER_DEBOUNCE_MS
+    );
+    return () => clearTimeout(timer);
+  }, [draft, workflowId, onWorkflowIdChange]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": "runs-parity-bar",
+      className: "mb-6 flex flex-col gap-3 lg:flex-row lg:items-center",
+      children: [
+        /* @__PURE__ */ jsxs("label", { className: "flex min-w-0 items-center gap-2 text-sm text-text-secondary lg:w-80", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:key-outline", width: 16, className: "shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "sr-only", children: tr("fluidgrids.executions.parity.workflowIdFilter", "Workflow ID") }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: draft,
+              maxLength: WORKFLOW_ID_MAX_LENGTH,
+              placeholder: tr(
+                "fluidgrids.executions.parity.workflowIdPlaceholder",
+                "Filter by workflow ID"
+              ),
+              onChange: (event) => setDraft(event.target.value),
+              "data-testid": "runs-workflow-id-filter"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "flex flex-wrap items-center gap-2",
+            "data-testid": "runs-status-counts",
+            children: countsError ? /* @__PURE__ */ jsxs("span", { className: "text-xs text-[var(--color-status-error-text)]", children: [
+              tr(
+                "fluidgrids.executions.parity.countsError",
+                "Could not count the runs:"
+              ),
+              " ",
+              countsError
+            ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              total !== null && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => onSelectStatus("all"),
+                  className: cn(
+                    "rounded-full border px-2.5 py-1 text-xs",
+                    selectedStatus === "all" ? "border-action-primary-bg bg-action-primary-bg text-action-primary-text" : "border-border-secondary text-text-secondary hover:text-text-primary"
+                  ),
+                  "aria-pressed": selectedStatus === "all",
+                  "data-testid": "runs-count-all",
+                  children: tr("fluidgrids.executions.parity.countAll", "All {{count}}", {
+                    count: total
+                  })
+                }
+              ),
+              counts.map(
+                ({ status, count }) => isRunStatus(status) ? /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => onSelectStatus(status),
+                    className: cn(
+                      "rounded-full border px-2.5 py-1 text-xs",
+                      selectedStatus === status ? "border-action-primary-bg bg-action-primary-bg text-action-primary-text" : "border-border-secondary text-text-secondary hover:text-text-primary"
+                    ),
+                    "aria-pressed": selectedStatus === status,
+                    "data-testid": `runs-count-${status}`,
+                    children: tr(
+                      "fluidgrids.executions.parity.countStatus",
+                      "{{status}} {{count}}",
+                      { status: statusLabels[status], count }
+                    )
+                  },
+                  status
+                ) : null
+              )
+            ] })
+          }
+        )
+      ]
+    }
+  );
+}
+function ExecutionsListPage() {
+  const tr = useTr();
+  const navigate = useNavigate();
+  const {
+    viewMode,
+    setViewMode,
+    setSelectedExecution,
+    selection,
+    clearSelection,
+    setStatusFilter,
+    setWorkflowFilter,
+    setWorkflowIdFilter,
+    filter,
+    autoRefresh,
+    autoRefreshInterval
+  } = useExecutionsStore();
+  const [searchParams] = useSearchParams();
+  const workflowKeyParam = searchParams.get("workflowKey") ?? "";
+  const lastWorkflowKeyParam = useRef(null);
+  if (lastWorkflowKeyParam.current !== workflowKeyParam) {
+    lastWorkflowKeyParam.current = workflowKeyParam;
+    if (useExecutionsStore.getState().filter.workflowKey !== workflowKeyParam) {
+      setWorkflowFilter(workflowKeyParam);
+    }
+  }
+  const parityEnabled = useDurableParityEnabled();
+  const phaseC = usePhaseCFlags();
+  const [searchFilter, setSearchFilter] = useState(null);
+  const [allMatching, setAllMatching] = useState(false);
+  const [batchType, setBatchType] = useState(null);
+  const [batchDrawer, setBatchDrawer] = useState(null);
+  const { allowed: canExecuteRuns } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.WORKFLOW_RUN_EXECUTE
+  );
+  const { allowed: canDeleteRuns } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.WORKFLOW_RUN_DELETE
+  );
+  const { executions, total, loading, error, refetch, input } = useExecutionsWithStore({
+    durableParity: parityEnabled,
+    searchAttributes: phaseC.searchAttributes ? searchFilter : null
+  });
+  const inputKey = JSON.stringify({ ...input, limit: 0, offset: 0 });
+  useEffect(() => setAllMatching(false), [inputKey]);
+  const batchOperations = useMemo(
+    () => allowedBatchOperations(
+      {
+        runControl: phaseC.runControl,
+        runControlDurable: phaseC.runControlDurable,
+        runArchival: phaseC.runArchival
+      },
+      { canExecute: canExecuteRuns, canDelete: canDeleteRuns }
+    ),
+    [
+      phaseC.runControl,
+      phaseC.runControlDurable,
+      phaseC.runArchival,
+      canExecuteRuns,
+      canDeleteRuns
+    ]
+  );
+  const statusCounts = useRunStatusCounts(input, parityEnabled);
+  const refetchCounts = statusCounts.refetch;
+  const {
+    stats,
+    loading: statsLoading,
+    refetch: refetchStats
+  } = useExecutionStats();
+  const { workflows } = useWorkflowDefinitions({ limit: 100 });
+  const {
+    cancelExecution,
+    pauseExecution,
+    resumeExecution,
+    retryExecution,
+    retryExecutions
+  } = useExecutionActions();
+  useAutoRefresh(
+    useCallback(() => {
+      refetch();
+      refetchStats();
+      void refetchCounts();
+    }, [refetch, refetchStats, refetchCounts]),
+    autoRefresh,
+    autoRefreshInterval
+  );
+  const executionStats = useMemo(() => {
+    if (!stats) return null;
+    return {
+      total: stats.runsCountTotal,
+      running: stats.runsRunningCount,
+      completed: stats.runsCompletedCount,
+      failed: stats.runsFailedCount,
+      cancelled: stats.runsCancelledCount ?? 0,
+      pending: stats.runsPendingCount,
+      waiting: stats.runsWaitingCount ?? 0,
+      successRate: stats.workflowSuccessRate,
+      avgDuration: stats.avgWorkflowExecutionTimeSeconds
+    };
+  }, [stats]);
+  const workflowOptions = useMemo(
+    () => workflows.map((w) => ({
+      workflowKey: w.workflowKey,
+      name: w.name
+    })),
+    [workflows]
+  );
+  const workflowNames = useMemo(() => {
+    const map = {};
+    for (const w of workflows) map[w.workflowKey] = w.name;
+    return map;
+  }, [workflows]);
+  const handleRowClick = (execution) => {
+    setSelectedExecution(execution);
+    navigate(`../runs/${execution.id}`);
+  };
+  const handleRetry = async (execution) => {
+    const result = await retryExecution(execution);
+    if (!result.ok) {
+      toast.error(
+        tr(
+          "fluidgrids.executions.executionsList.retryFailed",
+          "Could not start a new run"
+        ),
+        { description: result.message }
+      );
+      return;
+    }
+    toast.success(
+      tr(
+        "fluidgrids.executions.executionsList.retryStarted",
+        "New run started"
+      )
+    );
+    navigate(`../runs/${result.run.runId}`);
+  };
+  const handleAction = async (action, execution) => {
+    switch (action) {
+      case "cancel":
+        await cancelExecution(execution.id);
+        break;
+      case "pause":
+        await pauseExecution(execution.id);
+        break;
+      case "resume":
+        await resumeExecution(execution.id);
+        break;
+      case "retry":
+        await handleRetry(execution);
+        break;
+      case "view":
+        navigate(`../runs/${execution.id}`);
+        break;
+    }
+    refetch();
+  };
+  const handleFilterByStatus = (status) => {
+    setStatusFilter(status);
+  };
+  const handleBulkRetry = async () => {
+    if (selection.runIds.length === 0) return;
+    const retried = await retryExecutions(selection.runIds.slice(0, 10));
+    if (retried.length === 0) {
+      toast.error(
+        tr(
+          "fluidgrids.executions.executionsList.bulkRetryFailed",
+          "Could not retry the selected runs"
+        )
+      );
+      return;
+    }
+    toast.success(
+      tr(
+        "fluidgrids.executions.executionsList.bulkRetryStarted",
+        `${retried.length} new run${retried.length === 1 ? "" : "s"} started`
+      )
+    );
+    clearSelection();
+    refetch();
+  };
+  const handleBulkAction = async (action) => {
+    if (selection.runIds.length === 0) return;
+    const promises = selection.runIds.map((id) => {
+      switch (action) {
+        case "cancel":
+          return cancelExecution(id);
+        case "pause":
+          return pauseExecution(id);
+        case "resume":
+          return resumeExecution(id);
+      }
+    });
+    const results = await Promise.allSettled(promises);
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      console.error(
+        `Bulk action partially failed: ${failures.length}/${results.length} failed`
+      );
+    }
+    clearSelection();
+    refetch();
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "p-4 sm:p-6 bg-background-primary min-h-screen", children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4 mb-6",
+        "data-tour": "fluidgrids-runs-header",
+        children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("h1", { className: "text-2xl sm:text-3xl font-bold text-text-primary", children: tr("fluidgrids.executions.executionsList.title", "Executions") }),
+            /* @__PURE__ */ jsx("p", { className: "text-text-secondary mt-1", children: tr(
+              "fluidgrids.executions.executionsList.subtitle",
+              "Monitor and manage your workflow runs"
+            ) }),
+            /* @__PURE__ */ jsx(FluidGridsDocsLink, { topic: "runs", className: "mt-1" })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center bg-background-secondary rounded-lg border border-border-secondary p-1", children: [
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => setViewMode("table"),
+                  className: `p-2 rounded ${viewMode === "table" ? "bg-background-tertiary text-text-primary" : "text-text-secondary hover:text-text-primary"}`,
+                  title: tr(
+                    "fluidgrids.executions.executionsList.tableViewTooltip",
+                    "Table View"
+                  ),
+                  children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:table", width: 18 })
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => setViewMode("cards"),
+                  className: `p-2 rounded ${viewMode === "cards" ? "bg-background-tertiary text-text-primary" : "text-text-secondary hover:text-text-primary"}`,
+                  title: tr(
+                    "fluidgrids.executions.executionsList.cardViewTooltip",
+                    "Card View"
+                  ),
+                  children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:view-grid", width: 18 })
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => setViewMode("timeline"),
+                  className: `p-2 rounded ${viewMode === "timeline" ? "bg-background-tertiary text-text-primary" : "text-text-secondary hover:text-text-primary"}`,
+                  title: tr(
+                    "fluidgrids.executions.executionsList.timelineViewTooltip",
+                    "Timeline View"
+                  ),
+                  children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:timeline", width: 18 })
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs(Button, { variant: "outline", onClick: () => navigate("../list"), children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:arrow-left", className: "mr-2", width: 16 }),
+              tr(
+                "fluidgrids.executions.executionsList.backToWorkflows",
+                "Back to Workflows"
+              )
+            ] })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "mb-6", "data-tour": "fluidgrids-runs-stats", children: /* @__PURE__ */ jsx(
+      ExecutionStats,
+      {
+        stats: executionStats,
+        loading: statsLoading,
+        onFilterByStatus: handleFilterByStatus
+      }
+    ) }),
+    /* @__PURE__ */ jsx("div", { className: "mb-6", "data-tour": "fluidgrids-runs-filters", children: /* @__PURE__ */ jsx(ExecutionFilters, { workflows: workflowOptions, onRefresh: refetch }) }),
+    parityEnabled && /* @__PURE__ */ jsx(
+      RunsParityBar,
+      {
+        workflowId: filter.workflowId,
+        onWorkflowIdChange: setWorkflowIdFilter,
+        total: statusCounts.total,
+        counts: statusCounts.counts,
+        countsError: statusCounts.error,
+        selectedStatus: filter.status,
+        onSelectStatus: handleFilterByStatus
+      }
+    ),
+    phaseC.searchAttributes && /* @__PURE__ */ jsx(
+      SearchAttributeFilterBar,
+      {
+        applied: searchFilter,
+        onApply: setSearchFilter,
+        conflicts: searchFilter ? searchFilterConflicts(input) : []
+      }
+    ),
+    phaseC.runControl && selection.runIds.length === 0 && /* @__PURE__ */ jsx("div", { className: "mb-4 flex justify-end", children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        onClick: () => setBatchDrawer({ job: null }),
+        "data-testid": "batch-jobs-button",
+        children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:layers-triple-outline",
+              className: "mr-1",
+              width: 14
+            }
+          ),
+          tr("fluidgrids.runControl.batch.jobs", "Batch jobs")
+        ]
+      }
+    ) }),
+    selection.runIds.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mb-4 p-3 bg-action-primary-bg/10 rounded-lg flex flex-wrap items-center gap-3", children: [
+      /* @__PURE__ */ jsxs("span", { className: "text-sm text-text-primary", children: [
+        selection.runIds.length,
+        " ",
+        selection.runIds.length > 1 ? tr(
+          "fluidgrids.executions.executionsList.selectionCountPlural",
+          "executions selected"
+        ) : tr(
+          "fluidgrids.executions.executionsList.selectionCountSingular",
+          "execution selected"
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            "data-agent": "confirm",
+            variant: "outline",
+            size: "sm",
+            onClick: () => void handleBulkRetry(),
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:refresh", className: "mr-1", width: 14 }),
+              tr(
+                "fluidgrids.executions.executionsList.bulkRetryButton",
+                "Retry selected"
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            "data-agent": "confirm",
+            variant: "outline",
+            size: "sm",
+            onClick: () => handleBulkAction("cancel"),
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:stop", className: "mr-1", width: 14 }),
+              tr(
+                "fluidgrids.executions.executionsList.bulkCancelButton",
+                "Cancel"
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            "data-agent": "confirm",
+            variant: "outline",
+            size: "sm",
+            onClick: () => handleBulkAction("pause"),
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:pause", className: "mr-1", width: 14 }),
+              tr(
+                "fluidgrids.executions.executionsList.bulkPauseButton",
+                "Pause"
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            "data-agent": "confirm",
+            variant: "outline",
+            size: "sm",
+            onClick: () => handleBulkAction("resume"),
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:play", className: "mr-1", width: 14 }),
+              tr(
+                "fluidgrids.executions.executionsList.bulkResumeButton",
+                "Resume"
+              )
+            ]
+          }
+        )
+      ] }),
+      phaseC.runControl && /* @__PURE__ */ jsxs(Fragment, { children: [
+        selection.allSelected && total > selection.runIds.length && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setAllMatching((current) => !current),
+            className: "text-sm text-action-primary-text hover:underline",
+            "data-testid": "select-all-matching",
+            "aria-pressed": allMatching,
+            children: allMatching ? tr(
+              "fluidgrids.runControl.batch.allMatchingSelected",
+              "All {{count}} matching runs are selected",
+              { count: total }
+            ) : tr(
+              "fluidgrids.runControl.batch.selectAllMatching",
+              "Select all {{count}} matching runs",
+              { count: total }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          BatchMenu,
+          {
+            allowed: batchOperations,
+            onPick: setBatchType,
+            onShowJobs: () => setBatchDrawer({ job: null })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => {
+            setAllMatching(false);
+            clearSelection();
+          },
+          className: "ml-auto text-sm text-text-secondary hover:text-text-primary",
+          children: tr(
+            "fluidgrids.executions.executionsList.clearSelection",
+            "Clear selection"
+          )
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsxs("div", { className: "mb-6 p-4 bg-[var(--color-status-error-bg-subtle)] border border-[var(--color-status-error-border)] rounded-lg", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-[var(--color-status-error-text)]", children: [
+        /* @__PURE__ */ jsx(Icon, { icon: "mdi:alert-circle", width: 20 }),
+        /* @__PURE__ */ jsx("span", { className: "font-medium", children: tr(
+          "fluidgrids.executions.executionsList.loadErrorTitle",
+          "Error loading executions"
+        ) })
+      ] }),
+      /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-[var(--color-status-error-text)]", children: error.message }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "outline",
+          size: "sm",
+          onClick: refetch,
+          className: "mt-3 border-[var(--color-status-error-border)] text-[var(--color-status-error-text)] hover:bg-[var(--color-status-error-bg-subtle)]",
+          children: tr("fluidgrids.executions.executionsList.retryButton", "Retry")
+        }
+      )
+    ] }),
+    viewMode === "table" && /* @__PURE__ */ jsx(
+      ExecutionTable,
+      {
+        workflowNames,
+        executions,
+        loading,
+        onRowClick: handleRowClick,
+        onAction: handleAction
+      }
+    ),
+    viewMode === "cards" && /* @__PURE__ */ jsx(
+      ExecutionCards,
+      {
+        workflowNames,
+        executions,
+        loading,
+        onCardClick: handleRowClick,
+        onAction: handleAction
+      }
+    ),
+    viewMode === "timeline" && /* @__PURE__ */ jsx(
+      ExecutionTimeline,
+      {
+        executions,
+        loading,
+        onItemClick: handleRowClick,
+        onAction: handleAction
+      }
+    ),
+    /* @__PURE__ */ jsx(Pagination, { totalItems: total }),
+    batchType && /* @__PURE__ */ jsx(
+      BatchOperationDialog,
+      {
+        type: batchType,
+        input,
+        selection: { runIds: selection.runIds, allMatching },
+        onClose: () => setBatchType(null),
+        onStarted: (job) => {
+          setBatchType(null);
+          setAllMatching(false);
+          clearSelection();
+          setBatchDrawer({ job });
+        }
+      }
+    ),
+    batchDrawer && /* @__PURE__ */ jsx(
+      BatchProgressDrawer,
+      {
+        job: batchDrawer.job,
+        open: true,
+        onOpenChange: (open) => {
+          if (open) return;
+          setBatchDrawer(null);
+          refetch();
+        },
+        canCancel: canExecuteRuns
+      }
+    )
+  ] });
+}
+
+export { ExecutionsListPage };