@burdenoff/fluidgrids-fe-sdk 2026.1115.7 → 2026.1115.9

package/dist/ExecutionSettingsFields-DzKJDOjU.js

@@ -0,0 +1,1003 @@
+"use client";
+import { o as throwIfResultError } from "./errors-xPZ-IbQd.js";
+import { n as getFluidGridsClient } from "./client-Ctl4jmY3.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { c as findSaveConflict } from "./workflow-save-state-DUE9lNwQ.js";
+import { At as useUpdateWorkflowDefinitionMutation, Ft as useWorkflowDefinitionQuery, Rt as useWorkflowDefinitionsQuery } from "./operations-qq_bbgXP.js";
+import { s as useFluidGridsPermission, t as FLUIDGRIDS_PERMISSIONS } from "./constants-65QV61nQ.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { gql } from "@apollo/client";
+import { Input, Label, Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@burdenoff/fe-libs/ui";
+
+// src/generated/documents/wspace/UpdateWorkflowNotificationSettingsDocument.ts
+const UpdateWorkflowNotificationSettingsDocument = {
+	"kind": "Document",
+	"definitions": [{
+		"kind": "OperationDefinition",
+		"operation": "mutation",
+		"name": {
+			"kind": "Name",
+			"value": "UpdateWorkflowNotificationSettings"
+		},
+		"variableDefinitions": [{
+			"kind": "VariableDefinition",
+			"variable": {
+				"kind": "Variable",
+				"name": {
+					"kind": "Name",
+					"value": "input"
+				}
+			},
+			"type": {
+				"kind": "NonNullType",
+				"type": {
+					"kind": "NamedType",
+					"name": {
+						"kind": "Name",
+						"value": "UpdateWorkflowNotificationSettingsInput"
+					}
+				}
+			},
+			"directives": []
+		}],
+		"directives": [],
+		"selectionSet": {
+			"kind": "SelectionSet",
+			"selections": [{
+				"kind": "Field",
+				"name": {
+					"kind": "Name",
+					"value": "updateWorkflowNotificationSettings"
+				},
+				"arguments": [{
+					"kind": "Argument",
+					"name": {
+						"kind": "Name",
+						"value": "input"
+					},
+					"value": {
+						"kind": "Variable",
+						"name": {
+							"kind": "Name",
+							"value": "input"
+						}
+					}
+				}],
+				"directives": [],
+				"selectionSet": {
+					"kind": "SelectionSet",
+					"selections": [
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "workflowKey"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnFailure"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnSuccess"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnApprovalRequest"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnTriggerDisabled"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "pushEnabled"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "throttleMinutes"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "customized"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "updatedAt"
+							},
+							"arguments": [],
+							"directives": []
+						}
+					]
+				}
+			}]
+		}
+	}]
+};
+
+// src/generated/documents/wspace/WorkflowNotificationSettingsDocument.ts
+const WorkflowNotificationSettingsDocument = {
+	"kind": "Document",
+	"definitions": [{
+		"kind": "OperationDefinition",
+		"operation": "query",
+		"name": {
+			"kind": "Name",
+			"value": "WorkflowNotificationSettings"
+		},
+		"variableDefinitions": [{
+			"kind": "VariableDefinition",
+			"variable": {
+				"kind": "Variable",
+				"name": {
+					"kind": "Name",
+					"value": "workflowKey"
+				}
+			},
+			"type": {
+				"kind": "NonNullType",
+				"type": {
+					"kind": "NamedType",
+					"name": {
+						"kind": "Name",
+						"value": "String"
+					}
+				}
+			},
+			"directives": []
+		}],
+		"directives": [],
+		"selectionSet": {
+			"kind": "SelectionSet",
+			"selections": [{
+				"kind": "Field",
+				"name": {
+					"kind": "Name",
+					"value": "workflowNotificationSettings"
+				},
+				"arguments": [{
+					"kind": "Argument",
+					"name": {
+						"kind": "Name",
+						"value": "workflowKey"
+					},
+					"value": {
+						"kind": "Variable",
+						"name": {
+							"kind": "Name",
+							"value": "workflowKey"
+						}
+					}
+				}],
+				"directives": [],
+				"selectionSet": {
+					"kind": "SelectionSet",
+					"selections": [
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "workflowKey"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnFailure"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnSuccess"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnApprovalRequest"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "notifyOnTriggerDisabled"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "pushEnabled"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "throttleMinutes"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "customized"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "updatedAt"
+							},
+							"arguments": [],
+							"directives": []
+						}
+					]
+				}
+			}]
+		}
+	}]
+};
+
+// src/modules/settings/hooks/useWorkflowNotificationSettings.ts
+/**
+* A workflow's notification preferences (G08) for Settings → Notifications
+* (BOFF-9974): which events notify the workflow's person in the app's bell
+* and, unless switched off, by push to their devices, and how often.
+*
+* Read with `workflowNotificationSettings` (the defaults when nobody saved
+* any) and saved with `updateWorkflowNotificationSettings`, a partial update.
+*/
+/** The throttle window the service accepts, in minutes (0 sends every one). */
+const NOTIFICATION_THROTTLE_RANGE = {
+	min: 0,
+	max: 1440
+};
+async function fetchWorkflowNotificationSettings(workflowKey) {
+	const result = await getFluidGridsClient().query({
+		query: WorkflowNotificationSettingsDocument,
+		variables: { workflowKey },
+		fetchPolicy: "network-only"
+	});
+	throwIfResultError(result);
+	return result.data?.workflowNotificationSettings ?? null;
+}
+async function saveWorkflowNotificationSettings(workflowKey, changes) {
+	const result = await getFluidGridsClient().mutate({
+		mutation: UpdateWorkflowNotificationSettingsDocument,
+		variables: { input: {
+			workflowKey,
+			...changes
+		} }
+	});
+	throwIfResultError(result);
+	const saved = result.data?.updateWorkflowNotificationSettings;
+	if (!saved) throw new Error("The notification settings were not saved.");
+	return saved;
+}
+function useWorkflowNotificationSettings(workflowKey) {
+	const [loaded, setLoaded] = useState(null);
+	useEffect(() => {
+		if (!workflowKey) return;
+		let cancelled = false;
+		fetchWorkflowNotificationSettings(workflowKey).then((settings) => {
+			if (!cancelled) setLoaded({
+				workflowKey,
+				settings,
+				error: null
+			});
+		}, (err) => {
+			if (!cancelled) setLoaded({
+				workflowKey,
+				settings: null,
+				error: err instanceof Error ? err : new Error(String(err))
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [workflowKey]);
+	const save = useCallback(async (changes) => {
+		if (!workflowKey) throw new Error("No workflow selected.");
+		const saved = await saveWorkflowNotificationSettings(workflowKey, changes);
+		setLoaded({
+			workflowKey,
+			settings: saved,
+			error: null
+		});
+		return saved;
+	}, [workflowKey]);
+	const current = loaded?.workflowKey === workflowKey ? loaded : null;
+	return {
+		settings: current?.settings ?? null,
+		loading: !!workflowKey && current === null,
+		error: current?.error ?? null,
+		save
+	};
+}
+
+// src/modules/settings/utils/error-trigger.ts
+/**
+* Error Workflow setting (BOFF-7514): the chosen workflow starts at its Error
+* Trigger node, so one without that node never starts. Mirrors the backend's
+* `findErrorTriggerNodeId` in wspace-workflow-svc.
+*/
+const ERROR_TRIGGER_NODE_TYPE = "internal:error-trigger";
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/** Reads `data.nodes`, falling back to the legacy top-level `nodes`. */
+function hasErrorTriggerNode(definitionJson) {
+	const definition = asRecord(definitionJson);
+	const dataNodes = asRecord(definition?.data)?.nodes;
+	const nodes = Array.isArray(dataNodes) ? dataNodes : definition?.nodes;
+	return Array.isArray(nodes) && nodes.some((node) => asRecord(node)?.type === "internal:error-trigger");
+}
+
+// src/modules/settings/utils/run-data.ts
+function toSavingChoice(value) {
+	if (value === void 0) return "default";
+	return value ? "save" : "skip";
+}
+function fromSavingChoice(choice) {
+	if (choice === "save") return true;
+	if (choice === "skip") return false;
+}
+/** Limits the backend applies to a workflow's redacted fields (run-data-privacy.ts, BOFF-9752). */
+const MAX_REDACT_FIELDS = 50;
+const MAX_REDACT_FIELD_LENGTH = 200;
+const MAX_REDACT_PATH_SEGMENTS = 16;
+/**
+* Read the "Redacted fields" input: entries separated by commas or new lines, each a field name
+* or a dotted path. Entries the backend would ignore (empty segments, too long, too deep) and
+* repeats are dropped, and the list is capped. An empty list means "none" (undefined).
+*/
+function parseRedactFields(text) {
+	const seen = /* @__PURE__ */ new Set();
+	const fields = [];
+	for (const raw of text.split(/[,\n]/)) {
+		const segments = raw.trim().split(".").map((segment) => segment.trim());
+		const field = segments.join(".");
+		if (field.length === 0 || field.length > MAX_REDACT_FIELD_LENGTH || segments.length > MAX_REDACT_PATH_SEGMENTS || segments.some((segment) => segment.length === 0)) continue;
+		const key = field.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		fields.push(field);
+		if (fields.length >= 50) break;
+	}
+	return fields.length > 0 ? fields : void 0;
+}
+/** Show a saved list in the "Redacted fields" input. */
+function formatRedactFields(fields) {
+	return (fields ?? []).join(", ");
+}
+/**
+* Drop the keys left unset, and the whole object when nothing is set, so a workflow that follows
+* its workspace saves no override at all.
+*/
+function compactOverrides(value) {
+	if (!value) return void 0;
+	const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+/** Bounds the backend accepts (wspace-workflow-svc run-data-lifecycle.service). */
+const RETENTION_DAYS_RANGE = {
+	min: 1,
+	max: 3650
+};
+const RETENTION_MAX_RUNS_RANGE = {
+	min: 1,
+	max: 1e6
+};
+/**
+* An empty input means "no override"; anything else is read whole (so `1e3` is 1000, not 1),
+* truncated to a whole number and clamped to its range.
+*/
+function parseBoundedInt(value, range) {
+	if (value.trim() === "") return void 0;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return void 0;
+	return Math.min(range.max, Math.max(range.min, Math.trunc(parsed)));
+}
+
+// src/modules/settings/utils/workflow-settings-persistence.ts
+/** The nested fields the Settings page edits; any other nested key is kept as saved. */
+const DATA_SAVING_KEYS = [
+	"saveSuccessExecutions",
+	"saveFailedExecutions",
+	"saveManualExecutions"
+];
+const RETENTION_KEYS = ["maxAgeDays", "maxRuns"];
+const DATA_PRIVACY_KEYS = ["doNotStoreRunData", "redactFields"];
+const BUDGET_KEYS = [
+	"maxSteps",
+	"maxWallTimeSec",
+	"maxTokens",
+	"maxCostMicroUsd"
+];
+/**
+* Merge the edited settings into the saved config without mutating it.
+*
+* Keys the form does not know (engine-only flags, fields added later) are kept. For the nested
+* run-data objects the form is authoritative over the fields it edits: a field it leaves unset was
+* cleared to "follow the workspace" (BOFF-7514), so it must not come back from the saved config.
+*/
+function mergeWorkflowExecutionSettings(existing, next) {
+	const merged = {
+		...existing,
+		...next
+	};
+	for (const [key, editable] of [
+		["dataSaving", DATA_SAVING_KEYS],
+		["retention", RETENTION_KEYS],
+		["dataPrivacy", DATA_PRIVACY_KEYS],
+		["budget", BUDGET_KEYS]
+	]) {
+		const nested = mergeNested(existing[key], next[key], editable);
+		if (nested) merged[key] = nested;
+		else delete merged[key];
+	}
+	return merged;
+}
+function mergeNested(existing, next, editable) {
+	const editableKeys = new Set(editable);
+	const kept = Object.fromEntries(Object.entries(isRecord(existing) ? existing : {}).filter(([key]) => !editableKeys.has(key)));
+	const result = Object.fromEntries(Object.entries({
+		...kept,
+		...next ?? {}
+	}).filter(([, value]) => value !== void 0));
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/modules/settings/hooks/useRunDataSettings.ts
+/**
+* The workspace's run-data settings (BOFF-7514): which finished runs keep their data and how long
+* finished runs are kept, for every workflow that does not override them in its own Settings.
+*/
+const FIELDS = `
+  saveSuccessfulRuns
+  saveFailedRuns
+  saveManualRuns
+  retentionDays
+  retentionMaxRunsPerWorkflow
+  customized
+  updatedAt
+`;
+const RUN_DATA_SETTINGS_QUERY = gql`
+  query WorkflowExecutionSettings {
+    workflowExecutionSettings {
+      ${FIELDS}
+    }
+  }
+`;
+const UPDATE_RUN_DATA_SETTINGS = gql`
+  mutation UpdateWorkflowExecutionSettings($input: UpdateWorkflowExecutionSettingsInput!) {
+    updateWorkflowExecutionSettings(input: $input) {
+      ${FIELDS}
+    }
+  }
+`;
+function useRunDataSettings() {
+	const [settings, setSettings] = useState(null);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	useEffect(() => {
+		let cancelled = false;
+		getFluidGridsClient().query({
+			query: RUN_DATA_SETTINGS_QUERY,
+			fetchPolicy: "network-only"
+		}).then((result) => {
+			throwIfResultError(result);
+			if (!cancelled) setSettings(result.data?.workflowExecutionSettings ?? null);
+		}).catch((err) => {
+			if (!cancelled) setError(err instanceof Error ? err : new Error(String(err)));
+		}).finally(() => {
+			if (!cancelled) setLoading(false);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+	return {
+		settings,
+		loading,
+		error,
+		save: useCallback(async (changes) => {
+			const result = await getFluidGridsClient().mutate({
+				mutation: UPDATE_RUN_DATA_SETTINGS,
+				variables: { input: changes }
+			});
+			throwIfResultError(result);
+			const saved = result.data?.updateWorkflowExecutionSettings;
+			if (!saved) throw new Error("No settings returned");
+			setSettings(saved);
+			return saved;
+		}, [])
+	};
+}
+
+// src/modules/settings/hooks/useWorkflowExecutionSettingsForm.ts
+/**
+* One workflow's execution settings as an editable form (BOFF-7512): the
+* values in `definitionJson.config`, the lists the form's pickers need, and a
+* save that never overwrites a canvas someone changed meanwhile.
+*
+* Shared by Settings › Execution and the Navigation v2 settings drawer
+* (BOFF-11843), so both read, check and save exactly the same way.
+*/
+/** What "On workflow error" means when nobody chose (the engine's default). */
+const DEFAULT_ON_ERROR = "stop";
+/**
+* The stored definition with the form's settings applied to its `config`.
+* Only `config` changes; every other part of the definition is sent back as
+* it was read.
+*/
+function definitionWithSettings(definitionJson, form) {
+	const definition = definitionJson ?? {};
+	return {
+		...definition,
+		config: mergeWorkflowExecutionSettings(definition.config ?? {}, form)
+	};
+}
+/** Whether saving `form` would change the stored `config`. */
+function settingsChanged(persisted, form) {
+	const before = mergeWorkflowExecutionSettings(persisted, persisted);
+	const after = mergeWorkflowExecutionSettings(persisted, form);
+	return JSON.stringify(sortKeys(before)) !== JSON.stringify(sortKeys(after));
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortKeys(value[key])]));
+}
+function useWorkflowExecutionSettingsForm(workflowKey) {
+	const tr = useTr();
+	const { data, loading, refetch } = useWorkflowDefinitionQuery({
+		variables: { workflowKey },
+		skip: !workflowKey,
+		fetchPolicy: "cache-and-network"
+	});
+	const [updateWorkflowDefinition, { loading: saving }] = useUpdateWorkflowDefinitionMutation();
+	const { allowed: canEdit } = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.WORKFLOW_UPDATE);
+	const locked = loading || saving || !canEdit || !data?.workflowDefinition;
+	const { data: otherWorkflowsData, loading: otherWorkflowsLoading } = useWorkflowDefinitionsQuery({
+		variables: { input: {
+			latestOnly: true,
+			limit: 100
+		} },
+		skip: !workflowKey
+	});
+	const errorWorkflowOptions = useMemo(() => (otherWorkflowsData?.workflowDefinitions?.items ?? []).filter((w) => w.workflowKey !== workflowKey), [otherWorkflowsData, workflowKey]);
+	const workflow = data?.workflowDefinition;
+	const persistedConfig = useMemo(() => {
+		return (workflow?.definitionJson)?.config ?? {};
+	}, [workflow?.definitionJson]);
+	const [form, setForm] = useState(persistedConfig);
+	const [redactFieldsText, setRedactFieldsText] = useState(() => formatRedactFields(persistedConfig.dataPrivacy?.redactFields));
+	useEffect(() => {
+		setForm(persistedConfig);
+		setRedactFieldsText(formatRedactFields(persistedConfig.dataPrivacy?.redactFields));
+	}, [persistedConfig]);
+	const runData = useRunDataSettings();
+	const selectedErrorWorkflowKey = form.errorWorkflowKey;
+	const { data: errorWorkflowData } = useWorkflowDefinitionQuery({
+		variables: { workflowKey: selectedErrorWorkflowKey ?? "" },
+		skip: !selectedErrorWorkflowKey
+	});
+	const selectedErrorWorkflow = errorWorkflowData?.workflowDefinition;
+	const errorWorkflowLacksTrigger = Boolean(selectedErrorWorkflowKey && selectedErrorWorkflow && !hasErrorTriggerNode(selectedErrorWorkflow.definitionJson));
+	/**
+	* Saves the form into the workflow's `config`. Resolves once saved, throws
+	* the service's refusal otherwise, and throws when the workflow could not be
+	* read, so a caller never reports a save that did not happen. A conflict (the workflow changed since
+	* it was read) is retried once on the latest version: settings only touch
+	* `config`, so they apply to it unchanged.
+	*/
+	const save = useCallback(async () => {
+		if (!workflow?.id) throw new Error(tr("fluidgrids.settings.execution.workflowNotFound", "This workflow couldn't be found. It may have been deleted, or you may no longer have access to it."));
+		const send = (stored) => updateWorkflowDefinition({ variables: {
+			id: stored.id,
+			input: {
+				definitionJson: definitionWithSettings(stored.definitionJson, form),
+				...typeof stored.revision === "number" ? { expectedRevision: stored.revision } : {}
+			}
+		} });
+		try {
+			await send(workflow);
+		} catch (err) {
+			if (!findSaveConflict(err)) throw err;
+			const latest = (await refetch()).data?.workflowDefinition;
+			if (!latest?.id) throw err;
+			await send(latest);
+		}
+		refetch();
+	}, [
+		workflow,
+		form,
+		updateWorkflowDefinition,
+		refetch,
+		tr
+	]);
+	return {
+		workflow,
+		loading,
+		saving,
+		canEdit,
+		locked,
+		form,
+		setForm,
+		persistedConfig,
+		dirty: settingsChanged(persistedConfig, form),
+		redactFieldsText,
+		setRedactFieldsText,
+		runData,
+		errorWorkflowOptions,
+		otherWorkflowsLoading,
+		errorWorkflowLacksTrigger,
+		save
+	};
+}
+
+// src/modules/settings/utils/optional-positive-int.ts
+/**
+* Number inputs whose empty value means "no limit" — Max parallel executions
+* (BOFF-7647) and Timeout in seconds (BOFF-7514). Empty is also what an unset
+* value means to the engine; anything else is clamped to a whole number of at
+* least 1.
+*/
+function parseOptionalPositiveInt(value) {
+	if (value.trim() === "") return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? Math.max(1, Math.trunc(parsed)) : void 0;
+}
+
+// src/modules/settings/components/SettingRow.tsx
+/**
+* One labelled setting: label and description on the left, its control on the right.
+* `stacked` puts the control under the label at every width, for narrow panels such
+* as the workflow settings drawer (BOFF-11843).
+*/
+function SettingRow({ label, description, stacked = false, children }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: stacked ? "flex flex-col gap-2 py-3" : "flex flex-col sm:flex-row sm:items-center sm:justify-between gap-3 py-4",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex-1 min-w-0",
+			children: [/* @__PURE__ */ jsx(Label, {
+				className: "text-sm font-medium text-text-primary",
+				children: label
+			}), description && /* @__PURE__ */ jsx("p", {
+				className: "text-xs text-text-secondary mt-0.5",
+				children: description
+			})]
+		}), /* @__PURE__ */ jsx("div", {
+			className: "shrink-0",
+			children
+		})]
+	});
+}
+
+// src/modules/settings/components/ExecutionSettingsFields.tsx
+/**
+* The per-workflow execution settings rows (BOFF-7512, BOFF-7514), shared by
+* Settings › Execution and the Navigation v2 settings drawer (BOFF-11843).
+* Each row reads and writes the form of `useWorkflowExecutionSettingsForm`.
+*/
+/** The "On workflow error" choices, in the order they are offered. */
+const ON_ERROR_CHOICES = [
+	"stop",
+	"continue",
+	"retry"
+];
+function isOnErrorChoice(value) {
+	return ON_ERROR_CHOICES.includes(value);
+}
+function TimeoutSetting({ ctl, stacked }) {
+	const tr = useTr();
+	const label = tr("fluidgrids.settings.execution.timeoutLabel", "Timeout");
+	return /* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label,
+		description: tr("fluidgrids.settings.execution.defaultTimeoutDescription", "Stop a run that keeps running longer than this. Time a run spends paused (a Wait over a minute, an approval, a person's answer) does not count. Leave empty for no limit."),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2",
+			children: [/* @__PURE__ */ jsx(Input, {
+				type: "number",
+				min: 1,
+				value: ctl.form.timeout ?? "",
+				placeholder: tr("fluidgrids.settings.execution.timeoutPlaceholder", "No timeout"),
+				"aria-label": label,
+				"data-testid": "execution-settings-timeout",
+				onChange: (e) => ctl.setForm((f) => ({
+					...f,
+					timeout: parseOptionalPositiveInt(e.target.value)
+				})),
+				disabled: ctl.locked,
+				className: "w-[100px] text-right"
+			}), /* @__PURE__ */ jsx("span", {
+				className: "text-xs text-text-secondary",
+				children: tr("fluidgrids.settings.execution.defaultTimeoutUnit", "seconds")
+			})]
+		})
+	});
+}
+function MaxParallelSetting({ ctl, stacked }) {
+	const tr = useTr();
+	const label = tr("fluidgrids.settings.execution.maxParallelLabel", "Max parallel executions");
+	return /* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label,
+		description: tr("fluidgrids.settings.execution.maxParallelDescription", "How many production runs of this workflow may run at once. Extra runs wait in a queue and start in order; manual test runs are never held back. Leave empty for no limit."),
+		children: /* @__PURE__ */ jsx(Input, {
+			type: "number",
+			min: 1,
+			value: ctl.form.maxParallelism ?? "",
+			placeholder: tr("fluidgrids.settings.execution.maxParallelPlaceholder", "No limit"),
+			"aria-label": label,
+			"data-testid": "execution-settings-max-parallel",
+			onChange: (e) => ctl.setForm((f) => ({
+				...f,
+				maxParallelism: parseOptionalPositiveInt(e.target.value)
+			})),
+			disabled: ctl.locked,
+			className: "w-[100px] text-right"
+		})
+	});
+}
+/**
+* "On workflow error": Stop, Continue or Retry. An fe-libs Select (it was a
+* native `<select>`, which ignored the theme in its open list).
+*/
+function OnErrorSetting({ ctl, stacked }) {
+	const tr = useTr();
+	const label = tr("fluidgrids.settings.execution.onErrorLabel", "On workflow error");
+	const choiceLabel = {
+		stop: tr("fluidgrids.settings.execution.onErrorStop", "Stop"),
+		continue: tr("fluidgrids.settings.execution.onErrorContinue", "Continue"),
+		retry: tr("fluidgrids.settings.execution.onErrorRetry", "Retry")
+	};
+	return /* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label,
+		description: tr("fluidgrids.settings.execution.onErrorDescription", "What to do when this workflow's execution fails"),
+		children: /* @__PURE__ */ jsxs(Select, {
+			value: ctl.form.onError ?? "stop",
+			onValueChange: (value) => {
+				if (!isOnErrorChoice(value)) return;
+				ctl.setForm((f) => ({
+					...f,
+					onError: value
+				}));
+			},
+			disabled: ctl.locked,
+			children: [/* @__PURE__ */ jsx(SelectTrigger, {
+				"aria-label": label,
+				"data-testid": "execution-settings-on-error",
+				className: "w-[160px] bg-surface border-border-default",
+				children: /* @__PURE__ */ jsx(SelectValue, {})
+			}), /* @__PURE__ */ jsx(SelectContent, { children: ON_ERROR_CHOICES.map((choice) => /* @__PURE__ */ jsx(SelectItem, {
+				value: choice,
+				children: choiceLabel[choice]
+			}, choice)) })]
+		})
+	});
+}
+const NO_ERROR_WORKFLOW = "__none__";
+function ErrorWorkflowSetting({ ctl, stacked }) {
+	const tr = useTr();
+	const label = tr("fluidgrids.settings.execution.errorWorkflowLabel", "Error workflow");
+	return /* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label,
+		description: tr("fluidgrids.settings.execution.errorWorkflowDescription", "Runs when a production run of this workflow fails, starting at that workflow's Error Trigger (optional)"),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: stacked ? "flex flex-col gap-1" : "flex flex-col items-end gap-1",
+			children: [/* @__PURE__ */ jsxs(Select, {
+				value: ctl.form.errorWorkflowKey ?? NO_ERROR_WORKFLOW,
+				onValueChange: (val) => ctl.setForm((f) => ({
+					...f,
+					errorWorkflowKey: val === NO_ERROR_WORKFLOW ? void 0 : val
+				})),
+				disabled: ctl.locked || ctl.otherWorkflowsLoading,
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					"aria-label": label,
+					"data-testid": "execution-settings-error-workflow",
+					className: "w-[220px] bg-surface border-border-default",
+					children: /* @__PURE__ */ jsx(SelectValue, { placeholder: tr("fluidgrids.settings.execution.errorWorkflowPlaceholder", "None") })
+				}), /* @__PURE__ */ jsxs(SelectContent, { children: [/* @__PURE__ */ jsx(SelectItem, {
+					value: NO_ERROR_WORKFLOW,
+					children: tr("fluidgrids.settings.execution.errorWorkflowNone", "None")
+				}), ctl.errorWorkflowOptions.map((w) => /* @__PURE__ */ jsx(SelectItem, {
+					value: w.workflowKey,
+					children: w.name
+				}, w.workflowKey))] })]
+			}), ctl.errorWorkflowLacksTrigger && /* @__PURE__ */ jsx("p", {
+				className: stacked ? "max-w-[260px] text-xs text-status-warning-text" : "max-w-[260px] text-right text-xs text-status-warning-text",
+				"data-testid": "error-workflow-no-trigger",
+				children: tr("fluidgrids.settings.execution.errorWorkflowNoTrigger", "This workflow has no Error Trigger, so it will not start. Add an Error Trigger node to it.")
+			})]
+		})
+	});
+}
+const SAVING_ROWS = [
+	{
+		key: "saveSuccessExecutions",
+		workspaceKey: "saveSuccessfulRuns",
+		labelKey: "fluidgrids.settings.execution.saveSuccessLabel",
+		label: "Keep data of successful runs",
+		testId: "execution-settings-keep-success"
+	},
+	{
+		key: "saveFailedExecutions",
+		workspaceKey: "saveFailedRuns",
+		labelKey: "fluidgrids.settings.execution.saveFailedLabel",
+		label: "Keep data of failed runs",
+		testId: "execution-settings-keep-failed"
+	},
+	{
+		key: "saveManualExecutions",
+		workspaceKey: "saveManualRuns",
+		labelKey: "fluidgrids.settings.execution.saveManualLabel",
+		label: "Keep data of test runs",
+		testId: "execution-settings-keep-test"
+	}
+];
+/** Keep data of successful / failed / test runs: workspace default, keep, or don't. */
+function RunDataSavingSettings({ ctl, stacked }) {
+	const tr = useTr();
+	return /* @__PURE__ */ jsx(Fragment$1, { children: SAVING_ROWS.map((row) => {
+		const inherited = ctl.runData.settings?.[row.workspaceKey];
+		return /* @__PURE__ */ jsx(SettingRow, {
+			stacked,
+			label: tr(row.labelKey, row.label),
+			children: /* @__PURE__ */ jsxs(Select, {
+				value: toSavingChoice(ctl.form.dataSaving?.[row.key]),
+				onValueChange: (choice) => ctl.setForm((f) => ({
+					...f,
+					dataSaving: compactOverrides({
+						...f.dataSaving,
+						[row.key]: fromSavingChoice(choice)
+					})
+				})),
+				disabled: ctl.locked,
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					"aria-label": tr(row.labelKey, row.label),
+					"data-testid": row.testId,
+					className: "w-[220px] bg-surface border-border-default",
+					children: /* @__PURE__ */ jsx(SelectValue, {})
+				}), /* @__PURE__ */ jsxs(SelectContent, { children: [
+					/* @__PURE__ */ jsx(SelectItem, {
+						value: "default",
+						children: inherited === void 0 ? tr("fluidgrids.settings.execution.savingDefault", "Workspace default") : inherited ? tr("fluidgrids.settings.execution.savingDefaultOn", "Workspace default (keep)") : tr("fluidgrids.settings.execution.savingDefaultOff", "Workspace default (don't keep)")
+					}),
+					/* @__PURE__ */ jsx(SelectItem, {
+						value: "save",
+						children: tr("fluidgrids.settings.execution.savingKeep", "Keep")
+					}),
+					/* @__PURE__ */ jsx(SelectItem, {
+						value: "skip",
+						children: tr("fluidgrids.settings.execution.savingDontKeep", "Don't keep")
+					})
+				] })]
+			})
+		}, row.key);
+	}) });
+}
+/** Delete runs after (days) and Runs kept: empty follows the workspace. */
+function RetentionSettings({ ctl, stacked }) {
+	const tr = useTr();
+	const daysLabel = tr("fluidgrids.settings.execution.retentionDaysLabel", "Delete runs after (days)");
+	const runsLabel = tr("fluidgrids.settings.execution.maxRunsLabel", "Runs kept");
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label: daysLabel,
+		description: tr("fluidgrids.settings.execution.retentionDaysDescription", "Leave empty to follow the workspace's Run data settings."),
+		children: /* @__PURE__ */ jsx(Input, {
+			type: "number",
+			min: RETENTION_DAYS_RANGE.min,
+			max: RETENTION_DAYS_RANGE.max,
+			"aria-label": daysLabel,
+			"data-testid": "execution-settings-retention-days",
+			value: ctl.form.retention?.maxAgeDays ?? "",
+			placeholder: ctl.runData.settings ? String(ctl.runData.settings.retentionDays) : "",
+			onChange: (e) => ctl.setForm((f) => ({
+				...f,
+				retention: compactOverrides({
+					...f.retention,
+					maxAgeDays: parseBoundedInt(e.target.value, RETENTION_DAYS_RANGE)
+				})
+			})),
+			disabled: ctl.locked,
+			className: "w-[100px] text-right"
+		})
+	}), /* @__PURE__ */ jsx(SettingRow, {
+		stacked,
+		label: runsLabel,
+		description: tr("fluidgrids.settings.execution.maxRunsDescription", "Leave empty to follow the workspace's Run data settings."),
+		children: /* @__PURE__ */ jsx(Input, {
+			type: "number",
+			min: RETENTION_MAX_RUNS_RANGE.min,
+			max: RETENTION_MAX_RUNS_RANGE.max,
+			"aria-label": runsLabel,
+			"data-testid": "execution-settings-max-runs",
+			value: ctl.form.retention?.maxRuns ?? "",
+			placeholder: ctl.runData.settings ? String(ctl.runData.settings.retentionMaxRunsPerWorkflow) : "",
+			onChange: (e) => ctl.setForm((f) => ({
+				...f,
+				retention: compactOverrides({
+					...f.retention,
+					maxRuns: parseBoundedInt(e.target.value, RETENTION_MAX_RUNS_RANGE)
+				})
+			})),
+			disabled: ctl.locked,
+			className: "w-[120px] text-right"
+		})
+	})] });
+}
+
+export { WorkflowNotificationSettingsDocument as _, RunDataSavingSettings as a, useWorkflowExecutionSettingsForm as c, RETENTION_MAX_RUNS_RANGE as d, compactOverrides as f, useWorkflowNotificationSettings as g, NOTIFICATION_THROTTLE_RANGE as h, RetentionSettings as i, useRunDataSettings as l, parseRedactFields as m, MaxParallelSetting as n, TimeoutSetting as o, parseBoundedInt as p, OnErrorSetting as r, SettingRow as s, ErrorWorkflowSetting as t, RETENTION_DAYS_RANGE as u, UpdateWorkflowNotificationSettingsDocument as v };