@burdenoff/fluidgrids-fe-sdk 2026.1108.1 → 2026.1108.2

package/dist/{chunk-36TEHKVN.js → chunk-ZHXJYOOG.js}

@@ -1,16 +1,17 @@
-import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-XAXZ4T6H.js';
-import { useDurableParityRunFields, hasAgentNodeState, agentNodeTraces, orderNodesByExecution, useRunMetadata, useRunPending, ExecutionStatusBadge, NodeTimeline, RunLogViewer, NodeStatusBadge, setRunVersioningOverride } from './chunk-WX5BNZVX.js';
-import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-2CM26W2I.js';
-import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-NZMUKAXG.js';
+import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-MYPB2KTJ.js';
+import { useDurableParityRunFields, hasAgentNodeState, agentNodeTraces, orderNodesByExecution, useRunPending, useRunMetadata, ExecutionStatusBadge, NodeTimeline, RunLogViewer, NodeStatusBadge, setRunVersioningOverride } from './chunk-RNYFPG7R.js';
+import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-JRR4VKYD.js';
+import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-54NXUOHI.js';
 import { aiCost, formatTokens, modelLabel } from './chunk-NZAYYUQ4.js';
-import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-EXJW7EKR.js';
-import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-PASKZCII.js';
-import { buildNodeDisplayMap, formatRunVersion, nodeDisplayTitle } from './chunk-KHS2DZHH.js';
+import { useRunPolicyDecisions, RunPolicyDecisions, checkCodecServerUrl, containsEncodedPayload, isEncodedPayload, encodedPayloadBytes, decodePayloads, CodecServerError } from './chunk-OJHBCOBA.js';
+import { readTyped, writeTyped, useResource, fetchCodecServerSettings, fetchRunControlFields, fetchPauseRules, RUN_CONTROL_DIALOG_STYLE, fetchRunHistoryArchive, parseJsonInput, NativeSelect, JsonField, FieldError, StatusPill, JsonBlock, fetchSignalTokens, parseJsonObjectInput, queryRun, revokeSignalToken, upsertRunSearchAttributes, newRunControlId, fetchRunUpdate, createSignalToken, pauseActivities, unpauseActivities, resetActivities, updateActivityOptions, completeActivityById, failActivityById, sendRunUpdate, resetRunToLastCleanTask, resetRun } from './chunk-YASVILWQ.js';
+import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-TN3NGTF7.js';
+import { buildNodeDisplayMap, formatRunVersion, nodeDisplayTitle } from './chunk-HICQ4J4W.js';
 import { AiCreditBalanceSlot } from './chunk-Y53CVZVV.js';
-import { useWorkflowVersions } from './chunk-PF7XQA2S.js';
-import { useDurableFunctionNodesEnabled, useDurableParityEnabled, runSignalTargets, canSignalRun, formatElapsedMs, runDurationMs, useWorkflowTestsEnabled } from './chunk-5OVWMFPL.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-5375NUIO.js';
-import { RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument, RunAiUsageDocument } from './chunk-Z3ABLERJ.js';
+import { useWorkflowVersions } from './chunk-KJB3WZVD.js';
+import { useDurableFunctionNodesEnabled, useDurableParityEnabled, usePhaseCFlags, runSignalTargets, canSignalRun, formatElapsedMs, runDurationMs, useWorkflowTestsEnabled, durableInterfaceOf } from './chunk-GI6BQIQA.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-AR22A74Y.js';
+import { TaskQueuesDocument, TaskQueueStatsDocument, CreateTaskQueueDocument, UpdateTaskQueueDocument, DeleteTaskQueueDocument, WorkflowWorkersDocument, WorkerTokensDocument, CreateWorkerTokenDocument, RotateWorkerTokenDocument, DeleteWorkerTokenDocument, SetWorkerTokenConnectionAllowlistDocument, RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument, RunAiUsageDocument } from './chunk-GOZR72NK.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
@@ -20,7 +21,7 @@ import { useParams, useNavigate, useSearchParams, Link } from 'react-router';
 import { Icon } from '@iconify/react';
 import { toast } from 'sonner';
 import { Button } from '@burdenoff/fe-libs/button';
-import { Card, CardHeader, Badge, CardContent, Label, Textarea, AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction, Input, Button as Button$1, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter } from '@burdenoff/fe-libs/ui';
+import { Card, CardHeader, Badge, CardContent, Label, Textarea, AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction, Input, Button as Button$1, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, DropdownMenuSeparator, Switch } from '@burdenoff/fe-libs/ui';
 import { useActorProfiles, buildActorFallback } from '@burdenoff/fe-libs/shared';
 import { gql } from '@apollo/client';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
@@ -463,7 +464,7 @@ function HumanRequestCard({
 }) {
   const tr = useTr();
   const { respond, loading } = useRespondToHumanRequest();
-  const [text, setText] = useState("");
+  const [text2, setText] = useState("");
   const [values, setValues] = useState({});
   const submit = async (answer) => {
     try {
@@ -490,7 +491,7 @@ function HumanRequestCard({
   const missingRequired = request.responseType === "CUSTOM_FORM" && request.fields.some(
     (field) => field.required && !(values[field.name] ?? "").trim()
   );
-  const emptyText = request.responseType === "FREE_TEXT" && !text.trim();
+  const emptyText = request.responseType === "FREE_TEXT" && !text2.trim();
   const recipient = useRecipientLabel(
     request,
     request.channel === "IN_APP" ? tr("fluidgrids.humanResponse.anyMember", "any workspace member") : ""
@@ -547,7 +548,7 @@ function HumanRequestCard({
               Textarea,
               {
                 id: `human-text-${request.id}`,
-                value: text,
+                value: text2,
                 onChange: (event) => setText(event.target.value)
               }
             )
@@ -598,7 +599,7 @@ function HumanRequestCard({
               size: "sm",
               disabled: loading || missingRequired || emptyText,
               onClick: () => submit(
-                request.responseType === "FREE_TEXT" ? { text } : { values }
+                request.responseType === "FREE_TEXT" ? { text: text2 } : { values }
               ),
               "data-testid": "human-request-submit",
               children: [
@@ -1292,7 +1293,7 @@ function urlTransform(url, key) {
   return safeMarkdownHref(url);
 }
 function RunMarkdown({
-  text,
+  text: text2,
   "data-testid": testId
 }) {
   return /* @__PURE__ */ jsx(
@@ -1306,7 +1307,7 @@ function RunMarkdown({
           components: COMPONENTS,
           skipHtml: true,
           urlTransform,
-          children: text
+          children: text2
         }
       )
     }
@@ -1981,6 +1982,2042 @@ function useRunAiUsage(runId, { enabled, live }) {
     refetch: read
   };
 }
+
+// src/modules/task-queues/api.ts
+async function fetchTaskQueues() {
+  return (await readTyped(TaskQueuesDocument, {})).taskQueues;
+}
+async function fetchTaskQueueStats(name, environment) {
+  return (await readTyped(TaskQueueStatsDocument, {
+    name,
+    environment: environment ?? null
+  })).taskQueueStats;
+}
+async function createTaskQueue(input) {
+  return (await writeTyped(CreateTaskQueueDocument, { input })).createTaskQueue;
+}
+async function updateTaskQueue(id, input) {
+  return (await writeTyped(UpdateTaskQueueDocument, { id, input })).updateTaskQueue;
+}
+async function deleteTaskQueue(id) {
+  return (await writeTyped(DeleteTaskQueueDocument, { id })).deleteTaskQueue;
+}
+async function fetchWorkflowWorkers(filter) {
+  return (await readTyped(WorkflowWorkersDocument, { filter: filter ?? null })).workflowWorkers;
+}
+async function fetchWorkerTokens() {
+  return (await readTyped(WorkerTokensDocument, {})).workerTokens;
+}
+async function createWorkerToken(input) {
+  return (await writeTyped(CreateWorkerTokenDocument, input)).createWorkerToken;
+}
+async function rotateWorkerToken(id) {
+  return (await writeTyped(RotateWorkerTokenDocument, { id })).rotateWorkerToken;
+}
+async function deleteWorkerToken(id) {
+  return (await writeTyped(DeleteWorkerTokenDocument, { id })).deleteWorkerToken;
+}
+async function setWorkerTokenConnectionAllowlist(id, names) {
+  return (await writeTyped(SetWorkerTokenConnectionAllowlistDocument, { id, names })).setWorkerTokenConnectionAllowlist;
+}
+
+// src/modules/run-control/utils/activity-pause.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function activityPauseStates(events) {
+  const states = /* @__PURE__ */ new Map();
+  const ordered = [...events].sort((a, b) => a.seq - b.seq);
+  for (const event of ordered) {
+    if (event.type !== "ACTIVITY_PAUSED" && event.type !== "ACTIVITY_UNPAUSED")
+      continue;
+    const activityId = text(event.payload?.["activityId"]);
+    if (!activityId) continue;
+    if (event.type === "ACTIVITY_PAUSED") {
+      states.set(activityId, {
+        paused: true,
+        reason: text(event.payload?.["reason"]),
+        ruleId: text(event.payload?.["ruleId"]),
+        seq: event.seq
+      });
+    } else {
+      states.set(activityId, {
+        paused: false,
+        reason: null,
+        ruleId: null,
+        seq: event.seq
+      });
+    }
+  }
+  return states;
+}
+
+// src/modules/run-control/utils/handlers.ts
+var GRAPH_RUN_QUERIES = [
+  "status",
+  "progress",
+  "nodeStates",
+  "nodeOutput"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function declaredHandlers(definitionJson, workflowFn, kind) {
+  const iface = durableInterfaceOf(definitionJson, workflowFn);
+  if (!iface) return { names: [], openNames: false };
+  const declared = iface[kind];
+  const names = isRecord2(declared) ? Object.keys(declared).sort() : Array.isArray(declared) ? declared.filter((item) => typeof item === "string").sort() : [];
+  const open = isRecord2(iface.open) && iface.open[kind] === true;
+  return { names, openNames: open };
+}
+function isFinalUpdateStatus(status) {
+  return status === "COMPLETED" || status === "REJECTED";
+}
+function updateReached(status, waitFor) {
+  if (isFinalUpdateStatus(status)) return true;
+  return waitFor === "ACCEPTED" && status === "ACCEPTED";
+}
+function RunActivitiesCard({
+  runId,
+  activities,
+  pauseStates,
+  pauseRules,
+  canControl,
+  onChanged
+}) {
+  const tr = useTr();
+  const [action, setAction] = useState(null);
+  const rules = useMemo(
+    () => new Map(pauseRules.map((rule) => [rule.id, rule])),
+    [pauseRules]
+  );
+  if (activities.length === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-6 rounded-lg border border-border-secondary bg-background-secondary",
+      "data-testid": "run-activities-card",
+      children: [
+        /* @__PURE__ */ jsxs("header", { className: "flex flex-wrap items-center gap-2 border-b border-border-secondary px-4 py-3", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:cog-play-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr("fluidgrids.runControl.activities.title", "Activities") }),
+          canControl && /* @__PURE__ */ jsxs("div", { className: "ml-auto flex gap-2", children: [
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "outline",
+                size: "sm",
+                onClick: () => setAction({ kind: "pause", activity: null }),
+                "data-testid": "run-activities-pause-all",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:pause", className: "mr-1", width: 14 }),
+                  tr("fluidgrids.runControl.activities.pauseAll", "Pause all")
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "outline",
+                size: "sm",
+                onClick: () => setAction({ kind: "unpause", activity: null }),
+                "data-testid": "run-activities-unpause-all",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:play", className: "mr-1", width: 14 }),
+                  tr("fluidgrids.runControl.activities.unpauseAll", "Unpause all")
+                ]
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("ul", { className: "divide-y divide-border-secondary", children: activities.map((activity) => {
+          const pause = pauseStates.get(activity.activityId);
+          const rule = pause?.ruleId ? rules.get(pause.ruleId) : void 0;
+          return /* @__PURE__ */ jsxs(
+            "li",
+            {
+              className: "flex flex-wrap items-center gap-3 px-4 py-2.5 text-sm",
+              "data-testid": `run-activity-${activity.activityId}`,
+              children: [
+                /* @__PURE__ */ jsx("code", { className: "font-mono text-xs text-text-primary", children: activity.activityType }),
+                /* @__PURE__ */ jsxs("span", { className: "text-xs text-text-secondary", children: [
+                  activity.state,
+                  " \xB7",
+                  " ",
+                  tr(
+                    "fluidgrids.runControl.activities.attempt",
+                    "attempt {{attempt}}",
+                    {
+                      attempt: activity.maxAttempts ? `${activity.attempt}/${activity.maxAttempts}` : activity.attempt
+                    }
+                  )
+                ] }),
+                pause?.paused && (pause.ruleId ? /* @__PURE__ */ jsx("span", { title: rule?.reason ?? pause.reason ?? void 0, children: /* @__PURE__ */ jsx(StatusPill, { tone: "warning", testId: "activity-paused-by-rule", children: tr(
+                  "fluidgrids.runControl.activities.pausedByRule",
+                  "Paused by rule"
+                ) }) }) : /* @__PURE__ */ jsx("span", { title: pause.reason ?? void 0, children: /* @__PURE__ */ jsx(StatusPill, { tone: "warning", testId: "activity-paused", children: tr("fluidgrids.runControl.activities.paused", "Paused") }) })),
+                canControl && /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+                  /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      variant: "ghost",
+                      size: "sm",
+                      className: "ml-auto",
+                      "aria-label": tr(
+                        "fluidgrids.runControl.activities.menu",
+                        "Activity actions"
+                      ),
+                      "data-testid": `run-activity-menu-${activity.activityId}`,
+                      children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:dots-vertical", width: 16 })
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsxs(
+                    DropdownMenuContent,
+                    {
+                      align: "end",
+                      style: RUN_CONTROL_DIALOG_STYLE,
+                      children: [
+                        pause?.paused ? /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "unpause", activity }),
+                            children: tr(
+                              "fluidgrids.runControl.activities.unpause",
+                              "Unpause"
+                            )
+                          }
+                        ) : /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "pause", activity }),
+                            children: tr("fluidgrids.runControl.activities.pause", "Pause")
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "reset", activity }),
+                            children: tr(
+                              "fluidgrids.runControl.activities.reset",
+                              "Reset attempts"
+                            )
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "options", activity }),
+                            children: tr(
+                              "fluidgrids.runControl.activities.options",
+                              "Change options\u2026"
+                            )
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+                        /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "complete", activity }),
+                            children: tr(
+                              "fluidgrids.runControl.activities.complete",
+                              "Complete\u2026"
+                            )
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(
+                          DropdownMenuItem,
+                          {
+                            onSelect: () => setAction({ kind: "fail", activity }),
+                            children: tr("fluidgrids.runControl.activities.fail", "Fail\u2026")
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ] })
+              ]
+            },
+            activity.activityId
+          );
+        }) }),
+        action && /* @__PURE__ */ jsx(
+          ActivityActionDialog,
+          {
+            runId,
+            action: action.kind,
+            activity: action.activity,
+            onClose: () => setAction(null),
+            onDone: () => {
+              setAction(null);
+              onChanged();
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function optionalMs(text2) {
+  const value = text2.trim();
+  if (!value) return void 0;
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? Math.round(seconds * 1e3) : null;
+}
+function optionalInt(text2) {
+  const value = text2.trim();
+  if (!value) return void 0;
+  return /^\d+$/.test(value) ? Number(value) : null;
+}
+function activityOptionsFrom(form) {
+  const maxRetries = optionalInt(form.maxRetries);
+  const retryDelay = optionalMs(form.retryDelaySeconds);
+  const startToClose = optionalMs(form.startToCloseSeconds);
+  const scheduleToClose = optionalMs(form.scheduleToCloseSeconds);
+  const heartbeat = optionalMs(form.heartbeatSeconds);
+  if ([maxRetries, retryDelay, startToClose, scheduleToClose, heartbeat].includes(
+    null
+  ))
+    return null;
+  const options = {};
+  const retry = {};
+  if (maxRetries !== void 0) retry.maxRetries = maxRetries;
+  if (retryDelay !== void 0) retry.retryDelay = retryDelay;
+  if (Object.keys(retry).length > 0) options.retry = retry;
+  if (startToClose !== void 0) options.startToCloseTimeoutMs = startToClose;
+  if (scheduleToClose !== void 0)
+    options.scheduleToCloseTimeoutMs = scheduleToClose;
+  if (heartbeat !== void 0) options.heartbeatTimeoutMs = heartbeat;
+  return Object.keys(options).length > 0 ? options : null;
+}
+function ActivityActionDialog({
+  runId,
+  action,
+  activity,
+  onClose,
+  onDone
+}) {
+  const tr = useTr();
+  const [reason, setReason] = useState("");
+  const [resetAttempts, setResetAttempts] = useState(false);
+  const [resetHeartbeat, setResetHeartbeat] = useState(false);
+  const [result, setResult] = useState("");
+  const [failureMessage, setFailureMessage] = useState("");
+  const [nonRetryable, setNonRetryable] = useState(false);
+  const [options, setOptions] = useState({
+    maxRetries: "",
+    retryDelaySeconds: "",
+    startToCloseSeconds: "",
+    scheduleToCloseSeconds: "",
+    heartbeatSeconds: ""
+  });
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const selector = activity ? { activityId: activity.activityId } : { all: true };
+  const parsedResult = parseJsonInput(result);
+  const optionsInput = action === "options" ? activityOptionsFrom(options) : null;
+  const valid = action === "pause" ? reason.trim().length > 0 : action === "complete" ? parsedResult.ok : action === "fail" ? failureMessage.trim().length > 0 : action === "options" ? optionsInput !== null : true;
+  const submit = async () => {
+    if (!valid) return;
+    setBusy(true);
+    setError(null);
+    try {
+      if (action === "pause")
+        await pauseActivities({ runId, selector, reason: reason.trim() });
+      else if (action === "unpause")
+        await unpauseActivities({
+          runId,
+          selector,
+          resetAttempts,
+          resetHeartbeat
+        });
+      else if (action === "reset")
+        await resetActivities({ runId, selector, resetHeartbeat });
+      else if (action === "options" && optionsInput)
+        await updateActivityOptions({ runId, selector, options: optionsInput });
+      else if (action === "complete" && activity && parsedResult.ok)
+        await completeActivityById({
+          runId,
+          activityId: activity.activityId,
+          result: parsedResult.value
+        });
+      else if (action === "fail" && activity)
+        await failActivityById({
+          runId,
+          activityId: activity.activityId,
+          failure: {
+            message: failureMessage.trim(),
+            errorType: "UNKNOWN" /* Unknown */,
+            nonRetryable
+          }
+        });
+      onDone();
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const titles = {
+    pause: tr(
+      "fluidgrids.runControl.activities.pauseTitle",
+      "Pause activities"
+    ),
+    unpause: tr(
+      "fluidgrids.runControl.activities.unpauseTitle",
+      "Unpause activities"
+    ),
+    reset: tr(
+      "fluidgrids.runControl.activities.resetTitle",
+      "Reset the attempt count"
+    ),
+    options: tr(
+      "fluidgrids.runControl.activities.optionsTitle",
+      "Change activity options"
+    ),
+    complete: tr(
+      "fluidgrids.runControl.activities.completeTitle",
+      "Complete the activity"
+    ),
+    fail: tr("fluidgrids.runControl.activities.failTitle", "Fail the activity")
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: true, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      "data-testid": "activity-action-dialog",
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: titles[action] }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: activity ? activity.activityType : tr(
+            "fluidgrids.runControl.activities.everyOpen",
+            "Every open activity of the run"
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          action === "pause" && /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "activity-pause-reason", children: tr("fluidgrids.runControl.activities.reason", "Reason") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "activity-pause-reason",
+                value: reason,
+                maxLength: 1e3,
+                onChange: (event) => setReason(event.target.value),
+                "data-testid": "activity-pause-reason"
+              }
+            )
+          ] }),
+          action === "unpause" && /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [
+            tr(
+              "fluidgrids.runControl.activities.resetAttemptsToggle",
+              "Restart the attempt count"
+            ),
+            /* @__PURE__ */ jsx(
+              Switch,
+              {
+                checked: resetAttempts,
+                onCheckedChange: setResetAttempts
+              }
+            )
+          ] }),
+          (action === "unpause" || action === "reset") && /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [
+            tr(
+              "fluidgrids.runControl.activities.resetHeartbeat",
+              "Drop the heartbeat details"
+            ),
+            /* @__PURE__ */ jsx(
+              Switch,
+              {
+                checked: resetHeartbeat,
+                onCheckedChange: setResetHeartbeat
+              }
+            )
+          ] }),
+          action === "options" && /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+            [
+              [
+                "maxRetries",
+                tr(
+                  "fluidgrids.runControl.activities.maxRetries",
+                  "Max retries"
+                )
+              ],
+              [
+                "retryDelaySeconds",
+                tr(
+                  "fluidgrids.runControl.activities.retryDelay",
+                  "First retry delay (s)"
+                )
+              ],
+              [
+                "startToCloseSeconds",
+                tr(
+                  "fluidgrids.runControl.activities.startToClose",
+                  "Start-to-close timeout (s)"
+                )
+              ],
+              [
+                "scheduleToCloseSeconds",
+                tr(
+                  "fluidgrids.runControl.activities.scheduleToClose",
+                  "Schedule-to-close timeout (s)"
+                )
+              ],
+              [
+                "heartbeatSeconds",
+                tr(
+                  "fluidgrids.runControl.activities.heartbeat",
+                  "Heartbeat timeout (s)"
+                )
+              ]
+            ].map(([field, label]) => /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: `activity-option-${field}`, children: label }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  id: `activity-option-${field}`,
+                  inputMode: "decimal",
+                  value: options[field],
+                  onChange: (event) => setOptions((current) => ({
+                    ...current,
+                    [field]: event.target.value
+                  })),
+                  "data-testid": `activity-option-${field}`
+                }
+              )
+            ] }, field)),
+            /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary sm:col-span-2", children: tr(
+              "fluidgrids.runControl.activities.optionsHint",
+              "Empty fields stay as they are. The change applies from the next attempt."
+            ) })
+          ] }),
+          action === "complete" && /* @__PURE__ */ jsx(
+            JsonField,
+            {
+              id: "activity-complete-result",
+              label: tr(
+                "fluidgrids.runControl.activities.result",
+                "Result (JSON, optional)"
+              ),
+              value: result,
+              onChange: setResult,
+              error: parsedResult.ok ? null : parsedResult.error,
+              testId: "activity-complete-result"
+            }
+          ),
+          action === "fail" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "activity-fail-message", children: tr(
+                "fluidgrids.runControl.activities.failureMessage",
+                "Failure message"
+              ) }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  id: "activity-fail-message",
+                  value: failureMessage,
+                  onChange: (event) => setFailureMessage(event.target.value),
+                  "data-testid": "activity-fail-message"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [
+              tr(
+                "fluidgrids.runControl.activities.nonRetryable",
+                "Do not retry"
+              ),
+              /* @__PURE__ */ jsx(
+                Switch,
+                {
+                  checked: nonRetryable,
+                  onCheckedChange: setNonRetryable
+                }
+              )
+            ] })
+          ] }),
+          (action === "complete" || action === "fail") && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.runControl.activities.asyncOnly",
+            "Only an activity that waits for an asynchronous completion can be completed or failed here."
+          ) }),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "activity-action-error" })
+        ] }),
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: onClose, disabled: busy, children: tr("fluidgrids.runControl.common.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => void submit(),
+              disabled: !valid || busy,
+              "data-testid": "activity-action-confirm",
+              children: busy ? tr("fluidgrids.runControl.common.working", "Working\u2026") : titles[action]
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+var CUSTOM = "__custom__";
+var REJECT_CONDITIONS = [
+  "NONE" /* None */,
+  "NOT_OPEN" /* NotOpen */,
+  "NOT_COMPLETED_CLEANLY" /* NotCompletedCleanly */
+];
+function RunQueryPanel({ runId, handlers }) {
+  const tr = useTr();
+  const [choice, setChoice] = useState(handlers.names[0] ?? CUSTOM);
+  const [customName, setCustomName] = useState("");
+  const [args, setArgs] = useState("");
+  const [rejectCondition, setRejectCondition] = useState("NONE" /* None */);
+  const [running, setRunning] = useState(false);
+  const [error, setError] = useState(null);
+  const [answer, setAnswer] = useState(null);
+  const name = choice === CUSTOM ? customName.trim() : choice;
+  const parsed = parseJsonInput(args);
+  const run = async () => {
+    if (!name || !parsed.ok) return;
+    setRunning(true);
+    setError(null);
+    try {
+      setAnswer(
+        await queryRun({ runId, name, args: parsed.value, rejectCondition })
+      );
+    } catch (err) {
+      setAnswer(null);
+      setError(describeOperationError(err));
+    } finally {
+      setRunning(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "space-y-3 rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "run-query-panel",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:help-circle-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr("fluidgrids.runControl.query.title", "Query the run") })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "run-query-name", children: tr("fluidgrids.runControl.query.name", "Query") }),
+            handlers.names.length > 0 && /* @__PURE__ */ jsxs(
+              NativeSelect,
+              {
+                id: "run-query-name",
+                value: choice,
+                onChange: setChoice,
+                testId: "run-query-name",
+                children: [
+                  handlers.names.map((handler) => /* @__PURE__ */ jsx("option", { value: handler, children: handler }, handler)),
+                  /* @__PURE__ */ jsx("option", { value: CUSTOM, children: tr("fluidgrids.runControl.query.other", "Another name\u2026") })
+                ]
+              }
+            ),
+            (choice === CUSTOM || handlers.names.length === 0) && /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: handlers.names.length === 0 ? "run-query-name" : void 0,
+                value: customName,
+                onChange: (event) => setCustomName(event.target.value),
+                placeholder: tr(
+                  "fluidgrids.runControl.query.namePlaceholder",
+                  "query-name"
+                ),
+                "data-testid": "run-query-custom-name"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "run-query-reject", children: tr("fluidgrids.runControl.query.rejectCondition", "Refuse when") }),
+            /* @__PURE__ */ jsxs(
+              NativeSelect,
+              {
+                id: "run-query-reject",
+                value: rejectCondition,
+                onChange: (value) => setRejectCondition(
+                  REJECT_CONDITIONS.find((item) => item === value) ?? "NONE" /* None */
+                ),
+                testId: "run-query-reject",
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "NONE" /* None */, children: tr("fluidgrids.runControl.query.rejectNone", "Never") }),
+                  /* @__PURE__ */ jsx("option", { value: "NOT_OPEN" /* NotOpen */, children: tr(
+                    "fluidgrids.runControl.query.rejectNotOpen",
+                    "The run has ended"
+                  ) }),
+                  /* @__PURE__ */ jsx("option", { value: "NOT_COMPLETED_CLEANLY" /* NotCompletedCleanly */, children: tr(
+                    "fluidgrids.runControl.query.rejectNotClean",
+                    "The run did not complete cleanly"
+                  ) })
+                ]
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(
+          JsonField,
+          {
+            id: "run-query-args",
+            label: tr(
+              "fluidgrids.runControl.query.args",
+              "Arguments (JSON, optional)"
+            ),
+            value: args,
+            onChange: setArgs,
+            rows: 2,
+            error: parsed.ok ? null : parsed.error,
+            testId: "run-query-args"
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { className: "flex justify-end", children: /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            onClick: () => void run(),
+            disabled: !name || !parsed.ok || running,
+            "data-testid": "run-query-send",
+            children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:play", className: "mr-1", width: 16 }),
+              running ? tr("fluidgrids.runControl.query.running", "Asking\u2026") : tr("fluidgrids.runControl.query.run", "Run query")
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx(FieldError, { message: error, testId: "run-query-error" }),
+        answer && /* @__PURE__ */ jsx("div", { className: "space-y-2", "data-testid": "run-query-answer", children: answer.rejected ? /* @__PURE__ */ jsxs(StatusPill, { tone: "warning", testId: "run-query-rejected", children: [
+          tr("fluidgrids.runControl.query.rejected", "Refused"),
+          answer.error ? `: ${answer.error}` : ""
+        ] }) : answer.error ? /* @__PURE__ */ jsx(FieldError, { message: answer.error }) : /* @__PURE__ */ jsx(JsonBlock, { value: answer.value, testId: "run-query-value" }) })
+      ]
+    }
+  );
+}
+function entriesOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return [];
+  return Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+}
+function display(value) {
+  if (Array.isArray(value)) return value.map(String).join(", ");
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function RunSearchAttributesCard({
+  runId,
+  attributes,
+  canEdit,
+  onChanged
+}) {
+  const tr = useTr();
+  const entries = entriesOf(attributes);
+  const [editing, setEditing] = useState(false);
+  const [text2, setText] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const parsed = parseJsonObjectInput(text2);
+  if (entries.length === 0 && !canEdit) return null;
+  const save = async () => {
+    if (!parsed.ok) return;
+    setBusy(true);
+    setError(null);
+    try {
+      await upsertRunSearchAttributes(runId, parsed.value);
+      toast.success(
+        tr(
+          "fluidgrids.runControl.searchAttributes.saved",
+          "Search attributes saved"
+        )
+      );
+      setEditing(false);
+      onChanged();
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-6 rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "run-search-attributes",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "mb-2 flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:tag-search-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr(
+            "fluidgrids.runControl.searchAttributes.title",
+            "Search attributes"
+          ) }),
+          canEdit && !editing && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              className: "ml-auto",
+              onClick: () => {
+                setText("");
+                setEditing(true);
+              },
+              "data-testid": "run-search-attributes-edit",
+              children: tr(
+                "fluidgrids.runControl.searchAttributes.edit",
+                "Set attributes"
+              )
+            }
+          )
+        ] }),
+        entries.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+          "fluidgrids.runControl.searchAttributes.none",
+          "This run has no search attributes."
+        ) }) : /* @__PURE__ */ jsx("dl", { className: "grid gap-x-4 gap-y-1 text-sm sm:grid-cols-[max-content_1fr]", children: entries.map(([name, value]) => /* @__PURE__ */ jsxs("div", { className: "contents", children: [
+          /* @__PURE__ */ jsx("dt", { className: "font-mono text-xs text-text-secondary", children: name }),
+          /* @__PURE__ */ jsx(
+            "dd",
+            {
+              className: "break-words text-text-primary",
+              "data-testid": `run-search-attribute-${name}`,
+              children: display(value)
+            }
+          )
+        ] }, name)) }),
+        editing && /* @__PURE__ */ jsxs("div", { className: "mt-3 space-y-2", children: [
+          /* @__PURE__ */ jsx(
+            JsonField,
+            {
+              id: "run-search-attributes-input",
+              label: tr(
+                "fluidgrids.runControl.searchAttributes.input",
+                "Attributes to set (JSON; null removes one)"
+              ),
+              value: text2,
+              onChange: setText,
+              placeholder: '{"customerId": "c-42", "priorityTier": null}',
+              error: text2.trim() && !parsed.ok ? parsed.error : null,
+              testId: "run-search-attributes-input"
+            }
+          ),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "run-search-attributes-error" }),
+          /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-2", children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => setEditing(false),
+                disabled: busy,
+                children: tr("fluidgrids.runControl.common.cancel", "Cancel")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                onClick: () => void save(),
+                disabled: busy || !text2.trim() || !parsed.ok,
+                "data-testid": "run-search-attributes-save",
+                children: tr("fluidgrids.runControl.common.save", "Save")
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+var UPDATE_POLL_INTERVAL_MS = 1e3;
+var UPDATE_POLL_LIMIT = 30;
+var CUSTOM2 = "__custom__";
+function statusTone(status) {
+  if (status === "COMPLETED") return "success";
+  if (status === "REJECTED") return "error";
+  return "info";
+}
+function RunUpdateDialog(props) {
+  return /* @__PURE__ */ jsx(Dialog, { open: props.open, onOpenChange: props.onOpenChange, children: props.open && /* @__PURE__ */ jsx(RunUpdateForm, { ...props }) });
+}
+function RunUpdateForm({
+  runId,
+  handlers,
+  open,
+  onOpenChange,
+  onDone
+}) {
+  const tr = useTr();
+  const [choice, setChoice] = useState(handlers.names[0] ?? CUSTOM2);
+  const [customName, setCustomName] = useState("");
+  const [args, setArgs] = useState("");
+  const [waitFor, setWaitFor] = useState(
+    "COMPLETED" /* Completed */
+  );
+  const [updateId] = useState(() => newRunControlId("ui-update"));
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(null);
+  const polls = useRef(0);
+  useEffect(() => {
+    if (!open || !result || isFinalUpdateStatus(result.status)) return;
+    if (polls.current >= UPDATE_POLL_LIMIT) return;
+    const timer = setTimeout(() => {
+      polls.current += 1;
+      fetchRunUpdate(runId, result.updateId).then((next) => {
+        setResult(next);
+        if (isFinalUpdateStatus(next.status)) onDone?.(next);
+      }).catch((err) => setError(describeOperationError(err)));
+    }, UPDATE_POLL_INTERVAL_MS);
+    return () => clearTimeout(timer);
+  }, [open, result, runId, onDone]);
+  const name = choice === CUSTOM2 ? customName.trim() : choice;
+  const parsed = parseJsonInput(args);
+  const canSend = !!name && parsed.ok && !sending;
+  const send = async () => {
+    if (!canSend || !parsed.ok) return;
+    setSending(true);
+    setError(null);
+    try {
+      const answer = await sendRunUpdate({
+        runId,
+        name,
+        args: parsed.value,
+        updateId,
+        waitFor
+      });
+      polls.current = 0;
+      setResult(answer);
+      if (updateReached(answer.status, waitFor)) onDone?.(answer);
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setSending(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      className: "max-w-lg",
+      "data-testid": "run-update-dialog",
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runControl.update.title", "Send an update") }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: tr(
+            "fluidgrids.runControl.update.description",
+            "The run's update handler validates and applies it. A rejected update leaves no history."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "run-update-name", children: tr("fluidgrids.runControl.update.name", "Update") }),
+            handlers.names.length > 0 && /* @__PURE__ */ jsxs(
+              NativeSelect,
+              {
+                id: "run-update-name",
+                value: choice,
+                onChange: setChoice,
+                testId: "run-update-name",
+                children: [
+                  handlers.names.map((handler) => /* @__PURE__ */ jsx("option", { value: handler, children: handler }, handler)),
+                  handlers.openNames && /* @__PURE__ */ jsx("option", { value: CUSTOM2, children: tr("fluidgrids.runControl.update.other", "Another name\u2026") })
+                ]
+              }
+            ),
+            (choice === CUSTOM2 || handlers.names.length === 0) && /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: handlers.names.length === 0 ? "run-update-name" : void 0,
+                value: customName,
+                onChange: (event) => setCustomName(event.target.value),
+                placeholder: tr(
+                  "fluidgrids.runControl.update.namePlaceholder",
+                  "update-name"
+                ),
+                "data-testid": "run-update-custom-name"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            JsonField,
+            {
+              id: "run-update-args",
+              label: tr("fluidgrids.runControl.update.args", "Arguments (JSON)"),
+              value: args,
+              onChange: setArgs,
+              placeholder: '{"quantity": 2}',
+              error: parsed.ok ? null : parsed.error,
+              testId: "run-update-args"
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "run-update-wait", children: tr("fluidgrids.runControl.update.waitFor", "Wait until") }),
+            /* @__PURE__ */ jsxs(
+              NativeSelect,
+              {
+                id: "run-update-wait",
+                value: waitFor,
+                onChange: (value) => setWaitFor(
+                  value === "ACCEPTED" /* Accepted */ ? "ACCEPTED" /* Accepted */ : "COMPLETED" /* Completed */
+                ),
+                testId: "run-update-wait",
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "COMPLETED" /* Completed */, children: tr("fluidgrids.runControl.update.waitCompleted", "it completes") }),
+                  /* @__PURE__ */ jsx("option", { value: "ACCEPTED" /* Accepted */, children: tr(
+                    "fluidgrids.runControl.update.waitAccepted",
+                    "it is accepted"
+                  ) })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "run-update-error" }),
+          result && /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "run-update-result", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-sm", children: [
+              /* @__PURE__ */ jsx(
+                StatusPill,
+                {
+                  tone: statusTone(result.status),
+                  testId: "run-update-status",
+                  children: result.status
+                }
+              ),
+              /* @__PURE__ */ jsx("code", { className: "truncate font-mono text-xs text-text-secondary", children: result.updateId })
+            ] }),
+            result.status === "COMPLETED" && result.result !== void 0 && /* @__PURE__ */ jsx(JsonBlock, { value: result.result, testId: "run-update-value" }),
+            result.failure && /* @__PURE__ */ jsx(JsonBlock, { value: result.failure, testId: "run-update-failure" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: () => onOpenChange(false), children: tr("fluidgrids.runControl.common.close", "Close") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => void send(),
+              disabled: !canSend,
+              "data-testid": "run-update-send",
+              children: sending ? tr("fluidgrids.runControl.update.sending", "Sending\u2026") : tr("fluidgrids.runControl.update.send", "Send update")
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function ResetRunDialog(props) {
+  return /* @__PURE__ */ jsx(AlertDialog, { open: props.point !== null, onOpenChange: props.onOpenChange, children: props.point && /* @__PURE__ */ jsx(ResetRunForm, { ...props, point: props.point }) });
+}
+function ResetRunForm({
+  runId,
+  point,
+  onOpenChange,
+  onReset
+}) {
+  const tr = useTr();
+  const [reason, setReason] = useState("");
+  const [reapplySignals, setReapplySignals] = useState(true);
+  const [reapplyUpdates, setReapplyUpdates] = useState(true);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const confirm = async () => {
+    setBusy(true);
+    setError(null);
+    try {
+      const fork = point.kind === "lastClean" ? await resetRunToLastCleanTask({ runId, reason }) : await resetRun({
+        runId,
+        to: { seq: point.seq },
+        reason,
+        reapplySignals,
+        reapplyUpdates
+      });
+      onOpenChange(false);
+      onReset(fork.id);
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    AlertDialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      "data-testid": "run-reset-dialog",
+      children: [
+        /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+          /* @__PURE__ */ jsx(AlertDialogTitle, { children: point.kind === "lastClean" ? tr(
+            "fluidgrids.runControl.reset.lastCleanTitle",
+            "Reset to the last clean task?"
+          ) : tr(
+            "fluidgrids.runControl.reset.hereTitle",
+            "Reset at event #{{seq}}?",
+            {
+              seq: point.seq
+            }
+          ) }),
+          /* @__PURE__ */ jsx(AlertDialogDescription, { children: tr(
+            "fluidgrids.runControl.reset.description",
+            "A new run with the same workflow id replays this run's history up to that point and continues from there. This run is terminated with the reason RESET."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "run-reset-reason", children: tr("fluidgrids.runControl.reset.reason", "Reason (optional)") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "run-reset-reason",
+                value: reason,
+                maxLength: 1e3,
+                onChange: (event) => setReason(event.target.value),
+                "data-testid": "run-reset-reason"
+              }
+            )
+          ] }),
+          point.kind === "seq" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm text-text-primary", children: [
+              tr(
+                "fluidgrids.runControl.reset.reapplySignals",
+                "Re-apply the signals received after it"
+              ),
+              /* @__PURE__ */ jsx(
+                Switch,
+                {
+                  checked: reapplySignals,
+                  onCheckedChange: setReapplySignals,
+                  "data-testid": "run-reset-reapply-signals"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm text-text-primary", children: [
+              tr(
+                "fluidgrids.runControl.reset.reapplyUpdates",
+                "Re-apply the updates received after it"
+              ),
+              /* @__PURE__ */ jsx(
+                Switch,
+                {
+                  checked: reapplyUpdates,
+                  onCheckedChange: setReapplyUpdates,
+                  "data-testid": "run-reset-reapply-updates"
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "run-reset-error" })
+        ] }),
+        /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+          /* @__PURE__ */ jsx(AlertDialogCancel, { disabled: busy, children: tr("fluidgrids.runControl.common.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(
+            AlertDialogAction,
+            {
+              onClick: (event) => {
+                event.preventDefault();
+                void confirm();
+              },
+              disabled: busy,
+              className: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+              "data-testid": "run-reset-confirm",
+              children: busy ? tr("fluidgrids.runControl.reset.resetting", "Resetting\u2026") : tr("fluidgrids.runControl.reset.confirm", "Reset run")
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+var SIGNAL_TOKEN_TTLS = [
+  { seconds: 3600, key: "hour" },
+  { seconds: 86400, key: "day" },
+  { seconds: 604800, key: "week" },
+  { seconds: 2592e3, key: "month" },
+  { seconds: 7776e3, key: "quarter" }
+];
+function signalTokenTtlLabel(tr, key) {
+  switch (key) {
+    case "hour":
+      return tr("fluidgrids.runControl.tokens.ttlOption.hour", "1 hour");
+    case "day":
+      return tr("fluidgrids.runControl.tokens.ttlOption.day", "1 day");
+    case "week":
+      return tr("fluidgrids.runControl.tokens.ttlOption.week", "7 days");
+    case "month":
+      return tr("fluidgrids.runControl.tokens.ttlOption.month", "30 days");
+    case "quarter":
+      return tr("fluidgrids.runControl.tokens.ttlOption.quarter", "90 days");
+  }
+}
+function signalTokenStateLabel(tr, state) {
+  switch (state) {
+    case "active":
+      return tr("fluidgrids.runControl.tokens.state.active", "Active");
+    case "spent":
+      return tr("fluidgrids.runControl.tokens.state.spent", "Spent");
+    case "expired":
+      return tr("fluidgrids.runControl.tokens.state.expired", "Expired");
+    case "revoked":
+      return tr("fluidgrids.runControl.tokens.state.revoked", "Revoked");
+  }
+}
+function parseIpAllowlist(text2) {
+  const values = text2.split(/[\s,]+/).map((item) => item.trim()).filter(Boolean);
+  const pattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})(\/(\d{1,2}))?$/;
+  for (const value of values) {
+    const match = pattern.exec(value);
+    const octets = match ? match.slice(1, 5).map(Number) : [];
+    const prefix = match?.[6] === void 0 ? 32 : Number(match[6]);
+    if (!match || octets.some((octet) => octet > 255) || prefix > 32)
+      return { ok: false, bad: value };
+  }
+  return { ok: true, values: values.slice(0, 50) };
+}
+function tokenState(token) {
+  if (token.revokedAt) return "revoked";
+  if (!token.reusable && token.usedAt) return "spent";
+  if (new Date(token.expiresAt).getTime() <= Date.now()) return "expired";
+  return "active";
+}
+function SignalTokensPanel({
+  runId,
+  signalNames,
+  canCreate
+}) {
+  const tr = useTr();
+  const tokens = useResource(
+    `signal-tokens:${runId}`,
+    true,
+    () => fetchSignalTokens(runId)
+  );
+  const [creating, setCreating] = useState(false);
+  const [created, setCreated] = useState(
+    null
+  );
+  const revoke = async (id) => {
+    try {
+      await revokeSignalToken(id);
+      toast.success(
+        tr("fluidgrids.runControl.tokens.revoked", "Token revoked")
+      );
+      await tokens.refetch();
+    } catch (err) {
+      toast.error(describeOperationError(err));
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "space-y-3 rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "signal-tokens-panel",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:key-chain-variant",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr("fluidgrids.runControl.tokens.title", "Signal tokens") }),
+          canCreate && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              className: "ml-auto",
+              onClick: () => setCreating(true),
+              "data-testid": "signal-token-create",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "mr-1", width: 14 }),
+                tr("fluidgrids.runControl.tokens.create", "New token")
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+          "fluidgrids.runControl.tokens.description",
+          "A token lets another system send a signal to this run with a plain POST, without a FluidGrids credential."
+        ) }),
+        /* @__PURE__ */ jsx(FieldError, { message: tokens.error }),
+        tokens.data && tokens.data.length === 0 && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-sm text-text-secondary",
+            "data-testid": "signal-tokens-empty",
+            children: tr("fluidgrids.runControl.tokens.empty", "No tokens yet.")
+          }
+        ),
+        tokens.data && tokens.data.length > 0 && /* @__PURE__ */ jsx("ul", { className: "divide-y divide-border-secondary rounded-md border border-border-secondary", children: tokens.data.map((token) => {
+          const state = tokenState(token);
+          return /* @__PURE__ */ jsxs(
+            "li",
+            {
+              className: "flex flex-wrap items-center gap-3 px-3 py-2 text-sm",
+              "data-testid": `signal-token-${token.id}`,
+              children: [
+                /* @__PURE__ */ jsx("code", { className: "font-mono text-xs text-text-primary", children: token.signalName }),
+                /* @__PURE__ */ jsx(StatusPill, { tone: state === "active" ? "success" : "neutral", children: signalTokenStateLabel(tr, state) }),
+                /* @__PURE__ */ jsxs("span", { className: "text-xs text-text-secondary", children: [
+                  token.reusable ? tr("fluidgrids.runControl.tokens.reusable", "Reusable") : tr(
+                    "fluidgrids.runControl.tokens.singleUse",
+                    "Single use"
+                  ),
+                  " \xB7 ",
+                  tr(
+                    "fluidgrids.runControl.tokens.expires",
+                    "expires {{date}}",
+                    {
+                      date: new Date(token.expiresAt).toLocaleString()
+                    }
+                  )
+                ] }),
+                state === "active" && canCreate && /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    size: "sm",
+                    variant: "ghost",
+                    className: "ml-auto text-[var(--color-status-error-text)]",
+                    onClick: () => void revoke(token.id),
+                    "data-testid": `signal-token-revoke-${token.id}`,
+                    children: tr("fluidgrids.runControl.tokens.revoke", "Revoke")
+                  }
+                )
+              ]
+            },
+            token.id
+          );
+        }) }),
+        creating && /* @__PURE__ */ jsx(
+          CreateSignalTokenDialog,
+          {
+            runId,
+            signalNames,
+            onClose: () => setCreating(false),
+            onCreated: (next) => {
+              setCreating(false);
+              setCreated(next);
+              void tokens.refetch();
+            }
+          }
+        ),
+        created && /* @__PURE__ */ jsx(
+          SignalTokenCreatedDialog,
+          {
+            created,
+            onClose: () => setCreated(null)
+          }
+        )
+      ]
+    }
+  );
+}
+function CreateSignalTokenDialog({
+  runId,
+  signalNames,
+  onClose,
+  onCreated
+}) {
+  const tr = useTr();
+  const [signalName, setSignalName] = useState(signalNames[0] ?? "");
+  const [ttl, setTtl] = useState(String(2592e3));
+  const [reusable, setReusable] = useState(false);
+  const [ips, setIps] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const allowlist = parseIpAllowlist(ips);
+  const submit = async () => {
+    if (!signalName.trim() || !allowlist.ok) return;
+    setBusy(true);
+    setError(null);
+    try {
+      onCreated(
+        await createSignalToken({
+          runId,
+          signalName: signalName.trim(),
+          ttlSeconds: Number(ttl),
+          reusable,
+          ipAllowlist: allowlist.values
+        })
+      );
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: true, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      "data-testid": "signal-token-dialog",
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runControl.tokens.createTitle", "New signal token") }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: tr(
+            "fluidgrids.runControl.tokens.createDescription",
+            "The token is shown once. Store it where the sending system can read it."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "signal-token-name", children: tr("fluidgrids.runControl.tokens.signal", "Signal") }),
+            signalNames.length > 0 ? /* @__PURE__ */ jsx(
+              NativeSelect,
+              {
+                id: "signal-token-name",
+                value: signalName,
+                onChange: setSignalName,
+                testId: "signal-token-name",
+                children: signalNames.map((name) => /* @__PURE__ */ jsx("option", { value: name, children: name }, name))
+              }
+            ) : /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "signal-token-name",
+                value: signalName,
+                onChange: (event) => setSignalName(event.target.value),
+                "data-testid": "signal-token-name"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "signal-token-ttl", children: tr("fluidgrids.runControl.tokens.ttl", "Lifetime") }),
+            /* @__PURE__ */ jsx(
+              NativeSelect,
+              {
+                id: "signal-token-ttl",
+                value: ttl,
+                onChange: setTtl,
+                testId: "signal-token-ttl",
+                children: SIGNAL_TOKEN_TTLS.map((option) => /* @__PURE__ */ jsx("option", { value: String(option.seconds), children: signalTokenTtlLabel(tr, option.key) }, option.seconds))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [
+            tr(
+              "fluidgrids.runControl.tokens.reusableToggle",
+              "Reusable until it expires"
+            ),
+            /* @__PURE__ */ jsx(
+              Switch,
+              {
+                checked: reusable,
+                onCheckedChange: setReusable,
+                "data-testid": "signal-token-reusable"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "signal-token-ips", children: tr(
+              "fluidgrids.runControl.tokens.ips",
+              "Allowed IPv4 addresses or ranges (optional)"
+            ) }),
+            /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                id: "signal-token-ips",
+                rows: 2,
+                value: ips,
+                onChange: (event) => setIps(event.target.value),
+                placeholder: "203.0.113.10, 198.51.100.0/24",
+                className: "font-mono text-xs",
+                "data-testid": "signal-token-ips"
+              }
+            ),
+            !allowlist.ok && /* @__PURE__ */ jsx(
+              FieldError,
+              {
+                message: tr(
+                  "fluidgrids.runControl.tokens.badIp",
+                  "Not an IPv4 address or range: {{value}}",
+                  { value: allowlist.bad }
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { message: error, testId: "signal-token-error" })
+        ] }),
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: onClose, disabled: busy, children: tr("fluidgrids.runControl.common.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => void submit(),
+              disabled: busy || !signalName.trim() || !allowlist.ok,
+              "data-testid": "signal-token-submit",
+              children: tr("fluidgrids.runControl.tokens.createButton", "Create token")
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+function SignalTokenCreatedDialog({
+  created,
+  onClose
+}) {
+  const tr = useTr();
+  const copy = async (text2) => {
+    try {
+      await navigator.clipboard.writeText(text2);
+      toast.success(tr("fluidgrids.runControl.common.copied", "Copied"));
+    } catch {
+      toast.error(
+        tr(
+          "fluidgrids.runControl.common.copyFailed",
+          "Could not copy; select the text instead."
+        )
+      );
+    }
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: true, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      style: RUN_CONTROL_DIALOG_STYLE,
+      "data-testid": "signal-token-created",
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runControl.tokens.createdTitle", "Token created") }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: tr(
+            "fluidgrids.runControl.tokens.createdDescription",
+            "Copy it now: it cannot be shown again. POST the signal's payload as JSON to the URL."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { children: tr("fluidgrids.runControl.tokens.url", "Signal URL") }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+              /* @__PURE__ */ jsx(
+                "code",
+                {
+                  className: "min-w-0 flex-1 break-all rounded-md bg-background-primary p-2 font-mono text-xs text-text-primary",
+                  "data-testid": "signal-token-url",
+                  children: created.url
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  size: "sm",
+                  variant: "outline",
+                  onClick: () => void copy(created.url),
+                  children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:content-copy", width: 14 })
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { children: tr("fluidgrids.runControl.tokens.token", "Token") }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+              /* @__PURE__ */ jsx(
+                "code",
+                {
+                  className: "min-w-0 flex-1 break-all rounded-md bg-background-primary p-2 font-mono text-xs text-text-primary",
+                  "data-testid": "signal-token-value",
+                  children: created.token
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  size: "sm",
+                  variant: "outline",
+                  onClick: () => void copy(created.token),
+                  children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:content-copy", width: 14 })
+                }
+              )
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(DialogFooter, { children: /* @__PURE__ */ jsx(Button, { onClick: onClose, "data-testid": "signal-token-created-done", children: tr("fluidgrids.runControl.common.done", "Done") }) })
+      ]
+    }
+  ) });
+}
+function shouldShowWaitingForWorker(props) {
+  return !!props.taskQueue && props.taskQueue !== "managed" && props.waiting && props.pollers === 0;
+}
+function WaitingForWorkerBanner(props) {
+  const tr = useTr();
+  if (!shouldShowWaitingForWorker(props)) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "status",
+      className: "mb-6 flex items-start gap-2 rounded-lg border border-[var(--color-status-warning-border)] bg-[var(--color-status-warning-bg-subtle)] p-3 text-sm text-[var(--color-status-warning-text)]",
+      "data-testid": "waiting-for-worker",
+      children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            icon: "mdi:server-network-off",
+            width: 18,
+            className: "mt-0.5 shrink-0"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.runControl.worker.waiting",
+          "Waiting for a worker on queue {{queue}}. Start a worker that serves this queue to continue the run.",
+          { queue: props.taskQueue ?? "" }
+        ) })
+      ]
+    }
+  );
+}
+var QUEUE_STATS_INTERVAL_MS = 6e4;
+function isRunOpen(status) {
+  return status === "RUNNING" || status === "PENDING" || status === "WAITING";
+}
+function RunControlSection({
+  run,
+  flags,
+  canControl,
+  activities,
+  workflowTaskWaiting,
+  historyEvents,
+  signalNames,
+  onChanged,
+  onOpenRun,
+  resetPoint,
+  onResetPointChange
+}) {
+  const tr = useTr();
+  const durable = run.executionKind === "DURABLE_FN";
+  const open = isRunOpen(run.status);
+  const runControl = durable ? flags.runControlDurable : flags.runControl;
+  const [updateOpen, setUpdateOpen] = useState(false);
+  const [panel, setPanel] = useState(null);
+  const fieldsEnabled = flags.searchAttributes || flags.selfHostedWorkers;
+  const fields = useResource(
+    `run-control-fields:${run.id}`,
+    fieldsEnabled,
+    () => fetchRunControlFields(run.id)
+  );
+  const activitiesShown = durable && open && flags.runControlDurable && activities.length > 0;
+  const rules = useResource(
+    "pause-rules",
+    activitiesShown,
+    fetchPauseRules
+  );
+  const queue = run.taskQueue ?? null;
+  const waiting = workflowTaskWaiting || activities.some((activity) => activity.state === "SCHEDULED");
+  const statsEnabled = flags.selfHostedWorkers && durable && open && !!queue && queue !== "managed" && waiting;
+  const stats = useResource(
+    `queue-stats:${queue ?? ""}`,
+    statsEnabled,
+    () => fetchTaskQueueStats(queue ?? "managed"),
+    { live: true, intervalMs: QUEUE_STATS_INTERVAL_MS }
+  );
+  const updates = declaredHandlers(
+    run.definitionJson,
+    run.workflowFn,
+    "updates"
+  );
+  const declaredQueries = declaredHandlers(
+    run.definitionJson,
+    run.workflowFn,
+    "queries"
+  );
+  const queries = durable ? declaredQueries : { names: [...GRAPH_RUN_QUERIES], openNames: false };
+  const pauseStates = activityPauseStates(historyEvents);
+  const showUpdate = runControl && durable && open && canControl;
+  const showReset = runControl && durable && canControl;
+  const showQuery = runControl;
+  const showTokens = runControl && durable && open;
+  return /* @__PURE__ */ jsxs("div", { "data-testid": "run-control-section", children: [
+    (showUpdate || showReset || showQuery || showTokens) && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "mb-4 flex flex-wrap items-center gap-2",
+        "data-testid": "run-control-actions",
+        children: [
+          showUpdate && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: () => setUpdateOpen(true),
+              "data-testid": "run-update-button",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:send-check-outline", className: "mr-1", width: 16 }),
+                tr("fluidgrids.runControl.actions.update", "Update")
+              ]
+            }
+          ),
+          showQuery && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: panel === "query" ? "default" : "outline",
+              size: "sm",
+              "aria-pressed": panel === "query",
+              onClick: () => setPanel(panel === "query" ? null : "query"),
+              "data-testid": "run-query-button",
+              children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:help-circle-outline",
+                    className: "mr-1",
+                    width: 16
+                  }
+                ),
+                tr("fluidgrids.runControl.actions.query", "Query")
+              ]
+            }
+          ),
+          showTokens && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: panel === "tokens" ? "default" : "outline",
+              size: "sm",
+              "aria-pressed": panel === "tokens",
+              onClick: () => setPanel(panel === "tokens" ? null : "tokens"),
+              "data-testid": "run-tokens-button",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:key-chain-variant", className: "mr-1", width: 16 }),
+                tr("fluidgrids.runControl.actions.tokens", "Signal tokens")
+              ]
+            }
+          ),
+          showReset && /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+            /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "outline",
+                size: "sm",
+                "data-testid": "run-reset-menu",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:restore", className: "mr-1", width: 16 }),
+                  tr("fluidgrids.runControl.actions.reset", "Reset"),
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:chevron-down", className: "ml-1", width: 14 })
+                ]
+              }
+            ) }),
+            /* @__PURE__ */ jsx(DropdownMenuContent, { style: RUN_CONTROL_DIALOG_STYLE, children: /* @__PURE__ */ jsx(
+              DropdownMenuItem,
+              {
+                onSelect: () => onResetPointChange({ kind: "lastClean" }),
+                "data-testid": "run-reset-last-clean",
+                children: tr(
+                  "fluidgrids.runControl.actions.resetLastClean",
+                  "Reset to last clean task"
+                )
+              }
+            ) })
+          ] }),
+          showReset && /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.runControl.actions.resetHint",
+            "Or use Reset here on an event in History."
+          ) })
+        ]
+      }
+    ),
+    statsEnabled && /* @__PURE__ */ jsx(
+      WaitingForWorkerBanner,
+      {
+        taskQueue: queue,
+        waiting,
+        pollers: stats.data?.pollers ?? null
+      }
+    ),
+    panel === "query" && showQuery && /* @__PURE__ */ jsx("div", { className: "mb-6", children: /* @__PURE__ */ jsx(RunQueryPanel, { runId: run.id, handlers: queries }) }),
+    panel === "tokens" && showTokens && /* @__PURE__ */ jsx("div", { className: "mb-6", children: /* @__PURE__ */ jsx(
+      SignalTokensPanel,
+      {
+        runId: run.id,
+        signalNames,
+        canCreate: canControl
+      }
+    ) }),
+    flags.searchAttributes && fields.data && /* @__PURE__ */ jsx(
+      RunSearchAttributesCard,
+      {
+        runId: run.id,
+        attributes: fields.data.searchAttributes,
+        canEdit: canControl,
+        onChanged: () => void fields.refetch()
+      }
+    ),
+    activitiesShown && /* @__PURE__ */ jsx(
+      RunActivitiesCard,
+      {
+        runId: run.id,
+        activities,
+        pauseStates,
+        pauseRules: rules.data ?? [],
+        canControl,
+        onChanged
+      }
+    ),
+    showUpdate && /* @__PURE__ */ jsx(
+      RunUpdateDialog,
+      {
+        runId: run.id,
+        handlers: updates,
+        open: updateOpen,
+        onOpenChange: setUpdateOpen,
+        onDone: onChanged
+      }
+    ),
+    showReset && /* @__PURE__ */ jsx(
+      ResetRunDialog,
+      {
+        runId: run.id,
+        point: resetPoint,
+        onOpenChange: (next) => !next && onResetPointChange(null),
+        onReset: onOpenRun
+      }
+    )
+  ] });
+}
+function describeCodecError(tr, err) {
+  if (!(err instanceof CodecServerError))
+    return tr(
+      "fluidgrids.runControl.codec.errors.failed",
+      "The payload could not be decoded."
+    );
+  switch (err.code) {
+    case "invalidUrl":
+      return tr(
+        "fluidgrids.runControl.codec.errors.invalidUrl",
+        "The codec server URL must be https (or http to localhost)."
+      );
+    case "unreachable":
+      return tr(
+        "fluidgrids.runControl.codec.errors.unreachable",
+        "The codec server could not be reached: {{detail}}",
+        { detail: err.params.detail ?? "" }
+      );
+    case "http":
+      return tr(
+        "fluidgrids.runControl.codec.errors.http",
+        "The codec server answered HTTP {{status}}.",
+        { status: err.params.status ?? 0 }
+      );
+    case "notPayloadList":
+      return tr(
+        "fluidgrids.runControl.codec.errors.notPayloadList",
+        "The codec server's answer is not a list of payloads."
+      );
+    case "notJson":
+      return tr(
+        "fluidgrids.runControl.codec.errors.notJson",
+        "The codec server returned a payload that is not JSON."
+      );
+  }
+}
+var MAX_DEPTH = 32;
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+function PayloadView({
+  value,
+  codecServer,
+  fetchImpl
+}) {
+  if (!containsEncodedPayload(value)) {
+    return /* @__PURE__ */ jsx("pre", { className: "mt-1 max-h-48 overflow-auto whitespace-pre-wrap break-words rounded bg-background-secondary p-2 font-mono text-text-primary", children: JSON.stringify(value, null, 2) });
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "mt-1 max-h-64 overflow-auto rounded bg-background-secondary p-2 font-mono text-text-primary",
+      "data-testid": "payload-view",
+      children: /* @__PURE__ */ jsx(
+        PayloadNode,
+        {
+          value,
+          codecServer,
+          fetchImpl,
+          depth: 0
+        }
+      )
+    }
+  );
+}
+function PayloadNode({
+  value,
+  codecServer,
+  fetchImpl,
+  depth
+}) {
+  if (isEncodedPayload(value))
+    return /* @__PURE__ */ jsx(
+      EncodedPayloadChip,
+      {
+        payload: value,
+        codecServer,
+        fetchImpl
+      }
+    );
+  if (depth >= MAX_DEPTH || !containsEncodedPayload(value))
+    return /* @__PURE__ */ jsx("span", { className: "whitespace-pre-wrap break-words", children: JSON.stringify(value) });
+  const entries = Array.isArray(value) ? value.map((item, index) => [String(index), item]) : typeof value === "object" && value !== null ? Object.entries(value) : [];
+  const open = Array.isArray(value) ? "[" : "{";
+  const close = Array.isArray(value) ? "]" : "}";
+  return /* @__PURE__ */ jsxs("span", { children: [
+    open,
+    /* @__PURE__ */ jsx("span", { className: "block pl-4", children: entries.map(([key, item]) => /* @__PURE__ */ jsxs("span", { className: "block", children: [
+      !Array.isArray(value) && /* @__PURE__ */ jsxs("span", { className: "text-text-secondary", children: [
+        JSON.stringify(key),
+        ":",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(
+        PayloadNode,
+        {
+          value: item,
+          codecServer,
+          fetchImpl,
+          depth: depth + 1
+        }
+      )
+    ] }, key)) }),
+    close
+  ] });
+}
+function EncodedPayloadChip({
+  payload,
+  codecServer,
+  fetchImpl
+}) {
+  const tr = useTr();
+  const [decoded, setDecoded] = useState(null);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  if (decoded && !isEncodedPayload(decoded.value)) {
+    return /* @__PURE__ */ jsxs("span", { className: "inline-block align-top", "data-testid": "payload-decoded", children: [
+      /* @__PURE__ */ jsx("span", { className: "mr-1 rounded border border-border-secondary px-1 text-[10px] uppercase text-text-secondary", children: tr("fluidgrids.runControl.payload.decoded", "decoded") }),
+      /* @__PURE__ */ jsx("span", { className: "whitespace-pre-wrap break-words", children: JSON.stringify(decoded.value, null, 2) })
+    ] });
+  }
+  const decode = async () => {
+    if (!codecServer) return;
+    setBusy(true);
+    setError(null);
+    try {
+      const [value] = await decodePayloads(codecServer, [payload], fetchImpl);
+      setDecoded({ value });
+      if (isEncodedPayload(value))
+        setError(
+          tr(
+            "fluidgrids.runControl.payload.stillEncoded",
+            "The codec server could not decode this payload."
+          )
+        );
+    } catch (err) {
+      setError(describeCodecError(tr, err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: "inline-flex flex-wrap items-center gap-2 align-middle",
+      "data-testid": "payload-encoded",
+      children: [
+        /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 rounded border border-border-secondary bg-background-tertiary px-1.5 py-0.5 text-xs text-text-secondary", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:lock-outline", width: 12 }),
+          tr("fluidgrids.runControl.payload.encoded", "Encoded payload"),
+          " \xB7",
+          " ",
+          payload.encoding,
+          " \xB7 ",
+          formatBytes(encodedPayloadBytes(payload))
+        ] }),
+        codecServer && /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            className: "h-6 px-2 text-xs",
+            onClick: () => void decode(),
+            disabled: busy,
+            "data-testid": "payload-decode",
+            children: busy ? tr("fluidgrids.runControl.payload.decoding", "Decoding\u2026") : tr("fluidgrids.runControl.payload.decode", "Decode")
+          }
+        ),
+        /* @__PURE__ */ jsx(FieldError, { message: error, testId: "payload-decode-error" })
+      ]
+    }
+  );
+}
+function RunArchivedNotice({
+  runId,
+  enabled
+}) {
+  const tr = useTr();
+  const archive = useResource(
+    `run-archive:${runId}`,
+    enabled,
+    () => fetchRunHistoryArchive(runId)
+  );
+  if (!archive.data?.archived) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "status",
+      className: "flex items-start gap-2 rounded-md border border-border-secondary bg-background-tertiary p-3 text-sm text-text-primary",
+      "data-testid": "run-archived",
+      children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            icon: "mdi:archive-outline",
+            width: 18,
+            className: "mt-0.5 shrink-0 text-text-secondary"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.runControl.archive.archived",
+          "This run's history was archived and then purged by retention. It is in {{ref}}.",
+          {
+            ref: archive.data.archiveRef ?? tr(
+              "fluidgrids.runControl.archive.unknownRef",
+              "the workspace's archive bucket"
+            )
+          }
+        ) })
+      ]
+    }
+  );
+}
+function useCodecServer(enabled) {
+  const settings = useResource(
+    "codec-server",
+    enabled,
+    fetchCodecServerSettings
+  );
+  return useMemo(() => {
+    const url = settings.data?.codecServerUrl;
+    if (!url || !checkCodecServerUrl(url).ok) return null;
+    return {
+      url,
+      includeCredentials: settings.data?.codecServerIncludeCredentials === true
+    };
+  }, [settings.data]);
+}
 function formatTime(value) {
   if (!value) return null;
   const date = new Date(value);
@@ -2904,6 +4941,9 @@ function ExecutionDetailPage() {
   );
   const durableEnabled = useDurableFunctionNodesEnabled();
   const parityEnabled = useDurableParityEnabled();
+  const phaseC = usePhaseCFlags();
+  const phaseCEnabled = phaseC.runControl || phaseC.searchAttributes || phaseC.selfHostedWorkers;
+  const [resetPoint, setResetPoint] = useState(null);
   const [showSignalDialog, setShowSignalDialog] = useState(false);
   const [showOverrideDialog, setShowOverrideDialog] = useState(false);
   const [minLogLevel, setMinLogLevel] = useState(null);
@@ -3018,10 +5058,20 @@ function ExecutionDetailPage() {
     ),
     [execution?.nodeStates, execution?.triggerNodeId]
   );
+  const activityControls = isDurableRun && phaseC.runControlDurable;
+  const runPending = useRunPending(runId, {
+    enabled: (parityEnabled || activityControls) && runCanChange,
+    live: isActive
+  });
+  const pendingActivities = runPending.pending?.activities ?? [];
+  const activityControlsShown = activityControls && runCanChange && pendingActivities.length > 0;
   const runHistory = useRunHistory(runId, {
-    enabled: isDurableRun && activeTab === "history",
+    enabled: isDurableRun && (activeTab === "history" || activityControlsShown),
     live: isActive
   });
+  const codecServer = useCodecServer(
+    isDurableRun && phaseC.selfHostedWorkers && activeTab === "history"
+  );
   const determinism = useDeterminismStatus(runId, {
     enabled: isDurableRun && runCanChange,
     live: isActive
@@ -3035,10 +5085,6 @@ function ExecutionDetailPage() {
     error: runMetadata.error,
     refetch: runMetadata.refetch
   } : stackTrace;
-  const runPending = useRunPending(runId, {
-    enabled: parityEnabled && runCanChange,
-    live: isActive
-  });
   const parityRun = parityEnabled && execution && parityFields.fields?.id === execution.id ? parityFields.fields : null;
   const signalTargets = useMemo(
     () => durableEnabled && execution ? runSignalTargets(execution) : { targets: [], openNames: false },
@@ -3716,6 +5762,32 @@ function ExecutionDetailPage() {
           onViewChildRun: handleViewChildRun
         }
       ),
+      phaseCEnabled && /* @__PURE__ */ jsx(
+        RunControlSection,
+        {
+          run: {
+            id: execution.id,
+            status: execution.status,
+            executionKind: isDurableRun ? "DURABLE_FN" : "GRAPH",
+            workflowFn: execution.workflowFn,
+            taskQueue: execution.taskQueue,
+            definitionJson: execution.workflow?.definitionJson
+          },
+          flags: phaseC,
+          canControl: canControlRuns,
+          activities: activityControlsShown ? pendingActivities : [],
+          workflowTaskWaiting: runPending.pending?.workflowTask?.state === "SCHEDULED",
+          historyEvents: activityControlsShown ? runHistory.events : [],
+          signalNames: signalTargets.targets.map((target) => target.name),
+          onChanged: () => {
+            void refetch();
+            void runPending.refetch();
+          },
+          onOpenRun: (newRunId) => navigate(`../runs/${newRunId}`),
+          resetPoint,
+          onResetPointChange: setResetPoint
+        }
+      ),
       /* @__PURE__ */ jsx("div", { className: "border-b border-border-secondary mb-6", children: /* @__PURE__ */ jsx("nav", { className: "flex gap-4 -mb-px overflow-x-auto", children: tabs.map((tab) => /* @__PURE__ */ jsxs(
         "button",
         {
@@ -3756,6 +5828,7 @@ function ExecutionDetailPage() {
           }
         ) }),
         activeTab === "history" && isDurableRun && /* @__PURE__ */ jsxs("div", { className: "space-y-4 p-4 sm:p-6", children: [
+          phaseC.runArchival && /* @__PURE__ */ jsx(RunArchivedNotice, { runId: execution.id, enabled: true }),
           runCanChange && /* @__PURE__ */ jsx(
             WaitingAtPanel,
             {
@@ -3778,7 +5851,24 @@ function ExecutionDetailPage() {
               historyLength: runHistory.historyLength,
               onRefresh: () => void runHistory.refetch(),
               onViewChildRun: handleViewChildRun,
-              showBenign: parityEnabled
+              showBenign: parityEnabled,
+              renderPayload: phaseC.selfHostedWorkers ? (event) => /* @__PURE__ */ jsx(
+                PayloadView,
+                {
+                  value: event.payload,
+                  codecServer
+                }
+              ) : void 0,
+              eventActions: phaseC.runControlDurable && canControlRuns ? (event) => /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "text-action-primary-text hover:underline",
+                  onClick: () => setResetPoint({ kind: "seq", seq: event.seq }),
+                  "data-testid": `history-reset-here-${event.seq}`,
+                  children: tr("fluidgrids.runControl.reset.here", "Reset here")
+                }
+              ) : void 0
             }
           )
         ] }),
@@ -4009,4 +6099,4 @@ function ExecutionDetailPage() {
   );
 }
 
-export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests };
+export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, createTaskQueue, createWorkerToken, deleteTaskQueue, deleteWorkerToken, fetchTaskQueueStats, fetchTaskQueues, fetchWorkerTokens, fetchWorkflowWorkers, rotateWorkerToken, setWorkerTokenConnectionAllowlist, updateTaskQueue, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests };