@loadstrike/loadstrike-sdk 1.0.30201 → 1.0.31001

package/dist/esm/runtime.js

@@ -3,11 +3,17 @@ import { randomBytes, randomUUID } from "node:crypto";
 import os from "node:os";
 import { resolve } from "node:path";
 import { LoadStrikeLocalClient } from "./local.js";
-import { DistributedClusterAgent, DistributedClusterCoordinator } from "./cluster.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 { buildDotnetCsvReport, buildDotnetHtmlReport, buildDotnetMarkdownReport, buildDotnetTxtReport } from "./reporting.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 = {
     SingleNode: "SingleNode",
     Coordinator: "Coordinator",
@@ -139,12 +145,20 @@ export class LoadStrikePluginData {
     }
 }
 class MeasurementAccumulator {
-    constructor() {
+    constructor(useHistogram = false) {
+        this.useHistogram = useHistogram;
         this.count = 0;
         this.allBytes = 0;
         this.latenciesMs = [];
         this.sizesBytes = [];
+        this.latencyLessOrEq800 = 0;
+        this.latencyMore800Less1200 = 0;
+        this.latencyMoreOrEq1200 = 0;
         this.statusCodes = new Map();
+        if (useHistogram) {
+            this.latencyHistogram = new LoadStrikeHistogramV1();
+            this.sizeHistogram = new LoadStrikeHistogramV1();
+        }
     }
     get Count() {
         return this.count;
@@ -161,8 +175,20 @@ class MeasurementAccumulator {
         const key = `${statusCode}|${message}|${reply.isSuccess ? "ok" : "fail"}`;
         this.count += 1;
         this.allBytes += sizeBytes;
-        this.latenciesMs.push(latencyMs);
-        this.sizesBytes.push(sizeBytes);
+        if (this.useHistogram) {
+            this.latencyHistogram.record(normalizeLatencyMicroseconds(latencyMs));
+            this.sizeHistogram.record(normalizeHistogramInteger(sizeBytes, "Response size"));
+        }
+        else {
+            this.latenciesMs.push(latencyMs);
+            this.sizesBytes.push(sizeBytes);
+        }
+        if (latencyMs <= 800)
+            this.latencyLessOrEq800 += 1;
+        else if (latencyMs < 1200)
+            this.latencyMore800Less1200 += 1;
+        else
+            this.latencyMoreOrEq1200 += 1;
         const existing = this.statusCodes.get(key);
         if (existing) {
             existing.count += 1;
@@ -180,6 +206,9 @@ class MeasurementAccumulator {
      * Use this when all builder inputs are ready to be materialized.
      */
     build(allRequestCount, durationMs) {
+        if (this.useHistogram) {
+            return buildHistogramMeasurement(this.histogramSnapshot(), allRequestCount, durationMs);
+        }
         const count = this.count;
         const totalDurationMs = Math.max(durationMs, 0);
         const latencyValues = [...this.latenciesMs];
@@ -228,14 +257,274 @@ class MeasurementAccumulator {
             statusCodes
         };
     }
+    buildCombined(other, allRequestCount, durationMs) {
+        if (!this.useHistogram || !other.useHistogram) {
+            throw new Error("Combined measurements require Load Engine V2 histograms.");
+        }
+        const left = this.histogramSnapshot();
+        const right = other.histogramSnapshot();
+        left.latency.merge(right.latency);
+        left.size.merge(right.size);
+        for (const [key, value] of right.statusCodes) {
+            const existing = left.statusCodes.get(key);
+            if (existing)
+                existing.count += value.count;
+            else
+                left.statusCodes.set(key, { ...value });
+        }
+        return buildHistogramMeasurement({
+            count: left.count + right.count,
+            allBytes: left.allBytes + right.allBytes,
+            latency: left.latency,
+            size: left.size,
+            statusCodes: left.statusCodes,
+            lessOrEq800: left.lessOrEq800 + right.lessOrEq800,
+            more800Less1200: left.more800Less1200 + right.more800Less1200,
+            moreOrEq1200: left.moreOrEq1200 + right.moreOrEq1200
+        }, allRequestCount, durationMs);
+    }
+    histogramSnapshot() {
+        return {
+            count: this.count,
+            allBytes: this.allBytes,
+            latency: this.latencyHistogram.clone(),
+            size: this.sizeHistogram.clone(),
+            statusCodes: new Map(Array.from(this.statusCodes, ([key, value]) => [key, { ...value }])),
+            lessOrEq800: this.latencyLessOrEq800,
+            more800Less1200: this.latencyMore800Less1200,
+            moreOrEq1200: this.latencyMoreOrEq1200
+        };
+    }
+}
+function buildHistogramMeasurement(snapshot, allRequestCount, durationMs) {
+    const count = snapshot.count;
+    const totalDurationMs = Math.max(durationMs, 0);
+    const latency = snapshot.latency;
+    const size = snapshot.size;
+    return {
+        count64: latency.count.toString(),
+        distributionMode: latency.mode === "quantized-v1" || size.mode === "quantized-v1"
+            ? "quantized-v1"
+            : "exact-normalized",
+        maxRelativeError: Math.max(latency.maxRelativeError, size.maxRelativeError),
+        histogramSidecar: {
+            latency: latency.toSidecar(),
+            size: size.toSidecar(),
+            allBytes64: size.exactTotal.toString(),
+            lessOrEq80064: snapshot.lessOrEq800.toString(),
+            more800Less120064: snapshot.more800Less1200.toString(),
+            moreOrEq120064: snapshot.moreOrEq1200.toString()
+        },
+        request: {
+            count,
+            percent: allRequestCount <= 0 ? 0 : Math.round((100 * count) / allRequestCount),
+            rps: totalDurationMs <= 0 ? 0 : count / (totalDurationMs / 1000)
+        },
+        dataTransfer: {
+            allBytes: snapshot.allBytes,
+            allBytes64: size.exactTotal.toString(),
+            minBytes: Number(size.minimum),
+            maxBytes: Number(size.maximum),
+            meanBytes: Math.round(size.mean),
+            percent50: Number(size.percentile(0.5)),
+            percent75: Number(size.percentile(0.75)),
+            percent95: Number(size.percentile(0.95)),
+            percent99: Number(size.percentile(0.99)),
+            percent100: Number(size.percentile(1)),
+            stdDev: size.populationStandardDeviation
+        },
+        latency: {
+            latencyCount: {
+                lessOrEq800: snapshot.lessOrEq800,
+                more800Less1200: snapshot.more800Less1200,
+                moreOrEq1200: snapshot.moreOrEq1200
+            },
+            minMs: Number(latency.minimum) / 1000,
+            maxMs: Number(latency.maximum) / 1000,
+            meanMs: latency.mean / 1000,
+            percent50: Number(latency.percentile(0.5)) / 1000,
+            percent75: Number(latency.percentile(0.75)) / 1000,
+            percent95: Number(latency.percentile(0.95)) / 1000,
+            percent99: Number(latency.percentile(0.99)) / 1000,
+            percent100: Number(latency.percentile(1)) / 1000,
+            stdDev: latency.populationStandardDeviation / 1000
+        },
+        statusCodes: Array.from(snapshot.statusCodes.values())
+            .sort((left, right) => right.count - left.count)
+            .map((value) => ({
+            count: value.count,
+            isError: value.isError,
+            message: value.message,
+            percent: count <= 0 ? 0 : Math.round((100 * value.count) / count),
+            statusCode: value.statusCode
+        }))
+    };
+}
+function normalizeLatencyMicroseconds(latencyMs) {
+    return normalizeHistogramInteger(Math.max(latencyMs, 0) * 1000, "Latency");
+}
+function normalizeRawObservationLatencyMicroseconds(latencyMs) {
+    const maximum = 9223372036854775807n;
+    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
+        return 0n;
+    }
+    const microseconds = latencyMs * 1000;
+    if (!Number.isFinite(microseconds) || microseconds >= Number(maximum)) {
+        return maximum;
+    }
+    return BigInt(Math.max(0, Math.round(microseconds)));
+}
+function normalizeHistogramInteger(value, name) {
+    if (!Number.isFinite(value) || value > Number(9223372036854775807n)) {
+        throw new RangeError(`${name} is outside the supported histogram range.`);
+    }
+    return BigInt(Math.max(0, Math.round(value)));
+}
+class LoadEngineV2Telemetry {
+    constructor(budget) {
+        this.budget = budget;
+        this.mutableSegments = [];
+        this.warnings = new Map();
+    }
+    createSegment(scenarioName, scenarioIndex, simulationIndex, kind, shardIndex, shardCount) {
+        const segment = {
+            scenarioName,
+            scenarioIndex,
+            simulationIndex,
+            kind,
+            shardIndex,
+            shardCount,
+            planned: 0n,
+            due: 0n,
+            started: 0n,
+            completed: 0n,
+            dropped: 0n,
+            unreached: 0n,
+            requestedWorkers: 0n,
+            startedWorkers: 0n,
+            unavailableWorkers: 0n,
+            dropReasons: new Map(),
+            unavailableWorkerReasons: new Map(),
+            decisionLag: new LoadStrikeHistogramV1(),
+            startLag: new LoadStrikeHistogramV1(),
+            accountingComplete: false
+        };
+        this.mutableSegments.push(segment);
+        return segment;
+    }
+    recordWarning(code, segment, count) {
+        if (count <= 0n)
+            return;
+        const key = `${code}\n${segment.scenarioIndex}\n${segment.simulationIndex}`;
+        const nowNs = BigInt(Date.now()) * 1000000n;
+        const existing = this.warnings.get(key);
+        if (existing) {
+            existing.count += count;
+            existing.lastObservedUtcNs = nowNs;
+        }
+        else {
+            this.warnings.set(key, {
+                code,
+                scenarioName: segment.scenarioName,
+                scenarioIndex: segment.scenarioIndex,
+                simulationIndex: segment.simulationIndex,
+                simulationKind: segment.kind,
+                count,
+                firstObservedUtcNs: nowNs,
+                lastObservedUtcNs: nowNs
+            });
+        }
+    }
+    recordDecisionLag(segment, lagNs) {
+        segment.decisionLag.record(maxBigInt(lagNs, 0n) / 1000n);
+    }
+    recordStartLag(segment, lagNs) {
+        segment.startLag.record(maxBigInt(lagNs, 0n) / 1000n);
+    }
+    buildSchedulerDistributions() {
+        return this.mutableSegments.flatMap((segment) => {
+            const scenarioIndex64 = segment.scenarioIndex.toString();
+            const simulationIndex64 = segment.simulationIndex.toString();
+            return [
+                ["scheduler-decision-lag", "decision", segment.decisionLag],
+                ["scheduler-start-lag", "start", segment.startLag]
+            ].map(([seriesKind, identityKind, histogram]) => ({
+                seriesKind,
+                scenarioIndex64,
+                scenarioName: segment.scenarioName,
+                identityKeyHex: buildLoadEngineV2SchedulerIdentityKey(identityKind, scenarioIndex64, simulationIndex64).toString("hex"),
+                outcome: "none",
+                unit: "microseconds",
+                histogram: histogram.toSidecar(),
+                exactTotalDecimalOrEmpty: histogram.toSidecar().exactTotal64
+            }));
+        });
+    }
+    buildWarnings() {
+        return Array.from(this.warnings.values())
+            .sort((left, right) => left.code.localeCompare(right.code)
+            || left.scenarioName.localeCompare(right.scenarioName)
+            || left.simulationIndex - right.simulationIndex)
+            .map((value) => ({
+            code: value.code,
+            scenarioName: value.scenarioName,
+            scenarioIndex: value.scenarioIndex,
+            simulationIndex: value.simulationIndex,
+            simulationKind: value.simulationKind,
+            count64: value.count.toString(),
+            message: value.code,
+            firstObservedUtcNs: value.firstObservedUtcNs.toString(),
+            lastObservedUtcNs: value.lastObservedUtcNs.toString()
+        }));
+    }
+    buildSegments() {
+        return this.mutableSegments.map((segment) => ({
+            scenarioName: segment.scenarioName,
+            scenarioIndex: segment.scenarioIndex,
+            simulationIndex: segment.simulationIndex,
+            kind: segment.kind,
+            shardIndex: segment.shardIndex,
+            shardCount: segment.shardCount,
+            plannedIterations64: segment.planned.toString(),
+            dueIterations64: segment.due.toString(),
+            startedIterations64: segment.started.toString(),
+            completedIterations64: segment.completed.toString(),
+            droppedIterations64: segment.dropped.toString(),
+            unreachedIterations64: segment.unreached.toString(),
+            requestedWorkerSlots64: segment.requestedWorkers.toString(),
+            startedWorkerSlots64: segment.startedWorkers.toString(),
+            unavailableWorkerSlots64: segment.unavailableWorkers.toString(),
+            dropReasons: Object.fromEntries(Array.from(segment.dropReasons, ([key, count]) => [key, count.toString()])),
+            unavailableWorkerReasons: Object.fromEntries(Array.from(segment.unavailableWorkerReasons, ([key, count]) => [key, count.toString()])),
+            deliveryPercent: segment.due === 0n ? 100 : Number(segment.started * 10000n / segment.due) / 100,
+            accountingComplete: segment.accountingComplete
+        }));
+    }
+    buildStats() {
+        return {
+            configuredMaxInFlight: this.budget.maxInFlight,
+            maxInFlightObserved: this.budget.highWater,
+            currentInFlight: this.budget.current,
+            segments: this.buildSegments()
+        };
+    }
+}
+function incrementReason(reasons, code, count = 1n) {
+    reasons.set(code, (reasons.get(code) ?? 0n) + count);
+}
+function ownedV2OrdinalCount(total, shardIndex, shardCount) {
+    if (total <= BigInt(shardIndex))
+        return 0n;
+    return (total - 1n - BigInt(shardIndex)) / BigInt(shardCount) + 1n;
 }
 class StepStatsAccumulator {
-    constructor(scenarioName, stepName, sortIndex) {
+    constructor(scenarioName, stepName, sortIndex, useHistogram = false) {
         this.scenarioName = scenarioName;
         this.stepName = stepName;
         this.sortIndex = sortIndex;
-        this.ok = new MeasurementAccumulator();
-        this.fail = new MeasurementAccumulator();
+        this.useHistogram = useHistogram;
+        this.ok = new MeasurementAccumulator(useHistogram);
+        this.fail = new MeasurementAccumulator(useHistogram);
     }
     /**
      * Exposes the public record operation.
@@ -274,6 +563,7 @@ class StepStatsAccumulator {
             minLatencyMs: minCandidates.length ? Math.min(...minCandidates) : 0,
             maxLatencyMs: maxCandidates.length ? Math.max(...maxCandidates) : 0,
             statusCodes,
+            allMeasurement: this.useHistogram ? this.ok.buildCombined(this.fail, requestCount, durationMs) : undefined,
             ok,
             fail,
             sortIndex: this.sortIndex
@@ -281,15 +571,16 @@ class StepStatsAccumulator {
     }
 }
 class ScenarioStatsAccumulator {
-    constructor(scenarioName, sortIndex) {
+    constructor(scenarioName, sortIndex, useHistogram = false) {
         this.scenarioName = scenarioName;
         this.sortIndex = sortIndex;
-        this.ok = new MeasurementAccumulator();
-        this.fail = new MeasurementAccumulator();
+        this.useHistogram = useHistogram;
         this.steps = new Map();
         this.nextStepSortIndex = 0;
         this.loadSimulationStats = { simulationName: "", value: 0 };
         this.currentOperation = "None";
+        this.ok = new MeasurementAccumulator(useHistogram);
+        this.fail = new MeasurementAccumulator(useHistogram);
     }
     /**
      * Exposes the public setLoadSimulation operation.
@@ -330,13 +621,18 @@ class ScenarioStatsAccumulator {
      * Exposes the public recordStep operation.
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
      */
-    recordStep(stepName, reply, observedLatencyMs) {
+    recordStep(stepName, reply, observedLatencyMs, sortIndex) {
         const existing = this.steps.get(stepName);
-        const step = existing ?? new StepStatsAccumulator(this.scenarioName, stepName, this.nextStepSortIndex += 1);
+        const resolvedSortIndex = sortIndex === undefined
+            ? this.nextStepSortIndex + 1
+            : Math.max(Math.trunc(sortIndex), 0);
+        const step = existing ?? new StepStatsAccumulator(this.scenarioName, stepName, resolvedSortIndex, this.useHistogram);
         if (!existing) {
+            this.nextStepSortIndex = Math.max(this.nextStepSortIndex, resolvedSortIndex);
             this.steps.set(stepName, step);
         }
         step.record(reply, observedLatencyMs);
+        return step.sortIndex;
     }
     /**
      * Builds the configured payload or helper object.
@@ -365,6 +661,7 @@ class ScenarioStatsAccumulator {
             minLatencyMs: minCandidates.length ? Math.min(...minCandidates) : 0,
             maxLatencyMs: maxCandidates.length ? Math.max(...maxCandidates) : 0,
             statusCodes,
+            allMeasurement: this.useHistogram ? this.ok.buildCombined(this.fail, totalRequests, durationMs) : undefined,
             allBytes,
             currentOperation: this.currentOperation,
             durationMs: Math.max(durationMs, 0),
@@ -459,7 +756,8 @@ export class LoadStrikeStep {
         const internal = context;
         await internal.invokeBeforeStep(stepName);
         let reply;
-        const startedAt = Date.now();
+        const startedUtcNs = utcNowNs();
+        const startedAtNs = process.hrtime.bigint();
         try {
             reply = normalizeReply(await run());
         }
@@ -467,8 +765,21 @@ export class LoadStrikeStep {
             reply = LoadStrikeResponse.fail("step_exception", resolveRuntimeErrorMessage(error, "step failed"), 0);
         }
         reply = attachReplyProjection(reply);
-        const observedLatencyMs = Math.max(Date.now() - startedAt, 0);
-        internal.recordStep(stepName, reply, observedLatencyMs);
+        const observedLatencyNs = maxBigInt(process.hrtime.bigint() - startedAtNs, 0n);
+        const completedUtcNs = startedUtcNs + observedLatencyNs;
+        const observedLatencyMs = Number(observedLatencyNs) / 1000000;
+        const recordedSortIndex = internal.recordStep(stepName, reply, observedLatencyMs);
+        internal.recordStepObservation?.(createIterationStepObservation({
+            stepName,
+            sortIndex: typeof recordedSortIndex === "number" ? recordedSortIndex : 0,
+            startedUtcNs,
+            completedUtcNs,
+            observedLatencyUs64: observedLatencyNs / 1000n,
+            reportedLatencyUs64: normalizeRawObservationLatencyMicroseconds(resolveRecordedLatency(reply.customLatencyMs, observedLatencyMs)),
+            isSuccess: reply.isSuccess,
+            statusCode: normalizeStatusCode(reply.statusCode, reply.isSuccess),
+            sizeBytes64: normalizeHistogramInteger(Math.max(toNumber(reply.sizeBytes), 0), "Step response bytes")
+        }));
         await internal.invokeAfterStep(stepName, reply);
         return reply;
     }
@@ -999,10 +1310,14 @@ export class LoadStrikeContext {
         const normalizedValues = normalizeRunContextCollectionShapes(this.values);
         return {
             displayConsoleMetrics: normalizedValues.ConsoleMetricsEnabled,
+            loadEngineContractVersion: normalizedValues.LoadEngineContractVersion,
+            maxInFlight: normalizedValues.MaxInFlight,
             nodeType: normalizedValues.NodeType,
             localDevClusterEnabled: normalizedValues.LocalDevClusterEnabled,
             agentGroup: normalizedValues.AgentGroup,
             agentsCount: normalizedValues.AgentsCount,
+            agentId: normalizedValues.AgentId,
+            expectedAgentIds: normalizedValues.ExpectedAgentIds,
             targetScenarios: normalizedValues.TargetScenarios,
             agentTargetScenarios: normalizedValues.AgentTargetScenarios,
             coordinatorTargetScenarios: normalizedValues.CoordinatorTargetScenarios,
@@ -1021,6 +1336,13 @@ export class LoadStrikeContext {
             reportFolderPath: normalizedValues.ReportFolderPath,
             reportFormats: normalizedValues.ReportFormats,
             reportingIntervalSeconds: normalizedValues.ReportingIntervalSeconds,
+            iterationObservationFlushIntervalSeconds: normalizedValues.IterationObservationFlushIntervalSeconds,
+            maxIterationObservationBufferBytes: normalizedValues.MaxIterationObservationBufferBytes,
+            maxIterationObservationsPerBatch: normalizedValues.MaxIterationObservationsPerBatch,
+            maxIterationObservationBatchBytes: normalizedValues.MaxIterationObservationBatchBytes,
+            iterationObservationSinkQueueDepth: normalizedValues.IterationObservationSinkQueueDepth,
+            iterationObservationSinkParallelism: normalizedValues.IterationObservationSinkParallelism,
+            iterationObservationDrainTimeoutSeconds: normalizedValues.IterationObservationDrainTimeoutSeconds,
             minimumLogLevel: normalizedValues.MinimumLogLevel,
             loggerConfig: normalizedValues.LoggerConfig,
             reportingSinks: normalizedValues.ReportingSinks,
@@ -1034,6 +1356,8 @@ export class LoadStrikeContext {
             workerPlugins: normalizedValues.WorkerPlugins,
             customSettings: normalizedValues.CustomSettings,
             globalCustomSettings: normalizedValues.GlobalCustomSettings,
+            clusterShardIndex: normalizedValues.ClusterShardIndex,
+            clusterShardCount: normalizedValues.ClusterShardCount,
             runArgs: this.runArgs.length ? [...this.runArgs] : undefined
         };
     }
@@ -1095,6 +1419,19 @@ export class LoadStrikeContext {
     DisplayConsoleMetrics(enable) {
         return this.mergeValues({ ConsoleMetricsEnabled: Boolean(enable) });
     }
+    useLoadEngineV2() {
+        return this.UseLoadEngineV2();
+    }
+    UseLoadEngineV2() {
+        return this.mergeValues({ LoadEngineContractVersion: 2 });
+    }
+    withMaxInFlight(maxInFlight) {
+        return this.WithMaxInFlight(maxInFlight);
+    }
+    WithMaxInFlight(maxInFlight) {
+        validateV2MaxInFlight(this.values.LoadEngineContractVersion, maxInFlight);
+        return this.mergeValues({ MaxInFlight: maxInFlight });
+    }
     /**
      * Toggles local development cluster mode.
      * Use this when you want to simulate coordinator and agent behavior on a single machine.
@@ -1161,6 +1498,26 @@ export class LoadStrikeContext {
     WithAgentGroup(agentGroup) {
         return this.mergeValues({ AgentGroup: requireNonEmpty(agentGroup, "Agent group must be provided.") });
     }
+    /** Sets the stable identity required by a remote Load Engine V2 agent. */
+    withAgentId(agentId) {
+        return this.WithAgentId(agentId);
+    }
+    /** Sets the stable identity required by a remote Load Engine V2 agent. */
+    WithAgentId(agentId) {
+        return this.mergeValues({ AgentId: requireNonEmpty(agentId, "Agent id must be provided.") });
+    }
+    /** Sets the exact remote agent identities required by a Load Engine V2 coordinator. */
+    withExpectedAgentIds(...agentIds) {
+        return this.WithExpectedAgentIds(...agentIds);
+    }
+    /** Sets the exact remote agent identities required by a Load Engine V2 coordinator. */
+    WithExpectedAgentIds(...agentIds) {
+        const normalized = validateScenarioNames(agentIds);
+        if (new Set(normalized).size !== normalized.length) {
+            throw new Error("Expected agent ids must be unique.");
+        }
+        return this.mergeValues({ ExpectedAgentIds: normalized });
+    }
     /**
      * Sets the requested agent count.
      * Use this when a coordinator should fan work out across a specific number of agents.
@@ -1997,7 +2354,7 @@ function firstWebVitalViolation(...values) {
     return "";
 }
 export class LoadStrikeScenario {
-    constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail, internalLicenseFeatures = []) {
+    constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail, internalLicenseFeatures = [], declaredStepNames = []) {
         this.name = name;
         this.runHandler = runHandler;
         this.initHandler = initHandler;
@@ -2011,6 +2368,7 @@ export class LoadStrikeScenario {
         this.weight = weight;
         this.restartIterationOnFail = restartIterationOnFail;
         this.internalLicenseFeatures = normalizeStringArray(internalLicenseFeatures);
+        this.declaredStepNames = normalizeDeclaredStepNames(declaredStepNames);
     }
     static create(name, runHandler) {
         const scenarioName = requireNonEmpty(name, "Scenario name must be provided.");
@@ -2053,7 +2411,7 @@ export class LoadStrikeScenario {
         if (typeof handler !== "function") {
             throw new TypeError("Init handler must be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, handler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, handler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures init async for this SDK object.
@@ -2070,7 +2428,7 @@ export class LoadStrikeScenario {
         if (typeof handler !== "function") {
             throw new TypeError("Clean handler must be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, handler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, handler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures clean async for this SDK object.
@@ -2087,14 +2445,14 @@ export class LoadStrikeScenario {
         if (!Number.isFinite(maxFailCount)) {
             throw new RangeError("maxFailCount should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, Math.trunc(maxFailCount), this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, Math.trunc(maxFailCount), this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures out warm up for this SDK object.
      * Use this when out warm up should be set explicitly before the run starts.
      */
     withoutWarmUp() {
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, true, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, true, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures warm up duration for this SDK object.
@@ -2104,7 +2462,7 @@ export class LoadStrikeScenario {
         if (!Number.isFinite(durationSeconds)) {
             throw new RangeError("Warmup duration should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, durationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, durationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures weight for this SDK object.
@@ -2114,14 +2472,14 @@ export class LoadStrikeScenario {
         if (!Number.isFinite(weight)) {
             throw new RangeError("Weight should be a finite number.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, Math.trunc(weight), this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, Math.trunc(weight), this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures restart iteration on fail for this SDK object.
      * Use this when restart iteration on fail should be set explicitly before the run starts.
      */
     withRestartIterationOnFail(shouldRestart) {
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, Boolean(shouldRestart), this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, Boolean(shouldRestart), this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures cross platform tracking for this SDK object.
@@ -2146,7 +2504,7 @@ export class LoadStrikeScenario {
         if (isCorrelateExistingTrafficTracking(copied) && this.loadSimulations.length > 0) {
             throw new Error("CorrelateExistingTraffic uses ForDuration and cannot be combined with WithLoadSimulations.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures load simulations for this SDK object.
@@ -2159,7 +2517,7 @@ export class LoadStrikeScenario {
         if (isCorrelateExistingTrafficTracking(this.trackingConfiguration)) {
             throw new Error("CorrelateExistingTraffic uses ForDuration and cannot be combined with WithLoadSimulations.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Configures thresholds for this SDK object.
@@ -2169,7 +2527,7 @@ export class LoadStrikeScenario {
         if (!thresholds.length) {
             throw new Error("At least one threshold should be provided.");
         }
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, thresholds.map((threshold) => ({ ...threshold })), this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, thresholds.map((threshold) => ({ ...threshold })), this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, this.declaredStepNames);
     }
     /**
      * Returns simulations.
@@ -2230,6 +2588,26 @@ export class LoadStrikeScenario {
     __loadStrikeInternalLicenseFeatures() {
         return [...this.internalLicenseFeatures];
     }
+    /** Freezes the named step identities that may be reported by this scenario. */
+    withDeclaredSteps(...stepNames) {
+        if (!stepNames.length) {
+            throw new Error("At least one declared step name should be provided.");
+        }
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures, stepNames);
+    }
+    /** Returns the immutable declared-step names in declaration order. */
+    getDeclaredSteps() {
+        return [...this.declaredStepNames];
+    }
+    __loadStrikeSetTrafficMixV2Metadata(metadata) {
+        this.trafficMixV2Metadata = cloneLoadEngineV2TrafficMixMetadata(metadata);
+        return this;
+    }
+    __loadStrikeTrafficMixV2Metadata() {
+        return this.trafficMixV2Metadata
+            ? cloneLoadEngineV2TrafficMixMetadata(this.trafficMixV2Metadata)
+            : undefined;
+    }
     __loadStrikeScenarioSourceAnalysis() {
         const source = this.runHandler.toString();
         const lines = source
@@ -2252,7 +2630,7 @@ export class LoadStrikeScenario {
     }
     __loadStrikeWithInternalLicenseFeatures(...features) {
         const merged = Array.from(new Set([...this.internalLicenseFeatures, ...normalizeStringArray(features)]));
-        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, merged);
+        return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, merged, this.declaredStepNames);
     }
     async invokeInit(context) {
         if (this.initHandler) {
@@ -2273,6 +2651,9 @@ export class LoadStrikeScenario {
             return normalizeReply(result);
         }
         catch (error) {
+            if (error instanceof RuntimePolicyCallbackError) {
+                throw error;
+            }
             return LoadStrikeResponse.fail("exception", resolveRuntimeErrorMessage(error, "scenario failed"), 0);
         }
     }
@@ -2318,6 +2699,10 @@ export class LoadStrikeScenario {
     WithLoadSimulations(...simulations) {
         return this.withLoadSimulations(...simulations);
     }
+    /** Freezes the named step identities that may be reported by this scenario. */
+    WithDeclaredSteps(...stepNames) {
+        return this.withDeclaredSteps(...stepNames);
+    }
     /**
      * Configures max fail count for this SDK object.
      * Use this when max fail count should be set explicitly before the run starts.
@@ -2446,7 +2831,7 @@ export class LoadStrikeTrafficMix {
         return this.withScenarioMix(...scenarioMix);
     }
     expandScenarios() {
-        return expandTrafficMixScenarios(this);
+        return expandTrafficMixScenarios(this, 0);
     }
     ExpandScenarios() {
         return this.expandScenarios();
@@ -2459,10 +2844,11 @@ export class LoadStrikeTrafficMix {
     }
 }
 export class LoadStrikeRunner {
-    constructor(scenarios, options, contextConfigurators = []) {
+    constructor(scenarios, options, contextConfigurators = [], internalOptions = {}) {
         this.scenarios = scenarios;
         this.options = normalizeRunnerOptionCollectionShapes(options);
         this.contextConfigurators = [...contextConfigurators];
+        this.internalOptions = internalOptions;
     }
     /**
      * Creates a new instance of this public SDK type.
@@ -2498,7 +2884,7 @@ export class LoadStrikeRunner {
      * Use this when one total load profile should be split across weighted scenario lanes.
      */
     static registerTrafficMix(trafficMix) {
-        return LoadStrikeRunner.registerScenarios(...expandTrafficMixScenarios(trafficMix));
+        return LoadStrikeRunner.registerScenarios(...expandTrafficMixScenarios(trafficMix, 0));
     }
     /**
      * Registers a traffic mix on a fresh runnable context.
@@ -2514,6 +2900,12 @@ export class LoadStrikeRunner {
     static DisplayConsoleMetrics(context, enable) {
         return context.DisplayConsoleMetrics(enable);
     }
+    static UseLoadEngineV2(context) {
+        return context.UseLoadEngineV2();
+    }
+    static WithMaxInFlight(context, maxInFlight) {
+        return context.WithMaxInFlight(maxInFlight);
+    }
     /**
      * Toggles local development cluster mode.
      * Use this when you want to simulate coordinator and agent behavior on a single machine.
@@ -2549,6 +2941,12 @@ export class LoadStrikeRunner {
     static WithAgentGroup(context, agentGroup) {
         return context.WithAgentGroup(agentGroup);
     }
+    static WithAgentId(context, agentId) {
+        return context.WithAgentId(agentId);
+    }
+    static WithExpectedAgentIds(context, ...agentIds) {
+        return context.WithExpectedAgentIds(...agentIds);
+    }
     /**
      * Sets the requested agent count.
      * Use this when a coordinator should fan work out across a specific number of agents.
@@ -2766,7 +3164,10 @@ export class LoadStrikeRunner {
      * Use this when one total load profile should be split across weighted scenario lanes.
      */
     addTrafficMix(trafficMix) {
-        this.scenarios = [...this.scenarios, ...expandTrafficMixScenarios(trafficMix)];
+        this.scenarios = [
+            ...this.scenarios,
+            ...expandTrafficMixScenarios(trafficMix, nextTrafficMixDeclarationIndex(this.scenarios))
+        ];
         return this;
     }
     /**
@@ -2899,6 +3300,19 @@ export class LoadStrikeRunner {
     WithReportingInterval(intervalSeconds) {
         return this.withReportingInterval(intervalSeconds);
     }
+    useLoadEngineV2() {
+        return this.configure({ loadEngineContractVersion: 2 });
+    }
+    UseLoadEngineV2() {
+        return this.useLoadEngineV2();
+    }
+    withMaxInFlight(maxInFlight) {
+        validateV2MaxInFlight(this.options.loadEngineContractVersion, maxInFlight);
+        return this.configure({ maxInFlight });
+    }
+    WithMaxInFlight(maxInFlight) {
+        return this.withMaxInFlight(maxInFlight);
+    }
     withReportingSinks(...sinks) {
         if (!sinks.length) {
             throw new Error("At least one reporting sink should be provided.");
@@ -2997,7 +3411,7 @@ export class LoadStrikeRunner {
     }
     async run(args = []) {
         if (this.contextConfigurators.length) {
-            return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions()).run(args);
+            return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions(), [], this.internalOptions).run(args);
         }
         if (args.length) {
             return this.buildContext().run(args);
@@ -3015,8 +3429,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 &&
@@ -3045,10 +3459,15 @@ export class LoadStrikeRunner {
         let licenseClient = null;
         let licensePayload = null;
         let licenseSession = null;
+        let iterationObservationsFinalized = false;
         const clusterMode = resolveClusterExecutionMode(this.options);
         const selectedScenarios = clusterMode === "local-coordinator" || clusterMode === "nats-coordinator"
             ? await this.filterScenariosWithPolicies(this.scenarios, policies, policyErrors, runtimePolicyErrorMode)
             : await this.selectScenarios(policies, policyErrors, runtimePolicyErrorMode);
+        if (this.options.loadEngineContractVersion === 2
+            && (clusterMode === "nats-coordinator" || clusterMode === "nats-agent")) {
+            validateLoadEngineV2ScenarioFeatures(selectedScenarios);
+        }
         if (clusterMode === "nats-agent") {
             return this.runAgentWithNats(createdUtc, testInfo, nodeInfo);
         }
@@ -3105,14 +3524,49 @@ 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
+            ?? testInfo.sessionId);
+        const iterationObservationResultOwnerId = String(nodeInfo.nodeType).toLowerCase() === "agent"
+            ? String(this.options.agentCommandId
+                ?? `${nodeInfo.machineName}:${Math.max(Math.trunc(this.options.clusterShardIndex ?? 0), 0)}`)
+            : "";
+        const iterationObservationProcessGroup = 0;
+        const iterationObservationExpectedResultOwnerCount64 = Math.max(Math.trunc(this.options.clusterShardCount ?? 1), 1).toString();
+        const initializedIterationObservationSinks = sinkStates
+            .filter((state) => !state.disabled)
+            .map((state) => ({
+            name: state.name,
+            iterationObservationPortalSink: Boolean(state.sink.iterationObservationPortalSink),
+            iterationObservationShapeLimited: Boolean(state.sink.iterationObservationShapeLimited),
+            saveIterationBatch: resolveSinkSaveIterationBatch(state.sink),
+            completeIterationObservationStream: resolveSinkCompleteIterationObservationStream(state.sink)
+        }));
+        const reporterIterationObservationSinks = this.internalOptions.iterationObservationSinks
+            ?? (clusterMode === "local-coordinator" || clusterMode === "nats-coordinator"
+                ? []
+                : initializedIterationObservationSinks);
+        const iterationObservationReporter = new IterationObservationReporter({
+            runId: iterationObservationRunId,
+            sessionId: testInfo.sessionId,
+            resultOwnerId: iterationObservationResultOwnerId,
+            expectedResultOwnerCount64: iterationObservationExpectedResultOwnerCount64,
+            processGroup: iterationObservationProcessGroup,
+            settings: resolveIterationObservationSettings(this.options),
+            sinks: reporterIterationObservationSinks,
+            sinkRetryCount,
+            sinkRetryBackoffMs,
+            logger: runLogger
+        });
         const emitRealtimeSnapshot = async () => {
             if (realtimeInFlight) {
                 return;
@@ -3123,7 +3577,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);
@@ -3179,21 +3633,30 @@ export class LoadStrikeRunner {
             let result;
             let metricStats;
             if (clusterMode === "local-coordinator") {
-                const aggregated = await this.runCoordinatorWithLocalAgents(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession);
+                const aggregated = await this.runCoordinatorWithLocalAgents(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession, iterationObservationRunId, initializedIterationObservationSinks);
                 metricStats = aggregated.metrics;
                 result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
             else if (clusterMode === "nats-coordinator") {
-                const aggregated = await this.runCoordinatorWithNats(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession);
+                const aggregated = await this.runCoordinatorWithNats(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession, iterationObservationRunId, initializedIterationObservationSinks);
                 metricStats = aggregated.metrics;
                 result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
             else {
                 const testAbortController = new AbortController();
                 const stopTestState = { value: false, reason: undefined };
-                await Promise.all(selectedScenarios.map((scenario, scenarioIndex) => executeScenarioRuntime({
+                const loadEngineV2Budget = this.options.loadEngineContractVersion === 2
+                    ? (this.options.loadEngineV2BudgetOverride
+                        ?? new LoadEngineV2ExecutionBudget(this.options.maxInFlight ?? 10000))
+                    : undefined;
+                const loadEngineV2Telemetry = loadEngineV2Budget
+                    ? new LoadEngineV2Telemetry(loadEngineV2Budget)
+                    : undefined;
+                const executeSelectedScenario = (scenario, selectedScenarioIndex) => executeScenarioRuntime({
                     scenario,
-                    scenarioIndex,
+                    scenarioIndex: this.options.loadEngineContractVersion === 2
+                        ? this.scenarios.indexOf(scenario)
+                        : selectedScenarioIndex,
                     scenarioCount: selectedScenarios.length,
                     options: this.options,
                     logger: runLogger,
@@ -3208,12 +3671,26 @@ export class LoadStrikeRunner {
                     scenarioDurationsMs,
                     stopTestState,
                     testAbortController,
+                    loadEngineV2Budget,
+                    loadEngineV2Telemetry,
+                    iterationObservationReporter,
+                    iterationObservationRunId,
+                    iterationObservationResultOwnerId,
+                    iterationObservationProcessGroup,
                     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),
                     invokeBeforeStep: (runtimePolicies, scenarioName, stepName) => this.invokeBeforeStep(runtimePolicies, scenarioName, stepName, policyErrors, runtimePolicyErrorMode),
                     invokeAfterStep: (runtimePolicies, scenarioName, stepName, reply) => this.invokeAfterStep(runtimePolicies, scenarioName, stepName, reply, policyErrors, runtimePolicyErrorMode)
-                })));
+                });
+                if (this.options.loadEngineV2SegmentLifecycleOverride) {
+                    for (let scenarioIndex = 0; scenarioIndex < selectedScenarios.length; scenarioIndex += 1) {
+                        await executeSelectedScenario(selectedScenarios[scenarioIndex], scenarioIndex);
+                    }
+                }
+                else {
+                    await Promise.all(selectedScenarios.map(executeSelectedScenario));
+                }
                 nodeInfo.currentOperation = stopTestState.value ? "Stop" : "Complete";
                 const scenarioStatList = Array.from(scenarioAccumulators.values())
                     .map((value) => value.build(scenarioDurationsMs.get(value.scenarioName) ?? 0))
@@ -3253,17 +3730,46 @@ export class LoadStrikeRunner {
                     reportFiles: [],
                     logFiles: [...loggerSetup.logFiles],
                     correlationRows: buildDetailedCorrelationRows(),
-                    failedCorrelationRows: buildDetailedFailedCorrelationRows()
+                    failedCorrelationRows: buildDetailedFailedCorrelationRows(),
+                    ...(loadEngineV2Telemetry
+                        ? {
+                            generatorWarnings: loadEngineV2Telemetry.buildWarnings(),
+                            schedulerSegments: loadEngineV2Telemetry.buildSegments(),
+                            schedulerStats: loadEngineV2Telemetry.buildStats(),
+                            [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]: loadEngineV2Telemetry.buildSchedulerDistributions()
+                        }
+                        : {})
                 };
             }
             await stopRealtimeReporting();
+            const observationDelivery = await iterationObservationReporter.sealAndDrain();
+            iterationObservationsFinalized = true;
+            if (clusterMode !== "local-coordinator"
+                && clusterMode !== "nats-coordinator") {
+                result.observationDeliveryStats = {
+                    lastBatchSequence64: observationDelivery.lastBatchSequence64,
+                    capturedCount64: observationDelivery.capturedCount64,
+                    deliveredCount64: observationDelivery.deliveredCount64,
+                    droppedBufferCount64: observationDelivery.droppedBufferCount64,
+                    droppedSinkCount64: observationDelivery.droppedSinkCount64
+                };
+                result.reportingComplete = observationDelivery.reportingComplete;
+            }
+            else {
+                result.observationDeliveryStats ?? (result.observationDeliveryStats = emptyObservationDeliveryStats());
+                result.reportingComplete ?? (result.reportingComplete = observationDelivery.reportingComplete);
+            }
+            result.generatorWarnings = [
+                ...(result.generatorWarnings ?? []),
+                ...iterationObservationReporter.buildWarnings()
+            ];
             result.pluginsData = mergePluginData(result.pluginsData, await this.collectPluginData(plugins, attachRunResultAliases(result), pluginLifecycleErrors));
             const finalizedResult = attachRunResultAliases(result);
             finalizedResult.logFiles = mergeStringArrays(finalizedResult.logFiles, loggerSetup.logFiles);
             finalizedResult.reportFiles = this.writeReports(finalizedResult);
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
-            await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
-            await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+            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
@@ -3272,8 +3778,11 @@ export class LoadStrikeRunner {
         }
         finally {
             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);
@@ -3308,7 +3817,7 @@ export class LoadStrikeRunner {
         }
         return filtered;
     }
-    async runClusterChildNode(targetScenarios, nodeType, machineName, includeWorkerExtensions, overrides = {}) {
+    async runClusterChildNode(targetScenarios, nodeType, machineName, includeWorkerExtensions, overrides = {}, internalOptions = {}) {
         if (!targetScenarios.length) {
             return buildEmptyNodeStats({
                 startedUtc: new Date().toISOString(),
@@ -3336,7 +3845,7 @@ export class LoadStrikeRunner {
             displayConsoleMetrics: false,
             reportingSinks: includeWorkerExtensions ? this.options.reportingSinks : [],
             workerPlugins: includeWorkerExtensions ? this.options.workerPlugins : []
-        });
+        }, [], internalOptions);
         const childResult = await childRunner.run();
         const childStats = detailedToNodeStats(childResult);
         return {
@@ -3349,70 +3858,127 @@ export class LoadStrikeRunner {
             logFiles: [...(childResult.logFiles ?? [])]
         };
     }
-    async runCoordinatorWithLocalAgents(scenarios, testInfo, nodeInfo, licenseClient, licenseSession) {
+    async runCoordinatorWithLocalAgents(scenarios, testInfo, nodeInfo, licenseClient, licenseSession, iterationObservationRunId, iterationObservationSinks) {
         if (!licenseClient) {
             throw new Error("Coordinator agent execution authorization requires an initialized licensing client.");
         }
-        const controllerRunToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+        const controllerRunToken = currentLicenseSessionRunToken(licenseSession);
         if (!controllerRunToken) {
             throw new Error("Coordinator agent execution authorization requires an active controller run token.");
         }
-        const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? []);
+        const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? [], this.options.loadEngineContractVersion === 2, this.options.coordinatorTargetScenarios ?? []);
+        const sharedV2Budget = this.options.loadEngineContractVersion === 2
+            ? new LoadEngineV2ExecutionBudget(this.options.maxInFlight ?? 10000)
+            : undefined;
         const nodeResults = await Promise.all(assignments.map(async (targetScenarios, index) => {
             const commandId = randomBytes(16).toString("hex");
-            const agentExecutionToken = await licenseClient.createAgentExecutionToken(controllerRunToken, testInfo.sessionId, commandId, index, assignments.length, targetScenarios);
+            const agentExecutionToken = await licenseClient.createAgentExecutionToken(currentLicenseSessionRunToken(licenseSession), testInfo.sessionId, commandId, index, assignments.length, targetScenarios);
             return this.runClusterChildNode(targetScenarios, "Agent", `local-agent-${index + 1}`, false, {
                 sessionId: testInfo.sessionId,
                 testSuite: testInfo.testSuite,
                 testName: testInfo.testName,
                 agentCommandId: commandId,
-                agentExecutionToken
+                agentExecutionToken,
+                clusterShardIndex: index,
+                clusterShardCount: assignments.length,
+                loadEngineV2BudgetOverride: sharedV2Budget
+            }, {
+                iterationObservationRunId,
+                iterationObservationSinks
             });
         }));
         const coordinatorTargets = [...(this.options.coordinatorTargetScenarios ?? [])];
         if (coordinatorTargets.length) {
-            nodeResults.push(await this.runClusterChildNode(coordinatorTargets, "Coordinator", nodeInfo.machineName, false));
+            nodeResults.push(await this.runClusterChildNode(coordinatorTargets, "Coordinator", nodeInfo.machineName, false, {}, {
+                iterationObservationRunId,
+                iterationObservationSinks
+            }));
         }
-        return aggregateNodeStats(testInfo, { ...nodeInfo, nodeType: "Coordinator" }, nodeResults);
+        return aggregateNodeStats(testInfo, { ...nodeInfo, nodeType: "Coordinator" }, nodeResults, this.options.loadEngineContractVersion === 2);
     }
-    async runCoordinatorWithNats(scenarios, testInfo, nodeInfo, licenseClient, licenseSession) {
+    async runCoordinatorWithNats(scenarios, testInfo, nodeInfo, licenseClient, licenseSession, iterationObservationRunId, iterationObservationSinks) {
         if (!licenseClient) {
             throw new Error("Coordinator agent execution authorization requires an initialized licensing client.");
         }
-        const controllerRunToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+        const controllerRunToken = currentLicenseSessionRunToken(licenseSession);
         if (!controllerRunToken) {
             throw new Error("Coordinator agent execution authorization requires an active controller run token.");
         }
-        const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? []);
+        const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? [], this.options.loadEngineContractVersion === 2, this.options.coordinatorTargetScenarios ?? []);
+        const expectedAgentIds = this.options.loadEngineContractVersion === 2
+            ? normalizeRequiredV2AgentIds(this.options.expectedAgentIds, assignments.length)
+            : undefined;
         const coordinator = new DistributedClusterCoordinator({
             clusterId: this.options.clusterId ?? "local",
             sessionId: testInfo.sessionId,
             testSuite: testInfo.testSuite,
             testName: testInfo.testName,
             expectedAgentResults: assignments.length,
+            expectedAgentIds,
+            loadEngineContractVersion: this.options.loadEngineContractVersion ?? 1,
             agentGroup: this.options.agentGroup,
             commandTimeoutMs: Math.max(Math.trunc((this.options.clusterCommandTimeoutSeconds ?? 120) * 1000), 1),
             nats: this.options.natsServerUrl
                 ? { ServerUrl: this.options.natsServerUrl }
                 : undefined
         });
-        const dispatch = await coordinator.dispatch(assignments, (command) => licenseClient.createAgentExecutionToken(controllerRunToken, testInfo.sessionId, command.commandId, command.agentIndex, command.agentCount, command.targetScenarios));
-        const nodes = dispatch.nodeResults.map((value) => clusterNodeResultToNodeStats(value, testInfo, { ...nodeInfo, nodeType: "Agent" }));
+        const tokenFactory = (command) => licenseClient.createAgentExecutionToken(currentLicenseSessionRunToken(licenseSession), testInfo.sessionId, command.commandId, command.agentIndex, command.agentCount, command.targetScenarios);
+        const dispatch = this.options.loadEngineContractVersion === 2
+            ? await coordinator.dispatchV2(assignments, buildRuntimeLoadEngineV2Plan(scenarios, this.options, testInfo, expectedAgentIds), tokenFactory)
+            : await coordinator.dispatch(assignments, tokenFactory);
+        const nodes = dispatch.nodeResults.map((value) => clusterNodeResultToNodeStats(value, testInfo, { ...nodeInfo, nodeType: "Agent" }, this.options.loadEngineContractVersion === 2));
         const coordinatorTargets = [...(this.options.coordinatorTargetScenarios ?? [])];
         if (coordinatorTargets.length) {
-            nodes.push(await this.runClusterChildNode(coordinatorTargets, "Coordinator", nodeInfo.machineName, false));
+            nodes.push(await this.runClusterChildNode(coordinatorTargets, "Coordinator", nodeInfo.machineName, false, {}, {
+                iterationObservationRunId,
+                iterationObservationSinks
+            }));
         }
-        let aggregated = aggregateNodeStats(testInfo, { ...nodeInfo, nodeType: "Coordinator" }, nodes);
+        let aggregated = aggregateNodeStats(testInfo, { ...nodeInfo, nodeType: "Coordinator" }, nodes, this.options.loadEngineContractVersion === 2);
         if (dispatch.missingNodes > 0) {
             aggregated = appendClusterPluginHint(aggregated, `Timed out waiting for ${dispatch.missingNodes} agent node result(s).`);
+            aggregated = attachNodeStatsAliases({
+                ...aggregated,
+                reportingComplete: false,
+                schedulerSegments: [
+                    ...(aggregated.schedulerSegments ?? []),
+                    ...(dispatch.ownerLoss?.schedulerSegments ?? [])
+                ],
+                generatorWarnings: [
+                    ...aggregated.generatorWarnings,
+                    ...(dispatch.ownerLoss?.generatorWarnings ?? []).map((warning) => ({
+                        code: warning.code,
+                        scenarioName: "cluster",
+                        simulationIndex: -1,
+                        count64: warning.count64,
+                        message: `Result owner ${warning.agentId} was lost after assignment; application failures were not fabricated.`,
+                        firstObservedUtcNs: "0",
+                        lastObservedUtcNs: "0"
+                    }))
+                ]
+            });
         }
         return aggregated;
     }
     async runAgentWithNats(startedUtc, testInfo, nodeInfo) {
+        const v2AgentId = this.options.loadEngineContractVersion === 2
+            ? requireNonEmpty(this.options.agentId ?? "", "Remote Load Engine V2 agents require an explicit stable AgentId.")
+            : `${nodeInfo.machineName}-${generateRuntimeSessionId()}`;
         const agent = new DistributedClusterAgent({
             clusterId: this.options.clusterId ?? "local",
             sessionId: testInfo.sessionId,
-            agentId: `${nodeInfo.machineName}-${generateRuntimeSessionId()}`,
+            agentId: v2AgentId,
+            loadEngineContractVersion: this.options.loadEngineContractVersion ?? 1,
+            validateV2Plan: this.options.loadEngineContractVersion === 2
+                ? (received) => {
+                    const local = buildRuntimeLoadEngineV2Plan(this.scenarios, this.options, { ...testInfo, sessionId: received.sessionId }, received.expectedAgentIds);
+                    local.runId = received.runId;
+                    local.registrationNonce = received.registrationNonce;
+                    if (buildLoadEngineV2Plan(local).hash !== buildLoadEngineV2Plan(received).hash) {
+                        throw new Error("Load Engine V2 signed plan descriptors do not match immutable local scenario declarations.");
+                    }
+                }
+                : undefined,
             agentGroup: this.options.agentGroup,
             nats: this.options.natsServerUrl
                 ? { ServerUrl: this.options.natsServerUrl }
@@ -3422,13 +3988,16 @@ export class LoadStrikeRunner {
             const deadline = Date.now() + Math.max(Math.trunc((this.options.clusterCommandTimeoutSeconds ?? 120) * 1000), 1);
             while (Date.now() < deadline) {
                 let handledStats = null;
-                const handled = await agent.pollAndExecuteOnce(async (dispatch) => {
+                const execute = async (dispatch) => {
                     handledStats = await this.runClusterChildNode(dispatch.scenarioNames, "Agent", nodeInfo.machineName, true, {
                         sessionId: testInfo.sessionId,
                         testSuite: testInfo.testSuite,
                         testName: testInfo.testName,
                         agentCommandId: dispatch.commandId,
-                        agentExecutionToken: dispatch.agentRunToken
+                        agentExecutionToken: dispatch.agentRunToken,
+                        clusterShardIndex: dispatch.agentIndex ?? 0,
+                        clusterShardCount: dispatch.agentCount ?? 1,
+                        loadEngineV2SegmentLifecycleOverride: dispatch.segmentLifecycle
                     });
                     return {
                         nodeId: handledStats.nodeInfo.machineName,
@@ -3436,9 +4005,12 @@ export class LoadStrikeRunner {
                         allRequestCount: handledStats.allRequestCount,
                         allOkCount: handledStats.allOkCount,
                         allFailCount: handledStats.allFailCount,
-                        stats: nodeStatsToClusterPayload(handledStats)
+                        stats: nodeStatsToClusterPayload(handledStats, this.scenarios.filter((scenario) => dispatch.scenarioNames.includes(scenario.name)), this.options.loadEngineContractVersion === 2)
                     };
-                });
+                };
+                const handled = this.options.loadEngineContractVersion === 2
+                    ? await agent.pollAndExecuteV2Once(execute)
+                    : await agent.pollAndExecuteOnce(execute);
                 if (handled && handledStats) {
                     return toDetailedRunResultFromNodeStats(handledStats, startedUtc, [], []);
                 }
@@ -3518,9 +4090,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);
@@ -3528,9 +4100,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);
@@ -3538,9 +4110,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);
@@ -3552,10 +4124,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();
@@ -3563,15 +4134,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);
@@ -3579,23 +4150,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) {
@@ -3603,9 +4200,7 @@ export class LoadStrikeRunner {
                     }
                     return;
                 }
-                if (retryBackoffMs > 0) {
-                    await sleep(retryBackoffMs * attempts);
-                }
+                await waitForSinkRetryDelay(nextDelayMs);
             }
         }
     }
@@ -3717,13 +4312,148 @@ function hasPluginRows(value) {
     }
     return value.tables.some((table) => Array.isArray(table.rows) && table.rows.length > 0);
 }
+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();
+    const toleranceNs = loadEngineV2LatenessToleranceNs(rate, intervalNs);
+    const active = new Set();
+    let schedulerLate = 0n;
+    let maxInFlight = 0n;
+    let executionError;
+    const normalizedShardCount = Math.max(Math.trunc(shardCount), 1);
+    const normalizedShardIndex = Math.min(Math.max(Math.trunc(shardIndex), 0), normalizedShardCount - 1);
+    const ordinals = ownedOrdinals
+        ? [...ownedOrdinals]
+        : (() => {
+            const values = [];
+            for (let ordinal = BigInt(normalizedShardIndex); ordinal < totalArrivals; ordinal += BigInt(normalizedShardCount)) {
+                values.push(ordinal);
+            }
+            return values;
+        })();
+    if (ordinals.some((ordinal, index) => ordinal < 0n || ordinal >= totalArrivals
+        || (index > 0 && ordinal <= ordinals[index - 1]))) {
+        throw new Error("Load Engine V2 owned arrival ordinals must be sorted, unique, and in range.");
+    }
+    if (segment) {
+        segment.planned = BigInt(ordinals.length);
+    }
+    for (const ordinal of ordinals) {
+        if (shouldStopNow())
+            break;
+        const index = Number(ordinal);
+        const deadlineNs = segmentStartNs
+            + (deadlineOffsetsNs?.[index] ?? loadEngineV2FixedDeadlineNs(ordinal, rate, intervalNs));
+        await delayUntilMonotonicDeadline(deadlineNs, cancellationToken);
+        if (shouldStopNow()) {
+            break;
+        }
+        const nowNs = process.hrtime.bigint();
+        if (segment)
+            segment.due += 1n;
+        if (segment)
+            telemetry?.recordDecisionLag(segment, nowNs - deadlineNs);
+        if (classifyLoadEngineV2Arrival(nowNs, deadlineNs, tolerancesNs?.[index] ?? toleranceNs, true) === "scheduler_late") {
+            schedulerLate += 1n;
+            if (segment) {
+                segment.dropped += 1n;
+                incrementReason(segment.dropReasons, "scheduler_late");
+            }
+            continue;
+        }
+        const release = budget.tryAcquire();
+        if (!release) {
+            maxInFlight += 1n;
+            if (segment) {
+                segment.dropped += 1n;
+                incrementReason(segment.dropReasons, "max_in_flight");
+            }
+            continue;
+        }
+        if (segment)
+            segment.started += 1n;
+        const instanceInfo = nextInstanceInfo();
+        let task;
+        task = (async () => {
+            if (segment)
+                telemetry?.recordStartLag(segment, process.hrtime.bigint() - deadlineNs);
+            await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, ordinal);
+        })().catch((error) => {
+            executionError ?? (executionError = error);
+        }).finally(() => {
+            if (segment)
+                segment.completed += 1n;
+            release();
+            active.delete(task);
+        });
+        active.add(task);
+    }
+    while (active.size > 0) {
+        await Promise.race(active);
+    }
+    if (segment) {
+        segment.unreached = segment.planned > segment.due ? segment.planned - segment.due : 0n;
+        segment.accountingComplete = segment.due + segment.unreached === segment.planned
+            && segment.started + segment.dropped === segment.due
+            && segment.completed === segment.started;
+    }
+    if (telemetry && segment) {
+        telemetry.recordWarning("scheduler_late", segment, schedulerLate);
+        telemetry.recordWarning("max_in_flight", segment, maxInFlight);
+    }
+    if (schedulerLate > 0n) {
+        logger.warn(`Load Engine V2 warning scheduler_late: dropped ${schedulerLate.toString()} overdue arrivals for scenario ${scenarioName}.`);
+    }
+    if (maxInFlight > 0n) {
+        logger.warn(`Load Engine V2 warning max_in_flight: dropped ${maxInFlight.toString()} arrivals for scenario ${scenarioName}; the process limit is ${budget.maxInFlight}.`);
+    }
+    if (executionError !== undefined) {
+        throw executionError;
+    }
+}
+async function delayUntilMonotonicDeadline(deadlineNs, cancellationToken) {
+    while (!cancellationToken.aborted) {
+        const remainingNs = deadlineNs - process.hrtime.bigint();
+        if (remainingNs <= 0n) {
+            return;
+        }
+        const remainingMs = Number((remainingNs + 999999n) / 1000000n);
+        await delayWithAbort(Math.max(1, Math.min(remainingMs, 50)), cancellationToken);
+    }
+}
+function secondsToNanoseconds(seconds, name) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new RangeError(`${name} must be greater than zero.`);
+    }
+    const nanoseconds = Math.trunc(seconds * 1000000000);
+    if (!Number.isSafeInteger(nanoseconds) || nanoseconds <= 0) {
+        throw new RangeError(`${name} is outside the supported nanosecond range.`);
+    }
+    return BigInt(nanoseconds);
+}
+function buildV2RampTolerances(offsets, durationNs) {
+    return offsets.map((offset, index) => {
+        const quantum = offsets.length === 1
+            ? durationNs
+            : index === 0
+                ? offsets[1] - offset
+                : offset - offsets[index - 1];
+        return minBigInt(100000000n, maxBigInt(2000000n, maxBigInt(1n, quantum) * 4n));
+    });
+}
+function minBigInt(left, right) {
+    return left < right ? left : right;
+}
+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, 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, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
     const scenarioStartedMs = Date.now();
     const scenarioContextData = {};
     const registeredMetrics = [];
     const runtime = ensureScenarioRuntime(scenarioRuntimes, scenario.name);
-    const accumulator = new ScenarioStatsAccumulator(scenario.name, scenarioIndex);
+    const accumulator = new ScenarioStatsAccumulator(scenario.name, scenarioIndex, options.loadEngineContractVersion === 2);
     scenarioAccumulators.set(scenario.name, accumulator);
     const scenarioAbortController = new AbortController();
     const scenarioCancellationToken = combineAbortSignals(testAbortController.signal, scenarioAbortController.signal);
@@ -3732,12 +4462,25 @@ async function executeScenarioRuntime(args) {
         ? Date.now() + Math.trunc(scenarioCompletionTimeoutSeconds * 1000)
         : Number.POSITIVE_INFINITY;
     const scenarioPartition = attachScenarioPartitionAliases({
-        number: 0,
-        count: 1
+        number: options.loadEngineContractVersion === 2 ? Math.max(Math.trunc(options.clusterShardIndex ?? 0), 0) : 0,
+        count: options.loadEngineContractVersion === 2 ? Math.max(Math.trunc(options.clusterShardCount ?? 1), 1) : 1
     });
+    const trafficMixV2 = options.loadEngineContractVersion === 2
+        ? scenario.__loadStrikeTrafficMixV2Metadata()
+        : undefined;
+    if (trafficMixV2) {
+        const expectedSeedId = buildLoadEngineV2TrafficMixSeedId(trafficMixV2.declarationIndex, trafficMixV2.name);
+        if (trafficMixV2.seedId !== expectedSeedId) {
+            throw new Error(`Load Engine V2 traffic-mix seed metadata differs for scenario ${scenario.name}.`);
+        }
+    }
     let stopScenario = false;
     let invocationNumber = 0;
     let instanceCounter = 0;
+    let nextV1ObservationOrdinal = 0n;
+    let nextV2FallbackOrdinal = BigInt(scenarioPartition.number);
+    let nextObservationStepSortIndex = 0;
+    const observationStepSortIndexes = new Map();
     const shouldStopNow = () => stopTestState.value
         || stopScenario
         || scenarioCancellationToken.aborted
@@ -3771,7 +4514,7 @@ async function executeScenarioRuntime(args) {
         runtime.maxLatencyMs = Math.max(runtime.maxLatencyMs, latencyMs);
         accumulator.recordScenario(reply, observedLatencyMs);
     };
-    const recordStepReply = (stepName, reply, observedLatencyMs) => {
+    const recordStepReply = (stepName, reply, observedLatencyMs, sortIndex) => {
         const key = `${scenario.name}::${stepName}`;
         const stepRuntime = ensureStepRuntime(stepRuntimes, key, scenario.name, stepName);
         if (reply.isSuccess) {
@@ -3794,11 +4537,35 @@ async function executeScenarioRuntime(args) {
         stepRuntime.maxLatencyMs = Math.max(stepRuntime.maxLatencyMs, latencyMs);
         const statusCode = normalizeStatusCode(reply.statusCode, reply.isSuccess);
         stepRuntime.statusCodes[statusCode] = (stepRuntime.statusCodes[statusCode] ?? 0) + 1;
-        accumulator.recordStep(stepName, reply, observedLatencyMs);
+        return accumulator.recordStep(stepName, reply, observedLatencyMs, sortIndex);
+    };
+    const resolveObservationStepSortIndex = (stepName) => {
+        const existing = observationStepSortIndexes.get(stepName);
+        if (existing !== undefined) {
+            return existing;
+        }
+        nextObservationStepSortIndex += 1;
+        observationStepSortIndexes.set(stepName, nextObservationStepSortIndex);
+        return nextObservationStepSortIndex;
+    };
+    const nextObservationOrdinal = (explicit) => {
+        if (explicit !== undefined) {
+            return explicit;
+        }
+        if (options.loadEngineContractVersion === 2) {
+            const ordinal = nextV2FallbackOrdinal;
+            nextV2FallbackOrdinal += BigInt(scenarioPartition.count);
+            return ordinal;
+        }
+        const ordinal = nextV1ObservationOrdinal;
+        nextV1ObservationOrdinal += 1n;
+        return ordinal;
     };
     const runSingleInvocation = async (operation, instanceData, instanceNumber, instanceId, recordScenarioResult) => {
         invocationNumber += 1;
         const runtimeRandom = createRuntimeRandom();
+        const attemptSteps = [];
+        const recordedSteps = [];
         const context = {
             scenarioName: scenario.name,
             data: scenarioContextData,
@@ -3827,7 +4594,12 @@ async function executeScenarioRuntime(args) {
                 testAbortController.abort(stopTestState.reason);
             },
             recordStep: (stepName, reply, observedLatencyMs) => {
-                recordStepReply(stepName, reply, observedLatencyMs);
+                const sortIndex = resolveObservationStepSortIndex(stepName);
+                recordedSteps.push({ stepName, reply, observedLatencyMs, sortIndex });
+                return sortIndex;
+            },
+            recordStepObservation: (observation) => {
+                attemptSteps.push(observation);
             },
             shouldStopScenario: () => stopScenario || scenarioCancellationToken.aborted,
             shouldStopTest: () => stopTestState.value || scenarioCancellationToken.aborted,
@@ -3835,28 +4607,100 @@ async function executeScenarioRuntime(args) {
             invokeAfterStep: async (stepName, reply) => invokeAfterStep(policies, scenario.name, stepName, reply)
         };
         attachScenarioContextAliases(context);
-        const startedAt = Date.now();
-        const reply = await executeScenarioInvocation(scenario, context, operation);
-        const observedLatencyMs = Math.max(Date.now() - startedAt, 0);
+        const startedUtcNs = utcNowNs();
+        const startedAtNs = process.hrtime.bigint();
+        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;
         if (recordScenarioResult) {
             recordScenarioReply(reply, observedLatencyMs);
         }
-        return { reply, observedLatencyMs };
+        return {
+            reply,
+            observedLatencyMs,
+            startedUtcNs,
+            completedUtcNs,
+            observedLatencyUs: observedLatencyNs / 1000n,
+            reportedLatencyUs: normalizeRawObservationLatencyMicroseconds(resolveRecordedLatency(reply.customLatencyMs, observedLatencyMs)),
+            steps: attemptSteps,
+            recordedSteps,
+            ...(policyFailure ? { policyFailure } : {})
+        };
+    };
+    const captureAttemptObservation = (operation, globalOrdinal, attemptIndex, isFinalAttempt, attempt, simulationIndex, simulationKind, iterationId, globalSecondaryOrdinal = 0n) => {
+        if (!iterationObservationReporter?.enabled) {
+            return;
+        }
+        iterationObservationReporter.capture(createIterationObservation({
+            runId: iterationObservationRunId,
+            sessionId: testInfo.sessionId,
+            resultOwnerId: iterationObservationResultOwnerId,
+            processGroup: iterationObservationProcessGroup,
+            scenarioName: scenario.name,
+            scenarioIndex,
+            simulationIndex,
+            simulationKind,
+            phase: operation === "WarmUp" ? "warmup" : "bombing",
+            globalOrdinal64: globalOrdinal,
+            globalSecondaryOrdinal64: globalSecondaryOrdinal,
+            ...(iterationId ? { iterationId } : {}),
+            shardIndex: scenarioPartition.number,
+            shardCount: scenarioPartition.count,
+            attemptIndex,
+            isFinalAttempt,
+            startedUtcNs: attempt.startedUtcNs,
+            completedUtcNs: attempt.completedUtcNs,
+            observedLatencyUs64: attempt.observedLatencyUs,
+            reportedLatencyUs64: attempt.reportedLatencyUs,
+            isSuccess: attempt.reply.isSuccess,
+            statusCode: normalizeStatusCode(attempt.reply.statusCode, attempt.reply.isSuccess),
+            sizeBytes64: normalizeHistogramInteger(Math.max(toNumber(attempt.reply.sizeBytes), 0), "Scenario response bytes"),
+            steps: attempt.steps
+        }));
     };
-    const runBombingInvocation = async (instanceData, instanceNumber, instanceId) => {
+    const runBombingInvocation = async (instanceData, instanceNumber, instanceId, explicitGlobalOrdinal, simulationIndex = -1, simulationKind = "SingleInvocation", explicitSecondaryOrdinal = 0n) => {
         if (shouldStopNow()) {
             return;
         }
+        const globalOrdinal = nextObservationOrdinal(explicitGlobalOrdinal);
+        const identityKind = canonicalLoadEngineV2InvocationIdentityKind(simulationKind);
+        const iterationId = options.loadEngineContractVersion === 2
+            && explicitGlobalOrdinal !== undefined
+            && identityKind
+            ? buildLoadEngineV2GlobalInvocationId(iterationObservationRunId, scenarioIndex, simulationIndex, identityKind, globalOrdinal, explicitSecondaryOrdinal)
+            : undefined;
         let attempts = 0;
         const maxAttempts = 1 + (scenario.shouldRestartIterationOnFail() ? restartIterationMaxAttempts : 0);
         while (attempts < maxAttempts && !shouldStopNow()) {
             attempts += 1;
             const attempt = await runSingleInvocation("Bombing", instanceData, instanceNumber, instanceId, false);
-            const shouldRetry = !attempt.reply.isSuccess
+            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);
+                }
                 recordScenarioReply(attempt.reply, attempt.observedLatencyMs);
                 if (scenario.getMaxFailCount() > 0 && runtime.allFailCount >= scenario.getMaxFailCount()) {
                     stopScenario = true;
@@ -3876,30 +4720,287 @@ async function executeScenarioRuntime(args) {
         const endMs = Date.now() + Math.trunc(warmUpDurationSeconds * 1000);
         const instanceInfo = nextInstanceInfo();
         while (Date.now() < endMs && !shouldStopNow()) {
-            await runSingleInvocation("WarmUp", instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, false);
+            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 executeSimulationAsync = async (simulation) => {
-        const kind = String(simulation.Kind ?? "");
-        const weight = Math.max(scenario.getWeight(), 1);
-        const rate = applyScenarioWeight(toInt(simulation.Rate), weight);
-        const minRate = applyScenarioWeight(toInt(simulation.MinRate), weight);
-        const maxRate = applyScenarioWeight(toInt(simulation.MaxRate), weight);
-        const copies = Math.max(applyScenarioWeight(Math.max(toInt(simulation.Copies), 1), weight), 1);
-        const iterations = applyScenarioWeight(Math.max(toInt(simulation.Iterations), 0), weight);
-        const intervalMs = Math.max(Math.trunc(Math.max(toNumber(simulation.IntervalSeconds), 0) * 1000), 0);
-        const duringMs = Math.max(Math.trunc(Math.max(toNumber(simulation.DuringSeconds), 0) * 1000), 0);
-        accumulator.setLoadSimulation(kind, resolveLoadSimulationValue(simulation, weight));
+    const executeV2TimedConstant = async (copies, durationNs, ramping, runSimulationInvocation, segment) => {
+        if (!loadEngineV2Budget) {
+            return;
+        }
+        const offsets = ramping ? planRampingConstantDeadlines(copies, durationNs) : Array(copies).fill(0n);
+        const ownedWorkerSlots = trafficMixV2
+            ? loadEngineV2TrafficMixOwnedUnits(BigInt(copies), trafficMixV2.shareWeights, trafficMixV2.laneIndex, scenarioPartition.number, scenarioPartition.count)
+            : offsets.flatMap((_offset, workerSlot) => workerSlot % scenarioPartition.count === scenarioPartition.number
+                ? [{ laneOrdinal: BigInt(workerSlot), globalRank: BigInt(workerSlot) }]
+                : []);
+        const quantum = ramping ? maxBigInt(1n, durationNs / BigInt(copies)) : 1n;
+        const toleranceNs = minBigInt(100000000n, maxBigInt(2000000n, quantum * 4n));
+        const startNs = process.hrtime.bigint();
+        const endNs = startNs + durationNs;
+        const active = new Set();
+        let schedulerLate = 0;
+        let unavailable = 0;
+        let executionError;
+        if (segment) {
+            segment.requestedWorkers = BigInt(ownedWorkerSlots.length);
+        }
+        for (const unit of ownedWorkerSlots) {
+            const offsetNs = offsets[Number(unit.globalRank)];
+            await delayUntilMonotonicDeadline(startNs + offsetNs, scenarioCancellationToken);
+            if (shouldStopNow()) {
+                break;
+            }
+            const decisionNowNs = process.hrtime.bigint();
+            if (segment)
+                loadEngineV2Telemetry?.recordDecisionLag(segment, decisionNowNs - (startNs + offsetNs));
+            if (decisionNowNs - (startNs + offsetNs) > toleranceNs) {
+                schedulerLate += 1;
+                if (segment) {
+                    segment.unavailableWorkers += 1n;
+                    incrementReason(segment.unavailableWorkerReasons, "scheduler_late");
+                }
+                continue;
+            }
+            const release = loadEngineV2Budget.tryAcquire();
+            if (!release) {
+                unavailable += 1;
+                if (segment) {
+                    segment.unavailableWorkers += 1n;
+                    incrementReason(segment.unavailableWorkerReasons, "max_in_flight");
+                }
+                continue;
+            }
+            if (segment)
+                segment.startedWorkers += 1n;
+            const instanceInfo = nextInstanceInfo();
+            let task;
+            task = (async () => {
+                if (segment) {
+                    loadEngineV2Telemetry?.recordStartLag(segment, process.hrtime.bigint() - (startNs + offsetNs));
+                }
+                let completedSinceYield = 0;
+                let workerIterationIndex = 0n;
+                while (process.hrtime.bigint() < endNs && !shouldStopNow()) {
+                    if (segment) {
+                        segment.planned += 1n;
+                        segment.due += 1n;
+                        segment.started += 1n;
+                    }
+                    await runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, unit.globalRank, workerIterationIndex);
+                    workerIterationIndex += 1n;
+                    if (segment)
+                        segment.completed += 1n;
+                    completedSinceYield += 1;
+                    if (completedSinceYield >= 64) {
+                        completedSinceYield = 0;
+                        await new Promise((resolve) => setImmediate(resolve));
+                    }
+                }
+            })().catch((error) => {
+                executionError ?? (executionError = error);
+            }).finally(() => {
+                release();
+                active.delete(task);
+            });
+            active.add(task);
+        }
+        while (active.size > 0) {
+            await Promise.race(active);
+        }
+        if (segment) {
+            segment.accountingComplete = segment.completed === segment.started
+                && segment.started === segment.due
+                && segment.due === segment.planned
+                && segment.startedWorkers + segment.unavailableWorkers === segment.requestedWorkers;
+            loadEngineV2Telemetry?.recordWarning("scheduler_late", segment, BigInt(schedulerLate));
+            loadEngineV2Telemetry?.recordWarning("max_in_flight", segment, BigInt(unavailable));
+        }
+        if (schedulerLate > 0) {
+            logger.warn(`Load Engine V2 warning scheduler_late: ${schedulerLate} constant worker slots were unavailable for scenario ${scenario.name}.`);
+        }
+        if (unavailable > 0) {
+            logger.warn(`Load Engine V2 warning max_in_flight: ${unavailable} constant worker slots were unavailable for scenario ${scenario.name}.`);
+        }
+        if (executionError !== undefined) {
+            throw executionError;
+        }
+    };
+    const executeV2IterationsConstant = async (copies, iterations, runSimulationInvocation, segment) => {
+        if (!loadEngineV2Budget || iterations <= 0) {
+            return;
+        }
+        let activeShardCount;
+        let ownedWorkerSlots;
+        let ownedIterations;
+        if (trafficMixV2) {
+            const laneCopies = loadEngineV2TrafficMixLaneUnitCount(BigInt(copies), trafficMixV2.shareWeights, trafficMixV2.laneIndex);
+            const laneIterations = loadEngineV2TrafficMixLaneUnitCount(BigInt(iterations), trafficMixV2.shareWeights, trafficMixV2.laneIndex);
+            if (laneIterations === 0n) {
+                if (segment) {
+                    segment.requestedWorkers = 0n;
+                    segment.accountingComplete = true;
+                }
+                return;
+            }
+            if (laneCopies === 0n) {
+                throw new Error("Load Engine V2 traffic-mix lane owns iterations but no constant worker slot.");
+            }
+            activeShardCount = Math.min(scenarioPartition.count, Number(laneCopies), Number(laneIterations));
+            if (scenarioPartition.number >= activeShardCount) {
+                if (segment) {
+                    segment.requestedWorkers = 0n;
+                    segment.accountingComplete = true;
+                }
+                return;
+            }
+            ownedWorkerSlots = loadEngineV2TrafficMixOwnedUnits(BigInt(copies), trafficMixV2.shareWeights, trafficMixV2.laneIndex, scenarioPartition.number, activeShardCount);
+            ownedIterations = loadEngineV2TrafficMixOwnedUnits(BigInt(iterations), trafficMixV2.shareWeights, trafficMixV2.laneIndex, scenarioPartition.number, activeShardCount);
+        }
+        else {
+            activeShardCount = Math.min(scenarioPartition.count, copies, iterations);
+            if (scenarioPartition.number >= activeShardCount) {
+                return;
+            }
+            ownedWorkerSlots = Array.from({ length: copies }, (_value, slot) => slot)
+                .filter((slot) => slot % activeShardCount === scenarioPartition.number)
+                .map((slot) => ({ laneOrdinal: BigInt(slot), globalRank: BigInt(slot) }));
+            ownedIterations = Array.from({ length: iterations }, (_value, ordinal) => ordinal)
+                .filter((ordinal) => ordinal % activeShardCount === scenarioPartition.number)
+                .map((ordinal) => ({ laneOrdinal: BigInt(ordinal), globalRank: BigInt(ordinal) }));
+        }
+        if (scenarioPartition.number >= activeShardCount) {
+            return;
+        }
+        const targetWorkers = Math.min(ownedWorkerSlots.length, ownedIterations.length);
+        if (targetWorkers <= 0) {
+            if (segment) {
+                segment.requestedWorkers = 0n;
+                segment.accountingComplete = true;
+            }
+            return;
+        }
+        if (segment) {
+            segment.planned = BigInt(ownedIterations.length);
+            segment.requestedWorkers = BigInt(targetWorkers);
+        }
+        const releases = [];
+        let firstRelease;
+        while (!firstRelease && !shouldStopNow()) {
+            firstRelease = loadEngineV2Budget.tryAcquire();
+            if (!firstRelease) {
+                await delayWithAbort(1, scenarioCancellationToken);
+            }
+        }
+        if (!firstRelease) {
+            if (segment) {
+                segment.unreached = segment.planned;
+                segment.unavailableWorkers = segment.requestedWorkers;
+                if (segment.unavailableWorkers > 0n) {
+                    incrementReason(segment.unavailableWorkerReasons, "cancelled", segment.unavailableWorkers);
+                }
+                segment.accountingComplete = true;
+            }
+            return;
+        }
+        releases.push(firstRelease);
+        for (let worker = 1; worker < targetWorkers; worker += 1) {
+            const release = loadEngineV2Budget.tryAcquire();
+            if (release) {
+                releases.push(release);
+            }
+        }
+        if (releases.length < targetWorkers) {
+            logger.warn(`Load Engine V2 warning max_in_flight: requested ${targetWorkers} constant workers but started ${releases.length} for scenario ${scenario.name}; all iterations will still run.`);
+        }
+        if (segment) {
+            segment.startedWorkers = BigInt(releases.length);
+            segment.unavailableWorkers = BigInt(targetWorkers - releases.length);
+            if (segment.unavailableWorkers > 0n) {
+                incrementReason(segment.unavailableWorkerReasons, "max_in_flight", segment.unavailableWorkers);
+                loadEngineV2Telemetry?.recordWarning("max_in_flight", segment, segment.unavailableWorkers);
+            }
+        }
+        let nextIterationIndex = 0;
+        const tasks = releases.map(async (release) => {
+            const instanceInfo = nextInstanceInfo();
+            try {
+                while (!shouldStopNow()) {
+                    const unit = ownedIterations[nextIterationIndex];
+                    nextIterationIndex += 1;
+                    if (!unit) {
+                        break;
+                    }
+                    if (segment) {
+                        segment.due += 1n;
+                        segment.started += 1n;
+                    }
+                    await runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, unit.globalRank, 0n);
+                    if (segment)
+                        segment.completed += 1n;
+                }
+            }
+            finally {
+                release();
+            }
+        });
+        await waitForScenarioTasks(tasks, scenario.name, scenarioCompletionTimeoutSeconds, logger, scenarioCancellationToken);
+        if (segment) {
+            segment.unreached = segment.planned > segment.due ? segment.planned - segment.due : 0n;
+            segment.accountingComplete = segment.due + segment.unreached === segment.planned
+                && segment.started === segment.due
+                && segment.completed === segment.started
+                && segment.startedWorkers + segment.unavailableWorkers === segment.requestedWorkers;
+        }
+    };
+    const executeSimulationAsync = async (simulation, simulationIndex) => {
+        const descriptor = trafficMixV2
+            ? trafficMixV2.originalSimulations[simulationIndex]
+            : simulation;
+        if (!descriptor) {
+            throw new Error(`Load Engine V2 traffic-mix phase ${simulationIndex} is missing its global descriptor.`);
+        }
+        const kind = String(descriptor.Kind ?? "");
+        const simulationKind = kind || "SingleInvocation";
+        const runSimulationInvocation = (instanceData, instanceNumber, instanceId, explicitGlobalOrdinal, explicitSecondaryOrdinal = 0n) => runBombingInvocation(instanceData, instanceNumber, instanceId, explicitGlobalOrdinal, simulationIndex, simulationKind, explicitSecondaryOrdinal);
+        if (options.loadEngineContractVersion === 2) {
+            nextV2FallbackOrdinal = BigInt(scenarioPartition.number);
+        }
+        const weight = trafficMixV2 ? 1 : Math.max(scenario.getWeight(), 1);
+        const rate = applyScenarioWeight(toInt(descriptor.Rate), weight);
+        const minRate = applyScenarioWeight(toInt(descriptor.MinRate), weight);
+        const maxRate = applyScenarioWeight(toInt(descriptor.MaxRate), weight);
+        const copies = Math.max(applyScenarioWeight(Math.max(toInt(descriptor.Copies), 1), weight), 1);
+        const iterations = applyScenarioWeight(Math.max(toInt(descriptor.Iterations), 0), weight);
+        const intervalMs = Math.max(Math.trunc(Math.max(toNumber(descriptor.IntervalSeconds), 0) * 1000), 0);
+        const duringMs = Math.max(Math.trunc(Math.max(toNumber(descriptor.DuringSeconds), 0) * 1000), 0);
+        accumulator.setLoadSimulation(kind, resolveLoadSimulationValue(descriptor, weight));
         accumulator.setCurrentOperation("Bombing");
+        const schedulerSegment = options.loadEngineContractVersion === 2
+            ? loadEngineV2Telemetry?.createSegment(scenario.name, scenarioIndex, simulationIndex, kind, scenarioPartition.number, scenarioPartition.count)
+            : undefined;
+        const trafficMixOwnedOrdinals = (total) => trafficMixV2
+            ? loadEngineV2TrafficMixOwnedUnits(total, trafficMixV2.shareWeights, trafficMixV2.laneIndex, scenarioPartition.number, scenarioPartition.count).map((unit) => unit.globalRank)
+            : undefined;
         if (kind === "KeepConstant") {
             if (duringMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                await executeV2TimedConstant(copies, secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "KeepConstant duration"), false, runSimulationInvocation, schedulerSegment);
+                return;
+            }
             const endMs = Date.now() + duringMs;
             const tasks = Array.from({ length: copies }, async () => {
                 const instanceInfo = nextInstanceInfo();
                 while (Date.now() < endMs && !shouldStopNow()) {
-                    await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
+                    await runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
                 }
             });
             await waitForScenarioTasks(tasks, scenario.name, scenarioCompletionTimeoutSeconds, logger, scenarioCancellationToken);
@@ -3909,6 +5010,10 @@ async function executeScenarioRuntime(args) {
             if (duringMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                await executeV2TimedConstant(copies, secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "RampingConstant duration"), true, runSimulationInvocation, schedulerSegment);
+                return;
+            }
             const tasks = [];
             const endMs = Date.now() + duringMs;
             const startIntervalMs = copies <= 1 ? 0 : Math.max(Math.trunc(duringMs / copies), 0);
@@ -3916,7 +5021,7 @@ async function executeScenarioRuntime(args) {
                 const instanceInfo = nextInstanceInfo();
                 tasks.push((async () => {
                     while (Date.now() < endMs && !shouldStopNow()) {
-                        await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
+                        await runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
                     }
                 })());
                 if (copy < copies && startIntervalMs > 0) {
@@ -3930,12 +5035,34 @@ async function executeScenarioRuntime(args) {
             if (duringMs <= 0 || rate <= 0 || intervalMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                const intervalNs = secondsToNanoseconds(toNumber(descriptor.IntervalSeconds), "Inject interval");
+                const durationNs = secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "Inject duration");
+                await executeV2FixedArrivals({
+                    rate,
+                    intervalNs,
+                    totalArrivals: loadEngineV2FixedArrivalCount(rate, intervalNs, durationNs),
+                    budget: loadEngineV2Budget,
+                    cancellationToken: scenarioCancellationToken,
+                    shouldStopNow,
+                    nextInstanceInfo,
+                    runBombingInvocation: runSimulationInvocation,
+                    logger,
+                    scenarioName: scenario.name,
+                    shardIndex: scenarioPartition.number,
+                    shardCount: scenarioPartition.count,
+                    ownedOrdinals: trafficMixOwnedOrdinals(loadEngineV2FixedArrivalCount(rate, intervalNs, durationNs)),
+                    telemetry: loadEngineV2Telemetry,
+                    segment: schedulerSegment
+                });
+                return;
+            }
             const pending = [];
             const endMs = Date.now() + duringMs;
             while (Date.now() < endMs && !shouldStopNow()) {
                 for (let index = 0; index < rate; index += 1) {
                     const instanceInfo = nextInstanceInfo();
-                    pending.push(runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
+                    pending.push(runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
                 }
                 await delayWithAbort(intervalMs, scenarioCancellationToken);
             }
@@ -3946,6 +5073,31 @@ async function executeScenarioRuntime(args) {
             if (duringMs <= 0 || rate <= 0 || intervalMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                const intervalNs = secondsToNanoseconds(toNumber(descriptor.IntervalSeconds), "RampingInject interval");
+                const durationNs = secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "RampingInject duration");
+                const offsets = planRampingInjectionDeadlines(rate, intervalNs, durationNs);
+                await executeV2FixedArrivals({
+                    rate,
+                    intervalNs,
+                    totalArrivals: BigInt(offsets.length),
+                    deadlineOffsetsNs: offsets,
+                    tolerancesNs: buildV2RampTolerances(offsets, durationNs),
+                    budget: loadEngineV2Budget,
+                    cancellationToken: scenarioCancellationToken,
+                    shouldStopNow,
+                    nextInstanceInfo,
+                    runBombingInvocation: runSimulationInvocation,
+                    logger,
+                    scenarioName: scenario.name,
+                    shardIndex: scenarioPartition.number,
+                    shardCount: scenarioPartition.count,
+                    ownedOrdinals: trafficMixOwnedOrdinals(BigInt(offsets.length)),
+                    telemetry: loadEngineV2Telemetry,
+                    segment: schedulerSegment
+                });
+                return;
+            }
             const pending = [];
             const startedAtMs = Date.now();
             const endMs = startedAtMs + duringMs;
@@ -3955,7 +5107,7 @@ async function executeScenarioRuntime(args) {
                 const currentRate = Math.max(1, Math.ceil(rate * progress));
                 for (let index = 0; index < currentRate; index += 1) {
                     const instanceInfo = nextInstanceInfo();
-                    pending.push(runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
+                    pending.push(runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
                 }
                 await delayWithAbort(intervalMs, scenarioCancellationToken);
             }
@@ -3966,6 +5118,37 @@ async function executeScenarioRuntime(args) {
             if (duringMs <= 0 || maxRate <= 0 || intervalMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                const intervalNs = secondsToNanoseconds(toNumber(descriptor.IntervalSeconds), "InjectRandom interval");
+                const durationNs = secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "InjectRandom duration");
+                const descriptorSeed = fnv1a32(trafficMixV2
+                    ? `traffic-mix\n${trafficMixV2.seedId}\n${simulationIndex}`
+                    : `${scenario.name}\n${simulationIndex}`);
+                const rotated = ((descriptorSeed << 13) | (descriptorSeed >>> 19)) >>> 0;
+                const seed = (fnv1a32(testInfo.sessionId) ^ rotated) >>> 0;
+                const offsets = planRandomInjectionDeadlines(Math.max(0, minRate), maxRate, intervalNs, durationNs, seed);
+                const tolerance = loadEngineV2LatenessToleranceNs(Math.max(1, maxRate), intervalNs);
+                await executeV2FixedArrivals({
+                    rate: Math.max(1, maxRate),
+                    intervalNs,
+                    totalArrivals: BigInt(offsets.length),
+                    deadlineOffsetsNs: offsets,
+                    tolerancesNs: offsets.map(() => tolerance),
+                    budget: loadEngineV2Budget,
+                    cancellationToken: scenarioCancellationToken,
+                    shouldStopNow,
+                    nextInstanceInfo,
+                    runBombingInvocation: runSimulationInvocation,
+                    logger,
+                    scenarioName: scenario.name,
+                    shardIndex: scenarioPartition.number,
+                    shardCount: scenarioPartition.count,
+                    ownedOrdinals: trafficMixOwnedOrdinals(BigInt(offsets.length)),
+                    telemetry: loadEngineV2Telemetry,
+                    segment: schedulerSegment
+                });
+                return;
+            }
             const pending = [];
             const normalizedMinRate = Math.max(1, minRate);
             const normalizedMaxRate = Math.max(normalizedMinRate, maxRate);
@@ -3974,7 +5157,7 @@ async function executeScenarioRuntime(args) {
                 const currentRate = randomIntInclusive(normalizedMinRate, normalizedMaxRate);
                 for (let index = 0; index < currentRate; index += 1) {
                     const instanceInfo = nextInstanceInfo();
-                    pending.push(runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
+                    pending.push(runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
                 }
                 await delayWithAbort(intervalMs, scenarioCancellationToken);
             }
@@ -3985,6 +5168,10 @@ async function executeScenarioRuntime(args) {
             if (iterations <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                await executeV2IterationsConstant(copies, iterations, runSimulationInvocation, schedulerSegment);
+                return;
+            }
             let remaining = iterations;
             const tasks = Array.from({ length: copies }, async () => {
                 const instanceInfo = nextInstanceInfo();
@@ -3993,7 +5180,7 @@ async function executeScenarioRuntime(args) {
                     if (remaining < 0) {
                         break;
                     }
-                    await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
+                    await runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
                 }
             });
             await waitForScenarioTasks(tasks, scenario.name, scenarioCompletionTimeoutSeconds, logger, scenarioCancellationToken);
@@ -4003,13 +5190,33 @@ async function executeScenarioRuntime(args) {
             if (iterations <= 0 || rate <= 0 || intervalMs <= 0) {
                 return;
             }
+            if (options.loadEngineContractVersion === 2 && loadEngineV2Budget) {
+                await executeV2FixedArrivals({
+                    rate,
+                    intervalNs: secondsToNanoseconds(toNumber(descriptor.IntervalSeconds), "IterationsForInject interval"),
+                    totalArrivals: BigInt(iterations),
+                    budget: loadEngineV2Budget,
+                    cancellationToken: scenarioCancellationToken,
+                    shouldStopNow,
+                    nextInstanceInfo,
+                    runBombingInvocation: runSimulationInvocation,
+                    logger,
+                    scenarioName: scenario.name,
+                    shardIndex: scenarioPartition.number,
+                    shardCount: scenarioPartition.count,
+                    ownedOrdinals: trafficMixOwnedOrdinals(BigInt(iterations)),
+                    telemetry: loadEngineV2Telemetry,
+                    segment: schedulerSegment
+                });
+                return;
+            }
             const pending = [];
             let remaining = iterations;
             while (remaining > 0 && !shouldStopNow()) {
                 const count = Math.min(rate, remaining);
                 for (let index = 0; index < count; index += 1) {
                     const instanceInfo = nextInstanceInfo();
-                    pending.push(runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
+                    pending.push(runSimulationInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId));
                 }
                 remaining -= count;
                 if (remaining > 0) {
@@ -4021,10 +5228,19 @@ async function executeScenarioRuntime(args) {
         }
         if (kind === "Pause") {
             if (duringMs > 0) {
-                await delayWithAbort(duringMs, scenarioCancellationToken);
+                if (options.loadEngineContractVersion === 2) {
+                    await delayUntilMonotonicDeadline(process.hrtime.bigint() + secondsToNanoseconds(toNumber(descriptor.DuringSeconds), "Pause duration"), scenarioCancellationToken);
+                }
+                else {
+                    await delayWithAbort(duringMs, scenarioCancellationToken);
+                }
             }
+            if (schedulerSegment)
+                schedulerSegment.accountingComplete = true;
             return;
         }
+        if (schedulerSegment)
+            schedulerSegment.accountingComplete = true;
     };
     const initContext = {
         customSettings: { ...(options.customSettings ?? {}) },
@@ -4056,15 +5272,33 @@ async function executeScenarioRuntime(args) {
         accumulator.setCurrentOperation("Bombing");
         const simulations = scenario.getSimulations();
         if (!simulations.length) {
-            const instanceInfo = nextInstanceInfo();
-            await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
+            if (options.loadEngineContractVersion === 2) {
+                await options.loadEngineV2SegmentLifecycleOverride?.beforeSegment(scenarioIndex, 0);
+                try {
+                    await executeSimulationAsync(LoadStrikeSimulation.iterationsForConstant(1, 1), 0);
+                }
+                finally {
+                    await options.loadEngineV2SegmentLifecycleOverride?.afterSegment(scenarioIndex, 0);
+                }
+            }
+            else {
+                const instanceInfo = nextInstanceInfo();
+                await runBombingInvocation(instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId);
+            }
         }
         else {
-            for (const simulation of simulations) {
+            for (let simulationIndex = 0; simulationIndex < simulations.length; simulationIndex += 1) {
+                const simulation = simulations[simulationIndex];
                 if (shouldStopNow()) {
                     break;
                 }
-                await executeSimulationAsync(simulation);
+                await options.loadEngineV2SegmentLifecycleOverride?.beforeSegment(scenarioIndex, simulationIndex);
+                try {
+                    await executeSimulationAsync(simulation, simulationIndex);
+                }
+                finally {
+                    await options.loadEngineV2SegmentLifecycleOverride?.afterSegment(scenarioIndex, simulationIndex);
+                }
             }
         }
         accumulator.setCurrentOperation(stopScenario || stopTestState.value ? "Stop" : "Complete");
@@ -4153,18 +5387,36 @@ async function waitForScenarioTasks(tasks, scenarioName, timeoutSeconds, logger,
     if (!tasks.length) {
         return;
     }
-    const all = Promise.allSettled(tasks).then(() => { });
-    if (timeoutSeconds <= 0) {
-        await all;
-        return;
+    const settled = Promise.allSettled(tasks);
+    const throwPolicyFailure = (results) => {
+        const failure = results.find((result) => result.status === "rejected" && result.reason instanceof RuntimePolicyCallbackError);
+        if (failure) {
+            throw failure.reason;
+        }
+    };
+    if (timeoutSeconds <= 0) {
+        throwPolicyFailure(await settled);
+        return;
+    }
+    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();
     }
-    const completed = await Promise.race([
-        all.then(() => true),
-        delayWithAbort(Math.trunc(timeoutSeconds * 1000), signal).then(() => false)
-    ]);
     if (!completed) {
+        if (signal.reason instanceof RuntimePolicyCallbackError) {
+            throw signal.reason;
+        }
         logger.warn(`Scenario ${scenarioName} timed out while waiting for completion (${timeoutSeconds}s).`);
+        return;
     }
+    throwPolicyFailure(await settled);
 }
 function randomIntInclusive(minValue, maxValue) {
     const min = Math.trunc(Math.min(minValue, maxValue));
@@ -4391,6 +5643,9 @@ function normalizeDataTransferStatsValue(value) {
     const source = asAliasRecord(value);
     return {
         allBytes: pickAliasNumber(source, "allBytes", "AllBytes"),
+        ...(hasAliasValue(source, "allBytes64", "AllBytes64")
+            ? { allBytes64: pickAliasString(source, "allBytes64", "AllBytes64") }
+            : {}),
         maxBytes: pickAliasNumber(source, "maxBytes", "MaxBytes"),
         meanBytes: pickAliasNumber(source, "meanBytes", "MeanBytes"),
         minBytes: pickAliasNumber(source, "minBytes", "MinBytes"),
@@ -4398,6 +5653,9 @@ function normalizeDataTransferStatsValue(value) {
         percent75: pickAliasNumber(source, "percent75", "Percent75"),
         percent95: pickAliasNumber(source, "percent95", "Percent95"),
         percent99: pickAliasNumber(source, "percent99", "Percent99"),
+        ...(hasAliasValue(source, "percent100", "Percent100")
+            ? { percent100: pickAliasNumber(source, "percent100", "Percent100") }
+            : {}),
         stdDev: pickAliasNumber(source, "stdDev", "StdDev")
     };
 }
@@ -4420,6 +5678,9 @@ function normalizeLatencyStatsValue(value) {
         percent75: pickAliasNumber(source, "percent75", "Percent75"),
         percent95: pickAliasNumber(source, "percent95", "Percent95"),
         percent99: pickAliasNumber(source, "percent99", "Percent99"),
+        ...(hasAliasValue(source, "percent100", "Percent100")
+            ? { percent100: pickAliasNumber(source, "percent100", "Percent100") }
+            : {}),
         stdDev: pickAliasNumber(source, "stdDev", "StdDev")
     };
 }
@@ -4435,13 +5696,42 @@ function normalizeStatusCodeStatsValue(value) {
 }
 function normalizeMeasurementStatsValue(value) {
     const source = asAliasRecord(value);
-    return {
+    const projected = {
+        ...(hasAliasValue(source, "count64", "Count64")
+            ? { count64: pickAliasString(source, "count64", "Count64") }
+            : {}),
+        ...(hasAliasValue(source, "distributionMode", "DistributionMode")
+            ? { distributionMode: pickAliasString(source, "distributionMode", "DistributionMode") }
+            : {}),
+        ...(hasAliasValue(source, "maxRelativeError", "MaxRelativeError")
+            ? { maxRelativeError: pickAliasNumber(source, "maxRelativeError", "MaxRelativeError") }
+            : {}),
         dataTransfer: normalizeDataTransferStatsValue(pickAliasValue(source, "dataTransfer", "DataTransfer")),
         latency: normalizeLatencyStatsValue(pickAliasValue(source, "latency", "Latency")),
         request: normalizeRequestStatsValue(pickAliasValue(source, "request", "Request")),
         statusCodes: pickAliasArray(source, "statusCodes", "StatusCodes")
             .map((entry) => normalizeStatusCodeStatsValue(entry))
     };
+    const sidecarValue = pickAliasValue(source, "histogramSidecar", "HistogramSidecar");
+    if (sidecarValue && typeof sidecarValue === "object" && !Array.isArray(sidecarValue)) {
+        const sidecar = sidecarValue;
+        if (sidecar?.latency && sidecar.size) {
+            Object.defineProperty(projected, "histogramSidecar", {
+                value: {
+                    latency: LoadStrikeHistogramV1.fromSidecar(sidecar.latency).toSidecar(),
+                    size: LoadStrikeHistogramV1.fromSidecar(sidecar.size).toSidecar(),
+                    allBytes64: String(sidecar.allBytes64 ?? "0"),
+                    lessOrEq80064: String(sidecar.lessOrEq80064 ?? "0"),
+                    more800Less120064: String(sidecar.more800Less120064 ?? "0"),
+                    moreOrEq120064: String(sidecar.moreOrEq120064 ?? "0")
+                },
+                enumerable: false,
+                configurable: false,
+                writable: false
+            });
+        }
+    }
+    return projected;
 }
 function normalizeLoadSimulationStatsValue(value) {
     const source = asAliasRecord(value);
@@ -4541,6 +5831,9 @@ function normalizeStepStatsValue(value, index = 0) {
         statusCodes: normalizeAliasNumberRecord(pickAliasValue(source, "statusCodes", "StatusCodes")),
         ok: normalizeMeasurementStatsValue(pickAliasValue(source, "ok", "Ok")),
         fail: normalizeMeasurementStatsValue(pickAliasValue(source, "fail", "Fail")),
+        ...(hasAliasValue(source, "allMeasurement", "AllMeasurement")
+            ? { allMeasurement: normalizeMeasurementStatsValue(pickAliasValue(source, "allMeasurement", "AllMeasurement")) }
+            : {}),
         sortIndex: hasAliasValue(source, "sortIndex", "SortIndex")
             ? pickAliasNumber(source, "sortIndex", "SortIndex")
             : index
@@ -4580,6 +5873,9 @@ function normalizeScenarioStatsValue(value, index = 0) {
         durationMs: pickAliasNumber(source, "durationMs", "DurationMs", "Duration"),
         ok: normalizeMeasurementStatsValue(pickAliasValue(source, "ok", "Ok")),
         fail: normalizeMeasurementStatsValue(pickAliasValue(source, "fail", "Fail")),
+        ...(hasAliasValue(source, "allMeasurement", "AllMeasurement")
+            ? { allMeasurement: normalizeMeasurementStatsValue(pickAliasValue(source, "allMeasurement", "AllMeasurement")) }
+            : {}),
         loadSimulationStats: normalizeLoadSimulationStatsValue(pickAliasValue(source, "loadSimulationStats", "LoadSimulationStats")),
         sortIndex: hasAliasValue(source, "sortIndex", "SortIndex")
             ? pickAliasNumber(source, "sortIndex", "SortIndex")
@@ -4666,7 +5962,7 @@ function attachSessionStartInfoAliases(session) {
     return session;
 }
 function attachPortalReportingSession(sinkSession, sessionInfo, licenseClient, licenseSession) {
-    const runToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+    const runToken = currentLicenseSessionRunToken(licenseSession);
     if (!runToken || !licenseClient) {
         return;
     }
@@ -4676,9 +5972,17 @@ function attachPortalReportingSession(sinkSession, sessionInfo, licenseClient, l
     sinkSession.portalReportingIngestUrl = ingestUrl;
     sinkSession.portalReportingRunId = runId;
     sessionInfo.runToken = runToken;
+    Object.defineProperty(sessionInfo, PORTAL_RUN_TOKEN_PROVIDER, {
+        configurable: true,
+        enumerable: false,
+        value: () => currentLicenseSessionRunToken(licenseSession)
+    });
     sessionInfo.portalReportingIngestUrl = ingestUrl;
     sessionInfo.portalReportingRunId = runId;
 }
+function currentLicenseSessionRunToken(licenseSession) {
+    return stringValueOrDefault(licenseSession?.runToken, "").trim();
+}
 function buildPortalReportingRunId(sessionId) {
     const sessionPart = String(sessionId ?? "")
         .replace(/[^A-Za-z0-9._-]+/g, "-")
@@ -4763,6 +6067,7 @@ function attachDataTransferStatsAliases(stats) {
     const projected = normalizeDataTransferStatsValue(stats);
     return attachAliasMap(projected, {
         AllBytes: "allBytes",
+        AllBytes64: "allBytes64",
         MaxBytes: "maxBytes",
         MeanBytes: "meanBytes",
         MinBytes: "minBytes",
@@ -4770,6 +6075,7 @@ function attachDataTransferStatsAliases(stats) {
         Percent75: "percent75",
         Percent95: "percent95",
         Percent99: "percent99",
+        Percent100: "percent100",
         StdDev: "stdDev"
     });
 }
@@ -4793,6 +6099,7 @@ function attachLatencyStatsAliases(stats) {
         Percent75: "percent75",
         Percent95: "percent95",
         Percent99: "percent99",
+        Percent100: "percent100",
         StdDev: "stdDev"
     });
     return projected;
@@ -4814,6 +6121,9 @@ function attachMeasurementStatsAliases(stats) {
     projected.latency = attachLatencyStatsAliases(projected.latency);
     projected.statusCodes = projected.statusCodes.map((value) => attachStatusCodeStatsAliases(value));
     attachAliasMap(projected, {
+        Count64: "count64",
+        DistributionMode: "distributionMode",
+        MaxRelativeError: "maxRelativeError",
         Request: "request",
         DataTransfer: "dataTransfer",
         Latency: "latency",
@@ -4875,6 +6185,8 @@ function attachStepStatsAliases(step) {
     const projected = normalizeStepStatsValue(step);
     projected.ok = attachMeasurementStatsAliases(projected.ok);
     projected.fail = attachMeasurementStatsAliases(projected.fail);
+    if (projected.allMeasurement)
+        projected.allMeasurement = attachMeasurementStatsAliases(projected.allMeasurement);
     attachAliasMap(projected, {
         ScenarioName: "scenarioName",
         StepName: "stepName",
@@ -4889,6 +6201,7 @@ function attachStepStatsAliases(step) {
         StatusCodes: "statusCodes",
         Ok: "ok",
         Fail: "fail",
+        AllMeasurement: "allMeasurement",
         SortIndex: "sortIndex"
     });
     return projected;
@@ -4927,7 +6240,20 @@ function attachLoadSimulationProjection(simulation) {
     });
     return simulation;
 }
-function expandTrafficMixScenarios(trafficMix) {
+function cloneLoadEngineV2TrafficMixMetadata(metadata) {
+    return {
+        ...metadata,
+        shareWeights: [...metadata.shareWeights],
+        originalSimulations: metadata.originalSimulations.map((simulation) => attachLoadSimulationProjection({ ...simulation }))
+    };
+}
+function nextTrafficMixDeclarationIndex(scenarios) {
+    return scenarios.reduce((next, scenario) => {
+        const metadata = scenario.__loadStrikeTrafficMixV2Metadata();
+        return metadata ? Math.max(next, metadata.declarationIndex + 1) : next;
+    }, 0);
+}
+function expandTrafficMixScenarios(trafficMix, declarationIndex = 0) {
     if (!(trafficMix instanceof LoadStrikeTrafficMix)) {
         throw new TypeError("Traffic mix must be provided.");
     }
@@ -4940,16 +6266,30 @@ function expandTrafficMixScenarios(trafficMix) {
         throw new Error("Traffic mix scenario shares must be configured before registration.");
     }
     const weights = scenarioMix.map((share) => share.weight);
+    const seedId = buildLoadEngineV2TrafficMixSeedId(declarationIndex, trafficMix.name);
     return scenarioMix.map((share, index) => {
-        const splitSimulations = totalLoad
-            .map((simulation) => splitTrafficSimulation(simulation, weights, index))
-            .filter((simulation) => simulation != null);
-        const scenario = !splitSimulations.length
-            ? share.scenario.withLoadSimulations(LoadStrikeSimulation.pause(0))
-            : share.scenario.withLoadSimulations(...splitSimulations);
-        return scenario.__loadStrikeWithInternalLicenseFeatures(TRAFFIC_MIX_FEATURE);
+        const splitSimulations = totalLoad.map((simulation) => splitTrafficSimulation(simulation, weights, index)
+            ?? trafficMixNoWorkSimulation(simulation));
+        return share.scenario
+            .withLoadSimulations(...splitSimulations)
+            .__loadStrikeWithInternalLicenseFeatures(TRAFFIC_MIX_FEATURE)
+            .__loadStrikeSetTrafficMixV2Metadata({
+            declarationIndex,
+            name: trafficMix.name,
+            laneIndex: index,
+            shareWeight: share.weight,
+            shareWeights: weights,
+            seedId,
+            originalSimulations: totalLoad
+        });
     });
 }
+function trafficMixNoWorkSimulation(simulation) {
+    const kind = String(simulation.Kind ?? "");
+    return kind === "IterationsForInject" || kind === "IterationsForConstant"
+        ? LoadStrikeSimulation.pause(0)
+        : LoadStrikeSimulation.pause(Math.max(readFiniteSimulationNumber(simulation, "DuringSeconds"), 0));
+}
 function splitTrafficSimulation(simulation, weights, index) {
     const kind = String(simulation.Kind ?? "");
     const duringSeconds = readFiniteSimulationNumber(simulation, "DuringSeconds");
@@ -5036,6 +6376,8 @@ function attachScenarioStatsAliases(scenario) {
     const normalized = normalizeScenarioStatsValue(scenario);
     normalized.ok = attachMeasurementStatsAliases(normalized.ok);
     normalized.fail = attachMeasurementStatsAliases(normalized.fail);
+    if (normalized.allMeasurement)
+        normalized.allMeasurement = attachMeasurementStatsAliases(normalized.allMeasurement);
     normalized.loadSimulationStats = attachLoadSimulationStatsAliases(normalized.loadSimulationStats);
     normalized.stepStats = normalized.stepStats.map((value) => attachStepStatsAliases(value));
     const findStepStats = scenario.findStepStats ?? ((stepName) => normalized.stepStats.find((value) => value.stepName === stepName));
@@ -5069,6 +6411,7 @@ function attachScenarioStatsAliases(scenario) {
         DurationMs: "durationMs",
         Ok: "ok",
         Fail: "fail",
+        AllMeasurement: "allMeasurement",
         LoadSimulationStats: "loadSimulationStats",
         SortIndex: "sortIndex",
         StepStats: "stepStats"
@@ -5089,6 +6432,10 @@ function attachNodeStatsAliases(stats) {
         : stats.scenarioStats.flatMap((value) => value.stepStats)).map((value) => attachStepStatsAliases(value));
     stats.pluginsData = stats.pluginsData.map((value) => normalizePluginData(value.pluginName ?? value.PluginName ?? "", value));
     stats.sinkErrors = stats.sinkErrors.map((value) => attachSinkErrorAliases(value));
+    stats.generatorWarnings = (stats.generatorWarnings ?? []).map(attachGeneratorWarningAliases);
+    stats.schedulerSegments = (stats.schedulerSegments ?? []).map((value) => normalizeSchedulerSegment(value));
+    stats.observationDeliveryStats = normalizeObservationDeliveryStats(stats.observationDeliveryStats ?? emptyObservationDeliveryStats());
+    stats.reportingComplete ?? (stats.reportingComplete = false);
     const findScenarioStats = stats.findScenarioStats ?? ((scenarioName) => stats.scenarioStats.find((value) => value.scenarioName === scenarioName));
     const getScenarioStats = stats.getScenarioStats ?? ((scenarioName) => {
         const value = findScenarioStats(scenarioName);
@@ -5123,7 +6470,11 @@ function attachNodeStatsAliases(stats) {
         DisabledSinks: "disabledSinks",
         SinkErrors: "sinkErrors",
         ReportFiles: "reportFiles",
-        LogFiles: "logFiles"
+        LogFiles: "logFiles",
+        GeneratorWarnings: "generatorWarnings",
+        SchedulerSegments: "schedulerSegments",
+        ObservationDeliveryStats: "observationDeliveryStats",
+        ReportingComplete: "reportingComplete"
     });
     defineAliasProperty(projected, "StartedUtc", () => parseAliasDate(stats.startedUtc));
     defineAliasProperty(projected, "CompletedUtc", () => parseAliasDate(stats.completedUtc));
@@ -5179,11 +6530,43 @@ function attachRunResultAliases(result) {
             .map((value) => ({ ...asAliasRecord(value) })),
         failedCorrelationRows: pickAliasArray(source, "failedCorrelationRows", "FailedCorrelationRows")
             .map((value) => ({ ...asAliasRecord(value) })),
+        ...(hasAliasValue(source, "generatorWarnings", "GeneratorWarnings")
+            ? {
+                generatorWarnings: pickAliasArray(source, "generatorWarnings", "GeneratorWarnings")
+                    .map(attachGeneratorWarningAliases)
+            }
+            : {}),
+        ...(hasAliasValue(source, "schedulerSegments", "SchedulerSegments")
+            ? {
+                schedulerSegments: pickAliasArray(source, "schedulerSegments", "SchedulerSegments")
+                    .map(normalizeSchedulerSegment)
+            }
+            : {}),
+        ...(hasAliasValue(source, "schedulerStats", "SchedulerStats")
+            ? { schedulerStats: normalizeSchedulerStats(pickAliasValue(source, "schedulerStats", "SchedulerStats")) }
+            : {}),
+        ...(hasAliasValue(source, "observationDeliveryStats", "ObservationDeliveryStats")
+            ? {
+                observationDeliveryStats: normalizeObservationDeliveryStats(pickAliasValue(source, "observationDeliveryStats", "ObservationDeliveryStats"))
+            }
+            : {}),
+        ...(hasAliasValue(source, "reportingComplete", "ReportingComplete")
+            ? { reportingComplete: pickAliasBoolean(source, "reportingComplete", "ReportingComplete") }
+            : {}),
         findScenarioStats,
         getScenarioStats,
         FindScenarioStats: findScenarioStats,
         GetScenarioStats: getScenarioStats
     };
+    const schedulerDistributions = result[LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS];
+    if (schedulerDistributions) {
+        Object.defineProperty(projected, LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS, {
+            value: schedulerDistributions.map(cloneLoadEngineV2DistributionRecord),
+            enumerable: false,
+            configurable: false,
+            writable: false
+        });
+    }
     attachAliasMap(projected, {
         AllBytes: "allBytes",
         AllRequestCount: "allRequestCount",
@@ -5207,7 +6590,12 @@ function attachRunResultAliases(result) {
         ReportFiles: "reportFiles",
         LogFiles: "logFiles",
         CorrelationRows: "correlationRows",
-        FailedCorrelationRows: "failedCorrelationRows"
+        FailedCorrelationRows: "failedCorrelationRows",
+        GeneratorWarnings: "generatorWarnings",
+        SchedulerSegments: "schedulerSegments",
+        SchedulerStats: "schedulerStats",
+        ObservationDeliveryStats: "observationDeliveryStats",
+        ReportingComplete: "reportingComplete"
     });
     defineAliasProperty(projected, "StartedUtc", () => parseAliasDate(projected.startedUtc));
     defineAliasProperty(projected, "CompletedUtc", () => parseAliasDate(projected.completedUtc));
@@ -5815,6 +7203,14 @@ function detailedToNodeStats(result, metricStats) {
         sinkErrors: (result.sinkErrors ?? []).map((sinkError) => ({ ...sinkError })),
         reportFiles: [...(result.reportFiles ?? [])],
         logFiles: [...(result.logFiles ?? [])],
+        generatorWarnings: (result.generatorWarnings ?? []).map(attachGeneratorWarningAliases),
+        schedulerSegments: result.schedulerSegments?.map((segment) => ({ ...segment })),
+        schedulerStats: result.schedulerStats
+            ? normalizeSchedulerStats(result.schedulerStats)
+            : undefined,
+        [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]: result[LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]?.map(cloneLoadEngineV2DistributionRecord),
+        observationDeliveryStats: normalizeObservationDeliveryStats(result.observationDeliveryStats ?? emptyObservationDeliveryStats()),
+        reportingComplete: result.reportingComplete ?? true,
         findScenarioStats: (scenarioName) => scenarioStats.find((scenario) => scenario.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -5882,22 +7278,35 @@ function buildEmptyNodeStats(args) {
         sinkErrors: [],
         reportFiles: [],
         logFiles: [],
+        generatorWarnings: [],
+        observationDeliveryStats: emptyObservationDeliveryStats(),
+        reportingComplete: true,
         findScenarioStats: (scenarioName) => undefined,
         getScenarioStats: (scenarioName) => {
             throw new Error(`Scenario stats not found: ${scenarioName}`);
         }
     });
 }
-function planRuntimeClusterAssignments(scenarios, agentsCount, targetScenarios, agentTargetScenarios) {
+function planRuntimeClusterAssignments(scenarios, agentsCount, targetScenarios, agentTargetScenarios, globalV2 = false, coordinatorTargetScenarios = []) {
     const resolvedAgentCount = Math.max(agentsCount, 1);
-    const selectedScenarios = targetScenarios.length
+    let selectedScenarios = targetScenarios.length
         ? scenarios.filter((scenario) => targetScenarios.includes(scenario.name))
         : [...scenarios];
+    if (globalV2 && coordinatorTargetScenarios.length) {
+        const coordinatorNames = new Set(coordinatorTargetScenarios);
+        selectedScenarios = selectedScenarios.filter((scenario) => !coordinatorNames.has(scenario.name));
+    }
     if (!selectedScenarios.length) {
         return Array.from({ length: resolvedAgentCount }, () => []);
     }
     if (agentTargetScenarios.length) {
-        return Array.from({ length: resolvedAgentCount }, () => [...agentTargetScenarios]);
+        const coordinatorNames = new Set(coordinatorTargetScenarios);
+        const names = agentTargetScenarios.filter((name) => !coordinatorNames.has(name));
+        return Array.from({ length: resolvedAgentCount }, () => [...names]);
+    }
+    if (globalV2) {
+        const scenarioNames = selectedScenarios.map((scenario) => scenario.name);
+        return Array.from({ length: resolvedAgentCount }, () => [...scenarioNames]);
     }
     const weightedNames = [];
     for (const scenario of selectedScenarios) {
@@ -5917,7 +7326,320 @@ function planRuntimeClusterAssignments(scenarios, agentsCount, targetScenarios,
     }
     return assignments.map((entry) => [...entry]);
 }
-function nodeStatsToClusterPayload(result) {
+function buildRuntimeLoadEngineV2Plan(scenarios, options, testInfo, expectedAgentIds) {
+    validateLoadEngineV2ScenarioFeatures(scenarios);
+    const kindToken = (value) => {
+        const normalized = String(value ?? "").replace(/[^a-z0-9]/gi, "").toLowerCase();
+        const tokens = {
+            inject: "inject", injectrandom: "inject-random", rampinginject: "ramping-inject",
+            keepconstant: "keep-constant", rampingconstant: "ramping-constant",
+            iterationsforinject: "iterations-for-inject", iterationsforconstant: "iterations-for-constant",
+            pause: "pause"
+        };
+        const token = tokens[normalized];
+        if (!token)
+            throw new Error(`Load Engine V2 simulation kind is unsupported: ${String(value ?? "")}`);
+        return token;
+    };
+    const integer = (value) => Math.max(Math.trunc(toNumber(value)), 0).toString();
+    const ns = (value) => Math.max(Math.round(toNumber(value) * 1000000000), 0).toString();
+    const coordinatorNames = new Set(options.coordinatorTargetScenarios ?? []);
+    const explicitAgentNames = new Set(options.agentTargetScenarios ?? []);
+    const selectedNames = new Set(options.targetScenarios ?? []);
+    const plannedScenarios = scenarios
+        .map((scenario, declarationIndex) => ({ scenario, declarationIndex }))
+        .filter(({ scenario }) => (selectedNames.size === 0 || selectedNames.has(scenario.name))
+        && (explicitAgentNames.size > 0
+            ? explicitAgentNames.has(scenario.name)
+            : !coordinatorNames.has(scenario.name)));
+    const implicitSingleInvocation = {
+        simulationIndex64: "0",
+        kind: "iterations-for-constant",
+        rate64: "0",
+        minRate64: "0",
+        maxRate64: "0",
+        copies64: "1",
+        iterations64: "1",
+        intervalNs64: "0",
+        durationNs64: "0"
+    };
+    return {
+        runId: testInfo.sessionId,
+        sessionId: testInfo.sessionId,
+        registrationNonce: randomBytes(16).toString("hex"),
+        maxInFlight64: Math.max(options.maxInFlight ?? 10000, 1).toString(),
+        reportingIntervalNs64: ns(options.reportingIntervalSeconds ?? 1),
+        schedulerVisibleProcessorCount64: Math.max(os.cpus().length, 1).toString(),
+        expectedAgentIds: [...expectedAgentIds],
+        scenarios: plannedScenarios.map(({ scenario, declarationIndex }) => ({
+            scenarioIndex64: declarationIndex.toString(),
+            scenarioName: scenario.name,
+            target: "agent",
+            callbackExecutionMode: "async",
+            declaredStepNames: scenario.getDeclaredSteps(),
+            simulations: scenario.getSimulations().length
+                ? scenario.getSimulations().map((simulation, simulationIndex) => ({
+                    simulationIndex64: simulationIndex.toString(),
+                    kind: kindToken(simulation.Kind ?? simulation.kind),
+                    rate64: integer(simulation.Rate ?? simulation.rate),
+                    minRate64: integer(simulation.MinRate ?? simulation.minRate),
+                    maxRate64: integer(simulation.MaxRate ?? simulation.maxRate),
+                    copies64: integer(simulation.Copies ?? simulation.copies),
+                    iterations64: integer(simulation.Iterations ?? simulation.iterations),
+                    intervalNs64: ns(simulation.IntervalSeconds ?? simulation.intervalSeconds),
+                    durationNs64: ns(simulation.DuringSeconds ?? simulation.duringSeconds)
+                }))
+                : [{ ...implicitSingleInvocation }]
+        }))
+    };
+}
+function normalizeRequiredV2AgentIds(values, expectedCount) {
+    const ids = normalizeOptionalStringArray(values) ?? [];
+    if (ids.length !== expectedCount || new Set(ids).size !== ids.length) {
+        throw new Error("Remote Load Engine V2 coordinators require an exact unique ExpectedAgentIds set matching AgentsCount.");
+    }
+    return ids;
+}
+function validateLoadEngineV2ScenarioFeatures(scenarios) {
+    for (const scenario of scenarios) {
+        if (scenario.getTrackingConfiguration()) {
+            throw new Error(`Load Engine V2 correlation is not available in the supported non-correlation profile. Scenario=${scenario.name}.`);
+        }
+    }
+}
+function canonicalLoadEngineV2InvocationIdentityKind(simulationKind) {
+    const normalized = simulationKind.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    if (["inject", "injectrandom", "rampinginject", "iterationsforinject"].includes(normalized)) {
+        return "arrival";
+    }
+    if (["keepconstant", "rampingconstant"].includes(normalized)) {
+        return "worker-iteration";
+    }
+    if (normalized === "iterationsforconstant") {
+        return "constant-iteration";
+    }
+    return "";
+}
+function buildRuntimeLoadEngineV2HistogramArtifact(result, scenarioDeclarations) {
+    const emptyHistogram = () => new LoadStrikeHistogramV1().toSidecar();
+    const distributions = [];
+    const measurementSummaries = [];
+    const statusBody = (measurement, outcome) => {
+        const named = measurement.statusCodes
+            .filter((row) => Boolean(row.statusCode || row.message))
+            .map((row) => {
+            const key = buildLoadEngineV2StatusIdentityKey(row.statusCode, row.message);
+            if (!key)
+                throw new Error("Load Engine V2 status identity unexpectedly resolved empty.");
+            return {
+                statusIdentityKeyHex: key.identity.toString("hex"),
+                display: key.display,
+                count64: Math.max(Math.trunc(row.count), 0).toString(),
+                aggregatedObservationCount64: "0",
+                hasAggregatedIdentities: false
+            };
+        })
+            .sort((left, right) => Buffer.compare(Buffer.from(left.statusIdentityKeyHex, "hex"), Buffer.from(right.statusIdentityKeyHex, "hex")));
+        let statuses = named;
+        if (named.length > 64) {
+            const retained = named.slice(0, 63);
+            const aggregated = named.slice(63).reduce((sum, row) => sum + BigInt(row.count64), 0n);
+            retained.push({
+                statusIdentityKeyHex: Buffer.concat([Buffer.from("LS-ID1\n", "ascii"), Buffer.from([0x0d])]).toString("hex"),
+                display: "<other>", count64: aggregated.toString(),
+                aggregatedObservationCount64: aggregated.toString(), hasAggregatedIdentities: aggregated > 0n
+            });
+            statuses = retained;
+        }
+        return {
+            outcome,
+            statusObservationCount64: statuses.reduce((sum, row) => sum + BigInt(row.count64), 0n).toString(),
+            statuses
+        };
+    };
+    const appendMeasurement = (seriesKind, scenarioIndex64, scenarioName, identity, display, ok, fail, all, reservedOther) => {
+        const emptyMeasurement = () => ({
+            count64: "0",
+            histogramSidecar: {
+                latency: emptyHistogram(), size: emptyHistogram(), allBytes64: "0",
+                lessOrEq80064: "0", more800Less120064: "0", moreOrEq120064: "0"
+            },
+            request: { count: 0, percent: 0, rps: 0 },
+            dataTransfer: { allBytes: 0, minBytes: 0, maxBytes: 0, meanBytes: 0, percent50: 0,
+                percent75: 0, percent95: 0, percent99: 0, percent100: 0, stdDev: 0 },
+            latency: { latencyCount: { lessOrEq800: 0, more800Less1200: 0, moreOrEq1200: 0 },
+                minMs: 0, maxMs: 0, meanMs: 0, percent50: 0, percent75: 0, percent95: 0,
+                percent99: 0, stdDev: 0 },
+            statusCodes: []
+        });
+        const okValue = ok ?? emptyMeasurement();
+        const failValue = fail ?? emptyMeasurement();
+        const allValue = all ?? emptyMeasurement();
+        for (const [outcome, measurement] of [
+            ["ok", okValue], ["fail", failValue], ["all", allValue]
+        ]) {
+            const sidecar = measurement.histogramSidecar;
+            if (!sidecar)
+                throw new Error("Load Engine V2 assigned measurement is missing histogram state.");
+            distributions.push({
+                seriesKind, scenarioIndex64, scenarioName, identityKeyHex: identity.toString("hex"),
+                outcome, unit: "microseconds", histogram: sidecar.latency,
+                exactTotalDecimalOrEmpty: sidecar.latency.exactTotal64,
+                bands: [
+                    { bandId64: "0", count64: sidecar.lessOrEq80064 },
+                    { bandId64: "1", count64: sidecar.more800Less120064 },
+                    { bandId64: "2", count64: sidecar.moreOrEq120064 }
+                ]
+            });
+            distributions.push({
+                seriesKind, scenarioIndex64, scenarioName, identityKeyHex: identity.toString("hex"),
+                outcome, unit: "bytes", histogram: sidecar.size,
+                exactTotalDecimalOrEmpty: sidecar.size.exactTotal64
+            });
+        }
+        const observation = BigInt(allValue.count64 ?? allValue.histogramSidecar?.latency.count64 ?? "0");
+        const success = BigInt(okValue.count64 ?? okValue.histogramSidecar?.latency.count64 ?? "0");
+        const failure = BigInt(failValue.count64 ?? failValue.histogramSidecar?.latency.count64 ?? "0");
+        measurementSummaries.push({
+            seriesKind, scenarioIndex64, scenarioName, identityKeyHex: identity.toString("hex"), display,
+            observationCount64: observation.toString(), successCount64: success.toString(),
+            failureCount64: failure.toString(),
+            aggregatedObservationCount64: reservedOther ? observation.toString() : "0",
+            hasAggregatedIdentities: reservedOther && observation > 0n,
+            outcomes: [statusBody(okValue, "ok"), statusBody(failValue, "fail")]
+        });
+    };
+    for (const scenario of result.scenarioStats) {
+        const scenarioIndex64 = Math.max(Math.trunc(scenario.sortIndex), 0).toString();
+        appendMeasurement("scenario", scenarioIndex64, scenario.scenarioName, buildLoadEngineV2ScenarioIdentityKey(scenarioIndex64), scenario.scenarioName, scenario.ok, scenario.fail, scenario.allMeasurement, false);
+        const declaration = scenarioDeclarations?.find((value) => value.name === scenario.scenarioName);
+        const declaredNames = declaration?.getDeclaredSteps()
+            ?? (scenarioDeclarations ? [] : undefined);
+        if (declaredNames === undefined) {
+            for (const step of scenario.stepStats) {
+                const key = buildLoadEngineV2StepIdentityKey(scenarioIndex64, step.stepName);
+                appendMeasurement("step", scenarioIndex64, scenario.scenarioName, key.identity, key.display, step.ok, step.fail, step.allMeasurement, false);
+            }
+        }
+        else {
+            const requiredStepAllMeasurement = (step) => {
+                if (!step.allMeasurement) {
+                    throw new Error("Load Engine V2 assigned step is missing its all-outcome histogram state.");
+                }
+                return step.allMeasurement;
+            };
+            const groups = new Map();
+            for (const declaredName of declaredNames) {
+                const key = buildLoadEngineV2StepIdentityKey(scenarioIndex64, declaredName);
+                groups.set(key.identity.toString("hex"), {
+                    identity: key.identity, display: key.display, routedToOther: false, steps: []
+                });
+            }
+            for (const step of scenario.stepStats) {
+                const resolved = resolveLoadEngineV2StepIdentityKey(scenarioIndex64, step.stepName, declaredNames);
+                const key = resolved.identity.toString("hex");
+                const group = groups.get(key) ?? {
+                    identity: resolved.identity,
+                    display: resolved.display,
+                    routedToOther: resolved.routedToOther,
+                    steps: []
+                };
+                group.steps.push(step);
+                groups.set(key, group);
+            }
+            const reservedHex = buildLoadEngineV2ReservedStepOtherIdentityKey(scenarioIndex64).toString("hex");
+            const declaredGroups = [...groups.entries()]
+                .filter(([key]) => key !== reservedHex)
+                .map(([, value]) => value)
+                .sort((left, right) => Buffer.compare(left.identity, right.identity));
+            for (const group of declaredGroups) {
+                const ok = group.steps.length
+                    ? aggregateMeasurementStats(group.steps.map((step) => step.ok), scenario.allRequestCount, scenario.durationMs, true)
+                    : undefined;
+                const fail = group.steps.length
+                    ? aggregateMeasurementStats(group.steps.map((step) => step.fail), scenario.allRequestCount, scenario.durationMs, true)
+                    : undefined;
+                const all = group.steps.length
+                    ? aggregateMeasurementStats(group.steps.map(requiredStepAllMeasurement), scenario.allRequestCount, scenario.durationMs, true)
+                    : undefined;
+                appendMeasurement("step", scenarioIndex64, scenario.scenarioName, group.identity, group.display, ok, fail, all, false);
+            }
+            const other = groups.get(reservedHex);
+            if (other?.steps.length) {
+                appendMeasurement("step", scenarioIndex64, scenario.scenarioName, other.identity, "<other>", aggregateMeasurementStats(other.steps.map((step) => step.ok), scenario.allRequestCount, scenario.durationMs, true), aggregateMeasurementStats(other.steps.map((step) => step.fail), scenario.allRequestCount, scenario.durationMs, true), aggregateMeasurementStats(other.steps.map(requiredStepAllMeasurement), scenario.allRequestCount, scenario.durationMs, true), true);
+                continue;
+            }
+        }
+        appendMeasurement("step", scenarioIndex64, scenario.scenarioName, buildLoadEngineV2ReservedStepOtherIdentityKey(scenarioIndex64), "<other>", undefined, undefined, undefined, true);
+    }
+    for (const segment of result.schedulerSegments ?? []) {
+        const scenarioIndex64 = segment.scenarioIndex.toString();
+        const simulationIndex64 = segment.simulationIndex.toString();
+        for (const kind of ["decision", "start"]) {
+            const seriesKind = kind === "decision" ? "scheduler-decision-lag" : "scheduler-start-lag";
+            const identityKeyHex = buildLoadEngineV2SchedulerIdentityKey(kind, scenarioIndex64, simulationIndex64).toString("hex");
+            const signed = result[LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]?.find((record) => record.seriesKind === seriesKind
+                && record.scenarioIndex64 === scenarioIndex64
+                && record.identityKeyHex === identityKeyHex
+                && record.outcome === "none"
+                && record.unit === "microseconds");
+            if (!distributions.some((record) => record.seriesKind === seriesKind
+                && record.scenarioIndex64 === scenarioIndex64
+                && record.identityKeyHex === identityKeyHex)) {
+                distributions.push(signed ? cloneLoadEngineV2DistributionRecord(signed) : {
+                    seriesKind,
+                    scenarioIndex64, scenarioName: segment.scenarioName,
+                    identityKeyHex,
+                    outcome: "none", unit: "microseconds", histogram: emptyHistogram(),
+                    exactTotalDecimalOrEmpty: "0"
+                });
+            }
+        }
+    }
+    return serializeLoadEngineV2HistogramArtifact({ distributions, measurementSummaries });
+}
+function cloneLoadEngineV2DistributionRecord(record) {
+    return {
+        ...record,
+        histogram: {
+            ...record.histogram,
+            exactSamples64: [...record.histogram.exactSamples64],
+            buckets: record.histogram.buckets.map((bucket) => ({ ...bucket }))
+        },
+        bands: record.bands?.map((band) => ({ ...band }))
+    };
+}
+function mergeLoadEngineV2SchedulerDistributions(records) {
+    const merged = new Map();
+    for (const input of records) {
+        if (input.seriesKind !== "scheduler-decision-lag" && input.seriesKind !== "scheduler-start-lag") {
+            continue;
+        }
+        const key = [input.seriesKind, input.scenarioIndex64, input.identityKeyHex, input.outcome, input.unit].join("\0");
+        const current = merged.get(key);
+        if (!current) {
+            merged.set(key, cloneLoadEngineV2DistributionRecord(input));
+            continue;
+        }
+        if (current.scenarioName !== input.scenarioName) {
+            throw new Error("Load Engine V2 scheduler histogram identities disagree across agents.");
+        }
+        const histogram = LoadStrikeHistogramV1.fromSidecar(current.histogram);
+        histogram.merge(LoadStrikeHistogramV1.fromSidecar(input.histogram));
+        current.histogram = histogram.toSidecar();
+        current.exactTotalDecimalOrEmpty = histogram.toSidecar().exactTotal64;
+        const bands = new Map();
+        for (const band of [...(current.bands ?? []), ...(input.bands ?? [])]) {
+            bands.set(band.bandId64, (bands.get(band.bandId64) ?? 0n) + BigInt(band.count64));
+        }
+        current.bands = Array.from(bands, ([bandId64, count]) => ({ bandId64, count64: count.toString() }));
+    }
+    return Array.from(merged.values());
+}
+function nodeStatsToClusterPayload(result, scenarioDeclarations, requireLoadEngineV2Histogram = false) {
+    const histogramArtifactBase64 = requireLoadEngineV2Histogram
+        ? buildRuntimeLoadEngineV2HistogramArtifact(result, scenarioDeclarations).toString("base64")
+        : undefined;
     return {
         allBytes: result.allBytes,
         allRequestCount: result.allRequestCount,
@@ -5930,7 +7652,13 @@ function nodeStatsToClusterPayload(result) {
         pluginsData: result.pluginsData,
         nodeInfo: result.nodeInfo,
         testInfo: result.testInfo,
-        logFiles: [...(result.logFiles ?? [])]
+        logFiles: [...(result.logFiles ?? [])],
+        generatorWarnings: result.generatorWarnings,
+        observationDeliveryStats: result.observationDeliveryStats,
+        schedulerSegments: result.schedulerSegments,
+        schedulerStats: result.schedulerStats,
+        ...(histogramArtifactBase64 ? { histogramArtifactBase64 } : {}),
+        reportingComplete: result.reportingComplete
     };
 }
 function toDetailedRunResultFromNodeStats(result, startedUtc, sinkErrors, policyErrors = []) {
@@ -5958,6 +7686,14 @@ function toDetailedRunResultFromNodeStats(result, startedUtc, sinkErrors, policy
         policyErrors: policyErrors.map((value) => attachRuntimePolicyErrorAliases({ ...value })),
         reportFiles: [...result.reportFiles],
         logFiles: [...(result.logFiles ?? [])],
+        generatorWarnings: (result.generatorWarnings ?? []).map(attachGeneratorWarningAliases),
+        schedulerSegments: result.schedulerSegments?.map((segment) => ({ ...segment })),
+        schedulerStats: result.schedulerStats
+            ? normalizeSchedulerStats(result.schedulerStats)
+            : undefined,
+        [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]: result[LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]?.map(cloneLoadEngineV2DistributionRecord),
+        observationDeliveryStats: normalizeObservationDeliveryStats(result.observationDeliveryStats ?? emptyObservationDeliveryStats()),
+        reportingComplete: result.reportingComplete ?? false,
         correlationRows: buildDetailedCorrelationRows(),
         failedCorrelationRows: buildDetailedFailedCorrelationRows()
     });
@@ -5980,7 +7716,198 @@ function flattenMetricValues(metricStats) {
         }))
     ];
 }
-function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
+function projectLoadEngineV2MeasurementsFromArtifact(sourceScenarios, artifact) {
+    const distributions = new Map();
+    for (const distribution of artifact.distributions) {
+        const key = loadEngineV2DistributionProjectionKey(distribution.seriesKind, distribution.scenarioIndex64, distribution.identityKeyHex, distribution.outcome, distribution.unit);
+        if (distributions.has(key)) {
+            throw new Error("Load Engine V2 histogram artifact contains a duplicate distribution identity.");
+        }
+        distributions.set(key, distribution);
+    }
+    const scenarioSummaries = artifact.measurementSummaries
+        .filter((summary) => summary.seriesKind === "scenario")
+        .sort((left, right) => compareLoadEngineV2Decimal(left.scenarioIndex64, right.scenarioIndex64));
+    if (scenarioSummaries.length !== sourceScenarios.length) {
+        throw new Error("Load Engine V2 histogram artifact scenario summaries do not reconcile with the scheduler snapshot.");
+    }
+    const sourceByName = new Map();
+    for (const scenario of sourceScenarios) {
+        if (!scenario.scenarioName || sourceByName.has(scenario.scenarioName)) {
+            throw new Error("Load Engine V2 scheduler snapshot scenario identities are empty or duplicated.");
+        }
+        sourceByName.set(scenario.scenarioName, scenario);
+    }
+    return scenarioSummaries.map((summary) => {
+        const source = sourceByName.get(summary.scenarioName);
+        if (!source) {
+            throw new Error("Load Engine V2 histogram artifact scenario identity is absent from the scheduler snapshot.");
+        }
+        const expectedIdentity = buildLoadEngineV2ScenarioIdentityKey(summary.scenarioIndex64).toString("hex");
+        if (summary.identityKeyHex !== expectedIdentity) {
+            throw new Error("Load Engine V2 histogram artifact scenario identity is not canonical.");
+        }
+        const observationCount = loadEngineV2SafeNumber(summary.observationCount64, "scenario observation count");
+        const successCount = loadEngineV2SafeNumber(summary.successCount64, "scenario success count");
+        const failureCount = loadEngineV2SafeNumber(summary.failureCount64, "scenario failure count");
+        if (source.allRequestCount !== observationCount
+            || source.allOkCount !== successCount
+            || source.allFailCount !== failureCount) {
+            throw new Error("Load Engine V2 histogram artifact scenario counts do not reconcile with the scheduler snapshot.");
+        }
+        const ok = projectLoadEngineV2Measurement(summary, "ok", distributions, observationCount, source.durationMs, [source.ok]);
+        const fail = projectLoadEngineV2Measurement(summary, "fail", distributions, observationCount, source.durationMs, [source.fail]);
+        const allMeasurement = projectLoadEngineV2Measurement(summary, "all", distributions, observationCount, source.durationMs, [source.ok, source.fail]);
+        const stepSummaries = artifact.measurementSummaries
+            .filter((candidate) => candidate.seriesKind === "step"
+            && candidate.scenarioIndex64 === summary.scenarioIndex64
+            && candidate.scenarioName === summary.scenarioName)
+            .sort((left, right) => Buffer.compare(Buffer.from(left.identityKeyHex, "hex"), Buffer.from(right.identityKeyHex, "hex")));
+        const stepIdentitySet = new Set(stepSummaries.map((candidate) => candidate.identityKeyHex));
+        const reservedOtherIdentity = buildLoadEngineV2ReservedStepOtherIdentityKey(summary.scenarioIndex64).toString("hex");
+        const stepStats = stepSummaries.map((stepSummary, sortIndex) => {
+            const matchingSourceSteps = source.stepStats.filter((step) => {
+                const observedIdentity = buildLoadEngineV2StepIdentityKey(summary.scenarioIndex64, step.stepName).identity.toString("hex");
+                return stepSummary.identityKeyHex === reservedOtherIdentity
+                    ? !stepIdentitySet.has(observedIdentity)
+                    : observedIdentity === stepSummary.identityKeyHex;
+            });
+            const stepObservationCount = loadEngineV2SafeNumber(stepSummary.observationCount64, "step observation count");
+            const stepOk = projectLoadEngineV2Measurement(stepSummary, "ok", distributions, observationCount, source.durationMs, matchingSourceSteps.map((step) => step.ok));
+            const stepFail = projectLoadEngineV2Measurement(stepSummary, "fail", distributions, observationCount, source.durationMs, matchingSourceSteps.map((step) => step.fail));
+            const stepAll = projectLoadEngineV2Measurement(stepSummary, "all", distributions, observationCount, source.durationMs, matchingSourceSteps.flatMap((step) => [step.ok, step.fail]));
+            const totalLatencyMs = stepAll.latency.meanMs * stepObservationCount;
+            return {
+                scenarioName: summary.scenarioName,
+                stepName: stepSummary.display,
+                okCount: stepOk.request.count,
+                failCount: stepFail.request.count,
+                requestCount: stepObservationCount,
+                totalBytes: stepAll.dataTransfer.allBytes,
+                totalLatencyMs,
+                avgLatencyMs: stepObservationCount > 0 ? totalLatencyMs / stepObservationCount : 0,
+                minLatencyMs: stepAll.latency.minMs,
+                maxLatencyMs: stepAll.latency.maxMs,
+                statusCodes: aggregateStatusCodeCounts(stepOk.statusCodes, stepFail.statusCodes),
+                ok: stepOk,
+                fail: stepFail,
+                allMeasurement: stepAll,
+                sortIndex
+            };
+        });
+        const totalLatencyMs = allMeasurement.latency.meanMs * observationCount;
+        const projected = {
+            scenarioName: summary.scenarioName,
+            allRequestCount: observationCount,
+            allOkCount: successCount,
+            allFailCount: failureCount,
+            totalBytes: allMeasurement.dataTransfer.allBytes,
+            totalLatencyMs,
+            avgLatencyMs: observationCount > 0 ? totalLatencyMs / observationCount : 0,
+            minLatencyMs: allMeasurement.latency.minMs,
+            maxLatencyMs: allMeasurement.latency.maxMs,
+            statusCodes: aggregateStatusCodeCounts(ok.statusCodes, fail.statusCodes),
+            allMeasurement,
+            allBytes: allMeasurement.dataTransfer.allBytes,
+            currentOperation: source.currentOperation,
+            durationMs: source.durationMs,
+            ok,
+            fail,
+            loadSimulationStats: { ...source.loadSimulationStats },
+            sortIndex: loadEngineV2SafeNumber(summary.scenarioIndex64, "scenario index"),
+            stepStats,
+            findStepStats: (stepName) => stepStats.find((step) => step.stepName === stepName),
+            getStepStats: (stepName) => {
+                const step = stepStats.find((candidate) => candidate.stepName === stepName);
+                if (!step)
+                    throw new Error(`Step stats not found: ${stepName}`);
+                return step;
+            }
+        };
+        return attachScenarioStatsAliases(projected);
+    });
+}
+function projectLoadEngineV2Measurement(summary, outcome, distributions, allRequestCount, durationMs, sourceMeasurements) {
+    const expectedCount64 = outcome === "ok"
+        ? summary.successCount64
+        : outcome === "fail"
+            ? summary.failureCount64
+            : summary.observationCount64;
+    const latency = requireLoadEngineV2MeasurementDistribution(summary, outcome, "microseconds", distributions);
+    const size = requireLoadEngineV2MeasurementDistribution(summary, outcome, "bytes", distributions);
+    if (latency.histogram.count64 !== expectedCount64 || size.histogram.count64 !== expectedCount64) {
+        throw new Error("Load Engine V2 histogram distribution counts do not reconcile with its measurement summary.");
+    }
+    const bands = new Map();
+    for (const band of latency.bands ?? []) {
+        if (bands.has(band.bandId64)) {
+            throw new Error("Load Engine V2 latency distribution contains a duplicate band.");
+        }
+        bands.set(band.bandId64, BigInt(band.count64));
+    }
+    if (bands.size !== 3 || !bands.has("0") || !bands.has("1") || !bands.has("2")
+        || [...bands.values()].reduce((sum, value) => sum + value, 0n) !== BigInt(expectedCount64)) {
+        throw new Error("Load Engine V2 latency distribution bands do not reconcile with its count.");
+    }
+    const sourceStatuses = new Map();
+    for (const measurement of sourceMeasurements) {
+        for (const status of measurement.statusCodes) {
+            const identity = buildLoadEngineV2StatusIdentityKey(status.statusCode, status.message);
+            if (identity)
+                sourceStatuses.set(identity.identity.toString("hex"), status);
+        }
+    }
+    const statusCodes = new Map();
+    const outcomeSummaries = outcome === "all"
+        ? summary.outcomes
+        : summary.outcomes.filter((candidate) => candidate.outcome === outcome);
+    for (const outcomeSummary of outcomeSummaries) {
+        for (const status of outcomeSummary.statuses) {
+            const source = sourceStatuses.get(status.statusIdentityKeyHex);
+            statusCodes.set(`${outcomeSummary.outcome}\0${status.statusIdentityKeyHex}`, {
+                statusCode: source?.statusCode ?? status.display,
+                message: source?.message ?? "",
+                isError: source?.isError ?? outcomeSummary.outcome === "fail",
+                count: loadEngineV2SafeNumber(status.count64, "status count")
+            });
+        }
+    }
+    const expectedCount = loadEngineV2SafeNumber(expectedCount64, "measurement count");
+    const sizeHistogram = LoadStrikeHistogramV1.fromSidecar(size.histogram);
+    return buildHistogramMeasurement({
+        count: expectedCount,
+        allBytes: loadEngineV2SafeNumber(sizeHistogram.exactTotal.toString(), "measurement byte total"),
+        latency: LoadStrikeHistogramV1.fromSidecar(latency.histogram),
+        size: sizeHistogram,
+        statusCodes,
+        lessOrEq800: loadEngineV2SafeNumber((bands.get("0") ?? 0n).toString(), "latency band count"),
+        more800Less1200: loadEngineV2SafeNumber((bands.get("1") ?? 0n).toString(), "latency band count"),
+        moreOrEq1200: loadEngineV2SafeNumber((bands.get("2") ?? 0n).toString(), "latency band count")
+    }, allRequestCount, durationMs);
+}
+function requireLoadEngineV2MeasurementDistribution(summary, outcome, unit, distributions) {
+    const distribution = distributions.get(loadEngineV2DistributionProjectionKey(summary.seriesKind, summary.scenarioIndex64, summary.identityKeyHex, outcome, unit));
+    if (!distribution || distribution.scenarioName !== summary.scenarioName) {
+        throw new Error("Load Engine V2 measurement summary is missing its canonical histogram distribution.");
+    }
+    return distribution;
+}
+function loadEngineV2DistributionProjectionKey(seriesKind, scenarioIndex64, identityKeyHex, outcome, unit) {
+    return [seriesKind, scenarioIndex64, identityKeyHex, outcome, unit].join("\0");
+}
+function compareLoadEngineV2Decimal(left, right) {
+    const a = BigInt(left);
+    const b = BigInt(right);
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function loadEngineV2SafeNumber(value, field) {
+    const parsed = BigInt(value);
+    if (parsed < 0n || parsed > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`Load Engine V2 ${field} exceeds the JavaScript safe integer range.`);
+    }
+    return Number(parsed);
+}
+function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo, requireHistogramArtifact = false) {
     const completedUtc = new Date().toISOString();
     if (!result.success || !result.stats) {
         return attachNodeStatsAliases({
@@ -6013,12 +7940,12 @@ function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
                     isFailed: true,
                     errorCount: 1,
                     exceptionMessage: result.error ?? "Agent execution failed."
-                }]
+                }],
+            reportingComplete: false
         });
     }
     const metrics = normalizeMetricStatsPayload(result.stats.metrics, result.stats.durationMs ?? 0);
-    const scenarioStats = normalizeScenarioStatsPayload(result.stats.scenarioStats);
-    const stepStats = scenarioStats.flatMap((value) => value.stepStats);
+    let scenarioStats = normalizeScenarioStatsPayload(result.stats.scenarioStats);
     const thresholds = normalizeThresholdPayload(result.stats.thresholds);
     const pluginsData = normalizePluginsPayload(result.stats.pluginsData);
     const nodeInfo = {
@@ -6031,6 +7958,17 @@ function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
         ...testInfo,
         ...(result.stats.testInfo ?? {})
     };
+    const histogramArtifactBase64 = String(result.stats.histogramArtifactBase64 ?? "");
+    if (requireHistogramArtifact && !histogramArtifactBase64) {
+        throw new Error("Load Engine V2 result omits the mandatory LS-H1 histogram artifact.");
+    }
+    const histogramArtifact = histogramArtifactBase64
+        ? parseLoadEngineV2HistogramArtifact(Buffer.from(histogramArtifactBase64, "base64"))
+        : undefined;
+    if (histogramArtifact) {
+        scenarioStats = projectLoadEngineV2MeasurementsFromArtifact(scenarioStats, histogramArtifact);
+    }
+    const stepStats = scenarioStats.flatMap((value) => value.stepStats);
     return attachNodeStatsAliases({
         startedUtc: testInfo.createdUtc,
         completedUtc,
@@ -6053,6 +7991,17 @@ function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
         sinkErrors: [],
         reportFiles: [],
         logFiles: normalizeAliasStringArray(result.stats.logFiles),
+        generatorWarnings: (result.stats.generatorWarnings ?? []).map(attachGeneratorWarningAliases),
+        schedulerSegments: (result.stats.schedulerSegments ?? []).map(normalizeSchedulerSegment),
+        schedulerStats: result.stats.schedulerStats
+            ? normalizeSchedulerStats(result.stats.schedulerStats)
+            : undefined,
+        [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]: histogramArtifact?.distributions
+            .filter((record) => record.seriesKind === "scheduler-decision-lag"
+            || record.seriesKind === "scheduler-start-lag")
+            .map(cloneLoadEngineV2DistributionRecord),
+        observationDeliveryStats: normalizeObservationDeliveryStats(result.stats.observationDeliveryStats ?? emptyObservationDeliveryStats()),
+        reportingComplete: result.stats.reportingComplete ?? false,
         findScenarioStats: (scenarioName) => scenarioStats.find((value) => value.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -6063,7 +8012,46 @@ function clusterNodeResultToNodeStats(result, testInfo, fallbackNodeInfo) {
         }
     });
 }
-function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes) {
+function emptyObservationDeliveryStats() {
+    return normalizeObservationDeliveryStats({
+        lastBatchSequence64: "-1",
+        capturedCount64: "0",
+        deliveredCount64: "0",
+        droppedBufferCount64: "0",
+        droppedSinkCount64: "0"
+    });
+}
+function aggregateObservationDeliveryStats(nodes) {
+    let lastBatchSequence = -1n;
+    let captured = 0n;
+    let delivered = 0n;
+    let droppedBuffer = 0n;
+    let droppedSink = 0n;
+    for (const node of nodes) {
+        const stats = node.observationDeliveryStats ?? emptyObservationDeliveryStats();
+        lastBatchSequence = maxBigInt(lastBatchSequence, parseObservationDecimal(stats.lastBatchSequence64, -1n));
+        captured += parseObservationDecimal(stats.capturedCount64);
+        delivered += parseObservationDecimal(stats.deliveredCount64);
+        droppedBuffer += parseObservationDecimal(stats.droppedBufferCount64);
+        droppedSink += parseObservationDecimal(stats.droppedSinkCount64);
+    }
+    return normalizeObservationDeliveryStats({
+        lastBatchSequence64: lastBatchSequence.toString(),
+        capturedCount64: captured.toString(),
+        deliveredCount64: delivered.toString(),
+        droppedBufferCount64: droppedBuffer.toString(),
+        droppedSinkCount64: droppedSink.toString()
+    });
+}
+function parseObservationDecimal(value, fallback = 0n) {
+    try {
+        return BigInt(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes, requireHistograms = false) {
     if (!nodes.length) {
         return buildEmptyNodeStats({
             startedUtc: testInfo.createdUtc,
@@ -6072,12 +8060,22 @@ function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes) {
             testInfo
         });
     }
-    const scenarioStats = aggregateScenarioStats(nodes);
+    const scenarioStats = aggregateScenarioStats(nodes, requireHistograms);
     const stepStats = scenarioStats.flatMap((value) => value.stepStats);
     const metrics = aggregateMetricStats(nodes);
     const thresholds = aggregateThresholds(nodes);
     const pluginsData = aggregatePluginsData(nodes);
     const completedUtc = new Date().toISOString();
+    const schedulerSegments = nodes.flatMap((value) => value.schedulerSegments ?? []);
+    const schedulerStatsRows = nodes.flatMap((value) => value.schedulerStats ? [value.schedulerStats] : []);
+    const schedulerStats = schedulerSegments.length || schedulerStatsRows.length
+        ? {
+            configuredMaxInFlight: schedulerStatsRows.reduce((maximum, value) => Math.max(maximum, value.configuredMaxInFlight), 0),
+            maxInFlightObserved: schedulerStatsRows.reduce((maximum, value) => Math.max(maximum, value.maxInFlightObserved), 0),
+            currentInFlight: schedulerStatsRows.reduce((sum, value) => sum + value.currentInFlight, 0),
+            segments: schedulerSegments
+        }
+        : undefined;
     return attachNodeStatsAliases({
         startedUtc: testInfo.createdUtc,
         completedUtc,
@@ -6100,6 +8098,12 @@ function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes) {
         sinkErrors: [],
         reportFiles: [],
         logFiles: mergeStringArrays(...nodes.map((value) => value.logFiles ?? [])),
+        generatorWarnings: nodes.flatMap((value) => value.generatorWarnings ?? []),
+        ...(schedulerSegments.length ? { schedulerSegments } : {}),
+        ...(schedulerStats ? { schedulerStats } : {}),
+        [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]: mergeLoadEngineV2SchedulerDistributions(nodes.flatMap((value) => value[LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS] ?? [])),
+        observationDeliveryStats: aggregateObservationDeliveryStats(nodes),
+        reportingComplete: nodes.every((value) => value.reportingComplete ?? false),
         findScenarioStats: (scenarioName) => scenarioStats.find((value) => value.scenarioName === scenarioName),
         getScenarioStats: (scenarioName) => {
             const value = scenarioStats.find((scenario) => scenario.scenarioName === scenarioName);
@@ -6110,7 +8114,7 @@ function aggregateNodeStats(testInfo, coordinatorNodeInfo, nodes) {
         }
     });
 }
-function aggregateScenarioStats(nodes) {
+function aggregateScenarioStats(nodes, requireHistograms = false) {
     const grouped = new Map();
     for (const node of nodes) {
         for (const scenario of node.scenarioStats) {
@@ -6124,9 +8128,12 @@ function aggregateScenarioStats(nodes) {
         .map((items) => {
         const allRequestCount = items.reduce((sum, value) => sum + value.allRequestCount, 0);
         const durationMs = items.reduce((max, value) => Math.max(max, value.durationMs), 0);
-        const ok = aggregateMeasurementStats(items.map((value) => value.ok), allRequestCount, durationMs);
-        const fail = aggregateMeasurementStats(items.map((value) => value.fail), allRequestCount, durationMs);
-        const stepStats = aggregateStepStats(items);
+        const ok = aggregateMeasurementStats(items.map((value) => value.ok), allRequestCount, durationMs, requireHistograms);
+        const fail = aggregateMeasurementStats(items.map((value) => value.fail), allRequestCount, durationMs, requireHistograms);
+        const allMeasurement = requireHistograms
+            ? aggregateMeasurementStats([ok, fail], allRequestCount, durationMs, true)
+            : undefined;
+        const stepStats = aggregateStepStats(items, requireHistograms);
         const scenarioName = items[0]?.scenarioName ?? "";
         const currentOperation = selectScenarioOperation(items.map((value) => value.currentOperation));
         const loadSimulationStats = items.find((value) => value.loadSimulationStats.simulationName)?.loadSimulationStats ?? {
@@ -6151,6 +8158,7 @@ function aggregateScenarioStats(nodes) {
             durationMs,
             ok,
             fail,
+            ...(allMeasurement ? { allMeasurement } : {}),
             loadSimulationStats,
             sortIndex: Math.min(...items.map((value) => value.sortIndex)),
             stepStats,
@@ -6166,7 +8174,7 @@ function aggregateScenarioStats(nodes) {
         return attachScenarioStatsAliases(scenario);
     });
 }
-function aggregateStepStats(scenarios) {
+function aggregateStepStats(scenarios, requireHistograms = false) {
     const grouped = new Map();
     for (const scenario of scenarios) {
         for (const step of scenario.stepStats) {
@@ -6180,8 +8188,11 @@ function aggregateStepStats(scenarios) {
     return Array.from(grouped.values())
         .sort((left, right) => Math.min(...left.map((value) => value.sortIndex)) - Math.min(...right.map((value) => value.sortIndex)))
         .map((items) => {
-        const ok = aggregateMeasurementStats(items.map((value) => value.ok), allScenarioRequests, scenarioDurationMs);
-        const fail = aggregateMeasurementStats(items.map((value) => value.fail), allScenarioRequests, scenarioDurationMs);
+        const ok = aggregateMeasurementStats(items.map((value) => value.ok), allScenarioRequests, scenarioDurationMs, requireHistograms);
+        const fail = aggregateMeasurementStats(items.map((value) => value.fail), allScenarioRequests, scenarioDurationMs, requireHistograms);
+        const allMeasurement = requireHistograms
+            ? aggregateMeasurementStats([ok, fail], allScenarioRequests, scenarioDurationMs, true)
+            : undefined;
         const requestCount = ok.request.count + fail.request.count;
         return {
             scenarioName: items[0]?.scenarioName ?? "",
@@ -6197,14 +8208,53 @@ function aggregateStepStats(scenarios) {
             statusCodes: aggregateStatusCodeCounts(ok.statusCodes, fail.statusCodes),
             ok,
             fail,
+            ...(allMeasurement ? { allMeasurement } : {}),
             sortIndex: Math.min(...items.map((value) => value.sortIndex))
         };
     });
 }
-function aggregateMeasurementStats(measurements, allRequestCount, durationMs) {
+function aggregateMeasurementStats(measurements, allRequestCount, durationMs, requireHistograms = false) {
     if (!measurements.length) {
         return buildMeasurementPlaceholder(0, allRequestCount, durationMs);
     }
+    if (measurements.every((measurement) => measurement.histogramSidecar)) {
+        const latency = LoadStrikeHistogramV1.fromSidecar(measurements[0].histogramSidecar.latency);
+        const size = LoadStrikeHistogramV1.fromSidecar(measurements[0].histogramSidecar.size);
+        for (const measurement of measurements.slice(1)) {
+            latency.merge(LoadStrikeHistogramV1.fromSidecar(measurement.histogramSidecar.latency));
+            size.merge(LoadStrikeHistogramV1.fromSidecar(measurement.histogramSidecar.size));
+        }
+        const statusCodes = new Map();
+        for (const measurement of measurements) {
+            for (const status of measurement.statusCodes) {
+                const key = `${status.statusCode}|${status.message}|${status.isError ? "1" : "0"}`;
+                const current = statusCodes.get(key);
+                if (current)
+                    current.count += status.count;
+                else
+                    statusCodes.set(key, {
+                        statusCode: status.statusCode,
+                        message: status.message,
+                        isError: status.isError,
+                        count: status.count
+                    });
+            }
+        }
+        const sumSidecar = (key) => Number(measurements.reduce((sum, measurement) => sum + BigInt(measurement.histogramSidecar[key]), 0n));
+        return buildHistogramMeasurement({
+            count: Number(latency.count),
+            allBytes: measurements.reduce((sum, measurement) => sum + measurement.dataTransfer.allBytes, 0),
+            latency,
+            size,
+            statusCodes,
+            lessOrEq800: sumSidecar("lessOrEq80064"),
+            more800Less1200: sumSidecar("more800Less120064"),
+            moreOrEq1200: sumSidecar("moreOrEq120064")
+        }, allRequestCount, durationMs);
+    }
+    if (requireHistograms) {
+        throw new Error("Load Engine V2 aggregation requires canonical histogram state for every node measurement.");
+    }
     const weights = measurements.map((value) => value.request.count);
     const totalCount = measurements.reduce((sum, value) => sum + value.request.count, 0);
     return {
@@ -7420,11 +9470,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);
     }
@@ -7448,23 +9510,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 = {};
+        }
+        else {
+            child = runtimeCloneJsonRecord(next);
         }
-        current = current[segment];
+        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) {
@@ -7474,8 +9570,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;
@@ -7729,26 +9825,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) {
@@ -8026,6 +10106,68 @@ function normalizeOptionalReportFormats(value) {
     const normalized = normalizeReportFormats(value);
     return normalized.length ? normalized : undefined;
 }
+function normalizeDeclaredStepNames(value) {
+    if (!Array.isArray(value)) {
+        throw new TypeError("Declared step names must be provided as text values.");
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const entry of value) {
+        if (typeof entry !== "string" || !entry.trim()) {
+            throw new Error("Declared step name must be non-empty text.");
+        }
+        const stepName = entry.trim();
+        for (let index = 0; index < stepName.length; index += 1) {
+            const code = stepName.charCodeAt(index);
+            if (code >= 0xd800 && code <= 0xdbff) {
+                const next = stepName.charCodeAt(index + 1);
+                if (!(next >= 0xdc00 && next <= 0xdfff)) {
+                    throw new Error("Declared step name contains an invalid Unicode scalar.");
+                }
+                index += 1;
+            }
+            else if (code >= 0xdc00 && code <= 0xdfff) {
+                throw new Error("Declared step name contains an invalid Unicode scalar.");
+            }
+        }
+        if (!seen.has(stepName)) {
+            seen.add(stepName);
+            normalized.push(stepName);
+        }
+    }
+    return normalized;
+}
+function resolveIterationObservationSettings(options) {
+    return {
+        flushIntervalMs: options.iterationObservationFlushIntervalSeconds === undefined
+            ? DEFAULT_ITERATION_OBSERVATION_SETTINGS.flushIntervalMs
+            : options.iterationObservationFlushIntervalSeconds * 1000,
+        maxBufferBytes: options.maxIterationObservationBufferBytes
+            ?? DEFAULT_ITERATION_OBSERVATION_SETTINGS.maxBufferBytes,
+        maxObservationsPerBatch: options.maxIterationObservationsPerBatch
+            ?? DEFAULT_ITERATION_OBSERVATION_SETTINGS.maxObservationsPerBatch,
+        maxBatchBytes: options.maxIterationObservationBatchBytes
+            ?? DEFAULT_ITERATION_OBSERVATION_SETTINGS.maxBatchBytes,
+        sinkQueueDepth: options.iterationObservationSinkQueueDepth
+            ?? DEFAULT_ITERATION_OBSERVATION_SETTINGS.sinkQueueDepth,
+        sinkParallelism: options.iterationObservationSinkParallelism
+            ?? DEFAULT_ITERATION_OBSERVATION_SETTINGS.sinkParallelism,
+        drainTimeoutMs: options.iterationObservationDrainTimeoutSeconds === undefined
+            ? DEFAULT_ITERATION_OBSERVATION_SETTINGS.drainTimeoutMs
+            : options.iterationObservationDrainTimeoutSeconds * 1000
+    };
+}
+function validateRunContextIterationObservationSettings(values) {
+    validateIterationObservationSettings(resolveIterationObservationSettings({
+        iterationObservationFlushIntervalSeconds: values.IterationObservationFlushIntervalSeconds,
+        maxIterationObservationBufferBytes: values.MaxIterationObservationBufferBytes,
+        maxIterationObservationsPerBatch: values.MaxIterationObservationsPerBatch,
+        maxIterationObservationBatchBytes: values.MaxIterationObservationBatchBytes,
+        iterationObservationSinkQueueDepth: values.IterationObservationSinkQueueDepth,
+        iterationObservationSinkParallelism: values.IterationObservationSinkParallelism,
+        iterationObservationDrainTimeoutSeconds: values.IterationObservationDrainTimeoutSeconds
+    }));
+}
 function assertNoDisableLicenseEnforcementOption(value, source) {
     if (value == null || typeof value !== "object" || Array.isArray(value)) {
         return;
@@ -8044,12 +10186,121 @@ function normalizeRunContextCollectionShapes(values) {
         TargetScenarios: normalizeOptionalStringArray(values.TargetScenarios),
         AgentTargetScenarios: normalizeOptionalStringArray(values.AgentTargetScenarios),
         CoordinatorTargetScenarios: normalizeOptionalStringArray(values.CoordinatorTargetScenarios),
+        ExpectedAgentIds: normalizeOptionalStringArray(values.ExpectedAgentIds),
         ReportFormats: normalizeOptionalReportFormats(values.ReportFormats)
     };
     validateNamedReportingSinks(normalized.ReportingSinks ?? []);
     validateNamedWorkerPlugins(normalized.WorkerPlugins ?? []);
+    validateLoadEngineV2Options(normalized.LoadEngineContractVersion, normalized.MaxInFlight);
+    validateRunContextIterationObservationSettings(normalized);
     return normalized;
 }
+function normalizeAliasStringRecord(value) {
+    const source = asAliasRecord(value);
+    const output = {};
+    for (const [key, entry] of Object.entries(source)) {
+        output[key] = String(entry);
+    }
+    return output;
+}
+function attachGeneratorWarningAliases(value) {
+    const source = asAliasRecord(value);
+    const projected = {
+        code: pickAliasString(source, "code", "Code"),
+        ...(hasAliasValue(source, "sinkName", "SinkName")
+            ? { sinkName: pickAliasString(source, "sinkName", "SinkName") }
+            : {}),
+        scenarioName: pickAliasString(source, "scenarioName", "ScenarioName"),
+        ...(hasAliasValue(source, "scenarioIndex", "ScenarioIndex")
+            ? { scenarioIndex: pickAliasNumber(source, "scenarioIndex", "ScenarioIndex") }
+            : {}),
+        simulationIndex: pickAliasNumber(source, "simulationIndex", "SimulationIndex"),
+        ...(hasAliasValue(source, "simulationKind", "SimulationKind")
+            ? { simulationKind: pickAliasString(source, "simulationKind", "SimulationKind") }
+            : {}),
+        count64: pickAliasString(source, "count64", "Count64"),
+        message: pickAliasString(source, "message", "Message"),
+        firstObservedUtcNs: pickAliasString(source, "firstObservedUtcNs", "FirstObservedUtcNs"),
+        lastObservedUtcNs: pickAliasString(source, "lastObservedUtcNs", "LastObservedUtcNs")
+    };
+    return attachAliasMap(projected, {
+        Code: "code",
+        SinkName: "sinkName",
+        ScenarioName: "scenarioName",
+        ScenarioIndex: "scenarioIndex",
+        SimulationIndex: "simulationIndex",
+        SimulationKind: "simulationKind",
+        Count64: "count64",
+        Message: "message",
+        FirstObservedUtcNs: "firstObservedUtcNs",
+        LastObservedUtcNs: "lastObservedUtcNs"
+    });
+}
+function normalizeSchedulerSegment(value) {
+    const source = asAliasRecord(value);
+    return {
+        scenarioName: pickAliasString(source, "scenarioName", "ScenarioName"),
+        scenarioIndex: pickAliasNumber(source, "scenarioIndex", "ScenarioIndex"),
+        simulationIndex: pickAliasNumber(source, "simulationIndex", "SimulationIndex"),
+        kind: pickAliasString(source, "kind", "Kind"),
+        shardIndex: pickAliasNumber(source, "shardIndex", "ShardIndex"),
+        shardCount: Math.max(pickAliasNumber(source, "shardCount", "ShardCount"), 1),
+        plannedIterations64: pickAliasString(source, "plannedIterations64", "PlannedIterations64"),
+        dueIterations64: pickAliasString(source, "dueIterations64", "DueIterations64"),
+        startedIterations64: pickAliasString(source, "startedIterations64", "StartedIterations64"),
+        completedIterations64: pickAliasString(source, "completedIterations64", "CompletedIterations64"),
+        droppedIterations64: pickAliasString(source, "droppedIterations64", "DroppedIterations64"),
+        unreachedIterations64: pickAliasString(source, "unreachedIterations64", "UnreachedIterations64"),
+        requestedWorkerSlots64: pickAliasString(source, "requestedWorkerSlots64", "RequestedWorkerSlots64"),
+        startedWorkerSlots64: pickAliasString(source, "startedWorkerSlots64", "StartedWorkerSlots64"),
+        unavailableWorkerSlots64: pickAliasString(source, "unavailableWorkerSlots64", "UnavailableWorkerSlots64"),
+        dropReasons: normalizeAliasStringRecord(pickAliasValue(source, "dropReasons", "DropReasons")),
+        unavailableWorkerReasons: normalizeAliasStringRecord(pickAliasValue(source, "unavailableWorkerReasons", "UnavailableWorkerReasons")),
+        deliveryPercent: pickAliasNumber(source, "deliveryPercent", "DeliveryPercent"),
+        accountingComplete: pickAliasBoolean(source, "accountingComplete", "AccountingComplete")
+    };
+}
+function normalizeSchedulerStats(value) {
+    const source = asAliasRecord(value);
+    return {
+        configuredMaxInFlight: pickAliasNumber(source, "configuredMaxInFlight", "ConfiguredMaxInFlight"),
+        maxInFlightObserved: pickAliasNumber(source, "maxInFlightObserved", "MaxInFlightObserved"),
+        currentInFlight: pickAliasNumber(source, "currentInFlight", "CurrentInFlight"),
+        segments: pickAliasArray(source, "segments", "Segments").map(normalizeSchedulerSegment)
+    };
+}
+function normalizeObservationDeliveryStats(value) {
+    const source = asAliasRecord(value);
+    return attachAliasMap({
+        lastBatchSequence64: pickAliasString(source, "lastBatchSequence64", "LastBatchSequence64"),
+        capturedCount64: pickAliasString(source, "capturedCount64", "CapturedCount64"),
+        deliveredCount64: pickAliasString(source, "deliveredCount64", "DeliveredCount64"),
+        droppedBufferCount64: pickAliasString(source, "droppedBufferCount64", "DroppedBufferCount64"),
+        droppedSinkCount64: pickAliasString(source, "droppedSinkCount64", "DroppedSinkCount64")
+    }, {
+        LastBatchSequence64: "lastBatchSequence64",
+        CapturedCount64: "capturedCount64",
+        DeliveredCount64: "deliveredCount64",
+        DroppedBufferCount64: "droppedBufferCount64",
+        DroppedSinkCount64: "droppedSinkCount64"
+    });
+}
+function validateLoadEngineV2Options(contractVersion, maxInFlight) {
+    if (contractVersion !== undefined && contractVersion !== 1 && contractVersion !== 2) {
+        throw new RangeError("Load engine contract version must be either 1 or 2.");
+    }
+    if (maxInFlight !== undefined) {
+        validateV2MaxInFlight(contractVersion, maxInFlight);
+    }
+}
+function validateV2MaxInFlight(contractVersion, maxInFlight) {
+    if (contractVersion !== 2) {
+        throw new Error("MaxInFlight is available only when Load Engine V2 is selected.");
+    }
+    if (!Number.isSafeInteger(maxInFlight) || maxInFlight < 1 || maxInFlight > 1000000) {
+        throw new RangeError("MaxInFlight must be an integer from 1 through 1000000.");
+    }
+}
 function normalizeRunnerOptionCollectionShapes(options) {
     assertNoDisableLicenseEnforcementOption(options, "LoadStrikeRunner");
     const normalized = {
@@ -8057,10 +10308,13 @@ function normalizeRunnerOptionCollectionShapes(options) {
         targetScenarios: normalizeOptionalStringArray(options.targetScenarios),
         agentTargetScenarios: normalizeOptionalStringArray(options.agentTargetScenarios),
         coordinatorTargetScenarios: normalizeOptionalStringArray(options.coordinatorTargetScenarios),
+        expectedAgentIds: normalizeOptionalStringArray(options.expectedAgentIds),
         reportFormats: normalizeOptionalReportFormats(options.reportFormats)
     };
     validateNamedReportingSinks(normalized.reportingSinks ?? []);
     validateNamedWorkerPlugins(normalized.workerPlugins ?? []);
+    validateLoadEngineV2Options(normalized.loadEngineContractVersion, normalized.maxInFlight);
+    validateIterationObservationSettings(resolveIterationObservationSettings(normalized));
     return normalized;
 }
 function normalizedRuntimePolicyErrorMode(value) {
@@ -8124,6 +10378,7 @@ function extractContextOverridesFromConfig(config) {
     setString("ReportFileName", "ReportFileName", "LoadStrike:ReportFileName");
     setString("ClusterId", "ClusterId", "LoadStrike:ClusterId");
     setString("AgentGroup", "AgentGroup", "LoadStrike:AgentGroup");
+    setString("AgentId", "AgentId", "LoadStrike:AgentId");
     setString("NatsServerUrl", "NatsServerUrl", "LoadStrike:NatsServerUrl");
     setString("RunnerKey", "RunnerKey", "LoadStrike:RunnerKey");
     setString("RuntimePolicyErrorMode", "RuntimePolicyErrorMode", "LoadStrike:RuntimePolicyErrorMode");
@@ -8153,6 +10408,13 @@ function extractContextOverridesFromConfig(config) {
         }
     }
     setPositiveNumber("ReportingIntervalSeconds", "ReportingIntervalSeconds", "LoadStrike:ReportingIntervalSeconds");
+    setPositiveNumber("IterationObservationFlushIntervalSeconds", "IterationObservationFlushInterval", "IterationObservationFlushIntervalSeconds", "LoadStrike:IterationObservationFlushInterval");
+    setPositiveNumber("MaxIterationObservationBufferBytes", "MaxIterationObservationBufferBytes", "LoadStrike:MaxIterationObservationBufferBytes");
+    setPositiveNumber("MaxIterationObservationsPerBatch", "MaxIterationObservationsPerBatch", "LoadStrike:MaxIterationObservationsPerBatch");
+    setPositiveNumber("MaxIterationObservationBatchBytes", "MaxIterationObservationBatchBytes", "LoadStrike:MaxIterationObservationBatchBytes");
+    setPositiveNumber("IterationObservationSinkQueueDepth", "IterationObservationSinkQueueDepth", "LoadStrike:IterationObservationSinkQueueDepth");
+    setPositiveNumber("IterationObservationSinkParallelism", "IterationObservationSinkParallelism", "LoadStrike:IterationObservationSinkParallelism");
+    setPositiveNumber("IterationObservationDrainTimeoutSeconds", "IterationObservationDrainTimeout", "IterationObservationDrainTimeoutSeconds", "LoadStrike:IterationObservationDrainTimeout");
     setPositiveNumber("ScenarioCompletionTimeoutSeconds", "ScenarioCompletionTimeoutSeconds", "LoadStrike:ScenarioCompletionTimeoutSeconds");
     setPositiveNumber("ClusterCommandTimeoutSeconds", "ClusterCommandTimeoutSeconds", "LoadStrike:ClusterCommandTimeoutSeconds");
     setPositiveNumber("LicenseValidationTimeoutSeconds", "LicenseValidationTimeoutSeconds", "LoadStrike:LicenseValidation:TimeoutSeconds");
@@ -8160,6 +10422,14 @@ function extractContextOverridesFromConfig(config) {
     if (reportingIntervalMs > 0) {
         patch.ReportingIntervalSeconds = reportingIntervalMs / 1000;
     }
+    const observationFlushIntervalMs = toNumber(pick("IterationObservationFlushIntervalMs", "LoadStrike:IterationObservationFlushIntervalMs"));
+    if (observationFlushIntervalMs > 0) {
+        patch.IterationObservationFlushIntervalSeconds = observationFlushIntervalMs / 1000;
+    }
+    const observationDrainTimeoutMs = toNumber(pick("IterationObservationDrainTimeoutMs", "LoadStrike:IterationObservationDrainTimeoutMs"));
+    if (observationDrainTimeoutMs > 0) {
+        patch.IterationObservationDrainTimeoutSeconds = observationDrainTimeoutMs / 1000;
+    }
     const scenarioCompletionTimeoutMs = toNumber(pick("ScenarioCompletionTimeoutMs", "LoadStrike:ScenarioCompletionTimeoutMs"));
     if (scenarioCompletionTimeoutMs > 0) {
         patch.ScenarioCompletionTimeoutSeconds = scenarioCompletionTimeoutMs / 1000;
@@ -8204,6 +10474,10 @@ function extractContextOverridesFromConfig(config) {
     if (agentTargetScenarios.length) {
         patch.AgentTargetScenarios = agentTargetScenarios;
     }
+    const expectedAgentIds = normalizeStringArray(pick("ExpectedAgentIds", "LoadStrike:ExpectedAgentIds"));
+    if (expectedAgentIds.length) {
+        patch.ExpectedAgentIds = expectedAgentIds;
+    }
     const coordinatorTargetScenarios = normalizeStringArray(pick("CoordinatorTargetScenarios", "LoadStrike:CoordinatorTargetScenarios"));
     if (coordinatorTargetScenarios.length) {
         patch.CoordinatorTargetScenarios = coordinatorTargetScenarios;
@@ -8266,10 +10540,14 @@ function toRunContext(options) {
     const normalized = normalizeRunnerOptionCollectionShapes(options);
     return {
         ConsoleMetricsEnabled: normalized.displayConsoleMetrics,
+        LoadEngineContractVersion: normalized.loadEngineContractVersion,
+        MaxInFlight: normalized.maxInFlight,
         NodeType: normalized.nodeType,
         LocalDevClusterEnabled: normalized.localDevClusterEnabled,
         AgentGroup: normalized.agentGroup,
         AgentsCount: normalized.agentsCount,
+        AgentId: normalized.agentId,
+        ExpectedAgentIds: normalized.expectedAgentIds,
         TargetScenarios: normalized.targetScenarios,
         AgentTargetScenarios: normalized.agentTargetScenarios,
         CoordinatorTargetScenarios: normalized.coordinatorTargetScenarios,
@@ -8288,6 +10566,13 @@ function toRunContext(options) {
         ReportFolderPath: normalized.reportFolderPath,
         ReportFormats: normalized.reportFormats,
         ReportingIntervalSeconds: normalized.reportingIntervalSeconds,
+        IterationObservationFlushIntervalSeconds: normalized.iterationObservationFlushIntervalSeconds,
+        MaxIterationObservationBufferBytes: normalized.maxIterationObservationBufferBytes,
+        MaxIterationObservationsPerBatch: normalized.maxIterationObservationsPerBatch,
+        MaxIterationObservationBatchBytes: normalized.maxIterationObservationBatchBytes,
+        IterationObservationSinkQueueDepth: normalized.iterationObservationSinkQueueDepth,
+        IterationObservationSinkParallelism: normalized.iterationObservationSinkParallelism,
+        IterationObservationDrainTimeoutSeconds: normalized.iterationObservationDrainTimeoutSeconds,
         MinimumLogLevel: normalized.minimumLogLevel,
         LoggerConfig: normalized.loggerConfig,
         ReportingSinks: normalized.reportingSinks,
@@ -8302,7 +10587,9 @@ function toRunContext(options) {
         CustomSettings: normalized.customSettings,
         GlobalCustomSettings: normalized.globalCustomSettings,
         AgentExecutionToken: normalized.agentExecutionToken,
-        AgentCommandId: normalized.agentCommandId
+        AgentCommandId: normalized.agentCommandId,
+        ClusterShardIndex: normalized.clusterShardIndex,
+        ClusterShardCount: normalized.clusterShardCount
     };
 }
 class RuntimePolicyCallbackError extends Error {
@@ -8390,11 +10677,15 @@ function looksLikeRunContext(value) {
     const keys = new Set(Object.keys(value));
     return [
         "ConsoleMetricsEnabled",
+        "LoadEngineContractVersion",
+        "MaxInFlight",
         "LocalDevClusterEnabled",
         "ConfigPath",
         "InfraConfigPath",
         "AgentGroup",
         "AgentsCount",
+        "AgentId",
+        "ExpectedAgentIds",
         "AgentTargetScenarios",
         "ClusterId",
         "CoordinatorTargetScenarios",
@@ -8409,6 +10700,13 @@ function looksLikeRunContext(value) {
         "ReportFolderPath",
         "ReportFormats",
         "ReportingIntervalSeconds",
+        "IterationObservationFlushIntervalSeconds",
+        "MaxIterationObservationBufferBytes",
+        "MaxIterationObservationsPerBatch",
+        "MaxIterationObservationBatchBytes",
+        "IterationObservationSinkQueueDepth",
+        "IterationObservationSinkParallelism",
+        "IterationObservationDrainTimeoutSeconds",
         "ReportingSinks",
         "SinkRetryCount",
         "SinkRetryBackoffMs",
@@ -8550,6 +10848,18 @@ function resolveSinkSaveRunResult(sink) {
         ? method.bind(sink)
         : undefined;
 }
+function resolveSinkSaveIterationBatch(sink) {
+    const method = sink.saveIterationBatch ?? sink.SaveIterationBatch;
+    return typeof method === "function"
+        ? method.bind(sink)
+        : undefined;
+}
+function resolveSinkCompleteIterationObservationStream(sink) {
+    const method = sink.completeIterationObservationStream ?? sink.CompleteIterationObservationStream;
+    return typeof method === "function"
+        ? method.bind(sink)
+        : undefined;
+}
 function resolveSinkStop(sink) {
     const method = sink.stop ?? sink.Stop;
     return typeof method === "function"
@@ -8967,13 +11277,17 @@ export const __loadstrikeTestExports = {
     ManagedScenarioTrackingRuntime,
     ScenarioStatsAccumulator,
     StepStatsAccumulator,
+    planRuntimeClusterAssignments,
     TrackingFieldSelector,
     addCorrelationRow,
     addFailedResponseRow,
     aggregateNodeStats,
+    aggregateMeasurementStats,
     asRecord,
     assertNoDisableLicenseEnforcementOption,
     buildEmptyNodeStats,
+    buildRuntimeLoadEngineV2HistogramArtifact,
+    buildRuntimeLoadEngineV2Plan,
     buildGroupedCorrelationRows,
     buildMeasurementPlaceholder,
     buildRichHtmlReport,
@@ -9028,6 +11342,7 @@ export const __loadstrikeTestExports = {
     parseStrictBooleanToken,
     percentile,
     pickOptionalTrackingSelectorString,
+    pickTrackingValue,
     pickTrackingNumber,
     produceOrConsumeTrackingPayload,
     readConfiguredSinkName,
@@ -9046,7 +11361,9 @@ export const __loadstrikeTestExports = {
     resolveSinkName,
     resolveSinkSaveRealtimeMetrics,
     resolveSinkSaveRealtimeStats,
+    resolveSinkSaveIterationBatch,
     resolveSinkSaveRunResult,
+    resolveSinkCompleteIterationObservationStream,
     resolveSinkStart,
     resolveSinkStop,
     resolveWorkerPlugins,
@@ -9067,6 +11384,7 @@ export const __loadstrikeTestExports = {
     tryParseNodeTypeToken,
     tryReadConfigValue,
     validateNamedReportingSinks,
+    validateLoadEngineV2ScenarioFeatures,
     validateRegisteredScenarios,
     validateRuntimeRedisCorrelationStoreConfiguration,
     validateRuntimeTrackingConfiguration,