@loadstrike/loadstrike-sdk 1.0.10101 → 1.0.10801

package/dist/esm/runtime.js

@@ -1,8 +1,8 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import os from "node:os";
 import { resolve } from "node:path";
-import { DEFAULT_LICENSING_API_BASE_URL, LoadStrikeLocalClient } from "./local.js";
+import { LoadStrikeLocalClient } from "./local.js";
 import { DistributedClusterAgent, DistributedClusterCoordinator } from "./cluster.js";
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector } from "./correlation.js";
 import { EndpointAdapterFactory } from "./transports.js";
@@ -85,42 +85,6 @@ export class LoadStrikePluginData {
         return this.tables;
     }
 }
-export class LoadStrikeReportData {
-    constructor(scenarioStats = []) {
-        if (!Array.isArray(scenarioStats) || scenarioStats.some((value) => !value || typeof value !== "object")) {
-            throw new TypeError("Scenario stats cannot contain null values.");
-        }
-        this.scenarioStats = scenarioStats.map((value, index) => attachScenarioStatsAliases(normalizeScenarioStatsValue(value, index)));
-    }
-    static create(...scenarioStats) {
-        return new LoadStrikeReportData(scenarioStats);
-    }
-    static Create(...scenarioStats) {
-        return LoadStrikeReportData.create(...scenarioStats);
-    }
-    static fromRunResult(result) {
-        return new LoadStrikeReportData((result?.scenarioStats ?? result?.ScenarioStats ?? []));
-    }
-    findScenarioStats(scenarioName) {
-        return this.scenarioStats.find((value) => value.scenarioName === scenarioName);
-    }
-    getScenarioStats(scenarioName) {
-        const value = this.findScenarioStats(scenarioName);
-        if (!value) {
-            throw new Error(`Scenario stats not found: ${scenarioName}`);
-        }
-        return value;
-    }
-    FindScenarioStats(scenarioName) {
-        return this.findScenarioStats(scenarioName);
-    }
-    GetScenarioStats(scenarioName) {
-        return this.getScenarioStats(scenarioName);
-    }
-    get ScenarioStats() {
-        return this.scenarioStats;
-    }
-}
 class MeasurementAccumulator {
     constructor() {
         this.count = 0;
@@ -731,28 +695,10 @@ export class LoadStrikeContext {
             .configureContext(this);
         return runner.run();
     }
-    async runDetailed(...argsOrSingleArray) {
-        const args = normalizeRunArgsInput(argsOrSingleArray);
-        if (!this.registeredScenarios.length) {
-            throw new Error("At least one scenario must be added before running the context.");
-        }
-        if (args.length) {
-            this.mergeValues(extractContextOverridesFromArgs(args), args);
-        }
-        const runner = LoadStrikeRunner
-            .create()
-            .addScenarios(...this.registeredScenarios)
-            .configureContext(this);
-        return runner.runDetailed();
-    }
     async Run(...argsOrSingleArray) {
         const args = normalizeRunArgsInput(argsOrSingleArray);
         return this.run(args);
     }
-    async RunDetailed(...argsOrSingleArray) {
-        const args = normalizeRunArgsInput(argsOrSingleArray);
-        return this.runDetailed(args);
-    }
     toRunnerOptions() {
         const normalizedValues = normalizeRunContextCollectionShapes(this.values);
         return {
@@ -766,7 +712,6 @@ export class LoadStrikeContext {
             coordinatorTargetScenarios: normalizedValues.CoordinatorTargetScenarios,
             natsServerUrl: normalizedValues.NatsServerUrl,
             runnerKey: normalizedValues.RunnerKey,
-            licenseValidationServerUrl: normalizedValues.LicenseValidationServerUrl,
             licenseValidationTimeoutSeconds: normalizedValues.LicenseValidationTimeoutSeconds,
             configPath: normalizedValues.ConfigPath,
             infraConfigPath: normalizedValues.InfraConfigPath,
@@ -779,8 +724,6 @@ export class LoadStrikeContext {
             reportFileName: normalizedValues.ReportFileName,
             reportFolderPath: normalizedValues.ReportFolderPath,
             reportFormats: normalizedValues.ReportFormats,
-            reportFinalizer: normalizedValues.ReportFinalizer,
-            detailedReportFinalizer: normalizedValues.DetailedReportFinalizer,
             reportingIntervalSeconds: normalizedValues.ReportingIntervalSeconds,
             minimumLogLevel: normalizedValues.MinimumLogLevel,
             loggerConfig: normalizedValues.LoggerConfig,
@@ -788,6 +731,7 @@ export class LoadStrikeContext {
             sinkRetryCount: normalizedValues.SinkRetryCount,
             sinkRetryBackoffMs: normalizedValues.SinkRetryBackoffMs,
             runtimePolicies: normalizedValues.RuntimePolicies,
+            runtimePolicyErrorMode: normalizedRuntimePolicyErrorMode(normalizedValues.RuntimePolicyErrorMode),
             scenarioCompletionTimeoutSeconds: normalizedValues.ScenarioCompletionTimeoutSeconds,
             clusterCommandTimeoutSeconds: normalizedValues.ClusterCommandTimeoutSeconds,
             restartIterationMaxAttempts: normalizedValues.RestartIterationMaxAttempts,
@@ -833,28 +777,6 @@ export class LoadStrikeContext {
     ConfigureContext(context) {
         return this.configureContext(context);
     }
-    buildLicenseValidationPayload() {
-        const scenarios = this.registeredScenarios.map((scenario) => ({
-            Name: scenario.name,
-            MaxFailCount: scenario.getMaxFailCount(),
-            RestartIterationOnFail: scenario.shouldRestartIterationOnFail(),
-            WithoutWarmUp: scenario.isWithoutWarmUp(),
-            WarmUpDurationSeconds: scenario.getWarmUpDurationSeconds(),
-            Weight: scenario.getWeight(),
-            LoadSimulations: [...scenario.getSimulations()],
-            Thresholds: [...scenario.getThresholds()],
-            Tracking: scenario.getTrackingConfiguration() ?? {},
-            LicenseFeatures: scenario.getLicenseFeatures()
-        }));
-        return {
-            Context: this.toObject(),
-            Scenarios: scenarios,
-            RunArgs: [...this.runArgs]
-        };
-    }
-    BuildLicenseValidationPayload() {
-        return this.buildLicenseValidationPayload();
-    }
     displayConsoleMetrics(enable) {
         return this.DisplayConsoleMetrics(enable);
     }
@@ -928,12 +850,6 @@ export class LoadStrikeContext {
     WithRunnerKey(runnerKey) {
         return this.mergeValues({ RunnerKey: requireNonEmpty(runnerKey, "Runner key must be provided.") });
     }
-    withLicenseValidationServerUrl(serverUrl) {
-        return this.WithLicenseValidationServerUrl(serverUrl);
-    }
-    WithLicenseValidationServerUrl(serverUrl) {
-        return this.mergeValues({ LicenseValidationServerUrl: requireNonEmpty(serverUrl, "License validation server URL must be provided.") });
-    }
     withLicenseValidationTimeout(timeoutSeconds) {
         return this.WithLicenseValidationTimeout(timeoutSeconds);
     }
@@ -986,24 +902,6 @@ export class LoadStrikeContext {
         }
         return this.mergeValues({ ReportFormats: normalized });
     }
-    withReportFinalizer(handler) {
-        return this.WithReportFinalizer(handler);
-    }
-    WithReportFinalizer(handler) {
-        if (typeof handler !== "function") {
-            throw new TypeError("Report finalizer must be provided.");
-        }
-        return this.mergeValues({ ReportFinalizer: handler });
-    }
-    withDetailedReportFinalizer(handler) {
-        return this.WithDetailedReportFinalizer(handler);
-    }
-    WithDetailedReportFinalizer(handler) {
-        if (typeof handler !== "function") {
-            throw new TypeError("Detailed report finalizer must be provided.");
-        }
-        return this.mergeValues({ DetailedReportFinalizer: handler });
-    }
     withReportingInterval(intervalSeconds) {
         return this.WithReportingInterval(intervalSeconds);
     }
@@ -1026,6 +924,26 @@ export class LoadStrikeContext {
         validateNamedReportingSinks(sinks);
         return this.mergeValues({ ReportingSinks: sinks });
     }
+    withRuntimePolicies(...policies) {
+        return this.WithRuntimePolicies(...policies);
+    }
+    WithRuntimePolicies(...policies) {
+        if (!policies.length) {
+            throw new Error("At least one runtime policy should be provided.");
+        }
+        if (policies.some((policy) => policy == null)) {
+            throw new Error("Runtime policy collection cannot contain null values.");
+        }
+        return this.mergeValues({ RuntimePolicies: policies });
+    }
+    withRuntimePolicyErrorMode(mode) {
+        return this.WithRuntimePolicyErrorMode(mode);
+    }
+    WithRuntimePolicyErrorMode(mode) {
+        return this.mergeValues({
+            RuntimePolicyErrorMode: normalizedRuntimePolicyErrorMode(mode)
+        });
+    }
     withWorkerPlugins(...plugins) {
         return this.WithWorkerPlugins(...plugins);
     }
@@ -1121,7 +1039,7 @@ export class LoadStrikeContext {
     }
 }
 export class LoadStrikeScenario {
-    constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail, licenseFeatures) {
+    constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail) {
         this.name = name;
         this.runHandler = runHandler;
         this.initHandler = initHandler;
@@ -1134,18 +1052,23 @@ export class LoadStrikeScenario {
         this.warmUpDurationSeconds = warmUpDurationSeconds;
         this.weight = weight;
         this.restartIterationOnFail = restartIterationOnFail;
-        this.licenseFeatures = [...licenseFeatures];
     }
     static create(name, runHandler) {
         const scenarioName = requireNonEmpty(name, "Scenario name must be provided.");
         if (typeof runHandler !== "function") {
             throw new TypeError("Scenario run handler must be provided.");
         }
-        return new LoadStrikeScenario(scenarioName, runHandler, undefined, undefined, [], [], undefined, 0, false, 0, 1, false, []);
+        return new LoadStrikeScenario(scenarioName, runHandler, undefined, undefined, [], [], undefined, 0, false, 0, 1, false);
     }
     static Create(name, runHandler) {
         return LoadStrikeScenario.create(name, runHandler);
     }
+    static createAsync(name, runHandler) {
+        return LoadStrikeScenario.create(name, runHandler);
+    }
+    static CreateAsync(name, runHandler) {
+        return LoadStrikeScenario.createAsync(name, runHandler);
+    }
     static empty(name) {
         return LoadStrikeScenario.create(name, () => LoadStrikeResponse.ok());
     }
@@ -1159,37 +1082,43 @@ export class LoadStrikeScenario {
         if (typeof handler !== "function") {
             throw new TypeError("Init handler must be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, handler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, handler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
+    }
+    withInitAsync(handler) {
+        return this.withInit(handler);
     }
     withClean(handler) {
         if (typeof handler !== "function") {
             throw new TypeError("Clean handler must be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, handler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, handler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
+    }
+    withCleanAsync(handler) {
+        return this.withClean(handler);
     }
     withMaxFailCount(maxFailCount) {
         if (!Number.isFinite(maxFailCount)) {
             throw new RangeError("maxFailCount should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, Math.trunc(maxFailCount), this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, Math.trunc(maxFailCount), this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
     withoutWarmUp() {
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, true, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, true, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
     withWarmUpDuration(durationSeconds) {
         if (!Number.isFinite(durationSeconds)) {
             throw new RangeError("Warmup duration should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, durationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, durationSeconds, this.weight, this.restartIterationOnFail);
     }
     withWeight(weight) {
         if (!Number.isFinite(weight)) {
             throw new RangeError("Weight should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, Math.trunc(weight), this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, Math.trunc(weight), this.restartIterationOnFail);
     }
     withRestartIterationOnFail(shouldRestart) {
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, Boolean(shouldRestart), this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, Boolean(shouldRestart));
     }
     withCrossPlatformTracking(configuration) {
         if (!configuration || typeof configuration !== "object" || Array.isArray(configuration)) {
@@ -1206,25 +1135,19 @@ export class LoadStrikeScenario {
             ? mapRuntimeTrackingEndpointSpec(destinationSpec)
             : null;
         validateRuntimeTrackingConfiguration(copied, sourceEndpoint, destinationEndpoint);
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
     withLoadSimulations(...simulations) {
         if (!simulations.length) {
             throw new Error("At least one load simulation should be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
     withThresholds(...thresholds) {
         if (!thresholds.length) {
             throw new Error("At least one threshold should be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, thresholds.map((threshold) => ({ ...threshold })), this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.licenseFeatures);
-    }
-    withLicenseFeatures(...features) {
-        const normalized = features
-            .map((value) => String(value ?? "").trim())
-            .filter((value) => value.length > 0);
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, [...this.licenseFeatures, ...normalized]);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, thresholds.map((threshold) => ({ ...threshold })), this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
     getSimulations() {
         return this.loadSimulations.map((simulation) => attachLoadSimulationProjection({ ...simulation }));
@@ -1250,9 +1173,6 @@ export class LoadStrikeScenario {
     shouldRestartIterationOnFail() {
         return this.restartIterationOnFail;
     }
-    getLicenseFeatures() {
-        return [...this.licenseFeatures];
-    }
     async invokeInit(context) {
         if (this.initHandler) {
             await this.initHandler(context);
@@ -1281,9 +1201,15 @@ export class LoadStrikeScenario {
     WithInit(handler) {
         return this.withInit(handler);
     }
+    WithInitAsync(handler) {
+        return this.withInitAsync(handler);
+    }
     WithClean(handler) {
         return this.withClean(handler);
     }
+    WithCleanAsync(handler) {
+        return this.withCleanAsync(handler);
+    }
     WithLoadSimulations(...simulations) {
         return this.withLoadSimulations(...simulations);
     }
@@ -1296,9 +1222,6 @@ export class LoadStrikeScenario {
     WithRestartIterationOnFail(shouldRestart) {
         return this.withRestartIterationOnFail(shouldRestart);
     }
-    WithLicenseFeatures(...features) {
-        return this.withLicenseFeatures(...features);
-    }
     WithThresholds(...thresholds) {
         return this.withThresholds(...thresholds);
     }
@@ -1361,9 +1284,6 @@ export class LoadStrikeRunner {
     static WithRunnerKey(context, runnerKey) {
         return context.WithRunnerKey(runnerKey);
     }
-    static WithLicenseValidationServerUrl(context, serverUrl) {
-        return context.WithLicenseValidationServerUrl(serverUrl);
-    }
     static WithLicenseValidationTimeout(context, timeoutSeconds) {
         return context.WithLicenseValidationTimeout(timeoutSeconds);
     }
@@ -1385,12 +1305,6 @@ export class LoadStrikeRunner {
     static WithReportFileName(context, reportFileName) {
         return context.WithReportFileName(reportFileName);
     }
-    static WithReportFinalizer(context, handler) {
-        return context.WithReportFinalizer(handler);
-    }
-    static WithDetailedReportFinalizer(context, handler) {
-        return context.WithDetailedReportFinalizer(handler);
-    }
     static WithReportFolder(context, reportFolderPath) {
         return context.WithReportFolder(reportFolderPath);
     }
@@ -1403,6 +1317,12 @@ export class LoadStrikeRunner {
     static WithReportingSinks(context, ...sinks) {
         return context.WithReportingSinks(...sinks);
     }
+    static WithRuntimePolicies(context, ...policies) {
+        return context.WithRuntimePolicies(...policies);
+    }
+    static WithRuntimePolicyErrorMode(context, mode) {
+        return context.WithRuntimePolicyErrorMode(mode);
+    }
     static WithScenarioCompletionTimeout(context, timeoutSeconds) {
         return context.WithScenarioCompletionTimeout(timeoutSeconds);
     }
@@ -1563,15 +1483,11 @@ export class LoadStrikeRunner {
         return this.buildContext();
     }
     async run(args = []) {
-        const detailed = await this.runDetailed(args);
-        return detailedToNodeStats(detailed);
-    }
-    async runDetailed(args = []) {
         if (this.contextConfigurators.length) {
-            return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions()).runDetailed(args);
+            return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions()).run(args);
         }
         if (args.length) {
-            return this.buildContext().runDetailed(args);
+            return this.buildContext().run(args);
         }
         const started = new Date();
         const scenarioStats = new Map();
@@ -1585,14 +1501,15 @@ export class LoadStrikeRunner {
             name: resolveSinkName(sink, index)
         }));
         const sinkErrors = [];
+        const policyErrors = [];
         const sinkRetryCount = Math.max(this.options.sinkRetryCount ?? 2, 0);
         const sinkRetryBackoffMs = Math.max(this.options.sinkRetryBackoffMs ?? 25, 0);
         const policies = this.options.runtimePolicies ?? [];
+        const runtimePolicyErrorMode = normalizedRuntimePolicyErrorMode(this.options.runtimePolicyErrorMode);
         const plugins = this.options.reportingSinks === undefined && this.options.workerPlugins === undefined &&
             this.options.runtimePolicies === undefined && this.options.customSettings === undefined &&
             this.options.globalCustomSettings === undefined && this.options.configPath === undefined &&
             this.options.infraConfigPath === undefined && this.options.infraConfig === undefined &&
-            this.options.reportFinalizer === undefined && this.options.detailedReportFinalizer === undefined &&
             this.options.loggerConfig === undefined && this.options.minimumLogLevel === undefined &&
             this.options.sinkRetryCount === undefined && this.options.sinkRetryBackoffMs === undefined &&
             this.options.reportsEnabled === false && this.options.displayConsoleMetrics === false &&
@@ -1607,7 +1524,6 @@ export class LoadStrikeRunner {
         const createdUtc = started.toISOString();
         const testInfo = buildTestInfo(this.options, createdUtc);
         const nodeInfo = buildNodeInfo(this.options);
-        const runLogger = createLogger(this.options.loggerConfig, this.options.minimumLogLevel);
         let pluginsStopped = false;
         let sinksStopped = false;
         let realtimeTimer = null;
@@ -1617,18 +1533,18 @@ export class LoadStrikeRunner {
         let licenseSession = null;
         const clusterMode = resolveClusterExecutionMode(this.options);
         const selectedScenarios = clusterMode === "local-coordinator" || clusterMode === "nats-coordinator"
-            ? await this.filterScenariosWithPolicies(this.scenarios, policies)
-            : await this.selectScenarios(policies);
-        const licenseValidationServerUrl = String(this.options.licenseValidationServerUrl ?? DEFAULT_LICENSING_API_BASE_URL).trim() || DEFAULT_LICENSING_API_BASE_URL;
-        licensePayload = this.buildLicenseValidationPayload();
+            ? await this.filterScenariosWithPolicies(this.scenarios, policies, policyErrors, runtimePolicyErrorMode)
+            : await this.selectScenarios(policies, policyErrors, runtimePolicyErrorMode);
+        licensePayload = buildLicenseValidationPayload(this.options, this.scenarios);
         licenseClient = new LoadStrikeLocalClient({
-            licensingApiBaseUrl: licenseValidationServerUrl,
             licenseValidationTimeoutMs: Math.max((this.options.licenseValidationTimeoutSeconds ?? 10) * 1000, 1)
         });
         licenseSession = await licenseClient.acquireLicenseLease(licensePayload);
         if (clusterMode === "nats-agent") {
             return this.runAgentWithNats(createdUtc, testInfo, nodeInfo);
         }
+        const loggerSetup = createLoggerSetup(this.options.loggerConfig, this.options.minimumLogLevel, this.options, testInfo, nodeInfo);
+        const runLogger = loggerSetup.logger;
         const scenarioStartInfos = selectedScenarios.map((scenario, index) => {
             const startInfo = {
                 scenarioName: scenario.name,
@@ -1695,7 +1611,7 @@ export class LoadStrikeRunner {
                     const okCount = snapshot.reduce((sum, value) => sum + value.allOkCount, 0);
                     const failCount = snapshot.reduce((sum, value) => sum + value.allFailCount, 0);
                     const stamp = new Date().toTimeString().slice(0, 8);
-                    runLogger.info(`[${stamp}] requests=${requestCount} ok=${okCount} fail=${failCount}`);
+                    console.log(`[${stamp}] requests=${requestCount} ok=${okCount} fail=${failCount}`);
                 }
             }
             finally {
@@ -1703,7 +1619,7 @@ export class LoadStrikeRunner {
             }
         };
         const reportingIntervalMs = Math.max(Math.trunc((this.options.reportingIntervalSeconds ?? 5) * 1000), 1);
-        if (sinkStates.length > 0) {
+        if (sinkStates.length > 0 || toBoolean(this.options.displayConsoleMetrics, true)) {
             realtimeTimer = setInterval(() => {
                 void emitRealtimeSnapshot();
             }, reportingIntervalMs);
@@ -1718,12 +1634,12 @@ export class LoadStrikeRunner {
             if (clusterMode === "local-coordinator") {
                 const aggregated = await this.runCoordinatorWithLocalAgents(selectedScenarios, testInfo, nodeInfo);
                 metricStats = aggregated.metrics;
-                result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors);
+                result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
             else if (clusterMode === "nats-coordinator") {
                 const aggregated = await this.runCoordinatorWithNats(selectedScenarios, testInfo, nodeInfo);
                 metricStats = aggregated.metrics;
-                result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors);
+                result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
             else {
                 const testAbortController = new AbortController();
@@ -1746,21 +1662,15 @@ export class LoadStrikeRunner {
                     stopTestState,
                     testAbortController,
                     executeScenarioInvocation: (targetScenario, context, operation) => this.executeScenarioInvocation(targetScenario, context, operation),
-                    invokeBeforeScenario: (runtimePolicies, scenarioName) => this.invokeBeforeScenario(runtimePolicies, scenarioName),
-                    invokeAfterScenario: (runtimePolicies, scenarioName, stats) => this.invokeAfterScenario(runtimePolicies, scenarioName, stats)
+                    invokeBeforeScenario: (runtimePolicies, scenarioName) => this.invokeBeforeScenario(runtimePolicies, scenarioName, policyErrors, runtimePolicyErrorMode),
+                    invokeAfterScenario: (runtimePolicies, scenarioName, stats) => this.invokeAfterScenario(runtimePolicies, scenarioName, stats, policyErrors, runtimePolicyErrorMode),
+                    invokeBeforeStep: (runtimePolicies, scenarioName, stepName) => this.invokeBeforeStep(runtimePolicies, scenarioName, stepName, policyErrors, runtimePolicyErrorMode),
+                    invokeAfterStep: (runtimePolicies, scenarioName, stepName, reply) => this.invokeAfterStep(runtimePolicies, scenarioName, stepName, reply, policyErrors, runtimePolicyErrorMode)
                 })));
                 nodeInfo.currentOperation = stopTestState.value ? "Stop" : "Complete";
-                let scenarioStatList = Array.from(scenarioAccumulators.values())
+                const scenarioStatList = Array.from(scenarioAccumulators.values())
                     .map((value) => value.build(scenarioDurationsMs.get(value.scenarioName) ?? 0))
                     .sort((left, right) => left.sortIndex - right.sortIndex);
-                const reportFinalizer = this.options.reportFinalizer;
-                if (typeof reportFinalizer === "function") {
-                    const finalized = reportFinalizer(LoadStrikeReportData.create(...scenarioStatList));
-                    if (!(finalized instanceof LoadStrikeReportData)) {
-                        throw new TypeError("Report finalizer must return LoadStrikeReportData.");
-                    }
-                    scenarioStatList = [...finalized.scenarioStats];
-                }
                 const metricValues = collectMetricValues(allRegisteredMetrics);
                 metricStats = collectMetricStats(allRegisteredMetrics, Date.now() - started.getTime());
                 const metricsByName = metricValues.reduce((accumulator, metric) => {
@@ -1774,35 +1684,42 @@ export class LoadStrikeRunner {
                 result = {
                     startedUtc: started.toISOString(),
                     completedUtc: new Date().toISOString(),
+                    allBytes: builtScenarioStats.reduce((sum, x) => sum + x.allBytes, 0),
                     allRequestCount: scenarioStatList.reduce((sum, x) => sum + x.allRequestCount, 0),
                     allOkCount: scenarioStatList.reduce((sum, x) => sum + x.allOkCount, 0),
                     allFailCount: scenarioStatList.reduce((sum, x) => sum + x.allFailCount, 0),
                     failedThresholds: thresholdEvaluation.failedCount,
+                    durationMs: Math.max(Date.now() - started.getTime(), 0),
                     nodeInfo,
                     testInfo,
+                    thresholds: thresholdEvaluation.results.map((value) => ({ ...value })),
                     thresholdResults: thresholdEvaluation.results,
+                    metricStats,
                     metrics: metricValues,
                     scenarioStats: builtScenarioStats,
                     stepStats: builtStepStats,
+                    scenarioDurationsMs: Object.fromEntries(scenarioDurationsMs.entries()),
                     pluginsData: [],
                     disabledSinks: [],
                     sinkErrors,
-                    reportFiles: []
+                    policyErrors,
+                    reportFiles: [],
+                    logFiles: [...loggerSetup.logFiles],
+                    correlationRows: buildDetailedCorrelationRows(),
+                    failedCorrelationRows: buildDetailedFailedCorrelationRows()
                 };
             }
-            result.pluginsData = mergePluginData(result.pluginsData, await this.collectPluginData(plugins, detailedToNodeStats(result, metricStats), pluginLifecycleErrors));
-            const detailedReportFinalizer = this.options.detailedReportFinalizer;
-            const detailedResult = attachRunResultAliases(result);
-            const finalizedResult = attachRunResultAliases(typeof detailedReportFinalizer === "function"
-                ? requireDetailedReportFinalizerResult(detailedReportFinalizer(detailedResult))
-                : detailedResult);
-            await this.emitFinalStats(sinkStates, detailedToNodeStats(finalizedResult, metricStats), sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+            result.pluginsData = mergePluginData(result.pluginsData, await this.collectPluginData(plugins, attachRunResultAliases(result), pluginLifecycleErrors));
+            const finalizedResult = attachRunResultAliases(result);
+            finalizedResult.logFiles = mergeStringArrays(finalizedResult.logFiles, loggerSetup.logFiles);
             finalizedResult.reportFiles = this.writeReports(finalizedResult);
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
             await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
             await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
             sinksStopped = true;
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
+            finalizedResult.sinkErrors = sinkErrors
+                .map((value) => attachSinkErrorAliases(normalizeSinkErrorValue(value)));
             return finalizedResult;
         }
         finally {
@@ -1813,7 +1730,7 @@ export class LoadStrikeRunner {
                 await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
             }
             if (!pluginsStopped) {
-                await this.stopPlugins(plugins, pluginLifecycleErrors);
+                await this.stopPlugins(plugins, pluginLifecycleErrors, runLogger);
             }
             if (licenseClient && licenseSession && licensePayload) {
                 await licenseClient.releaseLicenseLease(licenseSession, licensePayload);
@@ -1823,10 +1740,7 @@ export class LoadStrikeRunner {
     async Run(args = []) {
         return this.run(args);
     }
-    async RunDetailed(args = []) {
-        return this.runDetailed(args);
-    }
-    async filterScenariosWithPolicies(scenarios, policies) {
+    async filterScenariosWithPolicies(scenarios, policies, policyErrors, mode) {
         if (!policies.length) {
             return [...scenarios];
         }
@@ -1835,7 +1749,7 @@ export class LoadStrikeRunner {
             let allowed = true;
             for (const policy of policies) {
                 if (policy.shouldRunScenario) {
-                    const shouldRun = await policy.shouldRunScenario(scenario.name);
+                    const shouldRun = await this.invokePolicyCallback(policy, "shouldRunScenario", scenario.name, "", policyErrors, mode, () => policy.shouldRunScenario(scenario.name), true);
                     if (!shouldRun) {
                         allowed = false;
                         break;
@@ -1868,6 +1782,7 @@ export class LoadStrikeRunner {
             localDevClusterEnabled: false,
             nodeType,
             natsServerUrl: undefined,
+            reportFolderPath: resolve(this.options.reportFolderPath ?? "./reports", sanitizeReportFileName(machineName)),
             targetScenarios,
             agentTargetScenarios: targetScenarios,
             coordinatorTargetScenarios: [],
@@ -1876,14 +1791,16 @@ export class LoadStrikeRunner {
             reportingSinks: includeWorkerExtensions ? this.options.reportingSinks : [],
             workerPlugins: includeWorkerExtensions ? this.options.workerPlugins : []
         });
-        const childStats = await childRunner.run();
+        const childResult = await childRunner.run();
+        const childStats = detailedToNodeStats(childResult);
         return {
             ...childStats,
             nodeInfo: {
                 ...childStats.nodeInfo,
                 machineName,
                 nodeType
-            }
+            },
+            logFiles: [...(childResult.logFiles ?? [])]
         };
     }
     async runCoordinatorWithLocalAgents(scenarios, testInfo, nodeInfo) {
@@ -1951,7 +1868,7 @@ export class LoadStrikeRunner {
                     };
                 });
                 if (handled && handledStats) {
-                    return toDetailedRunResultFromNodeStats(handledStats, startedUtc, []);
+                    return toDetailedRunResultFromNodeStats(handledStats, startedUtc, [], []);
                 }
                 await sleep(5);
             }
@@ -1961,15 +1878,17 @@ export class LoadStrikeRunner {
             await agent.dispose().catch(() => { });
         }
     }
-    async stopPlugins(plugins, pluginLifecycleErrors) {
-        void pluginLifecycleErrors;
+    async stopPlugins(plugins, pluginLifecycleErrors, logger) {
         for (const plugin of plugins) {
+            const pluginName = normalizePluginName(resolveWorkerPluginName(plugin));
             const stop = resolveWorkerPluginStop(plugin);
             if (stop) {
                 try {
                     await stop();
                 }
-                catch {
+                catch (error) {
+                    recordPluginLifecycleError(pluginLifecycleErrors, pluginName, "stop", error);
+                    logger?.warn?.(`Worker plugin ${pluginName} stop failed during shutdown: ${String(error ?? "unknown error")}`);
                 }
             }
             const dispose = resolveWorkerPluginDispose(plugin);
@@ -1977,7 +1896,9 @@ export class LoadStrikeRunner {
                 try {
                     await dispose();
                 }
-                catch {
+                catch (error) {
+                    recordPluginLifecycleError(pluginLifecycleErrors, pluginName, "dispose", error);
+                    logger?.warn?.(`Worker plugin ${pluginName} dispose failed during shutdown: ${String(error ?? "unknown error")}`);
                 }
             }
         }
@@ -1989,7 +1910,7 @@ export class LoadStrikeRunner {
         }
         return executeTrackedScenarioInvocation(tracking, context, () => scenario.execute(context), operation);
     }
-    async selectScenarios(policies) {
+    async selectScenarios(policies, policyErrors, mode) {
         const scenarioMap = new Map(this.scenarios.map((x) => [x.name, x]));
         const nodeType = (this.options.nodeType ?? "SingleNode").toLowerCase();
         let selectedNames = this.options.targetScenarios;
@@ -2012,7 +1933,7 @@ export class LoadStrikeRunner {
             let allowed = true;
             for (const policy of policies) {
                 if (policy.shouldRunScenario) {
-                    const shouldRun = await policy.shouldRunScenario(scenario.name);
+                    const shouldRun = await this.invokePolicyCallback(policy, "shouldRunScenario", scenario.name, "", policyErrors, mode, () => policy.shouldRunScenario(scenario.name), true);
                     if (!shouldRun) {
                         allowed = false;
                         break;
@@ -2025,9 +1946,6 @@ export class LoadStrikeRunner {
         }
         return filtered;
     }
-    buildLicenseValidationPayload() {
-        return buildLicenseValidationPayload(this.options, this.scenarios);
-    }
     async initializeSinks(sinkStates, context, infraConfig, retryCount, retryBackoffMs, sinkErrors) {
         for (const state of sinkStates) {
             await this.invokeSinkAction(state, "init", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
@@ -2062,19 +1980,10 @@ export class LoadStrikeRunner {
             });
         }
     }
-    async emitFinalStats(sinkStates, result, retryCount, retryBackoffMs, sinkErrors) {
-        for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "final", retryCount, retryBackoffMs, sinkErrors, false, false, async () => {
-                const saveFinalStats = resolveSinkSaveFinalStats(state.sink);
-                if (saveFinalStats) {
-                    await saveFinalStats(result);
-                }
-            });
-        }
-    }
     async stopSinks(sinkStates, retryCount, retryBackoffMs, sinkErrors) {
+        const shutdownRetryCount = 0;
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "stop", retryCount, retryBackoffMs, sinkErrors, true, false, async () => {
+            await this.invokeSinkAction(state, "stop", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
                 const stop = resolveSinkStop(state.sink);
                 if (stop) {
                     await stop();
@@ -2082,11 +1991,9 @@ export class LoadStrikeRunner {
             });
             const dispose = resolveSinkDispose(state.sink);
             if (dispose) {
-                try {
+                await this.invokeSinkAction(state, "dispose", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
                     await dispose();
-                }
-                catch {
-                }
+                });
             }
         }
     }
@@ -2130,20 +2037,56 @@ export class LoadStrikeRunner {
             }
         }
     }
-    async invokeBeforeScenario(policies, scenarioName) {
+    async invokeBeforeScenario(policies, scenarioName, policyErrors, mode) {
         for (const policy of policies) {
             if (policy.beforeScenario) {
-                await policy.beforeScenario(scenarioName);
+                await this.invokePolicyCallback(policy, "beforeScenario", scenarioName, "", policyErrors, mode, () => policy.beforeScenario(scenarioName));
             }
         }
     }
-    async invokeAfterScenario(policies, scenarioName, stats) {
+    async invokeAfterScenario(policies, scenarioName, stats, policyErrors, mode) {
         for (const policy of policies) {
             if (policy.afterScenario) {
-                await policy.afterScenario(scenarioName, stats);
+                await this.invokePolicyCallback(policy, "afterScenario", scenarioName, "", policyErrors, mode, () => policy.afterScenario(scenarioName, stats));
+            }
+        }
+    }
+    async invokeBeforeStep(policies, scenarioName, stepName, policyErrors, mode) {
+        for (const policy of policies) {
+            if (policy.beforeStep) {
+                await this.invokePolicyCallback(policy, "beforeStep", scenarioName, stepName, policyErrors, mode, () => policy.beforeStep(scenarioName, stepName));
             }
         }
     }
+    async invokeAfterStep(policies, scenarioName, stepName, reply, policyErrors, mode) {
+        for (const policy of policies) {
+            if (policy.afterStep) {
+                await this.invokePolicyCallback(policy, "afterStep", scenarioName, stepName, policyErrors, mode, () => policy.afterStep(scenarioName, stepName, reply));
+            }
+        }
+    }
+    async invokePolicyCallback(policy, callbackName, scenarioName, stepName, policyErrors, mode, callback, continueFallback) {
+        try {
+            return await callback();
+        }
+        catch (error) {
+            const entry = this.buildRuntimePolicyError(policy, callbackName, scenarioName, stepName, error);
+            policyErrors.push(entry);
+            if (mode === "fail") {
+                throw new RuntimePolicyCallbackError(`Runtime policy '${entry.policyName}' failed during ${callbackName}: ${entry.message}`);
+            }
+            return continueFallback;
+        }
+    }
+    buildRuntimePolicyError(policy, callbackName, scenarioName, stepName, error) {
+        return attachRuntimePolicyErrorAliases({
+            policyName: resolveRuntimePolicyName(policy),
+            callbackName,
+            scenarioName,
+            stepName,
+            message: String(error ?? "runtime policy callback failed")
+        });
+    }
     writeReports(result) {
         const reportsEnabled = this.options.reportsEnabled ?? true;
         if (!reportsEnabled) {
@@ -2152,7 +2095,7 @@ export class LoadStrikeRunner {
         const reportFolder = resolve(this.options.reportFolderPath ?? "./reports");
         const reportFile = sanitizeReportFileName(this.options.reportFileName?.trim()
             ? this.options.reportFileName
-            : `${result.testInfo.testSuite}_${result.testInfo.testName}_${formatUtcReportTimestamp(new Date())}`);
+            : `${result.testInfo.testSuite}_${result.testInfo.testName}_${resolveDefaultReportTimestamp(result)}`);
         const reportFormats = normalizeReportFormats(this.options.reportFormats ?? ["html", "txt", "csv", "md"]);
         mkdirSync(reportFolder, { recursive: true });
         const nodeStats = detailedToNodeStats(result);
@@ -2203,7 +2146,7 @@ function hasPluginRows(value) {
     return value.tables.some((table) => Array.isArray(table.rows) && table.rows.length > 0);
 }
 async function executeScenarioRuntime(args) {
-    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario } = args;
+    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
     const scenarioStartedMs = Date.now();
     const scenarioContextData = {};
     const registeredMetrics = [];
@@ -2316,20 +2259,8 @@ async function executeScenarioRuntime(args) {
             },
             shouldStopScenario: () => stopScenario || scenarioCancellationToken.aborted,
             shouldStopTest: () => stopTestState.value || scenarioCancellationToken.aborted,
-            invokeBeforeStep: async (stepName) => {
-                for (const policy of policies) {
-                    if (policy.beforeStep) {
-                        await policy.beforeStep(scenario.name, stepName);
-                    }
-                }
-            },
-            invokeAfterStep: async (stepName, reply) => {
-                for (const policy of policies) {
-                    if (policy.afterStep) {
-                        await policy.afterStep(scenario.name, stepName, reply);
-                    }
-                }
-            }
+            invokeBeforeStep: async (stepName) => invokeBeforeStep(policies, scenario.name, stepName),
+            invokeAfterStep: async (stepName, reply) => invokeAfterStep(policies, scenario.name, stepName, reply)
         };
         attachScenarioContextAliases(context);
         const startedAt = Date.now();
@@ -2568,6 +2499,10 @@ async function executeScenarioRuntime(args) {
         await invokeAfterScenario(policies, scenario.name, runtime);
     }
     catch (error) {
+        if (error instanceof RuntimePolicyCallbackError) {
+            accumulator.setCurrentOperation("Error");
+            throw error;
+        }
         if (scenarioCancellationToken.aborted || testAbortController.signal.aborted) {
             accumulator.setCurrentOperation("Stop");
         }
@@ -2965,6 +2900,16 @@ function normalizeSinkErrorValue(value) {
         attempts: pickAliasNumber(source, "attempts", "Attempts")
     };
 }
+function normalizeRuntimePolicyErrorValue(value) {
+    const source = asAliasRecord(value);
+    return {
+        policyName: pickAliasString(source, "policyName", "PolicyName"),
+        callbackName: pickAliasString(source, "callbackName", "CallbackName"),
+        scenarioName: pickAliasString(source, "scenarioName", "ScenarioName"),
+        stepName: pickAliasString(source, "stepName", "StepName"),
+        message: pickAliasString(source, "message", "Message")
+    };
+}
 function normalizeMetricValueProjection(value) {
     const source = asAliasRecord(value);
     const scenarioName = pickAliasString(source, "scenarioName", "ScenarioName");
@@ -3307,6 +3252,16 @@ function attachSinkErrorAliases(error) {
         Attempts: "attempts"
     });
 }
+function attachRuntimePolicyErrorAliases(error) {
+    const projected = normalizeRuntimePolicyErrorValue(error);
+    return attachAliasMap(projected, {
+        PolicyName: "policyName",
+        CallbackName: "callbackName",
+        ScenarioName: "scenarioName",
+        StepName: "stepName",
+        Message: "message"
+    });
+}
 function attachMetricStatsAliases(stats) {
     const projected = normalizeMetricStatsValue(stats);
     projected.counters = projected.counters.map((value) => attachCounterStatsAliases(value));
@@ -3465,7 +3420,8 @@ function attachNodeStatsAliases(stats) {
         PluginsData: "pluginsData",
         DisabledSinks: "disabledSinks",
         SinkErrors: "sinkErrors",
-        ReportFiles: "reportFiles"
+        ReportFiles: "reportFiles",
+        LogFiles: "logFiles"
     });
     defineAliasProperty(projected, "StartedUtc", () => parseAliasDate(stats.startedUtc));
     defineAliasProperty(projected, "CompletedUtc", () => parseAliasDate(stats.completedUtc));
@@ -3476,17 +3432,30 @@ function attachRunResultAliases(result) {
     const source = asAliasRecord(result);
     const scenarioStats = pickAliasArray(source, "scenarioStats", "ScenarioStats")
         .map((value, index) => attachScenarioStatsAliases(normalizeScenarioStatsValue(value, index)));
+    const findScenarioStats = (scenarioName) => scenarioStats.find((value) => value.scenarioName === scenarioName);
+    const getScenarioStats = (scenarioName) => {
+        const value = findScenarioStats(scenarioName);
+        if (!value) {
+            throw new Error(`Scenario stats not found: ${scenarioName}`);
+        }
+        return value;
+    };
     const projected = {
         startedUtc: pickAliasDateToken(source, "startedUtc", "StartedUtc"),
         completedUtc: pickAliasDateToken(source, "completedUtc", "CompletedUtc"),
+        allBytes: pickAliasNumber(source, "allBytes", "AllBytes"),
         allRequestCount: pickAliasNumber(source, "allRequestCount", "AllRequestCount"),
         allOkCount: pickAliasNumber(source, "allOkCount", "AllOkCount"),
         allFailCount: pickAliasNumber(source, "allFailCount", "AllFailCount"),
         failedThresholds: pickAliasNumber(source, "failedThresholds", "FailedThresholds"),
+        durationMs: pickAliasNumber(source, "durationMs", "DurationMs", "Duration"),
         nodeInfo: attachNodeInfoAliases(pickAliasValue(source, "nodeInfo", "NodeInfo")),
         testInfo: attachTestInfoAliases(pickAliasValue(source, "testInfo", "TestInfo")),
+        thresholds: pickAliasArray(source, "thresholds", "Thresholds")
+            .map((value) => attachThresholdResultAliases(normalizeThresholdResultValue(value))),
         thresholdResults: pickAliasArray(source, "thresholdResults", "ThresholdResults")
             .map((value) => attachThresholdResultAliases(normalizeThresholdResultValue(value))),
+        metricStats: attachMetricStatsAliases(normalizeMetricStatsValue(pickAliasValue(source, "metricStats", "MetricStats"), pickAliasNumber(source, "durationMs", "DurationMs", "Duration"))),
         metrics: pickAliasArray(source, "metrics", "Metrics")
             .map((value) => attachMetricValueAliases(normalizeMetricValueProjection(value))),
         scenarioStats,
@@ -3496,37 +3465,53 @@ function attachRunResultAliases(result) {
             : scenarioStats.flatMap((value) => value.stepStats)),
         pluginsData: pickAliasArray(source, "pluginsData", "PluginsData")
             .map((value) => normalizePluginData(pickAliasString(asAliasRecord(value), "pluginName", "PluginName"), value)),
+        scenarioDurationsMs: pickAliasValue(source, "scenarioDurationsMs", "ScenarioDurationsMs") ?? {},
         disabledSinks: normalizeAliasStringArray(pickAliasValue(source, "disabledSinks", "DisabledSinks")),
         sinkErrors: pickAliasArray(source, "sinkErrors", "SinkErrors")
             .map((value) => attachSinkErrorAliases(normalizeSinkErrorValue(value))),
-        reportFiles: normalizeAliasStringArray(pickAliasValue(source, "reportFiles", "ReportFiles"))
+        policyErrors: pickAliasArray(source, "policyErrors", "PolicyErrors")
+            .map((value) => attachRuntimePolicyErrorAliases(normalizeRuntimePolicyErrorValue(value))),
+        reportFiles: normalizeAliasStringArray(pickAliasValue(source, "reportFiles", "ReportFiles")),
+        logFiles: normalizeAliasStringArray(pickAliasValue(source, "logFiles", "LogFiles")),
+        correlationRows: pickAliasArray(source, "correlationRows", "CorrelationRows")
+            .map((value) => ({ ...asAliasRecord(value) })),
+        failedCorrelationRows: pickAliasArray(source, "failedCorrelationRows", "FailedCorrelationRows")
+            .map((value) => ({ ...asAliasRecord(value) })),
+        findScenarioStats,
+        getScenarioStats,
+        FindScenarioStats: findScenarioStats,
+        GetScenarioStats: getScenarioStats
     };
     attachAliasMap(projected, {
+        AllBytes: "allBytes",
         AllRequestCount: "allRequestCount",
         AllOkCount: "allOkCount",
         AllFailCount: "allFailCount",
         FailedThresholds: "failedThresholds",
+        DurationMs: "durationMs",
         NodeInfo: "nodeInfo",
         TestInfo: "testInfo",
+        Thresholds: "thresholds",
         ThresholdResults: "thresholdResults",
+        MetricStats: "metricStats",
         Metrics: "metrics",
         ScenarioStats: "scenarioStats",
         StepStats: "stepStats",
+        ScenarioDurationsMs: "scenarioDurationsMs",
         PluginsData: "pluginsData",
         DisabledSinks: "disabledSinks",
         SinkErrors: "sinkErrors",
-        ReportFiles: "reportFiles"
+        PolicyErrors: "policyErrors",
+        ReportFiles: "reportFiles",
+        LogFiles: "logFiles",
+        CorrelationRows: "correlationRows",
+        FailedCorrelationRows: "failedCorrelationRows"
     });
     defineAliasProperty(projected, "StartedUtc", () => parseAliasDate(projected.startedUtc));
     defineAliasProperty(projected, "CompletedUtc", () => parseAliasDate(projected.completedUtc));
+    defineAliasProperty(projected, "Duration", () => projected.durationMs);
     return projected;
 }
-function requireDetailedReportFinalizerResult(result) {
-    if (!result || typeof result !== "object" || Array.isArray(result)) {
-        throw new TypeError("Detailed report finalizer must return LoadStrikeRunResult.");
-    }
-    return result;
-}
 function resolveResponseCustomLatency(customLatencyMs, usesOverloadDefaults) {
     if (!Number.isFinite(customLatencyMs)) {
         return usesOverloadDefaults ? -1 : 0;
@@ -4124,9 +4109,10 @@ function detailedToNodeStats(result, metricStats) {
         scenarioStats,
         stepStats,
         pluginsData,
-        disabledSinks: [...result.disabledSinks],
-        sinkErrors: result.sinkErrors.map((sinkError) => ({ ...sinkError })),
-        reportFiles: [...result.reportFiles],
+        disabledSinks: [...(result.disabledSinks ?? [])],
+        sinkErrors: (result.sinkErrors ?? []).map((sinkError) => ({ ...sinkError })),
+        reportFiles: [...(result.reportFiles ?? [])],
+        logFiles: [...(result.logFiles ?? [])],
         findScenarioStats: (scenarioName) => scenarioStats.find((scenario) => scenario.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -4193,6 +4179,7 @@ function buildEmptyNodeStats(args) {
         disabledSinks: [],
         sinkErrors: [],
         reportFiles: [],
+        logFiles: [],
         findScenarioStats: (scenarioName) => undefined,
         getScenarioStats: (scenarioName) => {
             throw new Error(`Scenario stats not found: ${scenarioName}`);
@@ -4240,27 +4227,37 @@ function nodeStatsToClusterPayload(result) {
         thresholds: result.thresholds,
         pluginsData: result.pluginsData,
         nodeInfo: result.nodeInfo,
-        testInfo: result.testInfo
+        testInfo: result.testInfo,
+        logFiles: [...(result.logFiles ?? [])]
     };
 }
-function toDetailedRunResultFromNodeStats(result, startedUtc, sinkErrors) {
+function toDetailedRunResultFromNodeStats(result, startedUtc, sinkErrors, policyErrors = []) {
     return attachRunResultAliases({
         startedUtc,
         completedUtc: result.completedUtc,
+        allBytes: result.allBytes,
         allRequestCount: result.allRequestCount,
         allOkCount: result.allOkCount,
         allFailCount: result.allFailCount,
         failedThresholds: result.failedThresholds,
+        durationMs: result.durationMs,
         nodeInfo: result.nodeInfo,
         testInfo: result.testInfo,
+        thresholds: result.thresholds.map((value) => ({ ...value })),
         thresholdResults: result.thresholds.map((value) => ({ ...value })),
+        metricStats: result.metrics,
         metrics: flattenMetricValues(result.metrics),
         scenarioStats: result.scenarioStats,
         stepStats: result.stepStats,
+        scenarioDurationsMs: Object.fromEntries(result.scenarioStats.map((value) => [value.scenarioName, value.durationMs])),
         pluginsData: result.pluginsData.map((value) => normalizePluginData(value.pluginName, value)),
         disabledSinks: [...result.disabledSinks],
         sinkErrors: [...sinkErrors, ...result.sinkErrors],
-        reportFiles: [...result.reportFiles]
+        policyErrors: policyErrors.map((value) => attachRuntimePolicyErrorAliases({ ...value })),
+        reportFiles: [...result.reportFiles],
+        logFiles: [...(result.logFiles ?? [])],
+        correlationRows: buildDetailedCorrelationRows(),
+        failedCorrelationRows: buildDetailedFailedCorrelationRows()
     });
 }
 function flattenMetricValues(metricStats) {
@@ -4353,6 +4350,7 @@ function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
         disabledSinks: [],
         sinkErrors: [],
         reportFiles: [],
+        logFiles: normalizeAliasStringArray(result.stats.logFiles),
         findScenarioStats: (scenarioName) => scenarioStats.find((value) => value.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -4399,6 +4397,7 @@ function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes) {
         disabledSinks: [],
         sinkErrors: [],
         reportFiles: [],
+        logFiles: mergeStringArrays(...nodes.map((value) => value.logFiles ?? [])),
         findScenarioStats: (scenarioName) => scenarioStats.find((value) => value.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -4791,6 +4790,8 @@ class ManagedScenarioTrackingRuntime {
         this.timeoutSweepIntervalMs = Math.trunc(pickTrackingNumber(tracking, ["TimeoutSweepIntervalMs", "timeoutSweepIntervalMs"], pickTrackingNumber(tracking, ["TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds"], 1) * 1000));
         this.timeoutBatchSize = Math.trunc(pickTrackingNumber(tracking, ["TimeoutBatchSize", "timeoutBatchSize"], 200));
         this.timeoutCountsAsFailure = pickTrackingBoolean(tracking, "TimeoutCountsAsFailure", "timeoutCountsAsFailure", true);
+        const trackingFieldValueCaseSensitive = pickTrackingBoolean(tracking, "TrackingFieldValueCaseSensitive", "trackingFieldValueCaseSensitive", true);
+        const gatherByFieldValueCaseSensitive = pickTrackingBoolean(tracking, "GatherByFieldValueCaseSensitive", "gatherByFieldValueCaseSensitive", true);
         this.sourceAdapter = EndpointAdapterFactory.create(this.sourceEndpoint);
         this.destinationAdapter = this.destinationEndpoint ? EndpointAdapterFactory.create(this.destinationEndpoint) : null;
         this.correlationStore = mapRuntimeCorrelationStore(tracking, runNamespace);
@@ -4798,18 +4799,20 @@ class ManagedScenarioTrackingRuntime {
             sourceTrackingField: this.sourceEndpoint.trackingField,
             destinationTrackingField: this.destinationEndpoint?.trackingField,
             destinationGatherByField: this.destinationEndpoint?.gatherByField,
+            trackingFieldValueCaseSensitive,
+            gatherByFieldValueCaseSensitive,
             correlationTimeoutMs: this.correlationTimeoutMs,
             timeoutCountsAsFailure: this.timeoutCountsAsFailure,
             store: this.correlationStore ?? undefined,
             plugins: [
                 {
-                    onMatched: async (trackingId, _source, destination, latencyMs) => {
+                    onMatched: async (trackingId, _source, destination, latencyMs, gatherByValue) => {
                         const eventId = this.shiftPendingValue(this.pendingEventIds, trackingId);
                         const sourceTimestampUtc = this.shiftPendingValue(this.pendingSourceTimestamps, trackingId);
                         const destinationTimestampUtc = new Date().toISOString();
-                        const gatherByValue = this.destinationEndpoint?.gatherByField
+                        const observedGatherByValue = gatherByValue ?? (this.destinationEndpoint?.gatherByField
                             ? readRuntimeTrackingId(destination, this.destinationEndpoint.gatherByField)
-                            : undefined;
+                            : undefined);
                         addCorrelationRow({
                             occurredUtc: new Date().toISOString(),
                             scenarioName: this.scenarioName,
@@ -4825,7 +4828,7 @@ class ManagedScenarioTrackingRuntime {
                             isSuccess: true,
                             isFailure: false,
                             gatherByField: this.gatherByFieldExpression,
-                            gatherByValue: gatherByValue ?? undefined
+                            gatherByValue: observedGatherByValue ?? undefined
                         });
                         this.resolveTrackingWaiter(trackingId, {
                             status: "matched",
@@ -5596,10 +5599,10 @@ function normalizeRuntimeObservedTrackingPayload(payload, endpoint) {
 function readRuntimeTrackingId(payload, selector) {
     const normalized = selector.trim().toLowerCase();
     if (normalized.startsWith("header:")) {
-        const headerName = selector.slice("header:".length).trim().toLowerCase();
+        const headerName = selector.slice("header:".length).trim();
         for (const [key, value] of Object.entries(payload.headers ?? {})) {
             const resolved = String(value ?? "").trim();
-            if (key.toLowerCase() === headerName && resolved) {
+            if (key === headerName && resolved) {
                 return resolved;
             }
         }
@@ -5875,6 +5878,49 @@ function createLogger(loggerConfig, minimumLogLevel) {
             };
         }
     }
+    return wrapLoggerWithMinimumLevel(baseLogger, minimumLogLevel);
+}
+function createLoggerSetup(loggerConfig, minimumLogLevel, options, testInfo, nodeInfo) {
+    if (typeof loggerConfig === "function") {
+        return {
+            logger: createLogger(loggerConfig, minimumLogLevel),
+            logFiles: []
+        };
+    }
+    const logFilePath = resolveDefaultLogFilePath(options, testInfo, nodeInfo);
+    mkdirSync(resolve(options.reportFolderPath ?? "./reports"), { recursive: true });
+    writeFileSync(logFilePath, "", "utf8");
+    return {
+        logger: wrapLoggerWithMinimumLevel(createDefaultLogger(logFilePath), minimumLogLevel),
+        logFiles: [logFilePath]
+    };
+}
+function createDefaultLogger(logFilePath) {
+    const write = (level, message) => {
+        const line = formatDefaultLoggerLine(level, message);
+        const output = `${line}\n`;
+        if (level === "debug") {
+            console.debug(line);
+        }
+        else if (level === "info") {
+            console.info(line);
+        }
+        else if (level === "warn") {
+            console.warn(line);
+        }
+        else {
+            console.error(line);
+        }
+        appendFileSync(logFilePath, output, "utf8");
+    };
+    return {
+        debug: (message) => write("debug", message),
+        info: (message) => write("info", message),
+        warn: (message) => write("warn", message),
+        error: (message) => write("error", message)
+    };
+}
+function wrapLoggerWithMinimumLevel(baseLogger, minimumLogLevel) {
     const threshold = logLevelOrder(minimumLogLevel);
     return {
         debug: (message) => {
@@ -5899,6 +5945,16 @@ function createLogger(loggerConfig, minimumLogLevel) {
         }
     };
 }
+function formatDefaultLoggerLine(level, message) {
+    const code = level === "debug"
+        ? "DBG"
+        : level === "info"
+            ? "INF"
+            : level === "warn"
+                ? "WRN"
+                : "ERR";
+    return `${new Date().toISOString()} [${code}] ${message}`;
+}
 function logLevelOrder(level) {
     const normalized = String(level ?? "").trim().toLowerCase();
     if (!normalized) {
@@ -5930,11 +5986,41 @@ function formatUtcReportTimestamp(value) {
     const second = String(value.getUTCSeconds()).padStart(2, "0");
     return `${year}${month}${day}_${hour}${minute}${second}`;
 }
+function resolveDefaultReportTimestamp(result) {
+    const createdUtc = result.testInfo?.createdUtc ?? result.startedUtc;
+    const parsed = createdUtc ? new Date(createdUtc) : undefined;
+    return parsed && !Number.isNaN(parsed.getTime())
+        ? formatUtcReportTimestamp(parsed)
+        : formatUtcReportTimestamp(new Date());
+}
+function resolveDefaultLogFilePath(options, testInfo, nodeInfo) {
+    const reportFolder = resolve(options.reportFolderPath ?? "./reports");
+    const parsedCreatedUtc = testInfo.createdUtc ? new Date(testInfo.createdUtc) : undefined;
+    const timestamp = parsedCreatedUtc && !Number.isNaN(parsedCreatedUtc.getTime())
+        ? formatUtcReportTimestamp(parsedCreatedUtc)
+        : formatUtcReportTimestamp(new Date());
+    const suffixParts = [];
+    if (nodeInfo.nodeType !== "SingleNode") {
+        suffixParts.push(nodeInfo.nodeType === "Coordinator" ? "coordinator" : "agent");
+    }
+    const localMachineName = os.hostname().trim().toLowerCase();
+    if (nodeInfo.machineName.trim() &&
+        (nodeInfo.nodeType !== "SingleNode" || nodeInfo.machineName.trim().toLowerCase() !== localMachineName)) {
+        suffixParts.push(nodeInfo.machineName);
+    }
+    const suffix = suffixParts.length
+        ? `-${suffixParts.map((value) => sanitizeReportFileName(value)).join("-")}`
+        : "";
+    return resolve(reportFolder, sanitizeReportFileName(`loadstrike-log-${timestamp}${suffix}.txt`));
+}
 function sanitizeReportFileName(value) {
     const normalized = String(value ?? "");
     return normalized
         .replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_") || "loadstrike-run";
 }
+function mergeStringArrays(...values) {
+    return Array.from(new Set(values.flatMap((value) => (value ?? []).filter((entry) => entry.trim().length > 0))));
+}
 function loadJsonObject(path) {
     try {
         const raw = readFileSync(resolve(path), "utf8");
@@ -6171,6 +6257,16 @@ function normalizeRunnerOptionCollectionShapes(options) {
     validateNamedWorkerPlugins(normalized.workerPlugins ?? []);
     return normalized;
 }
+function normalizedRuntimePolicyErrorMode(value) {
+    const normalized = String(value ?? "fail").trim().toLowerCase();
+    if (normalized === "fail") {
+        return "fail";
+    }
+    if (normalized === "continue") {
+        return "continue";
+    }
+    throw new Error("Runtime policy error mode must be either Fail or Continue.");
+}
 function extractContextOverridesFromConfig(config) {
     const rootConfig = asRecord(config);
     const loadStrikeSection = asRecord(tryReadConfigValue(rootConfig, "LoadStrike"));
@@ -6224,6 +6320,7 @@ function extractContextOverridesFromConfig(config) {
     setString("AgentGroup", "AgentGroup", "LoadStrike:AgentGroup");
     setString("NatsServerUrl", "NatsServerUrl", "LoadStrike:NatsServerUrl");
     setString("RunnerKey", "RunnerKey", "LoadStrike:RunnerKey");
+    setString("RuntimePolicyErrorMode", "RuntimePolicyErrorMode", "LoadStrike:RuntimePolicyErrorMode");
     const nodeType = pick("NodeType", "LoadStrike:NodeType");
     if (nodeType != null) {
         const parsed = tryParseNodeTypeToken(nodeType);
@@ -6238,7 +6335,6 @@ function extractContextOverridesFromConfig(config) {
             patch.MinimumLogLevel = parsed;
         }
     }
-    setString("LicenseValidationServerUrl", "LicenseValidationServerUrl", "LoadStrike:LicenseValidation:ServerUrl", "LicenseValidation:ServerUrl");
     const agentsCount = toInt(pick("AgentsCount", "LoadStrike:AgentsCount"));
     if (agentsCount > 0) {
         patch.AgentsCount = agentsCount;
@@ -6373,7 +6469,6 @@ function toRunContext(options) {
         CoordinatorTargetScenarios: normalized.coordinatorTargetScenarios,
         NatsServerUrl: normalized.natsServerUrl,
         RunnerKey: normalized.runnerKey,
-        LicenseValidationServerUrl: normalized.licenseValidationServerUrl,
         LicenseValidationTimeoutSeconds: normalized.licenseValidationTimeoutSeconds,
         ConfigPath: normalized.configPath,
         InfraConfigPath: normalized.infraConfigPath,
@@ -6386,8 +6481,6 @@ function toRunContext(options) {
         ReportFileName: normalized.reportFileName,
         ReportFolderPath: normalized.reportFolderPath,
         ReportFormats: normalized.reportFormats,
-        ReportFinalizer: normalized.reportFinalizer,
-        DetailedReportFinalizer: normalized.detailedReportFinalizer,
         ReportingIntervalSeconds: normalized.reportingIntervalSeconds,
         MinimumLogLevel: normalized.minimumLogLevel,
         LoggerConfig: normalized.loggerConfig,
@@ -6395,6 +6488,7 @@ function toRunContext(options) {
         SinkRetryCount: normalized.sinkRetryCount,
         SinkRetryBackoffMs: normalized.sinkRetryBackoffMs,
         RuntimePolicies: normalized.runtimePolicies,
+        RuntimePolicyErrorMode: normalized.runtimePolicyErrorMode,
         ScenarioCompletionTimeoutSeconds: normalized.scenarioCompletionTimeoutSeconds,
         ClusterCommandTimeoutSeconds: normalized.clusterCommandTimeoutSeconds,
         RestartIterationMaxAttempts: normalized.restartIterationMaxAttempts,
@@ -6403,6 +6497,26 @@ function toRunContext(options) {
         GlobalCustomSettings: normalized.globalCustomSettings
     };
 }
+class RuntimePolicyCallbackError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RuntimePolicyCallbackError";
+    }
+}
+function resolveRuntimePolicyName(policy) {
+    const namedPolicy = policy.policyName ?? policy.PolicyName;
+    if (typeof namedPolicy === "string" && namedPolicy.trim()) {
+        return namedPolicy;
+    }
+    const constructorValue = Reflect.get(policy, "constructor");
+    const constructorName = constructorValue && typeof constructorValue === "object"
+        ? Reflect.get(constructorValue, "name")
+        : typeof constructorValue === "function"
+            ? Reflect.get(constructorValue, "name")
+            : "";
+    const fallback = typeof constructorName === "string" ? constructorName.trim() : "";
+    return fallback || "runtime-policy";
+}
 function buildLicenseValidationPayload(options, scenarios) {
     const context = {
         ...toRunContext(options)
@@ -6416,8 +6530,7 @@ function buildLicenseValidationPayload(options, scenarios) {
         Weight: scenario.getWeight(),
         LoadSimulations: [...scenario.getSimulations()],
         Thresholds: [...scenario.getThresholds()],
-        Tracking: scenario.getTrackingConfiguration() ?? {},
-        LicenseFeatures: scenario.getLicenseFeatures()
+        Tracking: scenario.getTrackingConfiguration() ?? {}
     }));
     return {
         Context: context,
@@ -6466,7 +6579,6 @@ function looksLikeRunContext(value) {
         "ClusterId",
         "CoordinatorTargetScenarios",
         "RunnerKey",
-        "LicenseValidationServerUrl",
         "LicenseValidationTimeoutSeconds",
         "MinimumLogLevel",
         "LoggerConfig",
@@ -6476,8 +6588,6 @@ function looksLikeRunContext(value) {
         "ReportFileName",
         "ReportFolderPath",
         "ReportFormats",
-        "ReportFinalizer",
-        "DetailedReportFinalizer",
         "ReportingIntervalSeconds",
         "ReportingSinks",
         "SinkRetryCount",
@@ -6614,12 +6724,6 @@ function resolveSinkSaveRealtimeMetrics(sink) {
         ? method.bind(sink)
         : undefined;
 }
-function resolveSinkSaveFinalStats(sink) {
-    const method = sink.saveFinalStats ?? sink.SaveFinalStats;
-    return typeof method === "function"
-        ? method.bind(sink)
-        : undefined;
-}
 function resolveSinkSaveRunResult(sink) {
     const method = sink.saveRunResult ?? sink.SaveRunResult;
     return typeof method === "function"
@@ -6658,6 +6762,46 @@ function addCorrelationRow(row) {
         correlationRows.splice(0, correlationRows.length - MAX_CORRELATION_ROWS);
     }
 }
+function buildDetailedFailedCorrelationRows() {
+    return [...failedResponseRows]
+        .reverse()
+        .map((row) => ({
+        OccurredUtc: row.occurredUtc,
+        Scenario: row.scenarioName,
+        Source: row.sourceEndpoint,
+        Destination: row.destinationEndpoint,
+        RunMode: row.runMode,
+        StatusCode: row.statusCode,
+        TrackingId: row.trackingId ?? "",
+        EventId: row.eventId ?? "",
+        SourceTimestampUtc: row.sourceTimestampUtc ?? "",
+        DestinationTimestampUtc: row.destinationTimestampUtc ?? "",
+        LatencyMs: formatOptionalLatency(row.latencyMs),
+        Message: row.message ?? ""
+    }));
+}
+function buildDetailedCorrelationRows() {
+    return [...correlationRows]
+        .reverse()
+        .map((row) => ({
+        OccurredUtc: row.occurredUtc,
+        Scenario: row.scenarioName,
+        Source: row.sourceEndpoint,
+        Destination: row.destinationEndpoint,
+        RunMode: row.runMode,
+        StatusCode: row.statusCode,
+        IsSuccess: row.isSuccess,
+        IsFailure: row.isFailure,
+        GatherByField: row.gatherByField ?? "",
+        GatherByValue: row.gatherByValue ?? "",
+        TrackingId: row.trackingId ?? "",
+        EventId: row.eventId ?? "",
+        SourceTimestampUtc: row.sourceTimestampUtc ?? "",
+        DestinationTimestampUtc: row.destinationTimestampUtc ?? "",
+        LatencyMs: formatOptionalLatency(row.latencyMs),
+        Message: row.message ?? ""
+    }));
+}
 function resolveWorkerPlugins(customPlugins) {
     const registry = new Map();
     for (const plugin of createBuiltInWorkerPlugins()) {
@@ -6990,3 +7134,122 @@ function readConfiguredSinkName(sink) {
 async function sleep(ms) {
     await new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
 }
+export const __loadstrikeTestExports = {
+    LoadStrikeContext,
+    LoadStrikeCounter,
+    LoadStrikeGauge,
+    LoadStrikeMetric,
+    LoadStrikeResponse,
+    LoadStrikeRunner,
+    LoadStrikeScenario,
+    LoadStrikeSimulation,
+    LoadStrikeStep,
+    ManagedScenarioTrackingRuntime,
+    ScenarioStatsAccumulator,
+    StepStatsAccumulator,
+    TrackingFieldSelector,
+    addCorrelationRow,
+    addFailedResponseRow,
+    aggregateNodeStats,
+    asRecord,
+    assertNoDisableLicenseEnforcementOption,
+    buildEmptyNodeStats,
+    buildGroupedCorrelationRows,
+    buildMeasurementPlaceholder,
+    buildRichHtmlReport,
+    buildThresholdCheckExpression,
+    buildTrackingLeaseKey,
+    buildTrackingRunNamespace,
+    clusterNodeResultToNodeStats,
+    combineAbortSignals,
+    computeScenarioRequestCount,
+    computeWarmUpIterations,
+    createBuiltInWorkerPlugins,
+    createLogger,
+    createRuntimeRandom,
+    delayWithAbort,
+    detailedToNodeStats,
+    evaluateThresholdsForScenarios,
+    executeTrackedScenarioInvocation,
+    extractContextOverridesFromArgs,
+    extractContextOverridesFromConfig,
+    findCaseInsensitiveKey,
+    formatOptionalLatency,
+    formatUtcReportTimestamp,
+    hasPluginRows,
+    inferRuntimeLegacyHttpResponseSource,
+    isComparisonFailed,
+    loadJsonObject,
+    logLevelOrder,
+    looksLikeRunContext,
+    mapRuntimeCorrelationStore,
+    mapRuntimeTrackingEndpointSpec,
+    mergeDefinedRecord,
+    normalizeCliOverrideKey,
+    normalizeMetricValue,
+    normalizeOptionalReportFormats,
+    normalizeOptionalStringArray,
+    normalizeReplyArguments,
+    normalizePluginData,
+    normalizeReportFormats,
+    normalizeRunArgsInput,
+    normalizeRunContextCollectionShapes,
+    normalizeRunnerOptionCollectionShapes,
+    normalizeRuntimeHttpTrackingPayloadSource,
+    normalizeRuntimeTrackingPayload,
+    normalizeStringArray,
+    normalizeFailureArguments,
+    normalizeTrackingRunMode,
+    normalizeThresholdScope,
+    parseAliasDate,
+    parseMinimumLogLevelToken,
+    parseNodeTypeToken,
+    parseStrictBooleanToken,
+    percentile,
+    pickOptionalTrackingSelectorString,
+    pickTrackingNumber,
+    produceOrConsumeTrackingPayload,
+    readConfiguredSinkName,
+    readRuntimeRedisCorrelationStoreOptions,
+    readRuntimeTrackingId,
+    recordPluginLifecycleError,
+    requireNonEmpty,
+    attachScenarioStatsAliases,
+    attachNodeStatsAliases,
+    attachRunResultAliases,
+    resolveClusterExecutionMode,
+    resolveThresholdActualValue,
+    resetCrossPlatformReportRegistries,
+    resolveSinkDispose,
+    resolveSinkInit,
+    resolveSinkName,
+    resolveSinkSaveRealtimeMetrics,
+    resolveSinkSaveRealtimeStats,
+    resolveSinkSaveRunResult,
+    resolveSinkStart,
+    resolveSinkStop,
+    resolveWorkerPlugins,
+    runtimeParseBodyAsObject,
+    sanitizeReportFileName,
+    sanitizeTrackingNamespacePart,
+    setRuntimeJsonPathValue,
+    stripCaseInsensitivePrefix,
+    toBoolean,
+    toDetailedRunResultFromNodeStats,
+    toInt,
+    toNullableInt,
+    toNumber,
+    toRunContext,
+    toTrackingStringMap,
+    tryParseDotnetDurationMs,
+    tryParseMinimumLogLevelToken,
+    tryParseNodeTypeToken,
+    tryReadConfigValue,
+    validateNamedReportingSinks,
+    validateRegisteredScenarios,
+    validateRuntimeRedisCorrelationStoreConfiguration,
+    validateRuntimeTrackingConfiguration,
+    validateScenarioNames,
+    waitForTrackingOutcome,
+    withLifecycleErrors
+};