@loadstrike/loadstrike-sdk 1.0.10101 → 1.0.10801

package/dist/types/runtime.d.ts

@@ -1,4 +1,6 @@
-import type { LoadStrikeRunRequest } from "./contracts.js";
+import { type ClusterNodeResult } from "./cluster.js";
+import { RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector, type TrackingPayload } from "./correlation.js";
+import { type EndpointAdapter, type EndpointDefinition } from "./transports.js";
 export declare const LoadStrikeNodeType: {
     readonly SingleNode: "SingleNode";
     readonly Coordinator: "Coordinator";
@@ -55,15 +57,15 @@ export interface LoadStrikeRandom {
     nextBytes(length: number): Uint8Array;
     NextBytes(length: number): Uint8Array;
 }
-export interface LoadStrikeStepReply<TPayload = unknown> {
+export interface LoadStrikeReply<TPayload = unknown> {
     isSuccess: boolean;
     statusCode: string;
     message: string;
     sizeBytes: number;
     customLatencyMs?: number;
     payload?: TPayload;
-    asReply?: () => LoadStrikeStepReply;
-    AsReply?: () => LoadStrikeStepReply;
+    asReply?: () => LoadStrikeReply;
+    AsReply?: () => LoadStrikeReply;
     readonly IsError?: boolean;
     readonly StatusCode?: string;
     readonly Message?: string;
@@ -71,7 +73,7 @@ export interface LoadStrikeStepReply<TPayload = unknown> {
     readonly CustomLatencyMs?: number;
     readonly Payload?: TPayload;
 }
-export type LoadStrikeReply<TPayload = unknown> = LoadStrikeStepReply<TPayload>;
+export type LoadStrikeStepReply<TPayload = unknown> = LoadStrikeReply<TPayload>;
 export interface LoadStrikeStepRuntime {
     scenarioName: string;
     stepName: string;
@@ -260,51 +262,62 @@ export declare class LoadStrikePluginData {
     get Hints(): string[];
     get Tables(): LoadStrikePluginDataTable[];
 }
-export declare class LoadStrikeReportData {
-    scenarioStats: LoadStrikeScenarioStats[];
-    constructor(scenarioStats?: LoadStrikeScenarioStats[]);
-    static create(...scenarioStats: LoadStrikeScenarioStats[]): LoadStrikeReportData;
-    static Create(...scenarioStats: LoadStrikeScenarioStats[]): LoadStrikeReportData;
-    static fromRunResult(result: LoadStrikeRunResult): LoadStrikeReportData;
-    findScenarioStats(scenarioName: string): LoadStrikeScenarioStats | undefined;
-    getScenarioStats(scenarioName: string): LoadStrikeScenarioStats;
-    FindScenarioStats(scenarioName: string): LoadStrikeScenarioStats | undefined;
-    GetScenarioStats(scenarioName: string): LoadStrikeScenarioStats;
-    get ScenarioStats(): LoadStrikeScenarioStats[];
-}
 export interface LoadStrikeRunResult {
     startedUtc: string;
     completedUtc: string;
+    allBytes: number;
     allRequestCount: number;
     allOkCount: number;
     allFailCount: number;
     failedThresholds: number;
+    durationMs: number;
     nodeInfo: LoadStrikeNodeInfo;
     testInfo: LoadStrikeTestInfo;
+    thresholds: LoadStrikeThresholdResult[];
     thresholdResults: LoadStrikeThresholdResult[];
+    metricStats: LoadStrikeMetricStats;
     metrics: LoadStrikeMetricValue[];
     scenarioStats: LoadStrikeScenarioStats[];
     stepStats: LoadStrikeStepStats[];
+    scenarioDurationsMs: Record<string, number>;
     pluginsData: LoadStrikePluginData[];
     disabledSinks: string[];
     sinkErrors: LoadStrikeSinkError[];
+    policyErrors: LoadStrikeRuntimePolicyError[];
     reportFiles: string[];
+    logFiles: string[];
+    correlationRows: Array<Record<string, unknown>>;
+    failedCorrelationRows: Array<Record<string, unknown>>;
+    findScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    getScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats;
+    FindScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    GetScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats;
     readonly StartedUtc?: Date;
     readonly CompletedUtc?: Date;
+    readonly AllBytes?: number;
     readonly AllRequestCount?: number;
     readonly AllOkCount?: number;
     readonly AllFailCount?: number;
     readonly FailedThresholds?: number;
+    readonly DurationMs?: number;
+    readonly Duration?: number;
     readonly NodeInfo?: LoadStrikeNodeInfo;
     readonly TestInfo?: LoadStrikeTestInfo;
+    readonly Thresholds?: LoadStrikeThresholdResult[];
     readonly ThresholdResults?: LoadStrikeThresholdResult[];
+    readonly MetricStats?: LoadStrikeMetricStats;
     readonly Metrics?: LoadStrikeMetricValue[];
     readonly ScenarioStats?: LoadStrikeScenarioStats[];
     readonly StepStats?: LoadStrikeStepStats[];
+    readonly ScenarioDurationsMs?: Record<string, number>;
     readonly PluginsData?: LoadStrikePluginData[];
     readonly DisabledSinks?: string[];
     readonly SinkErrors?: LoadStrikeSinkError[];
+    readonly PolicyErrors?: LoadStrikeRuntimePolicyError[];
     readonly ReportFiles?: string[];
+    readonly LogFiles?: string[];
+    readonly CorrelationRows?: Array<Record<string, unknown>>;
+    readonly FailedCorrelationRows?: Array<Record<string, unknown>>;
 }
 export interface LoadStrikeStepStats extends LoadStrikeStepRuntime {
     ok: LoadStrikeMeasurementStats;
@@ -358,7 +371,7 @@ export interface LoadStrikeScenarioStats extends LoadStrikeScenarioRuntime {
     readonly SortIndex?: number;
     readonly StepStats?: LoadStrikeStepStats[];
 }
-export interface LoadStrikeNodeStats {
+interface LoadStrikeNodeStats {
     startedUtc: string;
     completedUtc: string;
     allBytes: number;
@@ -379,6 +392,7 @@ export interface LoadStrikeNodeStats {
     disabledSinks: string[];
     sinkErrors: LoadStrikeSinkError[];
     reportFiles: string[];
+    logFiles: string[];
     findScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
     getScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
     FindScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
@@ -404,10 +418,48 @@ export interface LoadStrikeNodeStats {
     readonly DisabledSinks?: string[];
     readonly SinkErrors?: LoadStrikeSinkError[];
     readonly ReportFiles?: string[];
+    readonly LogFiles?: string[];
+}
+declare class MeasurementAccumulator {
+    private count;
+    private allBytes;
+    private readonly latenciesMs;
+    private readonly sizesBytes;
+    private readonly statusCodes;
+    get Count(): number;
+    record(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    build(allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
+}
+declare class StepStatsAccumulator {
+    readonly scenarioName: string;
+    readonly stepName: string;
+    readonly sortIndex: number;
+    readonly ok: MeasurementAccumulator;
+    readonly fail: MeasurementAccumulator;
+    constructor(scenarioName: string, stepName: string, sortIndex: number);
+    record(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    build(allScenarioRequestCount: number, durationMs: number): LoadStrikeStepStats;
+}
+declare class ScenarioStatsAccumulator {
+    readonly scenarioName: string;
+    readonly sortIndex: number;
+    readonly ok: MeasurementAccumulator;
+    readonly fail: MeasurementAccumulator;
+    private readonly steps;
+    private nextStepSortIndex;
+    private loadSimulationStats;
+    private currentOperation;
+    constructor(scenarioName: string, sortIndex: number);
+    setLoadSimulation(simulationName: string, value: number): void;
+    setCurrentOperation(operation: LoadStrikeScenarioStats["currentOperation"]): void;
+    getCurrentOperation(): LoadStrikeScenarioStats["currentOperation"];
+    recordScenario(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    recordStep(stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    build(durationMs: number): LoadStrikeScenarioStats;
 }
 export interface LoadStrikeSinkError {
     sinkName: string;
-    phase: "init" | "start" | "realtime" | "final" | "run-result" | "stop";
+    phase: "init" | "start" | "realtime" | "final" | "run-result" | "stop" | "dispose";
     message: string;
     attempts: number;
     readonly SinkName?: string;
@@ -415,6 +467,19 @@ export interface LoadStrikeSinkError {
     readonly Message?: string;
     readonly Attempts?: number;
 }
+export type LoadStrikeRuntimePolicyErrorMode = "fail" | "continue";
+export interface LoadStrikeRuntimePolicyError {
+    policyName: string;
+    callbackName: string;
+    scenarioName: string;
+    stepName: string;
+    message: string;
+    readonly PolicyName?: string;
+    readonly CallbackName?: string;
+    readonly ScenarioName?: string;
+    readonly StepName?: string;
+    readonly Message?: string;
+}
 export interface LoadStrikeSinkSession {
     startedUtc: string;
     scenarioNames: string[];
@@ -458,8 +523,6 @@ export interface LoadStrikeReportingSink {
     SaveRealtimeStats?: (scenarioStats: LoadStrikeScenarioStats[]) => Promise<void> | void;
     saveRealtimeMetrics?: (metrics: LoadStrikeMetricStats) => Promise<void> | void;
     SaveRealtimeMetrics?: (metrics: LoadStrikeMetricStats) => Promise<void> | void;
-    saveFinalStats?: (result: LoadStrikeNodeStats) => Promise<void> | void;
-    SaveFinalStats?: (result: LoadStrikeNodeStats) => Promise<void> | void;
     saveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
     SaveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
     stop?: () => Promise<void> | void;
@@ -474,6 +537,8 @@ export interface LoadStrikeRuntimePolicy {
     afterScenario?: (scenarioName: string, stats: LoadStrikeScenarioRuntime) => Promise<void> | void;
     beforeStep?: (scenarioName: string, stepName: string) => Promise<void> | void;
     afterStep?: (scenarioName: string, stepName: string, reply: LoadStrikeStepReply) => Promise<void> | void;
+    policyName?: string;
+    PolicyName?: string;
 }
 export interface LoadStrikeWorkerPlugin {
     pluginName?: string;
@@ -486,8 +551,8 @@ export interface LoadStrikeWorkerPlugin {
     Stop?: () => Promise<void> | void;
     dispose?: () => Promise<void> | void;
     Dispose?: () => Promise<void> | void;
-    getData?: (result: LoadStrikeNodeStats) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
-    GetData?: (result: LoadStrikeNodeStats) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
+    getData?: (result: LoadStrikeRunResult) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
+    GetData?: (result: LoadStrikeRunResult) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
 }
 export type ILoadStrikeWorkerPlugin = RequireAtLeastOne<LoadStrikeWorkerPlugin, "pluginName" | "PluginName">;
 export interface LoadStrikeRunnerOptions {
@@ -501,7 +566,6 @@ export interface LoadStrikeRunnerOptions {
     coordinatorTargetScenarios?: string[];
     natsServerUrl?: string;
     runnerKey?: string;
-    licenseValidationServerUrl?: string;
     licenseValidationTimeoutSeconds?: number;
     configPath?: string;
     infraConfigPath?: string;
@@ -514,8 +578,6 @@ export interface LoadStrikeRunnerOptions {
     reportFolderPath?: string;
     reportFileName?: string;
     reportFormats?: Array<LoadStrikeReportFormat>;
-    reportFinalizer?: (reportData: LoadStrikeReportData) => LoadStrikeReportData;
-    detailedReportFinalizer?: (result: LoadStrikeRunResult) => LoadStrikeRunResult;
     reportingIntervalSeconds?: number;
     minimumLogLevel?: LoadStrikeLogLevel | string;
     loggerConfig?: () => LoadStrikeLogger;
@@ -525,6 +587,7 @@ export interface LoadStrikeRunnerOptions {
     scenarioCompletionTimeoutSeconds?: number;
     clusterCommandTimeoutSeconds?: number;
     restartIterationMaxAttempts?: number;
+    runtimePolicyErrorMode?: LoadStrikeRuntimePolicyErrorMode | string;
     customSettings?: Record<string, unknown>;
     globalCustomSettings?: Record<string, unknown>;
     runtimePolicies?: LoadStrikeRuntimePolicy[];
@@ -659,23 +722,31 @@ export interface LoadStrikeScenarioContext {
     StopScenario?: (scenarioNameOrReason?: string, reason?: string) => void;
     StopCurrentTest?: (reason?: string) => void;
 }
+interface InternalScenarioContext extends LoadStrikeScenarioContext {
+    readonly scenarioName: string;
+    readonly recordStep: (stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number) => void;
+    readonly shouldStopScenario: () => boolean;
+    readonly shouldStopTest: () => boolean;
+    readonly invokeBeforeStep: (stepName: string) => Promise<void>;
+    readonly invokeAfterStep: (stepName: string, reply: LoadStrikeStepReply) => Promise<void>;
+}
 export declare class LoadStrikeResponse {
-    static ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply;
-    static ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static Ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply;
-    static Ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static okWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static OkWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply;
-    static fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static Fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply;
-    static Fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static failWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
-    static FailWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply;
+    static ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static Ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply;
+    static Ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static okWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static OkWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply;
+    static fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static Fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply;
+    static Fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static failWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply<TPayload>;
+    static FailWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeReply<TPayload>;
 }
 export declare class LoadStrikeStep {
-    static run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeStepReply<TPayload>> | LoadStrikeStepReply<TPayload>): Promise<LoadStrikeStepReply<TPayload>>;
-    static Run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeStepReply<TPayload>> | LoadStrikeStepReply<TPayload>): Promise<LoadStrikeStepReply<TPayload>>;
+    static run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeReply<TPayload>> | LoadStrikeReply<TPayload>): Promise<LoadStrikeReply<TPayload>>;
+    static Run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeReply<TPayload>> | LoadStrikeReply<TPayload>): Promise<LoadStrikeReply<TPayload>>;
 }
 export declare class LoadStrikeSimulation {
     static inject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
@@ -771,7 +842,6 @@ export interface LoadStrikeRunContext {
     ClusterId?: string;
     CoordinatorTargetScenarios?: string[];
     RunnerKey?: string;
-    LicenseValidationServerUrl?: string;
     LicenseValidationTimeoutSeconds?: number;
     MinimumLogLevel?: LoadStrikeLogLevel | string;
     LoggerConfig?: () => LoadStrikeLogger;
@@ -781,13 +851,12 @@ export interface LoadStrikeRunContext {
     ReportFileName?: string;
     ReportFolderPath?: string;
     ReportFormats?: LoadStrikeReportFormat[];
-    ReportFinalizer?: (reportData: LoadStrikeReportData) => LoadStrikeReportData;
-    DetailedReportFinalizer?: (result: LoadStrikeRunResult) => LoadStrikeRunResult;
     ReportingIntervalSeconds?: number;
     ReportingSinks?: ILoadStrikeReportingSink[];
     SinkRetryCount?: number;
     SinkRetryBackoffMs?: number;
     RuntimePolicies?: LoadStrikeRuntimePolicy[];
+    RuntimePolicyErrorMode?: LoadStrikeRuntimePolicyErrorMode | string;
     ScenarioCompletionTimeoutSeconds?: number;
     ClusterCommandTimeoutSeconds?: number;
     RestartIterationMaxAttempts?: number;
@@ -808,18 +877,12 @@ export declare class LoadStrikeContext {
     toObject(): LoadStrikeRunContext;
     buildContext(): LoadStrikeContext;
     BuildContext(): LoadStrikeContext;
-    run(): Promise<LoadStrikeNodeStats>;
-    run(args: string[]): Promise<LoadStrikeNodeStats>;
-    run(...args: string[]): Promise<LoadStrikeNodeStats>;
-    runDetailed(): Promise<LoadStrikeRunResult>;
-    runDetailed(args: string[]): Promise<LoadStrikeRunResult>;
-    runDetailed(...args: string[]): Promise<LoadStrikeRunResult>;
-    Run(): Promise<LoadStrikeNodeStats>;
-    Run(args: string[]): Promise<LoadStrikeNodeStats>;
-    Run(...args: string[]): Promise<LoadStrikeNodeStats>;
-    RunDetailed(): Promise<LoadStrikeRunResult>;
-    RunDetailed(args: string[]): Promise<LoadStrikeRunResult>;
-    RunDetailed(...args: string[]): Promise<LoadStrikeRunResult>;
+    run(): Promise<LoadStrikeRunResult>;
+    run(args: string[]): Promise<LoadStrikeRunResult>;
+    run(...args: string[]): Promise<LoadStrikeRunResult>;
+    Run(): Promise<LoadStrikeRunResult>;
+    Run(args: string[]): Promise<LoadStrikeRunResult>;
+    Run(...args: string[]): Promise<LoadStrikeRunResult>;
     toRunnerOptions(): LoadStrikeRunnerOptions;
     configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeContext;
     configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
@@ -829,8 +892,6 @@ export declare class LoadStrikeContext {
     Configure(options: LoadStrikeRunnerOptions): LoadStrikeContext;
     configureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
     ConfigureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
-    buildLicenseValidationPayload(): LoadStrikeRunRequest;
-    BuildLicenseValidationPayload(): LoadStrikeRunRequest;
     displayConsoleMetrics(enable: boolean): LoadStrikeContext;
     DisplayConsoleMetrics(enable: boolean): LoadStrikeContext;
     enableLocalDevCluster(enable: boolean): LoadStrikeContext;
@@ -851,8 +912,6 @@ export declare class LoadStrikeContext {
     WithCoordinatorTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
     withRunnerKey(runnerKey: string): LoadStrikeContext;
     WithRunnerKey(runnerKey: string): LoadStrikeContext;
-    withLicenseValidationServerUrl(serverUrl: string): LoadStrikeContext;
-    WithLicenseValidationServerUrl(serverUrl: string): LoadStrikeContext;
     withLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
     WithLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
     withNodeType(nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
@@ -867,14 +926,14 @@ export declare class LoadStrikeContext {
     WithReportFolder(reportFolderPath: string): LoadStrikeContext;
     withReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
     WithReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
-    withReportFinalizer(handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
-    WithReportFinalizer(handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
-    withDetailedReportFinalizer(handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
-    WithDetailedReportFinalizer(handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
     withReportingInterval(intervalSeconds: number): LoadStrikeContext;
     WithReportingInterval(intervalSeconds: number): LoadStrikeContext;
     withReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
     WithReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    withRuntimePolicies(...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
+    WithRuntimePolicies(...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
+    withRuntimePolicyErrorMode(mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
+    WithRuntimePolicyErrorMode(mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
     withWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
     WithWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
     withMinimumLogLevel(minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
@@ -912,15 +971,18 @@ export declare class LoadStrikeScenario {
     private readonly warmUpDurationSeconds;
     private readonly weight;
     private readonly restartIterationOnFail;
-    private readonly licenseFeatures;
     private constructor();
     static create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
     static Create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
+    static createAsync(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
+    static CreateAsync(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
     static empty(name: string): LoadStrikeScenario;
     static Empty(name: string): LoadStrikeScenario;
     get Name(): string;
     withInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    withInitAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
     withClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    withCleanAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
     withMaxFailCount(maxFailCount: number): LoadStrikeScenario;
     withoutWarmUp(): LoadStrikeScenario;
     withWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
@@ -929,7 +991,6 @@ export declare class LoadStrikeScenario {
     withCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
     withLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
     withThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
-    withLicenseFeatures(...features: string[]): LoadStrikeScenario;
     getSimulations(): Array<Record<string, unknown>>;
     getThresholds(): Array<Record<string, unknown>>;
     getTrackingConfiguration(): Record<string, unknown> | undefined;
@@ -938,18 +999,18 @@ export declare class LoadStrikeScenario {
     getWarmUpDurationSeconds(): number;
     getWeight(): number;
     shouldRestartIterationOnFail(): boolean;
-    getLicenseFeatures(): string[];
     invokeInit(context: LoadStrikeScenarioInitContext): Promise<void>;
     invokeClean(context: LoadStrikeScenarioInitContext): Promise<void>;
     execute(context: LoadStrikeScenarioContext): Promise<LoadStrikeStepReply>;
     WithCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
     WithInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    WithInitAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
     WithClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    WithCleanAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
     WithLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
     WithMaxFailCount(maxFailCount: number): LoadStrikeScenario;
     WithoutWarmUp(): LoadStrikeScenario;
     WithRestartIterationOnFail(shouldRestart: boolean): LoadStrikeScenario;
-    WithLicenseFeatures(...features: string[]): LoadStrikeScenario;
     WithThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
     WithWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
     WithWeight(weight: number): LoadStrikeScenario;
@@ -967,14 +1028,13 @@ export declare class LoadStrikeRunner {
     static EnableLocalDevCluster(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
     static LoadConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
     static LoadInfraConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
-    static Run(context: LoadStrikeContext, ...args: string[]): Promise<LoadStrikeNodeStats>;
+    static Run(context: LoadStrikeContext, ...args: string[]): Promise<LoadStrikeRunResult>;
     static WithAgentGroup(context: LoadStrikeContext, agentGroup: string): LoadStrikeContext;
     static WithAgentsCount(context: LoadStrikeContext, agentsCount: number): LoadStrikeContext;
     static WithAgentTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
     static WithClusterId(context: LoadStrikeContext, clusterId: string): LoadStrikeContext;
     static WithCoordinatorTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
     static WithRunnerKey(context: LoadStrikeContext, runnerKey: string): LoadStrikeContext;
-    static WithLicenseValidationServerUrl(context: LoadStrikeContext, serverUrl: string): LoadStrikeContext;
     static WithLicenseValidationTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
     static WithLoggerConfig(context: LoadStrikeContext, loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
     static WithMinimumLogLevel(context: LoadStrikeContext, minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
@@ -982,12 +1042,12 @@ export declare class LoadStrikeRunner {
     static WithNodeType(context: LoadStrikeContext, nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
     static WithoutReports(context: LoadStrikeContext): LoadStrikeContext;
     static WithReportFileName(context: LoadStrikeContext, reportFileName: string): LoadStrikeContext;
-    static WithReportFinalizer(context: LoadStrikeContext, handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
-    static WithDetailedReportFinalizer(context: LoadStrikeContext, handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
     static WithReportFolder(context: LoadStrikeContext, reportFolderPath: string): LoadStrikeContext;
     static WithReportFormats(context: LoadStrikeContext, ...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
     static WithReportingInterval(context: LoadStrikeContext, intervalSeconds: number): LoadStrikeContext;
     static WithReportingSinks(context: LoadStrikeContext, ...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    static WithRuntimePolicies(context: LoadStrikeContext, ...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
+    static WithRuntimePolicyErrorMode(context: LoadStrikeContext, mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
     static WithScenarioCompletionTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
     static WithClusterCommandTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
     static WithRestartIterationMaxAttempts(context: LoadStrikeContext, attempts: number): LoadStrikeContext;
@@ -1024,10 +1084,8 @@ export declare class LoadStrikeRunner {
     WithoutReports(): LoadStrikeRunner;
     buildContext(): LoadStrikeContext;
     BuildContext(): LoadStrikeContext;
-    run(args?: string[]): Promise<LoadStrikeNodeStats>;
-    runDetailed(args?: string[]): Promise<LoadStrikeRunResult>;
-    Run(args?: string[]): Promise<LoadStrikeNodeStats>;
-    RunDetailed(args?: string[]): Promise<LoadStrikeRunResult>;
+    run(args?: string[]): Promise<LoadStrikeRunResult>;
+    Run(args?: string[]): Promise<LoadStrikeRunResult>;
     private filterScenariosWithPolicies;
     private runClusterChildNode;
     private runCoordinatorWithLocalAgents;
@@ -1036,17 +1094,346 @@ export declare class LoadStrikeRunner {
     private stopPlugins;
     private executeScenarioInvocation;
     private selectScenarios;
-    private buildLicenseValidationPayload;
     private initializeSinks;
     private startSinks;
     private emitRealtimeStats;
-    private emitFinalStats;
     private stopSinks;
     private emitRunResult;
     private invokeSinkAction;
     private invokeBeforeScenario;
     private invokeAfterScenario;
+    private invokeBeforeStep;
+    private invokeAfterStep;
+    private invokePolicyCallback;
+    private buildRuntimePolicyError;
     private writeReports;
     private collectPluginData;
 }
+declare function hasPluginRows(value: LoadStrikePluginData): boolean;
+declare function combineAbortSignals(...signals: AbortSignal[]): AbortSignal;
+declare function delayWithAbort(durationMs: number, signal: AbortSignal): Promise<void>;
+declare function createRuntimeRandom(): LoadStrikeRandom;
+declare function parseAliasDate(value: string | Date | null | undefined): Date | undefined;
+declare function attachScenarioStatsAliases(scenario: Omit<LoadStrikeScenarioStats, "FindStepStats" | "GetStepStats"> & Partial<Pick<LoadStrikeScenarioStats, "FindStepStats" | "GetStepStats">>): LoadStrikeScenarioStats;
+declare function attachNodeStatsAliases(stats: Omit<LoadStrikeNodeStats, "FindScenarioStats" | "GetScenarioStats"> & Partial<Pick<LoadStrikeNodeStats, "FindScenarioStats" | "GetScenarioStats">>): LoadStrikeNodeStats;
+declare function attachRunResultAliases(result: LoadStrikeRunResult): LoadStrikeRunResult;
+declare function normalizeReplyArguments(sizeBytesOrMessage: number | string, messageOrSizeBytes: string | number, customLatencyMs?: number): {
+    sizeBytes: number;
+    message: string;
+    latencyMs: number | undefined;
+};
+declare function normalizeFailureArguments(messageOrSizeBytes: string | number, sizeBytesOrMessage: number | string, customLatencyMs?: number): {
+    sizeBytes: number;
+    message: string;
+    latencyMs: number | undefined;
+};
+interface ThresholdEvaluationSummary {
+    failedCount: number;
+    results: LoadStrikeThresholdResult[];
+}
+declare function evaluateThresholdsForScenarios(scenarios: LoadStrikeScenario[], stats: Map<string, LoadStrikeScenarioRuntime>, stepStats: Map<string, LoadStrikeStepRuntime>, durationsMs: Map<string, number>, runDurationMs: number, metricsByName: Record<string, number>): Promise<ThresholdEvaluationSummary>;
+declare function resolveThresholdActualValue(args: {
+    scope: "scenario" | "step" | "metric";
+    field: string;
+    stepName: string;
+    scenarioName: string;
+    scenarioStats: LoadStrikeScenarioRuntime;
+    stepStats: Map<string, LoadStrikeStepRuntime>;
+    totalRequestCount: number;
+    totalOkCount: number;
+    totalFailCount: number;
+    runDurationMs: number;
+    metricsByName: Record<string, number>;
+}): number;
+declare function isComparisonFailed(actual: number, operator: string, expected: number): boolean;
+declare function normalizeThresholdScope(value: string): "scenario" | "step" | "metric";
+declare function buildThresholdCheckExpression(scope: "scenario" | "step" | "metric", stepName: string, field: string): string;
+declare function detailedToNodeStats(result: LoadStrikeRunResult, metricStats?: LoadStrikeMetricStats): LoadStrikeNodeStats;
+declare function resolveClusterExecutionMode(options: LoadStrikeRunnerOptions): "single" | "local-coordinator" | "nats-coordinator" | "nats-agent";
+declare function buildEmptyNodeStats(args: {
+    startedUtc: string;
+    completedUtc: string;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+}): LoadStrikeNodeStats;
+declare function toDetailedRunResultFromNodeStats(result: LoadStrikeNodeStats, startedUtc: string, sinkErrors: LoadStrikeSinkError[], policyErrors?: LoadStrikeRuntimePolicyError[]): LoadStrikeRunResult;
+declare function clusterNodeResultToNodeStats(result: ClusterNodeResult, testInfo: LoadStrikeTestInfo, fallbackNodeInfo: LoadStrikeNodeInfo): LoadStrikeNodeStats;
+declare function aggregateNodeStats(testInfo: LoadStrikeTestInfo, coordinatorNodeInfo: LoadStrikeNodeInfo, nodes: LoadStrikeNodeStats[]): LoadStrikeNodeStats;
+declare function buildMeasurementPlaceholder(count: number, allCount: number, durationMs: number): LoadStrikeMeasurementStats;
+declare function executeTrackedScenarioInvocation(tracking: Record<string, unknown>, context: InternalScenarioContext, originalRun: () => Promise<LoadStrikeStepReply>, operation: "WarmUp" | "Bombing"): Promise<LoadStrikeStepReply>;
+interface ManagedTrackingOutcome {
+    status: "matched" | "timeout" | "unmatched_destination" | "source_error";
+    trackingId?: string;
+    eventId?: string;
+    latencyMs?: number;
+    message?: string;
+}
+declare class ManagedScenarioTrackingRuntime {
+    private readonly tracking;
+    private readonly sourceEndpoint;
+    private readonly destinationEndpoint;
+    private readonly sourceAdapter;
+    private readonly destinationAdapter;
+    private readonly correlationStore;
+    private readonly correlationRuntime;
+    private readonly runMode;
+    private readonly sourceOnlyMode;
+    private readonly executeOriginalScenarioRun;
+    private readonly correlationTimeoutMs;
+    private readonly timeoutSweepIntervalMs;
+    private readonly timeoutBatchSize;
+    private readonly timeoutCountsAsFailure;
+    private readonly scenarioName;
+    private readonly sourceEndpointName;
+    private readonly destinationEndpointName;
+    private readonly gatherByFieldExpression?;
+    private readonly pendingEventIds;
+    private readonly pendingSourceTimestamps;
+    private readonly waiters;
+    private readonly outcomeQueue;
+    private readonly outcomeWaiters;
+    private started;
+    private shutdown;
+    private destinationLoop;
+    private sourceLoop;
+    private timeoutLoop;
+    constructor(tracking: Record<string, unknown>, initContext: LoadStrikeScenarioInitContext, runNamespace: string);
+    start(): Promise<void>;
+    executeIteration(context: InternalScenarioContext, originalRun: () => Promise<LoadStrikeStepReply>, _operation: "WarmUp" | "Bombing"): Promise<LoadStrikeStepReply>;
+    dispose(): Promise<void>;
+    private executeSourceOnly;
+    private consumeSourceLoop;
+    private consumeDestinationLoop;
+    private runTimeoutSweepLoop;
+    private buildSourceErrorReply;
+    private toResponse;
+    private pushPendingValue;
+    private shiftPendingValue;
+    private pushPendingWaiter;
+    private removePendingWaiter;
+    private resolveTrackingWaiter;
+    private pushOutcome;
+    private waitForOutcome;
+    private rejectOutstandingWaiters;
+}
+declare function buildTrackingLeaseKey(sessionId: string, scenarioName: string, tracking: Record<string, unknown>): string;
+declare function waitForTrackingOutcome(promise: Promise<ManagedTrackingOutcome>, timeoutMs: number, signal: AbortSignal): Promise<ManagedTrackingOutcome | null>;
+declare function validateRuntimeTrackingConfiguration(tracking: Record<string, unknown>, sourceEndpoint: EndpointDefinition, destinationEndpoint: EndpointDefinition | null): void;
+declare function validateRuntimeRedisCorrelationStoreConfiguration(tracking: Record<string, unknown>): void;
+declare function normalizeRuntimeHttpTrackingPayloadSource(value: string | undefined): "Request" | "Response" | undefined;
+declare function inferRuntimeLegacyHttpResponseSource(value: string | undefined): "ResponseBody" | "ResponseHeaders" | "ResponseStatusCode" | undefined;
+declare function mapRuntimeCorrelationStore(tracking: Record<string, unknown>, runNamespace: string): RedisCorrelationStore | null;
+declare function readRuntimeRedisCorrelationStoreOptions(redisSpec: Record<string, unknown>): RedisCorrelationStoreOptions;
+declare function buildTrackingRunNamespace(sessionId: string, scenarioName: string, sourceName: string, destinationName?: string | null): string;
+declare function sanitizeTrackingNamespacePart(value: string): string;
+declare function produceOrConsumeTrackingPayload(adapter: EndpointAdapter, endpoint: EndpointDefinition, runMode: string, index: number): Promise<TrackingPayload | null>;
+declare function mapRuntimeTrackingEndpointSpec(spec: Record<string, unknown>): EndpointDefinition;
+declare function normalizeRuntimeTrackingPayload(payload: TrackingPayload | null, endpoint: EndpointDefinition, index: number): TrackingPayload;
+declare function readRuntimeTrackingId(payload: TrackingPayload, selector: string): string | null;
+declare function runtimeParseBodyAsObject(body: unknown): Record<string, unknown> | null;
+declare function setRuntimeJsonPathValue(body: unknown, path: string, value: string): unknown;
+declare function pickOptionalTrackingSelectorString(source: Record<string, unknown>, key: string, altKey: string): string | undefined;
+declare function pickTrackingNumber(source: Record<string, unknown>, keys: string[], fallback: number): number;
+declare function toTrackingStringMap(value: unknown): Record<string, string>;
+declare function normalizeTrackingRunMode(value: string): string;
+declare function normalizeMetricValue(value: unknown): LoadStrikeMetricValue | null;
+declare function computeScenarioRequestCount(scenario: Record<string, unknown>, weight?: number): number;
+declare function computeWarmUpIterations(scenario: LoadStrikeScenario, bombingIterations: number): number;
+declare function createLogger(loggerConfig?: (() => LoadStrikeLogger) | undefined, minimumLogLevel?: LoadStrikeLogLevel | string | undefined): LoadStrikeLogger;
+declare function logLevelOrder(level: string | undefined): number;
+declare function formatUtcReportTimestamp(value: Date): string;
+declare function sanitizeReportFileName(value: string): string;
+declare function loadJsonObject(path: string): Record<string, unknown>;
+declare function asRecord(value: unknown): Record<string, unknown>;
+declare function findCaseInsensitiveKey(record: Record<string, unknown>, key: string): string | undefined;
+declare function tryReadConfigValue(record: Record<string, unknown>, path: string): unknown;
+declare function stripCaseInsensitivePrefix(value: string, prefix: string): string | undefined;
+declare function normalizeCliOverrideKey(key: string): string;
+declare function toBoolean(value: unknown, fallback: boolean): boolean;
+declare function parseStrictBooleanToken(value: unknown): boolean | null;
+declare function parseNodeTypeToken(value: unknown): LoadStrikeNodeType;
+declare function tryParseNodeTypeToken(value: unknown): LoadStrikeNodeType | null;
+declare function parseMinimumLogLevelToken(value: unknown): string;
+declare function tryParseMinimumLogLevelToken(value: unknown): string | null;
+declare function normalizeStringArray(value: unknown): string[];
+declare function normalizeOptionalStringArray(value: unknown): string[] | undefined;
+declare function normalizeReportFormats(value: unknown): Array<"txt" | "csv" | "md" | "html">;
+declare function normalizeOptionalReportFormats(value: unknown): Array<"txt" | "csv" | "md" | "html"> | undefined;
+declare function assertNoDisableLicenseEnforcementOption(value: unknown, source: string): void;
+declare function normalizeRunContextCollectionShapes(values: LoadStrikeRunContext): LoadStrikeRunContext;
+declare function normalizeRunnerOptionCollectionShapes(options: LoadStrikeRunnerOptions): LoadStrikeRunnerOptions;
+declare function extractContextOverridesFromConfig(config: Record<string, unknown>): Partial<LoadStrikeRunContext>;
+declare function extractContextOverridesFromArgs(args: string[]): Partial<LoadStrikeRunContext>;
+declare function normalizeRunArgsInput(argsOrSingleArray: Array<string | string[]>): string[];
+declare function toRunContext(options: LoadStrikeRunnerOptions): LoadStrikeRunContext;
+declare function requireNonEmpty(value: string, message: string): string;
+declare function mergeDefinedRecord<T extends object>(base: T, patch: Partial<T>): T;
+declare function validateRegisteredScenarios(scenarios: LoadStrikeScenario[]): void;
+declare function looksLikeRunContext(value: unknown): value is LoadStrikeRunContext;
+declare function validateScenarioNames(values: string[]): string[];
+declare function toInt(value: unknown): number;
+declare function toNullableInt(value: unknown): number | undefined;
+declare function tryParseDotnetDurationMs(value: unknown): number | undefined;
+declare function toNumber(value: unknown): number;
+declare function resolveSinkInit(sink: LoadStrikeReportingSink): ((context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>) => Promise<void> | void) | undefined;
+declare function resolveSinkStart(sink: LoadStrikeReportingSink): ((session: LoadStrikeSessionStartInfo) => Promise<void> | void) | undefined;
+declare function resolveSinkSaveRealtimeStats(sink: LoadStrikeReportingSink): ((scenarioStats: LoadStrikeScenarioStats[]) => Promise<void> | void) | undefined;
+declare function resolveSinkSaveRealtimeMetrics(sink: LoadStrikeReportingSink): ((metrics: LoadStrikeMetricStats) => Promise<void> | void) | undefined;
+declare function resolveSinkSaveRunResult(sink: LoadStrikeReportingSink): ((result: LoadStrikeRunResult) => Promise<void> | void) | undefined;
+declare function resolveSinkStop(sink: LoadStrikeReportingSink): (() => Promise<void> | void) | undefined;
+declare function resolveSinkDispose(sink: LoadStrikeReportingSink): (() => Promise<void> | void) | undefined;
+interface CrossPlatformFailedResponseRow {
+    occurredUtc: string;
+    scenarioName: string;
+    sourceEndpoint: string;
+    destinationEndpoint: string;
+    runMode: string;
+    statusCode: string;
+    trackingId?: string;
+    eventId?: string;
+    sourceTimestampUtc?: string;
+    destinationTimestampUtc?: string;
+    latencyMs?: number;
+    message?: string;
+}
+interface CrossPlatformCorrelationRow extends CrossPlatformFailedResponseRow {
+    isSuccess: boolean;
+    isFailure: boolean;
+    gatherByField?: string;
+    gatherByValue?: string;
+}
+declare function resetCrossPlatformReportRegistries(): void;
+declare function addFailedResponseRow(row: CrossPlatformFailedResponseRow): void;
+declare function addCorrelationRow(row: CrossPlatformCorrelationRow): void;
+declare function resolveWorkerPlugins(customPlugins: LoadStrikeWorkerPlugin[]): LoadStrikeWorkerPlugin[];
+declare function createBuiltInWorkerPlugins(): LoadStrikeWorkerPlugin[];
+declare function buildGroupedCorrelationRows(rows: CrossPlatformCorrelationRow[]): Array<Record<string, unknown>>;
+declare function percentile(orderedValues: number[], percentileValue: number): number;
+declare function formatOptionalLatency(value: number | undefined): string;
+declare function normalizePluginData(pluginName: string, value: LoadStrikePluginData | null): LoadStrikePluginData;
+declare function withLifecycleErrors(value: LoadStrikePluginData, pluginName: string, lifecycleErrors: Map<string, string[]>): LoadStrikePluginData;
+declare function recordPluginLifecycleError(errors: Map<string, string[]>, pluginName: string, phase: "init" | "start" | "stop" | "dispose", error: unknown): void;
+declare function buildRichHtmlReport(result: LoadStrikeRunResult): string;
+declare function resolveSinkName(sink: LoadStrikeReportingSink, index: number): string;
+declare function validateNamedReportingSinks(sinks: LoadStrikeReportingSink[]): void;
+declare function readConfiguredSinkName(sink: LoadStrikeReportingSink): string;
+export declare const __loadstrikeTestExports: {
+    LoadStrikeContext: typeof LoadStrikeContext;
+    LoadStrikeCounter: typeof LoadStrikeCounter;
+    LoadStrikeGauge: typeof LoadStrikeGauge;
+    LoadStrikeMetric: typeof LoadStrikeMetric;
+    LoadStrikeResponse: typeof LoadStrikeResponse;
+    LoadStrikeRunner: typeof LoadStrikeRunner;
+    LoadStrikeScenario: typeof LoadStrikeScenario;
+    LoadStrikeSimulation: typeof LoadStrikeSimulation;
+    LoadStrikeStep: typeof LoadStrikeStep;
+    ManagedScenarioTrackingRuntime: typeof ManagedScenarioTrackingRuntime;
+    ScenarioStatsAccumulator: typeof ScenarioStatsAccumulator;
+    StepStatsAccumulator: typeof StepStatsAccumulator;
+    TrackingFieldSelector: typeof TrackingFieldSelector;
+    addCorrelationRow: typeof addCorrelationRow;
+    addFailedResponseRow: typeof addFailedResponseRow;
+    aggregateNodeStats: typeof aggregateNodeStats;
+    asRecord: typeof asRecord;
+    assertNoDisableLicenseEnforcementOption: typeof assertNoDisableLicenseEnforcementOption;
+    buildEmptyNodeStats: typeof buildEmptyNodeStats;
+    buildGroupedCorrelationRows: typeof buildGroupedCorrelationRows;
+    buildMeasurementPlaceholder: typeof buildMeasurementPlaceholder;
+    buildRichHtmlReport: typeof buildRichHtmlReport;
+    buildThresholdCheckExpression: typeof buildThresholdCheckExpression;
+    buildTrackingLeaseKey: typeof buildTrackingLeaseKey;
+    buildTrackingRunNamespace: typeof buildTrackingRunNamespace;
+    clusterNodeResultToNodeStats: typeof clusterNodeResultToNodeStats;
+    combineAbortSignals: typeof combineAbortSignals;
+    computeScenarioRequestCount: typeof computeScenarioRequestCount;
+    computeWarmUpIterations: typeof computeWarmUpIterations;
+    createBuiltInWorkerPlugins: typeof createBuiltInWorkerPlugins;
+    createLogger: typeof createLogger;
+    createRuntimeRandom: typeof createRuntimeRandom;
+    delayWithAbort: typeof delayWithAbort;
+    detailedToNodeStats: typeof detailedToNodeStats;
+    evaluateThresholdsForScenarios: typeof evaluateThresholdsForScenarios;
+    executeTrackedScenarioInvocation: typeof executeTrackedScenarioInvocation;
+    extractContextOverridesFromArgs: typeof extractContextOverridesFromArgs;
+    extractContextOverridesFromConfig: typeof extractContextOverridesFromConfig;
+    findCaseInsensitiveKey: typeof findCaseInsensitiveKey;
+    formatOptionalLatency: typeof formatOptionalLatency;
+    formatUtcReportTimestamp: typeof formatUtcReportTimestamp;
+    hasPluginRows: typeof hasPluginRows;
+    inferRuntimeLegacyHttpResponseSource: typeof inferRuntimeLegacyHttpResponseSource;
+    isComparisonFailed: typeof isComparisonFailed;
+    loadJsonObject: typeof loadJsonObject;
+    logLevelOrder: typeof logLevelOrder;
+    looksLikeRunContext: typeof looksLikeRunContext;
+    mapRuntimeCorrelationStore: typeof mapRuntimeCorrelationStore;
+    mapRuntimeTrackingEndpointSpec: typeof mapRuntimeTrackingEndpointSpec;
+    mergeDefinedRecord: typeof mergeDefinedRecord;
+    normalizeCliOverrideKey: typeof normalizeCliOverrideKey;
+    normalizeMetricValue: typeof normalizeMetricValue;
+    normalizeOptionalReportFormats: typeof normalizeOptionalReportFormats;
+    normalizeOptionalStringArray: typeof normalizeOptionalStringArray;
+    normalizeReplyArguments: typeof normalizeReplyArguments;
+    normalizePluginData: typeof normalizePluginData;
+    normalizeReportFormats: typeof normalizeReportFormats;
+    normalizeRunArgsInput: typeof normalizeRunArgsInput;
+    normalizeRunContextCollectionShapes: typeof normalizeRunContextCollectionShapes;
+    normalizeRunnerOptionCollectionShapes: typeof normalizeRunnerOptionCollectionShapes;
+    normalizeRuntimeHttpTrackingPayloadSource: typeof normalizeRuntimeHttpTrackingPayloadSource;
+    normalizeRuntimeTrackingPayload: typeof normalizeRuntimeTrackingPayload;
+    normalizeStringArray: typeof normalizeStringArray;
+    normalizeFailureArguments: typeof normalizeFailureArguments;
+    normalizeTrackingRunMode: typeof normalizeTrackingRunMode;
+    normalizeThresholdScope: typeof normalizeThresholdScope;
+    parseAliasDate: typeof parseAliasDate;
+    parseMinimumLogLevelToken: typeof parseMinimumLogLevelToken;
+    parseNodeTypeToken: typeof parseNodeTypeToken;
+    parseStrictBooleanToken: typeof parseStrictBooleanToken;
+    percentile: typeof percentile;
+    pickOptionalTrackingSelectorString: typeof pickOptionalTrackingSelectorString;
+    pickTrackingNumber: typeof pickTrackingNumber;
+    produceOrConsumeTrackingPayload: typeof produceOrConsumeTrackingPayload;
+    readConfiguredSinkName: typeof readConfiguredSinkName;
+    readRuntimeRedisCorrelationStoreOptions: typeof readRuntimeRedisCorrelationStoreOptions;
+    readRuntimeTrackingId: typeof readRuntimeTrackingId;
+    recordPluginLifecycleError: typeof recordPluginLifecycleError;
+    requireNonEmpty: typeof requireNonEmpty;
+    attachScenarioStatsAliases: typeof attachScenarioStatsAliases;
+    attachNodeStatsAliases: typeof attachNodeStatsAliases;
+    attachRunResultAliases: typeof attachRunResultAliases;
+    resolveClusterExecutionMode: typeof resolveClusterExecutionMode;
+    resolveThresholdActualValue: typeof resolveThresholdActualValue;
+    resetCrossPlatformReportRegistries: typeof resetCrossPlatformReportRegistries;
+    resolveSinkDispose: typeof resolveSinkDispose;
+    resolveSinkInit: typeof resolveSinkInit;
+    resolveSinkName: typeof resolveSinkName;
+    resolveSinkSaveRealtimeMetrics: typeof resolveSinkSaveRealtimeMetrics;
+    resolveSinkSaveRealtimeStats: typeof resolveSinkSaveRealtimeStats;
+    resolveSinkSaveRunResult: typeof resolveSinkSaveRunResult;
+    resolveSinkStart: typeof resolveSinkStart;
+    resolveSinkStop: typeof resolveSinkStop;
+    resolveWorkerPlugins: typeof resolveWorkerPlugins;
+    runtimeParseBodyAsObject: typeof runtimeParseBodyAsObject;
+    sanitizeReportFileName: typeof sanitizeReportFileName;
+    sanitizeTrackingNamespacePart: typeof sanitizeTrackingNamespacePart;
+    setRuntimeJsonPathValue: typeof setRuntimeJsonPathValue;
+    stripCaseInsensitivePrefix: typeof stripCaseInsensitivePrefix;
+    toBoolean: typeof toBoolean;
+    toDetailedRunResultFromNodeStats: typeof toDetailedRunResultFromNodeStats;
+    toInt: typeof toInt;
+    toNullableInt: typeof toNullableInt;
+    toNumber: typeof toNumber;
+    toRunContext: typeof toRunContext;
+    toTrackingStringMap: typeof toTrackingStringMap;
+    tryParseDotnetDurationMs: typeof tryParseDotnetDurationMs;
+    tryParseMinimumLogLevelToken: typeof tryParseMinimumLogLevelToken;
+    tryParseNodeTypeToken: typeof tryParseNodeTypeToken;
+    tryReadConfigValue: typeof tryReadConfigValue;
+    validateNamedReportingSinks: typeof validateNamedReportingSinks;
+    validateRegisteredScenarios: typeof validateRegisteredScenarios;
+    validateRuntimeRedisCorrelationStoreConfiguration: typeof validateRuntimeRedisCorrelationStoreConfiguration;
+    validateRuntimeTrackingConfiguration: typeof validateRuntimeTrackingConfiguration;
+    validateScenarioNames: typeof validateScenarioNames;
+    waitForTrackingOutcome: typeof waitForTrackingOutcome;
+    withLifecycleErrors: typeof withLifecycleErrors;
+};
 export {};