@burdenoff/fluidgrids-fe-sdk 2026.1031.7 → 2026.1101.2

package/dist/chunk-F7DD7BOB.js

@@ -0,0 +1,1164 @@
+import { operatorSpec, normaliseAssertRules, describeAssertRuleProblem } from './chunk-JDLQ6QIB.js';
+import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-PZ45H72P.js';
+import { notifyFluidGridsAiCreditsUpdated } from './chunk-Y53CVZVV.js';
+import { ErrorType } from './chunk-7KKYIRLH.js';
+import { throwIfResultError, isForbiddenError } from './chunk-NZJWKVER.js';
+import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
+import { WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument, WorkflowTestCasesDocument, WorkflowTestRunsDocument, WorkflowTestRunDocument, CreateWorkflowTestCaseDocument, UpdateWorkflowTestCaseDocument, DeleteWorkflowTestCaseDocument, RunWorkflowTestsDocument, CreateWorkflowTestCaseFromRunDocument } from './chunk-IHEV5HTD.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { TagBadge, TagsWidget } from '@burdenoff/fe-libs/tag';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Icon } from '@iconify/react';
+import { Badge, Button } from '@burdenoff/fe-libs/ui';
+
+function toTagItem(assignment) {
+  return {
+    id: assignment.tagId,
+    key: assignment.tagInfo?.key ?? assignment.tagId,
+    label: assignment.tagInfo?.label ?? assignment.tagInfo?.key ?? "Tag",
+    color: assignment.tagInfo?.color ?? null
+  };
+}
+function EntityTagPicker({
+  entityType,
+  entityId,
+  onDraftChange,
+  readOnly = false,
+  onChange,
+  className
+}) {
+  const draftMode = !entityId;
+  const { workspaceId } = getFluidGridsConfig();
+  const { tags: assignments, refetch } = useEntityTags(entityType, entityId);
+  const tagEntity = useTagEntity();
+  const untagEntity = useUntagEntity();
+  const [current, setCurrent] = useState([]);
+  const currentRef = useRef([]);
+  const assignmentKey = assignments.map((a) => a.tagId).join("|");
+  const syncedKey = useRef(null);
+  useEffect(() => {
+    if (draftMode || syncedKey.current === assignmentKey) return;
+    syncedKey.current = assignmentKey;
+    const synced = assignments.map(toTagItem);
+    currentRef.current = synced;
+    setCurrent(synced);
+  }, [assignmentKey, assignments, draftMode]);
+  const handleAdd = useCallback(
+    async (tag) => {
+      if (currentRef.current.some((t) => t.id === tag.id)) return;
+      const next = [...currentRef.current, tag];
+      currentRef.current = next;
+      setCurrent(next);
+      if (draftMode) {
+        onDraftChange?.(next.map((t) => t.id));
+        return;
+      }
+      try {
+        await tagEntity(entityType, entityId, tag.id);
+        await refetch();
+        onChange?.();
+      } catch {
+        const rolledBack = currentRef.current.filter((t) => t.id !== tag.id);
+        currentRef.current = rolledBack;
+        setCurrent(rolledBack);
+      }
+    },
+    [
+      draftMode,
+      entityId,
+      entityType,
+      onChange,
+      onDraftChange,
+      refetch,
+      tagEntity
+    ]
+  );
+  const handleRemove = useCallback(
+    async (tagId) => {
+      const removed = currentRef.current.find((t) => t.id === tagId);
+      const next = currentRef.current.filter((t) => t.id !== tagId);
+      currentRef.current = next;
+      setCurrent(next);
+      if (draftMode) {
+        onDraftChange?.(next.map((t) => t.id));
+        return;
+      }
+      try {
+        await untagEntity(entityType, entityId, tagId);
+        await refetch();
+        onChange?.();
+      } catch {
+        if (removed) {
+          const rolledBack = [...currentRef.current, removed];
+          currentRef.current = rolledBack;
+          setCurrent(rolledBack);
+        }
+      }
+    },
+    [
+      draftMode,
+      entityId,
+      entityType,
+      onChange,
+      onDraftChange,
+      refetch,
+      untagEntity
+    ]
+  );
+  if (readOnly) {
+    if (current.length === 0) return null;
+    return /* @__PURE__ */ jsx("div", { className: `flex flex-wrap items-center gap-1 ${className ?? ""}`, children: current.map((tag) => /* @__PURE__ */ jsx(
+      TagBadge,
+      {
+        id: tag.id,
+        label: tag.label,
+        color: tag.color ?? void 0,
+        size: "sm"
+      },
+      tag.id
+    )) });
+  }
+  return /* @__PURE__ */ jsx(
+    TagsWidget,
+    {
+      entityType,
+      entityId: entityId ?? "",
+      workspaceId: workspaceId || void 0,
+      tags: current,
+      onAdd: handleAdd,
+      onRemove: handleRemove,
+      syncGraphNotifications: !draftMode,
+      className
+    }
+  );
+}
+var PROPOSAL_POLL_INTERVAL_MS = 3e3;
+var PROPOSAL_MAX_WAIT_MS = 6 * 60 * 1e3;
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isProposalRunning(status) {
+  return status === "PROCESSING";
+}
+function useWorkflowProposal() {
+  const [proposal, setProposal] = useState(null);
+  const [isWorking, setIsWorking] = useState(false);
+  const [isDeciding, setIsDeciding] = useState(false);
+  const [error, setError] = useState(null);
+  const [timedOut, setTimedOut] = useState(false);
+  const runRef = useRef(0);
+  const timerRef = useRef(null);
+  const clearTimer = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = null;
+  }, []);
+  useEffect(
+    () => () => {
+      runRef.current++;
+      clearTimer();
+    },
+    [clearTimer]
+  );
+  const reset = useCallback(() => {
+    runRef.current++;
+    clearTimer();
+    setProposal(null);
+    setIsWorking(false);
+    setIsDeciding(false);
+    setError(null);
+    setTimedOut(false);
+  }, [clearTimer]);
+  const poll = useCallback(
+    async (run, id, startedAt) => {
+      if (run !== runRef.current) return;
+      try {
+        const result = throwIfResultError(
+          await getFluidGridsClient().query({
+            query: WorkflowProposalDocument,
+            variables: { id },
+            fetchPolicy: "network-only"
+          })
+        );
+        if (run !== runRef.current) return;
+        const next = result.data?.workflowProposal ?? null;
+        if (next) setProposal(next);
+        const status = next ? String(next.status) : void 0;
+        if (isProposalRunning(status)) {
+          if (Date.now() - startedAt < PROPOSAL_MAX_WAIT_MS) {
+            timerRef.current = setTimeout(
+              () => void poll(run, id, startedAt),
+              PROPOSAL_POLL_INTERVAL_MS
+            );
+            return;
+          }
+          setTimedOut(true);
+        } else {
+          notifyFluidGridsAiCreditsUpdated();
+        }
+        setIsWorking(false);
+      } catch (pollError) {
+        if (run !== runRef.current) return;
+        setError(messageOf(pollError));
+        setIsWorking(false);
+      }
+    },
+    []
+  );
+  const start = useCallback(
+    async (input) => {
+      const run = ++runRef.current;
+      clearTimer();
+      setProposal(null);
+      setError(null);
+      setTimedOut(false);
+      setIsWorking(true);
+      try {
+        const client = getFluidGridsClient();
+        let started;
+        if (input.kind === "runFix") {
+          const result = throwIfResultError(
+            await client.mutate({
+              mutation: ProposeRunFixDocument,
+              variables: {
+                input: {
+                  runId: input.runId,
+                  ...input.prompt ? { prompt: input.prompt } : {}
+                }
+              }
+            })
+          );
+          started = result.data?.proposeRunFix;
+        } else {
+          const result = throwIfResultError(
+            await client.mutate({
+              mutation: ProposeWorkflowChangeDocument,
+              variables: {
+                input: {
+                  prompt: input.prompt,
+                  ...input.workflowKey ? { workflowKey: input.workflowKey } : {},
+                  ...input.baseVersion ? { baseVersion: input.baseVersion } : {},
+                  ...input.template ? { template: input.template } : {}
+                }
+              }
+            })
+          );
+          started = result.data?.proposeWorkflowChange;
+        }
+        if (!started?.id) throw new Error("The proposal did not start");
+        if (run !== runRef.current) return;
+        setProposal(started);
+        const id = started.id;
+        timerRef.current = setTimeout(
+          () => void poll(run, id, Date.now()),
+          PROPOSAL_POLL_INTERVAL_MS
+        );
+      } catch (startError) {
+        if (run !== runRef.current) return;
+        setError(messageOf(startError));
+        setIsWorking(false);
+      }
+    },
+    [clearTimer, poll]
+  );
+  const open = useCallback(
+    async (id) => {
+      const run = ++runRef.current;
+      clearTimer();
+      setError(null);
+      setTimedOut(false);
+      setIsWorking(true);
+      await poll(run, id, Date.now());
+    },
+    [clearTimer, poll]
+  );
+  const decide = useCallback(
+    async (action) => {
+      const id = proposal?.id;
+      if (!id) return null;
+      const run = runRef.current;
+      setIsDeciding(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        let next;
+        if (action === "apply") {
+          const result = throwIfResultError(
+            await client.mutate({ mutation: ApplyWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.applyWorkflowProposal;
+        } else if (action === "reject") {
+          const result = throwIfResultError(
+            await client.mutate({ mutation: RejectWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.rejectWorkflowProposal;
+        } else {
+          clearTimer();
+          const result = throwIfResultError(
+            await client.mutate({ mutation: CancelWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.cancelWorkflowProposal;
+          setIsWorking(false);
+        }
+        if (run === runRef.current && next) setProposal(next);
+        return next ?? null;
+      } catch (decideError) {
+        if (run === runRef.current) setError(messageOf(decideError));
+        return null;
+      } finally {
+        if (run === runRef.current) setIsDeciding(false);
+      }
+    },
+    [clearTimer, proposal?.id]
+  );
+  const apply = useCallback(() => decide("apply"), [decide]);
+  const reject = useCallback(async () => {
+    await decide("reject");
+  }, [decide]);
+  const cancel = useCallback(async () => {
+    await decide("cancel");
+  }, [decide]);
+  return {
+    proposal,
+    isWorking,
+    isDeciding,
+    error,
+    timedOut,
+    start,
+    open,
+    apply,
+    reject,
+    cancel,
+    reset
+  };
+}
+var STATUS_TONE = {
+  PROCESSING: "secondary",
+  PROPOSED: "default",
+  APPLIED: "default",
+  REJECTED: "outline",
+  STALE: "outline",
+  CANCELLED: "outline",
+  FAILED: "destructive"
+};
+function edgeLabel(edge) {
+  const from = edge.sourceHandle ? `${edge.source} (${edge.sourceHandle})` : edge.source;
+  return `${from} \u2192 ${edge.target}`;
+}
+function ChangeList({
+  title,
+  icon,
+  items,
+  testId
+}) {
+  if (items.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { "data-testid": testId, children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 text-xs font-medium uppercase tracking-wide text-text-secondary", children: [
+      /* @__PURE__ */ jsx(Icon, { icon, width: 14 }),
+      title,
+      " (",
+      items.length,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-primary", children: items.map((item) => /* @__PURE__ */ jsx("li", { className: "truncate", children: item }, item)) })
+  ] });
+}
+function nodeLine(node, withFields) {
+  const base = `${node.label} \xB7 ${node.type}`;
+  return withFields && node.fields.length > 0 ? `${base} \u2014 ${node.fields.join(", ")}` : base;
+}
+function visibleErrors(errors, shownMessage) {
+  const shown = normalise(shownMessage ?? "");
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const error of errors) {
+    const key = normalise(error);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    if (shown && shown.includes(key)) continue;
+    result.push(error);
+  }
+  return result;
+}
+function normalise(text) {
+  return text.trim().toLowerCase().replace(/^[\s.:;,]+|[\s.:;,]+$/g, "");
+}
+function WorkflowProposalCard({
+  proposal,
+  isDeciding = false,
+  onOpenWorkflow,
+  onApply,
+  onReject,
+  onCancel,
+  onRevert
+}) {
+  const tr = useTr();
+  const status = String(proposal.status);
+  const diff = proposal.diff;
+  const warnings = proposal.validation?.warnings ?? [];
+  const showMessage = Boolean(
+    proposal.message && status !== "PROPOSED" && status !== "PROCESSING" && status !== "APPLIED"
+  );
+  const errors = visibleErrors(
+    proposal.validation?.valid === false ? proposal.validation.errors : [],
+    showMessage ? proposal.message : null
+  );
+  const revertTarget = proposal.baseVersion && proposal.workflowKey && proposal.appliedWorkflowKey === proposal.workflowKey ? { workflowKey: proposal.workflowKey, version: proposal.baseVersion } : null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "workflow-proposal-card",
+      "data-status": status,
+      children: [
+        /* @__PURE__ */ jsxs("header", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:creation-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: proposal.name ?? tr("fluidgrids.ai.proposal.title", "AI proposal") }),
+          /* @__PURE__ */ jsx(
+            Badge,
+            {
+              variant: STATUS_TONE[status] ?? "outline",
+              "data-testid": "workflow-proposal-status",
+              children: status
+            }
+          ),
+          proposal.baseVersion && /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.ai.proposal.against",
+            "against version {{version}}",
+            {
+              version: proposal.baseVersion
+            }
+          ) })
+        ] }),
+        status === "PROCESSING" && /* @__PURE__ */ jsxs("div", { className: "mt-3 flex items-center gap-2 text-sm text-text-secondary", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:loading", width: 16, className: "animate-spin" }),
+          tr("fluidgrids.ai.proposal.working", "Working ({{stage}})\u2026", {
+            stage: proposal.progress?.stage ?? "prompting"
+          }),
+          onCancel && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "ghost",
+              onClick: onCancel,
+              disabled: isDeciding,
+              children: tr("fluidgrids.ai.proposal.cancel", "Cancel")
+            }
+          )
+        ] }),
+        proposal.explanation && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-3 text-sm text-text-primary",
+            "data-testid": "workflow-proposal-explanation",
+            children: proposal.explanation
+          }
+        ),
+        showMessage && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-2 text-sm text-text-secondary",
+            "data-testid": "workflow-proposal-message",
+            children: proposal.message
+          }
+        ),
+        diff && /* @__PURE__ */ jsxs("div", { className: "mt-3 space-y-2", "data-testid": "workflow-proposal-diff", children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: diff.summary }),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-added",
+              icon: "mdi:plus-circle-outline",
+              title: tr("fluidgrids.ai.proposal.added", "Added nodes"),
+              items: diff.addedNodes.map((node) => nodeLine(node, false))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-changed",
+              icon: "mdi:pencil-circle-outline",
+              title: tr("fluidgrids.ai.proposal.changed", "Changed nodes"),
+              items: diff.changedNodes.map((node) => nodeLine(node, true))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-removed",
+              icon: "mdi:minus-circle-outline",
+              title: tr("fluidgrids.ai.proposal.removed", "Removed nodes"),
+              items: diff.removedNodes.map((node) => nodeLine(node, false))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-edges",
+              icon: "mdi:vector-line",
+              title: tr(
+                "fluidgrids.ai.proposal.connections",
+                "Connection changes"
+              ),
+              items: [
+                ...diff.addedEdges.map((edge) => `+ ${edgeLabel(edge)}`),
+                ...diff.removedEdges.map((edge) => `\u2212 ${edgeLabel(edge)}`)
+              ]
+            }
+          )
+        ] }),
+        errors.length > 0 && /* @__PURE__ */ jsx(
+          "ul",
+          {
+            className: "mt-3 space-y-1 text-sm text-[var(--color-status-error-text)]",
+            "data-testid": "workflow-proposal-errors",
+            children: errors.map((message) => /* @__PURE__ */ jsx("li", { children: message }, message))
+          }
+        ),
+        warnings.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-3", "data-testid": "workflow-proposal-warnings", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-xs font-medium uppercase tracking-wide text-text-secondary", children: tr("fluidgrids.ai.proposal.todo", "Still to set up") }),
+          /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-secondary", children: warnings.map((warning) => /* @__PURE__ */ jsx("li", { children: warning }, warning)) })
+        ] }),
+        status === "PROPOSED" && (onApply || onReject) && /* @__PURE__ */ jsxs("div", { className: "mt-4 flex flex-wrap items-center gap-2", children: [
+          onApply && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              onClick: onApply,
+              disabled: isDeciding,
+              "data-testid": "workflow-proposal-apply",
+              children: proposal.baseVersion ? tr(
+                "fluidgrids.ai.proposal.applyVersion",
+                "Apply as a new draft version"
+              ) : tr(
+                "fluidgrids.ai.proposal.applyNew",
+                "Create as a draft workflow"
+              )
+            }
+          ),
+          onReject && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: onReject,
+              disabled: isDeciding,
+              children: tr("fluidgrids.ai.proposal.reject", "Reject")
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.ai.proposal.neverActivates",
+            "Nothing goes live: the result is a draft you can review, run as a test and activate yourself."
+          ) })
+        ] }),
+        status === "APPLIED" && proposal.appliedWorkflowKey && proposal.appliedVersion && /* @__PURE__ */ jsxs("div", { className: "mt-4 space-y-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+            onOpenWorkflow && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                "data-testid": "workflow-proposal-open",
+                onClick: () => onOpenWorkflow(
+                  proposal.appliedWorkflowKey ?? "",
+                  proposal.appliedVersion ?? ""
+                ),
+                children: tr("fluidgrids.ai.proposal.open", "Open draft {{version}}", {
+                  version: proposal.appliedVersion
+                })
+              }
+            ),
+            onRevert && revertTarget && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "ghost",
+                "data-testid": "workflow-proposal-revert",
+                disabled: isDeciding,
+                onClick: () => onRevert(revertTarget.workflowKey, revertTarget.version),
+                children: tr(
+                  "fluidgrids.ai.proposal.revert",
+                  "Revert to {{version}}",
+                  { version: revertTarget.version }
+                )
+              }
+            )
+          ] }),
+          !onRevert && proposal.restoreHint && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: proposal.restoreHint })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/builder/lib/workflow-tests.ts
+var MAX_TEST_CASES = 50;
+var MAX_CASE_JSON_BYTES = 256 * 1024;
+var MAX_CASE_ENTRIES = 100;
+var MAX_CASE_NAME = 200;
+function emptyTestCaseDraft() {
+  return {
+    name: "",
+    description: "",
+    enabled: true,
+    expectedStatus: "COMPLETED" /* Completed */,
+    triggerNodeId: "",
+    triggerData: "{}",
+    pinnedOutputs: "{}",
+    connectionMocks: "[]",
+    expectations: "{}"
+  };
+}
+function pretty(value) {
+  return JSON.stringify(value, null, 2);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wireRule(rule) {
+  const wire = {
+    operator: operatorSpec(rule.operator)?.wire ?? String(rule.operator)
+  };
+  if (rule.path) wire.path = rule.path;
+  if (rule.expected !== null && rule.expected !== void 0)
+    wire.expected = rule.expected;
+  if (rule.min !== null && rule.min !== void 0) wire.min = rule.min;
+  if (rule.max !== null && rule.max !== void 0) wire.max = rule.max;
+  if (rule.message) wire.message = rule.message;
+  return wire;
+}
+function draftFromTestCase(testCase) {
+  const expectations = {};
+  for (const expectation of testCase.expectations)
+    expectations[expectation.nodeId] = expectation.rules.map(wireRule);
+  const mocks = testCase.connectionMocks.map((mock) => {
+    const entry = { nodeId: mock.nodeId };
+    if (mock.operation) entry.operation = mock.operation;
+    if (mock.error) {
+      entry.error = mock.error.errorType ? { message: mock.error.message, errorType: mock.error.errorType } : { message: mock.error.message };
+    } else {
+      entry.response = mock.response ?? {};
+    }
+    return entry;
+  });
+  return {
+    name: testCase.name,
+    description: testCase.description ?? "",
+    enabled: testCase.enabled,
+    expectedStatus: testCase.expectedStatus,
+    triggerNodeId: testCase.triggerNodeId ?? "",
+    triggerData: pretty(testCase.triggerData ?? {}),
+    pinnedOutputs: pretty(testCase.pinnedOutputs ?? {}),
+    connectionMocks: pretty(mocks),
+    expectations: pretty(expectations)
+  };
+}
+function pinnedOutputsFromCanvas(pinned) {
+  const outputs = {};
+  for (const [nodeId, entry] of Object.entries(pinned ?? {})) {
+    if (entry && isRecord(entry.data)) outputs[nodeId] = { data: entry.data };
+  }
+  return outputs;
+}
+function parseJson(text, field, label) {
+  const source = text.trim();
+  if (source === "") return { value: void 0 };
+  try {
+    return { value: JSON.parse(source) };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      error: {
+        field,
+        key: "fluidgrids.builder.workflowTests.invalidJson",
+        fallback: `${label} is not valid JSON: ${reason}`
+      }
+    };
+  }
+}
+function fieldError(field, key, fallback) {
+  return {
+    error: { field, key: `fluidgrids.builder.workflowTests.${key}`, fallback }
+  };
+}
+function parseTriggerData(text) {
+  const parsed = parseJson(text, "triggerData", "Trigger data");
+  if ("error" in parsed) return parsed;
+  if (parsed.value === void 0) return { value: {} };
+  if (!isRecord(parsed.value))
+    return fieldError(
+      "triggerData",
+      "triggerDataShape",
+      "Trigger data must be a JSON object."
+    );
+  return { value: parsed.value };
+}
+function parsePinnedOutputs(text) {
+  const parsed = parseJson(text, "pinnedOutputs", "Pinned outputs");
+  if ("error" in parsed) return parsed;
+  if (parsed.value === void 0) return { value: {} };
+  if (!isRecord(parsed.value))
+    return fieldError(
+      "pinnedOutputs",
+      "pinnedShape",
+      'Pinned outputs must be an object of { "nodeId": { "data": { ... } } }.'
+    );
+  const entries = Object.entries(parsed.value);
+  if (entries.length > MAX_CASE_ENTRIES)
+    return fieldError(
+      "pinnedOutputs",
+      "pinnedTooMany",
+      `At most ${MAX_CASE_ENTRIES} pinned nodes.`
+    );
+  const outputs = {};
+  for (const [nodeId, entry] of entries) {
+    if (!isRecord(entry) || !isRecord(entry.data))
+      return fieldError(
+        "pinnedOutputs",
+        "pinnedShape",
+        `Pinned output "${nodeId}" must be { "data": { ... } }.`
+      );
+    outputs[nodeId] = { data: entry.data };
+  }
+  return { value: outputs };
+}
+var ERROR_TYPES = new Set(Object.values(ErrorType));
+function isErrorType(value) {
+  return ERROR_TYPES.has(value);
+}
+function parseConnectionMocks(text) {
+  const parsed = parseJson(text, "connectionMocks", "Connection mocks");
+  if ("error" in parsed) return parsed;
+  if (parsed.value === void 0) return { value: [] };
+  if (!Array.isArray(parsed.value))
+    return fieldError(
+      "connectionMocks",
+      "mocksShape",
+      'Connection mocks must be an array of { "nodeId", "response" } or { "nodeId", "error" }.'
+    );
+  if (parsed.value.length > MAX_CASE_ENTRIES)
+    return fieldError(
+      "connectionMocks",
+      "mocksTooMany",
+      `At most ${MAX_CASE_ENTRIES} connection mocks.`
+    );
+  const mocks = [];
+  for (const [index, raw] of parsed.value.entries()) {
+    const at = `Mock ${index + 1}`;
+    if (!isRecord(raw) || typeof raw.nodeId !== "string" || !raw.nodeId)
+      return fieldError(
+        "connectionMocks",
+        "mockNodeRequired",
+        `${at} needs a "nodeId".`
+      );
+    if (raw.operation !== void 0 && raw.operation !== null && typeof raw.operation !== "string")
+      return fieldError(
+        "connectionMocks",
+        "mockOperationInvalid",
+        `${at}: "operation" must be text.`
+      );
+    const hasResponse = raw.response !== void 0 && raw.response !== null;
+    const hasError = raw.error !== void 0 && raw.error !== null;
+    if (hasResponse === hasError)
+      return fieldError(
+        "connectionMocks",
+        "mockResponseOrError",
+        `${at} must set exactly one of "response" and "error".`
+      );
+    const mock = { nodeId: raw.nodeId };
+    if (typeof raw.operation === "string" && raw.operation)
+      mock.operation = raw.operation;
+    if (hasResponse) {
+      mock.response = jsonScalar(raw.response);
+    } else {
+      const error = raw.error;
+      if (!isRecord(error) || typeof error.message !== "string")
+        return fieldError(
+          "connectionMocks",
+          "mockErrorShape",
+          `${at}: "error" must be { "message": "...", "errorType"?: "..." }.`
+        );
+      const errorType = error.errorType;
+      if (errorType !== void 0 && errorType !== null) {
+        if (typeof errorType !== "string" || !isErrorType(errorType))
+          return fieldError(
+            "connectionMocks",
+            "mockErrorType",
+            `${at}: "errorType" must be one of ${[...ERROR_TYPES].join(", ")}.`
+          );
+        mock.error = { message: error.message, errorType };
+      } else {
+        mock.error = { message: error.message };
+      }
+    }
+    mocks.push(mock);
+  }
+  return { value: mocks };
+}
+function jsonScalar(value) {
+  return value;
+}
+function ruleInput(rule) {
+  const spec = operatorSpec(rule.operator);
+  if (!spec) return [];
+  const input = { operator: spec.value };
+  if (rule.path !== void 0) input.path = rule.path;
+  if (rule.expected !== void 0) input.expected = jsonScalar(rule.expected);
+  if (rule.min !== void 0) input.min = rule.min;
+  if (rule.max !== void 0) input.max = rule.max;
+  if (rule.message !== void 0) input.message = rule.message;
+  return [input];
+}
+function expectationEntries(value) {
+  if (isRecord(value)) return Object.entries(value);
+  if (Array.isArray(value)) {
+    const entries = [];
+    for (const item of value) {
+      if (!isRecord(item)) return null;
+      entries.push([item.nodeId, item.rules]);
+    }
+    return entries;
+  }
+  return null;
+}
+function parseExpectations(text) {
+  const parsed = parseJson(text, "expectations", "Expectations");
+  if ("error" in parsed) return parsed;
+  if (parsed.value === void 0) return { value: [] };
+  const entries = expectationEntries(parsed.value);
+  if (!entries)
+    return fieldError(
+      "expectations",
+      "expectationsShape",
+      'Expectations must be an object of { "nodeId": [rules] }.'
+    );
+  if (entries.length > MAX_CASE_ENTRIES)
+    return fieldError(
+      "expectations",
+      "expectationsTooMany",
+      `At most ${MAX_CASE_ENTRIES} checked nodes.`
+    );
+  const expectations = [];
+  for (const [nodeId, rules] of entries) {
+    if (typeof nodeId !== "string" || !nodeId || !Array.isArray(rules))
+      return fieldError(
+        "expectations",
+        "expectationsShape",
+        'Expectations must be an object of { "nodeId": [rules] }.'
+      );
+    const result = normaliseAssertRules(rules);
+    if ("problem" in result) {
+      const problem = describeAssertRuleProblem(result.problem);
+      return {
+        error: {
+          field: "expectations",
+          key: problem.key,
+          fallback: `${nodeId}: ${problem.fallback}`
+        }
+      };
+    }
+    expectations.push({ nodeId, rules: result.rules.flatMap(ruleInput) });
+  }
+  return { value: expectations };
+}
+function draftToInput(draft, sortOrder) {
+  const name = draft.name.trim();
+  if (!name)
+    return fieldError("name", "nameRequired", "Give the test case a name.");
+  if (name.length > MAX_CASE_NAME)
+    return fieldError(
+      "name",
+      "nameTooLong",
+      `A name may have at most ${MAX_CASE_NAME} characters.`
+    );
+  const triggerData = parseTriggerData(draft.triggerData);
+  if ("error" in triggerData) return triggerData;
+  const pinnedOutputs = parsePinnedOutputs(draft.pinnedOutputs);
+  if ("error" in pinnedOutputs) return pinnedOutputs;
+  const connectionMocks = parseConnectionMocks(draft.connectionMocks);
+  if ("error" in connectionMocks) return connectionMocks;
+  const expectations = parseExpectations(draft.expectations);
+  if ("error" in expectations) return expectations;
+  const bytes = new TextEncoder().encode(
+    JSON.stringify([
+      triggerData.value,
+      pinnedOutputs.value,
+      connectionMocks.value,
+      expectations.value
+    ])
+  ).length;
+  if (bytes > MAX_CASE_JSON_BYTES)
+    return fieldError(
+      "size",
+      "tooLarge",
+      `The case holds ${Math.ceil(bytes / 1024)} KiB of JSON; the limit is ${MAX_CASE_JSON_BYTES / 1024} KiB.`
+    );
+  const description = draft.description.trim();
+  const input = {
+    name,
+    description: description || null,
+    triggerNodeId: draft.triggerNodeId || null,
+    triggerData: triggerData.value,
+    pinnedOutputs: pinnedOutputs.value,
+    connectionMocks: connectionMocks.value,
+    expectedStatus: draft.expectedStatus,
+    expectations: expectations.value,
+    enabled: draft.enabled
+  };
+  if (sortOrder !== void 0) input.sortOrder = sortOrder;
+  return { input };
+}
+function isTestRunOpen(status) {
+  return status === "PENDING" /* Pending */ || status === "RUNNING" /* Running */;
+}
+function testStatusTone(status) {
+  switch (status) {
+    case "PASSED" /* Passed */:
+      return "success";
+    case "FAILED" /* Failed */:
+      return "error";
+    case "ERROR" /* Error */:
+      return "warning";
+    default:
+      return "pending";
+  }
+}
+var TEST_STATUS_TONE_CLASS = {
+  success: "border-[var(--color-status-success-border)] bg-[var(--color-status-success-bg-subtle)] text-[var(--color-status-success-text)]",
+  error: "border-[var(--color-status-error-border)] bg-[var(--color-status-error-bg-subtle)] text-[var(--color-status-error-text)]",
+  warning: "border-[var(--color-status-warning-border)] bg-[var(--color-status-warning-bg-subtle)] text-[var(--color-status-warning-text)]",
+  pending: "border-border bg-muted text-muted-foreground"
+};
+function testStatusLabel(status) {
+  const fallback = {
+    ["PENDING" /* Pending */]: "Pending",
+    ["RUNNING" /* Running */]: "Running",
+    ["PASSED" /* Passed */]: "Passed",
+    ["FAILED" /* Failed */]: "Failed",
+    ["ERROR" /* Error */]: "Error"
+  };
+  return {
+    key: `fluidgrids.builder.workflowTests.status.${status.toLowerCase()}`,
+    fallback: fallback[status]
+  };
+}
+function testRunSummaryText(summary) {
+  const parts = [`${summary.passed} passed`];
+  if (summary.failed) parts.push(`${summary.failed} failed`);
+  if (summary.errored) parts.push(`${summary.errored} errored`);
+  if (summary.pending) parts.push(`${summary.pending} running`);
+  return `${parts.join(" \xB7 ")} of ${summary.total}`;
+}
+function enabledCaseIds(cases) {
+  return cases.filter((testCase) => testCase.enabled).map((c) => c.id);
+}
+function nextSortOrder(cases) {
+  return cases.reduce((max, c) => Math.max(max, c.sortOrder + 1), 0);
+}
+var SAVEABLE_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "COMPLETED",
+  "FAILED"
+]);
+function canSaveRunAsTestCase(run) {
+  return SAVEABLE_RUN_STATUSES.has(run.status) && !!run.workflowKey && !run.isDurable;
+}
+var TEST_RUN_POLL_INTERVAL_MS = 2e3;
+var TEST_RUN_HISTORY_LIMIT = 10;
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function upsertRun(runs, run) {
+  return [run, ...runs.filter((item) => item.id !== run.id)].slice(
+    0,
+    TEST_RUN_HISTORY_LIMIT
+  );
+}
+function useWorkflowTests(workflowKey, enabled) {
+  const [cases, setCases] = useState([]);
+  const [runs, setRuns] = useState([]);
+  const [activeRunId, setActiveRunId] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [forbidden, setForbidden] = useState(false);
+  const [pollTick, setPollTick] = useState(0);
+  const keyRef = useRef(workflowKey);
+  const refetch = useCallback(async () => {
+    if (!enabled || !workflowKey) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const [caseResult, runResult] = await Promise.all([
+        client.query({
+          query: WorkflowTestCasesDocument,
+          variables: { workflowKey },
+          fetchPolicy: "network-only"
+        }),
+        client.query({
+          query: WorkflowTestRunsDocument,
+          variables: { workflowKey, limit: TEST_RUN_HISTORY_LIMIT },
+          fetchPolicy: "network-only"
+        })
+      ]);
+      throwIfResultError(caseResult);
+      throwIfResultError(runResult);
+      if (keyRef.current !== workflowKey) return;
+      setCases(caseResult.data?.workflowTestCases ?? []);
+      setRuns(runResult.data?.workflowTestRuns ?? []);
+      setForbidden(false);
+    } catch (err) {
+      if (keyRef.current !== workflowKey) return;
+      if (isForbiddenError(err)) setForbidden(true);
+      else setError(messageOf2(err));
+    } finally {
+      if (keyRef.current === workflowKey) setLoading(false);
+    }
+  }, [enabled, workflowKey]);
+  useEffect(() => {
+    keyRef.current = workflowKey;
+    setCases([]);
+    setRuns([]);
+    setActiveRunId(null);
+    setForbidden(false);
+    setError(null);
+  }, [workflowKey]);
+  const activeRun = (activeRunId ? runs.find((run) => run.id === activeRunId) : runs[0]) ?? null;
+  const followedId = activeRun && isTestRunOpen(activeRun.status) ? activeRun.id : null;
+  useEffect(() => {
+    if (!enabled || !followedId) return;
+    let cancelled = false;
+    const key = workflowKey;
+    const timer = setTimeout(() => {
+      void (async () => {
+        try {
+          const result = await getFluidGridsClient().query({
+            query: WorkflowTestRunDocument,
+            variables: { id: followedId },
+            fetchPolicy: "network-only"
+          });
+          throwIfResultError(result);
+          const run = result.data?.workflowTestRun;
+          if (cancelled || keyRef.current !== key || !run) return;
+          setRuns((current) => upsertRun(current, run));
+          if (!isTestRunOpen(run.status)) await refetchCases(key);
+        } catch (err) {
+          if (!cancelled && keyRef.current === key) setError(messageOf2(err));
+        } finally {
+          if (!cancelled) setPollTick((tick) => tick + 1);
+        }
+      })();
+    }, TEST_RUN_POLL_INTERVAL_MS);
+    async function refetchCases(forKey) {
+      const result = await getFluidGridsClient().query({
+        query: WorkflowTestCasesDocument,
+        variables: { workflowKey: forKey },
+        fetchPolicy: "network-only"
+      });
+      throwIfResultError(result);
+      if (!cancelled && keyRef.current === forKey)
+        setCases(result.data?.workflowTestCases ?? []);
+    }
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [enabled, followedId, workflowKey, pollTick]);
+  const createCase = useCallback(
+    async (input) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: CreateWorkflowTestCaseDocument,
+        variables: { workflowKey, input }
+      });
+      throwIfResultError(result);
+      const created = result.data?.createWorkflowTestCase;
+      if (!created) throw new Error("The test case was not saved.");
+      await refetch();
+      return created;
+    },
+    [workflowKey, refetch]
+  );
+  const updateCase = useCallback(
+    async (id, input) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: UpdateWorkflowTestCaseDocument,
+        variables: { id, input }
+      });
+      throwIfResultError(result);
+      const updated = result.data?.updateWorkflowTestCase;
+      if (!updated) throw new Error("The test case was not saved.");
+      await refetch();
+      return updated;
+    },
+    [refetch]
+  );
+  const deleteCase = useCallback(
+    async (id) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: DeleteWorkflowTestCaseDocument,
+        variables: { id }
+      });
+      throwIfResultError(result);
+      await refetch();
+    },
+    [refetch]
+  );
+  const runTests = useCallback(
+    async (options = {}) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: RunWorkflowTestsDocument,
+        variables: {
+          input: {
+            workflowKey,
+            source: "UI" /* Ui */,
+            ...options.version ? { version: options.version } : {},
+            ...options.caseIds ? { caseIds: options.caseIds } : {}
+          }
+        }
+      });
+      throwIfResultError(result);
+      const run = result.data?.runWorkflowTests;
+      if (!run) throw new Error("The test run did not start.");
+      setRuns((current) => upsertRun(current, run));
+      setActiveRunId(run.id);
+      return run;
+    },
+    [workflowKey]
+  );
+  return {
+    cases,
+    runs,
+    activeRun,
+    loading,
+    error,
+    forbidden,
+    refetch,
+    createCase,
+    updateCase,
+    deleteCase,
+    runTests
+  };
+}
+async function saveRunAsTestCase(runId, name, description) {
+  const result = await getFluidGridsClient().mutate({
+    mutation: CreateWorkflowTestCaseFromRunDocument,
+    variables: {
+      runId,
+      name,
+      ...description ? { description } : {}
+    }
+  });
+  throwIfResultError(result);
+  const created = result.data?.createWorkflowTestCaseFromRun;
+  if (!created) throw new Error("The test case was not saved.");
+  return created;
+}
+
+export { EntityTagPicker, MAX_CASE_NAME, MAX_TEST_CASES, TEST_STATUS_TONE_CLASS, WorkflowProposalCard, canSaveRunAsTestCase, draftFromTestCase, draftToInput, emptyTestCaseDraft, enabledCaseIds, isTestRunOpen, nextSortOrder, pinnedOutputsFromCanvas, saveRunAsTestCase, testRunSummaryText, testStatusLabel, testStatusTone, useWorkflowProposal, useWorkflowTests };