norn-cli 2.2.2 → 2.4.0

package/out/sequenceRunner.js

@@ -0,0 +1,3590 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHeaderGroupsToRequest = void 0;
+exports.extractReturnVariables = extractReturnVariables;
+exports.splitNamedArgumentList = splitNamedArgumentList;
+exports.parseRunMcpListCommand = parseRunMcpListCommand;
+exports.parseRunMcpCallCommand = parseRunMcpCallCommand;
+exports.parseRunSqlCommand = parseRunSqlCommand;
+exports.bindSequenceArguments = bindSequenceArguments;
+exports.parseTagFilter = parseTagFilter;
+exports.sequenceMatchesTags = sequenceMatchesTags;
+exports.validateSequenceParameters = validateSequenceParameters;
+exports.extractSequences = extractSequences;
+exports.getSequenceAtLine = getSequenceAtLine;
+exports.countSequenceSteps = countSequenceSteps;
+exports.extractStepsFromSequence = extractStepsFromSequence;
+exports.runSequence = runSequence;
+exports.runSequenceWithJar = runSequenceWithJar;
+const parser_1 = require("./parser");
+const httpClient_1 = require("./httpClient");
+const scriptRunner_1 = require("./scriptRunner");
+const assertionRunner_1 = require("./assertionRunner");
+const jsonFileReader_1 = require("./jsonFileReader");
+const formatError_1 = require("./errors/formatError");
+const requestValidation_1 = require("./requestValidation");
+const quotedString_1 = require("./quotedString");
+const pathAccess_1 = require("./pathAccess");
+const stringUtils_1 = require("./stringUtils");
+const sqlConfig_1 = require("./sqlConfig");
+const sqlAdapterRunner_1 = require("./sqlAdapterRunner");
+const mcpClient_1 = require("./mcpClient");
+const requestPreparation_1 = require("./requestPreparation");
+const environmentTemplates_1 = require("./environmentTemplates");
+const mcpToolSchema_1 = require("./mcpToolSchema");
+var requestPreparation_2 = require("./requestPreparation");
+Object.defineProperty(exports, "applyHeaderGroupsToRequest", { enumerable: true, get: function () { return requestPreparation_2.applyHeaderGroupsToRequest; } });
+function indentMultiline(value, prefix = '  ') {
+    return value
+        .split('\n')
+        .map(line => `${prefix}${line}`)
+        .join('\n');
+}
+/**
+ * Checks if a line is a "run <RequestName>" or "run <Name>(args)" command (for named requests/sequences)
+ * Also supports retry/backoff options: "run Name retry 3 backoff 500 ms"
+ */
+function isRunNamedRequestCommand(line) {
+    const trimmed = line.trim();
+    // Match "run <name>" or "run <name>(args)" but NOT "run bash", "run js", "run powershell"
+    if (!trimmed.toLowerCase().startsWith('run ')) {
+        return false;
+    }
+    const afterRun = trimmed.substring(4).trim();
+    // Exclude script commands
+    if (/^(bash|js|powershell|sql|mcp)\s+/i.test(afterRun)) {
+        return false;
+    }
+    // Must have a valid identifier (optionally followed by args in parentheses)
+    // Also allow retry/backoff options at the end - use specific patterns
+    return /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?$/i.test(afterRun);
+}
+/**
+ * Parses a "run <RequestName>" or "run <Name>(args)" command.
+ * Returns the request name, optional arguments, and retry/backoff options.
+ */
+function parseRunNamedRequestCommand(line) {
+    const trimmed = line.trim();
+    // Extract retry/backoff options first using the shared function
+    const { cleanedLine, retryCount, backoffMs } = (0, parser_1.extractRetryOptions)(trimmed);
+    // Now parse the cleaned line for name and args
+    const match = cleanedLine.match(/^run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        name: match[1],
+        args: parseRunArguments(match[2] || ''),
+        retryCount,
+        backoffMs
+    };
+}
+/**
+ * Checks if a line is a return statement (return var1, var2)
+ */
+function isReturnStatement(line) {
+    return /^return\s+/i.test(line.trim());
+}
+/**
+ * Parses a return statement and extracts the return expressions.
+ * Supports:
+ *   return token, userId        - variable names
+ *   return repaymentId.value    - path into variable
+ *   return "done"               - quoted string literals
+ *   return {{repaymentId.value}} - template syntax (also supported)
+ */
+function parseReturnStatement(line) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^return\s+(.+)$/i);
+    if (!match) {
+        return null;
+    }
+    // Split by comma and trim each expression
+    // Also strip {{ }} if present for convenience
+    return match[1].split(',').map(v => {
+        let expr = v.trim();
+        // Remove {{ }} wrapper if present
+        if (expr.startsWith('{{') && expr.endsWith('}}')) {
+            expr = expr.slice(2, -2).trim();
+        }
+        return expr;
+    }).filter(v => v.length > 0);
+}
+/**
+ * Resolves a return expression to get the actual value.
+ * Handles:
+ *   - Simple variable: "token" -> runtimeVariables["token"]
+ *   - Path expression: "repaymentId.value" -> parse JSON and get nested value
+ *   - Array access: "id[0].prop" -> array and object navigation
+ */
+function resolveReturnExpression(expr, runtimeVariables) {
+    // Extract the base variable name (before any . or [)
+    const varNameMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+    if (!varNameMatch) {
+        return null;
+    }
+    const varName = varNameMatch[1];
+    const pathPart = expr.substring(varName.length);
+    if (!(varName in runtimeVariables)) {
+        return null;
+    }
+    const varValue = runtimeVariables[varName];
+    // Simple variable (no path)
+    if (!pathPart) {
+        return { key: varName, value: varValue };
+    }
+    // Navigate the path
+    try {
+        // Parse the value if it's a string (could be JSON)
+        let current = parseJsonBackedValue(varValue);
+        const parts = (0, pathAccess_1.getPathSegments)(pathPart);
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return null;
+            }
+            current = (0, pathAccess_1.getPathPartValue)(current, part);
+        }
+        // Use the last part of the path as the key name
+        const keyName = parts[parts.length - 1] || varName;
+        return { key: keyName, value: current };
+    }
+    catch {
+        // Navigation failed
+        return { key: varName, value: varValue };
+    }
+}
+/**
+ * Resolves a single return expression to its raw value.
+ * Supports variables, paths, and literal values such as "done", 123, true, and null.
+ */
+function resolveSingleReturnValue(expr, runtimeVariables) {
+    const result = evaluateSqlArgumentExpression(expr, runtimeVariables);
+    return result.error ? '' : result.value;
+}
+/**
+ * Extracts the return statement from sequence content.
+ * Returns the list of return expressions, or null if no return statement.
+ */
+function extractReturnVariables(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (isReturnStatement(line)) {
+            return parseReturnStatement(line);
+        }
+    }
+    return null;
+}
+function buildParsedNamedRequest(requestContent, runtimeVariables, apiDefinitions) {
+    return (0, requestPreparation_1.prepareRequestFromContent)(requestContent, runtimeVariables, apiDefinitions).request;
+}
+/**
+ * Parses arguments from a run command.
+ * Supports: run Name(arg1, arg2) or run Name(param: value, param2: value2)
+ */
+function parseRunArguments(argsStr) {
+    const args = [];
+    if (!argsStr || !argsStr.trim()) {
+        return args;
+    }
+    // Split by comma, respecting quoted strings and {{}} 
+    const parts = argsStr.split(/,(?=(?:[^"]*"[^"]*")*(?:[^{]*\{\{[^}]*\}\})*[^"]*$)/);
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        // Check for named argument: param: value
+        const namedMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+        if (namedMatch) {
+            let value = namedMatch[2].trim();
+            // Strip quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = (0, quotedString_1.decodeQuotedStringLiteral)(value);
+            }
+            args.push({
+                name: namedMatch[1],
+                value
+            });
+        }
+        else {
+            // Positional argument
+            let value = trimmed;
+            // Strip quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = (0, quotedString_1.decodeQuotedStringLiteral)(value);
+            }
+            args.push({ value });
+        }
+    }
+    return args;
+}
+function splitNamedArgumentList(argsStr) {
+    const parts = [];
+    let current = '';
+    let quoteChar = null;
+    let templateDepth = 0;
+    let bracketDepth = 0;
+    for (let i = 0; i < argsStr.length; i++) {
+        const char = argsStr[i];
+        const next = i + 1 < argsStr.length ? argsStr[i + 1] : '';
+        const prev = i > 0 ? argsStr[i - 1] : '';
+        if (quoteChar) {
+            current += char;
+            if (char === quoteChar && prev !== '\\') {
+                quoteChar = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quoteChar = char;
+            current += char;
+            continue;
+        }
+        if (char === '{' && next === '{') {
+            templateDepth++;
+            current += '{{';
+            i++;
+            continue;
+        }
+        if (char === '}' && next === '}' && templateDepth > 0) {
+            templateDepth--;
+            current += '}}';
+            i++;
+            continue;
+        }
+        if (templateDepth === 0) {
+            if (char === '(' || char === '[' || char === '{') {
+                bracketDepth++;
+                current += char;
+                continue;
+            }
+            if (char === ')' || char === ']' || char === '}') {
+                bracketDepth = Math.max(0, bracketDepth - 1);
+                current += char;
+                continue;
+            }
+            if (char === ',' && bracketDepth === 0) {
+                parts.push(current.trim());
+                current = '';
+                continue;
+            }
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+function parseSqlArguments(argsStr) {
+    if (!argsStr.trim()) {
+        return { args: [] };
+    }
+    const parts = splitNamedArgumentList(argsStr);
+    const args = [];
+    let sawNamedArgument = false;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+        if (match) {
+            sawNamedArgument = true;
+            args.push({
+                name: match[1],
+                valueExpression: match[2].trim()
+            });
+            continue;
+        }
+        if (sawNamedArgument) {
+            return {
+                args: [],
+                error: 'Positional SQL arguments cannot follow named arguments.'
+            };
+        }
+        args.push({
+            valueExpression: trimmed
+        });
+    }
+    return { args };
+}
+function isRunMcpListCommand(line) {
+    return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s+list\s+[a-zA-Z_][a-zA-Z0-9_-]*\s*$/i.test(line.trim());
+}
+function parseRunMcpListCommand(line) {
+    const match = line.trim().match(/^(?:var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*)?run\s+mcp\s+list\s+([a-zA-Z_][a-zA-Z0-9_-]*)\s*$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        variableName: match[1],
+        serverAlias: match[2]
+    };
+}
+function parseMcpArguments(argsStr) {
+    if (!argsStr.trim()) {
+        return { args: [] };
+    }
+    const parts = splitNamedArgumentList(argsStr);
+    const args = [];
+    let sawNamedArgument = false;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+        if (match) {
+            sawNamedArgument = true;
+            args.push({
+                name: match[1],
+                valueExpression: match[2].trim()
+            });
+            continue;
+        }
+        if (sawNamedArgument) {
+            return {
+                args: [],
+                error: 'Positional MCP arguments cannot follow named arguments.'
+            };
+        }
+        args.push({
+            valueExpression: trimmed
+        });
+    }
+    return { args };
+}
+function isRunMcpCallCommand(line) {
+    return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s+call\s+[a-zA-Z_][a-zA-Z0-9_-]*\s+[a-zA-Z_][a-zA-Z0-9_.:-]*(?:\s*\(.*\))?\s*$/i.test(line.trim());
+}
+function parseRunMcpCallCommand(line) {
+    const match = line.trim().match(/^(?:var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*)?run\s+mcp\s+call\s+([a-zA-Z_][a-zA-Z0-9_-]*)\s+([a-zA-Z_][a-zA-Z0-9_.:-]*)(?:\s*\((.*)\))?\s*$/i);
+    if (!match) {
+        return null;
+    }
+    const parsedArgs = parseMcpArguments(match[4] || '');
+    if (parsedArgs.error) {
+        return {
+            variableName: match[1],
+            serverAlias: match[2],
+            toolName: match[3],
+            args: [],
+            error: parsedArgs.error
+        };
+    }
+    return {
+        variableName: match[1],
+        serverAlias: match[2],
+        toolName: match[3],
+        args: parsedArgs.args
+    };
+}
+function isRunSqlCommand(line) {
+    return /^run\s+sql\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(line.trim());
+}
+function parseRunSqlCommand(line) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^(?:var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*)?run\s+sql\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\((.*)\))?\s*$/i);
+    if (!match) {
+        return null;
+    }
+    const parsedArgs = parseSqlArguments(match[3] || '');
+    if (parsedArgs.error) {
+        return {
+            variableName: match[1],
+            operationName: match[2],
+            args: [],
+            error: parsedArgs.error
+        };
+    }
+    return {
+        variableName: match[1],
+        operationName: match[2],
+        args: parsedArgs.args
+    };
+}
+function bindSqlArguments(parameterNames, args, runtimeVariables) {
+    const resolvedParams = {};
+    const boundParams = new Set();
+    let positionalIndex = 0;
+    let sawNamedArgument = false;
+    for (const arg of args) {
+        if (arg.name) {
+            sawNamedArgument = true;
+            const declaredParam = parameterNames.find(param => param.toLowerCase() === arg.name.toLowerCase());
+            if (!declaredParam) {
+                return { error: `Unknown SQL parameter '${arg.name}'.` };
+            }
+            const declaredLower = declaredParam.toLowerCase();
+            if (boundParams.has(declaredLower)) {
+                return { error: `Duplicate SQL parameter '${declaredParam}' in run sql call.` };
+            }
+            const valueResult = evaluateSqlArgumentExpression(arg.valueExpression, runtimeVariables);
+            if (valueResult.error) {
+                return { error: valueResult.error };
+            }
+            resolvedParams[declaredParam] = valueResult.value;
+            boundParams.add(declaredLower);
+            continue;
+        }
+        if (sawNamedArgument) {
+            return { error: 'Positional SQL arguments cannot follow named arguments.' };
+        }
+        if (positionalIndex >= parameterNames.length) {
+            return { error: `Too many SQL arguments: expected ${parameterNames.length}.` };
+        }
+        const declaredParam = parameterNames[positionalIndex];
+        const valueResult = evaluateSqlArgumentExpression(arg.valueExpression, runtimeVariables);
+        if (valueResult.error) {
+            return { error: valueResult.error };
+        }
+        resolvedParams[declaredParam] = valueResult.value;
+        boundParams.add(declaredParam.toLowerCase());
+        positionalIndex++;
+    }
+    for (const param of parameterNames) {
+        if (!boundParams.has(param.toLowerCase())) {
+            return { error: `Missing required SQL parameter '${param}'.` };
+        }
+    }
+    return { params: resolvedParams };
+}
+function evaluateMcpArgumentExpression(expr, runtimeVariables) {
+    const trimmed = expr.trim();
+    if (!trimmed) {
+        return { value: '' };
+    }
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            const resolvedJson = (0, parser_1.substituteVariables)(trimmed, runtimeVariables);
+            return { value: JSON.parse(resolvedJson) };
+        }
+        catch (error) {
+            return {
+                value: undefined,
+                error: `Invalid MCP JSON argument: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    return evaluateSqlArgumentExpression(expr, runtimeVariables);
+}
+function bindMcpArguments(tool, args, runtimeVariables) {
+    const parameterNames = (0, mcpToolSchema_1.getMcpToolInputParameterNames)(tool);
+    const requiredParameterNames = (0, mcpToolSchema_1.getMcpToolRequiredParameterNames)(tool);
+    const allowsAdditionalProperties = (0, mcpToolSchema_1.mcpToolAllowsAdditionalProperties)(tool);
+    const resolvedParams = {};
+    const boundNames = new Set();
+    let positionalIndex = 0;
+    let sawNamedArgument = false;
+    for (const arg of args) {
+        if (arg.name) {
+            sawNamedArgument = true;
+            const declaredParam = parameterNames.find(param => param.toLowerCase() === arg.name.toLowerCase());
+            const resolvedName = declaredParam ?? arg.name;
+            const normalizedName = resolvedName.toLowerCase();
+            if (!declaredParam && !allowsAdditionalProperties) {
+                return { error: `Unknown MCP parameter '${arg.name}' for tool '${tool.name}'.` };
+            }
+            if (boundNames.has(normalizedName)) {
+                return { error: `Duplicate MCP parameter '${resolvedName}' in tool call.` };
+            }
+            const valueResult = evaluateMcpArgumentExpression(arg.valueExpression, runtimeVariables);
+            if (valueResult.error) {
+                return { error: valueResult.error };
+            }
+            resolvedParams[resolvedName] = valueResult.value;
+            boundNames.add(normalizedName);
+            continue;
+        }
+        if (sawNamedArgument) {
+            return { error: 'Positional MCP arguments cannot follow named arguments.' };
+        }
+        if (positionalIndex >= parameterNames.length) {
+            if (parameterNames.length === 0) {
+                return { error: `Tool '${tool.name}' does not declare positional parameters.` };
+            }
+            return { error: `Too many MCP arguments for tool '${tool.name}': expected at most ${parameterNames.length}.` };
+        }
+        const valueResult = evaluateMcpArgumentExpression(arg.valueExpression, runtimeVariables);
+        if (valueResult.error) {
+            return { error: valueResult.error };
+        }
+        const resolvedName = parameterNames[positionalIndex];
+        resolvedParams[resolvedName] = valueResult.value;
+        boundNames.add(resolvedName.toLowerCase());
+        positionalIndex++;
+    }
+    for (const requiredName of requiredParameterNames) {
+        if (!boundNames.has(requiredName.toLowerCase())) {
+            return { error: `Missing required MCP parameter '${requiredName}' for tool '${tool.name}'.` };
+        }
+    }
+    return { params: resolvedParams };
+}
+/**
+ * Checks if a line is a "var x = run SequenceName" or "var x = run SequenceName(args)" command.
+ * Also supports retry/backoff options: "var x = run Name retry 3 backoff 500 ms"
+ * Excludes script types (bash, powershell, js) which are handled by isRunCommand.
+ */
+function isVarRunSequenceCommand(line) {
+    const trimmed = line.trim();
+    // First check the basic pattern - allow retry/backoff options at the end
+    // Use specific patterns for retry (retry N) and backoff (backoff N [unit])
+    if (!/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?\s*$/i.test(trimmed)) {
+        return false;
+    }
+    // Exclude script types - these should be handled by isRunCommand
+    const match = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+([a-zA-Z_][a-zA-Z0-9_-]*)/i);
+    if (match) {
+        const name = match[1].toLowerCase();
+        if (name === 'bash' || name === 'powershell' || name === 'js' || name === 'sql' || name === 'readjson' || name === 'mcp') {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Parses a "var x = run SequenceName" or "var x = run SequenceName(args)" command.
+ * Returns the variable name, sequence name, arguments, and retry/backoff options.
+ */
+function parseVarRunSequenceCommand(line) {
+    const trimmed = line.trim();
+    // Extract retry/backoff options first using the shared function
+    const { cleanedLine, retryCount, backoffMs } = (0, parser_1.extractRetryOptions)(trimmed);
+    const match = cleanedLine.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?\s*$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        varName: match[1],
+        sequenceName: match[2],
+        args: parseRunArguments(match[3] || ''),
+        retryCount,
+        backoffMs
+    };
+}
+/**
+ * Checks if a line is a plain "run SequenceName" or "run SequenceName(args)" command
+ */
+function isRunSequenceCommand(line) {
+    const trimmed = line.trim();
+    // Must not start with "var" - that's handled by isVarRunSequenceCommand
+    if (/^var\s+/i.test(trimmed)) {
+        return false;
+    }
+    return /^run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(trimmed);
+}
+/**
+ * Parses a plain "run SequenceName" or "run SequenceName(args)" command.
+ */
+function parseRunSequenceCommand(line) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?\s*$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        sequenceName: match[1],
+        args: parseRunArguments(match[2] || '')
+    };
+}
+/**
+ * Binds arguments to parameters, resolving positional and named arguments.
+ * Returns the resulting variables to inject into the sequence scope, or an error message.
+ *
+ * Rules:
+ * - Positional args are bound in order
+ * - Named args can be in any order
+ * - Required params (no default) must be provided
+ * - Optional params use default if not provided
+ * - Cannot mix positional after named
+ */
+function bindSequenceArguments(params, args, runtimeVariables) {
+    const result = {};
+    const boundParams = new Set();
+    let positionalIndex = 0;
+    let sawNamedArg = false;
+    for (const arg of args) {
+        if (arg.name) {
+            // Named argument
+            sawNamedArg = true;
+            const param = params.find(p => p.name === arg.name);
+            if (!param) {
+                return { error: `Unknown parameter: "${arg.name}"` };
+            }
+            if (boundParams.has(arg.name)) {
+                return { error: `Parameter "${arg.name}" provided multiple times` };
+            }
+            const value = resolveSequenceArgumentValue(arg.value, runtimeVariables);
+            result[arg.name] = value;
+            boundParams.add(arg.name);
+        }
+        else {
+            // Positional argument
+            if (sawNamedArg) {
+                return { error: 'Positional arguments cannot follow named arguments' };
+            }
+            if (positionalIndex >= params.length) {
+                return { error: `Too many arguments: expected ${params.length}, got more` };
+            }
+            const param = params[positionalIndex];
+            const value = resolveSequenceArgumentValue(arg.value, runtimeVariables);
+            result[param.name] = value;
+            boundParams.add(param.name);
+            positionalIndex++;
+        }
+    }
+    // Check for missing required params and apply defaults
+    for (const param of params) {
+        if (!boundParams.has(param.name)) {
+            if (param.defaultValue !== undefined) {
+                result[param.name] = param.defaultValue;
+            }
+            else {
+                return { error: `Missing required argument: "${param.name}"` };
+            }
+        }
+    }
+    return { variables: result };
+}
+/**
+ * Helper to get a value by path from a variables object, supporting nested access.
+ * Used for resolving argument values from runtime variables.
+ */
+function parseJsonBackedValue(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function getVariableValueByPath(path, variables) {
+    const parts = (0, pathAccess_1.getPathSegments)(path);
+    let current = variables;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return '';
+        }
+        if (typeof current === 'string') {
+            current = parseJsonBackedValue(current);
+            if (typeof current === 'string') {
+                return '';
+            }
+        }
+        current = (0, pathAccess_1.getPathPartValue)(current, part);
+    }
+    if (current === null || current === undefined) {
+        return '';
+    }
+    return current;
+}
+function resolveSequenceArgumentValue(value, runtimeVariables) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('{{') && trimmed.endsWith('}}')) {
+        return getVariableValueByPath(trimmed.slice(2, -2).trim(), runtimeVariables);
+    }
+    if (trimmed in runtimeVariables) {
+        return runtimeVariables[trimmed];
+    }
+    const pathMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])+)$/);
+    if (pathMatch && pathMatch[1] in runtimeVariables) {
+        return getVariableValueByPath(trimmed, runtimeVariables);
+    }
+    return value;
+}
+function createPrintStepResult(stepIndex, stepStartTime, sequenceStartTime, title, body) {
+    const now = Date.now();
+    return {
+        type: 'print',
+        stepIndex,
+        durationMs: now - stepStartTime,
+        print: {
+            title,
+            body,
+            timestamp: now - sequenceStartTime
+        }
+    };
+}
+/**
+ * Parses a tag filter string into a TagFilter object.
+ * Supports: "smoke" (simple) and "team(CustomerExp)" (key-value)
+ */
+function parseTagFilter(filterStr) {
+    const match = filterStr.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?$/);
+    if (!match) {
+        return { name: filterStr }; // Fallback to treating entire string as name
+    }
+    return {
+        name: match[1],
+        value: match[2]?.trim()
+    };
+}
+/**
+ * Checks if a sequence tag matches a filter.
+ * Case-insensitive comparison for both name and value.
+ * If filter has no value, matches any tag with that name.
+ * If filter has a value, requires exact (case-insensitive) match.
+ */
+function tagMatchesFilter(tag, filter) {
+    // Case-insensitive name comparison
+    if (tag.name.toLowerCase() !== filter.name.toLowerCase()) {
+        return false;
+    }
+    // If filter has no value requirement, any value matches (including no value)
+    if (filter.value === undefined) {
+        return true;
+    }
+    // If filter has value requirement, tag must have matching value
+    if (tag.value === undefined) {
+        return false;
+    }
+    return tag.value.toLowerCase() === filter.value.toLowerCase();
+}
+/**
+ * Checks if a sequence matches the tag filter options.
+ * @param sequence The sequence to check
+ * @param options The filter options (filters and mode)
+ * @returns true if the sequence matches according to the filter mode
+ */
+function sequenceMatchesTags(sequence, options) {
+    if (options.filters.length === 0) {
+        return true; // No filters = match all
+    }
+    if (options.mode === 'and') {
+        // Must match ALL filters
+        return options.filters.every(filter => sequence.tags.some(tag => tagMatchesFilter(tag, filter)));
+    }
+    else {
+        // Must match ANY filter
+        return options.filters.some(filter => sequence.tags.some(tag => tagMatchesFilter(tag, filter)));
+    }
+}
+/**
+ * Parses sequence parameters from a sequence declaration line.
+ * Supports: sequence Name(param1, param2 = "default")
+ * Returns empty array if no parameters.
+ */
+function parseSequenceParameters(line) {
+    const params = [];
+    // Match the parentheses content
+    const parenMatch = line.match(/\(([^)]*)\)/);
+    if (!parenMatch) {
+        return params;
+    }
+    const paramsStr = parenMatch[1].trim();
+    if (!paramsStr) {
+        return params;
+    }
+    // Split by comma, but handle quoted strings
+    const paramParts = paramsStr.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/);
+    let hasSeenDefault = false;
+    for (const part of paramParts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        // Check for param = value pattern
+        const defaultMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/);
+        if (defaultMatch) {
+            hasSeenDefault = true;
+            let defaultValue = defaultMatch[2].trim();
+            // Strip quotes if present
+            if ((defaultValue.startsWith('"') && defaultValue.endsWith('"')) ||
+                (defaultValue.startsWith("'") && defaultValue.endsWith("'"))) {
+                defaultValue = (0, quotedString_1.decodeQuotedStringLiteral)(defaultValue);
+            }
+            params.push({
+                name: defaultMatch[1],
+                defaultValue
+            });
+        }
+        else {
+            // No default value
+            const nameMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
+            if (nameMatch) {
+                // Error: required param after optional param
+                if (hasSeenDefault) {
+                    // We'll still add it, but validation should catch this
+                    console.warn(`Required parameter "${nameMatch[1]}" follows optional parameter`);
+                }
+                params.push({
+                    name: nameMatch[1]
+                });
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Validates that required parameters come before optional ones.
+ */
+function validateSequenceParameters(params) {
+    let hasSeenDefault = false;
+    for (const param of params) {
+        if (param.defaultValue !== undefined) {
+            hasSeenDefault = true;
+        }
+        else if (hasSeenDefault) {
+            return `Required parameter "${param.name}" cannot come after optional parameter`;
+        }
+    }
+    return null;
+}
+/**
+ * Parses tags from lines immediately preceding a sequence declaration.
+ * Supports: @tagname (simple) and @key(value) (key-value)
+ * Multiple tags can be on the same line or separate lines.
+ * Tag names follow the pattern: [a-zA-Z_][a-zA-Z0-9_-]*
+ *
+ * Also extracts @data(...) and @theory("file.json") annotations for parameterized tests.
+ * @data values are parsed as typed: numbers, booleans, or quoted strings.
+ */
+function parseSequenceTags(lines, sequenceLineIndex) {
+    const tags = [];
+    const dataCases = [];
+    let theorySource;
+    let tagStartLine = sequenceLineIndex;
+    // Look backwards from the sequence line to collect tag lines
+    for (let i = sequenceLineIndex - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        // Skip empty lines between tags and sequence
+        if (!line) {
+            continue;
+        }
+        // Check if this line contains tags (starts with @)
+        if (!line.startsWith('@')) {
+            // Not a tag line, stop looking
+            break;
+        }
+        // Check for @data(...) - parameterized test data
+        const dataMatch = line.match(/^@data\s*\((.+)\)\s*$/);
+        if (dataMatch) {
+            const values = parseDataValues(dataMatch[1]);
+            dataCases.push(values);
+            tagStartLine = i;
+            continue;
+        }
+        // Check for @theory("file.json") - external data file
+        const theoryMatch = line.match(/^@theory\s*\(\s*["']([^"']+)["']\s*\)\s*$/);
+        if (theoryMatch) {
+            theorySource = theoryMatch[1];
+            tagStartLine = i;
+            continue;
+        }
+        // Parse regular tags from this line
+        // Pattern: @tagname or @key(value)
+        const tagPattern = /@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?/g;
+        let match;
+        while ((match = tagPattern.exec(line)) !== null) {
+            const tagName = match[1];
+            // Skip data and theory since we handle them separately
+            if (tagName === 'data' || tagName === 'theory') {
+                continue;
+            }
+            const tagValue = match[2]?.trim();
+            tags.push({
+                name: tagName,
+                value: tagValue
+            });
+        }
+        tagStartLine = i;
+    }
+    // Build theoryData if we have @data or @theory
+    let theoryData;
+    if (dataCases.length > 0 || theorySource) {
+        theoryData = {
+            cases: [], // Will be populated with param names after we know them
+            source: theorySource
+        };
+        // Store raw data cases temporarily - will be bound to param names in extractSequences
+        // Reverse because we collected them in backwards order (iterating up from sequence line)
+        theoryData._rawCases = dataCases.reverse();
+    }
+    return { tags, tagStartLine, theoryData };
+}
+/**
+ * Parses comma-separated values from @data(...) annotation.
+ * Supports: numbers (1, 3.14), booleans (true, false), quoted strings ("hello", 'world')
+ */
+function parseDataValues(valuesStr) {
+    const values = [];
+    let current = '';
+    let inQuote = null;
+    let i = 0;
+    while (i < valuesStr.length) {
+        const char = valuesStr[i];
+        if (inQuote) {
+            if (char === inQuote) {
+                // End of quoted string - add without quotes
+                values.push(current);
+                current = '';
+                inQuote = null;
+                // Skip to next comma or end
+                i++;
+                while (i < valuesStr.length && valuesStr[i] !== ',') {
+                    i++;
+                }
+                i++; // Skip comma
+                continue;
+            }
+            else {
+                current += char;
+            }
+        }
+        else {
+            if (char === '"' || char === "'") {
+                inQuote = char;
+                current = '';
+            }
+            else if (char === ',') {
+                // End of value
+                const trimmed = current.trim();
+                if (trimmed) {
+                    values.push(parseTypedValue(trimmed));
+                }
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        i++;
+    }
+    // Handle last value
+    if (inQuote) {
+        // Unclosed quote - treat as string
+        values.push(current);
+    }
+    else {
+        const trimmed = current.trim();
+        if (trimmed) {
+            values.push(parseTypedValue(trimmed));
+        }
+    }
+    return values;
+}
+/**
+ * Parses a value string into its typed representation.
+ * Numbers become numbers, booleans become booleans, everything else is a string.
+ */
+function parseTypedValue(value) {
+    // Boolean
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    // Null
+    if (value === 'null') {
+        return null;
+    }
+    // Number (integer or float)
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return parseFloat(value);
+    }
+    // String (possibly quoted)
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return (0, quotedString_1.decodeQuotedStringLiteral)(value);
+    }
+    return value;
+}
+/**
+ * Extracts sequence blocks from the document.
+ */
+function extractSequences(text) {
+    const lines = text.split('\n');
+    const sequences = [];
+    let currentSequence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Strip inline comment for matching
+        const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+        // Check for sequence start - supports 'test sequence' and 'sequence', with optional parameters
+        const testSequenceMatch = lineWithoutComment.match(/^test\s+sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?\s*$/);
+        const sequenceMatch = lineWithoutComment.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?\s*$/);
+        if (testSequenceMatch || sequenceMatch) {
+            const isTest = !!testSequenceMatch;
+            const name = isTest ? testSequenceMatch[1] : sequenceMatch[1];
+            const parameters = parseSequenceParameters(lines[i]);
+            const { tags, tagStartLine, theoryData } = parseSequenceTags(lines, i);
+            // If we have raw @data cases, bind them to parameter names
+            let finalTheoryData = theoryData;
+            if (theoryData && theoryData._rawCases) {
+                const rawCases = theoryData._rawCases;
+                // Handle single-param shorthand: @data(1, 2, 3) with single param (id) 
+                // should create 3 cases [{id:1}, {id:2}, {id:3}] not 1 case with 3 values
+                if (parameters.length === 1 && rawCases.length === 1 && rawCases[0].length > 1) {
+                    const paramName = parameters[0].name;
+                    finalTheoryData = {
+                        cases: rawCases[0].map(value => ({ [paramName]: value })),
+                        source: theoryData.source
+                    };
+                }
+                else {
+                    // Normal multi-param case: each @data line is a test case
+                    finalTheoryData = {
+                        cases: rawCases.map(values => {
+                            const caseObj = {};
+                            parameters.forEach((param, idx) => {
+                                caseObj[param.name] = values[idx];
+                            });
+                            return caseObj;
+                        }),
+                        source: theoryData.source
+                    };
+                }
+            }
+            currentSequence = {
+                name,
+                startLine: tagStartLine, // Include tag lines in the sequence range
+                lines: [],
+                parameters,
+                tags,
+                isTest,
+                theoryData: finalTheoryData
+            };
+            continue;
+        }
+        // Check for sequence end
+        if (line === 'end sequence' && currentSequence) {
+            sequences.push({
+                name: currentSequence.name,
+                startLine: currentSequence.startLine,
+                endLine: i,
+                content: currentSequence.lines.join('\n'),
+                parameters: currentSequence.parameters,
+                tags: currentSequence.tags,
+                isTest: currentSequence.isTest,
+                theoryData: currentSequence.theoryData
+            });
+            currentSequence = null;
+            continue;
+        }
+        // Add line to current sequence
+        if (currentSequence) {
+            currentSequence.lines.push(lines[i]);
+        }
+    }
+    return sequences;
+}
+/**
+ * Finds which sequence a line belongs to.
+ */
+function getSequenceAtLine(text, lineNumber) {
+    const sequences = extractSequences(text);
+    return sequences.find(seq => lineNumber >= seq.startLine && lineNumber <= seq.endLine) || null;
+}
+/**
+ * HTTP methods for regex matching
+ */
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+/**
+ * Checks if a line is a variable request assignment: var name = GET/POST/etc url
+ * This captures the response directly into a variable for stable referencing.
+ */
+function isVarRequestCommand(line) {
+    const trimmed = line.trim();
+    const methodPattern = HTTP_METHODS.join('|');
+    const regex = new RegExp(`^var\\s+[a-zA-Z_][a-zA-Z0-9_]*\\s*=\\s*(${methodPattern})\\s+.+$`, 'i');
+    return regex.test(trimmed);
+}
+/**
+ * Parses a variable request command: var name = METHOD url [retry N] [backoff N ms]
+ * Returns the variable name, method, URL, and optional retry options.
+ */
+function parseVarRequestCommand(line) {
+    const trimmed = line.trim();
+    const methodPattern = HTTP_METHODS.join('|');
+    const regex = new RegExp(`^var\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=\\s*(${methodPattern})\\s+(.+)$`, 'i');
+    const match = trimmed.match(regex);
+    if (!match) {
+        return null;
+    }
+    // Extract retry options from the URL part
+    const { cleanedLine: url, retryCount, backoffMs } = (0, parser_1.extractRetryOptions)(match[3].trim());
+    return {
+        varName: match[1],
+        method: match[2].toUpperCase(),
+        url,
+        retryCount,
+        backoffMs
+    };
+}
+/**
+ * Checks if a line is a variable assignment that should be evaluated at runtime.
+ * This handles: var x = someVar.path or var x = "literal string"
+ * Does NOT handle: var x = $1.path (response capture), var x = run ... (script/json), var x = METHOD url (request)
+ */
+function isVarAssignCommand(line) {
+    const trimmed = line.trim();
+    // Must start with 'var'
+    if (!/^var\s+/i.test(trimmed)) {
+        return false;
+    }
+    // Exclude response captures (var x = $1...)
+    if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*\$\d+/.test(trimmed)) {
+        return false;
+    }
+    // Exclude run commands (var x = run ...)
+    if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+/i.test(trimmed)) {
+        return false;
+    }
+    // Exclude request assignments (var x = GET/POST/etc ...)
+    if (isVarRequestCommand(trimmed)) {
+        return false;
+    }
+    // Must have the form: var name = something
+    return /^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+$/.test(trimmed);
+}
+/**
+ * Parses a variable assignment command.
+ * Returns the variable name and the value expression.
+ */
+function parseVarAssignCommand(line) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        varName: match[1],
+        valueExpr: match[2].trim()
+    };
+}
+/**
+ * Evaluates a value expression in the context of runtime variables.
+ *
+ * Supports:
+ * - Quoted strings: "hello" or 'hello' (with {{}} interpolation)
+ * - Variable paths: someVar.property[0].value
+ * - Simple literals: 123, true, false, null
+ */
+function evaluateValueExpression(expr, runtimeVariables) {
+    const trimmed = expr.trim();
+    // Check for quoted string (literal with optional interpolation)
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        // Decode escaped quotes/backslashes, then substitute variables in the literal text.
+        const inner = (0, quotedString_1.decodeQuotedStringLiteral)(trimmed);
+        const substituted = (0, parser_1.substituteVariables)(inner, runtimeVariables);
+        return { value: substituted };
+    }
+    // Check for simple literals
+    if (trimmed === 'true' || trimmed === 'false' || trimmed === 'null') {
+        return { value: trimmed };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return { value: trimmed };
+    }
+    // It's a variable path expression: varName or varName.path or varName[0].path
+    const pathMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+    if (!pathMatch) {
+        return { value: trimmed, error: `Invalid expression: ${trimmed}` };
+    }
+    const varName = pathMatch[1];
+    const pathPart = pathMatch[2] || '';
+    if (!(varName in runtimeVariables)) {
+        return { value: '', error: `Variable '${varName}' is not defined` };
+    }
+    const varValue = runtimeVariables[varName];
+    // If there's a path, navigate into the value
+    if (pathPart) {
+        const dataToNavigate = parseJsonBackedValue(varValue);
+        if (typeof dataToNavigate !== 'object' || dataToNavigate === null) {
+            return { value: String(varValue), error: `Cannot access path on non-object value` };
+        }
+        // Navigate the path
+        const path = pathPart.replace(/^\./, '');
+        const parts = (0, pathAccess_1.getPathSegments)(path);
+        let current = dataToNavigate;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return { value: '', error: `Cannot access '${part}' on null/undefined` };
+            }
+            current = (0, pathAccess_1.getPathPartValue)(current, part);
+        }
+        // Return the result - preserve type for objects/arrays
+        if (current === null) {
+            return { value: null };
+        }
+        if (current === undefined) {
+            return { value: '', error: `Property path '${pathPart}' not found` };
+        }
+        // Return objects/arrays as-is so they can be used in further expressions
+        return { value: current };
+    }
+    // No path, return the variable value as-is
+    return { value: varValue };
+}
+function evaluateSqlArgumentExpression(expr, runtimeVariables) {
+    const trimmed = expr.trim();
+    if (!trimmed) {
+        return { value: '' };
+    }
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        const inner = (0, quotedString_1.decodeQuotedStringLiteral)(trimmed);
+        return { value: (0, parser_1.substituteVariables)(inner, runtimeVariables) };
+    }
+    if (trimmed.startsWith('{{') && trimmed.endsWith('}}')) {
+        return evaluateSqlArgumentExpression(trimmed.slice(2, -2).trim(), runtimeVariables);
+    }
+    if (trimmed === 'true') {
+        return { value: true };
+    }
+    if (trimmed === 'false') {
+        return { value: false };
+    }
+    if (trimmed === 'null') {
+        return { value: null };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return { value: Number(trimmed) };
+    }
+    return evaluateValueExpression(trimmed, runtimeVariables);
+}
+function getSqlConnectionValues(profile, runtimeVariables) {
+    const values = {};
+    const envScope = runtimeVariables.$env && typeof runtimeVariables.$env === 'object'
+        ? runtimeVariables.$env
+        : undefined;
+    if (!envScope) {
+        return values;
+    }
+    const prefix = `${profile}_`;
+    for (const [key, value] of Object.entries(envScope)) {
+        if (!key.startsWith(prefix) || value === undefined || value === null) {
+            continue;
+        }
+        const propertyName = key.slice(prefix.length);
+        if (!propertyName) {
+            continue;
+        }
+        const resolved = (0, environmentTemplates_1.resolveEnvironmentTemplateValue)(key, envScope);
+        if (resolved.errors.length > 0) {
+            const message = resolved.errors.map(error => error.message).join('; ');
+            throw new Error(`Failed to resolve SQL connection value '${key}': ${message}`);
+        }
+        values[propertyName] = resolved.value;
+    }
+    return values;
+}
+function getRuntimeEnvironmentVariables(runtimeVariables) {
+    const envScope = runtimeVariables.$env;
+    if (!envScope || typeof envScope !== 'object' || Array.isArray(envScope)) {
+        return undefined;
+    }
+    const values = {};
+    for (const [key, value] of Object.entries(envScope)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        values[key] = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    return values;
+}
+/**
+ * Checks if a line is a print command.
+ */
+function isPrintCommand(line) {
+    return /^print\s+/i.test(line.trim());
+}
+/**
+ * Parses a print command and returns title and optional body.
+ * Format: print Title | Optional body content
+ */
+function parsePrintCommand(line) {
+    // Strip inline comments before parsing
+    const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+    const match = lineWithoutComment.trim().match(/^print\s+(.+)$/i);
+    if (!match) {
+        return { title: '' };
+    }
+    const content = match[1];
+    const pipeIndex = content.indexOf('|');
+    if (pipeIndex === -1) {
+        // No body, just title
+        return { title: content.trim() };
+    }
+    // Split into title and body
+    const title = content.substring(0, pipeIndex).trim();
+    const body = content.substring(pipeIndex + 1).trim();
+    return { title, body: body || undefined };
+}
+/**
+ * Checks if a line is a wait command.
+ * Formats: wait 2s, wait 500ms, wait 1.5s
+ */
+function isWaitCommand(line) {
+    return /^wait\s+\d+(\.\d+)?\s*(s|ms|seconds?|milliseconds?)?$/i.test(line.trim());
+}
+/**
+ * Parses a wait command and returns the duration in milliseconds.
+ * Formats: wait 2s, wait 500ms, wait 1.5s, wait 2 seconds
+ */
+function parseWaitCommand(line) {
+    const match = line.trim().match(/^wait\s+(\d+(?:\.\d+)?)\s*(s|ms|seconds?|milliseconds?)?$/i);
+    if (!match) {
+        return 0;
+    }
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 's').toLowerCase();
+    // Convert to milliseconds
+    if (unit === 'ms' || unit.startsWith('millisecond')) {
+        return value;
+    }
+    // Default to seconds
+    return value * 1000;
+}
+/**
+ * Resolves bare variable references in text.
+ * A bare variable is a single identifier that matches a defined variable.
+ * Examples: "id" -> value of id, "user.body.name" -> nested access
+ * Does NOT resolve variables inside strings or expressions with operators.
+ * This is used for print statements where bare variable names should be resolved.
+ */
+function resolveBareVariables(text, variables) {
+    const trimmed = text.trim();
+    // Check if the entire text is a bare variable reference (with optional path)
+    // Pattern: varName or varName.path.to.property
+    const bareVarMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+    if (bareVarMatch) {
+        const varName = bareVarMatch[1];
+        const pathPart = bareVarMatch[2] || '';
+        if (varName in variables) {
+            const value = variables[varName];
+            if (pathPart) {
+                // Navigate the path
+                const path = pathPart.replace(/^\./, '');
+                const nestedValue = (0, pathAccess_1.getNestedPathValue)(value, path);
+                return valueToString(nestedValue);
+            }
+            return valueToString(value);
+        }
+    }
+    // For expressions with + or other operators, resolve each bare variable in parts
+    // Split by + and resolve each part, preserving string literals
+    if (text.includes('+')) {
+        const parts = splitExpressionParts(text);
+        const resolvedParts = parts.map(part => {
+            const partTrimmed = part.trim();
+            // If it's a quoted string, keep as-is but remove quotes
+            if ((partTrimmed.startsWith('"') && partTrimmed.endsWith('"')) ||
+                (partTrimmed.startsWith("'") && partTrimmed.endsWith("'"))) {
+                return (0, quotedString_1.decodeQuotedStringLiteral)(partTrimmed);
+            }
+            // If it's a bare variable, resolve it
+            const varMatch = partTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+            if (varMatch) {
+                const varName = varMatch[1];
+                const pathPart = varMatch[2] || '';
+                if (varName in variables) {
+                    const value = variables[varName];
+                    if (pathPart) {
+                        const path = pathPart.replace(/^\./, '');
+                        return valueToString((0, pathAccess_1.getNestedPathValue)(value, path));
+                    }
+                    return valueToString(value);
+                }
+            }
+            // Otherwise, return as-is
+            return partTrimmed;
+        });
+        return resolvedParts.join('');
+    }
+    // No resolution needed
+    return text;
+}
+/**
+ * Split an expression by + operator, respecting string literals
+ */
+function splitExpressionParts(expr) {
+    const parts = [];
+    let current = '';
+    let inString = false;
+    let stringChar = '';
+    let escapeNext = false;
+    for (let i = 0; i < expr.length; i++) {
+        const char = expr[i];
+        if (escapeNext) {
+            current += char;
+            escapeNext = false;
+            continue;
+        }
+        if (inString && char === '\\') {
+            current += char;
+            escapeNext = true;
+            continue;
+        }
+        if (!inString && (char === '"' || char === "'")) {
+            inString = true;
+            stringChar = char;
+            current += char;
+        }
+        else if (inString && char === stringChar) {
+            inString = false;
+            current += char;
+        }
+        else if (!inString && char === '+') {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        parts.push(current);
+    }
+    return parts;
+}
+/**
+ * Convert a value to string for display
+ */
+function valueToString(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Sleep helper function
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Checks if a line is the start of an if block.
+ * Format: if <condition>
+ */
+function isIfCommand(line) {
+    return /^if\s+.+$/i.test(line.trim());
+}
+/**
+ * Checks if a line is the end of an if block.
+ */
+function isEndIfCommand(line) {
+    const trimmed = line.trim().toLowerCase();
+    return trimmed === 'end if' || trimmed === 'endif';
+}
+/**
+ * Parses an if condition.
+ * Reuses assertion parsing logic for the condition.
+ */
+function parseIfCondition(line) {
+    const match = line.trim().match(/^if\s+(.+)$/i);
+    return match ? match[1].trim() : null;
+}
+/**
+ * Evaluates an if condition using the same logic as assertions.
+ * Supports: ==, !=, >, >=, <, <=, contains, exists, !exists, isType
+ */
+function evaluateIfCondition(condition, responses, variables, getValueByPathFn) {
+    // Wrap condition as "assert <condition>" to reuse parsing
+    const parsed = (0, assertionRunner_1.parseAssertCommand)(`assert ${condition}`);
+    if (!parsed) {
+        // Can't parse - treat as false
+        return false;
+    }
+    const result = (0, assertionRunner_1.evaluateAssertion)(parsed, responses, variables, getValueByPathFn);
+    return result.passed;
+}
+/**
+ * Counts the number of steps in a sequence (for progress reporting).
+ */
+function countSequenceSteps(sequenceContent) {
+    // Match the streaming response panel count to the steps that are actually shown.
+    // Wait steps are handled as execution delays but are not rendered as visible rows there.
+    return extractStepsFromSequence(sequenceContent)
+        .filter(step => step.type !== 'wait')
+        .length;
+}
+/**
+ * Extracts steps (requests, run commands, and print statements) from a sequence block.
+ */
+function extractStepsFromSequence(content) {
+    const lines = content.split('\n');
+    const steps = [];
+    const methodRegex = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+    // Boundaries that end a pending request-like block and start a new step.
+    const stepBoundaryRegex = /^(###|(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+|(test\s+)?sequence\s+|end\s+sequence|end\s+if|endif\b|var\s+|run\s+|print\s+|assert\s+|if\s+|wait\s+|import\s+|return\s+|\[)/i;
+    let currentRequest = [];
+    let currentRequestStartLine = -1;
+    let inRequest = false;
+    // Track varRequest with body support (var x = POST Endpoint Headers + body lines)
+    let currentVarRequest = [];
+    let currentVarRequestStartLine = -1;
+    let inVarRequest = false;
+    // Helper to save pending varRequest
+    const savePendingVarRequest = () => {
+        if (currentVarRequest.length > 0) {
+            steps.push({
+                type: 'varRequest',
+                content: currentVarRequest.join('\n'),
+                lineNumber: currentVarRequestStartLine,
+            });
+            currentVarRequest = [];
+            inVarRequest = false;
+        }
+    };
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        const trimmed = line.trim();
+        // Check if this is an assert command
+        if ((0, assertionRunner_1.isAssertCommand)(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the assertion step
+            steps.push({
+                type: 'assertion',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is an if command
+        if (isIfCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the if step with the condition
+            const condition = parseIfCondition(trimmed);
+            steps.push({
+                type: 'if',
+                content: condition || '',
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is an end if command
+        if (isEndIfCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the endif step
+            steps.push({
+                type: 'endif',
+                content: '',
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a print command
+        if (isPrintCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the print step - store raw line for later parsing with variable substitution
+            steps.push({
+                type: 'print',
+                content: trimmed, // Store the full print command
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a wait command
+        if (isWaitCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the wait step
+            steps.push({
+                type: 'wait',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a JSON file load command (var x = run readJson ./path.json)
+        if ((0, jsonFileReader_1.isJsonCommand)(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the JSON load step
+            steps.push({
+                type: 'json',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a property assignment (config.property = value)
+        if ((0, jsonFileReader_1.isPropertyAssignment)(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the property assignment step
+            steps.push({
+                type: 'propAssign',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check for script run commands (run bash, run js, run powershell) including var x = run ...
+        // Must check BEFORE isVarRunSequenceCommand to avoid treating "powershell" as a sequence name
+        if ((0, scriptRunner_1.isRunCommand)(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the script step
+            steps.push({
+                type: 'script',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        if (isRunSqlCommand(trimmed) || /^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+sql\b/i.test(trimmed)) {
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            steps.push({
+                type: 'sql',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        if (isRunMcpListCommand(trimmed)) {
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            steps.push({
+                type: 'mcpList',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        if (isRunMcpCallCommand(trimmed)) {
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            steps.push({
+                type: 'mcpCall',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a "var x = run SequenceName" command (capture sequence result)
+        // Must check BEFORE isRunNamedRequestCommand since it also involves "run"
+        if (isVarRunSequenceCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the varRunSequence step
+            steps.push({
+                type: 'varRunSequence',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a run command (including var x = run ...)
+        // First check for "run <RequestName>" (named request invocation)
+        if (isRunNamedRequestCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the named request step - store the whole line so we can parse args later
+            steps.push({
+                type: 'namedRequest',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a variable request assignment (var x = GET/POST url)
+        // This must come before varAssign check since it also starts with 'var'
+        if (isVarRequestCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Start collecting the variable request (may have body on subsequent lines)
+            currentVarRequest = [trimmed];
+            currentVarRequestStartLine = lineIdx;
+            inVarRequest = true;
+            continue;
+        }
+        // Check if this is a variable assignment (var x = expr or var x = "string")
+        // This must come after run command check to not catch var x = run ...
+        if (isVarAssignCommand(trimmed)) {
+            // Save any pending request/varRequest first
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+                currentRequest = [];
+                inRequest = false;
+            }
+            savePendingVarRequest();
+            // Add the variable assignment step
+            steps.push({
+                type: 'varAssign',
+                content: trimmed,
+                lineNumber: lineIdx,
+            });
+            continue;
+        }
+        // Check if this is a new HTTP request (use trimmed for detection)
+        if (methodRegex.test(trimmed)) {
+            // Save previous request if exists
+            if (currentRequest.length > 0) {
+                steps.push({
+                    type: 'request',
+                    content: currentRequest.join('\n'),
+                    lineNumber: currentRequestStartLine,
+                });
+            }
+            savePendingVarRequest();
+            // Use trimmed line for the request content
+            currentRequest = [trimmed];
+            currentRequestStartLine = lineIdx;
+            inRequest = true;
+        }
+        else if (inVarRequest) {
+            // Keep collecting all request lines (headers/body/comments/blank lines)
+            // until we hit a new command boundary.
+            if (trimmed !== '' && stepBoundaryRegex.test(trimmed)) {
+                savePendingVarRequest();
+                // Re-process this line as the next command.
+                lineIdx--;
+            }
+            else {
+                currentVarRequest.push(trimmed);
+            }
+        }
+        else if (inRequest) {
+            // Check if this is a var line with $N reference (capture) - don't include in request
+            if (trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*\$\d+/)) {
+                // This is a capture line, end the current request
+                if (currentRequest.length > 0) {
+                    steps.push({
+                        type: 'request',
+                        content: currentRequest.join('\n'),
+                        lineNumber: currentRequestStartLine,
+                    });
+                    currentRequest = [];
+                    inRequest = false;
+                }
+            }
+            else if (trimmed === '' || trimmed.startsWith('#') || trimmed.startsWith('var ')) {
+                // Empty lines, comments, or static vars might be part of request context
+                if (trimmed.startsWith('var ') && !trimmed.match(/\$\d+/)) {
+                    // Static var, keep going - use trimmed
+                    currentRequest.push(trimmed);
+                }
+                else if (trimmed.startsWith('#')) {
+                    // Comment, keep in request - use trimmed
+                    currentRequest.push(trimmed);
+                }
+                else {
+                    // Empty line - could be body separator or end
+                    currentRequest.push(trimmed);
+                }
+            }
+            else {
+                // Use trimmed for request body lines too
+                currentRequest.push(trimmed);
+            }
+        }
+    }
+    // Don't forget the last request or varRequest
+    if (currentRequest.length > 0) {
+        steps.push({
+            type: 'request',
+            content: currentRequest.join('\n'),
+            lineNumber: currentRequestStartLine,
+        });
+    }
+    savePendingVarRequest();
+    return steps;
+}
+/**
+ * Extracts individual requests from a sequence block.
+ * @deprecated Use extractStepsFromSequence instead
+ */
+function extractRequestsFromSequence(content) {
+    return extractStepsFromSequence(content)
+        .filter(s => s.type === 'request')
+        .map(s => s.content);
+}
+function extractCaptureDirectives(content) {
+    const captures = [];
+    // Match: var x = $1  OR  var x = $1.path  OR  var x = $1[0]  OR  var x = $1[0].path
+    const captureRegex = /^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*\$(\d+)([\.\[].*)?$/;
+    for (const line of content.split('\n')) {
+        const match = line.trim().match(captureRegex);
+        if (match) {
+            let path = match[3] || '';
+            // Remove leading dot if present (e.g., ".user.id" -> "user.id")
+            if (path.startsWith('.')) {
+                path = path.substring(1);
+            }
+            captures.push({
+                varName: match[1],
+                afterRequest: parseInt(match[2], 10),
+                path: path
+            });
+        }
+    }
+    return captures;
+}
+/**
+ * Gets a value from an HTTP response using a path.
+ *
+ * Supported top-level properties:
+ * - status: HTTP status code (e.g., 200)
+ * - statusText: HTTP status text (e.g., "OK")
+ * - headers: Response headers object
+ * - headers.X: Specific header value (e.g., headers.Content-Type)
+ * - duration: Request duration in milliseconds
+ * - body: Response body (required prefix for body access)
+ * - body.path.to.value: Access nested body properties
+ *
+ * Examples:
+ * - "status" → 200
+ * - "headers.Content-Type" → "application/json"
+ * - "body" → entire response body (stringified if object)
+ * - "body.user.id" → nested body value
+ * - "body[0].name" → array access in body
+ */
+function getValueByPath(response, path) {
+    // Empty path is invalid - must specify what to access
+    if (!path) {
+        return undefined;
+    }
+    const parts = (0, pathAccess_1.getPathSegments)(path);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    const topLevel = parts[0];
+    const remainingParts = parts.slice(1);
+    // Handle top-level response properties
+    switch (topLevel) {
+        case 'status':
+            return response.status;
+        case 'statusText':
+            return response.statusText;
+        case 'duration':
+            return response.duration;
+        case 'headers':
+            if (remainingParts.length === 0) {
+                return JSON.stringify(response.headers);
+            }
+            // Access specific header (case-insensitive lookup)
+            const headerName = remainingParts[0];
+            const headerKey = Object.keys(response.headers).find(k => k.toLowerCase() === headerName.toLowerCase());
+            if (headerKey) {
+                return response.headers[headerKey];
+            }
+            return undefined;
+        case 'body':
+            // Access body or nested body property
+            if (remainingParts.length === 0) {
+                // Return entire body as-is (keep objects/arrays for type checking)
+                return response.body;
+            }
+            // Navigate into body
+            let current = response.body;
+            for (const part of remainingParts) {
+                if (current === null || current === undefined) {
+                    return undefined;
+                }
+                current = (0, pathAccess_1.getPathPartValue)(current, part);
+            }
+            // Return the value as-is (keep objects/arrays as objects for type checking)
+            return current;
+        default:
+            // Unknown top-level property
+            return undefined;
+    }
+}
+/**
+ * Runs all requests in a sequence, capturing variables between requests.
+ * Uses the shared cookie jar by default (for VS Code extension).
+ * @param fullDocumentText - Optional full document text for resolving named requests (run <RequestName>)
+ * @param onProgress - Optional callback invoked after each step completes
+ * @param callStack - Internal: tracks sequence call stack for circular reference detection
+ * @param sequenceArgs - Optional variables to inject as sequence parameters
+ * @param apiDefinitions - Optional API definitions (header groups and endpoints) from imported .nornapi files
+ * @param tagFilterOptions - Optional tag filter options for filtering nested sequence calls
+ * @param sequenceSources - Optional map of sequence names to source file paths for script path resolution
+ */
+async function runSequence(sequenceContent, fileVariables, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, sqlOperationsBySource, executionContext, debugHooks) {
+    return runSequenceWithJar(sequenceContent, fileVariables, undefined, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, sqlOperationsBySource, executionContext, debugHooks);
+}
+/**
+ * Runs all requests in a sequence with a specific cookie jar.
+ * If no jar is provided, uses shared jar (VS Code) or creates new one (CLI).
+ * @param fullDocumentText - Optional full document text for resolving named requests (run <RequestName>)
+ * @param onProgress - Optional callback invoked after each step completes
+ * @param callStack - Internal: tracks sequence call stack for circular reference detection
+ * @param sequenceArgs - Optional variables to inject as sequence parameters
+ * @param apiDefinitions - Optional API definitions (header groups and endpoints) from imported .nornapi files
+ * @param tagFilterOptions - Optional tag filter options for filtering nested sequence calls
+ * @param sequenceSources - Optional map of sequence names to source file paths for script path resolution
+ */
+async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, sqlOperationsBySource, executionContext, debugHooks) {
+    const startTime = Date.now();
+    const responses = [];
+    const scriptResults = [];
+    const assertionResults = [];
+    const orderedSteps = [];
+    const errors = [];
+    // Helper to add response and update $N references in runtimeVariables
+    const addResponse = (response) => {
+        responses.push(response);
+        // Store as $N for easy reference in print, etc.
+        runtimeVariables[`$${responses.length}`] = response;
+    };
+    // Track mapping from response index (1-based) to variable name for enhanced failure context
+    const responseIndexToVariable = new Map();
+    // Extract steps (requests and scripts) and capture directives
+    const steps = extractStepsFromSequence(sequenceContent);
+    const captures = extractCaptureDirectives(sequenceContent);
+    const totalSteps = steps.length;
+    // Calculate nesting depth from call stack
+    const nestingDepth = callStack ? callStack.length : 0;
+    const ownsMcpSessionManager = !executionContext?.mcpSessionManager;
+    // Helper to report progress
+    const reportProgress = (stepIdx, stepType, description, result, sequenceName) => {
+        if (result) {
+            const location = resolveDebugStepLocation(steps[stepIdx]);
+            result.sourceFile = result.sourceFile ?? location.filePath;
+            result.sourceLine = result.sourceLine ?? location.absoluteLine;
+        }
+        if (onProgress) {
+            onProgress({
+                currentStep: stepIdx + 1,
+                totalSteps,
+                stepType,
+                stepDescription: description,
+                stepResult: result,
+                sequenceName,
+                nestingDepth
+            });
+        }
+    };
+    // Runtime variables (starts with file variables, grows with captures and script outputs)
+    // Inject sequence arguments (parameters) which shadow file variables
+    // Type is any to allow storing response objects (from var x = GET url)
+    const runtimeVariables = (0, parser_1.copyEnvironmentScope)({ ...fileVariables, ...sequenceArgs }, fileVariables);
+    const mcpSessionManager = executionContext?.mcpSessionManager ?? new mcpClient_1.McpSessionManager();
+    const buildRequestValidationContext = (stepNumber, method, url, requestName) => ({
+        source: 'sequence',
+        filePath: executionContext?.filePath,
+        sequenceName: executionContext?.sequenceName,
+        stepIndex: stepNumber,
+        method,
+        url,
+        requestName,
+        environment: executionContext?.environment
+    });
+    const getCurrentSqlScope = () => {
+        if (!executionContext?.filePath || !sqlOperationsBySource) {
+            return undefined;
+        }
+        return sqlOperationsBySource.get(executionContext.filePath);
+    };
+    const getCurrentMcpStartPath = () => executionContext?.filePath || workingDir || process.cwd();
+    // Track request index for $N capture references
+    let requestIndex = 0;
+    // Track if-block state: stack of booleans (true = executing, false = skipping)
+    const ifStack = [];
+    // Helper to check if we should skip the current step (inside a false if-block)
+    const shouldSkip = () => ifStack.length > 0 && ifStack.some(v => !v);
+    const resolveDebugStepLocation = (step) => {
+        const sequenceName = executionContext?.sequenceName;
+        const indexed = sequenceName
+            ? executionContext?.sequenceLocationIndex?.get(sequenceName.toLowerCase())
+            : undefined;
+        const startLine = executionContext?.sequenceStartLine ?? indexed?.startLine;
+        return {
+            filePath: executionContext?.filePath ?? indexed?.filePath,
+            sequenceName,
+            declarationLine: indexed?.declarationLine ?? executionContext?.sequenceStartLine,
+            absoluteLine: startLine !== undefined ? startLine + 1 + step.lineNumber : undefined,
+            relativeLine: step.lineNumber,
+            nestingDepth
+        };
+    };
+    const emitBeforeStep = async (step, stepIdx) => {
+        if (!debugHooks?.beforeStep) {
+            return;
+        }
+        await debugHooks.beforeStep({
+            stepType: step.type,
+            stepContent: step.content,
+            stepIndex: stepIdx,
+            totalSteps,
+            location: resolveDebugStepLocation(step),
+            runtimeVariables,
+            responses
+        });
+    };
+    const emitAfterStep = async (step, stepIdx) => {
+        if (!debugHooks?.afterStep) {
+            return;
+        }
+        await debugHooks.afterStep({
+            stepType: step.type,
+            stepContent: step.content,
+            stepIndex: stepIdx,
+            totalSteps,
+            location: resolveDebugStepLocation(step),
+            runtimeVariables,
+            responses
+        });
+    };
+    const emitFailure = async (message, step, stepIdx) => {
+        if (!debugHooks?.onFailure) {
+            return;
+        }
+        await debugHooks.onFailure({
+            message,
+            stepIndex: stepIdx,
+            location: step ? resolveDebugStepLocation(step) : undefined,
+            runtimeVariables,
+            responses
+        });
+    };
+    if (debugHooks?.onSequenceEnter) {
+        await debugHooks.onSequenceEnter({
+            sequenceName: executionContext?.sequenceName,
+            filePath: executionContext?.filePath,
+            declarationLine: executionContext?.sequenceStartLine,
+            nestingDepth,
+            runtimeVariables,
+            responses
+        });
+    }
+    try {
+        for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
+            const step = steps[stepIdx];
+            await emitBeforeStep(step, stepIdx);
+            const stepStartTime = Date.now();
+            try {
+                // Handle if/endif first (they affect control flow)
+                if (step.type === 'if') {
+                    // Always evaluate if statements, even when skipping (for nesting)
+                    if (shouldSkip()) {
+                        // Already skipping, push false to maintain nesting
+                        ifStack.push(false);
+                    }
+                    else {
+                        // Evaluate the condition
+                        const conditionMet = evaluateIfCondition(step.content, responses, runtimeVariables, getValueByPath);
+                        ifStack.push(conditionMet);
+                        const stepResult = createPrintStepResult(stepIdx, stepStartTime, startTime, `if ${step.content}: ${conditionMet ? 'true' : 'false'}`);
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'if', `if ${step.content} → ${conditionMet}`, stepResult);
+                    }
+                    continue;
+                }
+                if (step.type === 'endif') {
+                    if (ifStack.length > 0) {
+                        ifStack.pop();
+                    }
+                    continue;
+                }
+                // Skip steps if inside a false if-block
+                if (shouldSkip()) {
+                    continue;
+                }
+                if (step.type === 'assertion') {
+                    // Parse and evaluate the assertion
+                    const parsed = (0, assertionRunner_1.parseAssertCommand)(step.content);
+                    if (!parsed) {
+                        const invalidAssertMessage = `Step ${stepIdx + 1}: Invalid assert command: ${step.content}`;
+                        errors.push(invalidAssertMessage);
+                        await emitFailure(invalidAssertMessage, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const result = (0, assertionRunner_1.evaluateAssertion)(parsed, responses, runtimeVariables, getValueByPath, responseIndexToVariable, workingDir);
+                    assertionResults.push(result);
+                    const stepResult = {
+                        type: 'assertion',
+                        stepIndex: stepIdx,
+                        durationMs: Date.now() - stepStartTime,
+                        assertion: result,
+                        lineNumber: step.lineNumber
+                    };
+                    orderedSteps.push(stepResult);
+                    const statusIcon = result.passed ? '✓' : '✗';
+                    reportProgress(stepIdx, 'assertion', `${statusIcon} assert ${result.expression}`, stepResult);
+                    // Failed assertions already have a dedicated assertion step/result entry.
+                    // Don't duplicate them in the generic errors list.
+                    if (!result.passed) {
+                        const failMessage = result.message
+                            ? `Assertion failed: ${result.message}`
+                            : `Assertion failed: ${result.expression}`;
+                        await emitFailure(failMessage, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    continue;
+                }
+                if (step.type === 'print') {
+                    // Parse and substitute variables in the print content
+                    const parsed = parsePrintCommand(step.content);
+                    // First resolve bare variables, then substitute {{var}} patterns
+                    const titleResolved = resolveBareVariables(parsed.title, runtimeVariables);
+                    const title = (0, parser_1.substituteVariables)(titleResolved, runtimeVariables);
+                    const bodyResolved = parsed.body ? resolveBareVariables(parsed.body, runtimeVariables) : undefined;
+                    const body = bodyResolved ? (0, parser_1.substituteVariables)(bodyResolved, runtimeVariables) : undefined;
+                    const stepResult = createPrintStepResult(stepIdx, stepStartTime, startTime, title, body);
+                    orderedSteps.push(stepResult);
+                    reportProgress(stepIdx, 'print', `print: ${title}`, stepResult);
+                    continue;
+                }
+                if (step.type === 'wait') {
+                    // Parse the wait duration
+                    const durationMs = parseWaitCommand(step.content);
+                    // Report that we're starting to wait
+                    reportProgress(stepIdx, 'wait', `wait: ${durationMs}ms`);
+                    // Actually wait
+                    await sleep(durationMs);
+                    // Create a print-like result for the wait step
+                    const stepResult = createPrintStepResult(stepIdx, stepStartTime, startTime, `Waited ${durationMs >= 1000 ? (durationMs / 1000) + 's' : durationMs + 'ms'}`);
+                    orderedSteps.push(stepResult);
+                    continue;
+                }
+                if (step.type === 'json') {
+                    // Parse the json command with variable substitution in the path
+                    // First resolve bare variables, then {{var}} patterns
+                    const bareResolved = resolveBareVariables(step.content, runtimeVariables);
+                    const parsed = (0, jsonFileReader_1.parseJsonCommand)((0, parser_1.substituteVariables)(bareResolved, runtimeVariables));
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid json command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Read the JSON file
+                    const result = (0, jsonFileReader_1.readJsonFile)(parsed.filePath, workingDir);
+                    const stepResult = {
+                        type: 'json',
+                        stepIndex: stepIdx,
+                        durationMs: Date.now() - stepStartTime,
+                        json: {
+                            varName: parsed.varName,
+                            filePath: result.filePath,
+                            success: result.success,
+                            error: result.error,
+                            timestamp: Date.now() - startTime
+                        }
+                    };
+                    orderedSteps.push(stepResult);
+                    if (!result.success) {
+                        errors.push(`Failed to load JSON file: ${result.error}`);
+                        reportProgress(stepIdx, 'json', `json: ${parsed.varName} ✗ ${result.error}`, stepResult);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Keep structured JSON values as objects so runtime access and debugger views stay consistent.
+                    runtimeVariables[parsed.varName] = result.data;
+                    reportProgress(stepIdx, 'json', `json: ${parsed.varName} = ${parsed.filePath}`, stepResult);
+                    continue;
+                }
+                if (step.type === 'propAssign') {
+                    // Parse the property assignment first to extract the value part
+                    // Then resolve variables in the value specifically
+                    const parsed = (0, jsonFileReader_1.parsePropertyAssignment)(step.content);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid property assignment: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Check if the variable exists and is a JSON object
+                    if (!(parsed.varName in runtimeVariables)) {
+                        errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not defined`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Parse the current JSON value
+                    let jsonObj;
+                    const existingValue = parseJsonBackedValue(runtimeVariables[parsed.varName]);
+                    if (typeof existingValue === 'object' && existingValue !== null) {
+                        jsonObj = existingValue;
+                    }
+                    else {
+                        errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not a valid JSON object`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Check if the value is a bare variable reference - if so, preserve its original type
+                    const valueTrimmed = parsed.value.trim();
+                    const bareVarMatch = valueTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+                    let newValue;
+                    if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
+                        // It's a bare variable - preserve the original type
+                        const varName = bareVarMatch[1];
+                        const pathPart = bareVarMatch[2] || '';
+                        let value = runtimeVariables[varName];
+                        // If it's a JSON string, parse it first
+                        if (typeof value === 'string') {
+                            const parsedValue = parseJsonBackedValue(value);
+                            if (typeof parsedValue === 'object' && parsedValue !== null) {
+                                value = parsedValue;
+                            }
+                        }
+                        if (pathPart) {
+                            // Navigate the path
+                            const path = pathPart.replace(/^\./, '');
+                            newValue = (0, pathAccess_1.getNestedPathValue)(value, path);
+                        }
+                        else {
+                            newValue = value;
+                        }
+                    }
+                    else {
+                        // Not a bare variable - resolve variables and parse as JSON
+                        const bareResolvedValue = resolveBareVariables(parsed.value, runtimeVariables);
+                        const resolvedValue = (0, parser_1.substituteVariables)(bareResolvedValue, runtimeVariables);
+                        // Parse the value - try to interpret it as JSON first, then as string
+                        newValue = resolvedValue;
+                        try {
+                            newValue = JSON.parse(resolvedValue);
+                        }
+                        catch {
+                            // Keep as string if not valid JSON
+                        }
+                    }
+                    // Set the nested value
+                    const success = (0, jsonFileReader_1.setNestedValue)(jsonObj, parsed.propertyPath, newValue);
+                    if (!success) {
+                        errors.push(`Step ${stepIdx + 1}: Failed to set property '${parsed.propertyPath}' on '${parsed.varName}'`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Update the runtime variable with the modified JSON object
+                    runtimeVariables[parsed.varName] = jsonObj;
+                    // No step result needed for property assignment - it's a simple operation
+                    // But we report progress for visibility
+                    reportProgress(stepIdx, 'propAssign', `${parsed.varName}.${parsed.propertyPath} = ${parsed.value}`, undefined);
+                    continue;
+                }
+                if (step.type === 'varAssign') {
+                    // Parse the variable assignment
+                    const parsed = parseVarAssignCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid variable assignment: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Evaluate the expression
+                    const result = evaluateValueExpression(parsed.valueExpr, runtimeVariables);
+                    if (result.error) {
+                        errors.push(`Step ${stepIdx + 1}: ${result.error}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Store the result
+                    runtimeVariables[parsed.varName] = result.value;
+                    // Report progress
+                    reportProgress(stepIdx, 'propAssign', `var ${parsed.varName} = ${result.value}`, undefined);
+                    continue;
+                }
+                if (step.type === 'sql') {
+                    const parsed = parseRunSqlCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid SQL command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    if (parsed.error) {
+                        errors.push(`Step ${stepIdx + 1}: ${parsed.error}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const sqlScope = getCurrentSqlScope();
+                    const operation = sqlScope?.get(parsed.operationName.toLowerCase());
+                    if (!operation) {
+                        errors.push(`SQL operation '${parsed.operationName}' was not found in the SQL files imported by this .norn file.`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const boundArgs = bindSqlArguments(operation.parameters, parsed.args, runtimeVariables);
+                    if ('error' in boundArgs) {
+                        errors.push(`Step ${stepIdx + 1}: ${boundArgs.error}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const adapterWorkingDir = workingDir || process.cwd();
+                    try {
+                        const connection = (0, sqlConfig_1.resolveSqlConnection)(executionContext?.filePath || adapterWorkingDir, operation.connectionName);
+                        const adapterTarget = (0, sqlConfig_1.resolveSqlAdapterTarget)(executionContext?.filePath || adapterWorkingDir, connection.adapter);
+                        const connectionValues = getSqlConnectionValues(connection.profile, runtimeVariables);
+                        const adapterResponse = await (0, sqlAdapterRunner_1.runSqlAdapter)(adapterTarget, {
+                            protocolVersion: 1,
+                            mode: operation.type,
+                            operation: {
+                                name: operation.name,
+                                type: operation.type,
+                                sql: operation.sql,
+                                parameters: operation.parameters,
+                                connectionName: operation.connectionName,
+                                sourcePath: operation.sourcePath
+                            },
+                            params: boundArgs.params,
+                            connection: {
+                                name: connection.alias,
+                                profile: connection.profile,
+                                values: connectionValues
+                            },
+                            context: {
+                                filePath: executionContext?.filePath,
+                                sequenceName: executionContext?.sequenceName,
+                                workingDir: adapterWorkingDir
+                            }
+                        }, adapterWorkingDir);
+                        let storedValue;
+                        let sqlResult;
+                        if (operation.type === 'query') {
+                            if (adapterResponse.result.kind !== 'rows') {
+                                throw new Error(`SQL query '${operation.name}' returned '${adapterResponse.result.kind}' instead of rows`);
+                            }
+                            storedValue = adapterResponse.result.rows;
+                            sqlResult = {
+                                operationName: operation.name,
+                                operationType: operation.type,
+                                connectionName: operation.connectionName,
+                                rowCount: adapterResponse.result.rowCount ?? adapterResponse.result.rows.length,
+                                rows: adapterResponse.result.rows,
+                                timestamp: Date.now() - startTime
+                            };
+                        }
+                        else {
+                            if (adapterResponse.result.kind !== 'exec') {
+                                throw new Error(`SQL command '${operation.name}' returned '${adapterResponse.result.kind}' instead of exec`);
+                            }
+                            storedValue = {
+                                affectedRows: adapterResponse.result.affectedRows ?? 0
+                            };
+                            sqlResult = {
+                                operationName: operation.name,
+                                operationType: operation.type,
+                                connectionName: operation.connectionName,
+                                affectedRows: adapterResponse.result.affectedRows ?? 0,
+                                timestamp: Date.now() - startTime
+                            };
+                        }
+                        if (parsed.variableName) {
+                            runtimeVariables[parsed.variableName] = storedValue;
+                        }
+                        const stepResult = {
+                            type: 'sql',
+                            stepIndex: stepIdx,
+                            durationMs: Date.now() - stepStartTime,
+                            sql: sqlResult,
+                            variableName: parsed.variableName,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        const description = operation.type === 'query'
+                            ? `run sql ${operation.name} → ${sqlResult.rowCount ?? 0} row(s)`
+                            : `run sql ${operation.name} → ${sqlResult.affectedRows ?? 0} affected`;
+                        reportProgress(stepIdx, 'sql', description, stepResult);
+                    }
+                    catch (error) {
+                        errors.push(`SQL execution failed for '${operation.name}': ${error.message || String(error)}`);
+                        await emitFailure(`SQL execution failed for '${operation.name}'`, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    continue;
+                }
+                if (step.type === 'mcpList') {
+                    const parsed = parseRunMcpListCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid MCP list command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    try {
+                        const listResult = await mcpSessionManager.listTools(getCurrentMcpStartPath(), parsed.serverAlias, getRuntimeEnvironmentVariables(runtimeVariables));
+                        if (parsed.variableName) {
+                            runtimeVariables[parsed.variableName] = listResult.tools;
+                        }
+                        const stepResult = {
+                            type: 'mcp',
+                            stepIndex: stepIdx,
+                            durationMs: Date.now() - stepStartTime,
+                            mcp: {
+                                operation: 'list',
+                                serverAlias: parsed.serverAlias,
+                                tools: listResult.tools,
+                                timestamp: Date.now() - startTime
+                            },
+                            variableName: parsed.variableName,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'mcp', `run mcp list ${parsed.serverAlias} → ${listResult.tools.length} tool(s)`, stepResult);
+                    }
+                    catch (error) {
+                        const message = `MCP list failed for '${parsed.serverAlias}': ${error?.message || String(error)}`;
+                        errors.push(message);
+                        await emitFailure(message, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    continue;
+                }
+                if (step.type === 'mcpCall') {
+                    const parsed = parseRunMcpCallCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid MCP call command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    if (parsed.error) {
+                        errors.push(`Step ${stepIdx + 1}: ${parsed.error}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    let toolDefinition;
+                    try {
+                        toolDefinition = await mcpSessionManager.getToolDefinition(getCurrentMcpStartPath(), parsed.serverAlias, parsed.toolName, getRuntimeEnvironmentVariables(runtimeVariables));
+                    }
+                    catch (error) {
+                        const message = `MCP call failed for '${parsed.serverAlias}.${parsed.toolName}': ${error?.message || String(error)}`;
+                        errors.push(message);
+                        await emitFailure(message, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const boundArgs = bindMcpArguments(toolDefinition, parsed.args, runtimeVariables);
+                    if ('error' in boundArgs) {
+                        errors.push(`Step ${stepIdx + 1}: ${boundArgs.error}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    try {
+                        const callResult = await mcpSessionManager.callTool(getCurrentMcpStartPath(), parsed.serverAlias, parsed.toolName, boundArgs.params, getRuntimeEnvironmentVariables(runtimeVariables));
+                        if (parsed.variableName) {
+                            runtimeVariables[parsed.variableName] = callResult;
+                        }
+                        const stepResult = {
+                            type: 'mcp',
+                            stepIndex: stepIdx,
+                            durationMs: Date.now() - stepStartTime,
+                            mcp: {
+                                operation: 'call',
+                                serverAlias: parsed.serverAlias,
+                                toolName: parsed.toolName,
+                                result: callResult,
+                                timestamp: Date.now() - startTime
+                            },
+                            variableName: parsed.variableName,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'mcp', `run mcp call ${parsed.serverAlias} ${parsed.toolName}()`, stepResult);
+                        if (callResult.isError) {
+                            const message = callResult.text || `MCP tool '${parsed.toolName}' reported an error.`;
+                            errors.push(message);
+                            await emitFailure(message, step, stepIdx);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                    }
+                    catch (error) {
+                        const message = `MCP call failed for '${parsed.serverAlias}.${parsed.toolName}': ${error?.message || String(error)}`;
+                        errors.push(message);
+                        await emitFailure(message, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    continue;
+                }
+                if (step.type === 'varRequest') {
+                    // Parse the variable request command: var name = GET/POST url/endpoint
+                    // Only parse the first line (command line), body is on subsequent lines
+                    const commandLine = step.content.split('\n')[0];
+                    const parsed = parseVarRequestCommand(commandLine);
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid variable request: ${commandLine}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    requestIndex++; // Count as a request for $N references
+                    let requestDescription = `${parsed.method} ${parsed.url}`;
+                    try {
+                        let requestText = `${parsed.method} ${parsed.url}`;
+                        // Extract and add body lines from step.content (lines after the command line)
+                        const contentLines = step.content.split('\n');
+                        if (contentLines.length > 1) {
+                            // Additional lines may contain headers + optional blank separator + body,
+                            // or body-only content. Preserve explicit structure when present.
+                            const extraLines = contentLines.slice(1).map(line => (0, parser_1.substituteVariables)(line, runtimeVariables));
+                            const hasExplicitBlank = extraLines.some(line => line.trim() === '');
+                            const firstNonEmpty = extraLines.find(line => line.trim() !== '');
+                            const startsWithHeader = firstNonEmpty ? /^[A-Za-z0-9\-_]+\s*:/.test(firstNonEmpty.trim()) : false;
+                            if (hasExplicitBlank || startsWithHeader) {
+                                requestText += '\n' + extraLines.join('\n');
+                            }
+                            else {
+                                // Body-only shorthand (no headers/blank separator) should still parse as body.
+                                requestText += '\n\n' + extraLines.join('\n');
+                            }
+                        }
+                        const preparedRequest = (0, requestPreparation_1.prepareRequestFromContent)(requestText, runtimeVariables, apiDefinitions);
+                        const requestParsed = (0, requestPreparation_1.resolveBareVariableRequestBody)(preparedRequest.request, runtimeVariables);
+                        requestDescription = preparedRequest.description;
+                        (0, requestValidation_1.validatePreparedRequest)(requestParsed, buildRequestValidationContext(stepIdx + 1, requestParsed.method, requestParsed.url, `var ${parsed.varName}`));
+                        // Build retry options if specified
+                        const retryOpts = parsed.retryCount
+                            ? {
+                                retryCount: parsed.retryCount,
+                                backoffMs: parsed.backoffMs || 1000,
+                                onRetry: (attempt, total, error, waitMs) => {
+                                    reportProgress(stepIdx, 'request', `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, undefined);
+                                }
+                            }
+                            : undefined;
+                        const response = cookieJar
+                            ? await (0, httpClient_1.sendRequestWithJar)(requestParsed, cookieJar, retryOpts)
+                            : await (0, httpClient_1.sendRequest)(requestParsed, retryOpts);
+                        addResponse(response);
+                        // Track variable name → response index mapping for enhanced failure context
+                        responseIndexToVariable.set(responses.length, parsed.varName);
+                        // Store the FULL response object in the variable (not stringified)
+                        // This allows {{varName.body.path}}, {{varName.status}}, etc.
+                        runtimeVariables[parsed.varName] = response;
+                        const stepResult = {
+                            type: 'request',
+                            stepIndex: stepIdx,
+                            response: response,
+                            requestMethod: requestParsed.method,
+                            requestUrl: requestParsed.url,
+                            variableName: parsed.varName,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'request', `var ${parsed.varName} = ${requestDescription}`, stepResult);
+                        // Also process captures that reference this response by $N
+                        const relevantCaptures = captures.filter(c => c.afterRequest === requestIndex);
+                        for (const capture of relevantCaptures) {
+                            const value = getValueByPath(response, capture.path);
+                            if (value !== undefined) {
+                                // Preserve the value as-is (objects, arrays, primitives) for type checking
+                                runtimeVariables[capture.varName] = value;
+                            }
+                            else {
+                                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        const userMessage = (0, formatError_1.formatUserFacingError)(error, buildRequestValidationContext(stepIdx + 1, undefined, undefined, `var ${parsed.varName}`));
+                        let errorDetails = `Request failed for var ${parsed.varName}:\n${indentMultiline(userMessage)}`;
+                        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
+                            errorDetails += `\n  Request: ${requestDescription}`;
+                        }
+                        errors.push(errorDetails);
+                        await emitFailure(errorDetails, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    continue;
+                }
+                if (step.type === 'script') {
+                    // Parse and execute the script
+                    const parsed = (0, scriptRunner_1.parseRunCommand)((0, parser_1.substituteVariables)(step.content, runtimeVariables));
+                    if (!parsed) {
+                        errors.push(`Step ${stepIdx + 1}: Invalid run command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Substitute variables in args - first resolve bare variables, then {{var}} patterns
+                    const substitutedArgs = parsed.args.map(arg => {
+                        const bareResolved = resolveBareVariables(arg, runtimeVariables);
+                        return (0, parser_1.substituteVariables)(bareResolved, runtimeVariables);
+                    });
+                    const substitutedPath = (0, parser_1.substituteVariables)(parsed.scriptPath, runtimeVariables);
+                    try {
+                        const result = await (0, scriptRunner_1.runScript)(parsed.type, substitutedPath, substitutedArgs, workingDir || process.cwd(), runtimeVariables, parsed.captureAs);
+                        scriptResults.push(result);
+                        const stepResult = {
+                            type: 'script',
+                            stepIndex: stepIdx,
+                            script: result
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'script', `run ${parsed.type} ${substitutedPath}`, stepResult);
+                        if (!result.success) {
+                            errors.push(`Script failed (exit ${result.exitCode}): ${result.error || result.output}`);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                        // If this was a capture command (var x = run ...), store the output
+                        if (parsed.captureAs) {
+                            // Try to parse as JSON for object/array/number/boolean
+                            let outputValue = result.output;
+                            try {
+                                const jsonParsed = JSON.parse(result.output);
+                                // Accept objects, arrays, numbers, and booleans from JSON parse
+                                // This means "1234" becomes 1234 (number), "true" becomes true (boolean)
+                                // Strings that don't parse as JSON stay as strings
+                                outputValue = jsonParsed;
+                            }
+                            catch {
+                                // Not valid JSON, keep as string
+                            }
+                            runtimeVariables[parsed.captureAs] = outputValue;
+                        }
+                    }
+                    catch (error) {
+                        errors.push(`Script execution error: ${error.message}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                }
+                else if (step.type === 'namedRequest') {
+                    // Named request OR sequence invocation: run <Name> or run <Name>(args)
+                    const parsed = parseRunNamedRequestCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Invalid run command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const { name: targetName, args: runArgs } = parsed;
+                    if (!fullDocumentText) {
+                        errors.push(`Cannot run "${targetName}": full document text not provided`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // First, check if this is a sequence name
+                    const allSequences = extractSequences(fullDocumentText);
+                    const targetSequence = allSequences.find(s => s.name === targetName);
+                    if (targetSequence) {
+                        // This is a sequence call - run the sequence recursively
+                        // Initialize call stack if not provided
+                        const currentCallStack = callStack || [];
+                        // Check for circular reference
+                        if (currentCallStack.includes(targetName)) {
+                            errors.push(`Circular reference detected: ${[...currentCallStack, targetName].join(' → ')}`);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                        // Bind arguments to parameters
+                        let sequenceArgs = {};
+                        if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
+                            const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
+                            if ('error' in bindResult) {
+                                errors.push(`Error calling sequence "${targetName}": ${bindResult.error}`);
+                                return {
+                                    name: '',
+                                    success: false,
+                                    responses,
+                                    scriptResults,
+                                    assertionResults,
+                                    steps: orderedSteps,
+                                    errors,
+                                    duration: Date.now() - startTime
+                                };
+                            }
+                            sequenceArgs = bindResult.variables;
+                        }
+                        // Check if tag filtering is active and if the target sequence matches
+                        if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
+                            if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
+                                // Silently skip this sequence - it doesn't match the tag filter
+                                continue;
+                            }
+                        }
+                        // Report that we're starting a sub-sequence
+                        reportProgress(stepIdx, 'sequenceStart', `Starting sequence ${targetName}`, undefined, targetName);
+                        // Determine the working directory for this sub-sequence
+                        // If we have source info for this sequence (from imports), use that file's directory
+                        // This ensures script paths resolve relative to where the sequence was defined
+                        let subWorkingDir = workingDir;
+                        if (sequenceSources) {
+                            const sourceFile = sequenceSources.get(targetName.toLowerCase());
+                            if (sourceFile) {
+                                const path = await import('path');
+                                subWorkingDir = path.dirname(sourceFile);
+                            }
+                        }
+                        // Run the sub-sequence with current runtime variables
+                        // Variables set in the sub-sequence will be available after it completes
+                        const targetLocation = executionContext?.sequenceLocationIndex?.get(targetName.toLowerCase());
+                        const childExecutionContext = {
+                            filePath: targetLocation?.filePath ?? executionContext?.filePath,
+                            sequenceName: targetName,
+                            environment: executionContext?.environment,
+                            sequenceStartLine: targetLocation?.startLine ?? targetSequence.startLine,
+                            sequenceLocationIndex: executionContext?.sequenceLocationIndex,
+                            mcpSessionManager
+                        };
+                        const subResult = await runSequenceWithJar(targetSequence.content, runtimeVariables, // Pass current runtime variables (includes file vars + any captured)
+                        cookieJar, subWorkingDir, fullDocumentText, onProgress, // Pass through progress callback
+                        [...currentCallStack, targetName], // Add to call stack for circular detection
+                        sequenceArgs, // Pass bound arguments as initial scope variables
+                        apiDefinitions, // Pass API definitions for endpoint resolution
+                        tagFilterOptions, // Pass tag filter options for nested sequence filtering
+                        sequenceSources, // Pass sequence sources for nested sequences
+                        sqlOperationsBySource, childExecutionContext, debugHooks);
+                        // Report that sub-sequence ended
+                        reportProgress(stepIdx, 'sequenceEnd', `Finished sequence ${targetName}`, undefined, targetName);
+                        // Merge results from sub-sequence and update $N references
+                        for (const subResponse of subResult.responses) {
+                            addResponse(subResponse);
+                        }
+                        scriptResults.push(...subResult.scriptResults);
+                        assertionResults.push(...subResult.assertionResults);
+                        // Merge step results (offset step indices)
+                        for (const subStep of subResult.steps) {
+                            orderedSteps.push({
+                                ...subStep,
+                                stepIndex: orderedSteps.length
+                            });
+                        }
+                        // No variable merging for plain "run Sequence"
+                        // Variables are only accessible via "var x = run Sequence" capture syntax
+                        // Update request index to account for sub-sequence requests
+                        requestIndex += subResult.responses.length;
+                        // If sub-sequence failed, propagate the failure
+                        if (!subResult.success) {
+                            errors.push(`Sequence "${targetName}" failed`);
+                            errors.push(...subResult.errors);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime,
+                                variables: runtimeVariables
+                            };
+                        }
+                        // Sub-sequence succeeded - continue
+                        continue;
+                    }
+                    // Not a sequence - check for named request
+                    const namedRequest = (0, parser_1.getNamedRequest)(fullDocumentText, targetName);
+                    if (!namedRequest) {
+                        errors.push(`"${targetName}" is not a named request or sequence`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    requestIndex++; // 1-based for user reference
+                    let requestUrl = '';
+                    let requestMethod = '';
+                    try {
+                        const requestParsed = buildParsedNamedRequest(namedRequest.content, runtimeVariables, apiDefinitions);
+                        requestUrl = requestParsed.url;
+                        requestMethod = requestParsed.method;
+                        (0, requestValidation_1.validatePreparedRequest)(requestParsed, buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, targetName));
+                        // Build retry options - prefer options from the run command, fallback to options in request content
+                        const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+                        const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1000;
+                        const retryOpts = effectiveRetryCount
+                            ? {
+                                retryCount: effectiveRetryCount,
+                                backoffMs: effectiveBackoffMs,
+                                onRetry: (attempt, total, error, waitMs) => {
+                                    reportProgress(stepIdx, 'request', `[Retry ${attempt}/${total}] run ${targetName} - waiting ${waitMs}ms`, undefined);
+                                }
+                            }
+                            : undefined;
+                        const response = cookieJar
+                            ? await (0, httpClient_1.sendRequestWithJar)(requestParsed, cookieJar, retryOpts)
+                            : await (0, httpClient_1.sendRequest)(requestParsed, retryOpts);
+                        addResponse(response);
+                        const stepResult = {
+                            type: 'request',
+                            stepIndex: stepIdx,
+                            response: response,
+                            requestMethod: requestParsed.method,
+                            requestUrl: requestParsed.url,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'namedRequest', `run ${targetName} → ${requestParsed.method} ${requestParsed.url}`, stepResult);
+                        // Process captures that reference this response
+                        const relevantCaptures = captures.filter(c => c.afterRequest === requestIndex);
+                        for (const capture of relevantCaptures) {
+                            const value = getValueByPath(response, capture.path);
+                            if (value !== undefined) {
+                                // Preserve the value as-is (objects, arrays, primitives) for type checking
+                                runtimeVariables[capture.varName] = value;
+                            }
+                            else {
+                                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        const userMessage = (0, formatError_1.formatUserFacingError)(error, buildRequestValidationContext(stepIdx + 1, requestMethod || undefined, requestUrl || undefined, targetName));
+                        let errorDetails = `Named request "${targetName}" failed:\n${indentMultiline(userMessage)}`;
+                        if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
+                            errorDetails += `\n  Request: ${requestMethod} ${requestUrl}`;
+                        }
+                        errors.push(errorDetails);
+                        await emitFailure(errorDetails, step, stepIdx);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                }
+                else if (step.type === 'varRunSequence') {
+                    // var x = run SequenceName or var x = run SequenceName(args) - capture sequence result into a variable
+                    const parsed = parseVarRunSequenceCommand(step.content);
+                    if (!parsed) {
+                        errors.push(`Invalid var run sequence command: ${step.content}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const { varName, sequenceName, args: runArgs } = parsed;
+                    if (!fullDocumentText) {
+                        errors.push(`Cannot run sequence "${sequenceName}": full document text not provided`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Find the target sequence
+                    const allSequences = extractSequences(fullDocumentText);
+                    const targetSequence = allSequences.find(s => s.name === sequenceName);
+                    if (!targetSequence) {
+                        // Not a sequence - check for named request
+                        const namedRequest = (0, parser_1.getNamedRequest)(fullDocumentText, sequenceName);
+                        if (!namedRequest) {
+                            errors.push(`"${sequenceName}" is not a named request or sequence`);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                        // Execute the named request and capture response to variable
+                        requestIndex++; // 1-based for user reference
+                        let requestUrl = '';
+                        let requestMethod = '';
+                        try {
+                            const requestParsed = buildParsedNamedRequest(namedRequest.content, runtimeVariables, apiDefinitions);
+                            requestUrl = requestParsed.url;
+                            requestMethod = requestParsed.method;
+                            (0, requestValidation_1.validatePreparedRequest)(requestParsed, buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, `${varName} = run ${sequenceName}`));
+                            // Build retry options - prefer options from the command, fallback to options in request content
+                            const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+                            const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1000;
+                            const retryOpts = effectiveRetryCount
+                                ? {
+                                    retryCount: effectiveRetryCount,
+                                    backoffMs: effectiveBackoffMs,
+                                    onRetry: (attempt, total, error, waitMs) => {
+                                        reportProgress(stepIdx, 'request', `[Retry ${attempt}/${total}] var ${varName} = run ${sequenceName} - waiting ${waitMs}ms`, undefined);
+                                    }
+                                }
+                                : undefined;
+                            const response = cookieJar
+                                ? await (0, httpClient_1.sendRequestWithJar)(requestParsed, cookieJar, retryOpts)
+                                : await (0, httpClient_1.sendRequest)(requestParsed, retryOpts);
+                            addResponse(response);
+                            // Track variable name -> response index mapping for friendly assertion/output labels
+                            responseIndexToVariable.set(responses.length, varName);
+                            const stepResult = {
+                                type: 'request',
+                                stepIndex: stepIdx,
+                                response: response,
+                                requestMethod: requestParsed.method,
+                                requestUrl: requestParsed.url,
+                                variableName: varName,
+                                lineNumber: step.lineNumber
+                            };
+                            orderedSteps.push(stepResult);
+                            reportProgress(stepIdx, 'namedRequest', `var ${varName} = run ${sequenceName} → ${requestParsed.method} ${requestParsed.url}`, stepResult);
+                            // Store the response in the variable as a JSON object
+                            // Include status, body, and headers for full access
+                            const capturedResponse = {
+                                status: response.status,
+                                statusText: response.statusText,
+                                body: response.body,
+                                headers: response.headers
+                            };
+                            runtimeVariables[varName] = capturedResponse;
+                            // Process captures that reference this response
+                            const relevantCaptures = captures.filter(c => c.afterRequest === requestIndex);
+                            for (const capture of relevantCaptures) {
+                                const value = getValueByPath(response, capture.path);
+                                if (value !== undefined) {
+                                    runtimeVariables[capture.varName] = value;
+                                }
+                                else {
+                                    errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            const userMessage = (0, formatError_1.formatUserFacingError)(error, buildRequestValidationContext(stepIdx + 1, requestMethod || undefined, requestUrl || undefined, `${varName} = run ${sequenceName}`));
+                            let errorDetails = `Named request "${sequenceName}" failed:\n${indentMultiline(userMessage)}`;
+                            if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
+                                errorDetails += `\n  Request: ${requestMethod} ${requestUrl}`;
+                            }
+                            errors.push(errorDetails);
+                            await emitFailure(errorDetails, step, stepIdx);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                        continue;
+                    }
+                    // Initialize call stack if not provided
+                    const currentCallStack = callStack || [];
+                    // Check for circular reference
+                    if (currentCallStack.includes(sequenceName)) {
+                        errors.push(`Circular reference detected: ${[...currentCallStack, sequenceName].join(' → ')}`);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    // Bind arguments to parameters
+                    let sequenceArgs = {};
+                    if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
+                        const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
+                        if ('error' in bindResult) {
+                            errors.push(`Error calling sequence "${sequenceName}": ${bindResult.error}`);
+                            return {
+                                name: '',
+                                success: false,
+                                responses,
+                                scriptResults,
+                                assertionResults,
+                                steps: orderedSteps,
+                                errors,
+                                duration: Date.now() - startTime
+                            };
+                        }
+                        sequenceArgs = bindResult.variables;
+                    }
+                    // Check if tag filtering is active and if the target sequence matches
+                    if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
+                        if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
+                            // Silently skip this sequence - it doesn't match the tag filter
+                            // For var x = run Sequence, the variable will not be set
+                            continue;
+                        }
+                    }
+                    // Report that we're starting a sub-sequence
+                    reportProgress(stepIdx, 'sequenceStart', `Starting sequence ${sequenceName}`, undefined, sequenceName);
+                    // Determine the working directory for this sub-sequence
+                    // If we have source info for this sequence (from imports), use that file's directory
+                    let subWorkingDir = workingDir;
+                    if (sequenceSources) {
+                        const sourceFile = sequenceSources.get(sequenceName.toLowerCase());
+                        if (sourceFile) {
+                            const path = await import('path');
+                            subWorkingDir = path.dirname(sourceFile);
+                        }
+                    }
+                    // Run the sub-sequence with current runtime variables
+                    const targetLocation = executionContext?.sequenceLocationIndex?.get(sequenceName.toLowerCase());
+                    const childExecutionContext = {
+                        filePath: targetLocation?.filePath ?? executionContext?.filePath,
+                        sequenceName,
+                        environment: executionContext?.environment,
+                        sequenceStartLine: targetLocation?.startLine ?? targetSequence.startLine,
+                        sequenceLocationIndex: executionContext?.sequenceLocationIndex,
+                        mcpSessionManager
+                    };
+                    const subResult = await runSequenceWithJar(targetSequence.content, runtimeVariables, cookieJar, subWorkingDir, fullDocumentText, onProgress, [...currentCallStack, sequenceName], sequenceArgs, // Pass bound arguments
+                    apiDefinitions, // Pass API definitions for endpoint resolution
+                    tagFilterOptions, // Pass tag filter options for nested sequence filtering
+                    sequenceSources, // Pass sequence sources for nested sequences
+                    sqlOperationsBySource, childExecutionContext, debugHooks);
+                    // Report that sub-sequence ended
+                    reportProgress(stepIdx, 'sequenceEnd', `Finished sequence ${sequenceName}`, undefined, sequenceName);
+                    // Merge results from sub-sequence and update $N references
+                    for (const subResponse of subResult.responses) {
+                        addResponse(subResponse);
+                    }
+                    scriptResults.push(...subResult.scriptResults);
+                    assertionResults.push(...subResult.assertionResults);
+                    // Merge step results
+                    for (const subStep of subResult.steps) {
+                        orderedSteps.push({
+                            ...subStep,
+                            stepIndex: orderedSteps.length
+                        });
+                    }
+                    // Extract return expressions from the sequence
+                    const returnExpressions = extractReturnVariables(targetSequence.content);
+                    if (returnExpressions && returnExpressions.length > 0 && subResult.variables) {
+                        if (returnExpressions.length === 1) {
+                            // Single return: store the raw value directly.
+                            // This supports both variable/path returns and literal returns.
+                            runtimeVariables[varName] = resolveSingleReturnValue(returnExpressions[0], subResult.variables);
+                        }
+                        else {
+                            // Multiple returns: create object with named values
+                            // return a, b → returns {a: valueA, b: valueB}
+                            const returnedObj = {};
+                            for (const expr of returnExpressions) {
+                                const resolved = resolveReturnExpression(expr, subResult.variables);
+                                if (resolved) {
+                                    returnedObj[resolved.key] = resolved.value;
+                                }
+                            }
+                            runtimeVariables[varName] = returnedObj;
+                        }
+                    }
+                    else {
+                        // No return statement - store empty string
+                        runtimeVariables[varName] = '';
+                    }
+                    // Update request index
+                    requestIndex += subResult.responses.length;
+                    // If sub-sequence failed, propagate the failure
+                    if (!subResult.success) {
+                        errors.push(`Sequence "${sequenceName}" failed`);
+                        errors.push(...subResult.errors);
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime,
+                            variables: runtimeVariables
+                        };
+                    }
+                    // Sub-sequence succeeded - continue
+                    continue;
+                }
+                else {
+                    // HTTP request (regular or API endpoint-based)
+                    requestIndex++; // 1-based for user reference
+                    let parsed;
+                    let requestDescription = '';
+                    try {
+                        const preparedRequest = (0, requestPreparation_1.prepareRequestFromContent)(step.content, runtimeVariables, apiDefinitions);
+                        parsed = (0, requestPreparation_1.resolveBareVariableRequestBody)(preparedRequest.request, runtimeVariables);
+                        requestDescription = preparedRequest.description;
+                        // Extract retry options from step content (works for both API and regular requests)
+                        const { retryCount, backoffMs } = (0, parser_1.extractRetryOptions)(step.content);
+                        (0, requestValidation_1.validatePreparedRequest)(parsed, buildRequestValidationContext(stepIdx + 1, parsed.method, parsed.url));
+                        const retryOpts = (retryCount ?? parsed.retryCount)
+                            ? {
+                                retryCount: retryCount ?? parsed.retryCount ?? 0,
+                                backoffMs: backoffMs ?? parsed.backoffMs ?? 1000,
+                                onRetry: (attempt, total, error, waitMs) => {
+                                    reportProgress(stepIdx, 'request', `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, undefined);
+                                }
+                            }
+                            : undefined;
+                        // Send the request (with jar if provided, otherwise uses shared jar)
+                        const response = cookieJar
+                            ? await (0, httpClient_1.sendRequestWithJar)(parsed, cookieJar, retryOpts)
+                            : await (0, httpClient_1.sendRequest)(parsed, retryOpts);
+                        addResponse(response);
+                        const stepResult = {
+                            type: 'request',
+                            stepIndex: stepIdx,
+                            response: response,
+                            requestMethod: parsed.method,
+                            requestUrl: parsed.url,
+                            lineNumber: step.lineNumber
+                        };
+                        orderedSteps.push(stepResult);
+                        reportProgress(stepIdx, 'request', requestDescription, stepResult);
+                        // Process captures that reference this response ($N where N = requestIndex)
+                        const relevantCaptures = captures.filter(c => c.afterRequest === requestIndex);
+                        for (const capture of relevantCaptures) {
+                            const value = getValueByPath(response, capture.path);
+                            if (value !== undefined) {
+                                // Preserve the value as-is (objects, arrays, primitives) for type checking
+                                runtimeVariables[capture.varName] = value;
+                            }
+                            else {
+                                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        const userMessage = (0, formatError_1.formatUserFacingError)(error, buildRequestValidationContext(stepIdx + 1));
+                        let errorDetails = `Request ${requestIndex} failed:\n${indentMultiline(userMessage)}`;
+                        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
+                            errorDetails += `\n  Request: ${requestDescription}`;
+                        }
+                        errors.push(errorDetails);
+                        await emitFailure(errorDetails, step, stepIdx);
+                        // Stop sequence on error
+                        return {
+                            name: '',
+                            success: false,
+                            responses,
+                            scriptResults,
+                            assertionResults,
+                            steps: orderedSteps,
+                            errors,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                }
+            }
+            finally {
+                await emitAfterStep(step, stepIdx);
+            }
+        }
+        return {
+            name: '',
+            success: errors.filter(e => !e.startsWith('Warning')).length === 0,
+            responses,
+            scriptResults,
+            assertionResults,
+            steps: orderedSteps,
+            errors,
+            duration: Date.now() - startTime,
+            variables: runtimeVariables
+        };
+    }
+    finally {
+        if (ownsMcpSessionManager) {
+            await mcpSessionManager.closeAll();
+        }
+        if (debugHooks?.onSequenceExit) {
+            await debugHooks.onSequenceExit({
+                sequenceName: executionContext?.sequenceName,
+                filePath: executionContext?.filePath,
+                declarationLine: executionContext?.sequenceStartLine,
+                nestingDepth,
+                runtimeVariables,
+                responses
+            });
+        }
+    }
+}
+//# sourceMappingURL=sequenceRunner.js.map