@testsmith/perfornium 0.6.4 → 0.6.5

package/dist/protocols/web/network/capture.d.ts

@@ -0,0 +1,19 @@
+import { Page } from 'playwright';
+import { NetworkCaptureConfig } from '../../../config';
+import { CapturedNetworkCall } from '../../../metrics/types';
+import { CurrentContext } from './types';
+export type NetworkCallCallback = (call: CapturedNetworkCall) => void;
+export declare class NetworkCaptureManager {
+    private networkCalls;
+    private pendingRequests;
+    private currentContext;
+    private onNetworkCall?;
+    constructor(onNetworkCall?: NetworkCallCallback);
+    setNetworkCallCallback(callback: NetworkCallCallback): void;
+    updateContext(vuId: number, context: CurrentContext): void;
+    setupNetworkCapture(page: Page, vuId: number, config: NetworkCaptureConfig): void;
+    getAndClearNetworkCalls(vuId: number): CapturedNetworkCall[];
+    getNetworkCalls(vuId: number): CapturedNetworkCall[];
+    clearVU(vuId: number): void;
+    clearAll(): void;
+}

package/dist/protocols/web/network/capture.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkCaptureManager = void 0;
+const logger_1 = require("../../../utils/logger");
+const filters_1 = require("./filters");
+const utils_1 = require("./utils");
+class NetworkCaptureManager {
+    constructor(onNetworkCall) {
+        this.networkCalls = new Map();
+        this.pendingRequests = new Map();
+        this.currentContext = new Map();
+        this.onNetworkCall = onNetworkCall;
+    }
+    setNetworkCallCallback(callback) {
+        this.onNetworkCall = callback;
+    }
+    updateContext(vuId, context) {
+        this.currentContext.set(vuId, context);
+    }
+    setupNetworkCapture(page, vuId, config) {
+        if (!this.networkCalls.has(vuId)) {
+            this.networkCalls.set(vuId, []);
+        }
+        const capturedBodies = new Map();
+        logger_1.logger.info(`VU ${vuId}: Setting up network capture with config: ${JSON.stringify(config)}`);
+        // Use route interception to capture response bodies
+        page.route('**/*', async (route) => {
+            const request = route.request();
+            const url = request.url();
+            const shouldCapture = filters_1.NetworkFilters.shouldCaptureUrl(url, config) && config.capture_response_body;
+            if (!shouldCapture) {
+                await route.continue();
+                return;
+            }
+            try {
+                const response = await route.fetch();
+                const contentType = response.headers()['content-type'] || '';
+                let bodyText;
+                if (filters_1.NetworkFilters.shouldCaptureBodyByContentType(contentType, config)) {
+                    try {
+                        bodyText = await response.text();
+                    }
+                    catch {
+                        // Body not available as text
+                    }
+                }
+                if (bodyText !== undefined) {
+                    capturedBodies.set(url, { body: bodyText, headers: response.headers() });
+                }
+                await route.fulfill({ response });
+            }
+            catch (error) {
+                await route.continue();
+            }
+        });
+        // Capture request start
+        page.on('request', (request) => {
+            const url = request.url();
+            if (!filters_1.NetworkFilters.shouldCaptureUrl(url, config))
+                return;
+            const requestId = utils_1.NetworkUtils.generateRequestId();
+            const startTime = Date.now();
+            const currentCtx = this.currentContext.get(vuId);
+            const call = {
+                id: requestId,
+                vu_id: vuId,
+                timestamp: startTime,
+                request_url: url,
+                request_method: request.method(),
+                request_headers: utils_1.NetworkUtils.captureHeaders(request.headers(), config),
+                request_body: utils_1.NetworkUtils.captureRequestBody(request.postData(), config),
+                request_body_truncated: utils_1.NetworkUtils.isBodyTruncated(request.postData(), config),
+                start_time: startTime,
+                resource_type: request.resourceType(),
+                scenario: currentCtx?.scenario,
+                step_name: currentCtx?.step_name,
+                success: false
+            };
+            this.pendingRequests.set(request, { call, vuId });
+        });
+        // Capture response
+        page.on('response', async (response) => {
+            const request = response.request();
+            const url = request.url();
+            if (!filters_1.NetworkFilters.shouldCaptureUrl(url, config))
+                return;
+            const pending = this.pendingRequests.get(request);
+            if (!pending) {
+                logger_1.logger.debug(`VU ${vuId}: Response without matching request for ${url}`);
+                return;
+            }
+            this.pendingRequests.delete(request);
+            const endTime = Date.now();
+            try {
+                const status = response.status();
+                const headers = response.headers();
+                let body;
+                let bodyTruncated = false;
+                const captured = capturedBodies.get(url);
+                if (captured && config.capture_response_body) {
+                    body = utils_1.NetworkUtils.truncateBody(captured.body, config);
+                    bodyTruncated = utils_1.NetworkUtils.isBodyTruncated(captured.body, config);
+                    capturedBodies.delete(url);
+                }
+                else if (config.capture_response_body && filters_1.NetworkFilters.shouldCaptureBodyByContentType(headers['content-type'], config)) {
+                    try {
+                        const bodyText = await response.text();
+                        body = utils_1.NetworkUtils.truncateBody(bodyText, config);
+                        bodyTruncated = utils_1.NetworkUtils.isBodyTruncated(bodyText, config);
+                    }
+                    catch (bodyError) {
+                        logger_1.logger.debug(`Failed to capture response body for ${url}: ${bodyError.message}`);
+                    }
+                }
+                const completedCall = {
+                    ...pending.call,
+                    response_status: status,
+                    response_status_text: response.statusText(),
+                    response_headers: utils_1.NetworkUtils.captureHeaders(headers, config),
+                    response_body: body,
+                    response_body_truncated: bodyTruncated,
+                    response_size: body?.length,
+                    end_time: endTime,
+                    duration: endTime - pending.call.start_time,
+                    success: status >= 200 && status < 400
+                };
+                const vuCalls = this.networkCalls.get(vuId);
+                vuCalls.push(completedCall);
+                // Invoke callback for real-time processing (e.g., InfluxDB storage)
+                if (this.onNetworkCall) {
+                    this.onNetworkCall(completedCall);
+                }
+                if (config.store_separate !== false) {
+                    console.log(`[NETWORK] ${JSON.stringify({
+                        id: completedCall.id,
+                        vu: vuId,
+                        url: url,
+                        method: request.method(),
+                        status: status,
+                        statusText: completedCall.response_status_text,
+                        duration: completedCall.duration,
+                        size: completedCall.response_size || 0,
+                        type: request.resourceType(),
+                        success: completedCall.success,
+                        requestHeaders: completedCall.request_headers,
+                        requestBody: completedCall.request_body,
+                        responseHeaders: completedCall.response_headers,
+                        responseBody: completedCall.response_body
+                    })}`);
+                }
+            }
+            catch (error) {
+                logger_1.logger.debug(`VU ${vuId}: Failed to capture response for ${url}: ${error.message}`);
+            }
+        });
+        // Capture request failures
+        page.on('requestfailed', (request) => {
+            const url = request.url();
+            if (!filters_1.NetworkFilters.shouldCaptureUrl(url, config))
+                return;
+            const pending = this.pendingRequests.get(request);
+            this.pendingRequests.delete(request);
+            const endTime = Date.now();
+            const currentCtx = this.currentContext.get(vuId);
+            const failedCall = {
+                id: pending?.call.id || utils_1.NetworkUtils.generateRequestId(),
+                vu_id: vuId,
+                timestamp: pending?.call.start_time || endTime,
+                request_url: url,
+                request_method: request.method(),
+                request_headers: pending?.call.request_headers,
+                request_body: pending?.call.request_body,
+                start_time: pending?.call.start_time || endTime,
+                end_time: endTime,
+                duration: endTime - (pending?.call.start_time || endTime),
+                resource_type: request.resourceType(),
+                scenario: pending?.call.scenario || currentCtx?.scenario,
+                step_name: pending?.call.step_name || currentCtx?.step_name,
+                success: false,
+                error: request.failure()?.errorText || 'Request failed'
+            };
+            const vuCalls = this.networkCalls.get(vuId);
+            vuCalls.push(failedCall);
+            // Invoke callback for real-time processing (e.g., InfluxDB storage)
+            if (this.onNetworkCall) {
+                this.onNetworkCall(failedCall);
+            }
+            if (config.store_separate !== false) {
+                console.log(`[NETWORK] ${JSON.stringify({
+                    id: failedCall.id,
+                    vu: vuId,
+                    url: url,
+                    method: request.method(),
+                    status: 0,
+                    statusText: 'Failed',
+                    duration: failedCall.duration,
+                    size: 0,
+                    type: request.resourceType(),
+                    success: false,
+                    error: failedCall.error,
+                    requestHeaders: failedCall.request_headers,
+                    requestBody: failedCall.request_body
+                })}`);
+            }
+        });
+    }
+    getAndClearNetworkCalls(vuId) {
+        const calls = this.networkCalls.get(vuId) || [];
+        this.networkCalls.set(vuId, []);
+        return calls;
+    }
+    getNetworkCalls(vuId) {
+        return this.networkCalls.get(vuId) || [];
+    }
+    clearVU(vuId) {
+        this.networkCalls.delete(vuId);
+        this.currentContext.delete(vuId);
+    }
+    clearAll() {
+        this.networkCalls.clear();
+        this.pendingRequests.clear();
+        this.currentContext.clear();
+    }
+}
+exports.NetworkCaptureManager = NetworkCaptureManager;

package/dist/protocols/web/network/filters.d.ts

@@ -0,0 +1,5 @@
+import { NetworkCaptureConfig } from '../../../config';
+export declare class NetworkFilters {
+    static shouldCaptureUrl(url: string, config: NetworkCaptureConfig): boolean;
+    static shouldCaptureBodyByContentType(contentType: string | undefined, config: NetworkCaptureConfig): boolean;
+}

package/dist/protocols/web/network/filters.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkFilters = void 0;
+const minimatch_1 = require("minimatch");
+const logger_1 = require("../../../utils/logger");
+class NetworkFilters {
+    static shouldCaptureUrl(url, config) {
+        let pathname = url;
+        try {
+            pathname = new URL(url).pathname;
+        }
+        catch {
+            // Keep full URL if parsing fails
+        }
+        // Check exclude patterns first
+        if (config.exclude_patterns?.length) {
+            for (const pattern of config.exclude_patterns) {
+                const corePattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '').replace(/^\/+|\/+$/g, '');
+                const simpleMatch = corePattern && (url.includes(corePattern) || pathname.includes(corePattern));
+                if ((0, minimatch_1.minimatch)(url, pattern) || (0, minimatch_1.minimatch)(pathname, pattern) || simpleMatch) {
+                    return false;
+                }
+            }
+        }
+        // Check include patterns (if specified, URL must match at least one)
+        if (config.include_patterns?.length) {
+            for (const pattern of config.include_patterns) {
+                const corePattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '').replace(/^\/+|\/+$/g, '');
+                const simpleMatch = corePattern && (url.includes(corePattern) || pathname.includes(corePattern));
+                const globMatch = (0, minimatch_1.minimatch)(url, pattern) || (0, minimatch_1.minimatch)(pathname, pattern);
+                if (globMatch || simpleMatch) {
+                    logger_1.logger.debug(`URL captured: ${url} matches pattern ${pattern}`);
+                    return true;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    static shouldCaptureBodyByContentType(contentType, config) {
+        if (!contentType)
+            return false;
+        if (!config.content_type_filters?.length)
+            return true;
+        const lowerContentType = contentType.toLowerCase();
+        return config.content_type_filters.some(filter => lowerContentType.includes(filter.toLowerCase()));
+    }
+}
+exports.NetworkFilters = NetworkFilters;

package/dist/protocols/web/network/index.d.ts

@@ -0,0 +1,4 @@
+export { NetworkCaptureManager, NetworkCallCallback } from './capture';
+export { NetworkFilters } from './filters';
+export { NetworkUtils } from './utils';
+export { PendingRequest, CurrentContext, CapturedBody } from './types';

package/dist/protocols/web/network/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkUtils = exports.NetworkFilters = exports.NetworkCaptureManager = void 0;
+var capture_1 = require("./capture");
+Object.defineProperty(exports, "NetworkCaptureManager", { enumerable: true, get: function () { return capture_1.NetworkCaptureManager; } });
+var filters_1 = require("./filters");
+Object.defineProperty(exports, "NetworkFilters", { enumerable: true, get: function () { return filters_1.NetworkFilters; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "NetworkUtils", { enumerable: true, get: function () { return utils_1.NetworkUtils; } });

package/dist/protocols/web/network/types.d.ts

@@ -0,0 +1,13 @@
+import { CapturedNetworkCall } from '../../../metrics/types';
+export interface PendingRequest {
+    call: Partial<CapturedNetworkCall>;
+    vuId: number;
+}
+export interface CurrentContext {
+    scenario?: string;
+    step_name?: string;
+}
+export interface CapturedBody {
+    body: string;
+    headers: Record<string, string>;
+}

package/dist/protocols/web/network/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protocols/web/network/utils.d.ts

@@ -0,0 +1,8 @@
+import { NetworkCaptureConfig } from '../../../config';
+export declare class NetworkUtils {
+    static captureHeaders(headers: Record<string, string>, config: NetworkCaptureConfig): Record<string, string> | undefined;
+    static captureRequestBody(body: string | null | undefined, config: NetworkCaptureConfig): string | undefined;
+    static truncateBody(body: string | null | undefined, config: NetworkCaptureConfig): string | undefined;
+    static isBodyTruncated(body: string | null | undefined, config: NetworkCaptureConfig): boolean;
+    static generateRequestId(): string;
+}

package/dist/protocols/web/network/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkUtils = void 0;
+class NetworkUtils {
+    static captureHeaders(headers, config) {
+        return headers;
+    }
+    static captureRequestBody(body, config) {
+        if (!config.capture_request_body || !body)
+            return undefined;
+        return NetworkUtils.truncateBody(body, config);
+    }
+    static truncateBody(body, config) {
+        if (!body)
+            return undefined;
+        const maxSize = config.max_body_size || 10240;
+        return body.length > maxSize ? body.substring(0, maxSize) : body;
+    }
+    static isBodyTruncated(body, config) {
+        if (!body)
+            return false;
+        const maxSize = config.max_body_size || 10240;
+        return body.length > maxSize;
+    }
+    static generateRequestId() {
+        return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+}
+exports.NetworkUtils = NetworkUtils;

package/dist/reporting/chart-data/index.d.ts

@@ -0,0 +1,5 @@
+export { StepStatisticsCalculator, StepStatistics, StepResponseTime } from './step-statistics';
+export { ThroughputCalculator, RequestsPerSecond, ResponsesPerSecond } from './throughput';
+export { TimelineCalculator, VURampupDataPoint, TimelineDataPoint } from './timeline';
+export { ScenarioCalculator, ScenarioData, ScenarioStatistics, ChartData } from './scenario';
+export { NetworkStatisticsCalculator, NetworkStatistics, EndpointStats } from './network';

package/dist/reporting/chart-data/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkStatisticsCalculator = exports.ScenarioCalculator = exports.TimelineCalculator = exports.ThroughputCalculator = exports.StepStatisticsCalculator = void 0;
+var step_statistics_1 = require("./step-statistics");
+Object.defineProperty(exports, "StepStatisticsCalculator", { enumerable: true, get: function () { return step_statistics_1.StepStatisticsCalculator; } });
+var throughput_1 = require("./throughput");
+Object.defineProperty(exports, "ThroughputCalculator", { enumerable: true, get: function () { return throughput_1.ThroughputCalculator; } });
+var timeline_1 = require("./timeline");
+Object.defineProperty(exports, "TimelineCalculator", { enumerable: true, get: function () { return timeline_1.TimelineCalculator; } });
+var scenario_1 = require("./scenario");
+Object.defineProperty(exports, "ScenarioCalculator", { enumerable: true, get: function () { return scenario_1.ScenarioCalculator; } });
+var network_1 = require("./network");
+Object.defineProperty(exports, "NetworkStatisticsCalculator", { enumerable: true, get: function () { return network_1.NetworkStatisticsCalculator; } });

package/dist/reporting/chart-data/network.d.ts

@@ -0,0 +1,25 @@
+import { TestResult } from '../../metrics/types';
+export interface EndpointStats {
+    endpoint: string;
+    count: number;
+    avg_duration: number;
+    success_rate: number;
+    total_size: number;
+    status_distribution: Record<number, number>;
+}
+export interface NetworkStatistics {
+    total_calls: number;
+    successful_calls: number;
+    failed_calls: number;
+    success_rate: number;
+    avg_duration: number;
+    total_size: number;
+    by_endpoint: EndpointStats[];
+    by_type: Array<{
+        type: string;
+        count: number;
+    }>;
+}
+export declare class NetworkStatisticsCalculator {
+    static calculateNetworkStatistics(results: TestResult[]): NetworkStatistics | null;
+}

package/dist/reporting/chart-data/network.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkStatisticsCalculator = void 0;
+class NetworkStatisticsCalculator {
+    static calculateNetworkStatistics(results) {
+        const allCalls = [];
+        results.forEach(result => {
+            if (result.custom_metrics?.network_calls) {
+                allCalls.push(...result.custom_metrics.network_calls);
+            }
+        });
+        if (allCalls.length === 0)
+            return null;
+        const successfulCalls = allCalls.filter(c => c.success);
+        const failedCalls = allCalls.filter(c => !c.success);
+        const durations = allCalls.filter(c => c.duration).map(c => c.duration);
+        const avgDuration = durations.length > 0
+            ? durations.reduce((a, b) => a + b, 0) / durations.length
+            : 0;
+        const totalSize = allCalls.reduce((sum, c) => sum + (c.response_size || 0), 0);
+        const byEndpoint = new Map();
+        allCalls.forEach(call => {
+            try {
+                const url = new URL(call.request_url);
+                const endpoint = url.pathname;
+                if (!byEndpoint.has(endpoint)) {
+                    byEndpoint.set(endpoint, []);
+                }
+                byEndpoint.get(endpoint).push(call);
+            }
+            catch {
+                // Invalid URL, skip
+            }
+        });
+        const endpointStats = Array.from(byEndpoint.entries())
+            .map(([endpoint, calls]) => {
+            const successful = calls.filter(c => c.success);
+            const callDurations = calls.filter(c => c.duration).map(c => c.duration);
+            const avgDur = callDurations.length > 0
+                ? callDurations.reduce((a, b) => a + b, 0) / callDurations.length
+                : 0;
+            const statusDist = {};
+            calls.forEach(c => {
+                const status = c.response_status || 0;
+                statusDist[status] = (statusDist[status] || 0) + 1;
+            });
+            return {
+                endpoint,
+                count: calls.length,
+                avg_duration: Math.round(avgDur),
+                success_rate: calls.length > 0 ? (successful.length / calls.length) * 100 : 0,
+                total_size: calls.reduce((sum, c) => sum + (c.response_size || 0), 0),
+                status_distribution: statusDist
+            };
+        })
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 20);
+        const byType = new Map();
+        allCalls.forEach(call => {
+            const type = call.resource_type || 'unknown';
+            byType.set(type, (byType.get(type) || 0) + 1);
+        });
+        const typeStats = Array.from(byType.entries())
+            .map(([type, count]) => ({ type, count }))
+            .sort((a, b) => b.count - a.count);
+        return {
+            total_calls: allCalls.length,
+            successful_calls: successfulCalls.length,
+            failed_calls: failedCalls.length,
+            success_rate: allCalls.length > 0 ? (successfulCalls.length / allCalls.length) * 100 : 0,
+            avg_duration: Math.round(avgDuration),
+            total_size: totalSize,
+            by_endpoint: endpointStats,
+            by_type: typeStats
+        };
+    }
+}
+exports.NetworkStatisticsCalculator = NetworkStatisticsCalculator;

package/dist/reporting/chart-data/scenario.d.ts

@@ -0,0 +1,37 @@
+import { TestResult } from '../../metrics/types';
+export interface ScenarioData {
+    name: string;
+    total: number;
+    success: number;
+    errors: number;
+    avgResponseTime: number;
+    responseTimes: number[];
+    successRate: number;
+}
+export interface ScenarioStatistics extends ScenarioData {
+    percentiles: Record<number, number>;
+    minResponseTime: number;
+    maxResponseTime: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+}
+export interface ChartData {
+    responseTimes: Array<{
+        timestamp: number;
+        duration: number;
+        scenario: string;
+    }>;
+    errors: Array<{
+        timestamp: number;
+        error: string;
+        scenario: string;
+    }>;
+    scenarios: ScenarioData[];
+}
+export declare class ScenarioCalculator {
+    static groupByScenario(results: TestResult[]): ScenarioData[];
+    static prepareChartData(results: TestResult[]): ChartData;
+    static calculateScenarioStatistics(results: TestResult[]): ScenarioStatistics[];
+}

package/dist/reporting/chart-data/scenario.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioCalculator = void 0;
+const statistics_1 = require("../statistics");
+class ScenarioCalculator {
+    static groupByScenario(results) {
+        const scenarios = {};
+        results.forEach(result => {
+            if (!scenarios[result.scenario]) {
+                scenarios[result.scenario] = {
+                    name: result.scenario,
+                    total: 0,
+                    success: 0,
+                    errors: 0,
+                    avgResponseTime: 0,
+                    responseTimes: [],
+                    successRate: 0
+                };
+            }
+            const scenario = scenarios[result.scenario];
+            scenario.total++;
+            if (result.success) {
+                scenario.success++;
+                scenario.responseTimes.push(result.duration);
+            }
+            else {
+                scenario.errors++;
+            }
+        });
+        Object.values(scenarios).forEach((scenario) => {
+            if (scenario.responseTimes.length > 0) {
+                scenario.avgResponseTime = scenario.responseTimes.reduce((a, b) => a + b, 0) / scenario.responseTimes.length;
+            }
+            scenario.successRate = scenario.total > 0 ? (scenario.success / scenario.total) * 100 : 0;
+        });
+        return Object.values(scenarios);
+    }
+    static prepareChartData(results) {
+        const responseTimes = results
+            .filter(r => r.success)
+            .map(r => ({
+            timestamp: r.timestamp,
+            duration: r.duration,
+            scenario: r.scenario
+        }));
+        const errors = results
+            .filter(r => !r.success)
+            .map(r => ({
+            timestamp: r.timestamp,
+            error: r.error || 'Unknown error',
+            scenario: r.scenario
+        }));
+        return {
+            responseTimes,
+            errors,
+            scenarios: ScenarioCalculator.groupByScenario(results)
+        };
+    }
+    static calculateScenarioStatistics(results) {
+        const scenarioGroups = ScenarioCalculator.groupByScenario(results);
+        return scenarioGroups.map((scenario) => {
+            const percentiles = statistics_1.StatisticsCalculator.calculatePercentiles(scenario.responseTimes, [50, 90, 95, 99]);
+            return {
+                ...scenario,
+                percentiles,
+                minResponseTime: scenario.responseTimes.length > 0 ? Math.min(...scenario.responseTimes) : 0,
+                maxResponseTime: scenario.responseTimes.length > 0 ? Math.max(...scenario.responseTimes) : 0,
+                p50: percentiles[50] || 0,
+                p90: percentiles[90] || 0,
+                p95: percentiles[95] || 0,
+                p99: percentiles[99] || 0
+            };
+        });
+    }
+}
+exports.ScenarioCalculator = ScenarioCalculator;

package/dist/reporting/chart-data/step-statistics.d.ts

@@ -0,0 +1,24 @@
+import { TestResult, StepStatistics } from '../../metrics/types';
+export type { StepStatistics } from '../../metrics/types';
+export interface StepResponseTime {
+    step_name: string;
+    count: number;
+    avg: number;
+    min: number;
+    max: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    response_times: number[];
+    timeline_data: Array<{
+        duration: number;
+        timestamp: number;
+        vu_id: number;
+        iteration: number;
+    }>;
+}
+export declare class StepStatisticsCalculator {
+    static calculateStepStatistics(results: TestResult[]): StepStatistics[];
+    static calculateStepResponseTimes(results: TestResult[]): StepResponseTime[];
+}