@apiquest/fracture 1.0.2 → 1.0.5

package/dist/fracture/src/CollectionRunner.js

@@ -1,802 +0,0 @@
-import { EventEmitter } from 'events';
-import { ScriptType, LogLevel } from '@apiquest/types';
-import { VariableResolver } from './VariableResolver.js';
-import { PluginManager } from './PluginManager.js';
-import { PluginLoader } from './PluginLoader.js';
-import { PluginResolver } from './PluginResolver.js';
-import { CollectionAnalyzer } from './CollectionAnalyzer.js';
-import { CollectionValidator } from './CollectionValidator.js';
-import { TestCounter } from './TestCounter.js';
-import { ScriptEngine } from './ScriptEngine.js';
-import { TreeBuilder } from './ExecutionTree.js';
-import { Logger } from './Logger.js';
-import { CookieJar } from './CookieJar.js';
-import { isNullOrEmpty, isNullOrWhitespace } from './utils.js';
-export class CollectionRunner extends EventEmitter {
-    variableResolver;
-    pluginManager;
-    pluginResolver;
-    pluginLoader;
-    collectionAnalyzer;
-    collectionValidator;
-    testCounter;
-    scriptEngine;
-    scriptQueue = Promise.resolve(); // Script execution mutex
-    pluginResolutionPromise; // Track plugin resolution (Phase 1)
-    resolvedPlugins = []; // Available plugins
-    logger;
-    constructor(options) {
-        super();
-        const logLevel = options?.logLevel ?? LogLevel.INFO;
-        // Create logger first so it can be passed to other components
-        this.logger = new Logger('CollectionRunner', logLevel, this);
-        this.variableResolver = new VariableResolver(this.logger);
-        this.pluginManager = new PluginManager(this, logLevel);
-        this.pluginResolver = new PluginResolver(this.logger);
-        this.pluginLoader = new PluginLoader(this.pluginManager, this.logger);
-        this.collectionAnalyzer = new CollectionAnalyzer();
-        this.collectionValidator = new CollectionValidator(this.pluginManager);
-        this.testCounter = new TestCounter(this.pluginManager);
-        this.scriptEngine = new ScriptEngine(this.logger);
-        // Phase 1: Resolve plugins if directories provided (fast - just scans, no loading)
-        if (options?.pluginsDir !== undefined) {
-            const dirs = Array.isArray(options.pluginsDir)
-                ? options.pluginsDir
-                : [options.pluginsDir];
-            // Start plugin resolution (but don't block constructor)
-            this.pluginResolutionPromise = this.pluginResolver.scanDirectories(dirs);
-        }
-        else {
-            // No plugins to resolve
-            this.pluginResolutionPromise = Promise.resolve([]);
-        }
-    }
-    /**
-     * Queue script execution to ensure sequential execution (thread-safe)
-     */
-    async queueScript(fn) {
-        const resultPromise = this.scriptQueue.then(fn);
-        this.scriptQueue = resultPromise.then(() => { }, () => { });
-        return resultPromise;
-    }
-    registerPlugin(plugin) {
-        this.pluginManager.registerPlugin(plugin);
-    }
-    registerAuthPlugin(plugin) {
-        this.pluginManager.registerAuthPlugin(plugin);
-    }
-    emitConsoleOutput(messages) {
-        if (messages === undefined || messages.length === 0)
-            return;
-        for (const message of messages) {
-            let level = 'log';
-            let cleanMessage = message;
-            if (message.startsWith('[INFO] ')) {
-                level = 'info';
-                cleanMessage = message.replace('[INFO] ', '');
-            }
-            else if (message.startsWith('[WARN] ')) {
-                level = 'warn';
-                cleanMessage = message.replace('[WARN] ', '');
-            }
-            else if (message.startsWith('[ERROR] ')) {
-                level = 'error';
-                cleanMessage = message.replace('[ERROR] ', '');
-            }
-            this.emit('console', { message: cleanMessage, level });
-        }
-    }
-    /**
-     * Subscribe to ALL events emitted by the runner (including custom plugin events)
-     * Overrides emit to intercept all event emissions
-     */
-    onAll(handler) {
-        // Store original emit
-        const originalEmit = this.emit.bind(this);
-        // Override emit to intercept all events
-        this.emit = function (event, ...args) {
-            // Call original handler first
-            const result = originalEmit(event, ...args);
-            // Skip internal EventEmitter events
-            if (event !== 'newListener' && event !== 'removeListener') {
-                handler(String(event), args[0]);
-            }
-            return result;
-        };
-        // Return cleanup function
-        return () => {
-            // Restore original emit
-            this.emit = originalEmit;
-        };
-    }
-    /**
-     * Create event envelope for all events (except console)
-     */
-    createEventEnvelope(collectionInfo, path, context, request) {
-        const pathType = path === 'collection:/' ? 'collection' : path.startsWith('folder:/') ? 'folder' : 'request';
-        const envelope = {
-            path,
-            pathType,
-            collectionInfo
-        };
-        // Add iteration info if available
-        if (context !== undefined) {
-            const currentRow = context.currentIterationData;
-            envelope.iteration = {
-                current: context.iterationCurrent,
-                total: context.iterationCount,
-                source: context.iterationSource,
-                rowIndex: currentRow !== undefined ? context.iterationCurrent - 1 : undefined,
-                rowKeys: currentRow !== undefined ? Object.keys(currentRow) : undefined,
-                row: currentRow
-            };
-        }
-        // Add request if provided
-        if (request !== undefined) {
-            envelope.request = request;
-        }
-        return envelope;
-    }
-    async run(collection, options = {}) {
-        const startTime = new Date();
-        // Set log level from options (if provided, overrides constructor level)
-        if (options.logLevel !== undefined) {
-            this.logger.setLevel(options.logLevel);
-            this.pluginManager.setLogLevel(options.logLevel);
-        }
-        // Phase 1: Wait for plugin resolution
-        this.resolvedPlugins = await this.pluginResolutionPromise;
-        this.logger.debug(`Plugin resolution complete: ${this.resolvedPlugins.length} plugins available`);
-        // Analyze collection to determine required plugins
-        const requirements = this.collectionAnalyzer.analyzeRequirements(collection);
-        this.logger.debug(`Collection requires: protocols=[${Array.from(requirements.protocols)}], auth=[${Array.from(requirements.authTypes)}], providers=[${Array.from(requirements.valueProviders)}]`);
-        // Phase 2: Load ONLY required plugins
-        await this.pluginLoader.loadRequiredPlugins(this.resolvedPlugins, requirements);
-        this.logger.debug('Required plugins loaded');
-        this.logger.info(`Starting collection: ${collection.info.name}`);
-        this.logger.debug(`Collection ID: ${collection.info.id}, Protocol: ${collection.protocol}`);
-        // Validate and cache protocol plugin
-        const protocolPlugin = this.pluginManager.getPlugin(collection.protocol);
-        if (protocolPlugin === undefined) {
-            throw new Error(`No plugin registered for protocol '${collection.protocol}'. ` +
-                `Available protocols: ${this.pluginManager.getAllPlugins().flatMap(p => p.protocols).join(', ')}`);
-        }
-        // Merge runtime options (needed for validation)
-        const runtimeOptions = this.mergeOptions(collection.options, options);
-        // Get strict mode with precedence: RunOptions > Collection.options > Default (true)
-        const strictMode = options.strictMode ?? collection.options?.strictMode ?? true;
-        // PRE-RUN VALIDATION
-        const validationResult = await this.collectionValidator.validateCollection(collection, runtimeOptions, strictMode);
-        // COUNT EXPECTED TESTS (only in strict mode for deterministic counting)
-        const expectedTestCount = strictMode ? this.testCounter.countTests(collection) : -1;
-        const treeBuilder = new TreeBuilder(options.data, this.logger);
-        const tree = treeBuilder.build(collection);
-        const collectionItem = tree.item;
-        const iterationData = collectionItem.testData ?? [];
-        const iterationCount = iterationData.length > 0 ? iterationData.length : 1;
-        // Determine iteration source for event envelopes
-        const iterationSource = options.data !== undefined ? 'cli' : (collection.testData !== undefined ? 'collection' : 'none');
-        // Emit beforeRun with validation results and expected test count
-        // Note: -1 means dynamic (can't determine), undefined means not calculated
-        this.emit('beforeRun', {
-            collectionInfo: {
-                id: collection.info.id,
-                name: collection.info.name,
-                version: collection.info.version,
-                description: collection.info.description
-            },
-            options,
-            validationResult,
-            expectedTestCount // Include -1 for dynamic tests
-        });
-        // STOP if validation failed
-        if (validationResult.valid === false) {
-            const endTime = new Date();
-            return {
-                collectionId: collection.info.id,
-                collectionName: collection.info.name,
-                startTime,
-                endTime,
-                duration: endTime.getTime() - startTime.getTime(),
-                requestResults: [],
-                totalTests: 0,
-                passedTests: 0,
-                failedTests: 0,
-                skippedTests: 0,
-                validationErrors: validationResult.errors
-            };
-        }
-        const requestResults = [];
-        // Initialize cookie jar - always create one
-        // If jar.persist = true, cookies carry across requests
-        // If jar.persist = false (default), each request gets cookies from response only
-        const cookieJar = new CookieJar(runtimeOptions.jar ?? { persist: false });
-        // Inject initial cookies if provided in options
-        if (runtimeOptions.cookies !== null && runtimeOptions.cookies !== undefined && runtimeOptions.cookies.length > 0) {
-            for (const cookie of runtimeOptions.cookies) {
-                // Skip cookies without domain - domain is required for RFC 6265 compliance
-                if (cookie.domain === null || cookie.domain === undefined) {
-                    continue;
-                }
-                cookieJar.set(cookie.name, cookie.value, {
-                    domain: cookie.domain,
-                    path: cookie.path,
-                    expires: cookie.expires,
-                    httpOnly: cookie.httpOnly,
-                    secure: cookie.secure,
-                    sameSite: cookie.sameSite
-                });
-            }
-        }
-        // Initialize scope stack with collection scope
-        const scopeStack = [{
-                level: 'collection',
-                id: collection.info.id,
-                vars: {}
-            }];
-        // Execute collection pre-request script once before all iterations
-        if (!isNullOrWhitespace(collection.collectionPreScript)) {
-            // Emit event before collection pre-script execution
-            const envelope = this.createEventEnvelope(collection.info, 'collection:/', undefined);
-            this.emit('beforeCollectionPreScript', {
-                ...envelope,
-                path: 'collection:/'
-            });
-            const tempContext = {
-                collectionInfo: collection.info,
-                protocol: collection.protocol,
-                collectionVariables: collection.variables ?? {},
-                globalVariables: options.globalVariables ?? {},
-                scopeStack: [...scopeStack], // Clone scope stack
-                environment: options.environment,
-                iterationCurrent: 1,
-                iterationCount,
-                iterationData,
-                currentIterationData: iterationData[0],
-                iterationSource,
-                executionHistory: [],
-                options: this.mergeOptions(collection.options, options),
-                cookieJar,
-                eventEmitter: this,
-                protocolPlugin
-            };
-            const preScriptResult = await this.queueScript(() => this.scriptEngine.execute(collection.collectionPreScript, tempContext, ScriptType.CollectionPre, () => { } // noop - collection pre-scripts cannot have tests
-            ));
-            this.emitConsoleOutput(preScriptResult.consoleOutput);
-            // Emit event after collection pre-script completion
-            const afterEnvelope = this.createEventEnvelope(collection.info, 'collection:/', tempContext);
-            this.emit('afterCollectionPreScript', {
-                ...afterEnvelope,
-                path: 'collection:/',
-                result: preScriptResult
-            });
-            if (preScriptResult.success === false) {
-                throw new Error(`Collection pre-script error: ${preScriptResult.error}`);
-            }
-            // Update context variables for iterations
-            options.globalVariables = tempContext.globalVariables;
-            options.environment = tempContext.environment;
-            // Update collection scope with any changes from script
-            Object.assign(scopeStack[0].vars, tempContext.scopeStack[0].vars);
-        }
-        for (let i = 0; i < iterationCount; i++) {
-            const iterationStart = Date.now();
-            const context = {
-                collectionInfo: collection.info,
-                protocol: collection.protocol,
-                collectionVariables: collection.variables ?? {},
-                globalVariables: options.globalVariables ?? {},
-                scopeStack: [...scopeStack], // Clone scope stack for each iteration
-                environment: options.environment,
-                iterationCurrent: i + 1,
-                iterationCount,
-                iterationData,
-                currentIterationData: iterationData[i],
-                iterationSource,
-                executionHistory: [],
-                options: this.mergeOptions(collection.options, options),
-                cookieJar,
-                eventEmitter: this,
-                protocolPlugin
-            };
-            // Emit beforeIteration event
-            const iterationEnvelope = this.createEventEnvelope(collection.info, 'collection:/', context);
-            this.emit('beforeIteration', {
-                ...iterationEnvelope,
-                iteration: iterationEnvelope.iteration
-            });
-            await this.executeTree(tree, context, requestResults);
-            // Emit afterIteration event
-            const iterationDuration = Date.now() - iterationStart;
-            const afterIterationEnvelope = this.createEventEnvelope(collection.info, 'collection:/', context);
-            this.emit('afterIteration', {
-                ...afterIterationEnvelope,
-                iteration: afterIterationEnvelope.iteration,
-                duration: iterationDuration
-            });
-            // Update collection scope with changes from iteration
-            Object.assign(scopeStack[0].vars, context.scopeStack[0].vars);
-            // Update global variables and environment for next iteration
-            options.globalVariables = context.globalVariables;
-            options.environment = context.environment;
-        }
-        // Execute collection post-request script once after all iterations
-        if (!isNullOrWhitespace(collection.collectionPostScript)) {
-            // Emit event before collection post-script execution
-            const beforePostEnvelope = this.createEventEnvelope(collection.info, 'collection:/', undefined);
-            this.emit('beforeCollectionPostScript', {
-                ...beforePostEnvelope,
-                path: 'collection:/'
-            });
-            const tempContext = {
-                collectionInfo: collection.info,
-                protocol: collection.protocol,
-                collectionVariables: collection.variables ?? {},
-                globalVariables: options.globalVariables ?? {},
-                scopeStack: [...scopeStack], // Clone scope stack
-                environment: options.environment,
-                iterationCurrent: iterationCount,
-                iterationCount,
-                iterationData,
-                currentIterationData: iterationData[iterationCount - 1],
-                iterationSource,
-                executionHistory: [],
-                options: this.mergeOptions(collection.options, options),
-                cookieJar,
-                eventEmitter: this,
-                protocolPlugin
-            };
-            const postScriptResult = await this.queueScript(() => this.scriptEngine.execute(collection.collectionPostScript, tempContext, ScriptType.CollectionPost, () => { } // noop - collection post-scripts cannot have tests
-            ));
-            this.emitConsoleOutput(postScriptResult.consoleOutput);
-            // Emit event for collection post-script completion
-            const afterPostEnvelope = this.createEventEnvelope(collection.info, 'collection:/', tempContext);
-            this.emit('afterCollectionPostScript', {
-                ...afterPostEnvelope,
-                path: 'collection:/',
-                result: postScriptResult
-            });
-            if (postScriptResult.success === false) {
-                throw new Error(`Collection post-script error: ${postScriptResult.error}`);
-            }
-        }
-        const endTime = new Date();
-        const duration = endTime.getTime() - startTime.getTime();
-        const totalTests = requestResults.reduce((sum, r) => sum + r.tests.length, 0);
-        const passedTests = requestResults.reduce((sum, r) => sum + r.tests.filter(t => t.passed && !t.skipped).length, 0);
-        const failedTests = requestResults.reduce((sum, r) => sum + r.tests.filter(t => !t.passed && !t.skipped).length, 0);
-        const skippedTests = requestResults.reduce((sum, r) => sum + r.tests.filter(t => t.skipped).length, 0);
-        const result = {
-            collectionId: collection.info.id,
-            collectionName: collection.info.name,
-            startTime,
-            endTime,
-            duration,
-            requestResults,
-            totalTests,
-            passedTests,
-            failedTests,
-            skippedTests
-        };
-        this.emit('afterRun', {
-            collectionInfo: collection.info,
-            result
-        });
-        return result;
-    }
-    async executeTree(node, context, results) {
-        if (node.type === 'request') {
-            const result = await this.executeRequest(node, context);
-            results.push(result);
-            // If there was a script error, stop execution immediately
-            if (!isNullOrEmpty(result.scriptError)) {
-                throw new Error(`${result.scriptError}`);
-            }
-            return;
-        }
-        // Handle folder node - execute folder scripts
-        if (node.type === 'folder') {
-            const folder = node.item;
-            const folderStart = Date.now();
-            // Emit beforeFolder event
-            const beforeFolderEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-            this.emit('beforeFolder', beforeFolderEnvelope);
-            // PUSH folder scope
-            context.scopeStack.push({
-                level: 'folder',
-                id: folder.id,
-                vars: {}
-            });
-            // Execute folder pre-script
-            if (!isNullOrWhitespace(folder.folderPreScript)) {
-                // Emit event before folder pre-script execution
-                const beforePreEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-                this.emit('beforeFolderPreScript', beforePreEnvelope);
-                const preScriptResult = await this.queueScript(() => this.scriptEngine.execute(folder.folderPreScript, context, ScriptType.FolderPre, () => { } // noop - folder pre-scripts cannot have tests
-                ));
-                this.emitConsoleOutput(preScriptResult.consoleOutput);
-                // Emit event after folder pre-script completion
-                const afterPreEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-                this.emit('afterFolderPreScript', {
-                    ...afterPreEnvelope,
-                    result: preScriptResult
-                });
-                if (preScriptResult.success === false) {
-                    throw new Error(`Folder pre-script error (${folder.name}): ${preScriptResult.error}`);
-                }
-            }
-            // Execute children
-            for (const child of node.children) {
-                await this.executeTree(child, context, results);
-            }
-            // Execute folder post-script
-            if (!isNullOrWhitespace(folder.folderPostScript)) {
-                // Emit event before folder post-script execution
-                const beforePostEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-                this.emit('beforeFolderPostScript', beforePostEnvelope);
-                const postScriptResult = await this.queueScript(() => this.scriptEngine.execute(folder.folderPostScript, context, ScriptType.FolderPost, () => { } // noop - folder post-scripts cannot have tests
-                ));
-                this.emitConsoleOutput(postScriptResult.consoleOutput);
-                // Emit event for folder post-script completion
-                const afterPostEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-                this.emit('afterFolderPostScript', {
-                    ...afterPostEnvelope,
-                    result: postScriptResult
-                });
-                if (postScriptResult.success === false) {
-                    throw new Error(`Folder post-script error (${folder.name}): ${postScriptResult.error}`);
-                }
-            }
-            // POP folder scope (folder variables don't persist)
-            context.scopeStack.pop();
-            // Emit afterFolder event
-            const folderDuration = Date.now() - folderStart;
-            const afterFolderEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context);
-            this.emit('afterFolder', {
-                ...afterFolderEnvelope,
-                duration: folderDuration
-            });
-            return;
-        }
-        // Default: execute children
-        for (const child of node.children) {
-            await this.executeTree(child, context, results);
-        }
-    }
-    async executeRequest(node, context) {
-        const request = node.item;
-        const requestStart = Date.now();
-        context.currentRequest = request;
-        context.currentPath = node.path;
-        // Emit beforeItem event
-        const beforeItemEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-        this.emit('beforeItem', {
-            ...beforeItemEnvelope,
-            request,
-            path: node.path
-        });
-        // PUSH request scope
-        context.scopeStack.push({
-            level: 'request',
-            id: request.id,
-            vars: {}
-        });
-        try {
-            // Queue all pre-request scripts
-            const preScripts = [
-                ...(node.inheritedScripts.preRequest ?? []).map(script => ({
-                    script,
-                    source: 'inherited'
-                })),
-                ...(!isNullOrWhitespace(request.preRequestScript)
-                    ? [{ script: request.preRequestScript, source: 'request' }]
-                    : [])
-            ];
-            if (preScripts.length > 0) {
-                await this.queueScript(async () => {
-                    for (const { script, source } of preScripts) {
-                        // Emit beforePreScript event
-                        const beforePreEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                        this.emit('beforePreScript', {
-                            ...beforePreEnvelope,
-                            request,
-                            path: node.path
-                        });
-                        const preScriptResult = await this.scriptEngine.execute(script, context, ScriptType.PreRequest, () => { } // noop - pre-request scripts cannot have tests
-                        );
-                        this.emitConsoleOutput(preScriptResult.consoleOutput);
-                        // Emit afterPreScript event
-                        const afterPreEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                        this.emit('afterPreScript', {
-                            ...afterPreEnvelope,
-                            request,
-                            path: node.path,
-                            result: preScriptResult
-                        });
-                        if (preScriptResult.success === false) {
-                            const error = new Error(`${source === 'inherited' ? 'Inherited pre-request' : 'Pre-request'} script error: ${preScriptResult.error}`);
-                            error.phase = 'prerequest';
-                            throw error;
-                        }
-                    }
-                });
-            }
-            // HTTP execution NOT queued - runs in parallel
-            const resolvedRequest = this.resolveRequest(request, context);
-            let resolvedAuth = node.effectiveAuth;
-            if (resolvedAuth?.data !== undefined) {
-                resolvedAuth = {
-                    ...resolvedAuth,
-                    data: this.variableResolver.resolveAll(resolvedAuth.data, context)
-                };
-            }
-            const requestWithAuth = { ...resolvedRequest, auth: resolvedAuth };
-            // Track event indices and tests for plugin events (per request)
-            const eventIndices = new Map();
-            const pluginEventTests = []; // Collect tests from plugin events
-            // Create emitEvent callback for plugin event execution
-            const emitEvent = async (eventName, eventData) => {
-                this.logger.trace(`Plugin event emitted: ${eventName}`, { hasScripts: request.data.scripts !== undefined });
-                // Find matching script (validation ensures at most one per event type)
-                const eventScript = request.data.scripts?.find(s => s.event === eventName);
-                this.logger.trace(`Event script found: ${eventScript !== undefined}`);
-                if (eventScript === undefined)
-                    return;
-                // Get current event index (starts at 0)
-                const currentIndex = eventIndices.get(eventName) ?? 0;
-                // Set event context (wrapped in try/finally to prevent state leak)
-                try {
-                    context.currentEvent = {
-                        eventName: eventName,
-                        requestId: request.id,
-                        timestamp: new Date(),
-                        data: eventData,
-                        index: currentIndex
-                    };
-                    // Execute plugin event script
-                    const result = await this.scriptEngine.execute(eventScript.script, context, ScriptType.PluginEvent, (test) => {
-                        // Emit assertion event for plugin event test
-                        const eventDef = context.protocolPlugin.events?.find(e => e.name === eventName);
-                        if (eventDef?.canHaveTests === true) {
-                            const envelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                            this.emit('assertion', {
-                                ...envelope,
-                                test,
-                                event: eventName
-                            });
-                        }
-                    });
-                    // Handle test results - add directly to collection
-                    if (result.tests !== undefined && result.tests.length > 0) {
-                        this.logger.trace(`Plugin event tests collected: ${result.tests.length}`);
-                        pluginEventTests.push(...result.tests);
-                    }
-                    else {
-                        this.logger.trace('No tests in plugin event result');
-                    }
-                    // Handle script errors (log but don't throw - allow other events to continue)
-                    if (!isNullOrEmpty(result.error)) {
-                        this.logger.error(`Plugin event script error (${eventName}):`, result.error);
-                    }
-                }
-                finally {
-                    // CRITICAL: Always reset event context to prevent state leak
-                    context.currentEvent = undefined;
-                    // Increment event index for next event of same type
-                    eventIndices.set(eventName, currentIndex + 1);
-                }
-            };
-            // Emit beforeRequest event
-            const beforeRequestEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-            this.emit('beforeRequest', {
-                ...beforeRequestEnvelope,
-                request,
-                path: node.path
-            });
-            const response = await this.pluginManager.execute(context.protocol, requestWithAuth, context, context.options, emitEvent // Pass event emitter to plugin
-            );
-            context.currentResponse = response;
-            // Emit afterRequest event (after HTTP execution, before post-scripts)
-            const requestDuration = Date.now() - requestStart;
-            const afterRequestEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-            this.emit('afterRequest', {
-                ...afterRequestEnvelope,
-                request,
-                response,
-                duration: requestDuration
-            });
-            // Add preliminary execution record to history
-            this.logger.trace(`Creating execution record with ${pluginEventTests.length} plugin event tests`);
-            const executionRecord = {
-                id: request.id,
-                name: request.name,
-                path: node.path,
-                iteration: context.iterationCurrent,
-                response,
-                tests: [...pluginEventTests], // Add plugin event tests first
-                timestamp: new Date().toISOString()
-            };
-            this.logger.trace(`Execution record has ${executionRecord.tests.length} total tests`);
-            context.executionHistory.push(executionRecord);
-            // Queue all post-request scripts
-            const postScripts = [
-                ...(!isNullOrWhitespace(request.postRequestScript)
-                    ? [{ script: request.postRequestScript, source: 'request' }]
-                    : []),
-                ...(node.inheritedScripts.postRequest ?? []).map(script => ({
-                    script,
-                    source: 'inherited'
-                }))
-            ];
-            const scriptResult = postScripts.length > 0
-                ? await this.queueScript(async () => {
-                    const combinedResult = { success: true, tests: [], consoleOutput: [] };
-                    for (const { script, source } of postScripts) {
-                        // Emit beforePostScript event
-                        const beforePostEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                        this.emit('beforePostScript', {
-                            ...beforePostEnvelope,
-                            request,
-                            path: node.path,
-                            response
-                        });
-                        const postScriptResult = await this.scriptEngine.execute(script, context, ScriptType.PostRequest, (test) => {
-                            // Emit assertion event for post-request test
-                            const envelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                            this.emit('assertion', {
-                                ...envelope,
-                                test,
-                                response
-                            });
-                        });
-                        this.emitConsoleOutput(postScriptResult.consoleOutput);
-                        // Emit afterPostScript event
-                        const afterPostEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-                        this.emit('afterPostScript', {
-                            ...afterPostEnvelope,
-                            request,
-                            path: node.path,
-                            response,
-                            result: postScriptResult
-                        });
-                        if (postScriptResult.success === false) {
-                            const error = new Error(`${source === 'inherited' ? 'Inherited post-request' : 'Post-request'} script error: ${postScriptResult.error}`);
-                            error.phase = 'postrequest';
-                            throw error;
-                        }
-                        combinedResult.tests.push(...postScriptResult.tests);
-                        combinedResult.consoleOutput.push(...postScriptResult.consoleOutput);
-                    }
-                    return combinedResult;
-                })
-                : { success: true, tests: [], consoleOutput: [] };
-            // Update the execution record with all tests (plugin events + post-request scripts)
-            const allTests = [...pluginEventTests, ...scriptResult.tests];
-            executionRecord.tests = allTests;
-            const duration = Date.now() - requestStart;
-            const result = {
-                requestId: request.id,
-                requestName: request.name,
-                path: node.path,
-                success: isNullOrEmpty(response.error),
-                response,
-                tests: allTests,
-                duration,
-                iteration: context.iterationCurrent
-            };
-            // Emit afterItem event
-            const afterItemEnvelope = this.createEventEnvelope(context.collectionInfo, node.path, context, request);
-            this.emit('afterItem', {
-                ...afterItemEnvelope,
-                request,
-                path: node.path,
-                response,
-                result
-            });
-            // Clear cookies if persist is false (default behavior)
-            if (context.options.jar?.persist !== true) {
-                context.cookieJar.clear();
-            }
-            // POP request scope
-            context.scopeStack.pop();
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - requestStart;
-            const err = error;
-            const result = {
-                requestId: request.id,
-                requestName: request.name,
-                path: node.path,
-                success: false,
-                tests: [],
-                duration,
-                scriptError: err.message ?? String(error),
-                iteration: context.iterationCurrent
-            };
-            const phase = err.phase ?? 'request';
-            this.emit('exception', {
-                error,
-                phase,
-                request,
-                path: node.path,
-                response: context.currentResponse
-            });
-            // POP request scope even on error
-            context.scopeStack.pop();
-            return result;
-        }
-    }
-    resolveRequest(request, context) {
-        const resolved = {
-            ...request,
-            data: this.variableResolver.resolveAll(request.data, context)
-        };
-        // Also resolve variables in auth configuration
-        if (resolved.auth?.data !== undefined) {
-            resolved.auth = {
-                ...resolved.auth,
-                data: this.variableResolver.resolveAll(resolved.auth.data, context)
-            };
-        }
-        return resolved;
-    }
-    mergeOptions(collectionOptions, runOptions) {
-        // Since RunOptions extends RuntimeOptions, merge is straightforward
-        // RunOptions takes precedence over collectionOptions
-        const merged = {
-            ...collectionOptions,
-            ...runOptions,
-            // Deep merge nested objects
-            execution: {
-                ...(collectionOptions?.execution ?? {}),
-                ...(runOptions?.execution ?? {})
-            },
-            // Ensure defaults
-            logLevel: runOptions?.logLevel ?? collectionOptions?.logLevel ?? LogLevel.INFO,
-            strictMode: runOptions?.strictMode ?? collectionOptions?.strictMode ?? true
-        };
-        // Conditionally merge optional nested objects
-        if (collectionOptions?.timeout !== undefined || runOptions?.timeout !== undefined) {
-            merged.timeout = {
-                ...(collectionOptions?.timeout ?? {}),
-                ...(runOptions?.timeout ?? {})
-            };
-        }
-        if (collectionOptions?.ssl !== undefined || runOptions?.ssl !== undefined) {
-            merged.ssl = {
-                ...(collectionOptions?.ssl ?? {}),
-                ...(runOptions?.ssl ?? {})
-            };
-        }
-        if (collectionOptions?.jar !== undefined || runOptions?.jar !== undefined) {
-            merged.jar = {
-                persist: runOptions?.jar?.persist ?? collectionOptions?.jar?.persist ?? false
-            };
-        }
-        if (runOptions?.proxy !== null && runOptions?.proxy !== undefined) {
-            merged.proxy = runOptions.proxy;
-        }
-        else if (collectionOptions?.proxy !== null && collectionOptions?.proxy !== undefined) {
-            merged.proxy = collectionOptions.proxy;
-        }
-        // Merge cookies arrays (runOptions cookies + collectionOptions cookies)
-        const collectionCookies = collectionOptions?.cookies ?? [];
-        const runCookies = runOptions?.cookies ?? [];
-        if (collectionCookies.length > 0 || runCookies.length > 0) {
-            // RunOptions cookies override collection cookies with same name
-            const cookieMap = new Map();
-            // Add collection cookies first
-            for (const cookie of collectionCookies) {
-                cookieMap.set(cookie.name, cookie);
-            }
-            // Then add/override with run cookies
-            for (const cookie of runCookies) {
-                cookieMap.set(cookie.name, cookie);
-            }
-            merged.cookies = Array.from(cookieMap.values());
-        }
-        return merged;
-    }
-}
-//# sourceMappingURL=CollectionRunner.js.map