@loadstrike/loadstrike-sdk 1.0.30201 → 1.0.31001

package/dist/types/runtime.d.ts

@@ -1,6 +1,9 @@
-import { type ClusterNodeResult } from "./cluster.js";
+import { type ClusterNodeResult, type LoadEngineV2PlanInput } from "./cluster.js";
 import { RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector, type TrackingPayload } from "./correlation.js";
 import { type EndpointAdapter, type EndpointDefinition } from "./transports.js";
+import { LoadEngineV2ExecutionBudget, type LoadEngineV2DistributionRecord, type LoadStrikeHistogramV1Sidecar } from "./load-engine-v2.js";
+import { type LoadStrikeIterationObservationBatchV1, type LoadStrikeIterationObservationStreamCompletionV1, type LoadStrikeIterationStepObservationV1, type LoadStrikeObservationDeliveryStats } from "./iteration-observations.js";
+declare const LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS: unique symbol;
 export declare const LoadStrikeNodeType: {
     readonly SingleNode: "SingleNode";
     readonly Coordinator: "Coordinator";
@@ -154,6 +157,7 @@ export interface LoadStrikeRequestStats {
 }
 export interface LoadStrikeDataTransferStats {
     allBytes: number;
+    allBytes64?: string;
     maxBytes: number;
     meanBytes: number;
     minBytes: number;
@@ -161,8 +165,10 @@ export interface LoadStrikeDataTransferStats {
     percent75: number;
     percent95: number;
     percent99: number;
+    percent100?: number;
     stdDev: number;
     readonly AllBytes?: number;
+    readonly AllBytes64?: string;
     readonly MaxBytes?: number;
     readonly MeanBytes?: number;
     readonly MinBytes?: number;
@@ -170,6 +176,7 @@ export interface LoadStrikeDataTransferStats {
     readonly Percent75?: number;
     readonly Percent95?: number;
     readonly Percent99?: number;
+    readonly Percent100?: number;
     readonly StdDev?: number;
 }
 export interface LoadStrikeLatencyCount {
@@ -189,6 +196,7 @@ export interface LoadStrikeLatencyStats {
     percent75: number;
     percent95: number;
     percent99: number;
+    percent100?: number;
     stdDev: number;
     readonly LatencyCount?: LoadStrikeLatencyCount;
     readonly MaxMs?: number;
@@ -198,6 +206,7 @@ export interface LoadStrikeLatencyStats {
     readonly Percent75?: number;
     readonly Percent95?: number;
     readonly Percent99?: number;
+    readonly Percent100?: number;
     readonly StdDev?: number;
 }
 export interface LoadStrikeStatusCodeStats {
@@ -213,11 +222,26 @@ export interface LoadStrikeStatusCodeStats {
     readonly StatusCode?: string;
 }
 export interface LoadStrikeMeasurementStats {
+    count64?: string;
+    distributionMode?: "exact-normalized" | "quantized-v1" | string;
+    maxRelativeError?: number;
+    /** @internal Mergeable V2 distribution state used by cluster result owners. */
+    histogramSidecar?: {
+        latency: LoadStrikeHistogramV1Sidecar;
+        size: LoadStrikeHistogramV1Sidecar;
+        allBytes64: string;
+        lessOrEq80064: string;
+        more800Less120064: string;
+        moreOrEq120064: string;
+    };
     dataTransfer: LoadStrikeDataTransferStats;
     latency: LoadStrikeLatencyStats;
     request: LoadStrikeRequestStats;
     statusCodes: LoadStrikeStatusCodeStats[];
     readonly DataTransfer?: LoadStrikeDataTransferStats;
+    readonly Count64?: string;
+    readonly DistributionMode?: string;
+    readonly MaxRelativeError?: number;
     readonly Latency?: LoadStrikeLatencyStats;
     readonly Request?: LoadStrikeRequestStats;
     readonly StatusCodes?: LoadStrikeStatusCodeStats[];
@@ -290,6 +314,55 @@ export declare class LoadStrikePluginData {
     get Hints(): string[];
     get Tables(): LoadStrikePluginDataTable[];
 }
+export interface LoadStrikeGeneratorWarning {
+    code: string;
+    sinkName?: string;
+    scenarioName: string;
+    scenarioIndex?: number;
+    simulationIndex: number;
+    simulationKind?: string;
+    count64: string;
+    message: string;
+    firstObservedUtcNs: string;
+    lastObservedUtcNs: string;
+    readonly Code?: string;
+    readonly SinkName?: string;
+    readonly ScenarioName?: string;
+    readonly ScenarioIndex?: number;
+    readonly SimulationIndex?: number;
+    readonly SimulationKind?: string;
+    readonly Count64?: string;
+    readonly Message?: string;
+    readonly FirstObservedUtcNs?: string;
+    readonly LastObservedUtcNs?: string;
+}
+export interface LoadStrikeSchedulerSegmentStats {
+    scenarioName: string;
+    scenarioIndex: number;
+    simulationIndex: number;
+    kind: string;
+    shardIndex: number;
+    shardCount: number;
+    plannedIterations64: string;
+    dueIterations64: string;
+    startedIterations64: string;
+    completedIterations64: string;
+    droppedIterations64: string;
+    unreachedIterations64: string;
+    requestedWorkerSlots64: string;
+    startedWorkerSlots64: string;
+    unavailableWorkerSlots64: string;
+    dropReasons: Record<string, string>;
+    unavailableWorkerReasons: Record<string, string>;
+    deliveryPercent: number;
+    accountingComplete: boolean;
+}
+export interface LoadStrikeSchedulerStats {
+    configuredMaxInFlight: number;
+    maxInFlightObserved: number;
+    currentInFlight: number;
+    segments: LoadStrikeSchedulerSegmentStats[];
+}
 export interface LoadStrikeRunResult {
     startedUtc: string;
     completedUtc: string;
@@ -316,6 +389,12 @@ export interface LoadStrikeRunResult {
     logFiles: string[];
     correlationRows: Array<Record<string, unknown>>;
     failedCorrelationRows: Array<Record<string, unknown>>;
+    generatorWarnings?: LoadStrikeGeneratorWarning[];
+    schedulerSegments?: LoadStrikeSchedulerSegmentStats[];
+    schedulerStats?: LoadStrikeSchedulerStats;
+    observationDeliveryStats?: LoadStrikeObservationDeliveryStats;
+    reportingComplete?: boolean;
+    [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]?: LoadEngineV2DistributionRecord[];
     findScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
     getScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats;
     FindScenarioStats?: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
@@ -346,8 +425,14 @@ export interface LoadStrikeRunResult {
     readonly LogFiles?: string[];
     readonly CorrelationRows?: Array<Record<string, unknown>>;
     readonly FailedCorrelationRows?: Array<Record<string, unknown>>;
+    readonly GeneratorWarnings?: LoadStrikeGeneratorWarning[];
+    readonly SchedulerSegments?: LoadStrikeSchedulerSegmentStats[];
+    readonly SchedulerStats?: LoadStrikeSchedulerStats;
+    readonly ObservationDeliveryStats?: LoadStrikeObservationDeliveryStats;
+    readonly ReportingComplete?: boolean;
 }
 export interface LoadStrikeStepStats extends LoadStrikeStepRuntime {
+    allMeasurement?: LoadStrikeMeasurementStats;
     ok: LoadStrikeMeasurementStats;
     fail: LoadStrikeMeasurementStats;
     sortIndex: number;
@@ -364,9 +449,11 @@ export interface LoadStrikeStepStats extends LoadStrikeStepRuntime {
     readonly StatusCodes?: Record<string, number>;
     readonly Ok?: LoadStrikeMeasurementStats;
     readonly Fail?: LoadStrikeMeasurementStats;
+    readonly AllMeasurement?: LoadStrikeMeasurementStats;
     readonly SortIndex?: number;
 }
 export interface LoadStrikeScenarioStats extends LoadStrikeScenarioRuntime {
+    allMeasurement?: LoadStrikeMeasurementStats;
     allBytes: number;
     currentOperation: "None" | "Init" | "WarmUp" | "Bombing" | "Stop" | "Complete" | "Error";
     durationMs: number;
@@ -395,6 +482,7 @@ export interface LoadStrikeScenarioStats extends LoadStrikeScenarioRuntime {
     readonly Duration?: number;
     readonly Ok?: LoadStrikeMeasurementStats;
     readonly Fail?: LoadStrikeMeasurementStats;
+    readonly AllMeasurement?: LoadStrikeMeasurementStats;
     readonly LoadSimulationStats?: LoadStrikeLoadSimulationStats;
     readonly SortIndex?: number;
     readonly StepStats?: LoadStrikeStepStats[];
@@ -421,6 +509,12 @@ interface LoadStrikeNodeStats {
     sinkErrors: LoadStrikeSinkError[];
     reportFiles: string[];
     logFiles: string[];
+    generatorWarnings: LoadStrikeGeneratorWarning[];
+    schedulerSegments?: LoadStrikeSchedulerSegmentStats[];
+    schedulerStats?: LoadStrikeSchedulerStats;
+    observationDeliveryStats: LoadStrikeObservationDeliveryStats;
+    reportingComplete: boolean;
+    [LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS]?: LoadEngineV2DistributionRecord[];
     findScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
     getScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
     FindScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
@@ -447,13 +541,23 @@ interface LoadStrikeNodeStats {
     readonly SinkErrors?: LoadStrikeSinkError[];
     readonly ReportFiles?: string[];
     readonly LogFiles?: string[];
+    readonly GeneratorWarnings?: LoadStrikeGeneratorWarning[];
+    readonly ObservationDeliveryStats?: LoadStrikeObservationDeliveryStats;
+    readonly ReportingComplete?: boolean;
 }
 declare class MeasurementAccumulator {
+    private readonly useHistogram;
     private count;
     private allBytes;
     private readonly latenciesMs;
     private readonly sizesBytes;
+    private readonly latencyHistogram?;
+    private readonly sizeHistogram?;
+    private latencyLessOrEq800;
+    private latencyMore800Less1200;
+    private latencyMoreOrEq1200;
     private readonly statusCodes;
+    constructor(useHistogram?: boolean);
     get Count(): number;
     /**
      * Exposes the public record operation.
@@ -465,14 +569,17 @@ declare class MeasurementAccumulator {
      * Use this when all builder inputs are ready to be materialized.
      */
     build(allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
+    buildCombined(other: MeasurementAccumulator, allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
+    private histogramSnapshot;
 }
 declare class StepStatsAccumulator {
     readonly scenarioName: string;
     readonly stepName: string;
     readonly sortIndex: number;
+    private readonly useHistogram;
     readonly ok: MeasurementAccumulator;
     readonly fail: MeasurementAccumulator;
-    constructor(scenarioName: string, stepName: string, sortIndex: number);
+    constructor(scenarioName: string, stepName: string, sortIndex: number, useHistogram?: boolean);
     /**
      * Exposes the public record operation.
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
@@ -487,13 +594,14 @@ declare class StepStatsAccumulator {
 declare class ScenarioStatsAccumulator {
     readonly scenarioName: string;
     readonly sortIndex: number;
+    private readonly useHistogram;
     readonly ok: MeasurementAccumulator;
     readonly fail: MeasurementAccumulator;
     private readonly steps;
     private nextStepSortIndex;
     private loadSimulationStats;
     private currentOperation;
-    constructor(scenarioName: string, sortIndex: number);
+    constructor(scenarioName: string, sortIndex: number, useHistogram?: boolean);
     /**
      * Exposes the public setLoadSimulation operation.
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
@@ -518,7 +626,7 @@ declare 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: string, reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    recordStep(stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number, sortIndex?: number): number;
     /**
      * Builds the configured payload or helper object.
      * Use this when all builder inputs are ready to be materialized.
@@ -602,6 +710,10 @@ export interface LoadStrikeReportingSink {
     SaveRealtimeMetrics?: (metrics: LoadStrikeMetricStats) => Promise<void> | void;
     saveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
     SaveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
+    saveIterationBatch?: (batch: LoadStrikeIterationObservationBatchV1) => Promise<void> | void;
+    SaveIterationBatch?: (batch: LoadStrikeIterationObservationBatchV1) => Promise<void> | void;
+    completeIterationObservationStream?: (completion: LoadStrikeIterationObservationStreamCompletionV1) => Promise<void> | void;
+    CompleteIterationObservationStream?: (completion: LoadStrikeIterationObservationStreamCompletionV1) => Promise<void> | void;
     stop?: () => Promise<void> | void;
     Stop?: () => Promise<void> | void;
     dispose?: () => Promise<void> | void;
@@ -633,11 +745,17 @@ export interface LoadStrikeWorkerPlugin {
 }
 export type ILoadStrikeWorkerPlugin = RequireAtLeastOne<LoadStrikeWorkerPlugin, "pluginName" | "PluginName">;
 export interface LoadStrikeRunnerOptions {
+    loadEngineContractVersion?: 1 | 2;
+    maxInFlight?: number;
     displayConsoleMetrics?: boolean;
     nodeType?: LoadStrikeNodeTypeInput;
     localDevClusterEnabled?: boolean;
     agentGroup?: string;
     agentsCount?: number;
+    /** Stable V2 identity required by remote agents. */
+    agentId?: string;
+    /** Exact stable V2 participant set required by remote coordinators. */
+    expectedAgentIds?: string[];
     targetScenarios?: string[];
     agentTargetScenarios?: string[];
     coordinatorTargetScenarios?: string[];
@@ -656,6 +774,13 @@ export interface LoadStrikeRunnerOptions {
     reportFileName?: string;
     reportFormats?: Array<LoadStrikeReportFormat>;
     reportingIntervalSeconds?: number;
+    iterationObservationFlushIntervalSeconds?: number;
+    maxIterationObservationBufferBytes?: number;
+    maxIterationObservationsPerBatch?: number;
+    maxIterationObservationBatchBytes?: number;
+    iterationObservationSinkQueueDepth?: number;
+    iterationObservationSinkParallelism?: number;
+    iterationObservationDrainTimeoutSeconds?: number;
     minimumLogLevel?: LoadStrikeLogLevel | string;
     loggerConfig?: () => LoadStrikeLogger;
     reportingSinks?: ILoadStrikeReportingSink[];
@@ -672,6 +797,17 @@ export interface LoadStrikeRunnerOptions {
     runArgs?: string[];
     agentExecutionToken?: string;
     agentCommandId?: string;
+    /** @internal Cluster-owned V2 shard index. */
+    clusterShardIndex?: number;
+    /** @internal Cluster-owned V2 shard count. */
+    clusterShardCount?: number;
+    /** @internal Shared by colocated logical agents in one process. */
+    loadEngineV2BudgetOverride?: LoadEngineV2ExecutionBudget;
+    /** @internal Remote V2 segment barrier/drain bridge. */
+    loadEngineV2SegmentLifecycleOverride?: {
+        beforeSegment: (scenarioIndex: number, simulationIndex: number) => Promise<void>;
+        afterSegment: (scenarioIndex: number, simulationIndex: number) => Promise<void>;
+    };
 }
 export interface LoadStrikeThresholdOptions {
     abortWhenErrorCount?: number;
@@ -860,7 +996,8 @@ export interface LoadStrikeScenarioContext {
 }
 interface InternalScenarioContext extends LoadStrikeScenarioContext {
     readonly scenarioName: string;
-    readonly recordStep: (stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number) => void;
+    readonly recordStep: (stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number) => number | void;
+    readonly recordStepObservation?: (observation: LoadStrikeIterationStepObservationV1) => void;
     readonly shouldStopScenario: () => boolean;
     readonly shouldStopTest: () => boolean;
     readonly invokeBeforeStep: (stepName: string) => Promise<void>;
@@ -1124,6 +1261,8 @@ export declare class ScenarioTrackingExtensions {
     static WithCrossPlatformTracking(scenario: LoadStrikeScenario, configuration: Record<string, unknown>): LoadStrikeScenario;
 }
 export interface LoadStrikeRunContext {
+    LoadEngineContractVersion?: 1 | 2;
+    MaxInFlight?: number;
     ConsoleMetricsEnabled?: boolean;
     LocalDevClusterEnabled?: boolean;
     ConfigPath?: string;
@@ -1131,6 +1270,8 @@ export interface LoadStrikeRunContext {
     InfraConfig?: Record<string, unknown>;
     AgentGroup?: string;
     AgentsCount?: number;
+    AgentId?: string;
+    ExpectedAgentIds?: string[];
     AgentTargetScenarios?: string[];
     ClusterId?: string;
     CoordinatorTargetScenarios?: string[];
@@ -1145,6 +1286,13 @@ export interface LoadStrikeRunContext {
     ReportFolderPath?: string;
     ReportFormats?: LoadStrikeReportFormat[];
     ReportingIntervalSeconds?: number;
+    IterationObservationFlushIntervalSeconds?: number;
+    MaxIterationObservationBufferBytes?: number;
+    MaxIterationObservationsPerBatch?: number;
+    MaxIterationObservationBatchBytes?: number;
+    IterationObservationSinkQueueDepth?: number;
+    IterationObservationSinkParallelism?: number;
+    IterationObservationDrainTimeoutSeconds?: number;
     ReportingSinks?: ILoadStrikeReportingSink[];
     SinkRetryCount?: number;
     SinkRetryBackoffMs?: number;
@@ -1162,6 +1310,10 @@ export interface LoadStrikeRunContext {
     GlobalCustomSettings?: Record<string, unknown>;
     AgentExecutionToken?: string;
     AgentCommandId?: string;
+    /** @internal */
+    ClusterShardIndex?: number;
+    /** @internal */
+    ClusterShardCount?: number;
 }
 export declare class LoadStrikeContext {
     private values;
@@ -1225,6 +1377,10 @@ export declare class LoadStrikeContext {
      * Use this when a local run or CI log should stream live throughput and latency updates.
      */
     DisplayConsoleMetrics(enable: boolean): LoadStrikeContext;
+    useLoadEngineV2(): LoadStrikeContext;
+    UseLoadEngineV2(): LoadStrikeContext;
+    withMaxInFlight(maxInFlight: number): LoadStrikeContext;
+    WithMaxInFlight(maxInFlight: number): LoadStrikeContext;
     /**
      * Toggles local development cluster mode.
      * Use this when you want to simulate coordinator and agent behavior on a single machine.
@@ -1265,6 +1421,14 @@ export declare class LoadStrikeContext {
      * Use this when only a subset of agents should pick up a particular workload.
      */
     WithAgentGroup(agentGroup: string): LoadStrikeContext;
+    /** Sets the stable identity required by a remote Load Engine V2 agent. */
+    withAgentId(agentId: string): LoadStrikeContext;
+    /** Sets the stable identity required by a remote Load Engine V2 agent. */
+    WithAgentId(agentId: string): LoadStrikeContext;
+    /** Sets the exact remote agent identities required by a Load Engine V2 coordinator. */
+    withExpectedAgentIds(...agentIds: string[]): LoadStrikeContext;
+    /** Sets the exact remote agent identities required by a Load Engine V2 coordinator. */
+    WithExpectedAgentIds(...agentIds: string[]): LoadStrikeContext;
     /**
      * Sets the requested agent count.
      * Use this when a coordinator should fan work out across a specific number of agents.
@@ -1611,6 +1775,8 @@ export declare class LoadStrikeScenario {
     private readonly weight;
     private readonly restartIterationOnFail;
     private readonly internalLicenseFeatures;
+    private readonly declaredStepNames;
+    private trafficMixV2Metadata?;
     private constructor();
     static create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
     static Create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
@@ -1728,6 +1894,12 @@ export declare class LoadStrikeScenario {
      */
     shouldRestartIterationOnFail(): boolean;
     __loadStrikeInternalLicenseFeatures(): string[];
+    /** Freezes the named step identities that may be reported by this scenario. */
+    withDeclaredSteps(...stepNames: string[]): LoadStrikeScenario;
+    /** Returns the immutable declared-step names in declaration order. */
+    getDeclaredSteps(): string[];
+    __loadStrikeSetTrafficMixV2Metadata(metadata: LoadEngineV2TrafficMixMetadata): LoadStrikeScenario;
+    __loadStrikeTrafficMixV2Metadata(): LoadEngineV2TrafficMixMetadata | undefined;
     __loadStrikeScenarioSourceAnalysis(): Record<string, unknown>;
     __loadStrikeWithInternalLicenseFeatures(...features: string[]): LoadStrikeScenario;
     invokeInit(context: LoadStrikeScenarioInitContext): Promise<void>;
@@ -1763,6 +1935,8 @@ export declare class LoadStrikeScenario {
      * Use this when load simulations should be set explicitly before the run starts.
      */
     WithLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
+    /** Freezes the named step identities that may be reported by this scenario. */
+    WithDeclaredSteps(...stepNames: string[]): LoadStrikeScenario;
     /**
      * Configures max fail count for this SDK object.
      * Use this when max fail count should be set explicitly before the run starts.
@@ -1853,6 +2027,7 @@ export declare class LoadStrikeRunner {
     private scenarios;
     private options;
     private contextConfigurators;
+    private readonly internalOptions;
     private constructor();
     /**
      * Creates a new instance of this public SDK type.
@@ -1889,6 +2064,8 @@ export declare class LoadStrikeRunner {
      * Use this when a local run or CI log should stream live throughput and latency updates.
      */
     static DisplayConsoleMetrics(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
+    static UseLoadEngineV2(context: LoadStrikeContext): LoadStrikeContext;
+    static WithMaxInFlight(context: LoadStrikeContext, maxInFlight: number): LoadStrikeContext;
     /**
      * Toggles local development cluster mode.
      * Use this when you want to simulate coordinator and agent behavior on a single machine.
@@ -1914,6 +2091,8 @@ export declare class LoadStrikeRunner {
      * Use this when only a subset of agents should pick up a particular workload.
      */
     static WithAgentGroup(context: LoadStrikeContext, agentGroup: string): LoadStrikeContext;
+    static WithAgentId(context: LoadStrikeContext, agentId: string): LoadStrikeContext;
+    static WithExpectedAgentIds(context: LoadStrikeContext, ...agentIds: string[]): LoadStrikeContext;
     /**
      * Sets the requested agent count.
      * Use this when a coordinator should fan work out across a specific number of agents.
@@ -2131,6 +2310,10 @@ export declare class LoadStrikeRunner {
      * Use this when sinks or dashboards should receive updates at a controlled interval.
      */
     WithReportingInterval(intervalSeconds: number): LoadStrikeRunner;
+    useLoadEngineV2(): LoadStrikeRunner;
+    UseLoadEngineV2(): LoadStrikeRunner;
+    withMaxInFlight(maxInFlight: number): LoadStrikeRunner;
+    WithMaxInFlight(maxInFlight: number): LoadStrikeRunner;
     withReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeRunner;
     WithReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeRunner;
     withPortalReporting(): LoadStrikeRunner;
@@ -2205,7 +2388,16 @@ declare function combineAbortSignals(...signals: AbortSignal[]): AbortSignal;
 declare function delayWithAbort(durationMs: number, signal: AbortSignal): Promise<void>;
 declare function createRuntimeRandom(): LoadStrikeRandom;
 declare function parseAliasDate(value: string | Date | null | undefined): Date | undefined;
-declare function expandTrafficMixScenarios(trafficMix: LoadStrikeTrafficMix): LoadStrikeScenario[];
+interface LoadEngineV2TrafficMixMetadata {
+    declarationIndex: number;
+    name: string;
+    laneIndex: number;
+    shareWeight: number;
+    shareWeights: number[];
+    seedId: string;
+    originalSimulations: Array<Record<string, unknown>>;
+}
+declare function expandTrafficMixScenarios(trafficMix: LoadStrikeTrafficMix, declarationIndex?: number): LoadStrikeScenario[];
 declare function attachScenarioStatsAliases(scenario: Omit<LoadStrikeScenarioStats, "FindStepStats" | "GetStepStats"> & Partial<Pick<LoadStrikeScenarioStats, "FindStepStats" | "GetStepStats">>): LoadStrikeScenarioStats;
 declare function attachNodeStatsAliases(stats: Omit<LoadStrikeNodeStats, "FindScenarioStats" | "GetScenarioStats"> & Partial<Pick<LoadStrikeNodeStats, "FindScenarioStats" | "GetScenarioStats">>): LoadStrikeNodeStats;
 declare function attachRunResultAliases(result: LoadStrikeRunResult): LoadStrikeRunResult;
@@ -2248,9 +2440,14 @@ declare function buildEmptyNodeStats(args: {
     nodeInfo: LoadStrikeNodeInfo;
     testInfo: LoadStrikeTestInfo;
 }): LoadStrikeNodeStats;
+declare function planRuntimeClusterAssignments(scenarios: LoadStrikeScenario[], agentsCount: number, targetScenarios: string[], agentTargetScenarios: string[], globalV2?: boolean, coordinatorTargetScenarios?: string[]): string[][];
+declare function buildRuntimeLoadEngineV2Plan(scenarios: LoadStrikeScenario[], options: LoadStrikeRunnerOptions, testInfo: LoadStrikeTestInfo, expectedAgentIds: string[]): LoadEngineV2PlanInput;
+declare function validateLoadEngineV2ScenarioFeatures(scenarios: LoadStrikeScenario[]): void;
+declare function buildRuntimeLoadEngineV2HistogramArtifact(result: LoadStrikeNodeStats, scenarioDeclarations?: readonly LoadStrikeScenario[]): Buffer;
 declare function toDetailedRunResultFromNodeStats(result: LoadStrikeNodeStats, startedUtc: string, sinkErrors: LoadStrikeSinkError[], policyErrors?: LoadStrikeRuntimePolicyError[]): LoadStrikeRunResult;
-declare function clusterNodeResultToNodeStats(result: ClusterNodeResult, testInfo: LoadStrikeTestInfo, fallbackNodeInfo: LoadStrikeNodeInfo): LoadStrikeNodeStats;
-declare function aggregateNodeStats(testInfo: LoadStrikeTestInfo, coordinatorNodeInfo: LoadStrikeNodeInfo, nodes: LoadStrikeNodeStats[]): LoadStrikeNodeStats;
+declare function clusterNodeResultToNodeStats(result: ClusterNodeResult, testInfo: LoadStrikeTestInfo, fallbackNodeInfo: LoadStrikeNodeInfo, requireHistogramArtifact?: boolean): LoadStrikeNodeStats;
+declare function aggregateNodeStats(testInfo: LoadStrikeTestInfo, coordinatorNodeInfo: LoadStrikeNodeInfo, nodes: LoadStrikeNodeStats[], requireHistograms?: boolean): LoadStrikeNodeStats;
+declare function aggregateMeasurementStats(measurements: LoadStrikeMeasurementStats[], allRequestCount: number, durationMs: number, requireHistograms?: boolean): LoadStrikeMeasurementStats;
 declare function buildMeasurementPlaceholder(count: number, allCount: number, durationMs: number): LoadStrikeMeasurementStats;
 declare function executeTrackedScenarioInvocation(tracking: Record<string, unknown>, context: InternalScenarioContext, originalRun: () => Promise<LoadStrikeStepReply>, operation: "WarmUp" | "Bombing"): Promise<LoadStrikeStepReply>;
 interface ManagedTrackingOutcome {
@@ -2329,6 +2526,7 @@ declare function normalizeRuntimeTrackingPayload(payload: TrackingPayload | null
 declare function readRuntimeTrackingId(payload: TrackingPayload, selector: string): string | null;
 declare function runtimeParseBodyAsObject(body: unknown): Record<string, unknown> | null;
 declare function setRuntimeJsonPathValue(body: unknown, path: string, value: string): unknown;
+declare function pickTrackingValue(source: Record<string, unknown>, ...keys: string[]): unknown;
 declare function pickOptionalTrackingSelectorString(source: Record<string, unknown>, key: string, altKey: string): string | undefined;
 declare function pickTrackingNumber(source: Record<string, unknown>, keys: string[], fallback: number): number;
 declare function toTrackingStringMap(value: unknown): Record<string, string>;
@@ -2377,6 +2575,8 @@ declare function resolveSinkStart(sink: LoadStrikeReportingSink): ((session: Loa
 declare function resolveSinkSaveRealtimeStats(sink: LoadStrikeReportingSink): ((scenarioStats: LoadStrikeScenarioStats[]) => Promise<void> | void) | undefined;
 declare function resolveSinkSaveRealtimeMetrics(sink: LoadStrikeReportingSink): ((metrics: LoadStrikeMetricStats) => Promise<void> | void) | undefined;
 declare function resolveSinkSaveRunResult(sink: LoadStrikeReportingSink): ((result: LoadStrikeRunResult) => Promise<void> | void) | undefined;
+declare function resolveSinkSaveIterationBatch(sink: LoadStrikeReportingSink): ((batch: LoadStrikeIterationObservationBatchV1) => Promise<void> | void) | undefined;
+declare function resolveSinkCompleteIterationObservationStream(sink: LoadStrikeReportingSink): ((completion: LoadStrikeIterationObservationStreamCompletionV1) => Promise<void> | void) | undefined;
 declare function resolveSinkStop(sink: LoadStrikeReportingSink): (() => Promise<void> | void) | undefined;
 declare function resolveSinkDispose(sink: LoadStrikeReportingSink): (() => Promise<void> | void) | undefined;
 interface CrossPlatformFailedResponseRow {
@@ -2427,13 +2627,17 @@ export declare const __loadstrikeTestExports: {
     ManagedScenarioTrackingRuntime: typeof ManagedScenarioTrackingRuntime;
     ScenarioStatsAccumulator: typeof ScenarioStatsAccumulator;
     StepStatsAccumulator: typeof StepStatsAccumulator;
+    planRuntimeClusterAssignments: typeof planRuntimeClusterAssignments;
     TrackingFieldSelector: typeof TrackingFieldSelector;
     addCorrelationRow: typeof addCorrelationRow;
     addFailedResponseRow: typeof addFailedResponseRow;
     aggregateNodeStats: typeof aggregateNodeStats;
+    aggregateMeasurementStats: typeof aggregateMeasurementStats;
     asRecord: typeof asRecord;
     assertNoDisableLicenseEnforcementOption: typeof assertNoDisableLicenseEnforcementOption;
     buildEmptyNodeStats: typeof buildEmptyNodeStats;
+    buildRuntimeLoadEngineV2HistogramArtifact: typeof buildRuntimeLoadEngineV2HistogramArtifact;
+    buildRuntimeLoadEngineV2Plan: typeof buildRuntimeLoadEngineV2Plan;
     buildGroupedCorrelationRows: typeof buildGroupedCorrelationRows;
     buildMeasurementPlaceholder: typeof buildMeasurementPlaceholder;
     buildRichHtmlReport: typeof buildRichHtmlReport;
@@ -2488,6 +2692,7 @@ export declare const __loadstrikeTestExports: {
     parseStrictBooleanToken: typeof parseStrictBooleanToken;
     percentile: typeof percentile;
     pickOptionalTrackingSelectorString: typeof pickOptionalTrackingSelectorString;
+    pickTrackingValue: typeof pickTrackingValue;
     pickTrackingNumber: typeof pickTrackingNumber;
     produceOrConsumeTrackingPayload: typeof produceOrConsumeTrackingPayload;
     readConfiguredSinkName: typeof readConfiguredSinkName;
@@ -2506,7 +2711,9 @@ export declare const __loadstrikeTestExports: {
     resolveSinkName: typeof resolveSinkName;
     resolveSinkSaveRealtimeMetrics: typeof resolveSinkSaveRealtimeMetrics;
     resolveSinkSaveRealtimeStats: typeof resolveSinkSaveRealtimeStats;
+    resolveSinkSaveIterationBatch: typeof resolveSinkSaveIterationBatch;
     resolveSinkSaveRunResult: typeof resolveSinkSaveRunResult;
+    resolveSinkCompleteIterationObservationStream: typeof resolveSinkCompleteIterationObservationStream;
     resolveSinkStart: typeof resolveSinkStart;
     resolveSinkStop: typeof resolveSinkStop;
     resolveWorkerPlugins: typeof resolveWorkerPlugins;
@@ -2527,6 +2734,7 @@ export declare const __loadstrikeTestExports: {
     tryParseNodeTypeToken: typeof tryParseNodeTypeToken;
     tryReadConfigValue: typeof tryReadConfigValue;
     validateNamedReportingSinks: typeof validateNamedReportingSinks;
+    validateLoadEngineV2ScenarioFeatures: typeof validateLoadEngineV2ScenarioFeatures;
     validateRegisteredScenarios: typeof validateRegisteredScenarios;
     validateRuntimeRedisCorrelationStoreConfiguration: typeof validateRuntimeRedisCorrelationStoreConfiguration;
     validateRuntimeTrackingConfiguration: typeof validateRuntimeTrackingConfiguration;

package/dist/types/sink-retry-policy.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_SINK_RETRY_COUNT = 3;
+export declare const DEFAULT_SINK_RETRY_BACKOFF_MS = 250;
+export declare const MAXIMUM_SINK_RETRY_COUNT = 100;
+export declare const MAXIMUM_TIMER_DELAY_MS = 2147483647;
+export declare function normalizeSinkRetryCount(value: number | undefined): number;
+export declare function normalizeSinkRetryBackoffMs(value: number | undefined): number;
+export declare function sinkRetryDelayMs(baseDelayMs: number, retryNumber: number): number;
+export declare function waitForSinkRetryDelay(delayMs: number): Promise<void>;
+export declare function cooperativeSinkRetryYield(): Promise<void>;