@burdenoff/fluidgrids-fe-sdk 2026.1029.5 → 2026.1029.7

package/dist/{chunk-EAJB5BNF.js → chunk-7CTIVBBA.js}

@@ -1,9 +1,12 @@
-import { validateDateRange } from './chunk-UZMLMPFJ.js';
-import { useAvailableTags } from './chunk-5GD6OXYW.js';
+import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-AXMEATLG.js';
+import { useAvailableTags } from './chunk-LAVHDFHI.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-K4BF7PAW.js';
+import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
+import { SetWorkflowRunVersioningOverrideDocument, WorkflowRunsCountDocument, DurableParityRunFieldsDocument, WorkflowRunPendingDocument, WorkflowRunMetadataDocument } from './chunk-YTUIGIVP.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-UZMLMPFJ.js → chunk-AXMEATLG.js}

@@ -1,7 +1,7 @@
 import { REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS } from './chunk-5ERAJC2I.js';
-import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-2U56452G.js';
-import { useExecutionsStore } from './chunk-CY6KX4RG.js';
-import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-7PP6CRXS.js';
+import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-K4BF7PAW.js';
+import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
+import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-YTUIGIVP.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
@@ -75,6 +75,107 @@ function dateRangeToInput(start, end) {
   return input;
 }
 
+// src/modules/executions/utils/run-parity.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function runChainLinks(run) {
+  const candidates = [
+    ["previous", run.continuedFromRunId],
+    ["next", run.continuedToRunId],
+    ["first", run.firstRunId],
+    ["root", run.rootRunId === run.parentRunId ? null : run.rootRunId]
+  ];
+  const seen = /* @__PURE__ */ new Set([run.id]);
+  const links = [];
+  for (const [kind, runId] of candidates) {
+    if (!runId || seen.has(runId)) continue;
+    seen.add(runId);
+    links.push({ kind, runId });
+  }
+  return links;
+}
+function shortRunId(runId, length = 12) {
+  return runId.length > length ? `${runId.slice(0, length)}\u2026` : runId;
+}
+function handlersOf(value) {
+  const entries = Array.isArray(value) ? value.map((entry) => [void 0, entry]) : isRecord(value) ? Object.entries(value) : [];
+  const handlers = [];
+  for (const [key, entry] of entries) {
+    if (typeof entry === "string") {
+      handlers.push({ name: entry });
+      continue;
+    }
+    if (!isRecord(entry)) continue;
+    const name = text(entry.name) ?? key;
+    if (!name) continue;
+    const description = text(entry.description);
+    handlers.push(description ? { name, description } : { name });
+  }
+  return handlers;
+}
+function parseMetadataDefinition(definition) {
+  const value = isRecord(definition) ? definition : {};
+  return {
+    name: text(value.name),
+    signals: handlersOf(value.signals),
+    queries: handlersOf(value.queries),
+    updates: handlersOf(value.updates)
+  };
+}
+var WORKFLOW_ID_MAX_LENGTH = 256;
+function withWorkflowIdFilter(input, workflowId, parityEnabled) {
+  const value = workflowId.trim();
+  if (!parityEnabled || !value) return input;
+  return { ...input, businessId: value.slice(0, WORKFLOW_ID_MAX_LENGTH) };
+}
+function statusCountFilter(input) {
+  const rest = { ...input };
+  delete rest.limit;
+  delete rest.offset;
+  delete rest.status;
+  return rest;
+}
+var STATUS_COUNT_GROUP_BY = ["STATUS" /* Status */];
+function statusCountsOf(groups) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const status = group.values[0] ?? group.key;
+    if (!status) continue;
+    counts.set(status, (counts.get(status) ?? 0) + group.count);
+  }
+  return [...counts.entries()].map(([status, count]) => ({ status, count })).sort((a, b) => b.count - a.count || a.status.localeCompare(b.status));
+}
+function overrideRequestOf(choice, version) {
+  if (choice === "remove") return { ok: true, override: null };
+  if (choice === "autoUpgrade")
+    return {
+      ok: true,
+      override: { behavior: "AUTO_UPGRADE" /* AutoUpgrade */ }
+    };
+  const pinned = version.trim();
+  if (!pinned) return { ok: false, reason: "versionRequired" };
+  return {
+    ok: true,
+    override: { behavior: "PINNED" /* Pinned */, version: pinned }
+  };
+}
+function callbackTone(status) {
+  switch (status) {
+    case "DELIVERED":
+      return "success";
+    case "FAILED":
+      return "error";
+    case "DELIVERING":
+      return "info";
+    default:
+      return "neutral";
+  }
+}
+
 // src/modules/executions/utils/retry.ts
 var NON_REPLAYABLE_CONTEXT_KEYS = ["isScheduled", "workspaceId"];
 function buildRetryTriggerInput(run) {
@@ -443,7 +544,9 @@ function useExecutionActions() {
   };
 }
 var EXECUTIONS_SEARCH_DEBOUNCE_MS = 350;
-function useExecutionsWithStore() {
+function useExecutionsWithStore({
+  durableParity = false
+} = {}) {
   const { filter, pagination, setTotal } = useExecutionsStore();
   const [debouncedSearch, setDebouncedSearch] = useState(filter.search);
   useEffect(() => {
@@ -490,15 +593,21 @@ function useExecutionsWithStore() {
     if (filter.tagId) {
       baseInput.tagIds = [filter.tagId];
     }
-    return baseInput;
-  }, [filter, debouncedSearch, pagination.page, pagination.pageSize]);
+    return withWorkflowIdFilter(baseInput, filter.workflowId, durableParity);
+  }, [
+    filter,
+    debouncedSearch,
+    pagination.page,
+    pagination.pageSize,
+    durableParity
+  ]);
   const result = useExecutions(input);
   useEffect(() => {
     if (result.total !== pagination.total) {
       setTotal(result.total);
     }
   }, [result.total, pagination.total, setTotal]);
-  return result;
+  return { ...result, input };
 }
 function useAutoRefresh(refetchFn, enabled = true, interval = 5e3) {
   useEffect(() => {
@@ -510,4 +619,4 @@ function useAutoRefresh(refetchFn, enabled = true, interval = 5e3) {
   }, [enabled, interval, refetchFn]);
 }
 
-export { useAutoRefresh, useExecution, useExecutionActions, useExecutionStats, useExecutions, useExecutionsWithStore, validateDateRange };
+export { STATUS_COUNT_GROUP_BY, WORKFLOW_ID_MAX_LENGTH, callbackTone, overrideRequestOf, parseMetadataDefinition, runChainLinks, shortRunId, statusCountFilter, statusCountsOf, useAutoRefresh, useExecution, useExecutionActions, useExecutionStats, useExecutions, useExecutionsWithStore, validateDateRange };

package/dist/{chunk-NM5L7MBJ.js → chunk-BZTVAUOQ.js}

@@ -1,6 +1,6 @@
-import { FailureTriagePanel } from './chunk-R4SBXQ2K.js';
-import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-VYH65RLH.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-2U56452G.js';
+import { FailureTriagePanel } from './chunk-ZE5KS2YL.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-US4LPOB3.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-K4BF7PAW.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useMemo, useEffect } from 'react';
 import { Icon } from '@iconify/react';

package/dist/{chunk-X3LQJLV7.js → chunk-DEGCZCHP.js}

@@ -1,5 +1,5 @@
-import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-2U56452G.js';
-import { ExportWorkflowCodeDocument } from './chunk-7PP6CRXS.js';
+import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-K4BF7PAW.js';
+import { ExportWorkflowCodeDocument } from './chunk-YTUIGIVP.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect } from 'react';

package/dist/{chunk-WDTO6ATM.js → chunk-E7UAY3JJ.js}

@@ -1,8 +1,8 @@
-import { useWorkflowDefinitions } from './chunk-SRE2JVSJ.js';
 import { historyControls } from './chunk-D3UWK7GY.js';
+import { useWorkflowDefinitions } from './chunk-OJPJ2QXD.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';