@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.32601

package/dist/esm/runtime.js

@@ -5,15 +5,20 @@ import { resolve } from "node:path";
 import { LoadStrikeLocalClient } from "./local.js";
 import { DistributedClusterAgent, DistributedClusterCoordinator, buildLoadEngineV2ReservedStepOtherIdentityKey, buildLoadEngineV2GlobalInvocationId, buildLoadEngineV2ScenarioIdentityKey, buildLoadEngineV2SchedulerIdentityKey, buildLoadEngineV2StatusIdentityKey, buildLoadEngineV2StepIdentityKey, resolveLoadEngineV2StepIdentityKey, buildLoadEngineV2Plan } from "./cluster.js";
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector } from "./correlation.js";
-import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD } from "./transports.js";
+import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, validateNativeEndpointExecutionSupport } from "./transports.js";
 import { buildDotnetCsvReport, buildDotnetHtmlReport, buildDotnetMarkdownReport, buildDotnetTxtReport } from "./reporting.js";
-import { PortalReportingSink, cloneReportingSinkForRun } from "./sinks.js";
+import { ReportHistoryCollector, ReportHistoryLifecycleCoordinator, ReportHistoryWorker, sanitizedExceptionClassChain } from "./report-history.js";
+import { distributedLocalReportInput, emptyLocalReportInput } from "./local-report-input.js";
+import { PortalReportingSink, PrometheusRemoteWriteReportingSink, cloneReportingSinkForRun } from "./sinks.js";
+import { ReportingSinkHttpError } from "./internal/reporting-sink-http-error.js";
+import { assertNoUnsupportedReportingSinkGraph } from "./reporting-containment.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");
+const REPORTING_INTERVAL_SECONDS = Symbol.for("loadstrike.internal.reporting-interval-seconds");
 export const LoadStrikeNodeType = {
     SingleNode: "SingleNode",
     Coordinator: "Coordinator",
@@ -283,6 +288,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,
@@ -296,6 +323,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);
@@ -634,6 +679,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.
@@ -682,6 +742,15 @@ class ScenarioStatsAccumulator {
         return attachScenarioStatsAliases(scenario);
     }
 }
+function isRetryableReportingSinkError(sink, error) {
+    if (!(sink instanceof PrometheusRemoteWriteReportingSink)) {
+        return true;
+    }
+    if (!(error instanceof ReportingSinkHttpError)) {
+        return true;
+    }
+    return error.status === 429 || error.status < 400 || error.status >= 500;
+}
 export class LoadStrikeResponse {
     /**
      * Creates a successful reply.
@@ -3410,6 +3479,8 @@ export class LoadStrikeRunner {
         return this.buildContext();
     }
     async run(args = []) {
+        assertNoUnsupportedReportingSinkGraph(this.options.reportingSinks ?? []);
+        assertNoUnsupportedNativeTrackingScenarios(this.scenarios);
         if (this.contextConfigurators.length) {
             return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions(), [], this.internalOptions).run(args);
         }
@@ -3421,7 +3492,7 @@ export class LoadStrikeRunner {
         const scenarioAccumulators = new Map();
         const scenarioDurationsMs = new Map();
         const stepStats = new Map();
-        const sinks = (this.options.reportingSinks ?? []).map((sink) => cloneReportingSinkForRun(sink));
+        const sinks = (this.options.reportingSinks ?? []).map((sink) => cloneReportingSinkForRun(sink, this.options.infraConfig ?? {}));
         const sinkStates = sinks.map((sink, index) => ({
             sink,
             disabled: false,
@@ -3481,6 +3552,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,
@@ -3494,6 +3617,12 @@ export 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,
@@ -3548,6 +3677,7 @@ export 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)
         }));
@@ -3590,7 +3720,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;
@@ -3677,6 +3807,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),
@@ -3764,9 +3895,14 @@ 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, testInfo.sessionId, runLogger);
             await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
@@ -3777,6 +3913,7 @@ export class LoadStrikeRunner {
             return finalizedResult;
         }
         finally {
+            reportHistoryLifecycle?.stopWithoutFinalizing();
             await stopRealtimeReporting();
             if (!iterationObservationsFinalized) {
                 await iterationObservationReporter.sealAndDrain().catch(() => { });
@@ -4175,7 +4312,9 @@ export 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 : sinkRetryDelayMs(backoffMs, attempts);
                 logIterationObservationFailure(logger, exhausted ? "error" : "warn", {
                     sinkName: state.name,
@@ -4185,7 +4324,7 @@ export class LoadStrikeRunner {
                     resultOwnerId: "",
                     observationCount: 0,
                     attempt: attempts,
-                    maximumAttempts,
+                    maximumAttempts: reportedMaximumAttempts,
                     nextDelayMs
                 }, error);
                 if (exhausted) {
@@ -4254,7 +4393,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 [];
@@ -4279,7 +4418,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);
         }
@@ -4312,6 +4451,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();
@@ -4448,7 +4600,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 = [];
@@ -5269,6 +5429,7 @@ async function executeScenarioRuntime(args) {
         })));
         await invokeBeforeScenario(policies, scenario.name);
         await runWarmUpAsync();
+        reportHistoryLifecycle?.scenarioBombingStarted();
         accumulator.setCurrentOperation("Bombing");
         const simulations = scenario.getSimulations();
         if (!simulations.length) {
@@ -5302,6 +5463,7 @@ async function executeScenarioRuntime(args) {
             }
         }
         accumulator.setCurrentOperation(stopScenario || stopTestState.value ? "Stop" : "Complete");
+        await endReportHistoryExecution();
         await invokeAfterScenario(policies, scenario.name, runtime);
     }
     catch (error) {
@@ -5318,6 +5480,7 @@ async function executeScenarioRuntime(args) {
         }
     }
     finally {
+        await endReportHistoryExecution();
         scenarioDurationsMs.set(scenario.name, Math.max(Date.now() - scenarioStartedMs, 0));
         try {
             await scenario.invokeClean({
@@ -7251,6 +7414,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,
@@ -8722,6 +8890,7 @@ class ManagedScenarioTrackingRuntime {
     }
     async dispose() {
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         this.rejectOutstandingWaiters();
         await Promise.all([
             this.sourceLoop,
@@ -8787,6 +8956,7 @@ class ManagedScenarioTrackingRuntime {
             failureSeen = failureSeen || this.isFailedObservationOutcome(outcome);
         }
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         await Promise.all([
             this.sourceLoop,
             this.destinationLoop,
@@ -8803,6 +8973,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 {
@@ -9394,6 +9578,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"
@@ -9416,6 +9614,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: {
@@ -10179,6 +10390,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) {
+                validateNativeEndpointExecutionSupport(endpoint);
+            }
+        }
+    }
+}
 function normalizeRunContextCollectionShapes(values) {
     assertNoDisableLicenseEnforcementOption(values, "LoadStrikeContext");
     const normalized = {
@@ -11082,6 +11307,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)) : "",
@@ -11294,6 +11520,8 @@ export const __loadstrikeTestExports = {
     buildThresholdCheckExpression,
     buildTrackingLeaseKey,
     buildTrackingRunNamespace,
+    boundedReportingIntervalMs,
+    resolvedReportHistoryCadenceSeconds,
     clusterNodeResultToNodeStats,
     combineAbortSignals,
     computeScenarioRequestCount,
@@ -11313,6 +11541,7 @@ export const __loadstrikeTestExports = {
     formatUtcReportTimestamp,
     hasPluginRows,
     inferRuntimeLegacyHttpResponseSource,
+    isDistributedReportHistoryExecution,
     isComparisonFailed,
     loadJsonObject,
     logLevelOrder,