@burdenoff/fluidgrids-fe-sdk 2026.1101.1 → 2026.1101.3

package/dist/chunk-OSQ3OCR3.js

@@ -0,0 +1,1193 @@
+import { throwIfResultError, describeOperationError, signalPayloadCard, components_default, payloadFromCardValues, parseRawSignalPayload } from './chunk-NZJWKVER.js';
+import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-IHEV5HTD.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
+import { useState, useMemo, useRef, useCallback, useEffect } from 'react';
+import { Icon } from '@iconify/react';
+import { Button } from '@burdenoff/fe-libs/button';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label, Textarea, DialogFooter, Input } from '@burdenoff/fe-libs/ui';
+
+// src/modules/executions/utils/run-history.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function payloadOf(event) {
+  return isRecord(event.payload) ? event.payload : {};
+}
+function mergeHistoryEvents(current, incoming) {
+  if (incoming.length === 0) return current;
+  const seen = new Set(current.map((event) => event.seq));
+  const fresh = incoming.filter((event) => {
+    if (seen.has(event.seq)) return false;
+    seen.add(event.seq);
+    return true;
+  });
+  if (fresh.length === 0) return current;
+  return [...current, ...fresh].sort((a, b) => a.seq - b.seq);
+}
+function lastSeqOf(events) {
+  return events.length ? events[events.length - 1].seq : 0;
+}
+function formatDurationMs(ms) {
+  if (ms < 1e3) return `${Math.max(0, Math.round(ms))}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    const rest2 = seconds % 60;
+    return rest2 ? `${minutes}m ${rest2}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    const rest2 = minutes % 60;
+    return rest2 ? `${hours}h ${rest2}m` : `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  const rest = hours % 24;
+  return rest ? `${days}d ${rest}h` : `${days}d`;
+}
+function failureOf(value) {
+  if (!isRecord(value)) return void 0;
+  const message = str(value.message);
+  if (!message) return void 0;
+  return {
+    message,
+    errorType: str(value.errorType) ?? str(value.type),
+    ...value.category === "BENIGN" ? { benign: true } : {}
+  };
+}
+function groupKeyOf(event) {
+  const payload = payloadOf(event);
+  const type = event.type;
+  if (type.startsWith("WORKFLOW_TASK_")) {
+    return ["task", str(payload.taskId) ?? str(event.taskId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("ACTIVITY_")) {
+    return ["activity", str(payload.activityId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("LOCAL_ACTIVITY_")) {
+    return ["activity", str(payload.localActivityId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("TIMER_")) {
+    return ["timer", str(payload.timerId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("CHILD_RUN_")) {
+    return ["child", str(payload.childId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("EXTERNAL_RUN_")) {
+    return ["external", str(payload.externalId) ?? `${event.seq}`];
+  }
+  if (type.startsWith("UPDATE_")) {
+    return ["update", str(payload.updateId) ?? `${event.seq}`];
+  }
+  if (type === "SIGNAL_RECEIVED") return ["signal", `${event.seq}`];
+  if (type === "MARKER_RECORDED") return ["marker", `${event.seq}`];
+  if (type === "SIDE_EFFECT_RECORDED") return ["sideEffect", `${event.seq}`];
+  if (type === "CONTEXT_UPSERTED") return ["context", `${event.seq}`];
+  if (type.startsWith("WORKFLOW_")) return ["workflow", `${event.seq}`];
+  return ["other", `${event.seq}`];
+}
+var ACTIVITY_STATUS = {
+  ACTIVITY_SCHEDULED: "scheduled",
+  ACTIVITY_STARTED: "running",
+  ACTIVITY_COMPLETED: "completed",
+  ACTIVITY_FAILED: "failed",
+  ACTIVITY_TIMED_OUT: "timedOut",
+  ACTIVITY_CANCEL_REQUESTED: "cancelRequested",
+  ACTIVITY_CANCELLED: "cancelled",
+  LOCAL_ACTIVITY_COMPLETED: "completed",
+  LOCAL_ACTIVITY_FAILED: "failed"
+};
+var TASK_STATUS = {
+  WORKFLOW_TASK_SCHEDULED: "scheduled",
+  WORKFLOW_TASK_STARTED: "running",
+  WORKFLOW_TASK_COMPLETED: "completed",
+  WORKFLOW_TASK_FAILED: "failed",
+  WORKFLOW_TASK_TIMED_OUT: "timedOut"
+};
+var TIMER_STATUS = {
+  TIMER_STARTED: "running",
+  TIMER_FIRED: "fired",
+  TIMER_CANCELLED: "cancelled"
+};
+var CHILD_STATUS = {
+  CHILD_RUN_INITIATED: "scheduled",
+  CHILD_RUN_STARTED: "running",
+  CHILD_RUN_COMPLETED: "completed",
+  CHILD_RUN_FAILED: "failed",
+  CHILD_RUN_CANCELLED: "cancelled",
+  CHILD_RUN_TERMINATED: "terminated",
+  CHILD_RUN_TIMED_OUT: "timedOut"
+};
+var WORKFLOW_STATUS = {
+  WORKFLOW_STARTED: "running",
+  WORKFLOW_COMPLETED: "completed",
+  WORKFLOW_FAILED: "failed",
+  WORKFLOW_CANCELLED: "cancelled",
+  WORKFLOW_CANCEL_REQUESTED: "cancelRequested",
+  WORKFLOW_TERMINATED: "terminated",
+  WORKFLOW_TIMED_OUT: "timedOut",
+  WORKFLOW_CONTINUED_AS_NEW: "continued"
+};
+var EXTERNAL_STATUS = {
+  EXTERNAL_RUN_CANCEL_REQUESTED: "cancelRequested",
+  EXTERNAL_RUN_CANCEL_RESOLVED: "completed",
+  EXTERNAL_RUN_SIGNALED: "completed"
+};
+var UPDATE_STATUS = {
+  UPDATE_ADMITTED: "scheduled",
+  UPDATE_ACCEPTED: "running",
+  UPDATE_COMPLETED: "completed"
+};
+var FINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "timedOut",
+  "cancelled",
+  "terminated",
+  "continued",
+  "fired",
+  "received",
+  "recorded"
+]);
+function statusFor(kind, type) {
+  switch (kind) {
+    case "activity":
+      return ACTIVITY_STATUS[type];
+    case "task":
+      return TASK_STATUS[type];
+    case "timer":
+      return TIMER_STATUS[type];
+    case "child":
+      return CHILD_STATUS[type];
+    case "workflow":
+      return WORKFLOW_STATUS[type];
+    case "external":
+      return EXTERNAL_STATUS[type];
+    case "update":
+      return UPDATE_STATUS[type];
+    case "signal":
+      return "received";
+    default:
+      return "recorded";
+  }
+}
+var WORKFLOW_LABELS = {
+  WORKFLOW_STARTED: "Workflow started",
+  WORKFLOW_COMPLETED: "Workflow completed",
+  WORKFLOW_FAILED: "Workflow failed",
+  WORKFLOW_CANCELLED: "Workflow cancelled",
+  WORKFLOW_CANCEL_REQUESTED: "Cancel requested",
+  WORKFLOW_TERMINATED: "Workflow terminated",
+  WORKFLOW_TIMED_OUT: "Workflow timed out",
+  WORKFLOW_CONTINUED_AS_NEW: "Continued as new",
+  WORKFLOW_RESET: "Workflow reset"
+};
+function humanizeEventType(type) {
+  const words = type.toLowerCase().split("_").filter(Boolean);
+  if (!words.length) return type;
+  const first = words[0];
+  return [first.charAt(0).toUpperCase() + first.slice(1), ...words.slice(1)].join(" ").trim();
+}
+function describe(kind, id, first) {
+  const payload = payloadOf(first);
+  const summary = str(payload.summary);
+  switch (kind) {
+    case "activity": {
+      const nodeType = str(payload.nodeType);
+      const operation = str(payload.operation);
+      const target = [nodeType, operation].filter(Boolean).join(" \xB7 ");
+      return {
+        label: summary ?? (target || `Activity ${id}`),
+        detail: summary && target ? target : id
+      };
+    }
+    case "timer": {
+      const duration = num(payload.durationMs);
+      const span = duration !== void 0 ? formatDurationMs(duration) : "";
+      return {
+        label: summary ?? (span ? `Timer ${span}` : `Timer ${id}`),
+        detail: summary && span ? span : id
+      };
+    }
+    case "child": {
+      const target = str(payload.workflowFn) ?? str(payload.workflowKey);
+      return {
+        label: summary ?? (target ? `Child ${target}` : `Child run ${id}`),
+        detail: id
+      };
+    }
+    case "signal":
+      return { label: `Signal ${str(payload.name) ?? ""}`.trim() };
+    case "task":
+      return { label: "Workflow task", detail: id };
+    case "external": {
+      const name = str(payload.name);
+      return {
+        label: name ? `Signal ${name} to another run` : first.type === "EXTERNAL_RUN_CANCEL_REQUESTED" ? "Cancel another run" : humanizeEventType(first.type),
+        detail: id
+      };
+    }
+    case "marker": {
+      const markerId = str(payload.markerId) ?? "";
+      return {
+        label: markerId.startsWith("patch:") ? `Patch ${markerId.slice("patch:".length)}` : "Marker",
+        detail: markerId || void 0
+      };
+    }
+    case "sideEffect":
+      return { label: "Side effect", detail: str(payload.sideEffectId) };
+    case "context":
+      return { label: "Context updated" };
+    case "update":
+      return { label: `Update ${str(payload.name) ?? id}` };
+    case "workflow":
+      return {
+        label: WORKFLOW_LABELS[first.type] ?? humanizeEventType(first.type)
+      };
+    default:
+      return { label: humanizeEventType(first.type) };
+  }
+}
+function groupRunHistory(events) {
+  const groups = /* @__PURE__ */ new Map();
+  const ordered = [...events].sort((a, b) => a.seq - b.seq);
+  for (const event of ordered) {
+    const [kind, id] = groupKeyOf(event);
+    const key = `${kind}:${id}`;
+    const payload = payloadOf(event);
+    let group = groups.get(key);
+    if (!group) {
+      const { label, detail } = describe(kind, id, event);
+      group = {
+        key,
+        kind,
+        id,
+        label,
+        detail,
+        status: statusFor(kind, event.type) ?? "recorded",
+        events: [],
+        firstSeq: event.seq,
+        lastSeq: event.seq,
+        startedAt: event.createdAt
+      };
+      groups.set(key, group);
+    }
+    group.events.push(event);
+    group.lastSeq = event.seq;
+    const status = statusFor(kind, event.type);
+    if (status && !(status === "cancelRequested" && FINAL_STATUSES.has(group.status))) {
+      group.status = status;
+    }
+    if (FINAL_STATUSES.has(group.status)) group.endedAt = event.createdAt;
+    const attempt = num(payload.attempt);
+    if (attempt !== void 0)
+      group.attempt = Math.max(group.attempt ?? 0, attempt);
+    const failure = failureOf(payload.failure) ?? (event.type === "WORKFLOW_TASK_FAILED" || event.type === "WORKFLOW_TASK_TIMED_OUT" ? failureOf({ message: payload.message, errorType: payload.cause }) : void 0);
+    if (failure) {
+      group.failure = {
+        ...failure,
+        cause: str(payload.cause)
+      };
+    }
+    const childRunId = str(payload.childRunId);
+    if (kind === "child" && childRunId) group.childRunId = childRunId;
+  }
+  return [...groups.values()].sort((a, b) => a.firstSeq - b.firstSeq);
+}
+var KIND_ICONS = {
+  workflow: "mdi:flag-outline",
+  task: "mdi:cog-sync-outline",
+  activity: "mdi:lightning-bolt-outline",
+  timer: "mdi:timer-sand",
+  child: "mdi:source-branch",
+  signal: "mdi:bell-ring-outline",
+  external: "mdi:send-outline",
+  marker: "mdi:bookmark-outline",
+  sideEffect: "mdi:dice-multiple-outline",
+  context: "mdi:tag-text-outline",
+  update: "mdi:pencil-outline",
+  other: "mdi:circle-small"
+};
+var STATUS_CLASS = {
+  scheduled: "bg-background-tertiary text-text-secondary border-border-secondary",
+  running: "bg-[var(--color-status-info-bg-subtle)] text-[var(--color-status-info-text)] border-[var(--color-status-info-border)]",
+  completed: "bg-[var(--color-status-success-bg-subtle)] text-[var(--color-status-success-text)] border-[var(--color-status-success-border)]",
+  fired: "bg-[var(--color-status-success-bg-subtle)] text-[var(--color-status-success-text)] border-[var(--color-status-success-border)]",
+  received: "bg-[var(--color-status-success-bg-subtle)] text-[var(--color-status-success-text)] border-[var(--color-status-success-border)]",
+  recorded: "bg-background-tertiary text-text-secondary border-border-secondary",
+  failed: "bg-[var(--color-status-error-bg-subtle)] text-[var(--color-status-error-text)] border-[var(--color-status-error-border)]",
+  timedOut: "bg-[var(--color-status-error-bg-subtle)] text-[var(--color-status-error-text)] border-[var(--color-status-error-border)]",
+  terminated: "bg-[var(--color-status-error-bg-subtle)] text-[var(--color-status-error-text)] border-[var(--color-status-error-border)]",
+  cancelRequested: "bg-[var(--color-status-warning-bg-subtle)] text-[var(--color-status-warning-text)] border-[var(--color-status-warning-border)]",
+  cancelled: "bg-[var(--color-status-warning-bg-subtle)] text-[var(--color-status-warning-text)] border-[var(--color-status-warning-border)]",
+  continued: "bg-[var(--color-status-info-bg-subtle)] text-[var(--color-status-info-text)] border-[var(--color-status-info-border)]"
+};
+var BENIGN_CLASS = "bg-background-tertiary text-text-secondary border-border-secondary";
+var STATUS_LABEL = {
+  scheduled: ["fluidgrids.executions.history.status.scheduled", "Scheduled"],
+  running: ["fluidgrids.executions.history.status.running", "Running"],
+  completed: ["fluidgrids.executions.history.status.completed", "Completed"],
+  failed: ["fluidgrids.executions.history.status.failed", "Failed"],
+  timedOut: ["fluidgrids.executions.history.status.timedOut", "Timed out"],
+  cancelled: ["fluidgrids.executions.history.status.cancelled", "Cancelled"],
+  cancelRequested: [
+    "fluidgrids.executions.history.status.cancelRequested",
+    "Cancel requested"
+  ],
+  terminated: ["fluidgrids.executions.history.status.terminated", "Terminated"],
+  continued: ["fluidgrids.executions.history.status.continued", "Continued"],
+  fired: ["fluidgrids.executions.history.status.fired", "Fired"],
+  received: ["fluidgrids.executions.history.status.received", "Received"],
+  recorded: ["fluidgrids.executions.history.status.recorded", "Recorded"]
+};
+function isHttpsUrl(value) {
+  if (!value) return false;
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function formatTime(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function RunHistoryView({
+  events,
+  loading,
+  error,
+  active,
+  streaming,
+  truncated = false,
+  historyLength,
+  onRefresh,
+  onViewChildRun,
+  defaultShowTasks = false,
+  compact = false,
+  showBenign = false,
+  "data-testid": testId = "run-history"
+}) {
+  const tr = useTr();
+  const [showTasks, setShowTasks] = useState(defaultShowTasks);
+  const [expanded, setExpanded] = useState(() => /* @__PURE__ */ new Set());
+  const groups = useMemo(() => groupRunHistory(events), [events]);
+  const visible = useMemo(
+    () => showTasks ? groups : groups.filter((g) => g.kind !== "task"),
+    [groups, showTasks]
+  );
+  const toggle = (key) => setExpanded((current) => {
+    const next = new Set(current);
+    if (next.has(key)) next.delete(key);
+    else next.add(key);
+    return next;
+  });
+  return /* @__PURE__ */ jsxs("div", { "data-testid": testId, className: "flex flex-col gap-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3 text-sm text-text-secondary", children: [
+      /* @__PURE__ */ jsx("span", { "data-testid": `${testId}-count`, children: tr("fluidgrids.executions.history.eventCount", "{{count}} events", {
+        count: historyLength ?? events.length
+      }) }),
+      active && /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1", children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            icon: streaming ? "mdi:access-point" : "mdi:refresh",
+            width: 14
+          }
+        ),
+        streaming ? tr("fluidgrids.executions.history.live", "Live") : tr("fluidgrids.executions.history.polling", "Refreshing")
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "ml-auto flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: showTasks,
+            onChange: (e) => setShowTasks(e.target.checked),
+            className: "h-4 w-4 rounded",
+            "data-testid": `${testId}-show-tasks`
+          }
+        ),
+        tr("fluidgrids.executions.history.showTasks", "Show workflow tasks")
+      ] }),
+      onRefresh && /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "sm", onClick: onRefresh, children: [
+        /* @__PURE__ */ jsx(Icon, { icon: "mdi:refresh", className: "mr-1", width: 16 }),
+        tr("fluidgrids.executions.history.refresh", "Refresh")
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "alert",
+        className: "rounded-md border border-[var(--color-status-error-border)] bg-[var(--color-status-error-bg-subtle)] p-3 text-sm text-[var(--color-status-error-text)]",
+        children: [
+          tr(
+            "fluidgrids.executions.history.loadError",
+            "Could not load the run history:"
+          ),
+          " ",
+          error.message
+        ]
+      }
+    ),
+    truncated && /* @__PURE__ */ jsx("div", { className: "rounded-md border border-[var(--color-status-warning-border)] bg-[var(--color-status-warning-bg-subtle)] p-3 text-sm text-[var(--color-status-warning-text)]", children: tr(
+      "fluidgrids.executions.history.truncated",
+      "Only the first events are shown. Use fluidgrids history <runId> for the full history."
+    ) }),
+    loading && events.length === 0 ? /* @__PURE__ */ jsx("div", { className: "space-y-2", "aria-busy": "true", children: [0, 1, 2].map((i) => /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "h-10 animate-pulse rounded bg-background-tertiary"
+      },
+      i
+    )) }) : visible.length === 0 && !error ? /* @__PURE__ */ jsx("p", { className: "py-6 text-center text-sm text-text-secondary", children: tr("fluidgrids.executions.history.empty", "No events recorded yet.") }) : /* @__PURE__ */ jsx("ol", { className: "flex flex-col divide-y divide-border-secondary rounded-md border border-border-secondary", children: visible.map((group) => /* @__PURE__ */ jsx(
+      HistoryRow,
+      {
+        group,
+        expanded: expanded.has(group.key),
+        onToggle: () => toggle(group.key),
+        onViewChildRun,
+        compact,
+        benign: showBenign && group.failure?.benign === true,
+        statusLabel: tr(...STATUS_LABEL[group.status])
+      },
+      group.key
+    )) })
+  ] });
+}
+function HistoryRow({
+  group,
+  expanded,
+  onToggle,
+  onViewChildRun,
+  compact,
+  benign,
+  statusLabel
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      "data-testid": `history-group-${group.key}`,
+      "data-status": group.status,
+      "data-benign": benign ? "true" : void 0,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: onToggle,
+            "aria-expanded": expanded,
+            className: cn(
+              "flex w-full items-center gap-3 text-left hover:bg-background-tertiary",
+              compact ? "px-2 py-1.5" : "px-3 py-2"
+            ),
+            children: [
+              /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: expanded ? "mdi:chevron-down" : "mdi:chevron-right",
+                  width: 16,
+                  className: "shrink-0 text-text-secondary"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: KIND_ICONS[group.kind],
+                  width: 16,
+                  className: "shrink-0 text-text-secondary"
+                }
+              ),
+              /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+                /* @__PURE__ */ jsx("span", { className: "block truncate text-sm font-medium text-text-primary", children: group.label }),
+                group.detail && /* @__PURE__ */ jsx("span", { className: "block truncate font-mono text-xs text-text-secondary", children: group.detail })
+              ] }),
+              group.attempt !== void 0 && group.attempt > 1 && /* @__PURE__ */ jsx("span", { className: "shrink-0 text-xs text-text-secondary", children: tr(
+                "fluidgrids.executions.history.attempt",
+                "attempt {{attempt}}",
+                {
+                  attempt: group.attempt
+                }
+              ) }),
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: cn(
+                    "shrink-0 rounded border px-1.5 py-0.5 text-xs",
+                    benign ? BENIGN_CLASS : STATUS_CLASS[group.status]
+                  ),
+                  children: benign ? tr("fluidgrids.executions.history.status.benign", "Expected") : statusLabel
+                }
+              ),
+              !compact && /* @__PURE__ */ jsx("span", { className: "w-20 shrink-0 text-right font-mono text-xs text-text-secondary", children: formatTime(group.startedAt) })
+            ]
+          }
+        ),
+        group.failure && /* @__PURE__ */ jsxs(
+          "p",
+          {
+            className: cn(
+              "px-10 pb-2 text-xs",
+              benign ? "text-text-secondary" : "text-[var(--color-status-error-text)]"
+            ),
+            children: [
+              group.failure.errorType ? `${group.failure.errorType}: ` : "",
+              group.failure.message
+            ]
+          }
+        ),
+        expanded && /* @__PURE__ */ jsxs("div", { className: "space-y-2 bg-background-primary px-10 py-2", children: [
+          group.childRunId && onViewChildRun && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: () => onViewChildRun(group.childRunId),
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:open-in-new", className: "mr-1", width: 14 }),
+                tr("fluidgrids.executions.history.openChild", "Open child run")
+              ]
+            }
+          ),
+          group.events.map((event) => /* @__PURE__ */ jsxs("div", { className: "text-xs", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-3 font-mono text-text-secondary", children: [
+              /* @__PURE__ */ jsxs("span", { children: [
+                "#",
+                event.seq
+              ] }),
+              /* @__PURE__ */ jsx("span", { className: "text-text-primary", children: event.type }),
+              /* @__PURE__ */ jsx("span", { className: "ml-auto", children: formatTime(event.createdAt) })
+            ] }),
+            isHttpsUrl(event.payloadUrl) ? /* @__PURE__ */ jsx(
+              "a",
+              {
+                href: event.payloadUrl ?? void 0,
+                target: "_blank",
+                rel: "noreferrer noopener",
+                className: "text-action-primary-text hover:underline",
+                children: tr(
+                  "fluidgrids.executions.history.offloadedPayload",
+                  "Download payload"
+                )
+              }
+            ) : event.payload && Object.keys(event.payload).length > 0 ? /* @__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(event.payload, null, 2) }) : null
+          ] }, event.seq))
+        ] })
+      ]
+    }
+  );
+}
+async function fetchDurableRunFields(runId) {
+  const result = await getFluidGridsClient().query({
+    query: DurableRunFieldsDocument,
+    variables: { id: runId },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRun ?? null;
+}
+function useDurableRunFields(runId, enabled) {
+  const [fields, setFields] = useState(null);
+  const request = useRef(0);
+  const isGraphRun = useRef(false);
+  const read = useCallback(async () => {
+    if (!runId || !enabled) return;
+    const id = ++request.current;
+    try {
+      const next = await fetchDurableRunFields(runId);
+      if (id !== request.current) return;
+      isGraphRun.current = next?.executionKind === "GRAPH" /* Graph */;
+      setFields(next);
+    } catch {
+      if (id !== request.current) return;
+    }
+  }, [runId, enabled]);
+  useEffect(() => {
+    request.current += 1;
+    isGraphRun.current = false;
+    setFields(null);
+    void read();
+  }, [read]);
+  const refetch = useCallback(async () => {
+    if (isGraphRun.current) return;
+    await read();
+  }, [read]);
+  return { fields: enabled ? fields : null, refetch };
+}
+var DETERMINISM_POLL_INTERVAL_MS = 1e4;
+async function fetchDeterminismStatus(runId) {
+  const result = await getFluidGridsClient().query({
+    query: WorkflowRunDeterminismStatusDocument,
+    variables: { runId },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRunDeterminismStatus ?? null;
+}
+async function fetchRunStackTrace(runId) {
+  const result = await getFluidGridsClient().query({
+    query: WorkflowRunStackTraceDocument,
+    variables: { runId, enhanced: false },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRunStackTrace.trace ?? null;
+}
+function newSignalIdempotencyKey() {
+  return crypto.randomUUID();
+}
+async function sendRunSignal(input) {
+  const result = await getFluidGridsClient().mutate({
+    mutation: SignalWorkflowRunDocument,
+    variables: {
+      runId: input.runId,
+      name: input.name,
+      // The JSON scalar carries any value; the generated type is the object
+      // form only, and the service validates the payload against the schema.
+      payload: input.payload,
+      idempotencyKey: input.idempotencyKey
+    }
+  });
+  throwIfResultError(result);
+  const data = result.data?.signalWorkflowRun;
+  if (!data) throw new Error("The signal returned no result");
+  return data;
+}
+async function terminateDurableRun(runId, reason) {
+  const result = await getFluidGridsClient().mutate({
+    mutation: TerminateWorkflowRunDocument,
+    variables: { runId, reason }
+  });
+  throwIfResultError(result);
+}
+function useDeterminismStatus(runId, { enabled, live }) {
+  const [status, setStatus] = useState(null);
+  const [error, setError] = useState(null);
+  const request = useRef(0);
+  const refetch = useCallback(async () => {
+    if (!runId || !enabled) return;
+    const id = ++request.current;
+    try {
+      const next = await fetchDeterminismStatus(runId);
+      if (id !== request.current) return;
+      setStatus(next);
+      setError(null);
+    } catch (err) {
+      if (id !== request.current) return;
+      setError(describeOperationError(err));
+    }
+  }, [runId, enabled]);
+  useEffect(() => {
+    request.current += 1;
+    setStatus(null);
+    setError(null);
+    void refetch();
+  }, [refetch]);
+  useEffect(() => {
+    if (!live || !enabled || !runId) return;
+    const timer = setInterval(() => {
+      void refetch();
+    }, DETERMINISM_POLL_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [live, enabled, runId, refetch]);
+  return { status, error, refetch };
+}
+function useRunStackTrace(runId, enabled) {
+  const [trace, setTrace] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const request = useRef(0);
+  const refetch = useCallback(async () => {
+    if (!runId || !enabled) return;
+    const id = ++request.current;
+    setLoading(true);
+    try {
+      const next = await fetchRunStackTrace(runId);
+      if (id !== request.current) return;
+      setTrace(next);
+      setError(null);
+    } catch (err) {
+      if (id !== request.current) return;
+      setError(describeOperationError(err));
+    } finally {
+      if (id === request.current) setLoading(false);
+    }
+  }, [runId, enabled]);
+  useEffect(() => {
+    request.current += 1;
+    setTrace(null);
+    setError(null);
+    setLoading(false);
+    void refetch();
+  }, [refetch]);
+  return { trace, loading, error, refetch };
+}
+function useOpenSnapshot(open, value) {
+  const [snapshot, setSnapshot] = useState(
+    () => open ? { value } : null
+  );
+  if (open && snapshot === null) {
+    setSnapshot({ value });
+    return value;
+  }
+  if (!open && snapshot !== null) {
+    setSnapshot(null);
+  }
+  return snapshot === null ? value : snapshot.value;
+}
+var CUSTOM = "__custom__";
+function CustomSignalNameInput({
+  value,
+  onChange
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsx(
+    Input,
+    {
+      value,
+      onChange: (e) => onChange(e.target.value),
+      placeholder: tr(
+        "fluidgrids.executions.signal.namePlaceholder",
+        "signal-name"
+      ),
+      "aria-label": tr(
+        "fluidgrids.executions.signal.customNameLabel",
+        "Signal name"
+      ),
+      "data-testid": "signal-custom-name"
+    }
+  );
+}
+function PayloadModeToggle({
+  mode,
+  onChange
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex gap-2 text-xs",
+      role: "group",
+      "aria-label": tr(
+        "fluidgrids.executions.signal.payloadMode",
+        "Payload editor"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: mode === "form" ? "default" : "outline",
+            size: "sm",
+            "aria-pressed": mode === "form",
+            onClick: () => onChange("form"),
+            children: tr("fluidgrids.executions.signal.formMode", "Form")
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: mode === "json" ? "default" : "outline",
+            size: "sm",
+            "aria-pressed": mode === "json",
+            onClick: () => onChange("json"),
+            children: tr("fluidgrids.executions.signal.jsonMode", "JSON")
+          }
+        )
+      ]
+    }
+  );
+}
+function SignalRunDialog({
+  runId,
+  targets: currentTargets,
+  open,
+  onOpenChange,
+  onSent,
+  initialName: currentInitialName
+}) {
+  const tr = useTr();
+  const { targets, initialName } = useOpenSnapshot(open, {
+    targets: currentTargets,
+    initialName: currentInitialName
+  });
+  const firstName = initialName ?? targets.targets[0]?.name ?? CUSTOM;
+  const [selected, setSelected] = useState(firstName);
+  const [customName, setCustomName] = useState("");
+  const [mode, setMode] = useState("form");
+  const [rawPayload, setRawPayload] = useState("");
+  const [error, setError] = useState(null);
+  const [sending, setSending] = useState(false);
+  const [result, setResult] = useState(null);
+  const idempotencyKey = useRef(newSignalIdempotencyKey());
+  const cardRef = useRef(null);
+  useEffect(() => {
+    if (!open) return;
+    idempotencyKey.current = newSignalIdempotencyKey();
+    setSelected(firstName);
+    setCustomName("");
+    setRawPayload("");
+    setError(null);
+    setResult(null);
+    setSending(false);
+  }, [open, firstName]);
+  const target = targets.targets.find((t) => t.name === selected);
+  const name = selected === CUSTOM ? customName.trim() : selected;
+  const card = useMemo(
+    () => signalPayloadCard(target?.payloadSchema),
+    [target?.payloadSchema]
+  );
+  const effectiveMode = card ? mode : "json";
+  useEffect(() => {
+    idempotencyKey.current = newSignalIdempotencyKey();
+    setResult(null);
+    setError(null);
+  }, [selected]);
+  const send = async () => {
+    setError(null);
+    if (!name) {
+      setError(
+        tr("fluidgrids.executions.signal.nameRequired", "Enter a signal name.")
+      );
+      return;
+    }
+    let payload;
+    if (effectiveMode === "form" && card) {
+      if (cardRef.current && !cardRef.current.validateInputs()) {
+        setError(
+          tr(
+            "fluidgrids.executions.signal.formInvalid",
+            "Fill in the required fields."
+          )
+        );
+        return;
+      }
+      const parsed = payloadFromCardValues(
+        target?.payloadSchema,
+        cardRef.current?.collectValues() ?? {}
+      );
+      if ("error" in parsed) {
+        setError(parsed.error);
+        return;
+      }
+      payload = parsed.payload;
+    } else {
+      const parsed = parseRawSignalPayload(rawPayload);
+      if ("error" in parsed) {
+        setError(
+          tr(
+            "fluidgrids.executions.signal.jsonInvalid",
+            "The payload is not valid JSON: {{message}}",
+            { message: parsed.error }
+          )
+        );
+        return;
+      }
+      payload = parsed.payload;
+    }
+    setSending(true);
+    try {
+      const sent = await sendRunSignal({
+        runId,
+        name,
+        payload,
+        idempotencyKey: idempotencyKey.current
+      });
+      setResult(sent);
+      onSent?.(sent);
+    } catch (err) {
+      setError(describeOperationError(err));
+    } finally {
+      setSending(false);
+    }
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(DialogContent, { "data-testid": "signal-run-dialog", className: "max-w-lg", children: [
+    /* @__PURE__ */ jsxs(DialogHeader, { children: [
+      /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.executions.signal.title", "Send a signal") }),
+      /* @__PURE__ */ jsx(DialogDescription, { children: tr(
+        "fluidgrids.executions.signal.description",
+        "The run receives the signal by name. A payload that does not match the signal's schema is refused."
+      ) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+        /* @__PURE__ */ jsx(Label, { htmlFor: "signal-name", children: tr("fluidgrids.executions.signal.nameLabel", "Signal") }),
+        /* @__PURE__ */ jsxs(
+          "select",
+          {
+            id: "signal-name",
+            value: selected,
+            onChange: (e) => setSelected(e.target.value),
+            className: "w-full rounded-md border border-input bg-background px-3 py-2 text-sm text-foreground",
+            "data-testid": "signal-name-select",
+            children: [
+              targets.targets.map((t) => /* @__PURE__ */ jsx("option", { value: t.name, children: t.name }, `${t.nodeId ?? ""}:${t.name}`)),
+              targets.openNames && /* @__PURE__ */ jsx("option", { value: CUSTOM, children: tr(
+                "fluidgrids.executions.signal.otherName",
+                "Another name\u2026"
+              ) })
+            ]
+          }
+        ),
+        selected === CUSTOM && /* @__PURE__ */ jsx(
+          CustomSignalNameInput,
+          {
+            value: customName,
+            onChange: setCustomName
+          }
+        )
+      ] }),
+      card && /* @__PURE__ */ jsx(PayloadModeToggle, { mode: effectiveMode, onChange: setMode }),
+      effectiveMode === "form" && card ? /* @__PURE__ */ jsx(components_default, { ref: cardRef, cardData: card }) : /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+        /* @__PURE__ */ jsx(Label, { htmlFor: "signal-payload", children: tr(
+          "fluidgrids.executions.signal.payloadLabel",
+          "Payload (JSON)"
+        ) }),
+        /* @__PURE__ */ jsx(
+          Textarea,
+          {
+            id: "signal-payload",
+            value: rawPayload,
+            onChange: (e) => setRawPayload(e.target.value),
+            rows: 6,
+            className: "font-mono text-sm",
+            placeholder: '{ "approved": true }',
+            "data-testid": "signal-payload-json"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsx(
+        "p",
+        {
+          role: "alert",
+          className: "text-sm text-[var(--color-status-error-text)]",
+          children: error
+        }
+      ),
+      result && /* @__PURE__ */ jsxs(
+        "p",
+        {
+          "data-testid": "signal-result",
+          className: "flex items-center gap-2 text-sm text-[var(--color-status-success-text)]",
+          children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:check-circle-outline", width: 16 }),
+            result.duplicate ? tr(
+              "fluidgrids.executions.signal.duplicate",
+              "Already sent; the run recorded it once."
+            ) : result.buffered ? tr(
+              "fluidgrids.executions.signal.buffered",
+              "Sent. The run will receive it when it reaches its wait."
+            ) : result.forwardedToRunId ? tr(
+              "fluidgrids.executions.signal.forwarded",
+              "Sent to the child run that is waiting for it."
+            ) : tr(
+              "fluidgrids.executions.signal.delivered",
+              "Sent and delivered."
+            )
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs(DialogFooter, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: () => onOpenChange(false), children: result ? tr("fluidgrids.executions.signal.close", "Close") : tr("fluidgrids.executions.signal.cancel", "Cancel") }),
+      !result && /* @__PURE__ */ jsx(
+        Button,
+        {
+          onClick: () => void send(),
+          disabled: sending,
+          "data-testid": "signal-send",
+          children: sending ? tr("fluidgrids.executions.signal.sending", "Sending...") : tr("fluidgrids.executions.signal.send", "Send")
+        }
+      )
+    ] })
+  ] }) });
+}
+var RUN_HISTORY_POLL_INTERVAL_MS = 2e3;
+var RUN_HISTORY_SAFETY_READ_INITIAL_MS = 15e3;
+var RUN_HISTORY_SAFETY_READ_MAX_MS = 12e4;
+var RUN_HISTORY_PAGE_SIZE = 500;
+var RUN_HISTORY_MAX_PAGES = 20;
+function toEvents(events) {
+  return events.map((event) => ({
+    runId: event.runId,
+    seq: event.seq,
+    type: event.type,
+    taskId: event.taskId ?? null,
+    payload: event.payload ?? null,
+    payloadUrl: event.payloadUrl ?? null,
+    createdAt: event.createdAt
+  }));
+}
+function useRunHistory(runId, options = {}) {
+  const { live = false, enabled = true } = options;
+  const [events, setEvents] = useState([]);
+  const [loading, setLoading] = useState(enabled && !!runId);
+  const [error, setError] = useState(null);
+  const [truncated, setTruncated] = useState(false);
+  const [historyLength, setHistoryLength] = useState(null);
+  const [streaming, setStreaming] = useState(false);
+  const cursor = useRef(0);
+  const generation = useRef(0);
+  const append = useCallback((incoming) => {
+    if (!incoming.length) return;
+    setEvents((current) => {
+      const next = mergeHistoryEvents(current, incoming);
+      cursor.current = Math.max(cursor.current, lastSeqOf(next));
+      return next;
+    });
+  }, []);
+  const readForward = useCallback(
+    async (maxPages) => {
+      const client = getFluidGridsClientSafe();
+      if (!client || !runId) return;
+      const started = generation.current;
+      for (let page = 0; page < maxPages; page += 1) {
+        const result = await client.query({
+          query: WorkflowRunHistoryDocument,
+          variables: {
+            runId,
+            after: cursor.current,
+            limit: RUN_HISTORY_PAGE_SIZE
+          },
+          fetchPolicy: "network-only"
+        });
+        throwIfResultError(result);
+        if (generation.current !== started) return;
+        const pageData = result.data?.workflowRunHistory;
+        if (!pageData) return;
+        const fresh = toEvents(pageData.events);
+        append(fresh);
+        cursor.current = Math.max(
+          cursor.current,
+          lastSeqOf(fresh),
+          pageData.nextAfter ?? 0
+        );
+        setHistoryLength(pageData.historyLength);
+        if (!pageData.hasMore || fresh.length === 0) {
+          setTruncated(false);
+          return;
+        }
+        if (page === maxPages - 1) setTruncated(true);
+      }
+    },
+    [runId, append]
+  );
+  const refetch = useCallback(async () => {
+    generation.current += 1;
+    cursor.current = 0;
+    setEvents([]);
+    setTruncated(false);
+    setError(null);
+    setLoading(true);
+    try {
+      await readForward(RUN_HISTORY_MAX_PAGES);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [readForward]);
+  useEffect(() => {
+    if (!runId || !enabled) {
+      generation.current += 1;
+      cursor.current = 0;
+      setEvents([]);
+      setLoading(false);
+      return;
+    }
+    void refetch();
+  }, [runId, enabled, refetch]);
+  useEffect(() => {
+    const client = getFluidGridsClientSafe();
+    if (!runId || !enabled || !live || !client) {
+      setStreaming(false);
+      return;
+    }
+    let cancelled = false;
+    let poll = null;
+    let safetyRead = null;
+    let delivered = false;
+    const stopSafetyReads = () => {
+      if (safetyRead) clearTimeout(safetyRead);
+      safetyRead = null;
+    };
+    const startPolling = () => {
+      stopSafetyReads();
+      if (poll || cancelled) return;
+      setStreaming(false);
+      poll = setInterval(() => {
+        void readForward(1).catch(() => {
+        });
+      }, RUN_HISTORY_POLL_INTERVAL_MS);
+    };
+    const scheduleSafetyRead = (delay) => {
+      safetyRead = setTimeout(() => {
+        safetyRead = null;
+        if (cancelled || delivered || poll) return;
+        void readForward(1).catch(() => {
+        });
+        scheduleSafetyRead(Math.min(delay * 2, RUN_HISTORY_SAFETY_READ_MAX_MS));
+      }, delay);
+    };
+    const subscription = client.subscribe({ query: RunEventAppendedDocument, variables: { runId } }).subscribe({
+      next: ({ data }) => {
+        if (cancelled || !data?.runEventAppended) return;
+        delivered = true;
+        stopSafetyReads();
+        if (poll) {
+          clearInterval(poll);
+          poll = null;
+        }
+        setStreaming(true);
+        append(toEvents([data.runEventAppended]));
+      },
+      error: () => startPolling(),
+      complete: () => {
+        if (!cancelled) startPolling();
+      }
+    });
+    scheduleSafetyRead(RUN_HISTORY_SAFETY_READ_INITIAL_MS);
+    return () => {
+      cancelled = true;
+      stopSafetyReads();
+      if (poll) clearInterval(poll);
+      subscription.unsubscribe();
+      setStreaming(false);
+    };
+  }, [runId, enabled, live, readForward, append]);
+  const wasLive = useRef(false);
+  useEffect(() => {
+    if (live) {
+      wasLive.current = true;
+      return;
+    }
+    if (!wasLive.current) return;
+    wasLive.current = false;
+    void readForward(RUN_HISTORY_MAX_PAGES).catch(() => {
+    });
+  }, [live, readForward]);
+  return {
+    events,
+    loading,
+    error,
+    truncated,
+    historyLength,
+    streaming,
+    refetch
+  };
+}
+
+export { RunHistoryView, SignalRunDialog, terminateDurableRun, useDeterminismStatus, useDurableRunFields, useRunHistory, useRunStackTrace };