@loadstrike/loadstrike-sdk 1.0.30401 → 1.0.31601

package/dist/esm/runtime.js

@@ -7,9 +7,13 @@ import { DistributedClusterAgent, DistributedClusterCoordinator, buildLoadEngine
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector } from "./correlation.js";
 import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD } from "./transports.js";
 import { buildDotnetCsvReport, buildDotnetHtmlReport, buildDotnetMarkdownReport, buildDotnetTxtReport } from "./reporting.js";
+import { ReportHistoryCollector, ReportHistoryLifecycleCoordinator, ReportHistoryWorker, sanitizedExceptionClassChain } from "./report-history.js";
+import { distributedLocalReportInput, emptyLocalReportInput } from "./local-report-input.js";
 import { PortalReportingSink, cloneReportingSinkForRun } from "./sinks.js";
 import { LoadEngineV2ExecutionBudget, buildLoadEngineV2TrafficMixSeedId, LoadStrikeHistogramV1, parseLoadEngineV2HistogramArtifact, serializeLoadEngineV2HistogramArtifact, classifyLoadEngineV2Arrival, loadEngineV2FixedArrivalCount, loadEngineV2FixedDeadlineNs, loadEngineV2LatenessToleranceNs, loadEngineV2TrafficMixLaneUnitCount, loadEngineV2TrafficMixOwnedUnits, planRampingInjectionDeadlines, planRampingConstantDeadlines, planRandomInjectionDeadlines, fnv1a32 } from "./load-engine-v2.js";
 import { DEFAULT_ITERATION_OBSERVATION_SETTINGS, IterationObservationReporter, createIterationObservation, createIterationStepObservation, utcNowNs, validateIterationObservationSettings } from "./iteration-observations.js";
+import { logIterationObservationFailure, logIterationObservationRecovery } from "./iteration-observation-diagnostics.js";
+import { normalizeSinkRetryBackoffMs, normalizeSinkRetryCount, sinkRetryDelayMs, waitForSinkRetryDelay } from "./sink-retry-policy.js";
 const LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS = Symbol("loadstrike.load-engine-v2.scheduler-distributions");
 const PORTAL_RUN_TOKEN_PROVIDER = Symbol.for("loadstrike.internal.portal-run-token-provider");
 export const LoadStrikeNodeType = {
@@ -281,6 +285,28 @@ class MeasurementAccumulator {
             moreOrEq1200: left.moreOrEq1200 + right.moreOrEq1200
         }, allRequestCount, durationMs);
     }
+    /**
+     * Projects only the cumulative fields used by the private HTML-report
+     * history. Legacy distributions deliberately omit latency so this cadence
+     * path never scans their retained per-request arrays.
+     */
+    buildReportHistoryMeasurement() {
+        return projectNativeReportHistoryMeasurement(this.count, this.allBytes, this.useHistogram ? this.latencyHistogram : undefined);
+    }
+    /**
+     * Combines only bounded native latency state plus exact counters. It does
+     * not materialize status rows or any public measurement DTO.
+     */
+    buildCombinedReportHistoryMeasurement(other) {
+        const count = this.count + other.count;
+        const bytes = this.allBytes + other.allBytes;
+        if (!this.useHistogram || !other.useHistogram) {
+            return projectNativeReportHistoryMeasurement(count, bytes);
+        }
+        const latency = this.latencyHistogram.clone();
+        latency.merge(other.latencyHistogram);
+        return projectNativeReportHistoryMeasurement(count, bytes, latency);
+    }
     histogramSnapshot() {
         return {
             count: this.count,
@@ -294,6 +320,24 @@ class MeasurementAccumulator {
         };
     }
 }
+function projectNativeReportHistoryMeasurement(count, bytes, latency) {
+    const measurement = {
+        count,
+        bytes,
+        approximate: latency?.maxRelativeError !== undefined
+            && latency.maxRelativeError > 0
+    };
+    if (!latency || latency.count === 0n) {
+        return measurement;
+    }
+    return {
+        ...measurement,
+        percent50Ms: Number(latency.percentile(0.5)) / 1000,
+        percent75Ms: Number(latency.percentile(0.75)) / 1000,
+        percent95Ms: Number(latency.percentile(0.95)) / 1000,
+        percent99Ms: Number(latency.percentile(0.99)) / 1000
+    };
+}
 function buildHistogramMeasurement(snapshot, allRequestCount, durationMs) {
     const count = snapshot.count;
     const totalDurationMs = Math.max(durationMs, 0);
@@ -632,6 +676,21 @@ class ScenarioStatsAccumulator {
         step.record(reply, observedLatencyMs);
         return step.sortIndex;
     }
+    /**
+     * Captures the bounded, private history view without building scenario
+     * steps, status rows, plugins, aliases, or any other public result shape.
+     */
+    buildReportHistorySnapshot() {
+        const ok = this.ok.buildReportHistoryMeasurement();
+        const failed = this.fail.buildReportHistoryMeasurement();
+        return {
+            scenarioName: this.scenarioName,
+            sortIndex: this.sortIndex,
+            all: this.ok.buildCombinedReportHistoryMeasurement(this.fail),
+            ...(ok.count > 0 ? { ok } : {}),
+            ...(failed.count > 0 ? { failed } : {})
+        };
+    }
     /**
      * Builds the configured payload or helper object.
      * Use this when all builder inputs are ready to be materialized.
@@ -3427,8 +3486,8 @@ export class LoadStrikeRunner {
         }));
         const sinkErrors = [];
         const policyErrors = [];
-        const sinkRetryCount = Math.max(this.options.sinkRetryCount ?? 2, 0);
-        const sinkRetryBackoffMs = Math.max(this.options.sinkRetryBackoffMs ?? 25, 0);
+        const sinkRetryCount = normalizeSinkRetryCount(this.options.sinkRetryCount);
+        const sinkRetryBackoffMs = normalizeSinkRetryBackoffMs(this.options.sinkRetryBackoffMs);
         const policies = this.options.runtimePolicies ?? [];
         const runtimePolicyErrorMode = normalizedRuntimePolicyErrorMode(this.options.runtimePolicyErrorMode);
         const plugins = this.options.reportingSinks === undefined && this.options.workerPlugins === undefined &&
@@ -3479,6 +3538,58 @@ export class LoadStrikeRunner {
         licenseSession = await licenseClient.acquireLicenseLease(licensePayload);
         const loggerSetup = createLoggerSetup(this.options.loggerConfig, this.options.minimumLogLevel, this.options, testInfo, nodeInfo);
         const runLogger = loggerSetup.logger;
+        const htmlReportHistoryRequested = (this.options.reportsEnabled ?? true)
+            && normalizeReportFormats(this.options.reportFormats ?? ["html", "txt", "csv", "md"]).includes("html");
+        const distributedReportHistory = isDistributedReportHistoryExecution(clusterMode, this.options);
+        let localReportInput = htmlReportHistoryRequested
+            && distributedReportHistory
+            ? distributedLocalReportInput()
+            : emptyLocalReportInput();
+        let reportHistoryCollector;
+        let reportHistoryLifecycle;
+        if (htmlReportHistoryRequested && !distributedReportHistory) {
+            const warnReportHistoryFailure = (category, error) => {
+                const exceptionClasses = error === undefined
+                    ? ""
+                    : `; exception_classes=${sanitizedExceptionClassChain(error)}`;
+                try {
+                    runLogger.warn(`LoadStrike report history unavailable: ${category}${exceptionClasses}.`);
+                }
+                catch {
+                    // Report-only diagnostics are best-effort.
+                }
+            };
+            reportHistoryCollector = new ReportHistoryCollector({
+                scenarioCount: selectedScenarios.length,
+                onCaptureError: (error) => warnReportHistoryFailure("capture_failure", error)
+            });
+            if (!reportHistoryCollector.available) {
+                warnReportHistoryFailure("budget_pressure");
+            }
+            const snapshotFactory = () => Array.from(scenarioAccumulators.values())
+                .map((value) => value.buildReportHistorySnapshot())
+                .sort((left, right) => (left.sortIndex ?? 0) - (right.sortIndex ?? 0)
+                || left.scenarioName.localeCompare(right.scenarioName));
+            const reportHistoryWorker = new ReportHistoryWorker({
+                collector: reportHistoryCollector,
+                cadenceSeconds: resolvedReportHistoryCadenceSeconds(this.options.reportingIntervalSeconds ?? 5),
+                snapshotFactory,
+                onFailure: (category, exceptionClasses) => {
+                    try {
+                        runLogger.warn(`LoadStrike report history unavailable: ${category}; exception_classes=${exceptionClasses}.`);
+                    }
+                    catch {
+                        // Report-only diagnostics are best-effort.
+                    }
+                }
+            });
+            reportHistoryLifecycle = new ReportHistoryLifecycleCoordinator({
+                scenarioCount: selectedScenarios.length,
+                start: () => reportHistoryWorker.start(),
+                stopAndFinalize: () => reportHistoryWorker.stopAndFinalize(),
+                stopWithoutFinalizing: () => reportHistoryWorker.stopWithoutFinalizing()
+            });
+        }
         const scenarioStartInfos = selectedScenarios.map((scenario, index) => {
             const startInfo = {
                 scenarioName: scenario.name,
@@ -3522,14 +3633,14 @@ export class LoadStrikeRunner {
                 await init(baseContext, this.options.infraConfig ?? {});
             }
         }
-        await this.initializeSinks(sinkStates, baseContext, this.options.infraConfig ?? {}, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+        await this.initializeSinks(sinkStates, baseContext, this.options.infraConfig ?? {}, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
         for (const plugin of plugins) {
             const start = resolveWorkerPluginStart(plugin);
             if (start) {
                 await start(sessionInfo);
             }
         }
-        await this.startSinks(sinkStates, sessionInfo, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+        await this.startSinks(sinkStates, sessionInfo, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
         const iterationObservationRunId = String(this.internalOptions.iterationObservationRunId
             ?? sessionInfo.portalReportingRunId
             ?? sessionInfo.PortalReportingRunId
@@ -3560,7 +3671,10 @@ export class LoadStrikeRunner {
             expectedResultOwnerCount64: iterationObservationExpectedResultOwnerCount64,
             processGroup: iterationObservationProcessGroup,
             settings: resolveIterationObservationSettings(this.options),
-            sinks: reporterIterationObservationSinks
+            sinks: reporterIterationObservationSinks,
+            sinkRetryCount,
+            sinkRetryBackoffMs,
+            logger: runLogger
         });
         const emitRealtimeSnapshot = async () => {
             if (realtimeInFlight) {
@@ -3572,7 +3686,7 @@ export class LoadStrikeRunner {
                     .map((value) => value.build(scenarioDurationsMs.get(value.scenarioName) ?? Math.max(Date.now() - started.getTime(), 0)))
                     .sort((left, right) => left.sortIndex - right.sortIndex);
                 const metricsSnapshot = collectMetricStats(allRegisteredMetrics, Date.now() - started.getTime());
-                await this.emitRealtimeStats(sinkStates, snapshot, metricsSnapshot, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+                await this.emitRealtimeStats(sinkStates, snapshot, metricsSnapshot, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
                 if (toBoolean(this.options.displayConsoleMetrics, true)) {
                     const requestCount = snapshot.reduce((sum, value) => sum + value.allRequestCount, 0);
                     const okCount = snapshot.reduce((sum, value) => sum + value.allOkCount, 0);
@@ -3585,7 +3699,7 @@ export class LoadStrikeRunner {
                 realtimeInFlight = false;
             }
         };
-        const reportingIntervalMs = Math.max(Math.trunc((this.options.reportingIntervalSeconds ?? 5) * 1000), 1);
+        const reportingIntervalMs = boundedReportingIntervalMs(this.options.reportingIntervalSeconds ?? 5);
         const triggerRealtimeSnapshot = () => {
             if (realtimeCurrent) {
                 return;
@@ -3672,6 +3786,7 @@ export class LoadStrikeRunner {
                     iterationObservationRunId,
                     iterationObservationResultOwnerId,
                     iterationObservationProcessGroup,
+                    reportHistoryLifecycle,
                     executeScenarioInvocation: (targetScenario, context, operation) => this.executeScenarioInvocation(targetScenario, context, operation),
                     invokeBeforeScenario: (runtimePolicies, scenarioName) => this.invokeBeforeScenario(runtimePolicies, scenarioName, policyErrors, runtimePolicyErrorMode),
                     invokeAfterScenario: (runtimePolicies, scenarioName, stats) => this.invokeAfterScenario(runtimePolicies, scenarioName, stats, policyErrors, runtimePolicyErrorMode),
@@ -3759,12 +3874,17 @@ export class LoadStrikeRunner {
                 ...iterationObservationReporter.buildWarnings()
             ];
             result.pluginsData = mergePluginData(result.pluginsData, await this.collectPluginData(plugins, attachRunResultAliases(result), pluginLifecycleErrors));
+            if (reportHistoryCollector) {
+                localReportInput = {
+                    history: reportHistoryCollector.toProjection()
+                };
+            }
             const finalizedResult = attachRunResultAliases(result);
             finalizedResult.logFiles = mergeStringArrays(finalizedResult.logFiles, loggerSetup.logFiles);
-            finalizedResult.reportFiles = this.writeReports(finalizedResult);
+            finalizedResult.reportFiles = this.writeReports(finalizedResult, localReportInput);
             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);
+            await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
+            await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
             sinksStopped = true;
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
             finalizedResult.sinkErrors = sinkErrors
@@ -3772,12 +3892,13 @@ export class LoadStrikeRunner {
             return finalizedResult;
         }
         finally {
+            reportHistoryLifecycle?.stopWithoutFinalizing();
             await stopRealtimeReporting();
             if (!iterationObservationsFinalized) {
                 await iterationObservationReporter.sealAndDrain().catch(() => { });
             }
             if (!sinksStopped) {
-                await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+                await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
             }
             if (!pluginsStopped) {
                 await this.stopPlugins(plugins, pluginLifecycleErrors, runLogger);
@@ -4085,9 +4206,9 @@ export class LoadStrikeRunner {
         }
         return filtered;
     }
-    async initializeSinks(sinkStates, context, infraConfig, retryCount, retryBackoffMs, sinkErrors) {
+    async initializeSinks(sinkStates, context, infraConfig, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "init", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "init", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const init = resolveSinkInit(state.sink);
                 if (init) {
                     await init(context, infraConfig);
@@ -4095,9 +4216,9 @@ export class LoadStrikeRunner {
             });
         }
     }
-    async startSinks(sinkStates, session, retryCount, retryBackoffMs, sinkErrors) {
+    async startSinks(sinkStates, session, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "start", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "start", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const start = resolveSinkStart(state.sink);
                 if (start) {
                     await start(session);
@@ -4105,9 +4226,9 @@ export class LoadStrikeRunner {
             });
         }
     }
-    async emitRealtimeStats(sinkStates, scenarioStats, metrics, retryCount, retryBackoffMs, sinkErrors) {
+    async emitRealtimeStats(sinkStates, scenarioStats, metrics, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "realtime", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "realtime", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const saveRealtimeStats = resolveSinkSaveRealtimeStats(state.sink);
                 if (saveRealtimeStats) {
                     await saveRealtimeStats(scenarioStats);
@@ -4119,10 +4240,9 @@ export class LoadStrikeRunner {
             });
         }
     }
-    async stopSinks(sinkStates, retryCount, retryBackoffMs, sinkErrors) {
-        const shutdownRetryCount = 0;
+    async stopSinks(sinkStates, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "stop", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
+            await this.invokeSinkAction(state, "stop", retryCount, retryBackoffMs, sinkErrors, runId, logger, true, true, async () => {
                 const stop = resolveSinkStop(state.sink);
                 if (stop) {
                     await stop();
@@ -4130,15 +4250,15 @@ export class LoadStrikeRunner {
             });
             const dispose = resolveSinkDispose(state.sink);
             if (dispose) {
-                await this.invokeSinkAction(state, "dispose", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
+                await this.invokeSinkAction(state, "dispose", retryCount, retryBackoffMs, sinkErrors, runId, logger, true, true, async () => {
                     await dispose();
                 });
             }
         }
     }
-    async emitRunResult(sinkStates, result, retryCount, retryBackoffMs, sinkErrors) {
+    async emitRunResult(sinkStates, result, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "run-result", retryCount, retryBackoffMs, sinkErrors, false, false, async () => {
+            await this.invokeSinkAction(state, "run-result", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, false, async () => {
                 const saveRunResult = resolveSinkSaveRunResult(state.sink);
                 if (saveRunResult) {
                     await saveRunResult(result);
@@ -4146,23 +4266,49 @@ export class LoadStrikeRunner {
             });
         }
     }
-    async invokeSinkAction(state, phase, retryCount, retryBackoffMs, sinkErrors, ignoreDisabled, disableOnFailure, action) {
+    async invokeSinkAction(state, phase, retryCount, retryBackoffMs, sinkErrors, runId, logger, ignoreDisabled, disableOnFailure, action) {
         if (state.disabled && !ignoreDisabled) {
             return;
         }
-        let attempts = 0;
-        while (attempts <= retryCount) {
-            attempts += 1;
+        const maximumAttempts = normalizeSinkRetryCount(retryCount) + 1;
+        const backoffMs = normalizeSinkRetryBackoffMs(retryBackoffMs);
+        for (let attempts = 1; attempts <= maximumAttempts; attempts += 1) {
             try {
                 await action();
+                if (attempts > 1) {
+                    logIterationObservationRecovery(logger, {
+                        sinkName: state.name,
+                        operation: "reporting-sink-action",
+                        phase,
+                        runId,
+                        resultOwnerId: "",
+                        observationCount: 0,
+                        attempt: attempts,
+                        maximumAttempts,
+                        nextDelayMs: 0
+                    });
+                }
                 return;
             }
             catch (error) {
-                if (attempts > retryCount) {
+                const exhausted = attempts >= maximumAttempts;
+                const nextDelayMs = exhausted ? 0 : sinkRetryDelayMs(backoffMs, attempts);
+                logIterationObservationFailure(logger, exhausted ? "error" : "warn", {
+                    sinkName: state.name,
+                    operation: "reporting-sink-action",
+                    phase,
+                    runId,
+                    resultOwnerId: "",
+                    observationCount: 0,
+                    attempt: attempts,
+                    maximumAttempts,
+                    nextDelayMs
+                }, error);
+                if (exhausted) {
                     sinkErrors.push({
                         sinkName: state.name,
                         phase,
-                        message: String(error ?? "sink action failed"),
+                        message: "The reporting sink action failed after retries.",
                         attempts
                     });
                     if (disableOnFailure) {
@@ -4170,9 +4316,7 @@ export class LoadStrikeRunner {
                     }
                     return;
                 }
-                if (retryBackoffMs > 0) {
-                    await sleep(retryBackoffMs * attempts);
-                }
+                await waitForSinkRetryDelay(nextDelayMs);
             }
         }
     }
@@ -4226,7 +4370,7 @@ export class LoadStrikeRunner {
             message: String(error ?? "runtime policy callback failed")
         });
     }
-    writeReports(result) {
+    writeReports(result, localReportInput = emptyLocalReportInput()) {
         const reportsEnabled = this.options.reportsEnabled ?? true;
         if (!reportsEnabled) {
             return [];
@@ -4251,7 +4395,7 @@ export class LoadStrikeRunner {
                 writeFileSync(path, buildDotnetMarkdownReport(nodeStats), "utf8");
             }
             else if (format === "html") {
-                writeFileSync(path, buildDotnetHtmlReport(nodeStats), "utf8");
+                writeFileSync(path, buildDotnetHtmlReport(nodeStats, localReportInput), "utf8");
             }
             written.push(path);
         }
@@ -4284,6 +4428,19 @@ function hasPluginRows(value) {
     }
     return value.tables.some((table) => Array.isArray(table.rows) && table.rows.length > 0);
 }
+function boundedReportingIntervalMs(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return 1;
+    }
+    const milliseconds = seconds * 1000;
+    if (!Number.isFinite(milliseconds) || milliseconds >= 2147483647) {
+        return 2147483647;
+    }
+    return Math.max(Math.trunc(milliseconds), 1);
+}
+function resolvedReportHistoryCadenceSeconds(seconds) {
+    return boundedReportingIntervalMs(seconds) / 1000;
+}
 async function executeV2FixedArrivals(args) {
     const { rate, intervalNs, totalArrivals, budget, cancellationToken, shouldStopNow, nextInstanceInfo, runBombingInvocation, logger, scenarioName, deadlineOffsetsNs, tolerancesNs, ownedOrdinals, shardIndex = 0, shardCount = 1, telemetry, segment } = args;
     const segmentStartNs = process.hrtime.bigint();
@@ -4420,7 +4577,15 @@ function maxBigInt(left, right) {
     return left > right ? left : right;
 }
 async function executeScenarioRuntime(args) {
-    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, loadEngineV2Budget, loadEngineV2Telemetry, iterationObservationReporter, iterationObservationRunId = testInfo.sessionId, iterationObservationResultOwnerId = "", iterationObservationProcessGroup = 0, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
+    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, loadEngineV2Budget, loadEngineV2Telemetry, iterationObservationReporter, iterationObservationRunId = testInfo.sessionId, iterationObservationResultOwnerId = "", iterationObservationProcessGroup = 0, reportHistoryLifecycle, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
+    let reportHistoryExecutionEnded = false;
+    const endReportHistoryExecution = async () => {
+        if (reportHistoryExecutionEnded) {
+            return;
+        }
+        reportHistoryExecutionEnded = true;
+        await reportHistoryLifecycle?.scenarioExecutionEnded();
+    };
     const scenarioStartedMs = Date.now();
     const scenarioContextData = {};
     const registeredMetrics = [];
@@ -4581,7 +4746,18 @@ async function executeScenarioRuntime(args) {
         attachScenarioContextAliases(context);
         const startedUtcNs = utcNowNs();
         const startedAtNs = process.hrtime.bigint();
-        const reply = await executeScenarioInvocation(scenario, context, operation);
+        let policyFailure;
+        let reply;
+        try {
+            reply = await executeScenarioInvocation(scenario, context, operation);
+        }
+        catch (error) {
+            if (!(error instanceof RuntimePolicyCallbackError)) {
+                throw error;
+            }
+            policyFailure = error;
+            reply = LoadStrikeResponse.fail("runtime_policy_error", "", 0);
+        }
         const observedLatencyNs = maxBigInt(process.hrtime.bigint() - startedAtNs, 0n);
         const completedUtcNs = startedUtcNs + observedLatencyNs;
         const observedLatencyMs = Number(observedLatencyNs) / 1000000;
@@ -4596,7 +4772,8 @@ async function executeScenarioRuntime(args) {
             observedLatencyUs: observedLatencyNs / 1000n,
             reportedLatencyUs: normalizeRawObservationLatencyMicroseconds(resolveRecordedLatency(reply.customLatencyMs, observedLatencyMs)),
             steps: attemptSteps,
-            recordedSteps
+            recordedSteps,
+            ...(policyFailure ? { policyFailure } : {})
         };
     };
     const captureAttemptObservation = (operation, globalOrdinal, attemptIndex, isFinalAttempt, attempt, simulationIndex, simulationKind, iterationId, globalSecondaryOrdinal = 0n) => {
@@ -4645,22 +4822,18 @@ async function executeScenarioRuntime(args) {
         const maxAttempts = 1 + (scenario.shouldRestartIterationOnFail() ? restartIterationMaxAttempts : 0);
         while (attempts < maxAttempts && !shouldStopNow()) {
             attempts += 1;
-            let attempt;
-            try {
-                attempt = await runSingleInvocation("Bombing", instanceData, instanceNumber, instanceId, false);
-            }
-            catch (error) {
-                if (error instanceof RuntimePolicyCallbackError) {
-                    stopScenario = true;
-                    scenarioAbortController.abort(error);
-                }
-                throw error;
-            }
-            const shouldRetry = !attempt.reply.isSuccess
+            const attempt = await runSingleInvocation("Bombing", instanceData, instanceNumber, instanceId, false);
+            const shouldRetry = !attempt.policyFailure
+                && !attempt.reply.isSuccess
                 && scenario.shouldRestartIterationOnFail()
                 && attempts < maxAttempts
                 && !shouldStopNow();
             captureAttemptObservation("Bombing", globalOrdinal, attempts - 1, !shouldRetry, attempt, simulationIndex, simulationKind, iterationId, explicitSecondaryOrdinal);
+            if (attempt.policyFailure) {
+                stopScenario = true;
+                scenarioAbortController.abort(attempt.policyFailure);
+                throw attempt.policyFailure;
+            }
             if (!shouldRetry) {
                 for (const step of attempt.recordedSteps) {
                     recordStepReply(step.stepName, step.reply, step.observedLatencyMs, step.sortIndex);
@@ -4687,6 +4860,11 @@ async function executeScenarioRuntime(args) {
             const globalOrdinal = nextObservationOrdinal();
             const attempt = await runSingleInvocation("WarmUp", instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, false);
             captureAttemptObservation("WarmUp", globalOrdinal, 0, true, attempt, -1, "SingleInvocation");
+            if (attempt.policyFailure) {
+                stopScenario = true;
+                scenarioAbortController.abort(attempt.policyFailure);
+                throw attempt.policyFailure;
+            }
         }
     };
     const executeV2TimedConstant = async (copies, durationNs, ramping, runSimulationInvocation, segment) => {
@@ -5228,6 +5406,7 @@ async function executeScenarioRuntime(args) {
         })));
         await invokeBeforeScenario(policies, scenario.name);
         await runWarmUpAsync();
+        reportHistoryLifecycle?.scenarioBombingStarted();
         accumulator.setCurrentOperation("Bombing");
         const simulations = scenario.getSimulations();
         if (!simulations.length) {
@@ -5261,6 +5440,7 @@ async function executeScenarioRuntime(args) {
             }
         }
         accumulator.setCurrentOperation(stopScenario || stopTestState.value ? "Stop" : "Complete");
+        await endReportHistoryExecution();
         await invokeAfterScenario(policies, scenario.name, runtime);
     }
     catch (error) {
@@ -5277,6 +5457,7 @@ async function executeScenarioRuntime(args) {
         }
     }
     finally {
+        await endReportHistoryExecution();
         scenarioDurationsMs.set(scenario.name, Math.max(Date.now() - scenarioStartedMs, 0));
         try {
             await scenario.invokeClean({
@@ -5357,10 +5538,17 @@ async function waitForScenarioTasks(tasks, scenarioName, timeoutSeconds, logger,
         throwPolicyFailure(await settled);
         return;
     }
-    const completed = await Promise.race([
-        settled.then(() => true),
-        delayWithAbort(Math.trunc(timeoutSeconds * 1000), signal).then(() => false)
-    ]);
+    const timeoutController = new AbortController();
+    let completed;
+    try {
+        completed = await Promise.race([
+            settled.then(() => true),
+            delayWithAbort(Math.trunc(timeoutSeconds * 1000), combineAbortSignals(signal, timeoutController.signal)).then(() => false)
+        ]);
+    }
+    finally {
+        timeoutController.abort();
+    }
     if (!completed) {
         if (signal.reason instanceof RuntimePolicyCallbackError) {
             throw signal.reason;
@@ -7203,6 +7391,11 @@ function resolveClusterExecutionMode(options) {
     }
     return "single";
 }
+function isDistributedReportHistoryExecution(clusterMode, options) {
+    return clusterMode !== "single"
+        || options.loadEngineV2SegmentLifecycleOverride !== undefined
+        || Math.max(Math.trunc(options.clusterShardCount ?? 1), 1) > 1;
+}
 function buildEmptyNodeStats(args) {
     return attachNodeStatsAliases({
         startedUtc: args.startedUtc,
@@ -9422,11 +9615,23 @@ function readRuntimeTrackingId(payload, selector) {
             return null;
         }
         let current = body;
-        for (const segment of selector.slice("json:".length).trim().replace(/^\$\./, "").split(".").filter(Boolean)) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        let segments;
+        try {
+            segments = runtimeSafeJsonPathSegments(path);
+        }
+        catch {
+            return null;
+        }
+        for (const segment of segments) {
             if (!current || typeof current !== "object" || Array.isArray(current)) {
                 return null;
             }
-            current = current[segment];
+            const record = current;
+            if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+                return null;
+            }
+            current = runtimeReadOwnJsonProperty(record, segment);
         }
         return current == null ? null : String(current);
     }
@@ -9450,23 +9655,57 @@ function runtimeParseBodyAsObject(body) {
     }
 }
 function setRuntimeJsonPathValue(body, path, value) {
-    const target = body && typeof body === "object" && !Array.isArray(body)
-        ? { ...body }
-        : {};
-    const segments = path.split(".").filter(Boolean);
+    const target = runtimeCloneJsonRecord(body);
+    const segments = runtimeSafeJsonPathSegments(path);
     if (!segments.length) {
         return target;
     }
     let current = target;
     for (let i = 0; i < segments.length - 1; i += 1) {
         const segment = segments[i];
-        const next = current[segment];
+        const next = runtimeReadOwnJsonProperty(current, segment);
+        let child;
         if (!next || typeof next !== "object" || Array.isArray(next)) {
-            current[segment] = {};
+            child = {};
         }
-        current = current[segment];
+        else {
+            child = runtimeCloneJsonRecord(next);
+        }
+        runtimeDefineJsonProperty(current, segment, child);
+        current = child;
+    }
+    runtimeDefineJsonProperty(current, segments[segments.length - 1], value);
+    return target;
+}
+const FORBIDDEN_RUNTIME_JSON_PATH_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function runtimeSafeJsonPathSegments(path) {
+    const segments = path.split(".").filter(Boolean);
+    const forbidden = segments.find((segment) => FORBIDDEN_RUNTIME_JSON_PATH_SEGMENTS.has(segment));
+    if (forbidden) {
+        throw new Error(`Tracking selector contains forbidden JSON path segment '${forbidden}'.`);
+    }
+    return segments;
+}
+function runtimeDefineJsonProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+    });
+}
+function runtimeReadOwnJsonProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function runtimeCloneJsonRecord(value) {
+    const target = {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return target;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        runtimeDefineJsonProperty(target, key, entry);
     }
-    current[segments[segments.length - 1]] = value;
     return target;
 }
 function asTrackingRecord(value) {
@@ -9476,8 +9715,8 @@ function asTrackingRecord(value) {
 }
 function pickTrackingValue(source, ...keys) {
     for (const key of keys) {
-        if (key in source) {
-            return source[key];
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            return runtimeReadOwnJsonProperty(source, key);
         }
     }
     return undefined;
@@ -9731,26 +9970,10 @@ function createDefaultLogger(logFilePath) {
 function wrapLoggerWithMinimumLevel(baseLogger, minimumLogLevel) {
     const threshold = logLevelOrder(minimumLogLevel);
     return {
-        debug: (message) => {
-            if (threshold <= 0) {
-                baseLogger.debug(message);
-            }
-        },
-        info: (message) => {
-            if (threshold <= 1) {
-                baseLogger.info(message);
-            }
-        },
-        warn: (message) => {
-            if (threshold <= 2) {
-                baseLogger.warn(message);
-            }
-        },
-        error: (message) => {
-            if (threshold <= 3) {
-                baseLogger.error(message);
-            }
-        }
+        debug: (message) => threshold <= 0 ? baseLogger.debug(message) : undefined,
+        info: (message) => threshold <= 1 ? baseLogger.info(message) : undefined,
+        warn: (message) => threshold <= 2 ? baseLogger.warn(message) : undefined,
+        error: (message) => threshold <= 3 ? baseLogger.error(message) : undefined
     };
 }
 function formatDefaultLoggerLine(level, message) {
@@ -11004,6 +11227,7 @@ function buildGroupedCorrelationRows(rows) {
             LatencyMinMs: latencySamples.length ? formatOptionalLatency(latencySamples[0]) : "",
             LatencyMeanMs: latencySamples.length ? formatOptionalLatency(latencySamples.reduce((sum, value) => sum + value, 0) / latencySamples.length) : "",
             LatencyP50Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.5)) : "",
+            LatencyP75Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.75)) : "",
             LatencyP80Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.8)) : "",
             LatencyP85Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.85)) : "",
             LatencyP90Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.9)) : "",
@@ -11216,6 +11440,8 @@ export const __loadstrikeTestExports = {
     buildThresholdCheckExpression,
     buildTrackingLeaseKey,
     buildTrackingRunNamespace,
+    boundedReportingIntervalMs,
+    resolvedReportHistoryCadenceSeconds,
     clusterNodeResultToNodeStats,
     combineAbortSignals,
     computeScenarioRequestCount,
@@ -11235,6 +11461,7 @@ export const __loadstrikeTestExports = {
     formatUtcReportTimestamp,
     hasPluginRows,
     inferRuntimeLegacyHttpResponseSource,
+    isDistributedReportHistoryExecution,
     isComparisonFailed,
     loadJsonObject,
     logLevelOrder,
@@ -11264,6 +11491,7 @@ export const __loadstrikeTestExports = {
     parseStrictBooleanToken,
     percentile,
     pickOptionalTrackingSelectorString,
+    pickTrackingValue,
     pickTrackingNumber,
     produceOrConsumeTrackingPayload,
     readConfiguredSinkName,