@burdenoff/fluidgrids-fe-sdk 2026.1031.4 → 2026.1031.6

package/dist/{chunk-ADTEMSJI.js → chunk-GMVXPC5N.js}

@@ -1,8 +1,9 @@
-import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-INMYNHJL.js';
+import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-TVOXRODW.js';
 import { notifyFluidGridsAiCreditsUpdated } from './chunk-Y53CVZVV.js';
-import { throwIfResultError, describeOperationError, signalPayloadCard, components_default, payloadFromCardValues, parseRawSignalPayload } from './chunk-6PGLJWIC.js';
+import { ErrorType } from './chunk-HQX7JZLY.js';
+import { throwIfResultError, describeOperationError, signalPayloadCard, components_default, isForbiddenError, payloadFromCardValues, parseRawSignalPayload } from './chunk-EPYTVCYH.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
-import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-AW3UXMNI.js';
+import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument, WorkflowTestCasesDocument, WorkflowTestRunsDocument, WorkflowTestRunDocument, CreateWorkflowTestCaseDocument, UpdateWorkflowTestCaseDocument, DeleteWorkflowTestCaseDocument, RunWorkflowTestsDocument, CreateWorkflowTestCaseFromRunDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-KEYKB4E7.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
@@ -1780,4 +1781,848 @@ function WorkflowProposalCard({
   );
 }
 
-export { EntityTagPicker, RunHistoryView, SignalRunDialog, WorkflowProposalCard, terminateDurableRun, useDeterminismStatus, useDurableRunFields, useRunHistory, useRunStackTrace, useWorkflowProposal };
+// src/builder/lib/assert-rules.ts
+var ASSERT_OPERATORS = [
+  {
+    wire: "equals",
+    value: "EQUALS" /* Equals */,
+    operand: "expected",
+    label: "equals"
+  },
+  {
+    wire: "notEquals",
+    value: "NOT_EQUALS" /* NotEquals */,
+    operand: "expected",
+    label: "does not equal"
+  },
+  {
+    wire: "contains",
+    value: "CONTAINS" /* Contains */,
+    operand: "expected",
+    label: "contains"
+  },
+  {
+    wire: "notContains",
+    value: "NOT_CONTAINS" /* NotContains */,
+    operand: "expected",
+    label: "does not contain"
+  },
+  {
+    wire: "matches",
+    value: "MATCHES" /* Matches */,
+    operand: "expected",
+    label: "matches regex"
+  },
+  {
+    wire: "jsonSchema",
+    value: "JSON_SCHEMA" /* JsonSchema */,
+    operand: "expected",
+    label: "matches JSON Schema"
+  },
+  {
+    wire: "between",
+    value: "BETWEEN" /* Between */,
+    operand: "range",
+    label: "is between"
+  },
+  {
+    wire: "itemCount",
+    value: "ITEM_COUNT" /* ItemCount */,
+    operand: "range",
+    label: "has item count"
+  },
+  {
+    wire: "exists",
+    value: "EXISTS" /* Exists */,
+    operand: "none",
+    label: "exists"
+  },
+  {
+    wire: "notExists",
+    value: "NOT_EXISTS" /* NotExists */,
+    operand: "none",
+    label: "does not exist"
+  }
+];
+var MAX_REGEX_LENGTH = 500;
+var MAX_RULES = 50;
+function operatorSpec(value) {
+  if (typeof value !== "string") return null;
+  return ASSERT_OPERATORS.find(
+    (spec) => spec.wire === value || spec.value === value
+  ) ?? null;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalNumber(value) {
+  if (value === void 0 || value === null) return void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : false;
+}
+function normaliseAssertRule(raw, index) {
+  if (!isRecord2(raw)) return { problem: { code: "notObject", index } };
+  const spec = operatorSpec(raw.operator);
+  if (!spec)
+    return {
+      problem: {
+        code: "unknownOperator",
+        index,
+        operator: String(raw.operator ?? "")
+      }
+    };
+  const rule = { operator: spec.wire };
+  if (raw.path !== void 0 && raw.path !== null && raw.path !== "") {
+    if (typeof raw.path !== "string")
+      return { problem: { code: "pathInvalid", index } };
+    rule.path = raw.path;
+  }
+  if (raw.message !== void 0 && raw.message !== null && raw.message !== "") {
+    if (typeof raw.message !== "string")
+      return { problem: { code: "messageInvalid", index } };
+    rule.message = raw.message;
+  }
+  if (spec.operand === "expected") {
+    if (!("expected" in raw))
+      return { problem: { code: "expectedRequired", index } };
+    if (spec.wire === "matches") {
+      if (typeof raw.expected !== "string")
+        return { problem: { code: "regexInvalid", index } };
+      if (raw.expected.length > MAX_REGEX_LENGTH)
+        return { problem: { code: "regexTooLong", index } };
+      try {
+        new RegExp(raw.expected);
+      } catch {
+        return { problem: { code: "regexInvalid", index } };
+      }
+    }
+    if (spec.wire === "jsonSchema" && !isRecord2(raw.expected))
+      return { problem: { code: "schemaInvalid", index } };
+    rule.expected = raw.expected;
+  }
+  if (spec.operand === "range") {
+    const min = optionalNumber(raw.min);
+    const max = optionalNumber(raw.max);
+    if (min === false || max === false)
+      return { problem: { code: "rangeInvalid", index } };
+    if (min === void 0 && max === void 0)
+      return { problem: { code: "rangeRequired", index } };
+    if (min !== void 0 && max !== void 0 && min > max)
+      return { problem: { code: "rangeInvalid", index } };
+    if (min !== void 0) rule.min = min;
+    if (max !== void 0) rule.max = max;
+  }
+  return { rule };
+}
+function normaliseAssertRules(raw) {
+  if (raw.length === 0) return { problem: { code: "empty" } };
+  if (raw.length > MAX_RULES)
+    return { problem: { code: "tooMany", count: raw.length } };
+  const rules = [];
+  for (const [index, item] of raw.entries()) {
+    const result = normaliseAssertRule(item, index);
+    if ("problem" in result) return result;
+    rules.push(result.rule);
+  }
+  return { rules };
+}
+function describeAssertRuleProblem(problem) {
+  const at = "index" in problem ? `Rule ${problem.index + 1}: ` : "";
+  switch (problem.code) {
+    case "notObject":
+      return {
+        key: "fluidgrids.builder.assertRules.notObject",
+        fallback: `${at}a rule must be an object.`
+      };
+    case "unknownOperator":
+      return {
+        key: "fluidgrids.builder.assertRules.unknownOperator",
+        fallback: `${at}unknown operator "${problem.operator}". Use ${ASSERT_OPERATORS.map((spec) => spec.wire).join(", ")}.`
+      };
+    case "expectedRequired":
+      return {
+        key: "fluidgrids.builder.assertRules.expectedRequired",
+        fallback: `${at}this operator needs an expected value.`
+      };
+    case "rangeRequired":
+      return {
+        key: "fluidgrids.builder.assertRules.rangeRequired",
+        fallback: `${at}set a minimum, a maximum or both.`
+      };
+    case "rangeInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.rangeInvalid",
+        fallback: `${at}minimum and maximum must be numbers, with the minimum not above the maximum.`
+      };
+    case "regexInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.regexInvalid",
+        fallback: `${at}the expected value is not a valid regular expression.`
+      };
+    case "regexTooLong":
+      return {
+        key: "fluidgrids.builder.assertRules.regexTooLong",
+        fallback: `${at}a regular expression may have at most ${MAX_REGEX_LENGTH} characters.`
+      };
+    case "schemaInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.schemaInvalid",
+        fallback: `${at}the expected value must be a JSON Schema object.`
+      };
+    case "pathInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.pathInvalid",
+        fallback: `${at}the path must be text.`
+      };
+    case "messageInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.messageInvalid",
+        fallback: `${at}the message must be text.`
+      };
+    case "tooMany":
+      return {
+        key: "fluidgrids.builder.assertRules.tooMany",
+        fallback: `At most ${MAX_RULES} rules (found ${problem.count}).`
+      };
+    case "empty":
+      return {
+        key: "fluidgrids.builder.assertRules.empty",
+        fallback: "Add at least one rule."
+      };
+  }
+}
+function readAssertRulesSetting(value) {
+  if (value === void 0 || value === null || value === "") return [];
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function emptyAssertRuleRow() {
+  return {
+    path: "",
+    operator: "equals",
+    expected: "",
+    min: "",
+    max: "",
+    message: ""
+  };
+}
+function rowNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+}
+function rowExpected(operator, value) {
+  if (value === void 0) return "";
+  if (operator === "matches" && typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function rowsFromRules(rules) {
+  return rules.map((raw) => {
+    const rule = isRecord2(raw) ? raw : {};
+    const operator = operatorSpec(rule.operator)?.wire ?? (typeof rule.operator === "string" ? rule.operator : "equals");
+    return {
+      path: typeof rule.path === "string" ? rule.path : "",
+      operator,
+      expected: rowExpected(operator, rule.expected),
+      min: rowNumber(rule.min),
+      max: rowNumber(rule.max),
+      message: typeof rule.message === "string" ? rule.message : ""
+    };
+  });
+}
+function parseExpected(operator, text) {
+  if (operator === "matches") return text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function parseRowNumber(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") return void 0;
+  const value = Number(trimmed);
+  return Number.isFinite(value) ? value : trimmed;
+}
+function ruleFromRow(row) {
+  const spec = operatorSpec(row.operator);
+  const rule = { operator: row.operator };
+  if (row.path.trim()) rule.path = row.path.trim();
+  if (spec?.operand === "expected" && (row.expected !== "" || spec.wire === "matches"))
+    rule.expected = parseExpected(spec.wire, row.expected);
+  if (spec?.operand === "range") {
+    const min = parseRowNumber(row.min);
+    const max = parseRowNumber(row.max);
+    if (min !== void 0) rule.min = min;
+    if (max !== void 0) rule.max = max;
+  }
+  if (row.message.trim()) rule.message = row.message.trim();
+  return rule;
+}
+
+// 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 isRecord3(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 && isRecord3(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 (!isRecord3(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 (!isRecord3(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 (!isRecord3(entry) || !isRecord3(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 (!isRecord3(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 (!isRecord3(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 (isRecord3(value)) return Object.entries(value);
+  if (Array.isArray(value)) {
+    const entries = [];
+    for (const item of value) {
+      if (!isRecord3(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 { ASSERT_OPERATORS, EntityTagPicker, MAX_CASE_NAME, MAX_TEST_CASES, RunHistoryView, SignalRunDialog, TEST_STATUS_TONE_CLASS, WorkflowProposalCard, canSaveRunAsTestCase, describeAssertRuleProblem, draftFromTestCase, draftToInput, emptyAssertRuleRow, emptyTestCaseDraft, enabledCaseIds, isTestRunOpen, nextSortOrder, normaliseAssertRules, operatorSpec, pinnedOutputsFromCanvas, readAssertRulesSetting, rowsFromRules, ruleFromRow, saveRunAsTestCase, terminateDurableRun, testRunSummaryText, testStatusLabel, testStatusTone, useDeterminismStatus, useDurableRunFields, useRunHistory, useRunStackTrace, useWorkflowProposal, useWorkflowTests };