norn-cli 1.6.0 → 1.6.2

package/out/sequenceRunner.js

@@ -1,3046 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractReturnVariables = extractReturnVariables;
-exports.bindSequenceArguments = bindSequenceArguments;
-exports.parseTagFilter = parseTagFilter;
-exports.sequenceMatchesTags = sequenceMatchesTags;
-exports.validateSequenceParameters = validateSequenceParameters;
-exports.extractSequences = extractSequences;
-exports.getSequenceAtLine = getSequenceAtLine;
-exports.countSequenceSteps = countSequenceSteps;
-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 nornapiParser_1 = require("./nornapiParser");
-/**
- * Applies header groups found in request text to a parsed request.
- * Handles lines like "Json" or "Auth" that are header group names.
- * Also strips header group names from the URL if they appear on the method line.
- */
-function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables) {
-    const lines = requestText.split('\n');
-    const headerGroupNames = headerGroups.map(hg => hg.name);
-    const headerGroupHeaders = {};
-    const foundGroups = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Skip empty lines, comments, variable lines
-        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('var ')) {
-            continue;
-        }
-        // Check if this is the HTTP method line - look for header groups at the end
-        const methodMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
-        if (methodMatch) {
-            const afterMethod = methodMatch[2];
-            // Split by space and check trailing tokens for header group names
-            const tokens = afterMethod.split(/\s+/);
-            // Scan from the end to find header groups
-            for (let i = tokens.length - 1; i >= 0; i--) {
-                if (headerGroupNames.includes(tokens[i])) {
-                    foundGroups.push(tokens[i]);
-                }
-                else {
-                    break; // Stop at first non-header-group token from the end
-                }
-            }
-            continue;
-        }
-        // Skip lines that look like headers (Name: Value)
-        if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
-            continue;
-        }
-        // Skip lines that look like JSON body
-        if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('"')) {
-            continue;
-        }
-        // Check if this line contains header group names (can be multiple space-separated)
-        const potentialGroups = trimmed.split(/\s+/);
-        for (const groupName of potentialGroups) {
-            if (headerGroupNames.includes(groupName)) {
-                foundGroups.push(groupName);
-            }
-        }
-    }
-    // Collect headers from all found groups
-    for (const groupName of foundGroups) {
-        const group = headerGroups.find(hg => hg.name === groupName);
-        if (group) {
-            const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, variables);
-            Object.assign(headerGroupHeaders, resolvedHeaders);
-        }
-    }
-    // Strip header group names from the already-resolved URL
-    let modifiedUrl = parsed.url;
-    for (const groupName of foundGroups) {
-        // Remove the header group name from URL (at the end with possible leading space)
-        const endPattern = new RegExp(`\\s+${groupName}$`);
-        modifiedUrl = modifiedUrl.replace(endPattern, '');
-    }
-    modifiedUrl = modifiedUrl.trim();
-    // Build the result - update URL if modified, merge headers
-    const result = {
-        ...parsed,
-        url: modifiedUrl
-    };
-    if (Object.keys(headerGroupHeaders).length > 0) {
-        // Header groups go first, inline headers take precedence
-        result.headers = { ...headerGroupHeaders, ...parsed.headers };
-    }
-    return result;
-}
-/**
- * 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)\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 {{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 = varValue;
-        if (typeof current === 'string') {
-            try {
-                current = JSON.parse(current);
-            }
-            catch {
-                // Not JSON, keep as string
-            }
-        }
-        // Parse the path: convert [0] to .0 and split by .
-        const normalizedPath = pathPart.replace(/^\.|^\[/, m => m === '.' ? '' : '[').replace(/\[(\d+)\]/g, '.$1');
-        const parts = normalizedPath.split('.').filter(p => p !== '');
-        for (const part of parts) {
-            if (current === null || current === undefined) {
-                return null;
-            }
-            current = 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 };
-    }
-}
-/**
- * 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;
-}
-/**
- * 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 = value.slice(1, -1);
-            }
-            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 = value.slice(1, -1);
-            }
-            args.push({ value });
-        }
-    }
-    return args;
-}
-/**
- * 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') {
-            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` };
-            }
-            // Resolve variable references in the value
-            let value = arg.value;
-            if (value.startsWith('{{') && value.endsWith('}}')) {
-                const varName = value.slice(2, -2);
-                value = getVariableValueByPath(varName, runtimeVariables);
-            }
-            else if (runtimeVariables[value] !== undefined) {
-                // Allow passing variable by name without braces
-                value = runtimeVariables[value];
-            }
-            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];
-            // Resolve variable references in the value
-            let value = arg.value;
-            if (value.startsWith('{{') && value.endsWith('}}')) {
-                const varName = value.slice(2, -2);
-                value = getVariableValueByPath(varName, runtimeVariables);
-            }
-            else if (runtimeVariables[value] !== undefined) {
-                // Allow passing variable by name without braces
-                value = runtimeVariables[value];
-            }
-            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 getVariableValueByPath(path, variables) {
-    const parts = path.split('.');
-    let current = variables;
-    for (const part of parts) {
-        if (current === null || current === undefined) {
-            return '';
-        }
-        if (typeof current === 'string') {
-            // Try to parse as JSON
-            try {
-                current = JSON.parse(current);
-            }
-            catch {
-                return '';
-            }
-        }
-        current = current[part];
-    }
-    if (current === null || current === undefined) {
-        return '';
-    }
-    if (typeof current === 'object') {
-        return JSON.stringify(current);
-    }
-    return String(current);
-}
-/**
- * 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 = defaultValue.slice(1, -1);
-            }
-            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 value.slice(1, -1);
-    }
-    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 = 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("'"))) {
-        // Remove quotes and substitute variables inside
-        const inner = trimmed.slice(1, -1);
-        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) {
-        // Handle object values directly (from var x = GET responses or parsed JSON)
-        let dataToNavigate;
-        if (typeof varValue === 'object' && varValue !== null) {
-            dataToNavigate = varValue;
-        }
-        else if (typeof varValue === 'string') {
-            try {
-                dataToNavigate = JSON.parse(varValue);
-            }
-            catch {
-                return { value: varValue, error: `Cannot parse '${varName}' as JSON for path access` };
-            }
-        }
-        else {
-            return { value: String(varValue), error: `Cannot access path on non-object value` };
-        }
-        // Navigate the path
-        const path = pathPart.replace(/^\./, '').replace(/\[(\d+)\]/g, '.$1');
-        const parts = path.split('.').filter(p => p !== '');
-        let current = dataToNavigate;
-        for (const part of parts) {
-            if (current === null || current === undefined) {
-                return { value: '', error: `Cannot access '${part}' on null/undefined` };
-            }
-            current = 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 };
-}
-/**
- * Strip inline comment from a line.
- * Finds # that is not inside quotes and removes everything after it.
- */
-function stripInlineComment(line) {
-    let inSingleQuote = false;
-    let inDoubleQuote = false;
-    for (let i = 0; i < line.length; i++) {
-        const char = line[i];
-        const prevChar = i > 0 ? line[i - 1] : '';
-        // Skip escaped quotes
-        if (prevChar === '\\') {
-            continue;
-        }
-        if (char === '"' && !inSingleQuote) {
-            inDoubleQuote = !inDoubleQuote;
-        }
-        else if (char === "'" && !inDoubleQuote) {
-            inSingleQuote = !inSingleQuote;
-        }
-        else if (char === '#' && !inSingleQuote && !inDoubleQuote) {
-            // Found an unquoted #, strip from here
-            return line.substring(0, i).trimEnd();
-        }
-    }
-    return line;
-}
-/**
- * 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 = 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 = getNestedValueFromObject(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 partTrimmed.slice(1, -1);
-            }
-            // 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(getNestedValueFromObject(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 = '';
-    for (let i = 0; i < expr.length; i++) {
-        const char = expr[i];
-        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;
-}
-/**
- * Get nested value from an object using a dot-notation path
- */
-function getNestedValueFromObject(obj, path) {
-    if (!path) {
-        return obj;
-    }
-    const parts = path.split(/\.|\[(\d+)\]/).filter(p => p !== '' && p !== undefined);
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        current = current[part];
-    }
-    return current;
-}
-/**
- * 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) {
-    // Import assertion parsing and evaluation
-    const { parseAssertCommand, evaluateAssertion } = require('./assertionRunner');
-    // Wrap condition as "assert <condition>" to reuse parsing
-    const parsed = parseAssertCommand(`assert ${condition}`);
-    if (!parsed) {
-        // Can't parse - treat as false
-        return false;
-    }
-    const result = evaluateAssertion(parsed, responses, variables, getValueByPathFn);
-    return result.passed;
-}
-/**
- * Counts the number of steps in a sequence (for progress reporting).
- */
-function countSequenceSteps(sequenceContent) {
-    return extractStepsFromSequence(sequenceContent).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;
-        }
-        // 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;
-    }
-    // Convert [0] to .0 and split by dots, filter out empty strings
-    const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(p => p !== '');
-    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 = 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) {
-    return runSequenceWithJar(sequenceContent, fileVariables, undefined, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources);
-}
-/**
- * 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) {
-    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;
-    // Helper to report progress
-    const reportProgress = (stepIdx, stepType, description, result, sequenceName) => {
-        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 = { ...fileVariables, ...sequenceArgs };
-    // 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);
-    for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
-        const step = steps[stepIdx];
-        // 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 = {
-                    type: 'print',
-                    stepIndex: stepIdx,
-                    print: {
-                        title: `if ${step.content}: ${conditionMet ? 'true' : 'false'}`,
-                        timestamp: Date.now() - startTime
-                    }
-                };
-                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)((0, parser_1.substituteVariables)(step.content, runtimeVariables));
-            if (!parsed) {
-                errors.push(`Step ${stepIdx + 1}: Invalid assert command: ${step.content}`);
-                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,
-                assertion: result,
-                lineNumber: step.lineNumber
-            };
-            orderedSteps.push(stepResult);
-            const statusIcon = result.passed ? '✓' : '✗';
-            reportProgress(stepIdx, 'assertion', `${statusIcon} assert ${result.expression}`, stepResult);
-            // If assertion failed, stop the sequence
-            if (!result.passed) {
-                const failMessage = result.message
-                    ? `Assertion failed: ${result.message}`
-                    : `Assertion failed: ${result.expression}`;
-                errors.push(failMessage);
-                if (result.error) {
-                    errors.push(`  Error: ${result.error}`);
-                }
-                else {
-                    errors.push(`  Expected: ${result.rightExpression ?? result.operator}`);
-                    errors.push(`  Actual: ${JSON.stringify(result.leftValue)}`);
-                }
-                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 = {
-                type: 'print',
-                stepIndex: stepIdx,
-                print: {
-                    title,
-                    body,
-                    timestamp: Date.now() - startTime
-                }
-            };
-            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 = {
-                type: 'print',
-                stepIndex: stepIdx,
-                print: {
-                    title: `Waited ${durationMs >= 1000 ? (durationMs / 1000) + 's' : durationMs + 'ms'}`,
-                    timestamp: Date.now() - startTime
-                }
-            };
-            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,
-                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
-                };
-            }
-            // Store the JSON data as a stringified value in runtimeVariables
-            // This allows {{varName.property}} access via the substituteVariables function
-            runtimeVariables[parsed.varName] = JSON.stringify(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;
-            try {
-                jsonObj = JSON.parse(runtimeVariables[parsed.varName]);
-            }
-            catch {
-                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') {
-                    try {
-                        const parsed = JSON.parse(value);
-                        if (typeof parsed === 'object' && parsed !== null) {
-                            value = parsed;
-                        }
-                    }
-                    catch {
-                        // Not a JSON string, use as-is
-                    }
-                }
-                if (pathPart) {
-                    // Navigate the path
-                    const path = pathPart.replace(/^\./, '');
-                    newValue = getNestedValueFromObject(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
-            runtimeVariables[parsed.varName] = JSON.stringify(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 === '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 resolvedUrl = '';
-            let resolvedHeaders = {};
-            let requestDescription = `${parsed.method} ${parsed.url}`;
-            try {
-                // Check if the URL is actually a named endpoint (e.g., GetUser(1))
-                const endpointMatch = parsed.url.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]*)\))?(\s+.*)?$/);
-                const potentialEndpointName = endpointMatch ? endpointMatch[1] : null;
-                const endpoint = apiDefinitions && potentialEndpointName
-                    ? (0, nornapiParser_1.getEndpoint)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, potentialEndpointName)
-                    : undefined;
-                if (endpoint && apiDefinitions) {
-                    // This is a named endpoint - resolve it
-                    const paramsStr = endpointMatch[2] || '';
-                    const headerGroupsStr = endpointMatch[3]?.trim() || '';
-                    // Parse parameters - supports both positional and named syntax
-                    // Positional: GetUser("123", "456") 
-                    // Named: GetUser(id: "123", orderId: "456")
-                    const paramTokens = paramsStr ? paramsStr.split(',').map(p => p.trim()) : [];
-                    const params = {};
-                    // Check if using named parameter syntax (first token contains ':')
-                    const isNamedSyntax = paramTokens.length > 0 && paramTokens[0].includes(':');
-                    if (isNamedSyntax) {
-                        // Named parameter syntax: param: value
-                        for (const token of paramTokens) {
-                            const kvMatch = token.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
-                            if (kvMatch) {
-                                const paramName = kvMatch[1];
-                                let paramValue = kvMatch[2].trim().replace(/^["']|["']$/g, '');
-                                // Resolve variables
-                                const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
-                                params[paramName] = (0, parser_1.substituteVariables)(bareResolved, runtimeVariables);
-                            }
-                        }
-                    }
-                    else {
-                        // Positional parameter syntax
-                        endpoint.parameters.forEach((paramName, idx) => {
-                            if (paramTokens[idx] !== undefined) {
-                                let paramValue = paramTokens[idx].replace(/^["']|["']$/g, '');
-                                // Resolve variables
-                                const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
-                                params[paramName] = (0, parser_1.substituteVariables)(bareResolved, runtimeVariables);
-                            }
-                        });
-                    }
-                    // Resolve endpoint path with variables and parameters
-                    let pathWithVars = (0, parser_1.substituteVariables)(endpoint.path, runtimeVariables);
-                    for (const paramName of endpoint.parameters) {
-                        const value = params[paramName];
-                        if (value !== undefined) {
-                            pathWithVars = pathWithVars.replace(`{${paramName}}`, value);
-                        }
-                    }
-                    resolvedUrl = pathWithVars;
-                    // Collect headers from header groups if specified
-                    if (headerGroupsStr) {
-                        const headerGroupNames = headerGroupsStr.split(/\s+/).filter(n => n);
-                        for (const groupName of headerGroupNames) {
-                            const group = (0, nornapiParser_1.getHeaderGroup)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, groupName);
-                            if (group) {
-                                const groupHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, runtimeVariables);
-                                Object.assign(resolvedHeaders, groupHeaders);
-                            }
-                        }
-                    }
-                    requestDescription = `${potentialEndpointName}(${paramTokens.join(', ')}) → ${parsed.method} ${resolvedUrl}`;
-                }
-                else {
-                    // Regular URL - substitute variables
-                    resolvedUrl = (0, parser_1.substituteVariables)(parsed.url, runtimeVariables);
-                    requestDescription = `${parsed.method} ${resolvedUrl}`;
-                }
-                // Build request with resolved URL and any headers
-                let requestText = `${parsed.method} ${resolvedUrl}`;
-                if (Object.keys(resolvedHeaders).length > 0) {
-                    const headerLines = Object.entries(resolvedHeaders).map(([k, v]) => `${k}: ${v}`);
-                    requestText += '\n' + headerLines.join('\n');
-                }
-                // 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 requestParsed = (0, parser_1.parserHttpRequest)(requestText, runtimeVariables);
-                // 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: parsed.method,
-                    requestUrl: resolvedUrl,
-                    variableName: parsed.varName
-                };
-                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) {
-                // Build a more informative error message
-                let errorDetails = `Request failed for var ${parsed.varName}: ${error.message}`;
-                if (requestDescription) {
-                    errorDetails += `\n  Request: ${requestDescription}`;
-                }
-                errors.push(errorDetails);
-                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 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
-                );
-                // 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 {
-                let requestParsed;
-                // Check if the named request uses API endpoint syntax (e.g., "POST HttpBinPost Form")
-                if (apiDefinitions && apiDefinitions.endpoints.length > 0 &&
-                    (0, nornapiParser_1.isApiRequestLine)(namedRequest.content, apiDefinitions.endpoints)) {
-                    const apiRequest = (0, nornapiParser_1.parseApiRequest)(namedRequest.content, apiDefinitions.endpoints, apiDefinitions.headerGroups);
-                    if (apiRequest) {
-                        const endpoint = (0, nornapiParser_1.getEndpoint)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, apiRequest.endpointName);
-                        if (endpoint) {
-                            // Resolve the endpoint path with variables and parameters
-                            let resolvedPath = endpoint.path;
-                            // Substitute {{variable}} references
-                            resolvedPath = resolvedPath.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                                return runtimeVariables[varName] !== undefined ? String(runtimeVariables[varName]) : `{{${varName}}}`;
-                            });
-                            for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
-                                let resolvedValue = paramValue;
-                                if (runtimeVariables[paramValue] !== undefined) {
-                                    resolvedValue = String(runtimeVariables[paramValue]);
-                                }
-                                else if (paramValue.startsWith('{{') && paramValue.endsWith('}}')) {
-                                    const varName = paramValue.slice(2, -2);
-                                    if (runtimeVariables[varName] !== undefined) {
-                                        resolvedValue = String(runtimeVariables[varName]);
-                                    }
-                                }
-                                resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
-                            }
-                            // Collect headers from header groups
-                            const combinedHeaders = {};
-                            for (const groupName of apiRequest.headerGroupNames) {
-                                const group = (0, nornapiParser_1.getHeaderGroup)(apiDefinitions, groupName);
-                                if (group) {
-                                    const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, runtimeVariables);
-                                    Object.assign(combinedHeaders, resolvedHeaders);
-                                }
-                            }
-                            // Add inline headers
-                            for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                                let resolved = headerValue;
-                                resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                                    return runtimeVariables[varName] !== undefined ? String(runtimeVariables[varName]) : `{{${varName}}}`;
-                                });
-                                combinedHeaders[headerName] = resolved;
-                            }
-                            // Extract body from the named request content (lines after the request line)
-                            const bodyParsed = (0, parser_1.parserHttpRequest)(namedRequest.content, runtimeVariables);
-                            requestParsed = {
-                                method: apiRequest.method,
-                                url: resolvedPath,
-                                headers: combinedHeaders,
-                                body: bodyParsed.body
-                            };
-                        }
-                        else {
-                            throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
-                        }
-                    }
-                    else {
-                        // Fallback to regular parsing
-                        requestParsed = (0, parser_1.parserHttpRequest)(namedRequest.content, runtimeVariables);
-                    }
-                }
-                else {
-                    // Parse as regular HTTP request
-                    requestParsed = (0, parser_1.parserHttpRequest)(namedRequest.content, runtimeVariables);
-                    // Apply header groups if available (handles "GET url Json" syntax)
-                    if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-                        requestParsed = applyHeaderGroupsToRequest(requestParsed, namedRequest.content, apiDefinitions.headerGroups, runtimeVariables);
-                    }
-                }
-                requestUrl = requestParsed.url;
-                requestMethod = requestParsed.method;
-                // 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
-                };
-                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) {
-                // Build a more informative error message
-                let errorDetails = `Named request "${targetName}" failed: ${error.message}`;
-                if (requestUrl) {
-                    errorDetails += `\n  Request: ${requestMethod} ${requestUrl}`;
-                }
-                errors.push(errorDetails);
-                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 {
-                    // Parse and send the named request with current variables
-                    const requestParsed = (0, parser_1.parserHttpRequest)(namedRequest.content, runtimeVariables);
-                    requestUrl = requestParsed.url;
-                    requestMethod = requestParsed.method;
-                    // 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);
-                    const stepResult = {
-                        type: 'request',
-                        stepIndex: stepIdx,
-                        response: response,
-                        requestMethod: requestParsed.method,
-                        requestUrl: requestParsed.url
-                    };
-                    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] = JSON.stringify(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) {
-                    let errorDetails = `Named request "${sequenceName}" failed: ${error.message}`;
-                    if (requestUrl) {
-                        errorDetails += `\n  Request: ${requestMethod} ${requestUrl}`;
-                    }
-                    errors.push(errorDetails);
-                    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 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
-            );
-            // 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
-                    // return foo.value → returns the value, not {value: ...}
-                    const resolved = resolveReturnExpression(returnExpressions[0], subResult.variables);
-                    if (resolved) {
-                        runtimeVariables[varName] = resolved.value;
-                    }
-                    else {
-                        runtimeVariables[varName] = '';
-                    }
-                }
-                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] = JSON.stringify(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 {
-                // Check if this is an API request (uses endpoint syntax)
-                if (apiDefinitions &&
-                    apiDefinitions.endpoints.length > 0 &&
-                    (0, nornapiParser_1.isApiRequestLine)(step.content, apiDefinitions.endpoints)) {
-                    // Parse API request syntax
-                    const apiRequest = (0, nornapiParser_1.parseApiRequest)(step.content, apiDefinitions.endpoints, apiDefinitions.headerGroups);
-                    if (apiRequest) {
-                        // Get the endpoint
-                        const endpoint = (0, nornapiParser_1.getEndpoint)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, apiRequest.endpointName);
-                        if (!endpoint) {
-                            throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
-                        }
-                        // Resolve parameters in the path (substitute values, including from variables)
-                        // First substitute {{variable}} references in the endpoint path (e.g., {{baseUrl}})
-                        // This must happen BEFORE {param} substitution to avoid conflicts
-                        const pathWithVars = (0, parser_1.substituteVariables)(endpoint.path, runtimeVariables);
-                        // Then substitute {param} placeholders with the values passed to the endpoint
-                        const resolvedParams = {};
-                        for (const [key, value] of Object.entries(apiRequest.params)) {
-                            // First resolve bare variable names, then substitute {{var}} patterns
-                            const bareResolved = resolveBareVariables(value, runtimeVariables);
-                            resolvedParams[key] = (0, parser_1.substituteVariables)(bareResolved, runtimeVariables);
-                        }
-                        // Apply parameter substitutions to the path
-                        let resolvedPath = pathWithVars;
-                        for (const paramName of endpoint.parameters) {
-                            const value = resolvedParams[paramName];
-                            if (value !== undefined) {
-                                resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
-                            }
-                        }
-                        // Collect headers from header groups
-                        const combinedHeaders = {};
-                        for (const groupName of apiRequest.headerGroupNames) {
-                            const group = (0, nornapiParser_1.getHeaderGroup)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, groupName);
-                            if (group) {
-                                // Resolve variable references in header values
-                                const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, runtimeVariables);
-                                Object.assign(combinedHeaders, resolvedHeaders);
-                            }
-                        }
-                        // Add inline headers (these take precedence over header groups)
-                        for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                            // Resolve variable references in header values
-                            combinedHeaders[headerName] = (0, parser_1.substituteVariables)(headerValue, runtimeVariables);
-                        }
-                        // Resolve variables in the body if present
-                        let resolvedBody;
-                        if (apiRequest.body) {
-                            resolvedBody = (0, parser_1.substituteVariables)(apiRequest.body, runtimeVariables);
-                        }
-                        parsed = {
-                            method: apiRequest.method,
-                            url: resolvedPath,
-                            headers: combinedHeaders,
-                            body: resolvedBody
-                        };
-                        requestDescription = `${apiRequest.endpointName}(${Object.values(resolvedParams).join(', ')}) → ${parsed.method} ${parsed.url}`;
-                    }
-                    else {
-                        // Fallback to regular parsing if API parsing fails
-                        parsed = (0, parser_1.parserHttpRequest)(step.content, runtimeVariables);
-                        requestDescription = `${parsed.method} ${parsed.url}`;
-                        // Check for header group names in the step content
-                        if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-                            parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
-                        }
-                    }
-                }
-                else {
-                    // Regular HTTP request (URL-based)
-                    parsed = (0, parser_1.parserHttpRequest)(step.content, runtimeVariables);
-                    requestDescription = `${parsed.method} ${parsed.url}`;
-                    // Check for header group names in the step content
-                    if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-                        parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
-                    }
-                    // Check if body is a bare variable name (no {{}} braces)
-                    // This allows: POST url Json\npayload  (where payload is a variable containing JSON)
-                    if (parsed.body) {
-                        const bodyTrimmed = parsed.body.trim();
-                        const bareVarMatch = bodyTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
-                        if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
-                            const varValue = runtimeVariables[bareVarMatch[1]];
-                            if (typeof varValue === 'object' && varValue !== null) {
-                                parsed.body = JSON.stringify(varValue);
-                            }
-                            else if (typeof varValue === 'string') {
-                                parsed.body = varValue;
-                            }
-                            else {
-                                parsed.body = String(varValue);
-                            }
-                        }
-                    }
-                }
-                // Extract retry options from step content (works for both API and regular requests)
-                const { retryCount, backoffMs } = (0, parser_1.extractRetryOptions)(step.content);
-                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
-                };
-                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) {
-                // Build a more informative error message
-                let errorDetails = `Request ${requestIndex} failed: ${error.message}`;
-                if (requestDescription) {
-                    errorDetails += `\n  Request: ${requestDescription}`;
-                }
-                errors.push(errorDetails);
-                // Stop sequence on error
-                return {
-                    name: '',
-                    success: false,
-                    responses,
-                    scriptResults,
-                    assertionResults,
-                    steps: orderedSteps,
-                    errors,
-                    duration: Date.now() - startTime
-                };
-            }
-        }
-    }
-    return {
-        name: '',
-        success: errors.filter(e => !e.startsWith('Warning')).length === 0,
-        responses,
-        scriptResults,
-        assertionResults,
-        steps: orderedSteps,
-        errors,
-        duration: Date.now() - startTime,
-        variables: runtimeVariables
-    };
-}
-//# sourceMappingURL=sequenceRunner.js.map