@burdenoff/fluidgrids-fe-sdk 2026.1031.7 → 2026.1101.2

package/dist/chunk-NMEI7TQW.js

@@ -1,2628 +0,0 @@
-import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-PZ45H72P.js';
-import { notifyFluidGridsAiCreditsUpdated } from './chunk-Y53CVZVV.js';
-import { ErrorType } from './chunk-7KKYIRLH.js';
-import { throwIfResultError, describeOperationError, signalPayloadCard, components_default, isForbiddenError, payloadFromCardValues, parseRawSignalPayload } from './chunk-6ILIBJFH.js';
-import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
-import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument, WorkflowTestCasesDocument, WorkflowTestRunsDocument, WorkflowTestRunDocument, CreateWorkflowTestCaseDocument, UpdateWorkflowTestCaseDocument, DeleteWorkflowTestCaseDocument, RunWorkflowTestsDocument, CreateWorkflowTestCaseFromRunDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-IHEV5HTD.js';
-import { useTr } from './chunk-UULVIT25.js';
-import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
-import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
-import { TagBadge, TagsWidget } from '@burdenoff/fe-libs/tag';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { Icon } from '@iconify/react';
-import { Button } from '@burdenoff/fe-libs/button';
-import { cn } from '@burdenoff/fe-libs/utils';
-import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label, Textarea, DialogFooter, Badge, Button as Button$1, Input } from '@burdenoff/fe-libs/ui';
-
-function toTagItem(assignment) {
-  return {
-    id: assignment.tagId,
-    key: assignment.tagInfo?.key ?? assignment.tagId,
-    label: assignment.tagInfo?.label ?? assignment.tagInfo?.key ?? "Tag",
-    color: assignment.tagInfo?.color ?? null
-  };
-}
-function EntityTagPicker({
-  entityType,
-  entityId,
-  onDraftChange,
-  readOnly = false,
-  onChange,
-  className
-}) {
-  const draftMode = !entityId;
-  const { workspaceId } = getFluidGridsConfig();
-  const { tags: assignments, refetch } = useEntityTags(entityType, entityId);
-  const tagEntity = useTagEntity();
-  const untagEntity = useUntagEntity();
-  const [current, setCurrent] = useState([]);
-  const currentRef = useRef([]);
-  const assignmentKey = assignments.map((a) => a.tagId).join("|");
-  const syncedKey = useRef(null);
-  useEffect(() => {
-    if (draftMode || syncedKey.current === assignmentKey) return;
-    syncedKey.current = assignmentKey;
-    const synced = assignments.map(toTagItem);
-    currentRef.current = synced;
-    setCurrent(synced);
-  }, [assignmentKey, assignments, draftMode]);
-  const handleAdd = useCallback(
-    async (tag) => {
-      if (currentRef.current.some((t) => t.id === tag.id)) return;
-      const next = [...currentRef.current, tag];
-      currentRef.current = next;
-      setCurrent(next);
-      if (draftMode) {
-        onDraftChange?.(next.map((t) => t.id));
-        return;
-      }
-      try {
-        await tagEntity(entityType, entityId, tag.id);
-        await refetch();
-        onChange?.();
-      } catch {
-        const rolledBack = currentRef.current.filter((t) => t.id !== tag.id);
-        currentRef.current = rolledBack;
-        setCurrent(rolledBack);
-      }
-    },
-    [
-      draftMode,
-      entityId,
-      entityType,
-      onChange,
-      onDraftChange,
-      refetch,
-      tagEntity
-    ]
-  );
-  const handleRemove = useCallback(
-    async (tagId) => {
-      const removed = currentRef.current.find((t) => t.id === tagId);
-      const next = currentRef.current.filter((t) => t.id !== tagId);
-      currentRef.current = next;
-      setCurrent(next);
-      if (draftMode) {
-        onDraftChange?.(next.map((t) => t.id));
-        return;
-      }
-      try {
-        await untagEntity(entityType, entityId, tagId);
-        await refetch();
-        onChange?.();
-      } catch {
-        if (removed) {
-          const rolledBack = [...currentRef.current, removed];
-          currentRef.current = rolledBack;
-          setCurrent(rolledBack);
-        }
-      }
-    },
-    [
-      draftMode,
-      entityId,
-      entityType,
-      onChange,
-      onDraftChange,
-      refetch,
-      untagEntity
-    ]
-  );
-  if (readOnly) {
-    if (current.length === 0) return null;
-    return /* @__PURE__ */ jsx("div", { className: `flex flex-wrap items-center gap-1 ${className ?? ""}`, children: current.map((tag) => /* @__PURE__ */ jsx(
-      TagBadge,
-      {
-        id: tag.id,
-        label: tag.label,
-        color: tag.color ?? void 0,
-        size: "sm"
-      },
-      tag.id
-    )) });
-  }
-  return /* @__PURE__ */ jsx(
-    TagsWidget,
-    {
-      entityType,
-      entityId: entityId ?? "",
-      workspaceId: workspaceId || void 0,
-      tags: current,
-      onAdd: handleAdd,
-      onRemove: handleRemove,
-      syncGraphNotifications: !draftMode,
-      className
-    }
-  );
-}
-
-// 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
-  };
-}
-var PROPOSAL_POLL_INTERVAL_MS = 3e3;
-var PROPOSAL_MAX_WAIT_MS = 6 * 60 * 1e3;
-function messageOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function isProposalRunning(status) {
-  return status === "PROCESSING";
-}
-function useWorkflowProposal() {
-  const [proposal, setProposal] = useState(null);
-  const [isWorking, setIsWorking] = useState(false);
-  const [isDeciding, setIsDeciding] = useState(false);
-  const [error, setError] = useState(null);
-  const [timedOut, setTimedOut] = useState(false);
-  const runRef = useRef(0);
-  const timerRef = useRef(null);
-  const clearTimer = useCallback(() => {
-    if (timerRef.current) clearTimeout(timerRef.current);
-    timerRef.current = null;
-  }, []);
-  useEffect(
-    () => () => {
-      runRef.current++;
-      clearTimer();
-    },
-    [clearTimer]
-  );
-  const reset = useCallback(() => {
-    runRef.current++;
-    clearTimer();
-    setProposal(null);
-    setIsWorking(false);
-    setIsDeciding(false);
-    setError(null);
-    setTimedOut(false);
-  }, [clearTimer]);
-  const poll = useCallback(
-    async (run, id, startedAt) => {
-      if (run !== runRef.current) return;
-      try {
-        const result = throwIfResultError(
-          await getFluidGridsClient().query({
-            query: WorkflowProposalDocument,
-            variables: { id },
-            fetchPolicy: "network-only"
-          })
-        );
-        if (run !== runRef.current) return;
-        const next = result.data?.workflowProposal ?? null;
-        if (next) setProposal(next);
-        const status = next ? String(next.status) : void 0;
-        if (isProposalRunning(status)) {
-          if (Date.now() - startedAt < PROPOSAL_MAX_WAIT_MS) {
-            timerRef.current = setTimeout(
-              () => void poll(run, id, startedAt),
-              PROPOSAL_POLL_INTERVAL_MS
-            );
-            return;
-          }
-          setTimedOut(true);
-        } else {
-          notifyFluidGridsAiCreditsUpdated();
-        }
-        setIsWorking(false);
-      } catch (pollError) {
-        if (run !== runRef.current) return;
-        setError(messageOf(pollError));
-        setIsWorking(false);
-      }
-    },
-    []
-  );
-  const start = useCallback(
-    async (input) => {
-      const run = ++runRef.current;
-      clearTimer();
-      setProposal(null);
-      setError(null);
-      setTimedOut(false);
-      setIsWorking(true);
-      try {
-        const client = getFluidGridsClient();
-        let started;
-        if (input.kind === "runFix") {
-          const result = throwIfResultError(
-            await client.mutate({
-              mutation: ProposeRunFixDocument,
-              variables: {
-                input: {
-                  runId: input.runId,
-                  ...input.prompt ? { prompt: input.prompt } : {}
-                }
-              }
-            })
-          );
-          started = result.data?.proposeRunFix;
-        } else {
-          const result = throwIfResultError(
-            await client.mutate({
-              mutation: ProposeWorkflowChangeDocument,
-              variables: {
-                input: {
-                  prompt: input.prompt,
-                  ...input.workflowKey ? { workflowKey: input.workflowKey } : {},
-                  ...input.baseVersion ? { baseVersion: input.baseVersion } : {},
-                  ...input.template ? { template: input.template } : {}
-                }
-              }
-            })
-          );
-          started = result.data?.proposeWorkflowChange;
-        }
-        if (!started?.id) throw new Error("The proposal did not start");
-        if (run !== runRef.current) return;
-        setProposal(started);
-        const id = started.id;
-        timerRef.current = setTimeout(
-          () => void poll(run, id, Date.now()),
-          PROPOSAL_POLL_INTERVAL_MS
-        );
-      } catch (startError) {
-        if (run !== runRef.current) return;
-        setError(messageOf(startError));
-        setIsWorking(false);
-      }
-    },
-    [clearTimer, poll]
-  );
-  const open = useCallback(
-    async (id) => {
-      const run = ++runRef.current;
-      clearTimer();
-      setError(null);
-      setTimedOut(false);
-      setIsWorking(true);
-      await poll(run, id, Date.now());
-    },
-    [clearTimer, poll]
-  );
-  const decide = useCallback(
-    async (action) => {
-      const id = proposal?.id;
-      if (!id) return null;
-      const run = runRef.current;
-      setIsDeciding(true);
-      setError(null);
-      try {
-        const client = getFluidGridsClient();
-        let next;
-        if (action === "apply") {
-          const result = throwIfResultError(
-            await client.mutate({ mutation: ApplyWorkflowProposalDocument, variables: { id } })
-          );
-          next = result.data?.applyWorkflowProposal;
-        } else if (action === "reject") {
-          const result = throwIfResultError(
-            await client.mutate({ mutation: RejectWorkflowProposalDocument, variables: { id } })
-          );
-          next = result.data?.rejectWorkflowProposal;
-        } else {
-          clearTimer();
-          const result = throwIfResultError(
-            await client.mutate({ mutation: CancelWorkflowProposalDocument, variables: { id } })
-          );
-          next = result.data?.cancelWorkflowProposal;
-          setIsWorking(false);
-        }
-        if (run === runRef.current && next) setProposal(next);
-        return next ?? null;
-      } catch (decideError) {
-        if (run === runRef.current) setError(messageOf(decideError));
-        return null;
-      } finally {
-        if (run === runRef.current) setIsDeciding(false);
-      }
-    },
-    [clearTimer, proposal?.id]
-  );
-  const apply = useCallback(() => decide("apply"), [decide]);
-  const reject = useCallback(async () => {
-    await decide("reject");
-  }, [decide]);
-  const cancel = useCallback(async () => {
-    await decide("cancel");
-  }, [decide]);
-  return {
-    proposal,
-    isWorking,
-    isDeciding,
-    error,
-    timedOut,
-    start,
-    open,
-    apply,
-    reject,
-    cancel,
-    reset
-  };
-}
-var STATUS_TONE = {
-  PROCESSING: "secondary",
-  PROPOSED: "default",
-  APPLIED: "default",
-  REJECTED: "outline",
-  STALE: "outline",
-  CANCELLED: "outline",
-  FAILED: "destructive"
-};
-function edgeLabel(edge) {
-  const from = edge.sourceHandle ? `${edge.source} (${edge.sourceHandle})` : edge.source;
-  return `${from} \u2192 ${edge.target}`;
-}
-function ChangeList({
-  title,
-  icon,
-  items,
-  testId
-}) {
-  if (items.length === 0) return null;
-  return /* @__PURE__ */ jsxs("div", { "data-testid": testId, children: [
-    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 text-xs font-medium uppercase tracking-wide text-text-secondary", children: [
-      /* @__PURE__ */ jsx(Icon, { icon, width: 14 }),
-      title,
-      " (",
-      items.length,
-      ")"
-    ] }),
-    /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-primary", children: items.map((item) => /* @__PURE__ */ jsx("li", { className: "truncate", children: item }, item)) })
-  ] });
-}
-function nodeLine(node, withFields) {
-  const base = `${node.label} \xB7 ${node.type}`;
-  return withFields && node.fields.length > 0 ? `${base} \u2014 ${node.fields.join(", ")}` : base;
-}
-function visibleErrors(errors, shownMessage) {
-  const shown = normalise(shownMessage ?? "");
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const error of errors) {
-    const key = normalise(error);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    if (shown && shown.includes(key)) continue;
-    result.push(error);
-  }
-  return result;
-}
-function normalise(text) {
-  return text.trim().toLowerCase().replace(/^[\s.:;,]+|[\s.:;,]+$/g, "");
-}
-function WorkflowProposalCard({
-  proposal,
-  isDeciding = false,
-  onOpenWorkflow,
-  onApply,
-  onReject,
-  onCancel,
-  onRevert
-}) {
-  const tr = useTr();
-  const status = String(proposal.status);
-  const diff = proposal.diff;
-  const warnings = proposal.validation?.warnings ?? [];
-  const showMessage = Boolean(
-    proposal.message && status !== "PROPOSED" && status !== "PROCESSING" && status !== "APPLIED"
-  );
-  const errors = visibleErrors(
-    proposal.validation?.valid === false ? proposal.validation.errors : [],
-    showMessage ? proposal.message : null
-  );
-  const revertTarget = proposal.baseVersion && proposal.workflowKey && proposal.appliedWorkflowKey === proposal.workflowKey ? { workflowKey: proposal.workflowKey, version: proposal.baseVersion } : null;
-  return /* @__PURE__ */ jsxs(
-    "section",
-    {
-      className: "rounded-lg border border-border-secondary bg-background-secondary p-4",
-      "data-testid": "workflow-proposal-card",
-      "data-status": status,
-      children: [
-        /* @__PURE__ */ jsxs("header", { className: "flex flex-wrap items-center gap-2", children: [
-          /* @__PURE__ */ jsx(
-            Icon,
-            {
-              icon: "mdi:creation-outline",
-              width: 18,
-              className: "text-text-secondary"
-            }
-          ),
-          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: proposal.name ?? tr("fluidgrids.ai.proposal.title", "AI proposal") }),
-          /* @__PURE__ */ jsx(
-            Badge,
-            {
-              variant: STATUS_TONE[status] ?? "outline",
-              "data-testid": "workflow-proposal-status",
-              children: status
-            }
-          ),
-          proposal.baseVersion && /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
-            "fluidgrids.ai.proposal.against",
-            "against version {{version}}",
-            {
-              version: proposal.baseVersion
-            }
-          ) })
-        ] }),
-        status === "PROCESSING" && /* @__PURE__ */ jsxs("div", { className: "mt-3 flex items-center gap-2 text-sm text-text-secondary", children: [
-          /* @__PURE__ */ jsx(Icon, { icon: "mdi:loading", width: 16, className: "animate-spin" }),
-          tr("fluidgrids.ai.proposal.working", "Working ({{stage}})\u2026", {
-            stage: proposal.progress?.stage ?? "prompting"
-          }),
-          onCancel && /* @__PURE__ */ jsx(
-            Button$1,
-            {
-              size: "sm",
-              variant: "ghost",
-              onClick: onCancel,
-              disabled: isDeciding,
-              children: tr("fluidgrids.ai.proposal.cancel", "Cancel")
-            }
-          )
-        ] }),
-        proposal.explanation && /* @__PURE__ */ jsx(
-          "p",
-          {
-            className: "mt-3 text-sm text-text-primary",
-            "data-testid": "workflow-proposal-explanation",
-            children: proposal.explanation
-          }
-        ),
-        showMessage && /* @__PURE__ */ jsx(
-          "p",
-          {
-            className: "mt-2 text-sm text-text-secondary",
-            "data-testid": "workflow-proposal-message",
-            children: proposal.message
-          }
-        ),
-        diff && /* @__PURE__ */ jsxs("div", { className: "mt-3 space-y-2", "data-testid": "workflow-proposal-diff", children: [
-          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: diff.summary }),
-          /* @__PURE__ */ jsx(
-            ChangeList,
-            {
-              testId: "workflow-proposal-added",
-              icon: "mdi:plus-circle-outline",
-              title: tr("fluidgrids.ai.proposal.added", "Added nodes"),
-              items: diff.addedNodes.map((node) => nodeLine(node, false))
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            ChangeList,
-            {
-              testId: "workflow-proposal-changed",
-              icon: "mdi:pencil-circle-outline",
-              title: tr("fluidgrids.ai.proposal.changed", "Changed nodes"),
-              items: diff.changedNodes.map((node) => nodeLine(node, true))
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            ChangeList,
-            {
-              testId: "workflow-proposal-removed",
-              icon: "mdi:minus-circle-outline",
-              title: tr("fluidgrids.ai.proposal.removed", "Removed nodes"),
-              items: diff.removedNodes.map((node) => nodeLine(node, false))
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            ChangeList,
-            {
-              testId: "workflow-proposal-edges",
-              icon: "mdi:vector-line",
-              title: tr(
-                "fluidgrids.ai.proposal.connections",
-                "Connection changes"
-              ),
-              items: [
-                ...diff.addedEdges.map((edge) => `+ ${edgeLabel(edge)}`),
-                ...diff.removedEdges.map((edge) => `\u2212 ${edgeLabel(edge)}`)
-              ]
-            }
-          )
-        ] }),
-        errors.length > 0 && /* @__PURE__ */ jsx(
-          "ul",
-          {
-            className: "mt-3 space-y-1 text-sm text-[var(--color-status-error-text)]",
-            "data-testid": "workflow-proposal-errors",
-            children: errors.map((message) => /* @__PURE__ */ jsx("li", { children: message }, message))
-          }
-        ),
-        warnings.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-3", "data-testid": "workflow-proposal-warnings", children: [
-          /* @__PURE__ */ jsx("div", { className: "text-xs font-medium uppercase tracking-wide text-text-secondary", children: tr("fluidgrids.ai.proposal.todo", "Still to set up") }),
-          /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-secondary", children: warnings.map((warning) => /* @__PURE__ */ jsx("li", { children: warning }, warning)) })
-        ] }),
-        status === "PROPOSED" && (onApply || onReject) && /* @__PURE__ */ jsxs("div", { className: "mt-4 flex flex-wrap items-center gap-2", children: [
-          onApply && /* @__PURE__ */ jsx(
-            Button$1,
-            {
-              size: "sm",
-              onClick: onApply,
-              disabled: isDeciding,
-              "data-testid": "workflow-proposal-apply",
-              children: proposal.baseVersion ? tr(
-                "fluidgrids.ai.proposal.applyVersion",
-                "Apply as a new draft version"
-              ) : tr(
-                "fluidgrids.ai.proposal.applyNew",
-                "Create as a draft workflow"
-              )
-            }
-          ),
-          onReject && /* @__PURE__ */ jsx(
-            Button$1,
-            {
-              size: "sm",
-              variant: "outline",
-              onClick: onReject,
-              disabled: isDeciding,
-              children: tr("fluidgrids.ai.proposal.reject", "Reject")
-            }
-          ),
-          /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
-            "fluidgrids.ai.proposal.neverActivates",
-            "Nothing goes live: the result is a draft you can review, run as a test and activate yourself."
-          ) })
-        ] }),
-        status === "APPLIED" && proposal.appliedWorkflowKey && proposal.appliedVersion && /* @__PURE__ */ jsxs("div", { className: "mt-4 space-y-2", children: [
-          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
-            onOpenWorkflow && /* @__PURE__ */ jsx(
-              Button$1,
-              {
-                size: "sm",
-                variant: "outline",
-                "data-testid": "workflow-proposal-open",
-                onClick: () => onOpenWorkflow(
-                  proposal.appliedWorkflowKey ?? "",
-                  proposal.appliedVersion ?? ""
-                ),
-                children: tr("fluidgrids.ai.proposal.open", "Open draft {{version}}", {
-                  version: proposal.appliedVersion
-                })
-              }
-            ),
-            onRevert && revertTarget && /* @__PURE__ */ jsx(
-              Button$1,
-              {
-                size: "sm",
-                variant: "ghost",
-                "data-testid": "workflow-proposal-revert",
-                disabled: isDeciding,
-                onClick: () => onRevert(revertTarget.workflowKey, revertTarget.version),
-                children: tr(
-                  "fluidgrids.ai.proposal.revert",
-                  "Revert to {{version}}",
-                  { version: revertTarget.version }
-                )
-              }
-            )
-          ] }),
-          !onRevert && proposal.restoreHint && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: proposal.restoreHint })
-        ] })
-      ]
-    }
-  );
-}
-
-// src/builder/lib/assert-rules.ts
-var ASSERT_OPERATORS = [
-  {
-    wire: "equals",
-    value: "EQUALS" /* Equals */,
-    operand: "expected",
-    label: "equals"
-  },
-  {
-    wire: "notEquals",
-    value: "NOT_EQUALS" /* NotEquals */,
-    operand: "expected",
-    label: "does not equal"
-  },
-  {
-    wire: "contains",
-    value: "CONTAINS" /* Contains */,
-    operand: "expected",
-    label: "contains"
-  },
-  {
-    wire: "notContains",
-    value: "NOT_CONTAINS" /* NotContains */,
-    operand: "expected",
-    label: "does not contain"
-  },
-  {
-    wire: "matches",
-    value: "MATCHES" /* Matches */,
-    operand: "expected",
-    label: "matches regex"
-  },
-  {
-    wire: "jsonSchema",
-    value: "JSON_SCHEMA" /* JsonSchema */,
-    operand: "expected",
-    label: "matches JSON Schema"
-  },
-  {
-    wire: "between",
-    value: "BETWEEN" /* Between */,
-    operand: "range",
-    label: "is between"
-  },
-  {
-    wire: "itemCount",
-    value: "ITEM_COUNT" /* ItemCount */,
-    operand: "range",
-    label: "has item count"
-  },
-  {
-    wire: "exists",
-    value: "EXISTS" /* Exists */,
-    operand: "none",
-    label: "exists"
-  },
-  {
-    wire: "notExists",
-    value: "NOT_EXISTS" /* NotExists */,
-    operand: "none",
-    label: "does not exist"
-  }
-];
-var MAX_REGEX_LENGTH = 500;
-var MAX_RULES = 50;
-function operatorSpec(value) {
-  if (typeof value !== "string") return null;
-  return ASSERT_OPERATORS.find(
-    (spec) => spec.wire === value || spec.value === value
-  ) ?? null;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalNumber(value) {
-  if (value === void 0 || value === null) return void 0;
-  return typeof value === "number" && Number.isFinite(value) ? value : false;
-}
-function normaliseAssertRule(raw, index) {
-  if (!isRecord2(raw)) return { problem: { code: "notObject", index } };
-  const spec = operatorSpec(raw.operator);
-  if (!spec)
-    return {
-      problem: {
-        code: "unknownOperator",
-        index,
-        operator: String(raw.operator ?? "")
-      }
-    };
-  const rule = { operator: spec.wire };
-  if (raw.path !== void 0 && raw.path !== null && raw.path !== "") {
-    if (typeof raw.path !== "string")
-      return { problem: { code: "pathInvalid", index } };
-    rule.path = raw.path;
-  }
-  if (raw.message !== void 0 && raw.message !== null && raw.message !== "") {
-    if (typeof raw.message !== "string")
-      return { problem: { code: "messageInvalid", index } };
-    rule.message = raw.message;
-  }
-  if (spec.operand === "expected") {
-    if (!("expected" in raw))
-      return { problem: { code: "expectedRequired", index } };
-    if (spec.wire === "matches") {
-      if (typeof raw.expected !== "string")
-        return { problem: { code: "regexInvalid", index } };
-      if (raw.expected.length > MAX_REGEX_LENGTH)
-        return { problem: { code: "regexTooLong", index } };
-      try {
-        new RegExp(raw.expected);
-      } catch {
-        return { problem: { code: "regexInvalid", index } };
-      }
-    }
-    if (spec.wire === "jsonSchema" && !isRecord2(raw.expected))
-      return { problem: { code: "schemaInvalid", index } };
-    rule.expected = raw.expected;
-  }
-  if (spec.operand === "range") {
-    const min = optionalNumber(raw.min);
-    const max = optionalNumber(raw.max);
-    if (min === false || max === false)
-      return { problem: { code: "rangeInvalid", index } };
-    if (min === void 0 && max === void 0)
-      return { problem: { code: "rangeRequired", index } };
-    if (min !== void 0 && max !== void 0 && min > max)
-      return { problem: { code: "rangeInvalid", index } };
-    if (min !== void 0) rule.min = min;
-    if (max !== void 0) rule.max = max;
-  }
-  return { rule };
-}
-function normaliseAssertRules(raw) {
-  if (raw.length === 0) return { problem: { code: "empty" } };
-  if (raw.length > MAX_RULES)
-    return { problem: { code: "tooMany", count: raw.length } };
-  const rules = [];
-  for (const [index, item] of raw.entries()) {
-    const result = normaliseAssertRule(item, index);
-    if ("problem" in result) return result;
-    rules.push(result.rule);
-  }
-  return { rules };
-}
-function describeAssertRuleProblem(problem) {
-  const at = "index" in problem ? `Rule ${problem.index + 1}: ` : "";
-  switch (problem.code) {
-    case "notObject":
-      return {
-        key: "fluidgrids.builder.assertRules.notObject",
-        fallback: `${at}a rule must be an object.`
-      };
-    case "unknownOperator":
-      return {
-        key: "fluidgrids.builder.assertRules.unknownOperator",
-        fallback: `${at}unknown operator "${problem.operator}". Use ${ASSERT_OPERATORS.map((spec) => spec.wire).join(", ")}.`
-      };
-    case "expectedRequired":
-      return {
-        key: "fluidgrids.builder.assertRules.expectedRequired",
-        fallback: `${at}this operator needs an expected value.`
-      };
-    case "rangeRequired":
-      return {
-        key: "fluidgrids.builder.assertRules.rangeRequired",
-        fallback: `${at}set a minimum, a maximum or both.`
-      };
-    case "rangeInvalid":
-      return {
-        key: "fluidgrids.builder.assertRules.rangeInvalid",
-        fallback: `${at}minimum and maximum must be numbers, with the minimum not above the maximum.`
-      };
-    case "regexInvalid":
-      return {
-        key: "fluidgrids.builder.assertRules.regexInvalid",
-        fallback: `${at}the expected value is not a valid regular expression.`
-      };
-    case "regexTooLong":
-      return {
-        key: "fluidgrids.builder.assertRules.regexTooLong",
-        fallback: `${at}a regular expression may have at most ${MAX_REGEX_LENGTH} characters.`
-      };
-    case "schemaInvalid":
-      return {
-        key: "fluidgrids.builder.assertRules.schemaInvalid",
-        fallback: `${at}the expected value must be a JSON Schema object.`
-      };
-    case "pathInvalid":
-      return {
-        key: "fluidgrids.builder.assertRules.pathInvalid",
-        fallback: `${at}the path must be text.`
-      };
-    case "messageInvalid":
-      return {
-        key: "fluidgrids.builder.assertRules.messageInvalid",
-        fallback: `${at}the message must be text.`
-      };
-    case "tooMany":
-      return {
-        key: "fluidgrids.builder.assertRules.tooMany",
-        fallback: `At most ${MAX_RULES} rules (found ${problem.count}).`
-      };
-    case "empty":
-      return {
-        key: "fluidgrids.builder.assertRules.empty",
-        fallback: "Add at least one rule."
-      };
-  }
-}
-function readAssertRulesSetting(value) {
-  if (value === void 0 || value === null || value === "") return [];
-  if (Array.isArray(value)) return value;
-  if (typeof value !== "string") return null;
-  try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function emptyAssertRuleRow() {
-  return {
-    path: "",
-    operator: "equals",
-    expected: "",
-    min: "",
-    max: "",
-    message: ""
-  };
-}
-function rowNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? String(value) : "";
-}
-function rowExpected(operator, value) {
-  if (value === void 0) return "";
-  if (operator === "matches" && typeof value === "string") return value;
-  return JSON.stringify(value);
-}
-function rowsFromRules(rules) {
-  return rules.map((raw) => {
-    const rule = isRecord2(raw) ? raw : {};
-    const operator = operatorSpec(rule.operator)?.wire ?? (typeof rule.operator === "string" ? rule.operator : "equals");
-    return {
-      path: typeof rule.path === "string" ? rule.path : "",
-      operator,
-      expected: rowExpected(operator, rule.expected),
-      min: rowNumber(rule.min),
-      max: rowNumber(rule.max),
-      message: typeof rule.message === "string" ? rule.message : ""
-    };
-  });
-}
-function parseExpected(operator, text) {
-  if (operator === "matches") return text;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function parseRowNumber(text) {
-  const trimmed = text.trim();
-  if (trimmed === "") return void 0;
-  const value = Number(trimmed);
-  return Number.isFinite(value) ? value : trimmed;
-}
-function ruleFromRow(row) {
-  const spec = operatorSpec(row.operator);
-  const rule = { operator: row.operator };
-  if (row.path.trim()) rule.path = row.path.trim();
-  if (spec?.operand === "expected" && (row.expected !== "" || spec.wire === "matches"))
-    rule.expected = parseExpected(spec.wire, row.expected);
-  if (spec?.operand === "range") {
-    const min = parseRowNumber(row.min);
-    const max = parseRowNumber(row.max);
-    if (min !== void 0) rule.min = min;
-    if (max !== void 0) rule.max = max;
-  }
-  if (row.message.trim()) rule.message = row.message.trim();
-  return rule;
-}
-
-// src/builder/lib/workflow-tests.ts
-var MAX_TEST_CASES = 50;
-var MAX_CASE_JSON_BYTES = 256 * 1024;
-var MAX_CASE_ENTRIES = 100;
-var MAX_CASE_NAME = 200;
-function emptyTestCaseDraft() {
-  return {
-    name: "",
-    description: "",
-    enabled: true,
-    expectedStatus: "COMPLETED" /* Completed */,
-    triggerNodeId: "",
-    triggerData: "{}",
-    pinnedOutputs: "{}",
-    connectionMocks: "[]",
-    expectations: "{}"
-  };
-}
-function pretty(value) {
-  return JSON.stringify(value, null, 2);
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function wireRule(rule) {
-  const wire = {
-    operator: operatorSpec(rule.operator)?.wire ?? String(rule.operator)
-  };
-  if (rule.path) wire.path = rule.path;
-  if (rule.expected !== null && rule.expected !== void 0)
-    wire.expected = rule.expected;
-  if (rule.min !== null && rule.min !== void 0) wire.min = rule.min;
-  if (rule.max !== null && rule.max !== void 0) wire.max = rule.max;
-  if (rule.message) wire.message = rule.message;
-  return wire;
-}
-function draftFromTestCase(testCase) {
-  const expectations = {};
-  for (const expectation of testCase.expectations)
-    expectations[expectation.nodeId] = expectation.rules.map(wireRule);
-  const mocks = testCase.connectionMocks.map((mock) => {
-    const entry = { nodeId: mock.nodeId };
-    if (mock.operation) entry.operation = mock.operation;
-    if (mock.error) {
-      entry.error = mock.error.errorType ? { message: mock.error.message, errorType: mock.error.errorType } : { message: mock.error.message };
-    } else {
-      entry.response = mock.response ?? {};
-    }
-    return entry;
-  });
-  return {
-    name: testCase.name,
-    description: testCase.description ?? "",
-    enabled: testCase.enabled,
-    expectedStatus: testCase.expectedStatus,
-    triggerNodeId: testCase.triggerNodeId ?? "",
-    triggerData: pretty(testCase.triggerData ?? {}),
-    pinnedOutputs: pretty(testCase.pinnedOutputs ?? {}),
-    connectionMocks: pretty(mocks),
-    expectations: pretty(expectations)
-  };
-}
-function pinnedOutputsFromCanvas(pinned) {
-  const outputs = {};
-  for (const [nodeId, entry] of Object.entries(pinned ?? {})) {
-    if (entry && isRecord3(entry.data)) outputs[nodeId] = { data: entry.data };
-  }
-  return outputs;
-}
-function parseJson(text, field, label) {
-  const source = text.trim();
-  if (source === "") return { value: void 0 };
-  try {
-    return { value: JSON.parse(source) };
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return {
-      error: {
-        field,
-        key: "fluidgrids.builder.workflowTests.invalidJson",
-        fallback: `${label} is not valid JSON: ${reason}`
-      }
-    };
-  }
-}
-function fieldError(field, key, fallback) {
-  return {
-    error: { field, key: `fluidgrids.builder.workflowTests.${key}`, fallback }
-  };
-}
-function parseTriggerData(text) {
-  const parsed = parseJson(text, "triggerData", "Trigger data");
-  if ("error" in parsed) return parsed;
-  if (parsed.value === void 0) return { value: {} };
-  if (!isRecord3(parsed.value))
-    return fieldError(
-      "triggerData",
-      "triggerDataShape",
-      "Trigger data must be a JSON object."
-    );
-  return { value: parsed.value };
-}
-function parsePinnedOutputs(text) {
-  const parsed = parseJson(text, "pinnedOutputs", "Pinned outputs");
-  if ("error" in parsed) return parsed;
-  if (parsed.value === void 0) return { value: {} };
-  if (!isRecord3(parsed.value))
-    return fieldError(
-      "pinnedOutputs",
-      "pinnedShape",
-      'Pinned outputs must be an object of { "nodeId": { "data": { ... } } }.'
-    );
-  const entries = Object.entries(parsed.value);
-  if (entries.length > MAX_CASE_ENTRIES)
-    return fieldError(
-      "pinnedOutputs",
-      "pinnedTooMany",
-      `At most ${MAX_CASE_ENTRIES} pinned nodes.`
-    );
-  const outputs = {};
-  for (const [nodeId, entry] of entries) {
-    if (!isRecord3(entry) || !isRecord3(entry.data))
-      return fieldError(
-        "pinnedOutputs",
-        "pinnedShape",
-        `Pinned output "${nodeId}" must be { "data": { ... } }.`
-      );
-    outputs[nodeId] = { data: entry.data };
-  }
-  return { value: outputs };
-}
-var ERROR_TYPES = new Set(Object.values(ErrorType));
-function isErrorType(value) {
-  return ERROR_TYPES.has(value);
-}
-function parseConnectionMocks(text) {
-  const parsed = parseJson(text, "connectionMocks", "Connection mocks");
-  if ("error" in parsed) return parsed;
-  if (parsed.value === void 0) return { value: [] };
-  if (!Array.isArray(parsed.value))
-    return fieldError(
-      "connectionMocks",
-      "mocksShape",
-      'Connection mocks must be an array of { "nodeId", "response" } or { "nodeId", "error" }.'
-    );
-  if (parsed.value.length > MAX_CASE_ENTRIES)
-    return fieldError(
-      "connectionMocks",
-      "mocksTooMany",
-      `At most ${MAX_CASE_ENTRIES} connection mocks.`
-    );
-  const mocks = [];
-  for (const [index, raw] of parsed.value.entries()) {
-    const at = `Mock ${index + 1}`;
-    if (!isRecord3(raw) || typeof raw.nodeId !== "string" || !raw.nodeId)
-      return fieldError(
-        "connectionMocks",
-        "mockNodeRequired",
-        `${at} needs a "nodeId".`
-      );
-    if (raw.operation !== void 0 && raw.operation !== null && typeof raw.operation !== "string")
-      return fieldError(
-        "connectionMocks",
-        "mockOperationInvalid",
-        `${at}: "operation" must be text.`
-      );
-    const hasResponse = raw.response !== void 0 && raw.response !== null;
-    const hasError = raw.error !== void 0 && raw.error !== null;
-    if (hasResponse === hasError)
-      return fieldError(
-        "connectionMocks",
-        "mockResponseOrError",
-        `${at} must set exactly one of "response" and "error".`
-      );
-    const mock = { nodeId: raw.nodeId };
-    if (typeof raw.operation === "string" && raw.operation)
-      mock.operation = raw.operation;
-    if (hasResponse) {
-      mock.response = jsonScalar(raw.response);
-    } else {
-      const error = raw.error;
-      if (!isRecord3(error) || typeof error.message !== "string")
-        return fieldError(
-          "connectionMocks",
-          "mockErrorShape",
-          `${at}: "error" must be { "message": "...", "errorType"?: "..." }.`
-        );
-      const errorType = error.errorType;
-      if (errorType !== void 0 && errorType !== null) {
-        if (typeof errorType !== "string" || !isErrorType(errorType))
-          return fieldError(
-            "connectionMocks",
-            "mockErrorType",
-            `${at}: "errorType" must be one of ${[...ERROR_TYPES].join(", ")}.`
-          );
-        mock.error = { message: error.message, errorType };
-      } else {
-        mock.error = { message: error.message };
-      }
-    }
-    mocks.push(mock);
-  }
-  return { value: mocks };
-}
-function jsonScalar(value) {
-  return value;
-}
-function ruleInput(rule) {
-  const spec = operatorSpec(rule.operator);
-  if (!spec) return [];
-  const input = { operator: spec.value };
-  if (rule.path !== void 0) input.path = rule.path;
-  if (rule.expected !== void 0) input.expected = jsonScalar(rule.expected);
-  if (rule.min !== void 0) input.min = rule.min;
-  if (rule.max !== void 0) input.max = rule.max;
-  if (rule.message !== void 0) input.message = rule.message;
-  return [input];
-}
-function expectationEntries(value) {
-  if (isRecord3(value)) return Object.entries(value);
-  if (Array.isArray(value)) {
-    const entries = [];
-    for (const item of value) {
-      if (!isRecord3(item)) return null;
-      entries.push([item.nodeId, item.rules]);
-    }
-    return entries;
-  }
-  return null;
-}
-function parseExpectations(text) {
-  const parsed = parseJson(text, "expectations", "Expectations");
-  if ("error" in parsed) return parsed;
-  if (parsed.value === void 0) return { value: [] };
-  const entries = expectationEntries(parsed.value);
-  if (!entries)
-    return fieldError(
-      "expectations",
-      "expectationsShape",
-      'Expectations must be an object of { "nodeId": [rules] }.'
-    );
-  if (entries.length > MAX_CASE_ENTRIES)
-    return fieldError(
-      "expectations",
-      "expectationsTooMany",
-      `At most ${MAX_CASE_ENTRIES} checked nodes.`
-    );
-  const expectations = [];
-  for (const [nodeId, rules] of entries) {
-    if (typeof nodeId !== "string" || !nodeId || !Array.isArray(rules))
-      return fieldError(
-        "expectations",
-        "expectationsShape",
-        'Expectations must be an object of { "nodeId": [rules] }.'
-      );
-    const result = normaliseAssertRules(rules);
-    if ("problem" in result) {
-      const problem = describeAssertRuleProblem(result.problem);
-      return {
-        error: {
-          field: "expectations",
-          key: problem.key,
-          fallback: `${nodeId}: ${problem.fallback}`
-        }
-      };
-    }
-    expectations.push({ nodeId, rules: result.rules.flatMap(ruleInput) });
-  }
-  return { value: expectations };
-}
-function draftToInput(draft, sortOrder) {
-  const name = draft.name.trim();
-  if (!name)
-    return fieldError("name", "nameRequired", "Give the test case a name.");
-  if (name.length > MAX_CASE_NAME)
-    return fieldError(
-      "name",
-      "nameTooLong",
-      `A name may have at most ${MAX_CASE_NAME} characters.`
-    );
-  const triggerData = parseTriggerData(draft.triggerData);
-  if ("error" in triggerData) return triggerData;
-  const pinnedOutputs = parsePinnedOutputs(draft.pinnedOutputs);
-  if ("error" in pinnedOutputs) return pinnedOutputs;
-  const connectionMocks = parseConnectionMocks(draft.connectionMocks);
-  if ("error" in connectionMocks) return connectionMocks;
-  const expectations = parseExpectations(draft.expectations);
-  if ("error" in expectations) return expectations;
-  const bytes = new TextEncoder().encode(
-    JSON.stringify([
-      triggerData.value,
-      pinnedOutputs.value,
-      connectionMocks.value,
-      expectations.value
-    ])
-  ).length;
-  if (bytes > MAX_CASE_JSON_BYTES)
-    return fieldError(
-      "size",
-      "tooLarge",
-      `The case holds ${Math.ceil(bytes / 1024)} KiB of JSON; the limit is ${MAX_CASE_JSON_BYTES / 1024} KiB.`
-    );
-  const description = draft.description.trim();
-  const input = {
-    name,
-    description: description || null,
-    triggerNodeId: draft.triggerNodeId || null,
-    triggerData: triggerData.value,
-    pinnedOutputs: pinnedOutputs.value,
-    connectionMocks: connectionMocks.value,
-    expectedStatus: draft.expectedStatus,
-    expectations: expectations.value,
-    enabled: draft.enabled
-  };
-  if (sortOrder !== void 0) input.sortOrder = sortOrder;
-  return { input };
-}
-function isTestRunOpen(status) {
-  return status === "PENDING" /* Pending */ || status === "RUNNING" /* Running */;
-}
-function testStatusTone(status) {
-  switch (status) {
-    case "PASSED" /* Passed */:
-      return "success";
-    case "FAILED" /* Failed */:
-      return "error";
-    case "ERROR" /* Error */:
-      return "warning";
-    default:
-      return "pending";
-  }
-}
-var TEST_STATUS_TONE_CLASS = {
-  success: "border-[var(--color-status-success-border)] bg-[var(--color-status-success-bg-subtle)] text-[var(--color-status-success-text)]",
-  error: "border-[var(--color-status-error-border)] bg-[var(--color-status-error-bg-subtle)] text-[var(--color-status-error-text)]",
-  warning: "border-[var(--color-status-warning-border)] bg-[var(--color-status-warning-bg-subtle)] text-[var(--color-status-warning-text)]",
-  pending: "border-border bg-muted text-muted-foreground"
-};
-function testStatusLabel(status) {
-  const fallback = {
-    ["PENDING" /* Pending */]: "Pending",
-    ["RUNNING" /* Running */]: "Running",
-    ["PASSED" /* Passed */]: "Passed",
-    ["FAILED" /* Failed */]: "Failed",
-    ["ERROR" /* Error */]: "Error"
-  };
-  return {
-    key: `fluidgrids.builder.workflowTests.status.${status.toLowerCase()}`,
-    fallback: fallback[status]
-  };
-}
-function testRunSummaryText(summary) {
-  const parts = [`${summary.passed} passed`];
-  if (summary.failed) parts.push(`${summary.failed} failed`);
-  if (summary.errored) parts.push(`${summary.errored} errored`);
-  if (summary.pending) parts.push(`${summary.pending} running`);
-  return `${parts.join(" \xB7 ")} of ${summary.total}`;
-}
-function enabledCaseIds(cases) {
-  return cases.filter((testCase) => testCase.enabled).map((c) => c.id);
-}
-function nextSortOrder(cases) {
-  return cases.reduce((max, c) => Math.max(max, c.sortOrder + 1), 0);
-}
-var SAVEABLE_RUN_STATUSES = /* @__PURE__ */ new Set([
-  "COMPLETED",
-  "FAILED"
-]);
-function canSaveRunAsTestCase(run) {
-  return SAVEABLE_RUN_STATUSES.has(run.status) && !!run.workflowKey && !run.isDurable;
-}
-var TEST_RUN_POLL_INTERVAL_MS = 2e3;
-var TEST_RUN_HISTORY_LIMIT = 10;
-function messageOf2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function upsertRun(runs, run) {
-  return [run, ...runs.filter((item) => item.id !== run.id)].slice(
-    0,
-    TEST_RUN_HISTORY_LIMIT
-  );
-}
-function useWorkflowTests(workflowKey, enabled) {
-  const [cases, setCases] = useState([]);
-  const [runs, setRuns] = useState([]);
-  const [activeRunId, setActiveRunId] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const [forbidden, setForbidden] = useState(false);
-  const [pollTick, setPollTick] = useState(0);
-  const keyRef = useRef(workflowKey);
-  const refetch = useCallback(async () => {
-    if (!enabled || !workflowKey) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const client = getFluidGridsClient();
-      const [caseResult, runResult] = await Promise.all([
-        client.query({
-          query: WorkflowTestCasesDocument,
-          variables: { workflowKey },
-          fetchPolicy: "network-only"
-        }),
-        client.query({
-          query: WorkflowTestRunsDocument,
-          variables: { workflowKey, limit: TEST_RUN_HISTORY_LIMIT },
-          fetchPolicy: "network-only"
-        })
-      ]);
-      throwIfResultError(caseResult);
-      throwIfResultError(runResult);
-      if (keyRef.current !== workflowKey) return;
-      setCases(caseResult.data?.workflowTestCases ?? []);
-      setRuns(runResult.data?.workflowTestRuns ?? []);
-      setForbidden(false);
-    } catch (err) {
-      if (keyRef.current !== workflowKey) return;
-      if (isForbiddenError(err)) setForbidden(true);
-      else setError(messageOf2(err));
-    } finally {
-      if (keyRef.current === workflowKey) setLoading(false);
-    }
-  }, [enabled, workflowKey]);
-  useEffect(() => {
-    keyRef.current = workflowKey;
-    setCases([]);
-    setRuns([]);
-    setActiveRunId(null);
-    setForbidden(false);
-    setError(null);
-  }, [workflowKey]);
-  const activeRun = (activeRunId ? runs.find((run) => run.id === activeRunId) : runs[0]) ?? null;
-  const followedId = activeRun && isTestRunOpen(activeRun.status) ? activeRun.id : null;
-  useEffect(() => {
-    if (!enabled || !followedId) return;
-    let cancelled = false;
-    const key = workflowKey;
-    const timer = setTimeout(() => {
-      void (async () => {
-        try {
-          const result = await getFluidGridsClient().query({
-            query: WorkflowTestRunDocument,
-            variables: { id: followedId },
-            fetchPolicy: "network-only"
-          });
-          throwIfResultError(result);
-          const run = result.data?.workflowTestRun;
-          if (cancelled || keyRef.current !== key || !run) return;
-          setRuns((current) => upsertRun(current, run));
-          if (!isTestRunOpen(run.status)) await refetchCases(key);
-        } catch (err) {
-          if (!cancelled && keyRef.current === key) setError(messageOf2(err));
-        } finally {
-          if (!cancelled) setPollTick((tick) => tick + 1);
-        }
-      })();
-    }, TEST_RUN_POLL_INTERVAL_MS);
-    async function refetchCases(forKey) {
-      const result = await getFluidGridsClient().query({
-        query: WorkflowTestCasesDocument,
-        variables: { workflowKey: forKey },
-        fetchPolicy: "network-only"
-      });
-      throwIfResultError(result);
-      if (!cancelled && keyRef.current === forKey)
-        setCases(result.data?.workflowTestCases ?? []);
-    }
-    return () => {
-      cancelled = true;
-      clearTimeout(timer);
-    };
-  }, [enabled, followedId, workflowKey, pollTick]);
-  const createCase = useCallback(
-    async (input) => {
-      const result = await getFluidGridsClient().mutate({
-        mutation: CreateWorkflowTestCaseDocument,
-        variables: { workflowKey, input }
-      });
-      throwIfResultError(result);
-      const created = result.data?.createWorkflowTestCase;
-      if (!created) throw new Error("The test case was not saved.");
-      await refetch();
-      return created;
-    },
-    [workflowKey, refetch]
-  );
-  const updateCase = useCallback(
-    async (id, input) => {
-      const result = await getFluidGridsClient().mutate({
-        mutation: UpdateWorkflowTestCaseDocument,
-        variables: { id, input }
-      });
-      throwIfResultError(result);
-      const updated = result.data?.updateWorkflowTestCase;
-      if (!updated) throw new Error("The test case was not saved.");
-      await refetch();
-      return updated;
-    },
-    [refetch]
-  );
-  const deleteCase = useCallback(
-    async (id) => {
-      const result = await getFluidGridsClient().mutate({
-        mutation: DeleteWorkflowTestCaseDocument,
-        variables: { id }
-      });
-      throwIfResultError(result);
-      await refetch();
-    },
-    [refetch]
-  );
-  const runTests = useCallback(
-    async (options = {}) => {
-      const result = await getFluidGridsClient().mutate({
-        mutation: RunWorkflowTestsDocument,
-        variables: {
-          input: {
-            workflowKey,
-            source: "UI" /* Ui */,
-            ...options.version ? { version: options.version } : {},
-            ...options.caseIds ? { caseIds: options.caseIds } : {}
-          }
-        }
-      });
-      throwIfResultError(result);
-      const run = result.data?.runWorkflowTests;
-      if (!run) throw new Error("The test run did not start.");
-      setRuns((current) => upsertRun(current, run));
-      setActiveRunId(run.id);
-      return run;
-    },
-    [workflowKey]
-  );
-  return {
-    cases,
-    runs,
-    activeRun,
-    loading,
-    error,
-    forbidden,
-    refetch,
-    createCase,
-    updateCase,
-    deleteCase,
-    runTests
-  };
-}
-async function saveRunAsTestCase(runId, name, description) {
-  const result = await getFluidGridsClient().mutate({
-    mutation: CreateWorkflowTestCaseFromRunDocument,
-    variables: {
-      runId,
-      name,
-      ...description ? { description } : {}
-    }
-  });
-  throwIfResultError(result);
-  const created = result.data?.createWorkflowTestCaseFromRun;
-  if (!created) throw new Error("The test case was not saved.");
-  return created;
-}
-
-export { ASSERT_OPERATORS, EntityTagPicker, MAX_CASE_NAME, MAX_TEST_CASES, RunHistoryView, SignalRunDialog, TEST_STATUS_TONE_CLASS, WorkflowProposalCard, canSaveRunAsTestCase, describeAssertRuleProblem, draftFromTestCase, draftToInput, emptyAssertRuleRow, emptyTestCaseDraft, enabledCaseIds, isTestRunOpen, nextSortOrder, normaliseAssertRules, operatorSpec, pinnedOutputsFromCanvas, readAssertRulesSetting, rowsFromRules, ruleFromRow, saveRunAsTestCase, terminateDurableRun, testRunSummaryText, testStatusLabel, testStatusTone, useDeterminismStatus, useDurableRunFields, useRunHistory, useRunStackTrace, useWorkflowProposal, useWorkflowTests };