@burdenoff/fluidgrids-fe-sdk 2026.1113.1 → 2026.1113.2

package/dist/WorkflowProposalCard-DGMdZC4R.js

@@ -1,1432 +0,0 @@
-"use client";
-import { _ as throwIfResultError, h as isForbiddenError, n as getFluidGridsClient, r as getFluidGridsClientSafe } from "./client-C9XSzSXr.js";
-import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
-import { $t as RejectWorkflowProposalDocument, En as RunWorkflowTestsDocument, Jt as ProposeWorkflowChangeDocument, Q as DeleteWorkflowTestCaseDocument, R as CreateWorkflowTestCaseDocument, Si as WorkflowTestRunsDocument, Yr as WorkflowProposalDocument, bi as WorkflowTestRunDocument, l as ApplyWorkflowProposalDocument, mr as UpdateWorkflowTestCaseDocument, qt as ProposeRunFixDocument, s as AgentTokenDeltaDocument, w as CancelWorkflowProposalDocument, yi as WorkflowTestCasesDocument, z as CreateWorkflowTestCaseFromRunDocument } from "./graphql-operation-types-C9qbvRa8.js";
-import { MI as WorkflowTestExpectedStatus, NI as WorkflowTestRunSource, PI as WorkflowTestRunStatus, jI as WorkflowTestAssertionOperator, jd as ErrorType } from "./graphql-types-v6CTGwA0.js";
-import { a as notifyFluidGridsAiCreditsUpdated } from "./aiCreditsBridge-BuE92tKo.js";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Icon } from "@iconify/react";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { Badge, Button } from "@burdenoff/fe-libs/ui";
-
-// src/modules/executions/utils/agent-token-stream.ts
-/** Longest reply kept per iteration; the PLAN step holds the full text. */
-const AGENT_TOKEN_STREAM_MAX_CHARS = 2e5;
-/** The key of one model turn: node execution and iteration. */
-function agentTokenStreamKey(delta) {
-	return `${delta.nodeId}|${delta.nodeStateId ?? ""}|${delta.iteration}`;
-}
-function capped(text) {
-	return text.length > 2e5 ? {
-		text: text.slice(0, AGENT_TOKEN_STREAM_MAX_CHARS),
-		truncated: true
-	} : {
-		text,
-		truncated: false
-	};
-}
-function isDelta(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const delta = value;
-	return typeof delta.nodeId === "string" && typeof delta.iteration === "number" && Number.isInteger(delta.iteration) && delta.iteration >= 0 && typeof delta.offset === "number" && Number.isInteger(delta.offset) && delta.offset >= 0 && typeof delta.delta === "string";
-}
-/** The text of a stream after one delta (see the module comment). */
-function applyText(current, delta) {
-	const before = current?.text ?? "";
-	if (delta.reset) return {
-		text: delta.delta,
-		gap: delta.offset > 0
-	};
-	if (delta.offset === before.length) return {
-		text: before + delta.delta,
-		gap: current?.gap ?? false
-	};
-	if (delta.offset < before.length) return {
-		text: before.slice(0, delta.offset) + delta.delta,
-		gap: current?.gap ?? false
-	};
-	return {
-		text: before + delta.delta,
-		gap: true
-	};
-}
-/**
-* `current` with a batch of deltas applied, in order. Returns `current` itself
-* when nothing in the batch was usable, so callers can skip a re-render.
-*/
-function applyAgentTokenDeltas(current, deltas, now = Date.now()) {
-	let next = null;
-	for (const raw of deltas) {
-		if (!isDelta(raw)) continue;
-		const nodeStateId = raw.nodeStateId ?? null;
-		const key = agentTokenStreamKey({
-			...raw,
-			nodeStateId
-		});
-		const held = (next ?? current).get(key);
-		if (held?.done && !raw.reset) continue;
-		next ??= new Map(current);
-		const { text, gap } = applyText(held, raw);
-		const limited = capped(text);
-		next.set(key, {
-			key,
-			runId: raw.runId,
-			nodeId: raw.nodeId,
-			nodeStateId,
-			iteration: raw.iteration,
-			text: limited.text,
-			done: raw.done === true,
-			error: typeof raw.error === "string" && raw.error.length > 0 ? raw.error : null,
-			gap,
-			truncated: limited.truncated || (held?.truncated ?? false),
-			order: held?.order ?? next.size,
-			updatedAt: now
-		});
-	}
-	return next ?? current;
-}
-/** The streams in the order they started (node execution, then iteration). */
-function sortedAgentTokenStreams(streams) {
-	return [...streams.values()].sort((a, b) => a.order - b.order);
-}
-/** The streams of one AI Agent node execution, by iteration. */
-function agentTokenStreamsFor(streams, nodeStateId, nodeId) {
-	return streams.filter((stream) => nodeStateId !== null && stream.nodeStateId !== null ? stream.nodeStateId === nodeStateId : stream.nodeId === nodeId).sort((a, b) => a.iteration - b.iteration);
-}
-/**
-* The state of a stream for the reader: a failed call, a finished one, one
-* still being written, or one the run stopped writing (cancelled, or the
-* worker went away) before the turn ended.
-*/
-function agentLiveReplyState(stream, runLive) {
-	if (stream.error) return "failed";
-	if (stream.done) return "done";
-	return runLive ? "streaming" : "stopped";
-}
-/**
-* The stream the builder's chat shows: the newest turn of the newest node
-* execution of an AI Agent node (`agentNodeIds`), or of any node when that set
-* is empty.
-*/
-function latestAgentTokenStream(streams, agentNodeIds) {
-	let latest = null;
-	for (const stream of streams.values()) {
-		if (agentNodeIds && agentNodeIds.size > 0) {
-			if (!agentNodeIds.has(stream.nodeId)) continue;
-		}
-		if (!latest || stream.order > latest.order) latest = stream;
-	}
-	return latest;
-}
-
-// src/modules/executions/hooks/useAgentTokenStream.ts
-/**
-* useAgentTokenStream — a run's AI Agent model replies while the model is
-* still writing them (BOFF-9938), for the run page's Agent tab and the
-* builder's chat panel.
-*
-* Subscribes to `agentTokenDelta(runId)` while `enabled`, and folds every
-* batch into one stream per model turn (node execution and iteration, see
-* `agent-token-stream.ts`). The stream carries no history: a turn that started
-* before the subscription opened shows only what arrives after. Turning
-* `enabled` off closes the subscription but keeps the streams already held,
-* so a reader can keep showing them until the step trace has the final text.
-* A different `runId` starts from nothing.
-*/
-const EMPTY_STREAMS = /* @__PURE__ */ new Map();
-/**
-* Follow a run's model replies: subscribe to `agentTokenDelta` and hand each
-* non-empty batch to `onDeltas`. Returns the function that closes the
-* subscription; nothing is called back after it ran. A failed or ended
-* subscription only reports `onStreaming(false)`: the step trace and the node
-* output still carry every reply, so the stream is an accelerator.
-*/
-function followAgentTokenDeltas(client, runId, { onDeltas, onStreaming }) {
-	let stopped = false;
-	const subscription = client.subscribe({
-		query: AgentTokenDeltaDocument,
-		variables: { runId }
-	}).subscribe({
-		next: ({ data }) => {
-			if (stopped) return;
-			onStreaming(true);
-			const deltas = data?.agentTokenDelta ?? [];
-			if (deltas.length > 0) onDeltas(deltas, Date.now());
-		},
-		error: () => {
-			if (!stopped) onStreaming(false);
-		},
-		complete: () => {
-			if (!stopped) onStreaming(false);
-		}
-	});
-	return () => {
-		stopped = true;
-		subscription.unsubscribe();
-		onStreaming(false);
-	};
-}
-function useAgentTokenStream(runId, { enabled }) {
-	const [state, setState] = useState(null);
-	const [streaming, setStreaming] = useState(false);
-	useEffect(() => {
-		const client = getFluidGridsClientSafe();
-		if (!runId || !enabled || !client) return void 0;
-		return followAgentTokenDeltas(client, runId, {
-			onStreaming: setStreaming,
-			onDeltas: (deltas, receivedAt) => setState((previous) => {
-				const held = previous?.runId === runId ? previous.streams : EMPTY_STREAMS;
-				const streams = applyAgentTokenDeltas(held, deltas, receivedAt);
-				if (streams === held && previous?.runId === runId) return previous;
-				return {
-					runId,
-					streams,
-					lastDeltaAt: receivedAt
-				};
-			})
-		});
-	}, [runId, enabled]);
-	const current = runId && state?.runId === runId ? state : null;
-	const byKey = current?.streams ?? EMPTY_STREAMS;
-	return {
-		streams: useMemo(() => sortedAgentTokenStreams(byKey), [byKey]),
-		byKey,
-		streaming: enabled && !!runId && streaming,
-		lastDeltaAt: current?.lastDeltaAt ?? null
-	};
-}
-
-// src/builder/lib/assert-rules.ts
-/** Every operator, in the order the editors offer them. */
-const ASSERT_OPERATORS = [
-	{
-		wire: "equals",
-		value: "EQUALS",
-		operand: "expected",
-		label: "equals"
-	},
-	{
-		wire: "notEquals",
-		value: "NOT_EQUALS",
-		operand: "expected",
-		label: "does not equal"
-	},
-	{
-		wire: "contains",
-		value: "CONTAINS",
-		operand: "expected",
-		label: "contains"
-	},
-	{
-		wire: "notContains",
-		value: "NOT_CONTAINS",
-		operand: "expected",
-		label: "does not contain"
-	},
-	{
-		wire: "matches",
-		value: "MATCHES",
-		operand: "expected",
-		label: "matches regex"
-	},
-	{
-		wire: "jsonSchema",
-		value: "JSON_SCHEMA",
-		operand: "expected",
-		label: "matches JSON Schema"
-	},
-	{
-		wire: "between",
-		value: "BETWEEN",
-		operand: "range",
-		label: "is between"
-	},
-	{
-		wire: "itemCount",
-		value: "ITEM_COUNT",
-		operand: "range",
-		label: "has item count"
-	},
-	{
-		wire: "exists",
-		value: "EXISTS",
-		operand: "none",
-		label: "exists"
-	},
-	{
-		wire: "notExists",
-		value: "NOT_EXISTS",
-		operand: "none",
-		label: "does not exist"
-	}
-];
-/** The service's cap on a `matches` pattern. */
-const MAX_REGEX_LENGTH = 500;
-/** Rules per node (Assert node or test-case expectation). */
-const MAX_RULES = 50;
-/**
-* The spec of an operator given in either spelling (`itemCount`,
-* `ITEM_COUNT`), or null when it is not one.
-*/
-function operatorSpec(value) {
-	if (typeof value !== "string") return null;
-	return ASSERT_OPERATORS.find((spec) => spec.wire === value || spec.value === value) ?? null;
-}
-function isRecord$1(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;
-}
-/**
-* Checks one rule and normalises it to the wire form, or reports the first
-* problem. `index` is the rule's position, for the message.
-*/
-function normaliseAssertRule(raw, index) {
-	if (!isRecord$1(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 > 500) return { problem: {
-				code: "regexTooLong",
-				index
-			} };
-			try {
-				new RegExp(raw.expected);
-			} catch {
-				return { problem: {
-					code: "regexInvalid",
-					index
-				} };
-			}
-		}
-		if (spec.wire === "jsonSchema" && !isRecord$1(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 };
-}
-/** Checks a list of rules (1 to {@link MAX_RULES}); the first problem wins. */
-function normaliseAssertRules(raw) {
-	if (raw.length === 0) return { problem: { code: "empty" } };
-	if (raw.length > 50) 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 };
-}
-/** An i18n key and its English fallback for a rule problem. */
-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 ${500} 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 ${50} rules (found ${problem.count}).`
-		};
-		case "empty": return {
-			key: "fluidgrids.builder.assertRules.empty",
-			fallback: "Add at least one rule."
-		};
-	}
-}
-/**
-* The rules held in an Assert node's `rules` setting. The manifest declares it
-* as text, so it is usually a JSON string; an array is accepted as well. A
-* value that does not parse yields null, so the editor can fall back to the
-* raw text instead of discarding it.
-*/
-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);
-}
-/** The editor rows of stored rules (either operator spelling). */
-function rowsFromRules(rules) {
-	return rules.map((raw) => {
-		const rule = isRecord$1(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;
-}
-/**
-* The stored form of an editor row. Only the operands its operator uses are
-* kept, so switching an operator does not leave a stale `expected` behind.
-*/
-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
-/**
-* Workflow test suites (BOFF-9960): the editable form of a saved test case,
-* its conversion to the GraphQL input, and the suite-status helpers the Tests
-* panel and "Save as test case" share.
-*
-* A person edits the JSON parts of a case as text. `draftToInput` parses and
-* checks them the way wspace-workflow-svc does (shapes, counts, the 256 KiB
-* cap) so a mistake shows next to its field instead of as a refused save. The
-* service still enforces every limit itself.
-*/
-/** JSON bytes per case (trigger data, pinned outputs, mocks, expectations). */
-const MAX_CASE_JSON_BYTES = 262144;
-/** Mocks, pinned nodes and checked nodes per case. */
-const MAX_CASE_ENTRIES = 100;
-/** Name length. */
-const MAX_CASE_NAME = 200;
-function emptyTestCaseDraft() {
-	return {
-		name: "",
-		description: "",
-		enabled: true,
-		expectedStatus: "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);
-}
-/** The rules of an expectation as the wire (and the editor) spells them. */
-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;
-}
-/** The editable form of a saved case. */
-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)
-	};
-}
-/**
-* The pinned outputs of the open canvas in the test-case shape, without the
-* pin metadata (`pinnedAt`, `pinnedBy`).
-*/
-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) {
-		return { error: {
-			field,
-			key: "fluidgrids.builder.workflowTests.invalidJson",
-			fallback: `${label} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
-		} };
-	}
-}
-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 > 100) return fieldError("pinnedOutputs", "pinnedTooMany", `At most ${100} 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 };
-}
-const 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 > 100) return fieldError("connectionMocks", "mocksTooMany", `At most ${100} 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;
-		if (hasResponse === (raw.error !== void 0 && raw.error !== null)) 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 };
-}
-/**
-* A JSON value for a GraphQL `JSON` field. Codegen maps the scalar to an
-* object type, but the service accepts any JSON value (a rule's `expected` is
-* often a string or a number, a mock's `response` an array), so the parsed
-* value is passed through unchanged.
-*/
-function jsonScalar(value) {
-	return value;
-}
-/** A normalised rule as the GraphQL input (UPPER_SNAKE operator). */
-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 > 100) return fieldError("expectations", "expectationsTooMany", `At most ${100} 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 };
-}
-/**
-* The GraphQL input for a draft, or the first problem found. Updating a case
-* replaces every field, so the whole input is always sent.
-*/
-function draftToInput(draft, sortOrder) {
-	const name = draft.name.trim();
-	if (!name) return fieldError("name", "nameRequired", "Give the test case a name.");
-	if (name.length > 200) return fieldError("name", "nameTooLong", `A name may have at most ${200} 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 > 262144) return fieldError("size", "tooLarge", `The case holds ${Math.ceil(bytes / 1024)} KiB of JSON; the limit is ${MAX_CASE_JSON_BYTES / 1024} KiB.`);
-	const input = {
-		name,
-		description: draft.description.trim() || 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 };
-}
-/** Whether a suite (or a case in it) is still running. */
-function isTestRunOpen(status) {
-	return status === "PENDING" || status === "RUNNING";
-}
-/** How a suite or case status is shown. */
-function testStatusTone(status) {
-	switch (status) {
-		case "PASSED": return "success";
-		case "FAILED": return "error";
-		case "ERROR": return "warning";
-		default: return "pending";
-	}
-}
-/** Semantic-token classes for a status tone. */
-const 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"
-};
-/** The i18n key and English label of a suite or case status. */
-function testStatusLabel(status) {
-	const fallback = {
-		["PENDING"]: "Pending",
-		["RUNNING"]: "Running",
-		["PASSED"]: "Passed",
-		["FAILED"]: "Failed",
-		["ERROR"]: "Error"
-	};
-	return {
-		key: `fluidgrids.builder.workflowTests.status.${status.toLowerCase()}`,
-		fallback: fallback[status]
-	};
-}
-/** "3 passed · 1 failed · 1 running" for a suite run. */
-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(" · ")} of ${summary.total}`;
-}
-/** The ids of the enabled cases, in their order. */
-function enabledCaseIds(cases) {
-	return cases.filter((testCase) => testCase.enabled).map((c) => c.id);
-}
-/** The sort order a new case takes: after every existing case. */
-function nextSortOrder(cases) {
-	return cases.reduce((max, c) => Math.max(max, c.sortOrder + 1), 0);
-}
-/** Run statuses after which a run can be saved as a test case. */
-const SAVEABLE_RUN_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED"]);
-/** Whether a finished run of a canvas workflow can become a test case. */
-function canSaveRunAsTestCase(run) {
-	return SAVEABLE_RUN_STATUSES.has(run.status) && !!run.workflowKey && !run.isDurable;
-}
-
-// src/builder/hooks/use-workflow-tests.ts
-/**
-* useWorkflowTests — the saved test cases of one workflow, its recent suite
-* runs and the actions on them (BOFF-9960).
-*
-* Every write refetches what it changed, so the panel shows what the server
-* holds. While a suite run is open (PENDING or RUNNING) it is polled with
-* `workflowTestRun` until it settles; the cases are then read again for their
-* last result. Nothing is sent while `enabled` is false (the
-* `fluidgrids.workflow-tests` flag off), so a workspace without the feature
-* never meets its FEATURE_DISABLED refusals.
-*/
-/** How often an open suite run is read again. */
-const TEST_RUN_POLL_INTERVAL_MS = 2e3;
-/** Suite runs listed in the panel. */
-const TEST_RUN_HISTORY_LIMIT = 10;
-function messageOf$1(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-/** Puts a run first in the list, replacing an older copy of it. */
-function upsertRun(runs, run) {
-	return [run, ...runs.filter((item) => item.id !== run.id)].slice(0, 10);
-}
-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: 10
-				},
-				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(messageOf$1(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(() => {
-			(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(messageOf$1(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
-	]);
-	return {
-		cases,
-		runs,
-		activeRun,
-		loading,
-		error,
-		forbidden,
-		refetch,
-		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]),
-		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]),
-		deleteCase: useCallback(async (id) => {
-			const result = await getFluidGridsClient().mutate({
-				mutation: DeleteWorkflowTestCaseDocument,
-				variables: { id }
-			});
-			throwIfResultError(result);
-			await refetch();
-		}, [refetch]),
-		runTests: useCallback(async (options = {}) => {
-			const result = await getFluidGridsClient().mutate({
-				mutation: RunWorkflowTestsDocument,
-				variables: { input: {
-					workflowKey,
-					source: "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])
-	};
-}
-/**
-* Saves a finished run as a test case of its workflow (used by the run detail
-* page, outside the builder).
-*/
-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;
-}
-
-// src/hooks/useWorkflowProposal.ts
-/**
-* useWorkflowProposal — drives one AI workflow proposal (BOFF-3662): start it
-* (author, run fix or next node), poll `workflowProposal(id)` while it is
-* PROCESSING, then apply, reject or cancel it.
-*
-* A proposal never changes a workflow by itself. Applying it creates a new
-* DRAFT version (or a new DRAFT workflow); the server marks it STALE when the
-* workflow changed after the proposal was made.
-*/
-/** How often a PROCESSING proposal is polled. */
-const PROPOSAL_POLL_INTERVAL_MS = 3e3;
-/** Stop polling after this long; the server closes a stuck proposal after 20 minutes. */
-const PROPOSAL_MAX_WAIT_MS = 36e4;
-function messageOf(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-/** Whether a proposal status means the model is still working. */
-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);
-			if (isProposalRunning(next ? String(next.status) : void 0)) {
-				if (Date.now() - startedAt < 36e4) {
-					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") started = throwIfResultError(await client.mutate({
-				mutation: ProposeRunFixDocument,
-				variables: { input: {
-					runId: input.runId,
-					...input.prompt ? { prompt: input.prompt } : {}
-				} }
-			})).data?.proposeRunFix;
-			else started = 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 } : {}
-				} }
-			})).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") next = throwIfResultError(await client.mutate({
-				mutation: ApplyWorkflowProposalDocument,
-				variables: { id }
-			})).data?.applyWorkflowProposal;
-			else if (action === "reject") next = throwIfResultError(await client.mutate({
-				mutation: RejectWorkflowProposalDocument,
-				variables: { id }
-			})).data?.rejectWorkflowProposal;
-			else {
-				clearTimer();
-				next = throwIfResultError(await client.mutate({
-					mutation: CancelWorkflowProposalDocument,
-					variables: { id }
-				})).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]);
-	return {
-		proposal,
-		isWorking,
-		isDeciding,
-		error,
-		timedOut,
-		start,
-		open,
-		apply: useCallback(() => decide("apply"), [decide]),
-		reject: useCallback(async () => {
-			await decide("reject");
-		}, [decide]),
-		cancel: useCallback(async () => {
-			await decide("cancel");
-		}, [decide]),
-		reset
-	};
-}
-
-// src/components/shared/WorkflowProposalCard.tsx
-/**
-* WorkflowProposalCard — review an AI workflow proposal before it changes
-* anything (BOFF-3662).
-*
-* Shows what the model proposes (explanation, a node and connection diff
-* against the version it was made from, validation errors and the settings the
-* user still has to fill in) with Apply / Reject while it is PROPOSED, a
-* Cancel while it is still running, and once applied a link to the new draft
-* plus a one-click revert to the version it was made from (a restore, which
-* creates another version and never deletes one).
-*/
-const STATUS_TONE = {
-	PROCESSING: "secondary",
-	PROPOSED: "default",
-	APPLIED: "default",
-	REJECTED: "outline",
-	STALE: "outline",
-	CANCELLED: "outline",
-	FAILED: "destructive"
-};
-function edgeLabel(edge) {
-	return `${edge.sourceHandle ? `${edge.source} (${edge.sourceHandle})` : edge.source} → ${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} · ${node.type}`;
-	return withFields && node.fields.length > 0 ? `${base} — ${node.fields.join(", ")}` : base;
-}
-/**
-* Validation errors that are not already part of the message shown above
-* them. Comparison ignores case and surrounding whitespace and punctuation.
-*/
-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}})…", { 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) => `− ${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
-				})]
-			})
-		]
-	});
-}
-
-export { rowsFromRules as C, agentTokenStreamsFor as D, agentLiveReplyState as E, latestAgentTokenStream as O, readAssertRulesSetting as S, useAgentTokenStream as T, ASSERT_OPERATORS as _, TEST_STATUS_TONE_CLASS as a, normaliseAssertRules as b, draftToInput as c, isTestRunOpen as d, nextSortOrder as f, testStatusTone as g, testStatusLabel as h, useWorkflowTests as i, emptyTestCaseDraft as l, testRunSummaryText as m, useWorkflowProposal as n, canSaveRunAsTestCase as o, pinnedOutputsFromCanvas as p, saveRunAsTestCase as r, draftFromTestCase as s, WorkflowProposalCard as t, enabledCaseIds as u, describeAssertRuleProblem as v, ruleFromRow as w, operatorSpec as x, emptyAssertRuleRow as y };