@burdenoff/fluidgrids-fe-sdk 2026.1111.15 → 2026.1111.17

package/dist/useDurableParity-CzUQMFJ3.js

@@ -0,0 +1,415 @@
+"use client";
+import { _ as throwIfResultError, m as describeOperationError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { $r as WorkflowRunPendingDocument, Qr as WorkflowRunMetadataDocument, jn as SetWorkflowRunVersioningOverrideDocument, ni as WorkflowRunsCountDocument, tt as DurableParityRunFieldsDocument } from "./graphql-operation-types-kX-MMjgW.js";
+import { _ as statusCountFilter, d as STATUS_COUNT_GROUP_BY, v as statusCountsOf } from "./useExecutions-9aLuOt1c.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Icon } from "@iconify/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+// src/modules/executions/types/index.ts
+const RUN_STATUS_CONFIG = {
+	PENDING: {
+		label: "Pending",
+		color: "text-text-secondary",
+		bgColor: "bg-bg-sunken",
+		borderColor: "border-border-default",
+		icon: "mdi:clock-outline"
+	},
+	RUNNING: {
+		label: "Running",
+		color: "text-status-info-text",
+		bgColor: "bg-status-info-bg-subtle",
+		borderColor: "border-status-info-border",
+		icon: "mdi:play-circle-outline"
+	},
+	COMPLETED: {
+		label: "Completed",
+		color: "text-status-success-text",
+		bgColor: "bg-status-success-bg-subtle",
+		borderColor: "border-status-success-border",
+		icon: "mdi:check-circle-outline"
+	},
+	FAILED: {
+		label: "Failed",
+		color: "text-status-error-text",
+		bgColor: "bg-status-error-bg-subtle",
+		borderColor: "border-status-error-border",
+		icon: "mdi:alert-circle-outline"
+	},
+	CANCELLED: {
+		label: "Cancelled",
+		color: "text-status-warning-text",
+		bgColor: "bg-status-warning-bg-subtle",
+		borderColor: "border-status-warning-border",
+		icon: "mdi:cancel"
+	},
+	WAITING: {
+		label: "Waiting",
+		color: "text-chart-3",
+		bgColor: "bg-chart-3/10",
+		borderColor: "border-chart-3/30",
+		icon: "mdi:timer-sand"
+	},
+	TERMINATED: {
+		label: "Terminated",
+		color: "text-text-secondary",
+		bgColor: "bg-bg-sunken",
+		borderColor: "border-border-strong",
+		icon: "mdi:stop-circle-outline"
+	}
+};
+const NODE_STATUS_CONFIG = {
+	PENDING: {
+		label: "Pending",
+		color: "text-text-secondary",
+		bgColor: "bg-bg-sunken",
+		borderColor: "border-border-default",
+		icon: "mdi:clock-outline"
+	},
+	RUNNING: {
+		label: "Running",
+		color: "text-status-info-text",
+		bgColor: "bg-status-info-bg-subtle",
+		borderColor: "border-status-info-border",
+		icon: "mdi:play-circle-outline"
+	},
+	COMPLETED: {
+		label: "Completed",
+		color: "text-status-success-text",
+		bgColor: "bg-status-success-bg-subtle",
+		borderColor: "border-status-success-border",
+		icon: "mdi:check-circle-outline"
+	},
+	FAILED: {
+		label: "Failed",
+		color: "text-status-error-text",
+		bgColor: "bg-status-error-bg-subtle",
+		borderColor: "border-status-error-border",
+		icon: "mdi:alert-circle-outline"
+	},
+	SKIPPED: {
+		label: "Skipped",
+		color: "text-text-muted",
+		bgColor: "bg-bg-sunken",
+		borderColor: "border-border-default",
+		icon: "mdi:skip-next"
+	},
+	DELAYED: {
+		label: "Delayed",
+		color: "text-status-warning-text",
+		bgColor: "bg-status-warning-bg-subtle",
+		borderColor: "border-status-warning-border",
+		icon: "mdi:clock-alert-outline"
+	},
+	CANCELLED: {
+		label: "Cancelled",
+		color: "text-status-warning-text",
+		bgColor: "bg-status-warning-bg-subtle",
+		borderColor: "border-status-warning-border",
+		icon: "mdi:cancel"
+	},
+	TIMEOUT: {
+		label: "Timeout",
+		color: "text-status-error-text",
+		bgColor: "bg-status-error-bg-subtle",
+		borderColor: "border-status-error-border",
+		icon: "mdi:timer-off-outline"
+	},
+	WAITING: {
+		label: "Waiting",
+		color: "text-chart-3",
+		bgColor: "bg-chart-3/10",
+		borderColor: "border-chart-3/30",
+		icon: "mdi:timer-sand"
+	},
+	WAITING_SUBWORKFLOW: {
+		label: "Waiting",
+		color: "text-chart-3",
+		bgColor: "bg-chart-3/10",
+		borderColor: "border-chart-3/30",
+		icon: "mdi:subdirectory-arrow-right"
+	}
+};
+
+// src/modules/executions/utils/run-status-labels.ts
+function runStatusLabels(tr) {
+	return {
+		PENDING: tr("fluidgrids.executions.executionFilters.statusPending", "Pending"),
+		RUNNING: tr("fluidgrids.executions.executionFilters.statusRunning", "Running"),
+		COMPLETED: tr("fluidgrids.executions.executionFilters.statusCompleted", "Completed"),
+		FAILED: tr("fluidgrids.executions.executionFilters.statusFailed", "Failed"),
+		CANCELLED: tr("fluidgrids.executions.executionFilters.statusCancelled", "Cancelled"),
+		WAITING: tr("fluidgrids.executions.executionFilters.statusWaiting", "Waiting"),
+		TERMINATED: tr("fluidgrids.executions.executionFilters.statusTerminated", "Terminated")
+	};
+}
+
+// src/modules/executions/components/ExecutionStatusBadge.tsx
+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",
+		lg: "px-3 py-1.5 text-base gap-2"
+	};
+	const iconSizes = {
+		sm: 12,
+		md: 14,
+		lg: 16
+	};
+	const isRunning = status === "RUNNING";
+	return /* @__PURE__ */ jsxs("span", {
+		className: `
+        inline-flex items-center rounded-full font-medium
+        ${config.bgColor} ${config.color} border ${config.borderColor}
+        ${sizeClasses[size]}
+        ${animated && isRunning ? "animate-pulse" : ""}
+      `,
+		children: [showIcon && /* @__PURE__ */ jsx(Icon, {
+			icon: config.icon,
+			width: iconSizes[size],
+			height: iconSizes[size],
+			className: animated && isRunning ? "animate-spin" : ""
+		}), showLabel && /* @__PURE__ */ jsx("span", { children: labels[status] ?? config.label })]
+	});
+}
+function NodeStatusBadge({ status, size = "md", showIcon = true, showLabel = true, animated = true }) {
+	const config = NODE_STATUS_CONFIG[status] ?? NODE_STATUS_CONFIG.PENDING;
+	const sizeClasses = {
+		sm: "px-1.5 py-0.5 text-xs gap-1",
+		md: "px-2 py-1 text-sm gap-1.5",
+		lg: "px-3 py-1.5 text-base gap-2"
+	};
+	const iconSizes = {
+		sm: 12,
+		md: 14,
+		lg: 16
+	};
+	const isRunning = status === "RUNNING";
+	return /* @__PURE__ */ jsxs("span", {
+		className: `
+        inline-flex items-center rounded-full font-medium
+        ${config.bgColor} ${config.color} border ${config.borderColor}
+        ${sizeClasses[size]}
+        ${animated && isRunning ? "animate-pulse" : ""}
+      `,
+		children: [showIcon && /* @__PURE__ */ jsx(Icon, {
+			icon: config.icon,
+			width: iconSizes[size],
+			height: iconSizes[size],
+			className: animated && isRunning ? "animate-spin" : ""
+		}), showLabel && /* @__PURE__ */ jsx("span", { children: config.label })]
+	});
+}
+
+// src/modules/executions/hooks/useDurableParity.ts
+/**
+* Durable-function parity reads and writes of the run page and the Runs list
+* (BOFF-9905, spec code-first 11): the run's workflow id, chain, metadata,
+* callback and versioning; what it is waiting on; the `__metadata` answer;
+* status counts; and the per-run versioning override.
+*
+* Like useDurableRun, every read is a plain network read and nothing is sent
+* while `enabled` is false, which the pages tie to useDurableParityEnabled().
+* A failed read keeps the last good answer, or none, so a gateway or service
+* without the parity release never breaks the page: the parity views simply
+* stay empty.
+*/
+/** Re-read cadence of the pending state while the run is live. */
+const 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;
+}
+/**
+* A read keyed by run id that keeps the last good answer, ignores answers to
+* superseded requests, and re-reads every `intervalMs` while `live`.
+*/
+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);
+		refetch();
+	}, [refetch]);
+	useEffect(() => {
+		if (!live || !enabled || !runId || intervalMs <= 0) return;
+		const timer = setInterval(() => {
+			refetch();
+		}, intervalMs);
+		return () => clearInterval(timer);
+	}, [
+		live,
+		enabled,
+		runId,
+		intervalMs,
+		refetch
+	]);
+	return {
+		data: enabled ? data : null,
+		loading,
+		error,
+		refetch
+	};
+}
+/** The parity fields of a run; nothing is read while `enabled` is false. */
+function useDurableParityRunFields(runId, enabled) {
+	const { data, error, refetch } = useRunRead(runId, enabled, fetchDurableParityRunFields, {});
+	return {
+		fields: data,
+		error,
+		refetch
+	};
+}
+/** What an open run is waiting on, re-read every 5 s while `live`. */
+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
+	};
+}
+/**
+* `__stack_trace` with `__metadata` of an open durable run: one replay in the
+* service, so it is read once when shown and on request, never polled.
+*/
+function useRunMetadata(runId, enabled) {
+	const { data, loading, error, refetch } = useRunRead(runId, enabled, fetchRunMetadata, {});
+	return {
+		answer: data,
+		loading,
+		error,
+		refetch
+	};
+}
+/**
+* Per-status counts of the Runs list's current filter. The filter is the
+* list's own request (so the counts match it), and nothing is sent while
+* `enabled` is false.
+*/
+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(() => {
+		refetch();
+	}, [refetch]);
+	return enabled ? {
+		...state,
+		error,
+		refetch
+	} : {
+		total: null,
+		counts: [],
+		error: null,
+		refetch
+	};
+}
+
+export { useRunStatusCounts as a, runStatusLabels as c, useRunPending as i, RUN_STATUS_CONFIG as l, useDurableParityRunFields as n, ExecutionStatusBadge as o, useRunMetadata as r, NodeStatusBadge as s, setRunVersioningOverride as t };

package/dist/useEntityTags-DhnsZcTl.js

@@ -0,0 +1,236 @@
+"use client";
+import { n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { $n as UntagFluidgridsEntityDocument, D as CreateFluidgridsTagDocument, En as SearchFluidgridsTagsDocument, _t as FluidgridsEntityTagsDocument, d as AvailableFluidgridsTagsDocument, en as ReplaceFluidgridsEntityTagsDocument, z as DataTablesTagsDocument, zn as TagFluidgridsEntityDocument } from "./graphql-operation-types-kX-MMjgW.js";
+import { useCallback, useEffect, useState } from "react";
+
+// src/hooks/useEntityTags.ts
+/**
+* Entity tag hooks — thin wrappers over the generic FluidGrids tag API
+* (wspace-workflow-svc `tags` module → wspace-tags-svc).
+*
+* Uses the shared Apollo client directly rather than generated hooks, matching
+* the convention in useWorkflows.ts (works in embeds and other contexts that
+* mount the SDK without an ApolloProvider above them).
+*/
+/**
+* Entity types accepted by the FluidGrids tag API (wspace-workflow-svc
+* `src/modules/tags/entity-tags.ts`). Workflows are tagged by `workflowKey`,
+* every other type by its id. Connections are tagged in the integrations
+* service, not here.
+*/
+const FLUIDGRIDS_ENTITY_TYPES = [
+	"FLUIDGRIDS_WORKFLOW",
+	"FLUIDGRIDS_RUN",
+	"FLUIDGRIDS_DATA_TABLE",
+	"FLUIDGRIDS_TRIGGER",
+	"FLUIDGRIDS_SCHEDULE"
+];
+/** Display label for an assignment, degrading to the tag id when tags-svc omits the projection. */
+function tagLabel(assignment) {
+	return assignment.tagInfo?.label ?? assignment.tagInfo?.key ?? assignment.tagId.slice(0, 8);
+}
+/** Tags currently assigned to an entity. */
+function useEntityTags(entityType, entityId) {
+	const [tags, setTags] = useState([]);
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const refetch = useCallback(async () => {
+		if (!entityId) {
+			setTags([]);
+			return [];
+		}
+		setLoading(true);
+		setError(null);
+		try {
+			const { data } = await getFluidGridsClient().query({
+				query: FluidgridsEntityTagsDocument,
+				variables: { input: {
+					entityType,
+					entityId
+				} },
+				fetchPolicy: "network-only"
+			});
+			const next = data?.fluidgridsEntityTags ?? [];
+			setTags(next);
+			return next;
+		} catch (err) {
+			setError(err);
+			return [];
+		} finally {
+			setLoading(false);
+		}
+	}, [entityType, entityId]);
+	useEffect(() => {
+		refetch();
+	}, [refetch]);
+	return {
+		tags,
+		loading,
+		error,
+		refetch
+	};
+}
+/** All assignable tags in the workspace. */
+function useAvailableTags(limit = 50, options = {}) {
+	const [availableTags, setAvailableTags] = useState([]);
+	const [loading, setLoading] = useState(false);
+	const skip = options.skip ?? false;
+	const fetchTags = useCallback(async () => {
+		if (skip) return;
+		setLoading(true);
+		try {
+			const { data } = await getFluidGridsClient().query({
+				query: AvailableFluidgridsTagsDocument,
+				variables: { limit },
+				fetchPolicy: "network-only"
+			});
+			setAvailableTags(data?.availableFluidgridsTags ?? []);
+		} catch {
+			setAvailableTags([]);
+		} finally {
+			setLoading(false);
+		}
+	}, [limit, skip]);
+	useEffect(() => {
+		fetchTags();
+	}, [fetchTags]);
+	return {
+		availableTags,
+		loading,
+		refetch: fetchTags
+	};
+}
+/** Search assignable tags by label. */
+function useSearchTags() {
+	return useCallback(async (query, limit = 20) => {
+		if (!query.trim()) return [];
+		try {
+			const { data } = await getFluidGridsClient().query({
+				query: SearchFluidgridsTagsDocument,
+				variables: {
+					query,
+					limit
+				},
+				fetchPolicy: "network-only"
+			});
+			return data?.searchFluidgridsTags ?? [];
+		} catch {
+			return [];
+		}
+	}, []);
+}
+/** Assign a tag to an entity. */
+function useTagEntity() {
+	return useCallback(async (entityType, entityId, tagId) => {
+		const { data } = await getFluidGridsClient().mutate({
+			mutation: TagFluidgridsEntityDocument,
+			variables: { input: {
+				entityType,
+				entityId,
+				tagId,
+				source: "MANUAL"
+			} }
+		});
+		return Boolean(data?.tagFluidgridsEntity);
+	}, []);
+}
+/** Remove a tag from an entity. */
+function useUntagEntity() {
+	return useCallback(async (entityType, entityId, tagId) => {
+		const { data } = await getFluidGridsClient().mutate({
+			mutation: UntagFluidgridsEntityDocument,
+			variables: { input: {
+				entityType,
+				entityId,
+				tagId
+			} }
+		});
+		return Boolean(data?.untagFluidgridsEntity);
+	}, []);
+}
+/** Replace the full tag set on an entity. */
+function useReplaceEntityTags() {
+	return useCallback(async (entityType, entityId, tagIds) => {
+		const { data } = await getFluidGridsClient().mutate({
+			mutation: ReplaceFluidgridsEntityTagsDocument,
+			variables: { input: {
+				entityType,
+				entityId,
+				tagIds
+			} }
+		});
+		return data?.replaceFluidgridsEntityTags ?? [];
+	}, []);
+}
+/** Create a new assignable tag (inline creation from the picker). */
+function useCreateTag() {
+	return useCallback(async (label, color) => {
+		const { data } = await getFluidGridsClient().mutate({
+			mutation: CreateFluidgridsTagDocument,
+			variables: { input: {
+				label,
+				color
+			} }
+		});
+		return data?.createFluidgridsTag ?? null;
+	}, []);
+}
+/**
+* Create-time tagging: collect tag ids while the entity does not exist yet,
+* then flush them once it does.
+*
+* The flush is best-effort — the entity already exists by then, so a tag
+* failure must never block navigation; the detail-surface picker lets the
+* user retry.
+*/
+function useDraftEntityTags(entityType) {
+	const [draftTagIds, setDraftTagIds] = useState([]);
+	const tagEntity = useTagEntity();
+	return {
+		draftTagIds,
+		setDraftTagIds,
+		flushTags: useCallback(async (entityId) => {
+			if (!entityId || draftTagIds.length === 0) return;
+			await Promise.all(draftTagIds.map((tagId) => tagEntity(entityType, entityId, tagId).catch(() => false)));
+		}, [
+			draftTagIds,
+			entityType,
+			tagEntity
+		])
+	};
+}
+/**
+* Tag overlay for the Data Tables list: tableId -> assignments (G47).
+*
+* Separate from the list query, like {@link useWorkflowTagOverlay}: when
+* `tagAssignments` is not in the supergraph yet, only the chips go missing.
+*/
+function useDataTableTagOverlay(limit = 200) {
+	const [tagsById, setTagsById] = useState({});
+	const fetchOverlay = useCallback(async () => {
+		try {
+			const { data } = await getFluidGridsClient().query({
+				query: DataTablesTagsDocument,
+				variables: { limit },
+				fetchPolicy: "network-only"
+			});
+			const next = {};
+			for (const table of data?.dataTables?.tables ?? []) {
+				const assignments = table.tagAssignments ?? [];
+				if (assignments.length > 0) next[table.id] = assignments;
+			}
+			setTagsById(next);
+		} catch {
+			setTagsById({});
+		}
+	}, [limit]);
+	useEffect(() => {
+		fetchOverlay();
+	}, [fetchOverlay]);
+	return {
+		tagsById,
+		refetch: fetchOverlay
+	};
+}
+
+export { useDataTableTagOverlay as a, useReplaceEntityTags as c, useUntagEntity as d, useCreateTag as i, useSearchTags as l, tagLabel as n, useDraftEntityTags as o, useAvailableTags as r, useEntityTags as s, FLUIDGRIDS_ENTITY_TYPES as t, useTagEntity as u };

package/dist/{useExecutions-DkS0FTfw.js → useExecutions-9aLuOt1c.js}

@@ -1,8 +1,9 @@
 "use client";
-import { Jn as TriggerWorkflowDocument, Kn as TerminateExecutionDocument, Li as emitFluidGridsEvent, Oi as getFluidGridsClient, Ri as emitOperationErrorEvent, Rt as PauseExecutionDocument, Ui as throwIfResultError, aa as useExecutionsStore, cn as ResumeExecutionDocument, ln as RetryNodeDocument, lt as ExecutionStatsDocument, st as ExecutionDetailDocument, ut as ExecutionsListDocument, y as CancelExecutionDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { hD as RunGroupBy, yP as VersioningBehavior } from "./graphql-types-XcDLtFwU.js";
+import { N as useExecutionsStore, _ as throwIfResultError, d as emitFluidGridsEvent, f as emitOperationErrorEvent, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { Gn as TerminateExecutionDocument, Lt as PauseExecutionDocument, cn as RetryNodeDocument, ct as ExecutionStatsDocument, lt as ExecutionsListDocument, ot as ExecutionDetailDocument, qn as TriggerWorkflowDocument, sn as ResumeExecutionDocument, v as CancelExecutionDocument } from "./graphql-operation-types-kX-MMjgW.js";
+import { hD as RunGroupBy, yP as VersioningBehavior } from "./graphql-types-CDKVWH2R.js";
 import { c as REPLAY_WORKFLOW_RUN, l as RETRY_WORKFLOW_RUNS } from "./operations-HU-xb78H.js";
-import { fn as useFluidGridsAnalytics, pn as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-B9RR_CI_.js";
+import { mn as openRunQuotaUpgradePrompt, pn as useFluidGridsAnalytics } from "./FluidGridsProvider-dvZSNtSW.js";
 import { i as emitRunStarted } from "./fluidgridsEvents-CNdcrUNN.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";

package/dist/{useObservability-BkxhHZsX.js → useObservability-CfEw3ZFD.js}

@@ -1,6 +1,6 @@
 "use client";
-import { Bi as describeOperationError, Li as emitFluidGridsEvent, Oi as getFluidGridsClient, Ui as throwIfResultError } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { fn as useFluidGridsAnalytics, pn as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-B9RR_CI_.js";
+import { _ as throwIfResultError, d as emitFluidGridsEvent, m as describeOperationError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { mn as openRunQuotaUpgradePrompt, pn as useFluidGridsAnalytics } from "./FluidGridsProvider-dvZSNtSW.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { i as emitRunStarted } from "./fluidgridsEvents-CNdcrUNN.js";
 import { a as OBSERVABILITY_DATA_SINKS, c as REPLAY_WORKFLOW_RUN, d as UPDATE_LOG_STREAM_DESTINATION, i as OBSERVABILITY_DASHBOARD_SUMMARY, l as RETRY_WORKFLOW_RUNS, n as DELETE_LOG_STREAM_DESTINATION, o as OBSERVABILITY_DATA_SINK_DATA, r as LOG_STREAM_DESTINATIONS, s as OBSERVABILITY_FAILED_RUNS, t as CREATE_LOG_STREAM_DESTINATION, u as TEST_LOG_STREAM_DESTINATION } from "./operations-HU-xb78H.js";

package/dist/{useRunHistory-DHehG09Z.js → useRunHistory-B1xJDwl1.js}

@@ -1,8 +1,9 @@
 "use client";
-import { Bi as describeOperationError, Oi as getFluidGridsClient, Pn as SignalWorkflowRunDocument, Qr as WorkflowRunHistoryDocument, Ui as throwIfResultError, hn as RunEventAppendedDocument, ki as getFluidGridsClientSafe, qn as TerminateWorkflowRunDocument, qr as WorkflowRunDeterminismStatusDocument, rt as DurableRunFieldsDocument, ti as WorkflowRunStackTraceDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { Cn as payloadFromCardValues, Sn as parseRawSignalPayload, Tn as signalPayloadCard } from "./FluidGridsProvider-B9RR_CI_.js";
+import { _ as throwIfResultError, m as describeOperationError, n as getFluidGridsClient, r as getFluidGridsClientSafe } from "./client-C9XSzSXr.js";
+import { Cn as parseRawSignalPayload, En as signalPayloadCard, wn as payloadFromCardValues } from "./FluidGridsProvider-dvZSNtSW.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
-import { yd as ExecutionKind } from "./graphql-types-XcDLtFwU.js";
+import { Kn as TerminateWorkflowRunDocument, Kr as WorkflowRunDeterminismStatusDocument, Nn as SignalWorkflowRunDocument, Zr as WorkflowRunHistoryDocument, ei as WorkflowRunStackTraceDocument, mn as RunEventAppendedDocument, nt as DurableRunFieldsDocument } from "./graphql-operation-types-kX-MMjgW.js";
+import { yd as ExecutionKind } from "./graphql-types-CDKVWH2R.js";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { Icon } from "@iconify/react";
 import { cn } from "@burdenoff/fe-libs/utils";