@burdenoff/fluidgrids-fe-sdk 2026.1029.6 → 2026.1029.8

package/dist/{chunk-6XZCYLAQ.js → chunk-XJBCRDWZ.js}

@@ -1,8 +1,8 @@
-import { Card, FluidGridsMark } from './chunk-Z6EWB5ZG.js';
+import { Card, FluidGridsMark } from './chunk-X2J4ZXKD.js';
 import { Input } from './chunk-IEVSFCFS.js';
 import { Button } from './chunk-BQXVT32O.js';
-import { useWorkflowDefinition } from './chunk-LTVAUZ3M.js';
-import { FluidGridsProvider, useFlowStore } from './chunk-4TGUNOQQ.js';
+import { useWorkflowDefinition } from './chunk-G3KZOX52.js';
+import { FluidGridsProvider, useFlowStore } from './chunk-NAYPOEYM.js';
 import { cn } from './chunk-JL7CASN5.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useRef, useEffect, useCallback } from 'react';

package/dist/{chunk-AVMI3XLM.js → chunk-XMKYZP6Q.js}

@@ -1,11 +1,11 @@
-import { ActionPoliciesTab } from './chunk-H364USFF.js';
-import { LogStreamingTab } from './chunk-YSUSSIWU.js';
-import { AgentsTab } from './chunk-QZM6EDGK.js';
+import { ActionPoliciesTab } from './chunk-UIDJT3YK.js';
+import { LogStreamingTab } from './chunk-R7VHURPQ.js';
+import { AgentsTab } from './chunk-NUBPALBK.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, throwIfResultError, describeOperationError, useConnections } from './chunk-4TGUNOQQ.js';
+import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, findSaveConflict, useDurableParityEnabled, throwIfResultError, describeOperationError, useConnections } from './chunk-NAYPOEYM.js';
 import { getGlobalStoreClient } from './chunk-PXIFUMLA.js';
-import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
-import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery } from './chunk-7PP6CRXS.js';
+import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
+import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery, DurableHistoryCapsDocument, UpdateDurableHistoryCapsDocument } from './chunk-GQTEHWWY.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useMemo, useEffect, useCallback } from 'react';
@@ -14,7 +14,7 @@ import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
 import { Tabs, TabsList, TabsTrigger, TabsContent, Input, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Label, Card, CardHeader, Badge, Checkbox, TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@burdenoff/fe-libs/ui';
 import { toast } from 'sonner';
-import { jsxs, jsx } from 'react/jsx-runtime';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { gql } from '@apollo/client';
 import { resolveExternalGatewayUrls } from '@burdenoff/fe-libs/shared/config';
 import { cn } from '@burdenoff/fe-libs/utils';
@@ -135,9 +135,255 @@ function parseBoundedInt(value, range) {
   if (!Number.isFinite(parsed)) return void 0;
   return Math.min(range.max, Math.max(range.min, Math.trunc(parsed)));
 }
+async function fetchDurableHistoryCaps() {
+  const result = await getFluidGridsClient().query({ query: DurableHistoryCapsDocument, fetchPolicy: "network-only" });
+  throwIfResultError(result);
+  const settings = result.data?.workflowExecutionSettings;
+  return {
+    maxHistoryEvents: settings?.maxHistoryEvents ?? null,
+    maxHistoryBytes: settings?.maxHistoryBytes ?? null
+  };
+}
+async function saveDurableHistoryCaps(caps) {
+  const variables = {};
+  if (caps.maxHistoryEvents !== void 0)
+    variables.maxHistoryEvents = caps.maxHistoryEvents;
+  if (caps.maxHistoryBytes !== void 0)
+    variables.maxHistoryBytes = caps.maxHistoryBytes;
+  const result = await getFluidGridsClient().mutate({ mutation: UpdateDurableHistoryCapsDocument, variables });
+  throwIfResultError(result);
+  const saved = result.data?.updateWorkflowExecutionSettings;
+  if (!saved) throw new Error("No settings returned");
+  return {
+    maxHistoryEvents: saved.maxHistoryEvents ?? null,
+    maxHistoryBytes: saved.maxHistoryBytes ?? null
+  };
+}
+function useDurableHistoryCaps(enabled) {
+  const [caps, setCaps] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    fetchDurableHistoryCaps().then((next) => {
+      if (cancelled) return;
+      setCaps(next);
+      setError(null);
+    }).catch((err) => {
+      if (!cancelled) setError(describeOperationError(err));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled]);
+  const save = useCallback(async (next) => {
+    const saved = await saveDurableHistoryCaps(next);
+    setCaps(saved);
+    return saved;
+  }, []);
+  return { caps: caps , error: error , save };
+}
+
+// src/modules/settings/utils/history-caps.ts
+var HISTORY_EVENTS_RANGE = { min: 1e3, max: 5e4 };
+var HISTORY_MIB_RANGE = { min: 1, max: 50 };
+var MIB = 1024 * 1024;
+function parseCap(raw, range) {
+  const value = raw.trim();
+  if (!value) return { ok: true, value: null };
+  if (!/^\d+$/.test(value)) return { ok: false, ...range };
+  const parsed = Number(value);
+  if (parsed < range.min || parsed > range.max) return { ok: false, ...range };
+  return { ok: true, value: parsed };
+}
+function bytesToMibText(bytes) {
+  if (bytes === null || bytes === void 0 || !Number.isFinite(bytes))
+    return "";
+  return String(Number((bytes / MIB).toFixed(2)));
+}
+function historyCapChanges(loaded, eventsText, mibText) {
+  const changes = {};
+  const loadedEvents = loaded.maxHistoryEvents === null ? "" : String(loaded.maxHistoryEvents);
+  if (eventsText.trim() !== loadedEvents) {
+    const parsed = parseCap(eventsText, HISTORY_EVENTS_RANGE);
+    if (!parsed.ok) return { ok: false };
+    changes.maxHistoryEvents = parsed.value;
+  }
+  if (mibText.trim() !== bytesToMibText(loaded.maxHistoryBytes)) {
+    const parsed = parseCap(mibText, HISTORY_MIB_RANGE);
+    if (!parsed.ok) return { ok: false };
+    changes.maxHistoryBytes = parsed.value === null ? null : parsed.value * MIB;
+  }
+  return { ok: true, changes };
+}
+function DurableHistoryCapsCard({ canEdit }) {
+  const tr = useTr();
+  const { caps, error, save } = useDurableHistoryCaps(true);
+  const [events, setEvents] = useState("");
+  const [mib, setMib] = useState("");
+  const [saving, setSaving] = useState(false);
+  const locked = !caps || saving || !canEdit;
+  useEffect(() => {
+    if (!caps) return;
+    setEvents(
+      caps.maxHistoryEvents === null ? "" : String(caps.maxHistoryEvents)
+    );
+    setMib(bytesToMibText(caps.maxHistoryBytes));
+  }, [caps]);
+  const handleSave = async () => {
+    if (!caps) return;
+    const parsed = historyCapChanges(caps, events, mib);
+    if (!parsed.ok) {
+      toast.error(
+        tr(
+          "fluidgrids.settings.historyCaps.invalid",
+          "Enter {{eventsMin}} to {{eventsMax}} events and {{mibMin}} to {{mibMax}} MiB, or leave a field empty for the plan ceiling.",
+          {
+            eventsMin: HISTORY_EVENTS_RANGE.min,
+            eventsMax: HISTORY_EVENTS_RANGE.max,
+            mibMin: HISTORY_MIB_RANGE.min,
+            mibMax: HISTORY_MIB_RANGE.max
+          }
+        )
+      );
+      return;
+    }
+    setSaving(true);
+    try {
+      await save(parsed.changes);
+      toast.success(
+        tr("fluidgrids.settings.historyCaps.saved", "History caps saved")
+      );
+    } catch (err) {
+      toast.error(
+        tr(
+          "fluidgrids.settings.runData.saveFailedToast",
+          "Failed to save settings"
+        ),
+        { description: describeOperationError(err) }
+      );
+    } finally {
+      setSaving(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "data-testid": "durable-history-caps",
+      className: "mt-8 border-t border-border-secondary pt-6",
+      children: [
+        /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr(
+          "fluidgrids.settings.historyCaps.title",
+          "Durable-function history caps"
+        ) }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-text-secondary", children: tr(
+          "fluidgrids.settings.historyCaps.intro",
+          "The most events and inline bytes a new durable-function run may record. Leave a field empty to use your plan's ceiling. Runs keep the caps they started with."
+        ) }),
+        error ? /* @__PURE__ */ jsxs("p", { className: "mt-3 text-sm text-status-error-text", role: "alert", children: [
+          tr(
+            "fluidgrids.settings.historyCaps.loadFailed",
+            "Could not load the history caps:"
+          ),
+          " ",
+          error
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsxs("div", { className: "divide-y divide-border-secondary", children: [
+            /* @__PURE__ */ jsx(
+              SettingRow,
+              {
+                label: tr(
+                  "fluidgrids.settings.historyCaps.eventsLabel",
+                  "Events per run"
+                ),
+                description: tr(
+                  "fluidgrids.settings.historyCaps.eventsDescription",
+                  "{{min}} to {{max}}; the run is told to continue as new at 80%.",
+                  {
+                    min: HISTORY_EVENTS_RANGE.min,
+                    max: HISTORY_EVENTS_RANGE.max
+                  }
+                ),
+                children: /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    type: "number",
+                    min: HISTORY_EVENTS_RANGE.min,
+                    max: HISTORY_EVENTS_RANGE.max,
+                    value: events,
+                    placeholder: tr(
+                      "fluidgrids.settings.historyCaps.planCeiling",
+                      "Plan ceiling"
+                    ),
+                    "aria-label": tr(
+                      "fluidgrids.settings.historyCaps.eventsLabel",
+                      "Events per run"
+                    ),
+                    onChange: (e) => setEvents(e.target.value),
+                    disabled: locked,
+                    className: "w-[140px] text-right",
+                    "data-testid": "history-caps-events"
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              SettingRow,
+              {
+                label: tr(
+                  "fluidgrids.settings.historyCaps.bytesLabel",
+                  "Inline history size"
+                ),
+                description: tr(
+                  "fluidgrids.settings.historyCaps.bytesDescription",
+                  "{{min}} to {{max}} MiB of event payloads kept inline.",
+                  { min: HISTORY_MIB_RANGE.min, max: HISTORY_MIB_RANGE.max }
+                ),
+                children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx(
+                    Input,
+                    {
+                      type: "number",
+                      min: HISTORY_MIB_RANGE.min,
+                      max: HISTORY_MIB_RANGE.max,
+                      value: mib,
+                      placeholder: tr(
+                        "fluidgrids.settings.historyCaps.planCeiling",
+                        "Plan ceiling"
+                      ),
+                      "aria-label": tr(
+                        "fluidgrids.settings.historyCaps.bytesLabel",
+                        "Inline history size"
+                      ),
+                      onChange: (e) => setMib(e.target.value),
+                      disabled: locked,
+                      className: "w-[100px] text-right",
+                      "data-testid": "history-caps-mib"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: "MiB" })
+                ] })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "mt-4 flex justify-end", children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              "data-agent": "confirm",
+              onClick: () => void handleSave(),
+              disabled: locked,
+              "data-testid": "history-caps-save",
+              children: saving ? tr("fluidgrids.settings.runData.saving", "Saving\u2026") : tr("fluidgrids.settings.historyCaps.save", "Save caps")
+            }
+          ) })
+        ] })
+      ]
+    }
+  );
+}
 function RunDataTab() {
   const tr = useTr();
   const { settings, loading, error, save } = useRunDataSettings();
+  const parityEnabled = useDurableParityEnabled();
   const [form, setForm] = useState(null);
   const [saving, setSaving] = useState(false);
   const { allowed: canEdit } = useFluidGridsPermission(
@@ -375,7 +621,8 @@ function RunDataTab() {
         disabled: locked,
         children: saving ? tr("fluidgrids.settings.runData.saving", "Saving\u2026") : tr("fluidgrids.settings.runData.save", "Save")
       }
-    ) })
+    ) }),
+    parityEnabled && /* @__PURE__ */ jsx(DurableHistoryCapsCard, { canEdit })
   ] });
 }
 
@@ -1907,17 +2154,34 @@ function ExecutionTab({ workflowKey }) {
   );
   const handleSave = useCallback(async () => {
     if (!workflow?.id) return;
-    try {
-      const definitionJson = {
-        ...workflow.definitionJson,
-        config: mergeWorkflowExecutionSettings(
-          workflow.definitionJson.config ?? {},
-          form
-        )
-      };
-      await updateWorkflowDefinition({
-        variables: { id: workflow.id, input: { definitionJson } }
+    const save = (stored) => {
+      const definition = stored.definitionJson;
+      return updateWorkflowDefinition({
+        variables: {
+          id: stored.id,
+          input: {
+            definitionJson: {
+              ...definition,
+              config: mergeWorkflowExecutionSettings(
+                definition.config ?? {},
+                form
+              )
+            },
+            // BOFF-9725: never write back a canvas someone changed meanwhile.
+            ...typeof stored.revision === "number" ? { expectedRevision: stored.revision } : {}
+          }
+        }
       });
+    };
+    try {
+      try {
+        await save(workflow);
+      } catch (err) {
+        if (!findSaveConflict(err)) throw err;
+        const latest = (await refetch()).data?.workflowDefinition;
+        if (!latest?.id) throw err;
+        await save(latest);
+      }
       toast.success(
         tr(
           "fluidgrids.settings.execution.savedToast",

package/dist/{chunk-5GD6OXYW.js → chunk-Z6I6A47T.js}

@@ -1,4 +1,4 @@
-import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-7PP6CRXS.js';
+import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-GQTEHWWY.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useCallback, useEffect } from 'react';
 

package/dist/{config-T7BQ7AO2.js → config-VM7FTHMZ.js}

@@ -1,2 +1,2 @@
-export { config, getFluidGridsConfig, getGraphQLEndpoint, resetFluidGridsConfig, resetFluidGridsExecutionState, setFluidGridsConfig, validateTrustedOrigin } from './chunk-CY6KX4RG.js';
+export { config, getFluidGridsConfig, getGraphQLEndpoint, resetFluidGridsConfig, resetFluidGridsExecutionState, setFluidGridsConfig, validateTrustedOrigin } from './chunk-6AMNEX2Y.js';
 import './chunk-62GWEYJ5.js';

package/dist/executions.js

@@ -1,25 +1,25 @@
 import './chunk-AD3BXTJS.js';
-export { ExecutionsListPage } from './chunk-MQI7NH4Z.js';
-export { ExecutionDetailPage } from './chunk-63ZMEHZ4.js';
-import './chunk-4XAPSIHY.js';
-import './chunk-57RS7DXZ.js';
-import './chunk-MDPBO52Q.js';
-import './chunk-H364USFF.js';
+export { ExecutionsListPage } from './chunk-VEZ7G2FE.js';
+export { ExecutionDetailPage } from './chunk-TJ6RUV4R.js';
+import './chunk-UWNCFMHV.js';
+import './chunk-HWEKWYXQ.js';
+import './chunk-V5PA5KGV.js';
+import './chunk-UIDJT3YK.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-WTGBHE3J.js';
-import './chunk-5GD6OXYW.js';
+import './chunk-T22LICGX.js';
+import './chunk-Z6I6A47T.js';
 import './chunk-Y53CVZVV.js';
-import './chunk-LTVAUZ3M.js';
 import './chunk-D3UWK7GY.js';
+import './chunk-G3KZOX52.js';
 import './chunk-PJAWNFJV.js';
-import './chunk-U6KI4AKI.js';
+import './chunk-6TMLIQHB.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-4TGUNOQQ.js';
+import './chunk-NAYPOEYM.js';
 import './chunk-JL7CASN5.js';
 import './chunk-PXIFUMLA.js';
-import './chunk-CY6KX4RG.js';
+import './chunk-6AMNEX2Y.js';
 import './chunk-JUUYPCFY.js';
-import './chunk-7PP6CRXS.js';
+import './chunk-GQTEHWWY.js';
 import './chunk-UULVIT25.js';
 import './chunk-NTWG3CJX.js';
 import './chunk-62GWEYJ5.js';

package/dist/history.js

@@ -1,14 +1,14 @@
-export { HistoryPage } from './chunk-7LFAWWVF.js';
-import './chunk-LTVAUZ3M.js';
+export { HistoryPage } from './chunk-WTP343PG.js';
 import './chunk-D3UWK7GY.js';
+import './chunk-G3KZOX52.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-4TGUNOQQ.js';
+import './chunk-NAYPOEYM.js';
 import './chunk-JL7CASN5.js';
 import './chunk-PXIFUMLA.js';
-import './chunk-CY6KX4RG.js';
+import './chunk-6AMNEX2Y.js';
 import './chunk-JUUYPCFY.js';
-import './chunk-7PP6CRXS.js';
+import './chunk-GQTEHWWY.js';
 import './chunk-UULVIT25.js';
 import './chunk-NTWG3CJX.js';
 import './chunk-62GWEYJ5.js';