@testsmith/perfornium 0.1.0

package/dist/distributed/health-monitor.d.ts

@@ -0,0 +1,18 @@
+import { RemoteWorker } from './remote-worker';
+export interface WorkerHealth {
+    address: string;
+    lastHeartbeat: number;
+    isHealthy: boolean;
+    responseTime: number;
+    errorCount: number;
+    status: 'connected' | 'disconnected' | 'unhealthy' | 'timeout';
+}
+export declare class HealthMonitor {
+    private workerHealth;
+    private monitorInterval?;
+    private isMonitoring;
+    start(workers: RemoteWorker[], intervalMs?: number): void;
+    stop(): void;
+    updateWorkerStatus(address: string, status: any): void;
+    private checkWorkerHealth;
+}

package/dist/distributed/health-monitor.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthMonitor = void 0;
+const logger_1 = require("../utils/logger");
+class HealthMonitor {
+    constructor() {
+        this.workerHealth = new Map();
+        this.isMonitoring = false;
+    }
+    start(workers, intervalMs = 30000) {
+        this.isMonitoring = true;
+        // Initialize health tracking
+        workers.forEach(worker => {
+            this.workerHealth.set(worker.getAddress(), {
+                address: worker.getAddress(),
+                lastHeartbeat: Date.now(),
+                isHealthy: true,
+                responseTime: 0,
+                errorCount: 0,
+                status: 'connected'
+            });
+        });
+        // Start monitoring loop
+        this.monitorInterval = setInterval(() => {
+            this.checkWorkerHealth();
+        }, intervalMs);
+        logger_1.logger.debug(`💓 Health monitoring started (${intervalMs}ms interval)`);
+    }
+    stop() {
+        this.isMonitoring = false;
+        if (this.monitorInterval) {
+            clearInterval(this.monitorInterval);
+            this.monitorInterval = undefined;
+        }
+        logger_1.logger.debug('💓 Health monitoring stopped');
+    }
+    updateWorkerStatus(address, status) {
+        const health = this.workerHealth.get(address);
+        if (health) {
+            health.lastHeartbeat = Date.now();
+            health.responseTime = status.responseTime || 0;
+            health.status = 'connected';
+            if (status.error) {
+                health.errorCount++;
+            }
+            this.workerHealth.set(address, health);
+        }
+    }
+    checkWorkerHealth() {
+        const now = Date.now();
+        const timeoutMs = 60000; // 1 minute timeout
+        for (const [address, health] of this.workerHealth) {
+            const timeSinceHeartbeat = now - health.lastHeartbeat;
+            if (timeSinceHeartbeat > timeoutMs) {
+                health.isHealthy = false;
+                health.status = 'timeout';
+                logger_1.logger.warn(`⚠️  Worker ${address} health check timeout`);
+            }
+            else if (health.errorCount > 10) {
+                health.isHealthy = false;
+                health.status = 'unhealthy';
+                logger_1.logger.warn(`⚠️  Worker ${address} has too many errors`);
+            }
+            else {
+                health.isHealthy = true;
+                health.status = 'connected';
+            }
+            this.workerHealth.set(address, health);
+        }
+    }
+}
+exports.HealthMonitor = HealthMonitor;

package/dist/distributed/load-distributor.d.ts

@@ -0,0 +1,17 @@
+import { TestConfiguration } from '../config';
+import { RemoteWorker } from './remote-worker';
+export type DistributionStrategy = 'even' | 'capacity_based' | 'round_robin' | 'geographic';
+export interface WorkerAssignment {
+    worker: RemoteWorker;
+    config: TestConfiguration;
+    virtualUsers: number;
+    startDelay?: number;
+}
+export declare class LoadDistributor {
+    distribute(testConfig: TestConfiguration, workers: RemoteWorker[], strategy: DistributionStrategy): WorkerAssignment[];
+    private evenDistribution;
+    private capacityBasedDistribution;
+    private roundRobinDistribution;
+    private geographicDistribution;
+    private createWorkerConfig;
+}

package/dist/distributed/load-distributor.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadDistributor = void 0;
+const logger_1 = require("../utils/logger");
+class LoadDistributor {
+    distribute(testConfig, workers, strategy) {
+        const { getPrimaryLoadPhase } = require('../config/types/load-config');
+        const primaryPhase = getPrimaryLoadPhase(testConfig.load);
+        const totalVUs = primaryPhase.virtual_users || primaryPhase.vus || 1;
+        logger_1.logger.info(`📊 Distributing ${totalVUs} VUs using ${strategy} strategy`);
+        switch (strategy) {
+            case 'even':
+                return this.evenDistribution(testConfig, workers, totalVUs);
+            case 'capacity_based':
+                return this.capacityBasedDistribution(testConfig, workers, totalVUs);
+            case 'round_robin':
+                return this.roundRobinDistribution(testConfig, workers, totalVUs);
+            case 'geographic':
+                return this.geographicDistribution(testConfig, workers, totalVUs);
+            default:
+                throw new Error(`Unknown distribution strategy: ${strategy}`);
+        }
+    }
+    evenDistribution(testConfig, workers, totalVUs) {
+        const vusPerWorker = Math.floor(totalVUs / workers.length);
+        const remainder = totalVUs % workers.length;
+        return workers.map((worker, index) => {
+            const virtualUsers = vusPerWorker + (index < remainder ? 1 : 0);
+            return {
+                worker,
+                virtualUsers,
+                config: this.createWorkerConfig(testConfig, virtualUsers, index)
+            };
+        });
+    }
+    capacityBasedDistribution(testConfig, workers, totalVUs) {
+        const totalCapacity = workers.reduce((sum, worker) => sum + worker.getCapacity(), 0);
+        if (totalCapacity === 0) {
+            throw new Error('No worker capacity available');
+        }
+        return workers.map((worker, index) => {
+            const workerRatio = worker.getCapacity() / totalCapacity;
+            const virtualUsers = Math.round(totalVUs * workerRatio);
+            return {
+                worker,
+                virtualUsers,
+                config: this.createWorkerConfig(testConfig, virtualUsers, index)
+            };
+        });
+    }
+    roundRobinDistribution(testConfig, workers, totalVUs) {
+        const assignments = workers.map((worker, index) => ({
+            worker,
+            virtualUsers: 0,
+            config: this.createWorkerConfig(testConfig, 0, index)
+        }));
+        for (let vu = 0; vu < totalVUs; vu++) {
+            const workerIndex = vu % workers.length;
+            assignments[workerIndex].virtualUsers++;
+        }
+        assignments.forEach((assignment, index) => {
+            assignment.config = this.createWorkerConfig(testConfig, assignment.virtualUsers, index);
+        });
+        return assignments;
+    }
+    geographicDistribution(testConfig, workers, totalVUs) {
+        const regionGroups = new Map();
+        workers.forEach(worker => {
+            const region = worker.getRegion();
+            if (!regionGroups.has(region)) {
+                regionGroups.set(region, []);
+            }
+            regionGroups.get(region).push(worker);
+        });
+        const vusPerRegion = Math.floor(totalVUs / regionGroups.size);
+        const regionRemainder = totalVUs % regionGroups.size;
+        const assignments = [];
+        let regionIndex = 0;
+        for (const [region, regionWorkers] of regionGroups) {
+            const regionVUs = vusPerRegion + (regionIndex < regionRemainder ? 1 : 0);
+            const regionAssignments = this.evenDistribution(testConfig, regionWorkers, regionVUs);
+            assignments.push(...regionAssignments);
+            regionIndex++;
+        }
+        return assignments;
+    }
+    createWorkerConfig(baseConfig, virtualUsers, workerIndex) {
+        // Fixed: Ensure report config has required fields
+        const reportConfig = baseConfig.report ? {
+            ...baseConfig.report,
+            generate: false, // Workers shouldn't generate reports
+            output: baseConfig.report.output || 'worker-report.html' // Provide default
+        } : undefined;
+        return {
+            ...baseConfig,
+            name: `${baseConfig.name} - Worker ${workerIndex + 1}`,
+            load: {
+                ...baseConfig.load,
+                virtual_users: virtualUsers
+            },
+            outputs: baseConfig.outputs?.filter(output => output.type !== 'webhook'),
+            report: reportConfig
+        };
+    }
+}
+exports.LoadDistributor = LoadDistributor;

package/dist/distributed/remote-worker.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import { TestConfiguration } from '../config/types';
+export interface RemoteWorkerConfig {
+    host: string;
+    port: number;
+    capacity: number;
+    region: string;
+}
+export interface WorkerStatus {
+    connected: boolean;
+    running: boolean;
+    virtualUsers: number;
+    requestsPerSecond: number;
+    responseTime: number;
+    errorRate: number;
+    activeRunner?: string;
+}
+export declare class RemoteWorker extends EventEmitter {
+    private config;
+    private connected;
+    private status;
+    constructor(config: RemoteWorkerConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    prepareTest(testConfig: TestConfiguration): Promise<void>;
+    startTest(startTime?: number): Promise<void>;
+    executeTest(testConfig: TestConfiguration): Promise<void>;
+    stop(): Promise<void>;
+    waitForCompletion(): Promise<void>;
+    getWorkerStatus(): Promise<WorkerStatus>;
+    private sendHealthCheck;
+    private sendRequest;
+    getAddress(): string;
+    getCapacity(): number;
+    getRegion(): string;
+    getResults(): Promise<any>;
+}

package/dist/distributed/remote-worker.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteWorker = void 0;
+const events_1 = require("events");
+const logger_1 = require("../utils/logger");
+const http = __importStar(require("http"));
+class RemoteWorker extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.connected = false;
+        this.config = config;
+        this.status = {
+            connected: false,
+            running: false,
+            virtualUsers: 0,
+            requestsPerSecond: 0,
+            responseTime: 0,
+            errorRate: 0
+        };
+    }
+    async connect() {
+        try {
+            // Implement connection logic to worker
+            await this.sendHealthCheck();
+            this.connected = true;
+            this.status.connected = true;
+            logger_1.logger.debug(`🔗 Connected to worker ${this.getAddress()}`);
+        }
+        catch (error) {
+            this.connected = false;
+            this.status.connected = false;
+            throw new Error(`Failed to connect to worker ${this.getAddress()}: ${error}`);
+        }
+    }
+    async disconnect() {
+        this.connected = false;
+        this.status.connected = false;
+        logger_1.logger.debug(`🔌 Disconnected from worker ${this.getAddress()}`);
+    }
+    async prepareTest(testConfig) {
+        if (!this.connected) {
+            throw new Error(`Worker ${this.getAddress()} not connected`);
+        }
+        try {
+            await this.sendRequest('/prepare', {
+                method: 'POST',
+                data: testConfig
+            });
+            logger_1.logger.debug(`📋 Test prepared on worker ${this.getAddress()}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to prepare test on worker ${this.getAddress()}: ${error}`);
+        }
+    }
+    async startTest(startTime) {
+        if (!this.connected) {
+            throw new Error(`Worker ${this.getAddress()} not connected`);
+        }
+        try {
+            await this.sendRequest('/start', {
+                method: 'POST',
+                data: { startTime }
+            });
+            this.status.running = true;
+            logger_1.logger.debug(`🚀 Test started on worker ${this.getAddress()}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to start test on worker ${this.getAddress()}: ${error}`);
+        }
+    }
+    async executeTest(testConfig) {
+        await this.prepareTest(testConfig);
+        await this.startTest();
+    }
+    async stop() {
+        if (!this.connected) {
+            return;
+        }
+        try {
+            await this.sendRequest('/stop', { method: 'POST' });
+            this.status.running = false;
+            logger_1.logger.debug(`⏹️ Test stopped on worker ${this.getAddress()}`);
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to stop test on worker ${this.getAddress()}: ${error}`);
+        }
+    }
+    async waitForCompletion() {
+        if (!this.status.running) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const checkCompletion = async () => {
+                try {
+                    const status = await this.getWorkerStatus();
+                    logger_1.logger.debug(`🔍 Worker ${this.getAddress()} status: running=${status.running}, activeRunner=${status.activeRunner}`);
+                    // Check if worker is no longer running AND has no active runner
+                    if (!status.running && (!status.activeRunner || status.activeRunner === 'idle')) {
+                        this.status.running = false;
+                        logger_1.logger.debug(`✅ Worker ${this.getAddress()} completed`);
+                        resolve();
+                    }
+                    else {
+                        // Continue checking
+                        setTimeout(checkCompletion, 2000); // Check every 2 seconds
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn(`⚠️ Error checking worker ${this.getAddress()} status:`, error);
+                    // On connection error, assume worker completed
+                    this.status.running = false;
+                    resolve();
+                }
+            };
+            checkCompletion();
+        });
+    }
+    async getWorkerStatus() {
+        if (!this.connected) {
+            return this.status;
+        }
+        try {
+            const response = await this.sendRequest('/status', { method: 'GET' });
+            this.status = { ...this.status, ...response };
+            this.emit('status', this.status);
+            return this.status;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    async sendHealthCheck() {
+        const response = await this.sendRequest('/health', { method: 'GET' });
+        if (response.status !== 'healthy') {
+            throw new Error(`Worker health check failed: ${JSON.stringify(response)}`);
+        }
+    }
+    async sendRequest(path, options) {
+        return new Promise((resolve, reject) => {
+            const postData = options.data ? JSON.stringify(options.data) : undefined;
+            const requestOptions = {
+                hostname: this.config.host,
+                port: this.config.port,
+                path,
+                method: options.method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(postData && { 'Content-Length': Buffer.byteLength(postData) })
+                },
+                timeout: 30000
+            };
+            const req = http.request(requestOptions, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    try {
+                        const response = data ? JSON.parse(data) : {};
+                        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                            resolve(response);
+                        }
+                        else {
+                            reject(new Error(`HTTP ${res.statusCode}: ${response.message || 'Request failed'}`));
+                        }
+                    }
+                    catch (error) {
+                        reject(new Error(`Invalid JSON response: ${error}`));
+                    }
+                });
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            if (postData) {
+                req.write(postData);
+            }
+            req.end();
+        });
+    }
+    getAddress() {
+        return `${this.config.host}:${this.config.port}`;
+    }
+    getCapacity() {
+        return this.config.capacity;
+    }
+    getRegion() {
+        return this.config.region;
+    }
+    async getResults() {
+        if (!this.connected) {
+            throw new Error(`Worker ${this.getAddress()} not connected`);
+        }
+        try {
+            return await this.sendRequest('/results', { method: 'GET' });
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+}
+exports.RemoteWorker = RemoteWorker;

package/dist/distributed/result-aggregator.d.ts

@@ -0,0 +1,43 @@
+import { TestResult, VUStartEvent } from '../metrics/types';
+export interface AggregatedResults {
+    summary: {
+        total_requests: number;
+        success_rate: number;
+        avg_response_time: number;
+        requests_per_second: number;
+        total_errors: number;
+        start_time: number;
+        end_time: number;
+        duration: number;
+        total_duration: number;
+        total_virtual_users: number;
+        peak_virtual_users: number;
+        successful_requests: number;
+        failed_requests: number;
+        vu_ramp_up: VUStartEvent[];
+    };
+    results: TestResult[];
+    workers: {
+        [workerAddress: string]: {
+            requests: number;
+            errors: number;
+            avg_response_time: number;
+            requests_per_second: number;
+        };
+    };
+}
+export declare class ResultAggregator {
+    private results;
+    private workerResults;
+    private vuRampUpEvents;
+    private workerVUEvents;
+    private isAggregating;
+    private startTime;
+    private endTime;
+    start(): void;
+    stop(): void;
+    addResult(result: TestResult, workerAddress?: string): void;
+    addVURampUpEvents(events: VUStartEvent[], workerAddress: string): void;
+    getAggregatedResults(): AggregatedResults;
+    clear(): void;
+}

package/dist/distributed/result-aggregator.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultAggregator = void 0;
+const logger_1 = require("../utils/logger");
+class ResultAggregator {
+    constructor() {
+        this.results = [];
+        this.workerResults = new Map();
+        this.vuRampUpEvents = [];
+        this.workerVUEvents = new Map();
+        this.isAggregating = false;
+        this.startTime = 0;
+        this.endTime = 0;
+    }
+    start() {
+        this.isAggregating = true;
+        this.startTime = Date.now();
+        this.results = [];
+        this.workerResults.clear();
+        this.vuRampUpEvents = [];
+        this.workerVUEvents.clear();
+        logger_1.logger.debug('📊 Result aggregation started');
+    }
+    stop() {
+        this.isAggregating = false;
+        this.endTime = Date.now();
+        logger_1.logger.debug('📊 Result aggregation stopped');
+    }
+    addResult(result, workerAddress) {
+        if (!this.isAggregating) {
+            return;
+        }
+        this.results.push(result);
+        if (workerAddress) {
+            if (!this.workerResults.has(workerAddress)) {
+                this.workerResults.set(workerAddress, []);
+            }
+            this.workerResults.get(workerAddress).push(result);
+        }
+    }
+    addVURampUpEvents(events, workerAddress) {
+        if (!this.isAggregating || !events || events.length === 0) {
+            return;
+        }
+        // Store per-worker VU events (with worker-unique VU IDs)
+        if (!this.workerVUEvents.has(workerAddress)) {
+            this.workerVUEvents.set(workerAddress, []);
+        }
+        // Create globally unique VU IDs by prefixing with worker index
+        const workerIndex = Array.from(this.workerVUEvents.keys()).indexOf(workerAddress);
+        const workerPrefix = workerIndex >= 0 ? workerIndex : this.workerVUEvents.size;
+        const maxVUsPerWorker = 10000; // Allows up to 10000 VUs per worker
+        events.forEach(event => {
+            // Create a globally unique VU ID: workerPrefix * maxVUsPerWorker + original vu_id
+            const globalVUId = (workerPrefix * maxVUsPerWorker) + event.vu_id;
+            const globalEvent = {
+                ...event,
+                vu_id: globalVUId
+            };
+            this.vuRampUpEvents.push(globalEvent);
+            this.workerVUEvents.get(workerAddress).push(event); // Keep original for per-worker tracking
+        });
+        logger_1.logger.debug(`📊 Added ${events.length} VU ramp-up events from ${workerAddress}`);
+    }
+    getAggregatedResults() {
+        const totalRequests = this.results.length;
+        const successfulRequests = this.results.filter(r => r.success).length;
+        const failedRequests = totalRequests - successfulRequests;
+        const successRate = totalRequests > 0 ? (successfulRequests / totalRequests) * 100 : 0;
+        const responseTimes = this.results.map(r => r.duration || r.response_size || 0);
+        const avgResponseTime = responseTimes.length > 0
+            ? responseTimes.reduce((sum, time) => sum + time, 0) / responseTimes.length
+            : 0;
+        const duration = this.endTime - this.startTime;
+        const requestsPerSecond = duration > 0 ? (totalRequests / duration) * 1000 : 0;
+        // Aggregate worker-specific results
+        const workerStats = {};
+        for (const [workerAddress, workerResults] of this.workerResults) {
+            const workerRequests = workerResults.length;
+            const workerSuccessful = workerResults.filter(r => r.success).length;
+            const workerErrors = workerRequests - workerSuccessful;
+            const workerResponseTimes = workerResults.map(r => r.duration || r.response_size || 0);
+            const workerAvgResponseTime = workerResponseTimes.length > 0
+                ? workerResponseTimes.reduce((sum, time) => sum + time, 0) / workerResponseTimes.length
+                : 0;
+            const workerRequestsPerSecond = duration > 0 ? (workerRequests / duration) * 1000 : 0;
+            workerStats[workerAddress] = {
+                requests: workerRequests,
+                errors: workerErrors,
+                avg_response_time: workerAvgResponseTime,
+                requests_per_second: workerRequestsPerSecond
+            };
+        }
+        // Calculate total virtual users across all workers
+        // Prefer VU ramp-up events if available (most accurate)
+        let totalVUs = 0;
+        if (this.vuRampUpEvents.length > 0) {
+            // Count from actual VU start events (already made globally unique)
+            totalVUs = this.vuRampUpEvents.length;
+        }
+        else {
+            // Fallback: Each worker has its own VU IDs (1, 2, 3...), so count per worker and sum
+            for (const [, workerResults] of this.workerResults) {
+                const uniqueVUsPerWorker = new Set(workerResults.map(r => r.vu_id)).size;
+                totalVUs += uniqueVUsPerWorker;
+            }
+            // Fallback if no worker info available
+            if (totalVUs === 0) {
+                totalVUs = new Set(this.results.map(r => r.vu_id)).size;
+            }
+        }
+        // Duration in seconds for report display
+        const totalDurationSeconds = duration / 1000;
+        // Sort VU ramp-up events by start time for proper chart rendering
+        const sortedVURampUp = [...this.vuRampUpEvents].sort((a, b) => a.start_time - b.start_time);
+        return {
+            summary: {
+                total_requests: totalRequests,
+                success_rate: successRate,
+                avg_response_time: avgResponseTime,
+                requests_per_second: requestsPerSecond,
+                total_errors: failedRequests,
+                start_time: this.startTime,
+                end_time: this.endTime,
+                duration,
+                total_duration: totalDurationSeconds,
+                total_virtual_users: totalVUs,
+                peak_virtual_users: totalVUs,
+                successful_requests: successfulRequests,
+                failed_requests: failedRequests,
+                vu_ramp_up: sortedVURampUp
+            },
+            results: this.results,
+            workers: workerStats
+        };
+    }
+    clear() {
+        this.results = [];
+        this.workerResults.clear();
+        this.vuRampUpEvents = [];
+        this.workerVUEvents.clear();
+        this.startTime = 0;
+        this.endTime = 0;
+    }
+}
+exports.ResultAggregator = ResultAggregator;

package/dist/dsl/index.d.ts

@@ -0,0 +1,3 @@
+export { TestBuilder, ScenarioBuilder, LoadBuilder, test, load, faker, testData } from './test-builder';
+export type { ScenarioContext } from './test-builder';
+export type { TestConfiguration, Scenario, Step } from '../config/types';