@burdenoff/fluidgrids-fe-sdk 2026.1029.6 → 2026.1029.8

package/dist/{chunk-H364USFF.js → chunk-UIDJT3YK.js}

@@ -1,4 +1,4 @@
-import { throwIfResultError, describeOperationError } from './chunk-4TGUNOQQ.js';
+import { throwIfResultError, describeOperationError } from './chunk-NAYPOEYM.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useCallback, useEffect, useMemo } from 'react';

package/dist/{chunk-4XAPSIHY.js → chunk-UWNCFMHV.js}

@@ -1,9 +1,12 @@
-import { validateDateRange } from './chunk-57RS7DXZ.js';
-import { useAvailableTags } from './chunk-5GD6OXYW.js';
+import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-HWEKWYXQ.js';
+import { useAvailableTags } from './chunk-Z6I6A47T.js';
 import { executionsControls } from './chunk-D3UWK7GY.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
-import { useExecutionsStore } from './chunk-CY6KX4RG.js';
+import { useDurableParityEnabled, throwIfResultError, describeOperationError } from './chunk-NAYPOEYM.js';
+import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
+import { SetWorkflowRunVersioningOverrideDocument, WorkflowRunsCountDocument, DurableParityRunFieldsDocument, WorkflowRunPendingDocument, WorkflowRunMetadataDocument } from './chunk-GQTEHWWY.js';
 import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { Icon } from '@iconify/react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { useMemo, useState, useCallback, useRef, useEffect } from 'react';
@@ -135,16 +138,10 @@ var NODE_STATUS_CONFIG = {
     icon: "mdi:subdirectory-arrow-right"
   }
 };
-function ExecutionStatusBadge({
-  status,
-  size = "md",
-  showIcon = true,
-  showLabel = true,
-  animated = true
-}) {
-  const tr = useTr();
-  const config = RUN_STATUS_CONFIG[status] ?? RUN_STATUS_CONFIG.PENDING;
-  const labels = {
+
+// src/modules/executions/utils/run-status-labels.ts
+function runStatusLabels(tr) {
+  return {
     PENDING: tr(
       "fluidgrids.executions.executionFilters.statusPending",
       "Pending"
@@ -171,6 +168,17 @@ function ExecutionStatusBadge({
       "Terminated"
     )
   };
+}
+function ExecutionStatusBadge({
+  status,
+  size = "md",
+  showIcon = true,
+  showLabel = true,
+  animated = true
+}) {
+  const tr = useTr();
+  const config = RUN_STATUS_CONFIG[status] ?? RUN_STATUS_CONFIG.PENDING;
+  const labels = runStatusLabels(tr);
   const sizeClasses = {
     sm: "px-1.5 py-0.5 text-xs gap-1",
     md: "px-2 py-1 text-sm gap-1.5",
@@ -249,6 +257,23 @@ function NodeStatusBadge({
     }
   );
 }
+
+// src/modules/executions/utils/active-filters.ts
+function countActiveFilters(filter, parityEnabled) {
+  return [
+    filter.status !== "all",
+    filter.workflowKey !== "",
+    filter.dateRange.preset !== "all",
+    filter.search !== "",
+    filter.triggerType !== "all",
+    filter.durationMinSeconds !== null,
+    filter.durationMaxSeconds !== null,
+    filter.errorType !== "all",
+    filter.nodeId !== "",
+    filter.tagId !== "",
+    parityEnabled && filter.workflowId.trim() !== ""
+  ].filter(Boolean).length;
+}
 function TagFilterSelect({
   value,
   onChange,
@@ -504,18 +529,8 @@ function ExecutionFilters({
     },
     [setDateRange]
   );
-  const activeFiltersCount = [
-    filter.status !== "all",
-    filter.workflowKey !== "",
-    filter.dateRange.preset !== "all",
-    filter.search !== "",
-    filter.triggerType !== "all",
-    filter.durationMinSeconds !== null,
-    filter.durationMaxSeconds !== null,
-    filter.errorType !== "all",
-    filter.nodeId !== "",
-    filter.tagId !== ""
-  ].filter(Boolean).length;
+  const parityEnabled = useDurableParityEnabled();
+  const activeFiltersCount = countActiveFilters(filter, parityEnabled);
   const assistantControls = useMemo(
     () => executionsControls({
       page: tr("fluidgrids.executions.executionsList.title", "Executions"),
@@ -2721,5 +2736,147 @@ function Pagination({
     ] })
   ] });
 }
+var RUN_PENDING_POLL_INTERVAL_MS = 5e3;
+async function fetchDurableParityRunFields(runId) {
+  const result = await getFluidGridsClient().query({
+    query: DurableParityRunFieldsDocument,
+    variables: { id: runId },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRun ?? null;
+}
+async function fetchRunPending(runId) {
+  const result = await getFluidGridsClient().query({
+    query: WorkflowRunPendingDocument,
+    variables: { id: runId },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRun?.pending ?? null;
+}
+async function fetchRunMetadata(runId) {
+  const result = await getFluidGridsClient().query({
+    query: WorkflowRunMetadataDocument,
+    variables: { runId },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  return result.data?.workflowRunStackTrace ?? null;
+}
+async function fetchRunStatusCounts(input) {
+  const filter = statusCountFilter(input);
+  const result = await getFluidGridsClient().query({
+    query: WorkflowRunsCountDocument,
+    variables: { filter, groupBy: [...STATUS_COUNT_GROUP_BY] },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  const count = result.data?.workflowRunsCount;
+  if (!count) throw new Error("The run count returned no result");
+  return { total: count.total, counts: statusCountsOf(count.groups) };
+}
+async function setRunVersioningOverride(input) {
+  const reason = input.reason?.trim();
+  const result = await getFluidGridsClient().mutate({
+    mutation: SetWorkflowRunVersioningOverrideDocument,
+    variables: {
+      runId: input.runId,
+      override: input.override,
+      reason: reason || null
+    }
+  });
+  throwIfResultError(result);
+  const data = result.data?.setWorkflowRunVersioningOverride;
+  if (!data) throw new Error("The override returned no result");
+  return data.versioning ?? null;
+}
+function useRunRead(runId, enabled, load, { live = false, intervalMs = 0 }) {
+  const [data, setData] = 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 load(runId);
+      if (id !== request.current) return;
+      setData(next);
+      setError(null);
+    } catch (err) {
+      if (id !== request.current) return;
+      setError(describeOperationError(err));
+    } finally {
+      if (id === request.current) setLoading(false);
+    }
+  }, [runId, enabled, load]);
+  useEffect(() => {
+    request.current += 1;
+    setData(null);
+    setError(null);
+    setLoading(false);
+    void refetch();
+  }, [refetch]);
+  useEffect(() => {
+    if (!live || !enabled || !runId || intervalMs <= 0) return;
+    const timer = setInterval(() => {
+      void refetch();
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [live, enabled, runId, intervalMs, refetch]);
+  return { data: enabled ? data : null, loading, error, refetch };
+}
+function useDurableParityRunFields(runId, enabled) {
+  const { data, error, refetch } = useRunRead(
+    runId,
+    enabled,
+    fetchDurableParityRunFields,
+    {}
+  );
+  return { fields: data, error, refetch };
+}
+function useRunPending(runId, { enabled, live }) {
+  const { data, loading, error, refetch } = useRunRead(
+    runId,
+    enabled,
+    fetchRunPending,
+    { live, intervalMs: RUN_PENDING_POLL_INTERVAL_MS }
+  );
+  return { pending: data, loading, error, refetch };
+}
+function useRunMetadata(runId, enabled) {
+  const { data, loading, error, refetch } = useRunRead(
+    runId,
+    enabled,
+    fetchRunMetadata,
+    {}
+  );
+  return { answer: data, loading, error, refetch };
+}
+function useRunStatusCounts(input, enabled) {
+  const [state, setState] = useState({ total: null, counts: [] });
+  const [error, setError] = useState(null);
+  const request = useRef(0);
+  const filterKey = JSON.stringify(statusCountFilter(input));
+  const refetch = useCallback(async () => {
+    if (!enabled) return;
+    const id = ++request.current;
+    try {
+      const next = await fetchRunStatusCounts(JSON.parse(filterKey));
+      if (id !== request.current) return;
+      setState(next);
+      setError(null);
+    } catch (err) {
+      if (id !== request.current) return;
+      setError(describeOperationError(err));
+    }
+  }, [enabled, filterKey]);
+  useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return enabled ? { ...state, error, refetch } : { total: null, counts: [], error: null, refetch };
+}
 
-export { ExecutionCards, ExecutionFilters, ExecutionStats, ExecutionStatusBadge, ExecutionTable, ExecutionTimeline, NodeTimeline, Pagination, RunLogViewer, TagFilterSelect, buildNodeDisplayMap, formatRunVersion };
+export { ExecutionCards, ExecutionFilters, ExecutionStats, ExecutionStatusBadge, ExecutionTable, ExecutionTimeline, NodeTimeline, Pagination, RunLogViewer, TagFilterSelect, buildNodeDisplayMap, formatRunVersion, runStatusLabels, setRunVersioningOverride, useDurableParityRunFields, useRunMetadata, useRunPending, useRunStatusCounts };

package/dist/{chunk-MDPBO52Q.js → chunk-V5PA5KGV.js}

@@ -1,5 +1,5 @@
-import { throwIfResultError } from './chunk-4TGUNOQQ.js';
-import { RunFailureClustersDocument, DismissRunFailureClusterDocument, RunFailureTriageSettingsDocument, SetRunFailureTriageEnabledDocument, FgTriageFailedRunsDocument } from './chunk-7PP6CRXS.js';
+import { throwIfResultError } from './chunk-NAYPOEYM.js';
+import { RunFailureClustersDocument, DismissRunFailureClusterDocument, RunFailureTriageSettingsDocument, SetRunFailureTriageEnabledDocument, FgTriageFailedRunsDocument } from './chunk-GQTEHWWY.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useCallback, useEffect } from 'react';

package/dist/{chunk-MQI7NH4Z.js → chunk-VEZ7G2FE.js}

@@ -1,16 +1,135 @@
-import { ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination } from './chunk-4XAPSIHY.js';
-import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh } from './chunk-57RS7DXZ.js';
-import { useWorkflowDefinitions } from './chunk-LTVAUZ3M.js';
+import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-UWNCFMHV.js';
+import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, WORKFLOW_ID_MAX_LENGTH } from './chunk-HWEKWYXQ.js';
+import { useWorkflowDefinitions } from './chunk-G3KZOX52.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useExecutionsStore } from './chunk-CY6KX4RG.js';
+import { useDurableParityEnabled } from './chunk-NAYPOEYM.js';
+import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { useRef, useCallback, useMemo } from 'react';
+import { useRef, useCallback, useMemo, useState, useEffect } from 'react';
 import { useNavigate, useSearchParams } from 'react-router';
 import { Icon } from '@iconify/react';
 import { toast } from 'sonner';
 import { Button } from '@burdenoff/fe-libs/button';
-import { jsxs, jsx } from 'react/jsx-runtime';
+import { Input } from '@burdenoff/fe-libs/ui';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
+var WORKFLOW_ID_FILTER_DEBOUNCE_MS = 350;
+var RUN_STATUSES = [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED"
+];
+function isRunStatus(value) {
+  return RUN_STATUSES.includes(value);
+}
+function RunsParityBar({
+  workflowId,
+  onWorkflowIdChange,
+  total,
+  counts,
+  countsError,
+  selectedStatus,
+  onSelectStatus
+}) {
+  const tr = useTr();
+  const statusLabels = runStatusLabels(tr);
+  const [draft, setDraft] = useState(workflowId);
+  useEffect(() => {
+    setDraft(workflowId);
+  }, [workflowId]);
+  useEffect(() => {
+    if (draft === workflowId) return;
+    const timer = setTimeout(
+      () => onWorkflowIdChange(draft),
+      WORKFLOW_ID_FILTER_DEBOUNCE_MS
+    );
+    return () => clearTimeout(timer);
+  }, [draft, workflowId, onWorkflowIdChange]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": "runs-parity-bar",
+      className: "mb-6 flex flex-col gap-3 lg:flex-row lg:items-center",
+      children: [
+        /* @__PURE__ */ jsxs("label", { className: "flex min-w-0 items-center gap-2 text-sm text-text-secondary lg:w-80", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:key-outline", width: 16, className: "shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "sr-only", children: tr("fluidgrids.executions.parity.workflowIdFilter", "Workflow ID") }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: draft,
+              maxLength: WORKFLOW_ID_MAX_LENGTH,
+              placeholder: tr(
+                "fluidgrids.executions.parity.workflowIdPlaceholder",
+                "Filter by workflow ID"
+              ),
+              onChange: (event) => setDraft(event.target.value),
+              "data-testid": "runs-workflow-id-filter"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "flex flex-wrap items-center gap-2",
+            "data-testid": "runs-status-counts",
+            children: countsError ? /* @__PURE__ */ jsxs("span", { className: "text-xs text-[var(--color-status-error-text)]", children: [
+              tr(
+                "fluidgrids.executions.parity.countsError",
+                "Could not count the runs:"
+              ),
+              " ",
+              countsError
+            ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              total !== null && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => onSelectStatus("all"),
+                  className: cn(
+                    "rounded-full border px-2.5 py-1 text-xs",
+                    selectedStatus === "all" ? "border-action-primary-bg bg-action-primary-bg text-action-primary-text" : "border-border-secondary text-text-secondary hover:text-text-primary"
+                  ),
+                  "aria-pressed": selectedStatus === "all",
+                  "data-testid": "runs-count-all",
+                  children: tr("fluidgrids.executions.parity.countAll", "All {{count}}", {
+                    count: total
+                  })
+                }
+              ),
+              counts.map(
+                ({ status, count }) => isRunStatus(status) ? /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => onSelectStatus(status),
+                    className: cn(
+                      "rounded-full border px-2.5 py-1 text-xs",
+                      selectedStatus === status ? "border-action-primary-bg bg-action-primary-bg text-action-primary-text" : "border-border-secondary text-text-secondary hover:text-text-primary"
+                    ),
+                    "aria-pressed": selectedStatus === status,
+                    "data-testid": `runs-count-${status}`,
+                    children: tr(
+                      "fluidgrids.executions.parity.countStatus",
+                      "{{status}} {{count}}",
+                      { status: statusLabels[status], count }
+                    )
+                  },
+                  status
+                ) : null
+              )
+            ] })
+          }
+        )
+      ]
+    }
+  );
+}
 function ExecutionsListPage() {
   const tr = useTr();
   const navigate = useNavigate();
@@ -22,6 +141,8 @@ function ExecutionsListPage() {
     clearSelection,
     setStatusFilter,
     setWorkflowFilter,
+    setWorkflowIdFilter,
+    filter,
     autoRefresh,
     autoRefreshInterval
   } = useExecutionsStore();
@@ -34,7 +155,10 @@ function ExecutionsListPage() {
       setWorkflowFilter(workflowKeyParam);
     }
   }
-  const { executions, total, loading, error, refetch } = useExecutionsWithStore();
+  const parityEnabled = useDurableParityEnabled();
+  const { executions, total, loading, error, refetch, input } = useExecutionsWithStore({ durableParity: parityEnabled });
+  const statusCounts = useRunStatusCounts(input, parityEnabled);
+  const refetchCounts = statusCounts.refetch;
   const {
     stats,
     loading: statsLoading,
@@ -52,7 +176,8 @@ function ExecutionsListPage() {
     useCallback(() => {
       refetch();
       refetchStats();
-    }, [refetch, refetchStats]),
+      void refetchCounts();
+    }, [refetch, refetchStats, refetchCounts]),
     autoRefresh,
     autoRefreshInterval
   );
@@ -246,6 +371,18 @@ function ExecutionsListPage() {
       }
     ) }),
     /* @__PURE__ */ jsx("div", { className: "mb-6", "data-tour": "fluidgrids-runs-filters", children: /* @__PURE__ */ jsx(ExecutionFilters, { workflows: workflowOptions, onRefresh: refetch }) }),
+    parityEnabled && /* @__PURE__ */ jsx(
+      RunsParityBar,
+      {
+        workflowId: filter.workflowId,
+        onWorkflowIdChange: setWorkflowIdFilter,
+        total: statusCounts.total,
+        counts: statusCounts.counts,
+        countsError: statusCounts.error,
+        selectedStatus: filter.status,
+        onSelectStatus: handleFilterByStatus
+      }
+    ),
     selection.runIds.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mb-4 p-3 bg-action-primary-bg/10 rounded-lg flex flex-wrap items-center gap-3", children: [
       /* @__PURE__ */ jsxs("span", { className: "text-sm text-text-primary", children: [
         selection.runIds.length,

package/dist/{chunk-YHTRCQ5M.js → chunk-WEXO3KAY.js}

@@ -1,10 +1,10 @@
-import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard } from './chunk-Z6EWB5ZG.js';
-import { QuotaExhaustedDialog } from './chunk-7SSZUX6E.js';
-import { useWorkflowDefinitions, useDuplicateWorkflow } from './chunk-LTVAUZ3M.js';
+import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard } from './chunk-X2J4ZXKD.js';
+import { QuotaExhaustedDialog } from './chunk-S4JYBJ4X.js';
 import { templatesControls } from './chunk-D3UWK7GY.js';
+import { useWorkflowDefinitions, useDuplicateWorkflow } from './chunk-G3KZOX52.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-4TGUNOQQ.js';
+import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-NAYPOEYM.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useEffect, useMemo, useCallback } from 'react';
 import { useParams, useNavigate } from 'react-router';

package/dist/{chunk-7LFAWWVF.js → chunk-WTP343PG.js}

@@ -1,8 +1,8 @@
-import { useWorkflowDefinitions } from './chunk-LTVAUZ3M.js';
 import { historyControls } from './chunk-D3UWK7GY.js';
+import { useWorkflowDefinitions } from './chunk-G3KZOX52.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
+import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useMemo, useCallback } from 'react';
 import { useNavigate } from 'react-router';