@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.32601

package/dist/cjs/runtime.js

@@ -13,13 +13,18 @@ const cluster_js_1 = require("./cluster.js");
 const correlation_js_1 = require("./correlation.js");
 const transports_js_1 = require("./transports.js");
 const reporting_js_1 = require("./reporting.js");
+const report_history_js_1 = require("./report-history.js");
+const local_report_input_js_1 = require("./local-report-input.js");
 const sinks_js_1 = require("./sinks.js");
+const reporting_sink_http_error_js_1 = require("./internal/reporting-sink-http-error.js");
+const reporting_containment_js_1 = require("./reporting-containment.js");
 const load_engine_v2_js_1 = require("./load-engine-v2.js");
 const iteration_observations_js_1 = require("./iteration-observations.js");
 const iteration_observation_diagnostics_js_1 = require("./iteration-observation-diagnostics.js");
 const sink_retry_policy_js_1 = require("./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");
+const REPORTING_INTERVAL_SECONDS = Symbol.for("loadstrike.internal.reporting-interval-seconds");
 exports.LoadStrikeNodeType = {
     SingleNode: "SingleNode",
     Coordinator: "Coordinator",
@@ -291,6 +296,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,
@@ -304,6 +331,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);
@@ -642,6 +687,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.
@@ -690,6 +750,15 @@ class ScenarioStatsAccumulator {
         return attachScenarioStatsAliases(scenario);
     }
 }
+function isRetryableReportingSinkError(sink, error) {
+    if (!(sink instanceof sinks_js_1.PrometheusRemoteWriteReportingSink)) {
+        return true;
+    }
+    if (!(error instanceof reporting_sink_http_error_js_1.ReportingSinkHttpError)) {
+        return true;
+    }
+    return error.status === 429 || error.status < 400 || error.status >= 500;
+}
 class LoadStrikeResponse {
     /**
      * Creates a successful reply.
@@ -3438,6 +3507,8 @@ class LoadStrikeRunner {
         return this.buildContext();
     }
     async run(args = []) {
+        (0, reporting_containment_js_1.assertNoUnsupportedReportingSinkGraph)(this.options.reportingSinks ?? []);
+        assertNoUnsupportedNativeTrackingScenarios(this.scenarios);
         if (this.contextConfigurators.length) {
             return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions(), [], this.internalOptions).run(args);
         }
@@ -3449,7 +3520,7 @@ class LoadStrikeRunner {
         const scenarioAccumulators = new Map();
         const scenarioDurationsMs = new Map();
         const stepStats = new Map();
-        const sinks = (this.options.reportingSinks ?? []).map((sink) => (0, sinks_js_1.cloneReportingSinkForRun)(sink));
+        const sinks = (this.options.reportingSinks ?? []).map((sink) => (0, sinks_js_1.cloneReportingSinkForRun)(sink, this.options.infraConfig ?? {}));
         const sinkStates = sinks.map((sink, index) => ({
             sink,
             disabled: false,
@@ -3509,6 +3580,58 @@ 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
+            ? (0, local_report_input_js_1.distributedLocalReportInput)()
+            : (0, local_report_input_js_1.emptyLocalReportInput)();
+        let reportHistoryCollector;
+        let reportHistoryLifecycle;
+        if (htmlReportHistoryRequested && !distributedReportHistory) {
+            const warnReportHistoryFailure = (category, error) => {
+                const exceptionClasses = error === undefined
+                    ? ""
+                    : `; exception_classes=${(0, report_history_js_1.sanitizedExceptionClassChain)(error)}`;
+                try {
+                    runLogger.warn(`LoadStrike report history unavailable: ${category}${exceptionClasses}.`);
+                }
+                catch {
+                    // Report-only diagnostics are best-effort.
+                }
+            };
+            reportHistoryCollector = new report_history_js_1.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 report_history_js_1.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 report_history_js_1.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,6 +3645,12 @@ class LoadStrikeRunner {
             testInfo,
             getNodeInfo: () => attachNodeInfoAliases({ ...nodeInfo })
         };
+        Object.defineProperty(baseContext, REPORTING_INTERVAL_SECONDS, {
+            value: this.options.reportingIntervalSeconds ?? 5,
+            enumerable: false,
+            configurable: false,
+            writable: false
+        });
         attachBaseContextAliases(baseContext);
         const sinkSession = {
             startedUtc: createdUtc,
@@ -3576,6 +3705,7 @@ class LoadStrikeRunner {
             name: state.name,
             iterationObservationPortalSink: Boolean(state.sink.iterationObservationPortalSink),
             iterationObservationShapeLimited: Boolean(state.sink.iterationObservationShapeLimited),
+            retryableErrorClassifier: (error) => isRetryableReportingSinkError(state.sink, error),
             saveIterationBatch: resolveSinkSaveIterationBatch(state.sink),
             completeIterationObservationStream: resolveSinkCompleteIterationObservationStream(state.sink)
         }));
@@ -3618,7 +3748,7 @@ 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;
@@ -3705,6 +3835,7 @@ 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),
@@ -3792,9 +3923,14 @@ 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, testInfo.sessionId, runLogger);
             await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
@@ -3805,6 +3941,7 @@ class LoadStrikeRunner {
             return finalizedResult;
         }
         finally {
+            reportHistoryLifecycle?.stopWithoutFinalizing();
             await stopRealtimeReporting();
             if (!iterationObservationsFinalized) {
                 await iterationObservationReporter.sealAndDrain().catch(() => { });
@@ -4203,7 +4340,9 @@ class LoadStrikeRunner {
                 return;
             }
             catch (error) {
-                const exhausted = attempts >= maximumAttempts;
+                const retryable = isRetryableReportingSinkError(state.sink, error);
+                const exhausted = attempts >= maximumAttempts || !retryable;
+                const reportedMaximumAttempts = retryable ? maximumAttempts : attempts;
                 const nextDelayMs = exhausted ? 0 : (0, sink_retry_policy_js_1.sinkRetryDelayMs)(backoffMs, attempts);
                 (0, iteration_observation_diagnostics_js_1.logIterationObservationFailure)(logger, exhausted ? "error" : "warn", {
                     sinkName: state.name,
@@ -4213,7 +4352,7 @@ class LoadStrikeRunner {
                     resultOwnerId: "",
                     observationCount: 0,
                     attempt: attempts,
-                    maximumAttempts,
+                    maximumAttempts: reportedMaximumAttempts,
                     nextDelayMs
                 }, error);
                 if (exhausted) {
@@ -4282,7 +4421,7 @@ class LoadStrikeRunner {
             message: String(error ?? "runtime policy callback failed")
         });
     }
-    writeReports(result) {
+    writeReports(result, localReportInput = (0, local_report_input_js_1.emptyLocalReportInput)()) {
         const reportsEnabled = this.options.reportsEnabled ?? true;
         if (!reportsEnabled) {
             return [];
@@ -4307,7 +4446,7 @@ class LoadStrikeRunner {
                 (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetMarkdownReport)(nodeStats), "utf8");
             }
             else if (format === "html") {
-                (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetHtmlReport)(nodeStats), "utf8");
+                (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetHtmlReport)(nodeStats, localReportInput), "utf8");
             }
             written.push(path);
         }
@@ -4341,6 +4480,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();
@@ -4477,7 +4629,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 = [];
@@ -5298,6 +5458,7 @@ async function executeScenarioRuntime(args) {
         })));
         await invokeBeforeScenario(policies, scenario.name);
         await runWarmUpAsync();
+        reportHistoryLifecycle?.scenarioBombingStarted();
         accumulator.setCurrentOperation("Bombing");
         const simulations = scenario.getSimulations();
         if (!simulations.length) {
@@ -5331,6 +5492,7 @@ async function executeScenarioRuntime(args) {
             }
         }
         accumulator.setCurrentOperation(stopScenario || stopTestState.value ? "Stop" : "Complete");
+        await endReportHistoryExecution();
         await invokeAfterScenario(policies, scenario.name, runtime);
     }
     catch (error) {
@@ -5347,6 +5509,7 @@ async function executeScenarioRuntime(args) {
         }
     }
     finally {
+        await endReportHistoryExecution();
         scenarioDurationsMs.set(scenario.name, Math.max(Date.now() - scenarioStartedMs, 0));
         try {
             await scenario.invokeClean({
@@ -7280,6 +7443,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,
@@ -8751,6 +8919,7 @@ class ManagedScenarioTrackingRuntime {
     }
     async dispose() {
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         this.rejectOutstandingWaiters();
         await Promise.all([
             this.sourceLoop,
@@ -8816,6 +8985,7 @@ class ManagedScenarioTrackingRuntime {
             failureSeen = failureSeen || this.isFailedObservationOutcome(outcome);
         }
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         await Promise.all([
             this.sourceLoop,
             this.destinationLoop,
@@ -8832,6 +9002,20 @@ class ManagedScenarioTrackingRuntime {
             ? LoadStrikeResponse.fail("tracking_failures", "One or more observed source or destination events did not correlate successfully.", 0)
             : LoadStrikeResponse.ok("observed");
     }
+    interruptEndpointAdapters() {
+        try {
+            this.sourceAdapter.interrupt?.();
+        }
+        catch {
+            // Shutdown remains best-effort and still disposes every adapter below.
+        }
+        try {
+            this.destinationAdapter?.interrupt?.();
+        }
+        catch {
+            // Shutdown remains best-effort and still disposes every adapter below.
+        }
+    }
     async consumeSourceLoop() {
         while (!this.shutdown) {
             try {
@@ -9423,6 +9607,20 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
         azureEventHubs: asTrackingRecord(pickTrackingValue(spec, "AzureEventHubs", "azureEventHubs")),
         sqs: asTrackingRecord(pickTrackingValue(spec, "Sqs", "sqs")),
         pushDiffusion: asTrackingRecord(pickTrackingValue(spec, "PushDiffusion", "pushDiffusion")),
+        grpc: mapRuntimeEndpointProtocolOptions(spec, ["Grpc", "grpc"], [
+            "Target", "target", "ServiceName", "serviceName", "MethodName", "methodName",
+            "MethodType", "methodType", "Deadline", "deadline", "DeadlineSeconds", "deadlineSeconds",
+            "DeadlineMs", "deadlineMs", "Metadata", "metadata", "Produce", "produce", "Consume", "consume",
+            "ProduceAsync", "produceAsync", "ConsumeAsync", "consumeAsync", "ConnectionMetadata", "connectionMetadata",
+            "NativeClient", "nativeClient"
+        ]),
+        webSocket: mapRuntimeEndpointProtocolOptions(spec, ["WebSocket", "webSocket"], [
+            "Url", "url", "Subprotocols", "subprotocols", "ConnectTimeout", "connectTimeout",
+            "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeoutMs", "connectTimeoutMs",
+            "CloseTimeout", "closeTimeout", "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeoutMs", "closeTimeoutMs",
+            "Produce", "produce", "Consume", "consume", "ProduceAsync", "produceAsync", "ConsumeAsync", "consumeAsync",
+            "ConnectionMetadata", "connectionMetadata", "NativeClient", "nativeClient"
+        ]),
         delegate: typeof delegateProduce === "function"
             || typeof delegateConsume === "function"
             || typeof delegateProduceAsync === "function"
@@ -9445,6 +9643,19 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
             : undefined
     };
 }
+function mapRuntimeEndpointProtocolOptions(spec, nestedKeys, flatKeys) {
+    const nested = asTrackingRecord(pickTrackingValue(spec, ...nestedKeys));
+    if (Object.keys(nested).length > 0) {
+        return nested;
+    }
+    const options = {};
+    for (const key of flatKeys) {
+        if (Object.prototype.hasOwnProperty.call(spec, key)) {
+            options[key] = pickTrackingValue(spec, key);
+        }
+    }
+    return options;
+}
 function normalizeRuntimeTrackingPayload(payload, endpoint, index) {
     const normalized = {
         headers: {
@@ -10208,6 +10419,20 @@ function assertNoDisableLicenseEnforcementOption(value, source) {
         }
     }
 }
+function assertNoUnsupportedNativeTrackingScenarios(scenarios) {
+    for (const scenario of scenarios) {
+        const tracking = scenario.getTrackingConfiguration();
+        if (!tracking) {
+            continue;
+        }
+        for (const field of ["Source", "Destination"]) {
+            const endpoint = asTrackingRecord(pickTrackingValue(tracking, field, field.toLowerCase()));
+            if (Object.keys(endpoint).length > 0) {
+                (0, transports_js_1.validateNativeEndpointExecutionSupport)(endpoint);
+            }
+        }
+    }
+}
 function normalizeRunContextCollectionShapes(values) {
     assertNoDisableLicenseEnforcementOption(values, "LoadStrikeContext");
     const normalized = {
@@ -11111,6 +11336,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)) : "",
@@ -11323,6 +11549,8 @@ exports.__loadstrikeTestExports = {
     buildThresholdCheckExpression,
     buildTrackingLeaseKey,
     buildTrackingRunNamespace,
+    boundedReportingIntervalMs,
+    resolvedReportHistoryCadenceSeconds,
     clusterNodeResultToNodeStats,
     combineAbortSignals,
     computeScenarioRequestCount,
@@ -11342,6 +11570,7 @@ exports.__loadstrikeTestExports = {
     formatUtcReportTimestamp,
     hasPluginRows,
     inferRuntimeLegacyHttpResponseSource,
+    isDistributedReportHistoryExecution,
     isComparisonFailed,
     loadJsonObject,
     logLevelOrder,