@burdenoff/fluidgrids-fe-sdk 2026.1027.11 → 2026.1027.13

package/dist/{chunk-46VSRXC2.js → chunk-FUVZHSU3.js}

@@ -1,9 +1,9 @@
-import { buildNodeDisplayMap, ExecutionStatusBadge, formatRunVersion, NodeTimeline, RunLogViewer } from './chunk-ZQTAZE55.js';
-import { useExecution, useExecutionActions, useAutoRefresh } from './chunk-QVYC37ZX.js';
-import { EntityTagPicker } from './chunk-Z6AFJGX3.js';
-import { throwIfResultError, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-H7PTIEUR.js';
+import { buildNodeDisplayMap, ExecutionStatusBadge, formatRunVersion, NodeTimeline, RunLogViewer } from './chunk-WJ3SQ7CF.js';
+import { useExecution, useExecutionActions, useAutoRefresh } from './chunk-GVLJRPVK.js';
+import { EntityTagPicker } from './chunk-BN6MTJ6A.js';
+import { throwIfResultError, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-JK5GPFYR.js';
 import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
-import { RunLogsDocument, RunLogAppendedDocument } from './chunk-TXQVCIVV.js';
+import { RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument, WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument } from './chunk-M3Q6GJCR.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
@@ -11,7 +11,7 @@ import { useParams, useNavigate, Link } from 'react-router';
 import { Icon } from '@iconify/react';
 import { toast } from 'sonner';
 import { Button } from '@burdenoff/fe-libs/button';
-import { Card, CardHeader, Badge, CardContent, Label, Textarea, AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction, Input } from '@burdenoff/fe-libs/ui';
+import { Card, CardHeader, Badge, CardContent, Label, Textarea, AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction, Input, Button as Button$1 } from '@burdenoff/fe-libs/ui';
 import { useActorProfiles, buildActorFallback } from '@burdenoff/fe-libs/shared';
 import { gql } from '@apollo/client';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
@@ -800,6 +800,522 @@ function RunQueuedBanner({
     }
   );
 }
+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);
+        }
+        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 } : {}
+                }
+              }
+            })
+          );
+          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 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,
+    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 WorkflowProposalCard({
+  proposal,
+  isDeciding = false,
+  onOpenWorkflow,
+  onApply,
+  onReject,
+  onCancel
+}) {
+  const tr = useTr();
+  const status = String(proposal.status);
+  const diff = proposal.diff;
+  const warnings = proposal.validation?.warnings ?? [];
+  const errors = proposal.validation?.valid === false ? proposal.validation.errors : [];
+  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
+          }
+        ),
+        proposal.message && status !== "PROPOSED" && status !== "PROCESSING" && status !== "APPLIED" && /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-text-secondary", 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)]", 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-1", 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
+              })
+            }
+          ),
+          proposal.restoreHint && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: proposal.restoreHint })
+        ] })
+      ]
+    }
+  );
+}
+function RunAiAssistPanel({
+  runId,
+  status,
+  canPropose,
+  canApply,
+  onOpenWorkflow
+}) {
+  const tr = useTr();
+  const [explanation, setExplanation] = useState(null);
+  const [explaining, setExplaining] = useState(false);
+  const [explainError, setExplainError] = useState(null);
+  const proposal = useWorkflowProposal();
+  const explain = useCallback(async () => {
+    setExplaining(true);
+    setExplainError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().query({
+          query: ExplainRunDocument,
+          variables: { runId },
+          fetchPolicy: "network-only"
+        })
+      );
+      setExplanation(result.data?.explainRun ?? null);
+    } catch (error) {
+      setExplainError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setExplaining(false);
+    }
+  }, [runId]);
+  const proposeFix = useCallback(() => {
+    void proposal.start({ kind: "runFix", runId });
+  }, [proposal, runId]);
+  const apply = useCallback(async () => {
+    const applied = await proposal.apply();
+    const appliedStatus = applied ? String(applied.status) : void 0;
+    if (appliedStatus === "APPLIED") {
+      toast.success(
+        tr(
+          "fluidgrids.ai.runAssist.appliedToast",
+          "Fix saved as draft {{version}}",
+          {
+            version: applied?.appliedVersion ?? ""
+          }
+        )
+      );
+    } else if (appliedStatus === "STALE") {
+      toast.warning(
+        tr(
+          "fluidgrids.ai.runAssist.staleToast",
+          "The workflow changed since this run. Propose the fix again."
+        )
+      );
+    }
+  }, [proposal, tr]);
+  if (status !== "FAILED" && status !== "TERMINATED") return null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-6 rounded-lg border border-border-secondary bg-background-primary p-4",
+      "data-testid": "run-ai-assist",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:robot-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: tr("fluidgrids.ai.runAssist.title", "AI assistant") }),
+          /* @__PURE__ */ jsxs("div", { className: "ml-auto flex gap-2", children: [
+            /* @__PURE__ */ jsx(
+              Button$1,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => void explain(),
+                disabled: explaining,
+                "data-testid": "run-ai-explain",
+                children: explaining ? tr("fluidgrids.ai.runAssist.explaining", "Explaining\u2026") : tr("fluidgrids.ai.runAssist.explain", "Explain failure")
+              }
+            ),
+            canPropose && /* @__PURE__ */ jsx(
+              Button$1,
+              {
+                size: "sm",
+                onClick: proposeFix,
+                disabled: proposal.isWorking,
+                "data-testid": "run-ai-propose-fix",
+                children: proposal.isWorking ? tr("fluidgrids.ai.runAssist.proposing", "Proposing\u2026") : tr("fluidgrids.ai.runAssist.proposeFix", "Propose a fix")
+              }
+            )
+          ] })
+        ] }),
+        explainError && /* @__PURE__ */ jsx("p", { className: "mt-3 text-sm text-[var(--color-status-error-text)]", children: explainError }),
+        explanation && /* @__PURE__ */ jsxs("div", { className: "mt-3 space-y-2", "data-testid": "run-ai-explanation", children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm text-text-primary", children: explanation.cause }),
+          explanation.evidence.length > 0 && /* @__PURE__ */ jsx("pre", { className: "max-h-40 overflow-auto whitespace-pre-wrap rounded bg-background-secondary p-2 text-xs text-text-secondary", children: explanation.evidence.join("\n") }),
+          explanation.suggestions.length > 0 && /* @__PURE__ */ jsx("ul", { className: "list-disc space-y-0.5 pl-5 text-sm text-text-primary", children: explanation.suggestions.map((suggestion) => /* @__PURE__ */ jsx("li", { children: suggestion }, suggestion)) })
+        ] }),
+        proposal.error && /* @__PURE__ */ jsx("p", { className: "mt-3 text-sm text-[var(--color-status-error-text)]", children: proposal.error }),
+        proposal.timedOut && /* @__PURE__ */ jsx("p", { className: "mt-3 text-sm text-text-secondary", children: tr(
+          "fluidgrids.ai.runAssist.timedOut",
+          "The fix is taking longer than usual. Check back in a minute."
+        ) }),
+        proposal.proposal && /* @__PURE__ */ jsx("div", { className: "mt-3", children: /* @__PURE__ */ jsx(
+          WorkflowProposalCard,
+          {
+            proposal: proposal.proposal,
+            isDeciding: proposal.isDeciding,
+            onOpenWorkflow,
+            ...canApply ? { onApply: () => void apply() } : {},
+            onReject: () => void proposal.reject(),
+            onCancel: () => void proposal.cancel()
+          }
+        ) })
+      ]
+    }
+  );
+}
 function ExecutionDetailPage() {
   const tr = useTr();
   const { runId } = useParams();
@@ -813,6 +1329,12 @@ function ExecutionDetailPage() {
   const { allowed: canTagRun } = useFluidGridsPermission(
     FLUIDGRIDS_PERMISSIONS.WORKFLOW_UPDATE
   );
+  const { allowed: canProposeFix } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.AI_WORKFLOW_CREATE
+  );
+  const { allowed: canApplyFix } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.WORKFLOW_CREATE
+  );
   const [minLogLevel, setMinLogLevel] = useState(null);
   const { execution, loading, error, refetch } = useExecution(runId);
   const runCanChange = execution?.status === "RUNNING" || execution?.status === "PENDING" || execution?.status === "WAITING";
@@ -1394,6 +1916,18 @@ function ExecutionDetailPage() {
       ] }),
       /* @__PURE__ */ jsx("p", { className: "text-[var(--color-status-error-text)]", children: execution.errorMessage })
     ] }),
+    /* @__PURE__ */ jsx(
+      RunAiAssistPanel,
+      {
+        runId: execution.id,
+        status: execution.status,
+        canPropose: canProposeFix,
+        canApply: canApplyFix,
+        onOpenWorkflow: (workflowKey, version) => navigate(
+          `../workflow/${encodeURIComponent(workflowKey)}/${encodeURIComponent(version)}`
+        )
+      }
+    ),
     /* @__PURE__ */ jsx(RunQueuedBanner, { status: execution.status, context: execution.context }),
     /* @__PURE__ */ jsx(RunDataPrunedNotice, { dataPrunedAt: execution.dataPrunedAt }),
     /* @__PURE__ */ jsx(RunHumanRequests, { requests: humanRequests }),

package/dist/{chunk-QVYC37ZX.js → chunk-GVLJRPVK.js}

@@ -1,7 +1,7 @@
 import { REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS } from './chunk-5ERAJC2I.js';
-import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-H7PTIEUR.js';
+import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-JK5GPFYR.js';
 import { useExecutionsStore } from './chunk-CY6KX4RG.js';
-import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-TXQVCIVV.js';
+import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-M3Q6GJCR.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';

package/dist/{chunk-6Z6SWFBA.js → chunk-J4PFYC4Z.js}

@@ -1,5 +1,5 @@
 import { LOG_STREAM_DESTINATIONS, CREATE_LOG_STREAM_DESTINATION, UPDATE_LOG_STREAM_DESTINATION, DELETE_LOG_STREAM_DESTINATION, TEST_LOG_STREAM_DESTINATION, REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS, OBSERVABILITY_DASHBOARD_SUMMARY, OBSERVABILITY_FAILED_RUNS, OBSERVABILITY_DATA_SINKS, OBSERVABILITY_DATA_SINK_DATA } from './chunk-5ERAJC2I.js';
-import { throwIfResultError, describeOperationError, useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-H7PTIEUR.js';
+import { throwIfResultError, describeOperationError, useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-JK5GPFYR.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useOptionalFeatureFlag } from '@burdenoff/fe-libs/shared/feature-flags';

package/dist/{chunk-H7PTIEUR.js → chunk-JK5GPFYR.js}

@@ -2,7 +2,7 @@ import { cn as cn$1 } from './chunk-JL7CASN5.js';
 import { getGlobalStoreClient, createGlobalStoreClient, setGlobalStoreClient, resetGlobalStoreClient } from './chunk-PXIFUMLA.js';
 import { getFluidGridsConfig, validateTrustedOrigin, resetFluidGridsExecutionState, setFluidGridsConfig, resetFluidGridsConfig } from './chunk-CY6KX4RG.js';
 import { GetMyNodeInstallationsDocument } from './chunk-WBH2XEWO.js';
-import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-TXQVCIVV.js';
+import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-M3Q6GJCR.js';
 import { useTr, ENGLISH_FALLBACK_TRANSLATOR, FluidGridsTranslationProvider } from './chunk-UULVIT25.js';
 import { waitForFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, createFluidGridsClient, setFluidGridsClient, resetFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { CombinedGraphQLErrors, ServerError } from '@apollo/client/errors';