callman-core 1.0.2 → 1.0.3

package/dist/scenario-runner/condition.js

@@ -0,0 +1,1508 @@
+const createId = (prefix) => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+    ? crypto.randomUUID()
+    : `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+const BUILT_IN_RUNTIME_SUGGESTIONS = [
+    {
+        description: "Latest HTTP status code from the most recent request node.",
+        exampleValue: "200",
+        group: "Built-in",
+        path: "response.status",
+        valueType: "number",
+    },
+    {
+        description: "Latest HTTP response body payload.",
+        exampleValue: '{"ok":true}',
+        group: "Built-in",
+        path: "response.body",
+        valueType: "string",
+    },
+    {
+        description: "Latest HTTP response text body.",
+        exampleValue: "OK",
+        group: "Built-in",
+        path: "response.text",
+        valueType: "string",
+    },
+    {
+        description: "Latest HTTP response headers object.",
+        exampleValue: '{"content-type":"application/json"}',
+        group: "Built-in",
+        path: "response.headers",
+        valueType: "string",
+    },
+    {
+        description: "Latest HTTP request duration in milliseconds.",
+        exampleValue: "124",
+        group: "Built-in",
+        path: "response.durationMs",
+        valueType: "number",
+    },
+    {
+        description: "Latest database result rows for unlabeled DB access.",
+        exampleValue: "[...]",
+        group: "Built-in",
+        path: "db.result",
+        valueType: "array",
+    },
+    {
+        description: "Latest Kafka event payload for unlabeled Kafka access.",
+        exampleValue: '{"pin":"1234"}',
+        group: "Built-in",
+        path: "kafkaEvent",
+        valueType: "string",
+    },
+    {
+        description: "Latest Redis result for unlabeled Redis access.",
+        exampleValue: "cached-value",
+        group: "Built-in",
+        path: "redis.result",
+        valueType: "string",
+    },
+    {
+        description: "Scenario environment variables.",
+        exampleValue: "token",
+        group: "Built-in",
+        path: "env",
+        valueType: "string",
+    },
+    {
+        description: "Global runtime variables.",
+        exampleValue: "sharedToken",
+        group: "Built-in",
+        path: "global",
+        valueType: "string",
+    },
+];
+export const CONDITION_OPERATOR_META = [
+    { category: "Equality", label: "Equals", value: "equals" },
+    { category: "Equality", label: "Not Equals", value: "not_equals" },
+    { category: "Equality", label: "Strict Equals", value: "strict_equals" },
+    { category: "Equality", label: "Strict Not Equals", value: "strict_not_equals" },
+    { category: "Numeric", label: "Greater Than", value: "greater_than" },
+    { category: "Numeric", label: "Less Than", value: "less_than" },
+    { category: "Numeric", label: "Greater Or Equal", value: "greater_or_equal" },
+    { category: "Numeric", label: "Less Or Equal", value: "less_or_equal" },
+    { category: "Numeric", label: "Between", value: "between" },
+    { category: "String", label: "Contains", value: "contains" },
+    { category: "String", label: "Not Contains", value: "not_contains" },
+    { category: "String", label: "Starts With", value: "starts_with" },
+    { category: "String", label: "Ends With", value: "ends_with" },
+    { category: "String", label: "Regex", value: "regex" },
+    { category: "Existence", isUnary: true, label: "Exists", value: "exists" },
+    { category: "Existence", isUnary: true, label: "Not Exists", value: "not_exists" },
+    { category: "Existence", isUnary: true, label: "Is Empty", value: "is_empty" },
+    { category: "Existence", isUnary: true, label: "Not Empty", value: "not_empty" },
+    { category: "Existence", isUnary: true, label: "Is Null", value: "is_null" },
+    { category: "Existence", isUnary: true, label: "Not Null", value: "not_null" },
+    { category: "Collection", label: "In", value: "in" },
+    { category: "Collection", label: "Not In", value: "not_in" },
+];
+const OPERATOR_ALIAS_MAP = [
+    { alias: "!==", operator: "strict_not_equals" },
+    { alias: "===", operator: "strict_equals" },
+    { alias: "!=", operator: "not_equals" },
+    { alias: "==", operator: "equals" },
+    { alias: ">=", operator: "greater_or_equal" },
+    { alias: "<=", operator: "less_or_equal" },
+    { alias: ">", operator: "greater_than" },
+    { alias: "<", operator: "less_than" },
+    { alias: "not_contains", operator: "not_contains" },
+    { alias: "not contains", operator: "not_contains" },
+    { alias: "contains", operator: "contains" },
+    { alias: "starts_with", operator: "starts_with" },
+    { alias: "starts with", operator: "starts_with" },
+    { alias: "ends_with", operator: "ends_with" },
+    { alias: "ends with", operator: "ends_with" },
+    { alias: "regex", operator: "regex" },
+    { alias: "not_exists", operator: "not_exists" },
+    { alias: "not exists", operator: "not_exists" },
+    { alias: "exists", operator: "exists" },
+    { alias: "is_empty", operator: "is_empty" },
+    { alias: "is empty", operator: "is_empty" },
+    { alias: "not_empty", operator: "not_empty" },
+    { alias: "not empty", operator: "not_empty" },
+    { alias: "is_null", operator: "is_null" },
+    { alias: "is null", operator: "is_null" },
+    { alias: "not_null", operator: "not_null" },
+    { alias: "not null", operator: "not_null" },
+    { alias: "not_in", operator: "not_in" },
+    { alias: "not in", operator: "not_in" },
+    { alias: "in", operator: "in" },
+    { alias: "between", operator: "between" },
+];
+const LOGICAL_OPERATOR_ALIAS_MAP = [
+    { alias: "&&", operator: "AND" },
+    { alias: "AND", operator: "AND" },
+    { alias: "||", operator: "OR" },
+    { alias: "OR", operator: "OR" },
+];
+const LEGACY_OPERATOR_MAP = {
+    "==": "equals",
+    "!=": "not_equals",
+    ">": "greater_than",
+    "<": "less_than",
+    ">=": "greater_or_equal",
+    "<=": "less_or_equal",
+    contains: "contains",
+};
+const VALUE_TYPE_LABELS = {
+    string: "String",
+    number: "Number",
+    boolean: "Boolean",
+    null: "Null",
+    array: "Array",
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
+const normalizeAlias = (value) => value.trim().toUpperCase();
+const isBoundaryCharacter = (value) => value.length === 0 || /[\s()[\]{},"']/.test(value);
+const matchesAliasAtStart = (input, alias) => {
+    if (/^[<>=!&|]+$/.test(alias)) {
+        return input.startsWith(alias);
+    }
+    const normalizedAlias = normalizeAlias(alias);
+    const candidate = input.slice(0, alias.length);
+    if (/[A-Z_ ]/.test(normalizedAlias) && normalizeAlias(candidate) !== normalizedAlias) {
+        return false;
+    }
+    if (!/[A-Z_ ]/.test(normalizedAlias) && candidate !== alias) {
+        return false;
+    }
+    return isBoundaryCharacter(input[alias.length] ?? "");
+};
+const isUnaryOperator = (operator) => operator === "exists" ||
+    operator === "not_exists" ||
+    operator === "is_empty" ||
+    operator === "not_empty" ||
+    operator === "is_null" ||
+    operator === "not_null";
+const isNumericOperator = (operator) => operator === "greater_than" ||
+    operator === "less_than" ||
+    operator === "greater_or_equal" ||
+    operator === "less_or_equal" ||
+    operator === "between";
+const isCollectionOperator = (operator) => operator === "in" || operator === "not_in";
+const getOperatorToken = (operator) => {
+    switch (operator) {
+        case "equals":
+            return "==";
+        case "not_equals":
+            return "!=";
+        case "strict_equals":
+            return "===";
+        case "strict_not_equals":
+            return "!==";
+        case "greater_than":
+            return ">";
+        case "less_than":
+            return "<";
+        case "greater_or_equal":
+            return ">=";
+        case "less_or_equal":
+            return "<=";
+        case "between":
+            return "between";
+        case "contains":
+            return "contains";
+        case "not_contains":
+            return "not contains";
+        case "starts_with":
+            return "starts_with";
+        case "ends_with":
+            return "ends_with";
+        case "regex":
+            return "regex";
+        case "exists":
+            return "exists";
+        case "not_exists":
+            return "not exists";
+        case "is_empty":
+            return "is empty";
+        case "not_empty":
+            return "not empty";
+        case "is_null":
+            return "is null";
+        case "not_null":
+            return "not null";
+        case "in":
+            return "in";
+        case "not_in":
+            return "not in";
+        default:
+            return "==";
+    }
+};
+const formatDisplayValue = (value) => {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "undefined") {
+        return "undefined";
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const flattenScenarioNodes = (nodes) => nodes.flatMap((node) => node.type === "subscenario"
+    ? [node, ...flattenScenarioNodes(node.data.config.nodes)]
+    : [node]);
+const createSuggestion = (group, path, description, valueType, exampleValue) => ({
+    description,
+    ...(exampleValue ? { exampleValue } : {}),
+    group,
+    path,
+    valueType,
+});
+const buildNodeSuggestions = (label, type) => {
+    const group = label;
+    switch (type) {
+        case "request":
+            return [
+                createSuggestion(group, `${label}.status`, "HTTP status code.", "number", "200"),
+                createSuggestion(group, `${label}.body`, "Resolved response body payload.", "string"),
+                createSuggestion(group, `${label}.data`, "Response data shortcut.", "string"),
+                createSuggestion(group, `${label}.headers`, "Response headers object.", "string"),
+                createSuggestion(group, `${label}.cookies`, "Response cookies object.", "string"),
+                createSuggestion(group, `${label}.durationMs`, "Request duration in milliseconds.", "number", "124"),
+            ];
+        case "db":
+            return [
+                createSuggestion(group, `${label}.rows`, "Database query rows.", "array"),
+                createSuggestion(group, `${label}.rows[0]`, "First database row.", "string"),
+                createSuggestion(group, `${label}.rowCount`, "Total database rows returned.", "number", "1"),
+            ];
+        case "kafka":
+            return [
+                createSuggestion(group, `${label}.meta`, "Kafka metadata object.", "string"),
+                createSuggestion(group, `${label}.value`, "Kafka payload value.", "string"),
+                createSuggestion(group, `${label}.text`, "Kafka payload text.", "string"),
+                createSuggestion(group, `${label}.headers`, "Kafka headers object.", "string"),
+                createSuggestion(group, `${label}.key`, "Kafka message key.", "string"),
+                createSuggestion(group, `${label}.timestamp`, "Kafka event timestamp.", "string"),
+            ];
+        case "redis":
+            return [
+                createSuggestion(group, `${label}`, "Redis command result.", "string"),
+                createSuggestion(group, `${label}[0]`, "First Redis result when multiple commands run.", "string"),
+            ];
+        case "condition":
+            return [
+                createSuggestion(group, `${label}.result`, "Condition boolean result.", "boolean", "true"),
+                createSuggestion(group, `${label}.preview`, "Human-readable condition preview.", "string"),
+                createSuggestion(group, `${label}.expression`, "Executable condition expression.", "string"),
+                createSuggestion(group, `${label}.mode`, "Condition editor mode.", "string", "builder"),
+            ];
+        case "script":
+            return [
+                createSuggestion(group, `${label}`, "Returned Script Node output.", "string"),
+            ];
+        case "aggregator":
+            return [
+                createSuggestion(group, `${label}`, "Aggregator JSON output.", "string"),
+            ];
+        case "subscenario":
+            return [
+                createSuggestion(group, `${label}`, "Grouped output from the sub-scenario.", "string"),
+            ];
+        default:
+            return [];
+    }
+};
+const dedupeSuggestions = (suggestions) => {
+    const seen = new Set();
+    return suggestions.filter((suggestion) => {
+        if (seen.has(suggestion.path)) {
+            return false;
+        }
+        seen.add(suggestion.path);
+        return true;
+    });
+};
+const getDefaultLiteralValue = (valueType) => {
+    switch (valueType) {
+        case "number":
+            return 0;
+        case "boolean":
+            return false;
+        case "null":
+            return null;
+        case "array":
+            return [];
+        default:
+            return "";
+    }
+};
+const getDefaultRightOperand = (operator) => {
+    if (isUnaryOperator(operator)) {
+        return undefined;
+    }
+    if (operator === "between" || isCollectionOperator(operator)) {
+        return createConditionOperand("literal", "array", operator === "between" ? [0, 1] : []);
+    }
+    return createConditionOperand("literal", "string", "");
+};
+const parseLegacyConditionOperator = (value) => LEGACY_OPERATOR_MAP[value] ?? "equals";
+const coerceUnknownToBoolean = (value) => {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return null;
+};
+const coerceUnknownToNumber = (value) => {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+};
+const coerceOperandValue = (value, valueType) => {
+    if (valueType === "null") {
+        return value === null ? null : value === "null" ? null : undefined;
+    }
+    if (valueType === "boolean") {
+        return coerceUnknownToBoolean(value) ?? undefined;
+    }
+    if (valueType === "number") {
+        return coerceUnknownToNumber(value) ?? undefined;
+    }
+    if (valueType === "array") {
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            try {
+                const parsed = JSON.parse(value);
+                return Array.isArray(parsed) ? parsed : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === null || typeof value === "undefined") {
+        return "";
+    }
+    return formatDisplayValue(value);
+};
+const parseLiteralValue = (value, valueType) => {
+    const coercedValue = coerceOperandValue(value, valueType);
+    if (typeof coercedValue === "undefined") {
+        return getDefaultLiteralValue(valueType);
+    }
+    return coercedValue;
+};
+const parseRuntimePathSegments = (path) => {
+    const segments = [];
+    let buffer = "";
+    let index = 0;
+    const pushBuffer = () => {
+        const trimmed = buffer.trim();
+        if (trimmed) {
+            segments.push(trimmed);
+        }
+        buffer = "";
+    };
+    while (index < path.length) {
+        const character = path[index] ?? "";
+        if (character === ".") {
+            pushBuffer();
+            index += 1;
+            continue;
+        }
+        if (character === "[") {
+            pushBuffer();
+            const closingIndex = path.indexOf("]", index + 1);
+            if (closingIndex === -1) {
+                buffer += path.slice(index);
+                break;
+            }
+            const indexValue = path.slice(index + 1, closingIndex).trim();
+            const numericIndex = Number(indexValue);
+            if (Number.isInteger(numericIndex)) {
+                segments.push(numericIndex);
+            }
+            else if (indexValue) {
+                segments.push(indexValue);
+            }
+            index = closingIndex + 1;
+            continue;
+        }
+        buffer += character;
+        index += 1;
+    }
+    pushBuffer();
+    return segments;
+};
+const resolveRuntimePath = (roots, path) => {
+    const segments = parseRuntimePathSegments(path);
+    if (segments.length === 0) {
+        return {
+            exists: false,
+            value: undefined,
+        };
+    }
+    let currentValue = roots;
+    for (const segment of segments) {
+        if (typeof segment === "number") {
+            if (!Array.isArray(currentValue) || segment < 0 || segment >= currentValue.length) {
+                return {
+                    exists: false,
+                    value: undefined,
+                };
+            }
+            currentValue = currentValue[segment];
+            continue;
+        }
+        if (!isRecord(currentValue)) {
+            return {
+                exists: false,
+                value: undefined,
+            };
+        }
+        if (!Object.prototype.hasOwnProperty.call(currentValue, segment)) {
+            return {
+                exists: false,
+                value: undefined,
+            };
+        }
+        currentValue = currentValue[segment];
+    }
+    return {
+        exists: true,
+        value: currentValue,
+    };
+};
+const createRuntimeRoots = ({ dbResult, environment, globals, kafkaEvent, redisResult, responseRoot, workflowContext, }) => {
+    const roots = {
+        ...(workflowContext ?? {}),
+        response: responseRoot ?? null,
+        lastResponse: responseRoot ?? null,
+        env: {
+            ...environment,
+            dbResult: dbResult ?? null,
+            kafkaEvent: kafkaEvent ?? null,
+            kafkaevent: kafkaEvent ?? null,
+            lastResponse: responseRoot ?? null,
+            redisResult: redisResult ?? null,
+        },
+        global: globals,
+        globals,
+        db: {
+            result: dbResult ?? null,
+        },
+        kafkaEvent: kafkaEvent ?? null,
+        kafkaevent: kafkaEvent ?? null,
+        redis: {
+            result: redisResult ?? null,
+        },
+    };
+    return roots;
+};
+const serializeLiteralOperand = (operand) => {
+    if (operand.valueType === "null") {
+        return "null";
+    }
+    if (operand.valueType === "boolean") {
+        return operand.value ? "true" : "false";
+    }
+    if (operand.valueType === "number") {
+        return String(typeof operand.value === "number" ? operand.value : 0);
+    }
+    if (operand.valueType === "array") {
+        try {
+            return JSON.stringify(Array.isArray(operand.value) ? operand.value : []);
+        }
+        catch {
+            return "[]";
+        }
+    }
+    return JSON.stringify(String(operand.value ?? ""));
+};
+const serializeOperandForExpression = (operand) => operand.mode === "runtime"
+    ? `{{${String(operand.value ?? "").trim()}}}`
+    : serializeLiteralOperand(operand);
+const serializeOperandForPreview = (operand) => operand.mode === "runtime"
+    ? String(operand.value ?? "").trim() || "runtime.path"
+    : serializeLiteralOperand(operand);
+const tokenizeConditionExpression = (expression) => {
+    const tokens = [];
+    let index = 0;
+    const pushToken = (type, value, position = index) => {
+        tokens.push({
+            type,
+            value,
+            position,
+        });
+    };
+    while (index < expression.length) {
+        const remaining = expression.slice(index);
+        if (/^\s+/.test(remaining)) {
+            index += remaining.match(/^\s+/)?.[0].length ?? 1;
+            continue;
+        }
+        if (remaining.startsWith("{{")) {
+            const closingIndex = expression.indexOf("}}", index + 2);
+            if (closingIndex === -1) {
+                throw new Error(`Unclosed runtime token at character ${index + 1}.`);
+            }
+            pushToken("runtime", expression.slice(index + 2, closingIndex).trim(), index);
+            index = closingIndex + 2;
+            continue;
+        }
+        if (remaining[0] === "(" || remaining[0] === ")") {
+            pushToken("paren", remaining[0] ?? "", index);
+            index += 1;
+            continue;
+        }
+        const logicalMatch = LOGICAL_OPERATOR_ALIAS_MAP.find(({ alias }) => matchesAliasAtStart(remaining, alias));
+        if (logicalMatch) {
+            pushToken("logic", logicalMatch.operator, index);
+            index += logicalMatch.alias.length;
+            continue;
+        }
+        const operatorMatch = OPERATOR_ALIAS_MAP.find(({ alias }) => matchesAliasAtStart(remaining, alias));
+        if (operatorMatch) {
+            pushToken("operator", operatorMatch.operator, index);
+            index += operatorMatch.alias.length;
+            continue;
+        }
+        if (remaining[0] === `"` || remaining[0] === `'`) {
+            const quote = remaining[0];
+            let cursor = index + 1;
+            let escaped = false;
+            while (cursor < expression.length) {
+                const character = expression[cursor] ?? "";
+                if (character === "\\" && !escaped) {
+                    escaped = true;
+                    cursor += 1;
+                    continue;
+                }
+                if (character === quote && !escaped) {
+                    break;
+                }
+                escaped = false;
+                cursor += 1;
+            }
+            if (expression[cursor] !== quote) {
+                throw new Error(`Unclosed string literal at character ${index + 1}.`);
+            }
+            pushToken("string", expression.slice(index, cursor + 1), index);
+            index = cursor + 1;
+            continue;
+        }
+        if (remaining[0] === "[") {
+            let depth = 0;
+            let cursor = index;
+            let activeQuote = null;
+            let escaped = false;
+            while (cursor < expression.length) {
+                const character = expression[cursor] ?? "";
+                if (activeQuote) {
+                    if (character === "\\" && !escaped) {
+                        escaped = true;
+                        cursor += 1;
+                        continue;
+                    }
+                    if (character === activeQuote && !escaped) {
+                        activeQuote = null;
+                    }
+                    escaped = false;
+                    cursor += 1;
+                    continue;
+                }
+                if (character === `"` || character === `'`) {
+                    activeQuote = character;
+                    cursor += 1;
+                    continue;
+                }
+                if (character === "[") {
+                    depth += 1;
+                }
+                if (character === "]") {
+                    depth -= 1;
+                    if (depth === 0) {
+                        cursor += 1;
+                        break;
+                    }
+                }
+                cursor += 1;
+            }
+            if (depth !== 0) {
+                throw new Error(`Unclosed array literal at character ${index + 1}.`);
+            }
+            pushToken("array", expression.slice(index, cursor), index);
+            index = cursor;
+            continue;
+        }
+        const numberMatch = remaining.match(/^-?\d+(?:\.\d+)?/);
+        if (numberMatch) {
+            pushToken("number", numberMatch[0], index);
+            index += numberMatch[0].length;
+            continue;
+        }
+        const booleanOrNullMatch = remaining.match(/^(true|false|null)\b/i);
+        if (booleanOrNullMatch) {
+            const matched = booleanOrNullMatch[1]?.toLowerCase() ?? "";
+            pushToken(matched === "null" ? "null" : "boolean", matched, index);
+            index += booleanOrNullMatch[0].length;
+            continue;
+        }
+        throw new Error(`Unexpected token near "${remaining.slice(0, 20)}" at character ${index + 1}.`);
+    }
+    return tokens;
+};
+const parseCursorToken = (cursor) => cursor.tokens[cursor.index] ?? null;
+const consumeCursorToken = (cursor, expectedType) => {
+    const token = parseCursorToken(cursor);
+    if (!token) {
+        throw new Error("Unexpected end of expression.");
+    }
+    if (expectedType && token.type !== expectedType) {
+        throw new Error(`Expected ${expectedType} at character ${token.position + 1}.`);
+    }
+    cursor.index += 1;
+    return token;
+};
+const mergeGroupChildren = (operator, children) => ({
+    id: createId("condition-group"),
+    type: "group",
+    operator,
+    children: children.flatMap((child) => child.type === "group" && child.operator === operator ? child.children : [child]),
+});
+const parseOperandToken = (token) => {
+    if (token.type === "runtime") {
+        return createConditionOperand("runtime", "string", token.value.trim());
+    }
+    if (token.type === "number") {
+        return createConditionOperand("literal", "number", Number(token.value));
+    }
+    if (token.type === "boolean") {
+        return createConditionOperand("literal", "boolean", token.value === "true");
+    }
+    if (token.type === "null") {
+        return createConditionOperand("literal", "null", null);
+    }
+    if (token.type === "array") {
+        try {
+            return createConditionOperand("literal", "array", JSON.parse(token.value.replace(/'/g, `"`)));
+        }
+        catch {
+            throw new Error(`Invalid array literal at character ${token.position + 1}.`);
+        }
+    }
+    if (token.type === "string") {
+        try {
+            const normalizedToken = token.value.startsWith("'") && token.value.endsWith("'")
+                ? `"${token.value.slice(1, -1).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+                : token.value;
+            return createConditionOperand("literal", "string", JSON.parse(normalizedToken));
+        }
+        catch {
+            return createConditionOperand("literal", "string", token.value.slice(1, -1));
+        }
+    }
+    throw new Error(`Expected operand at character ${token.position + 1}.`);
+};
+const parseConditionRule = (cursor) => {
+    const leftToken = consumeCursorToken(cursor);
+    if (leftToken.type !== "runtime" &&
+        leftToken.type !== "number" &&
+        leftToken.type !== "boolean" &&
+        leftToken.type !== "null" &&
+        leftToken.type !== "array" &&
+        leftToken.type !== "string") {
+        throw new Error(`Expected operand at character ${leftToken.position + 1}.`);
+    }
+    const operatorToken = consumeCursorToken(cursor, "operator");
+    const operator = operatorToken.value;
+    if (isUnaryOperator(operator)) {
+        return {
+            id: createId("condition-rule"),
+            type: "rule",
+            left: parseOperandToken(leftToken),
+            operator,
+        };
+    }
+    const rightToken = consumeCursorToken(cursor);
+    if (rightToken.type !== "runtime" &&
+        rightToken.type !== "number" &&
+        rightToken.type !== "boolean" &&
+        rightToken.type !== "null" &&
+        rightToken.type !== "array" &&
+        rightToken.type !== "string") {
+        throw new Error(`Expected right operand at character ${rightToken.position + 1}.`);
+    }
+    return {
+        id: createId("condition-rule"),
+        type: "rule",
+        left: parseOperandToken(leftToken),
+        operator,
+        right: parseOperandToken(rightToken),
+    };
+};
+const parsePrimaryGroupNode = (cursor) => {
+    const token = parseCursorToken(cursor);
+    if (!token) {
+        throw new Error("Unexpected end of expression.");
+    }
+    if (token.type === "paren" && token.value === "(") {
+        consumeCursorToken(cursor, "paren");
+        const nested = parseOrExpression(cursor);
+        const closingToken = consumeCursorToken(cursor, "paren");
+        if (closingToken.value !== ")") {
+            throw new Error(`Expected closing parenthesis at character ${closingToken.position + 1}.`);
+        }
+        return nested;
+    }
+    return parseConditionRule(cursor);
+};
+const parseAndExpression = (cursor) => {
+    const children = [parsePrimaryGroupNode(cursor)];
+    while (parseCursorToken(cursor)?.type === "logic" && parseCursorToken(cursor)?.value === "AND") {
+        consumeCursorToken(cursor, "logic");
+        children.push(parsePrimaryGroupNode(cursor));
+    }
+    return children.length === 1 ? children[0] : mergeGroupChildren("AND", children);
+};
+const parseOrExpression = (cursor) => {
+    const children = [parseAndExpression(cursor)];
+    while (parseCursorToken(cursor)?.type === "logic" && parseCursorToken(cursor)?.value === "OR") {
+        consumeCursorToken(cursor, "logic");
+        children.push(parseAndExpression(cursor));
+    }
+    return children.length === 1 ? children[0] : mergeGroupChildren("OR", children);
+};
+const ensureGroupRoot = (node) => node.type === "group"
+    ? node
+    : {
+        id: createId("condition-root"),
+        type: "group",
+        operator: "AND",
+        children: [node],
+    };
+const serializeRuleExpression = (rule, humanReadable) => {
+    const left = humanReadable
+        ? serializeOperandForPreview(rule.left)
+        : serializeOperandForExpression(rule.left);
+    const operator = getOperatorToken(rule.operator);
+    if (isUnaryOperator(rule.operator)) {
+        return `${left} ${operator}`;
+    }
+    const rightOperand = rule.right ?? getDefaultRightOperand(rule.operator);
+    const right = humanReadable
+        ? serializeOperandForPreview(rightOperand ?? createConditionOperand("literal", "string", ""))
+        : serializeOperandForExpression(rightOperand ?? createConditionOperand("literal", "string", ""));
+    return `${left} ${operator} ${right}`;
+};
+const serializeGroupExpression = (group, humanReadable, nested = false) => {
+    if (group.children.length === 0) {
+        return humanReadable ? "Empty group" : "()";
+    }
+    const renderedChildren = group.children.map((child) => child.type === "group"
+        ? serializeGroupExpression(child, humanReadable, true)
+        : serializeRuleExpression(child, humanReadable));
+    const joined = renderedChildren.join(` ${group.operator} `);
+    if (!nested && group.children.length === 1) {
+        return joined;
+    }
+    return `(${joined})`;
+};
+const collectConditionRuleCount = (group) => group.children.reduce((count, child) => count + (child.type === "rule" ? 1 : collectConditionRuleCount(child)), 0);
+const collectConditionGroupCount = (group) => 1 +
+    group.children.reduce((count, child) => count + (child.type === "group" ? collectConditionGroupCount(child) : 0), 0);
+const cloneConditionOperand = (operand) => ({
+    mode: operand.mode,
+    valueType: operand.valueType,
+    value: Array.isArray(operand.value) ? [...operand.value] : operand.value,
+});
+const sanitizeConditionOperand = (value, fallbackMode = "literal") => {
+    if (!isRecord(value)) {
+        return createConditionOperand(fallbackMode);
+    }
+    const mode = value.mode === "runtime" ? "runtime" : "literal";
+    const rawValueType = String(value.valueType ?? "");
+    const valueType = rawValueType === "number" ||
+        rawValueType === "boolean" ||
+        rawValueType === "null" ||
+        rawValueType === "array" ||
+        rawValueType === "string"
+        ? rawValueType
+        : mode === "runtime"
+            ? "string"
+            : "string";
+    return {
+        mode,
+        valueType,
+        value: mode === "runtime"
+            ? String(value.value ?? "").trim()
+            : parseLiteralValue(value.value, valueType),
+    };
+};
+const sanitizeConditionRule = (value) => {
+    if (!isRecord(value) || value.type !== "rule") {
+        return null;
+    }
+    const rawOperator = String(value.operator ?? "");
+    const operator = CONDITION_OPERATOR_META.find((entry) => entry.value === rawOperator)?.value;
+    if (!operator) {
+        return null;
+    }
+    return {
+        id: typeof value.id === "string" && value.id.trim() ? value.id : createId("condition-rule"),
+        type: "rule",
+        left: sanitizeConditionOperand(value.left, "runtime"),
+        operator,
+        ...(isUnaryOperator(operator)
+            ? {}
+            : {
+                right: sanitizeConditionOperand(value.right ?? getDefaultRightOperand(operator), "literal"),
+            }),
+    };
+};
+const sanitizeConditionGroup = (value) => {
+    if (!isRecord(value) || value.type !== "group") {
+        return null;
+    }
+    const operator = value.operator === "OR" ? "OR" : "AND";
+    const children = Array.isArray(value.children)
+        ? value.children
+            .map((child) => sanitizeConditionGroup(child) ?? sanitizeConditionRule(child))
+            .filter((child) => child !== null)
+        : [];
+    return {
+        id: typeof value.id === "string" && value.id.trim() ? value.id : createId("condition-group"),
+        type: "group",
+        operator,
+        children,
+    };
+};
+const buildValidationIssue = (id, message, severity) => ({
+    id,
+    message,
+    severity,
+});
+const validateOperand = (operand, id, issues, runtimeRootKeys) => {
+    if (!operand) {
+        issues.push(buildValidationIssue(id, "Operand is missing.", "error"));
+        return;
+    }
+    if (operand.mode === "runtime") {
+        const path = String(operand.value ?? "").trim();
+        if (!path) {
+            issues.push(buildValidationIssue(id, "Runtime path is required.", "error"));
+            return;
+        }
+        const root = parseRuntimePathSegments(path)[0];
+        if (runtimeRootKeys &&
+            typeof root === "string" &&
+            root.trim() &&
+            !runtimeRootKeys.has(root)) {
+            issues.push(buildValidationIssue(id, `Runtime root "${root}" is not available in this workflow context.`, "warning"));
+        }
+        return;
+    }
+    if (operand.valueType === "array") {
+        if (!Array.isArray(operand.value)) {
+            issues.push(buildValidationIssue(id, "Array operand must be a JSON array.", "error"));
+        }
+        return;
+    }
+    if (operand.valueType === "number" && coerceUnknownToNumber(operand.value) === null) {
+        issues.push(buildValidationIssue(id, "Number operand must be numeric.", "error"));
+    }
+    if (operand.valueType === "boolean" && coerceUnknownToBoolean(operand.value) === null) {
+        issues.push(buildValidationIssue(id, "Boolean operand must be true or false.", "error"));
+    }
+};
+const validateRule = (rule, issues, runtimeRootKeys) => {
+    validateOperand(rule.left, `${rule.id}:left`, issues, runtimeRootKeys);
+    if (!isUnaryOperator(rule.operator)) {
+        validateOperand(rule.right, `${rule.id}:right`, issues, runtimeRootKeys);
+    }
+    if (rule.operator === "between") {
+        if (!rule.right || rule.right.valueType !== "array" || !Array.isArray(rule.right.value)) {
+            issues.push(buildValidationIssue(rule.id, "Between expects an array literal with exactly two numeric values.", "error"));
+        }
+        else if (rule.right.value.length !== 2 ||
+            rule.right.value.some((value) => coerceUnknownToNumber(value) === null)) {
+            issues.push(buildValidationIssue(rule.id, "Between expects two numeric boundary values.", "error"));
+        }
+    }
+    if (isCollectionOperator(rule.operator)) {
+        if (!rule.right || rule.right.valueType !== "array" || !Array.isArray(rule.right.value)) {
+            issues.push(buildValidationIssue(rule.id, "In operators require an array on the right side.", "error"));
+        }
+    }
+    if (rule.operator === "regex" && rule.right?.mode === "literal") {
+        try {
+            buildConditionRegex(String(rule.right.value ?? ""));
+        }
+        catch (error) {
+            issues.push(buildValidationIssue(rule.id, error instanceof Error ? error.message : "Regex pattern is invalid.", "error"));
+        }
+    }
+    if (isNumericOperator(rule.operator)) {
+        if (rule.left.valueType !== "number") {
+            issues.push(buildValidationIssue(`${rule.id}:numeric-left`, "Left operand should use Number type for numeric comparisons.", "warning"));
+        }
+        if (rule.operator !== "between" &&
+            rule.right &&
+            rule.right.valueType !== "number" &&
+            rule.right.mode !== "runtime") {
+            issues.push(buildValidationIssue(`${rule.id}:numeric-right`, "Right operand should use Number type for numeric comparisons.", "warning"));
+        }
+    }
+};
+const validateGroup = (group, issues, runtimeRootKeys) => {
+    if (group.children.length === 0) {
+        issues.push(buildValidationIssue(group.id, "Group must contain at least one rule.", "error"));
+        return;
+    }
+    group.children.forEach((child) => {
+        if (child.type === "group") {
+            validateGroup(child, issues, runtimeRootKeys);
+            return;
+        }
+        validateRule(child, issues, runtimeRootKeys);
+    });
+};
+const buildConditionRegex = (value) => {
+    const trimmed = value.trim();
+    const literalMatch = trimmed.match(/^\/(.+)\/([a-z]*)$/i);
+    if (literalMatch) {
+        return new RegExp(literalMatch[1] ?? "", literalMatch[2] ?? "");
+    }
+    return new RegExp(trimmed);
+};
+const compareLooseEquality = (left, right) => {
+    if (Array.isArray(left) || Array.isArray(right) || isRecord(left) || isRecord(right)) {
+        try {
+            return JSON.stringify(left) === JSON.stringify(right);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (left === right) {
+        return true;
+    }
+    if (typeof left === "string" && typeof right !== "string") {
+        const coercedLeft = coerceOperandValue(left, typeof right === "number" ? "number" : typeof right === "boolean" ? "boolean" : right === null ? "null" : "string");
+        return typeof coercedLeft === "undefined" ? false : compareLooseEquality(coercedLeft, right);
+    }
+    if (typeof right === "string" && typeof left !== "string") {
+        const coercedRight = coerceOperandValue(right, typeof left === "number" ? "number" : typeof left === "boolean" ? "boolean" : left === null ? "null" : "string");
+        return typeof coercedRight === "undefined" ? false : compareLooseEquality(left, coercedRight);
+    }
+    return formatDisplayValue(left) === formatDisplayValue(right);
+};
+const resolveOperand = (operand, runtimeScope) => {
+    if (operand.mode === "literal") {
+        const literalValue = parseLiteralValue(operand.value, operand.valueType);
+        return {
+            displayValue: formatDisplayValue(literalValue),
+            exists: true,
+            operand,
+            path: null,
+            value: literalValue,
+        };
+    }
+    const path = String(operand.value ?? "").trim();
+    const resolution = resolveRuntimePath(createRuntimeRoots(runtimeScope), path);
+    const coercedValue = typeof resolution.value === "undefined"
+        ? undefined
+        : coerceOperandValue(resolution.value, operand.valueType);
+    return {
+        displayValue: formatDisplayValue(typeof coercedValue === "undefined" ? resolution.value : coercedValue),
+        exists: resolution.exists,
+        operand,
+        path,
+        value: typeof coercedValue === "undefined" ? resolution.value : coercedValue,
+    };
+};
+const evaluateRule = (rule, runtimeScope) => {
+    const left = resolveOperand(rule.left, runtimeScope);
+    const right = rule.right ? resolveOperand(rule.right, runtimeScope) : undefined;
+    let result = false;
+    switch (rule.operator) {
+        case "equals":
+            result = compareLooseEquality(left.value, right?.value);
+            break;
+        case "not_equals":
+            result = !compareLooseEquality(left.value, right?.value);
+            break;
+        case "strict_equals":
+            result = left.value === right?.value;
+            break;
+        case "strict_not_equals":
+            result = left.value !== right?.value;
+            break;
+        case "greater_than":
+            result =
+                coerceUnknownToNumber(left.value) !== null &&
+                    coerceUnknownToNumber(right?.value) !== null &&
+                    (coerceUnknownToNumber(left.value) ?? 0) > (coerceUnknownToNumber(right?.value) ?? 0);
+            break;
+        case "less_than":
+            result =
+                coerceUnknownToNumber(left.value) !== null &&
+                    coerceUnknownToNumber(right?.value) !== null &&
+                    (coerceUnknownToNumber(left.value) ?? 0) < (coerceUnknownToNumber(right?.value) ?? 0);
+            break;
+        case "greater_or_equal":
+            result =
+                coerceUnknownToNumber(left.value) !== null &&
+                    coerceUnknownToNumber(right?.value) !== null &&
+                    (coerceUnknownToNumber(left.value) ?? 0) >= (coerceUnknownToNumber(right?.value) ?? 0);
+            break;
+        case "less_or_equal":
+            result =
+                coerceUnknownToNumber(left.value) !== null &&
+                    coerceUnknownToNumber(right?.value) !== null &&
+                    (coerceUnknownToNumber(left.value) ?? 0) <= (coerceUnknownToNumber(right?.value) ?? 0);
+            break;
+        case "between": {
+            const range = Array.isArray(right?.value) ? right?.value : [];
+            const leftNumber = coerceUnknownToNumber(left.value);
+            const lowerBound = coerceUnknownToNumber(range[0]);
+            const upperBound = coerceUnknownToNumber(range[1]);
+            result =
+                leftNumber !== null &&
+                    lowerBound !== null &&
+                    upperBound !== null &&
+                    leftNumber >= lowerBound &&
+                    leftNumber <= upperBound;
+            break;
+        }
+        case "contains":
+            result = Array.isArray(left.value)
+                ? left.value.some((entry) => compareLooseEquality(entry, right?.value))
+                : formatDisplayValue(left.value).includes(formatDisplayValue(right?.value));
+            break;
+        case "not_contains":
+            result = Array.isArray(left.value)
+                ? !left.value.some((entry) => compareLooseEquality(entry, right?.value))
+                : !formatDisplayValue(left.value).includes(formatDisplayValue(right?.value));
+            break;
+        case "starts_with":
+            result = formatDisplayValue(left.value).startsWith(formatDisplayValue(right?.value));
+            break;
+        case "ends_with":
+            result = formatDisplayValue(left.value).endsWith(formatDisplayValue(right?.value));
+            break;
+        case "regex":
+            result = buildConditionRegex(formatDisplayValue(right?.value)).test(formatDisplayValue(left.value));
+            break;
+        case "exists":
+            result = left.exists;
+            break;
+        case "not_exists":
+            result = !left.exists;
+            break;
+        case "is_empty":
+            result = left.exists
+                ? left.value === "" ||
+                    (Array.isArray(left.value) && left.value.length === 0) ||
+                    (isRecord(left.value) && Object.keys(left.value).length === 0)
+                : false;
+            break;
+        case "not_empty":
+            result = left.exists
+                ? !(left.value === "" ||
+                    (Array.isArray(left.value) && left.value.length === 0) ||
+                    (isRecord(left.value) && Object.keys(left.value).length === 0))
+                : false;
+            break;
+        case "is_null":
+            result = left.value === null;
+            break;
+        case "not_null":
+            result = left.value !== null;
+            break;
+        case "in":
+            result = Array.isArray(right?.value)
+                ? right.value.some((entry) => compareLooseEquality(left.value, entry))
+                : false;
+            break;
+        case "not_in":
+            result = Array.isArray(right?.value)
+                ? !right.value.some((entry) => compareLooseEquality(left.value, entry))
+                : false;
+            break;
+        default:
+            result = false;
+            break;
+    }
+    return {
+        id: rule.id,
+        type: "rule",
+        operator: rule.operator,
+        result,
+        left,
+        ...(right ? { right } : {}),
+    };
+};
+const evaluateGroup = (group, runtimeScope) => {
+    const children = group.children.map((child) => child.type === "group"
+        ? evaluateGroup(child, runtimeScope)
+        : evaluateRule(child, runtimeScope));
+    return {
+        id: group.id,
+        type: "group",
+        operator: group.operator,
+        result: group.operator === "AND"
+            ? children.every((child) => child.result)
+            : children.some((child) => child.result),
+        children,
+    };
+};
+const replaceChildInGroup = (group, childId, nextChild) => ({
+    ...group,
+    children: group.children.map((child) => {
+        if (child.id === childId) {
+            return nextChild;
+        }
+        if (child.type === "group") {
+            return replaceChildInGroup(child, childId, nextChild);
+        }
+        return child;
+    }),
+});
+const appendChildToConditionGroup = (group, groupId, nextChild) => ({
+    ...group,
+    children: group.id === groupId
+        ? [...group.children, nextChild]
+        : group.children.map((child) => child.type === "group"
+            ? appendChildToConditionGroup(child, groupId, nextChild)
+            : child),
+});
+const removeChildFromConditionGroup = (group, groupId, childId) => ({
+    ...group,
+    children: group.id === groupId
+        ? group.children.filter((child) => child.id !== childId)
+        : group.children.map((child) => child.type === "group"
+            ? removeChildFromConditionGroup(child, groupId, childId)
+            : child),
+});
+const updateConditionGroup = (group, groupId, updater) => {
+    if (group.id === groupId) {
+        return updater(group);
+    }
+    return {
+        ...group,
+        children: group.children.map((child) => child.type === "group" ? updateConditionGroup(child, groupId, updater) : child),
+    };
+};
+const updateConditionRule = (group, ruleId, updater) => ({
+    ...group,
+    children: group.children.map((child) => {
+        if (child.type === "rule") {
+            return child.id === ruleId ? updater(child) : child;
+        }
+        return updateConditionRule(child, ruleId, updater);
+    }),
+});
+const getConditionQuickSummaryParts = (config) => {
+    const ruleCount = collectConditionRuleCount(config.rootGroup);
+    const groupCount = collectConditionGroupCount(config.rootGroup);
+    return [
+        config.mode === "expert" ? "Expert" : "Builder",
+        `${ruleCount} rule${ruleCount === 1 ? "" : "s"}`,
+        `${groupCount} group${groupCount === 1 ? "" : "s"}`,
+    ];
+};
+export const CONDITION_VALUE_TYPES = [
+    "string",
+    "number",
+    "boolean",
+    "null",
+    "array",
+];
+export const createConditionOperand = (mode = "runtime", valueType = mode === "runtime" ? "string" : "string", value) => ({
+    mode,
+    valueType,
+    value: typeof value !== "undefined"
+        ? mode === "runtime"
+            ? String(value ?? "").trim()
+            : parseLiteralValue(value, valueType)
+        : mode === "runtime"
+            ? ""
+            : getDefaultLiteralValue(valueType),
+});
+export const createConditionRule = (overrides = {}) => {
+    const operator = overrides.operator ?? "equals";
+    return {
+        id: overrides.id ?? createId("condition-rule"),
+        type: "rule",
+        left: overrides.left ? cloneConditionOperand(overrides.left) : createConditionOperand("runtime"),
+        operator,
+        ...(isUnaryOperator(operator)
+            ? {}
+            : {
+                right: overrides.right
+                    ? cloneConditionOperand(overrides.right)
+                    : getDefaultRightOperand(operator),
+            }),
+    };
+};
+export const createConditionGroup = (operator = "AND", children = [createConditionRule()]) => ({
+    id: createId("condition-group"),
+    type: "group",
+    operator,
+    children,
+});
+export const createDefaultConditionConfig = () => {
+    const rootGroup = createConditionGroup("AND", [
+        createConditionRule({
+            left: createConditionOperand("runtime", "number", "response.status"),
+            operator: "equals",
+            right: createConditionOperand("literal", "number", 200),
+        }),
+    ]);
+    return {
+        mode: "builder",
+        rootGroup,
+        expertExpression: serializeConditionGroupToExpression(rootGroup),
+    };
+};
+export const serializeConditionGroupToExpression = (group) => serializeGroupExpression(group, false);
+export const serializeConditionConfigToExpression = (config) => config.mode === "expert" && config.expertExpression?.trim()
+    ? config.expertExpression.trim()
+    : serializeConditionGroupToExpression(config.rootGroup);
+export const serializeConditionGroupToPreview = (group) => serializeGroupExpression(group, true);
+export const serializeConditionConfigToPreview = (config) => config.mode === "expert" && config.expertExpression?.trim()
+    ? config.expertExpression.trim()
+    : serializeConditionGroupToPreview(config.rootGroup);
+export const parseConditionExpressionToGroup = (expression) => {
+    const tokens = tokenizeConditionExpression(expression);
+    const cursor = {
+        index: 0,
+        tokens,
+    };
+    const group = ensureGroupRoot(parseOrExpression(cursor));
+    if (parseCursorToken(cursor)) {
+        throw new Error(`Unexpected token at character ${(parseCursorToken(cursor)?.position ?? 0) + 1}.`);
+    }
+    return group;
+};
+export const parseConditionExpressionSafely = (expression) => {
+    try {
+        return {
+            group: parseConditionExpressionToGroup(expression),
+            issues: [],
+        };
+    }
+    catch (error) {
+        return {
+            group: createDefaultConditionConfig().rootGroup,
+            issues: [
+                buildValidationIssue("expert:parse", error instanceof Error ? error.message : "Condition expression is invalid.", "error"),
+            ],
+        };
+    }
+};
+export const normalizeConditionNodeConfig = (value) => {
+    if (isRecord(value) && typeof value.expression === "string") {
+        const expression = value.expression.trim();
+        if (!expression) {
+            return createDefaultConditionConfig();
+        }
+        try {
+            const rootGroup = parseConditionExpressionToGroup(expression);
+            return {
+                mode: "builder",
+                rootGroup,
+                expertExpression: serializeConditionGroupToExpression(rootGroup),
+            };
+        }
+        catch {
+            return {
+                mode: "expert",
+                rootGroup: createDefaultConditionConfig().rootGroup,
+                expertExpression: expression,
+            };
+        }
+    }
+    if (!isRecord(value)) {
+        return createDefaultConditionConfig();
+    }
+    const mode = value.mode === "expert" ? "expert" : "builder";
+    const rootGroup = sanitizeConditionGroup(value.rootGroup) ?? createDefaultConditionConfig().rootGroup;
+    const expertExpression = typeof value.expertExpression === "string" ? value.expertExpression : null;
+    return {
+        mode,
+        rootGroup,
+        expertExpression: expertExpression ??
+            serializeConditionGroupToExpression(rootGroup),
+    };
+};
+export const validateConditionConfig = (config, runtimeRootKeys) => {
+    const issues = [];
+    const rootKeySet = runtimeRootKeys ? new Set(runtimeRootKeys) : null;
+    let targetGroup = config.rootGroup;
+    if (config.mode === "expert" && config.expertExpression?.trim()) {
+        const parseResult = parseConditionExpressionSafely(config.expertExpression);
+        issues.push(...parseResult.issues);
+        if (parseResult.issues.some((issue) => issue.severity === "error")) {
+            return issues;
+        }
+        targetGroup = parseResult.group;
+    }
+    validateGroup(targetGroup, issues, rootKeySet);
+    return issues;
+};
+export const getConditionRuleCount = (group) => collectConditionRuleCount(group);
+export const getConditionGroupCount = (group) => collectConditionGroupCount(group);
+export const getConditionQuickSummary = (config) => getConditionQuickSummaryParts(config).join(" • ");
+export const getConditionHeadline = (config) => {
+    const ruleCount = collectConditionRuleCount(config.rootGroup);
+    const groupCount = collectConditionGroupCount(config.rootGroup);
+    return `IF (${ruleCount} rule${ruleCount === 1 ? "" : "s"}, ${groupCount} group${groupCount === 1 ? "" : "s"})`;
+};
+export const getConditionValueTypeLabel = (valueType) => VALUE_TYPE_LABELS[valueType];
+export const getExecutableConditionGroup = (config) => {
+    if (config.mode === "expert" && config.expertExpression?.trim()) {
+        return parseConditionExpressionToGroup(config.expertExpression);
+    }
+    return config.rootGroup;
+};
+export const evaluateConditionConfig = (config, runtimeScope) => {
+    const executableGroup = getExecutableConditionGroup(config);
+    const tree = evaluateGroup(executableGroup, runtimeScope);
+    return {
+        expression: serializeConditionConfigToExpression(config),
+        result: tree.result,
+        tree,
+    };
+};
+export const getConditionRuntimeRootKeys = (config) => new Set(Object.keys(createRuntimeRoots(config)));
+export const updateConditionGroupOperator = (rootGroup, groupId, operator) => updateConditionGroup(rootGroup, groupId, (group) => ({
+    ...group,
+    operator,
+}));
+export const appendRuleToConditionGroup = (rootGroup, groupId) => appendChildToConditionGroup(rootGroup, groupId, createConditionRule());
+export const appendGroupToConditionGroup = (rootGroup, groupId) => appendChildToConditionGroup(rootGroup, groupId, createConditionGroup("AND"));
+export const removeConditionChild = (rootGroup, groupId, childId) => removeChildFromConditionGroup(rootGroup, groupId, childId);
+export const replaceConditionGroup = (rootGroup, nextGroup) => replaceChildInGroup(rootGroup, nextGroup.id, nextGroup);
+export const patchConditionRule = (rootGroup, ruleId, updater) => updateConditionRule(rootGroup, ruleId, updater);
+export const patchConditionGroup = (rootGroup, groupId, updater) => updateConditionGroup(rootGroup, groupId, updater);
+export const updateConditionRuleOperator = (rootGroup, ruleId, operator) => updateConditionRule(rootGroup, ruleId, (rule) => ({
+    ...rule,
+    operator,
+    ...(isUnaryOperator(operator)
+        ? { right: undefined }
+        : {
+            right: rule.right &&
+                ((operator !== "between" && operator !== "in" && operator !== "not_in") ||
+                    rule.right.valueType === "array")
+                ? cloneConditionOperand(rule.right)
+                : getDefaultRightOperand(operator),
+        }),
+}));
+export const updateConditionRuleLeftOperand = (rootGroup, ruleId, operand) => updateConditionRule(rootGroup, ruleId, (rule) => ({
+    ...rule,
+    left: cloneConditionOperand(operand),
+}));
+export const updateConditionRuleRightOperand = (rootGroup, ruleId, operand) => updateConditionRule(rootGroup, ruleId, (rule) => ({
+    ...rule,
+    right: cloneConditionOperand(operand),
+}));
+export const buildConditionOutputPayload = (config, evaluation) => ({
+    debug: evaluation.tree,
+    expression: evaluation.expression,
+    mode: config.mode,
+    preview: serializeConditionConfigToPreview(config),
+    result: evaluation.result,
+});
+export const getConditionOperatorLabel = (operator) => CONDITION_OPERATOR_META.find((entry) => entry.value === operator)?.label ?? operator;
+export const isConditionOperatorUnary = (operator) => isUnaryOperator(operator);
+export const buildConditionRuntimeRootSetFromKeys = (keys) => new Set(keys);
+export const buildConditionRuntimeRootKeysForNodes = (nodes) => {
+    const nodeLabels = flattenScenarioNodes(nodes)
+        .map((node) => node.data.label.trim())
+        .filter(Boolean);
+    return new Set([
+        "response",
+        "env",
+        "global",
+        "globals",
+        "db",
+        "kafkaEvent",
+        "kafkaevent",
+        "redis",
+        "lastResponse",
+        ...nodeLabels,
+    ]);
+};
+export const buildConditionRuntimeSuggestions = ({ nodes, environmentKeys = [], }) => dedupeSuggestions([
+    ...BUILT_IN_RUNTIME_SUGGESTIONS,
+    ...environmentKeys.map((key) => createSuggestion("Environment", `env.${key}`, `Environment variable "${key}".`, "string")),
+    ...flattenScenarioNodes(nodes).flatMap((node) => {
+        const label = node.data.label.trim();
+        return label ? buildNodeSuggestions(label, node.type) : [];
+    }),
+]);
+export const filterConditionRuntimeSuggestions = ({ query, suggestions, limit = 40, }) => {
+    const normalizedQuery = query.trim().toLowerCase();
+    const filtered = normalizedQuery
+        ? suggestions.filter((suggestion) => {
+            const haystacks = [
+                suggestion.group.toLowerCase(),
+                suggestion.path.toLowerCase(),
+                suggestion.description.toLowerCase(),
+            ];
+            return haystacks.some((haystack) => haystack.includes(normalizedQuery));
+        })
+        : suggestions;
+    return filtered.slice(0, limit);
+};
+export const createConditionConfigFromLegacyExpression = (expression) => {
+    const normalizedExpression = normalizeWhitespace(expression);
+    if (!normalizedExpression) {
+        return createDefaultConditionConfig();
+    }
+    try {
+        const rootGroup = parseConditionExpressionToGroup(normalizedExpression);
+        return {
+            mode: "builder",
+            rootGroup,
+            expertExpression: serializeConditionGroupToExpression(rootGroup),
+        };
+    }
+    catch {
+        return {
+            mode: "expert",
+            rootGroup: createDefaultConditionConfig().rootGroup,
+            expertExpression: normalizedExpression,
+        };
+    }
+};
+export const convertLegacyConditionOperator = (value) => parseLegacyConditionOperator(value);
+//# sourceMappingURL=condition.js.map