@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.32601

package/dist/types/contracts.d.ts

@@ -259,6 +259,7 @@ export interface LoadStrikeWebSocketEndpointOptions {
     ConnectTimeoutSeconds?: number;
     CloseTimeoutSeconds?: number;
     ConnectionMetadata?: Record<string, string>;
+    NativeClient?: Record<string, unknown>;
 }
 export interface LoadStrikeReportingSinkSpec {
     Kind: string;

package/dist/types/index.d.ts

@@ -11,4 +11,4 @@ export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, Correlati
 export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, GrpcMethodTypes, GrpcNativeClientOptions, GrpcStatusMapper, ProtocolMetricSnapshot, WebSocketEndpointDefinition, WebSocketExpectedMessage, WebSocketMessageSpec, WebSocketNativeClientOptions, WebSocketReconnectPolicy, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
 export type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, SqsEndpointOptions, PushDiffusionEndpointOptions, GrpcEndpointOptions, WebSocketEndpointOptions, GrpcEndpointDefinition as GrpcEndpointDefinitionShape, WebSocketEndpointDefinition as WebSocketEndpointDefinitionShape, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, DogStatsDReportingSink, CloudWatchReportingSink, DynatraceReportingSink, ElasticsearchReportingSink, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, GenericWebhookReportingSink, InfluxDbReportingSink, InfluxDbReportingSinkOptions, JsonlFileReportingSink, KafkaReportingSink, NetdataStatsDReportingSink, NewRelicReportingSink, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, OpenSearchReportingSink, PortalReportingSink, PrometheusRemoteWriteReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, StatsDReportingSink, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
-export type { DatadogSinkOptions, ExpandedSinkOptionsInput, GrafanaLokiSinkOptions, InfluxDbSinkOptions, JsonlFileReportingSinkOptionsInput, KafkaReportingSinkOptionsInput, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, SplunkSinkOptions, StatsDReportingSinkOptionsInput, TimescaleDbSinkOptions } from "./sinks.js";
+export type { CloudWatchReportingSinkOptionsInput, DatadogSinkOptions, DynatraceReportingSinkOptionsInput, ElasticsearchReportingSinkOptionsInput, ExpandedSinkOptionsInput, GrafanaLokiSinkOptions, InfluxDbSinkOptions, JsonlFileReportingSinkOptionsInput, KafkaReportingSinkOptionsInput, NewRelicReportingSinkOptionsInput, OpenSearchReportingSinkOptionsInput, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, PrometheusRemoteWriteReportingSinkOptionsInput, SplunkSinkOptions, StatsDReportingSinkOptionsInput, TimescaleDbSinkOptions } from "./sinks.js";

package/dist/types/internal/prometheus-remote-write.d.ts

@@ -0,0 +1,2 @@
+import { type EncodedProtocolPayload, type ProtocolMetricPoint } from "./vendor-metric-payloads.js";
+export declare function encodePrometheusRemoteWrite(points: readonly ProtocolMetricPoint[], staticLabels?: Readonly<Record<string, string>>): EncodedProtocolPayload;

package/dist/types/internal/reporting-sink-http-error.d.ts

@@ -0,0 +1,6 @@
+export declare class ReportingSinkHttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly requestId: string;
+    constructor(sinkName: string, status: number, statusText: string, requestId: string);
+}

package/dist/types/internal/vendor-metric-payloads.d.ts

@@ -0,0 +1,48 @@
+export type ProtocolMetricKind = "count" | "gauge";
+export interface ProtocolMetricPoint {
+    metricName: string;
+    metricKind: ProtocolMetricKind;
+    occurredUtc: Date;
+    value: number;
+    unitOfMeasure?: string;
+    scenario: string;
+    status: string;
+    runId?: string;
+    intervalMs?: number | bigint;
+}
+export interface EncodedProtocolPayload {
+    contentType: string;
+    body: Uint8Array;
+}
+export interface CloudWatchDimension {
+    Name: string;
+    Value: string;
+}
+export interface CloudWatchMetricDatum {
+    MetricName: string;
+    Dimensions: CloudWatchDimension[];
+    Value: number;
+    Unit?: string;
+    Timestamp: Date;
+}
+export interface CloudWatchPutMetricData {
+    Namespace: string;
+    MetricData: CloudWatchMetricDatum[];
+}
+type ProtocolSink = "prometheus" | "cloudwatch" | "dynatrace" | "newrelic";
+export interface PreparedProtocolMetricPoint {
+    metricName: string;
+    metricKind: ProtocolMetricKind;
+    occurredUtc: Date;
+    value: number;
+    unitOfMeasure?: string;
+    intervalMs?: bigint;
+    attributes: Array<readonly [string, string]>;
+}
+export declare function createCloudWatchMetricData(namespace: string, points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>): CloudWatchPutMetricData;
+export declare function encodeDynatraceMetrics(points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>): EncodedProtocolPayload;
+export declare function encodeDynatraceMetricBatches(points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>, maximumBodyBytesExclusive?: number): EncodedProtocolPayload[];
+export declare function encodeNewRelicMetricBatch(points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>): EncodedProtocolPayload;
+export declare function encodeNewRelicMetricBatches(points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>, maximumBodyBytesExclusive?: number): EncodedProtocolPayload[];
+export declare function prepareProtocolMetricPoints(sink: ProtocolSink, points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>): PreparedProtocolMetricPoint[];
+export {};

package/dist/types/local-report-input.d.ts

@@ -0,0 +1,6 @@
+import type { ReportHistoryProjection } from "./report-history.js";
+export interface LocalReportInput {
+    history: ReportHistoryProjection;
+}
+export declare function emptyLocalReportInput(): LocalReportInput;
+export declare function distributedLocalReportInput(): LocalReportInput;

package/dist/types/local.d.ts

@@ -43,9 +43,6 @@ export declare class LoadStrikeLocalClient {
     private getLicensingRequest;
 }
 declare function sanitizeRequest(request: LoadStrikeRunRequest): LoadStrikeRunRequest;
-declare function normalizeLicensingApiBaseUrl(value: string | undefined): string;
-declare function resolveLicensingApiBaseUrl(): string;
-declare function setDevelopmentLicensingApiBaseUrlOverride(value: string | undefined): void;
 declare function normalizeTimeoutMs(value: number | undefined): number;
 declare function collectRequestedFeatures(request: LoadStrikeRunRequest): string[];
 declare function mapEnvironmentClassification(value: string): number;
@@ -146,8 +143,6 @@ export declare const __loadstrikeTestExports: {
     mapEnvironmentClassification: typeof mapEnvironmentClassification;
     mapEndpointSpec: typeof mapEndpointSpec;
     normalizeEndpointPayloadValue: typeof normalizeEndpointPayloadValue;
-    normalizeLicensingApiBaseUrl: typeof normalizeLicensingApiBaseUrl;
-    resolveLicensingApiBaseUrl: typeof resolveLicensingApiBaseUrl;
     normalizeNodeType: typeof normalizeNodeType;
     normalizePayload: typeof normalizePayload;
     normalizeStringArray: typeof normalizeStringArray;
@@ -166,7 +161,6 @@ export declare const __loadstrikeTestExports: {
     sanitizeLooseJson: typeof sanitizeLooseJson;
     sanitizeRequest: typeof sanitizeRequest;
     setJsonPathValue: typeof setJsonPathValue;
-    setDevelopmentLicensingApiBaseUrlOverride: typeof setDevelopmentLicensingApiBaseUrlOverride;
     sleep: typeof sleep;
     stringOrDefault: typeof stringOrDefault;
     toBoolean: typeof toBoolean;

package/dist/types/report-history.d.ts

@@ -0,0 +1,124 @@
+export declare const REPORT_HISTORY_MAX_POINTS = 2048;
+export declare const REPORT_HISTORY_MAX_SCALAR_VALUES = 262144;
+export type ReportHistoryReasonCategory = "capture_failure" | "budget_pressure" | "distributed_temporal_aggregation_unavailable";
+export interface ReportHistoryMeasurement {
+    count: number;
+    bytes: number;
+    approximate?: boolean;
+    percent50Ms?: number;
+    percent75Ms?: number;
+    percent95Ms?: number;
+    percent99Ms?: number;
+}
+export interface ReportHistoryScenario {
+    scenarioName: string;
+    sortIndex?: number;
+    all?: ReportHistoryMeasurement;
+    ok?: ReportHistoryMeasurement;
+    failed?: ReportHistoryMeasurement;
+}
+export interface ReportHistoryPoint {
+    elapsedSeconds: number;
+    terminal: boolean;
+    scenarios: ReportHistoryScenario[];
+}
+export interface AvailableReportHistoryProjection {
+    status: "available";
+    points: ReportHistoryPoint[];
+}
+export interface UnavailableReportHistoryProjection {
+    status: "unavailable";
+    reasonCategory: ReportHistoryReasonCategory;
+    points: [];
+}
+export type ReportHistoryProjection = AvailableReportHistoryProjection | UnavailableReportHistoryProjection;
+export interface ReportHistoryRateSeries {
+    scenarioName: string;
+    values: Array<number | null>;
+}
+export interface ReportHistoryCollectorOptions {
+    scenarioCount: number;
+    maxPoints?: number;
+    nowNs?: () => bigint;
+    onCaptureError?: (error: unknown) => void;
+}
+/**
+ * Bounded report-only cumulative telemetry. This type is intentionally not
+ * exported from the package entry point and never participates in public run,
+ * sink, observation, or cluster payloads.
+ */
+export declare class ReportHistoryCollector {
+    readonly pointLimit: number;
+    private readonly nowNs;
+    private readonly onCaptureError?;
+    private points;
+    private startNs;
+    private terminalCaptured;
+    private reasonCategory;
+    constructor(options: ReportHistoryCollectorOptions);
+    get available(): boolean;
+    start(startNs?: bigint): void;
+    capture(snapshotFactory: () => readonly ReportHistoryScenario[]): boolean;
+    finalize(snapshotFactory: () => readonly ReportHistoryScenario[]): boolean;
+    disable(reasonCategory: ReportHistoryReasonCategory): void;
+    toProjection(): ReportHistoryProjection;
+    private captureSafely;
+    private compact;
+}
+export interface ReportHistoryWorkerOptions {
+    collector: ReportHistoryCollector;
+    cadenceSeconds: number;
+    snapshotFactory: () => readonly ReportHistoryScenario[];
+    nowNs?: () => bigint;
+    onFailure?: (category: ReportHistoryReasonCategory, exceptionClasses: string) => void;
+}
+interface ReportHistoryLifecycleWorker {
+    start(): void;
+    stopAndFinalize(): void;
+    stopWithoutFinalizing(): void;
+}
+/**
+ * Coordinates one private history worker across every local scenario. The
+ * first measured phase establishes the history clock, and the last scenario
+ * leaving execution records the terminal point before scenario cleanup.
+ */
+export declare class ReportHistoryLifecycleCoordinator {
+    private readonly worker;
+    private readonly scenarioCount;
+    private readonly terminalBoundary;
+    private releaseTerminalBoundary;
+    private measuredLoadStarted;
+    private endedScenarios;
+    private completed;
+    private terminalBoundaryReleased;
+    constructor(worker: ReportHistoryLifecycleWorker & {
+        scenarioCount?: number;
+    });
+    scenarioBombingStarted(): void;
+    scenarioExecutionEnded(): Promise<void>;
+    stopWithoutFinalizing(): void;
+    private releaseBoundary;
+}
+/**
+ * Owns the report timer. Every cadence calculation, timeout callback, snapshot,
+ * and projection is exception-bounded so report history can never fail a run.
+ */
+export declare class ReportHistoryWorker {
+    private readonly options;
+    private readonly nowNs;
+    private timer;
+    private cadenceNs;
+    private nextDeadlineNs;
+    private running;
+    constructor(options: ReportHistoryWorkerOptions);
+    get started(): boolean;
+    start(): void;
+    stopAndFinalize(): void;
+    stopWithoutFinalizing(): void;
+    private scheduleNext;
+    private onTimer;
+    private fail;
+}
+export declare function sanitizedExceptionClassChain(error: unknown): string;
+export declare function deriveScenarioRates(points: readonly ReportHistoryPoint[]): ReportHistoryRateSeries[];
+export {};

package/dist/types/reporting-containment.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNoUnsupportedReportingInfraConfig(infraConfig: unknown, sinks?: readonly unknown[]): void;
+export declare function assertNoUnsupportedReportingSinkGraph(sinks: readonly unknown[]): void;

package/dist/types/reporting-svg.d.ts

@@ -0,0 +1,2 @@
+export declare const REPORT_SVG_CSS: string;
+export declare const REPORT_SVG_SCRIPT: string;

package/dist/types/reporting.d.ts

@@ -1,3 +1,4 @@
+import { type LocalReportInput } from "./local-report-input.js";
 type ReportRecord = Record<string, any>;
 type ReportTab = [string, string, string];
 declare function buildUngroupedCorrelationChartPayload(rows: ReportRecord[]): ReportRecord;
@@ -14,7 +15,7 @@ declare function buildDotnetMetricHtml(nodeStats: ReportRecord): string;
 declare function buildDotnetGroupedCorrelationSummaryHtml(rows: ReportRecord[], groupedChartKey: string): string;
 declare function buildDotnetUngroupedCorrelationSummaryHtml(rows: ReportRecord[], groupedChartKey: string): string;
 declare function buildDotnetPluginHints(plugin: ReportRecord): string;
-declare function buildDotnetHtmlTabs(nodeStats: ReportRecord): ReportTab[];
+declare function buildDotnetHtmlTabs(nodeStats: ReportRecord, localReportInput?: LocalReportInput): ReportTab[];
 /**
  * Exposes the build dotnet txt report operation. Use this when interacting with the SDK through this surface.
  */
@@ -28,9 +29,11 @@ export declare function buildDotnetCsvReport(nodeStats: ReportRecord): string;
  */
 export declare function buildDotnetMarkdownReport(nodeStats: ReportRecord): string;
 /**
- * Exposes the build dotnet html report operation. Use this when interacting with the SDK through this surface.
+ * Builds the portable single-file HTML report. The optional second argument is
+ * an internal report-only carrier used by the native runner and is never added
+ * to public result, sink, observation, or cluster payloads.
  */
-export declare function buildDotnetHtmlReport(nodeStats: ReportRecord): string;
+export declare function buildDotnetHtmlReport(nodeStats: ReportRecord, localReportInput?: LocalReportInput): string;
 export declare const __loadstrikeTestExports: {
     buildDotnetFailedResponseContent: typeof buildDotnetFailedResponseContent;
     buildDotnetFailedResponseHtml: typeof buildDotnetFailedResponseHtml;

package/dist/types/runtime.d.ts

@@ -1,6 +1,7 @@
 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 { type ReportHistoryMeasurement, type ReportHistoryScenario } from "./report-history.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;
@@ -570,6 +571,17 @@ declare class MeasurementAccumulator {
      */
     build(allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
     buildCombined(other: MeasurementAccumulator, allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
+    /**
+     * Projects only the cumulative fields used by the private HTML-report
+     * history. Legacy distributions deliberately omit latency so this cadence
+     * path never scans their retained per-request arrays.
+     */
+    buildReportHistoryMeasurement(): ReportHistoryMeasurement;
+    /**
+     * Combines only bounded native latency state plus exact counters. It does
+     * not materialize status rows or any public measurement DTO.
+     */
+    buildCombinedReportHistoryMeasurement(other: MeasurementAccumulator): ReportHistoryMeasurement;
     private histogramSnapshot;
 }
 declare class StepStatsAccumulator {
@@ -627,6 +639,11 @@ declare class ScenarioStatsAccumulator {
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
      */
     recordStep(stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number, sortIndex?: number): number;
+    /**
+     * Captures the bounded, private history view without building scenario
+     * steps, status rows, plugins, aliases, or any other public result shape.
+     */
+    buildReportHistorySnapshot(): ReportHistoryScenario;
     /**
      * Builds the configured payload or helper object.
      * Use this when all builder inputs are ready to be materialized.
@@ -2384,6 +2401,8 @@ export declare class LoadStrikeRunner {
     private collectPluginData;
 }
 declare function hasPluginRows(value: LoadStrikePluginData): boolean;
+declare function boundedReportingIntervalMs(seconds: number): number;
+declare function resolvedReportHistoryCadenceSeconds(seconds: number): number;
 declare function combineAbortSignals(...signals: AbortSignal[]): AbortSignal;
 declare function delayWithAbort(durationMs: number, signal: AbortSignal): Promise<void>;
 declare function createRuntimeRandom(): LoadStrikeRandom;
@@ -2434,6 +2453,7 @@ declare function normalizeThresholdScope(value: string): "scenario" | "step" | "
 declare function buildThresholdCheckExpression(scope: "scenario" | "step" | "metric", stepName: string, field: string): string;
 declare function detailedToNodeStats(result: LoadStrikeRunResult, metricStats?: LoadStrikeMetricStats): LoadStrikeNodeStats;
 declare function resolveClusterExecutionMode(options: LoadStrikeRunnerOptions): "single" | "local-coordinator" | "nats-coordinator" | "nats-agent";
+declare function isDistributedReportHistoryExecution(clusterMode: ReturnType<typeof resolveClusterExecutionMode>, options: Pick<LoadStrikeRunnerOptions, "clusterShardCount" | "loadEngineV2SegmentLifecycleOverride">): boolean;
 declare function buildEmptyNodeStats(args: {
     startedUtc: string;
     completedUtc: string;
@@ -2494,6 +2514,7 @@ declare class ManagedScenarioTrackingRuntime {
     dispose(): Promise<void>;
     private executeSourceOnly;
     private observeExistingTraffic;
+    private interruptEndpointAdapters;
     private consumeSourceLoop;
     private consumeDestinationLoop;
     private runTimeoutSweepLoop;
@@ -2644,6 +2665,8 @@ export declare const __loadstrikeTestExports: {
     buildThresholdCheckExpression: typeof buildThresholdCheckExpression;
     buildTrackingLeaseKey: typeof buildTrackingLeaseKey;
     buildTrackingRunNamespace: typeof buildTrackingRunNamespace;
+    boundedReportingIntervalMs: typeof boundedReportingIntervalMs;
+    resolvedReportHistoryCadenceSeconds: typeof resolvedReportHistoryCadenceSeconds;
     clusterNodeResultToNodeStats: typeof clusterNodeResultToNodeStats;
     combineAbortSignals: typeof combineAbortSignals;
     computeScenarioRequestCount: typeof computeScenarioRequestCount;
@@ -2663,6 +2686,7 @@ export declare const __loadstrikeTestExports: {
     formatUtcReportTimestamp: typeof formatUtcReportTimestamp;
     hasPluginRows: typeof hasPluginRows;
     inferRuntimeLegacyHttpResponseSource: typeof inferRuntimeLegacyHttpResponseSource;
+    isDistributedReportHistoryExecution: typeof isDistributedReportHistoryExecution;
     isComparisonFailed: typeof isComparisonFailed;
     loadJsonObject: typeof loadJsonObject;
     logLevelOrder: typeof logLevelOrder;

package/dist/types/sinks.d.ts

@@ -1,5 +1,8 @@
 import type { ILoadStrikeReportingSink, LoadStrikeBaseContext, LoadStrikeMetricStats, LoadStrikeMetricValue, LoadStrikeNodeInfo, LoadStrikePluginData, LoadStrikeReportingSink, LoadStrikeRunResult, LoadStrikeScenarioStats, LoadStrikeSessionStartInfo, LoadStrikeSinkError, LoadStrikeStepStats, LoadStrikeTestInfo, LoadStrikeThresholdResult } from "./runtime.js";
 import { type LoadStrikeIterationObservationBatchV1, type LoadStrikeIterationObservationStreamCompletionV1 } from "./iteration-observations.js";
+import { type ProtocolMetricPoint } from "./internal/vendor-metric-payloads.js";
+declare const SEND_DIRECT_VENDOR_PROTOCOL_POINTS: unique symbol;
+declare const CLONE_DIRECT_VENDOR_FOR_RUN: unique symbol;
 interface LoadStrikeNodeStats {
     startedUtc: string;
     completedUtc: string;
@@ -489,7 +492,7 @@ export declare class PortalReportingSink implements LoadStrikeReportingSink {
     private persistObservationPayload;
     private currentRunToken;
 }
-export declare function cloneReportingSinkForRun(sink: LoadStrikeReportingSink): LoadStrikeReportingSink;
+export declare function cloneReportingSinkForRun(sink: LoadStrikeReportingSink, infraConfig?: Record<string, unknown>, environment?: Readonly<Record<string, string | undefined>>): LoadStrikeReportingSink;
 export declare class InfluxDbReportingSink implements LoadStrikeReportingSink {
     readonly sinkName = "influxdb";
     readonly SinkName = "influxdb";
@@ -680,6 +683,8 @@ export declare class OtelCollectorReportingSink implements LoadStrikeReportingSi
     private persistEvents;
 }
 export interface ExpandedSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     BaseUrl?: string;
     baseUrl?: string;
     EndpointPath?: string;
@@ -695,6 +700,20 @@ export interface ExpandedSinkOptionsInput {
     FetchImpl?: SinkFetch;
     fetchImpl?: SinkFetch;
 }
+export interface ElasticsearchReportingSinkOptionsInput extends ExpandedSinkOptionsInput {
+    IndexName?: string;
+    indexName?: string;
+    ApiKey?: string;
+    apiKey?: string;
+}
+export interface OpenSearchReportingSinkOptionsInput extends ExpandedSinkOptionsInput {
+    IndexName?: string;
+    indexName?: string;
+    Username?: string;
+    username?: string;
+    Password?: string;
+    password?: string;
+}
 declare abstract class ExpandedEventReportingSink implements LoadStrikeReportingSink {
     readonly SinkName: string;
     readonly sinkName: string;
@@ -729,38 +748,128 @@ declare abstract class ExpandedEventReportingSink implements LoadStrikeReporting
 declare class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
     private readonly fetchImpl;
     private readonly baseUrl;
+    private readonly exactUrl;
     private readonly endpointPath;
     private readonly headers;
     private readonly staticTags;
     private readonly timeoutMs;
-    constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options?: ExpandedSinkOptionsInput);
+    constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options?: ExpandedSinkOptionsInput, bindingOptions?: ExpandedSinkOptionsInput);
     init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
     protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
     saveIterationBatch(batch: LoadStrikeIterationObservationBatchV1): Promise<void>;
     completeIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
     protected persistCanonicalGzipPayload(payload: unknown): Promise<void>;
+    private requestUrl;
 }
-export declare class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+interface DirectVendorMetricSinkOptionsInput extends ExpandedSinkOptionsInput {
+    RunId?: string;
+    runId?: string;
+    ReportingIntervalSeconds?: number;
+    reportingIntervalSeconds?: number;
 }
-export declare class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+export interface PrometheusRemoteWriteReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    BearerToken?: string;
+    bearerToken?: string;
+}
+export interface CloudWatchReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    Namespace?: string;
+    namespace?: string;
+    Region?: string;
+    region?: string;
+    AccessKeyId?: string;
+    accessKeyId?: string;
+    SecretAccessKey?: string;
+    secretAccessKey?: string;
+    SessionToken?: string;
+    sessionToken?: string;
+    EndpointUrl?: string;
+    endpointUrl?: string;
+}
+export interface DynatraceReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    ApiToken?: string;
+    apiToken?: string;
 }
-export declare class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+export interface NewRelicReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    LicenseKey?: string;
+    licenseKey?: string;
+    ApiKey?: string;
+    apiKey?: string;
+}
+declare abstract class DirectVendorMetricReportingSink extends ExpandedEventReportingSink {
     readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+    protected readonly fetchImpl: SinkFetch;
+    protected readonly baseUrl: string;
+    protected readonly endpointPath: string;
+    protected readonly headers: Record<string, string>;
+    protected readonly staticTags: Record<string, string>;
+    protected readonly timeoutMs: number;
+    private readonly configuredRunId;
+    private readonly requireBaseUrl;
+    private configuredFirstIntervalMs;
+    private runStartedUtc;
+    private previousCounts;
+    private previousCountTimes;
+    private stateGeneration;
+    private stateQueue;
+    protected constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options: DirectVendorMetricSinkOptionsInput, requireBaseUrl?: boolean);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    start(session: LoadStrikeSessionStartInfo): void;
+    stop(): void;
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+    protected abstract [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+    abstract [CLONE_DIRECT_VENDOR_FOR_RUN](): DirectVendorMetricReportingSink;
+    private prepareStatefulPoints;
+}
+export declare class PrometheusRemoteWriteReportingSink extends DirectVendorMetricReportingSink {
+    private readonly bearerToken;
+    private readonly cloneOptions;
+    constructor(options?: PrometheusRemoteWriteReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): PrometheusRemoteWriteReportingSink;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class CloudWatchReportingSink extends DirectVendorMetricReportingSink {
+    private readonly namespace;
+    private readonly region;
+    private readonly accessKeyId;
+    private readonly secretAccessKey;
+    private readonly sessionToken;
+    private readonly cloneOptions;
+    private cloudWatchClient;
+    constructor(options?: CloudWatchReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): CloudWatchReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    Dispose(): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class DynatraceReportingSink extends DirectVendorMetricReportingSink {
+    private readonly apiToken;
+    private readonly cloneOptions;
+    constructor(options?: DynatraceReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): DynatraceReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class NewRelicReportingSink extends DirectVendorMetricReportingSink {
+    private readonly licenseKey;
+    private readonly cloneOptions;
+    constructor(options?: NewRelicReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): NewRelicReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
 }
 export declare class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
-    constructor(options?: ExpandedSinkOptionsInput);
+    private readonly indexName;
+    private readonly usesIndexName;
+    constructor(options?: ElasticsearchReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
 }
 export declare class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
-    constructor(options?: ExpandedSinkOptionsInput);
-}
-export declare class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+    private readonly indexName;
+    private readonly usesIndexName;
+    private readonly username;
+    private readonly password;
+    constructor(options?: OpenSearchReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
 }
 export declare class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
     protected preservesRawIterationObservations: boolean;
@@ -771,6 +880,8 @@ export declare class GenericWebhookReportingSink extends ExpandedHttpJsonReporti
     CompleteIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
 }
 export interface KafkaReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     Topic?: string;
     topic?: string;
     BootstrapServers?: string;
@@ -782,15 +893,19 @@ export interface KafkaReportingSinkOptionsInput {
 }
 export declare class KafkaReportingSink extends ExpandedEventReportingSink {
     private readonly topic;
+    private readonly bootstrapServers;
     private readonly staticTags;
     private readonly publishAsync?;
     constructor(options?: KafkaReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
     saveIterationBatch(batch: LoadStrikeIterationObservationBatchV1): Promise<void>;
     completeIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
     protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
     private publishCanonicalValue;
 }
 export interface StatsDReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     Prefix?: string;
     prefix?: string;
     Host?: string;
@@ -827,6 +942,8 @@ export declare class NetdataStatsDReportingSink extends StatsDReportingSinkBase
     constructor(options?: StatsDReportingSinkOptionsInput);
 }
 export interface JsonlFileReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     FilePath?: string;
     filePath?: string;
     StaticTags?: Record<string, string>;
@@ -886,7 +1003,7 @@ declare function cloneSessionStartInfo(session: LoadStrikeSessionStartInfo): Loa
 declare function cloneMetricStats(metrics: LoadStrikeMetricStats): LoadStrikeMetricStats;
 declare function cloneScenarioStats(value: LoadStrikeScenarioStats): LoadStrikeScenarioStats;
 declare function cloneNodeStats(result: LoadStrikeNodeStats): LoadStrikeNodeStats;
-declare function postWithTimeout(fetchImpl: SinkFetch, url: string, init: RequestInit, timeoutMs: number, sinkName: string): Promise<string>;
+declare function postWithTimeout(fetchImpl: SinkFetch, url: string, init: RequestInit, timeoutMs: number, sinkName: string, ignoreSuccessfulResponseBody?: boolean): Promise<string>;
 export declare const __loadstrikeTestExports: {
     GrafanaLokiReportingSink: typeof GrafanaLokiReportingSink;
     InfluxDbReportingSink: typeof InfluxDbReportingSink;

package/dist/types/transports.d.ts

@@ -1009,6 +1009,7 @@ export interface EndpointAdapter {
     initialize?(): Promise<void>;
     produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
     consume(): Promise<TrackingPayload | null>;
+    interrupt?(): void;
     dispose?(): Promise<void>;
 }
 declare class CallbackAdapter implements EndpointAdapter {
@@ -1068,6 +1069,7 @@ declare class SqsEndpointAdapter extends CallbackAdapter {
 export declare class EndpointAdapterFactory {
     static create(endpoint: EndpointDefinitionInput): EndpointAdapter;
 }
+export declare function validateNativeEndpointExecutionSupport(endpoint: EndpointDefinitionInput): void;
 declare function validateTrackingSelectorPath(expression: string, fieldName: "TrackingField" | "GatherByField"): void;
 declare function validateHttpEndpoint(endpoint: EndpointDefinition, mode: EndpointMode, hasModeDelegate: boolean): void;
 declare function applyHttpAuthHeaders(headers: Record<string, string>, options: HttpEndpointOptions, resolveOAuthToken: () => Promise<string>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.31001",
+  "version": "1.0.32601",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",
@@ -61,6 +61,7 @@
     "test:broker": "node --test --test-concurrency=1 tests/broker-integration.test.mjs tests/broker-distributed.test.mjs"
   },
   "dependencies": {
+    "@aws-sdk/client-cloudwatch": "^3.1045.0",
     "@aws-sdk/client-sqs": "^3.1045.0",
     "@azure/event-hubs": "^5.12.2",
     "@confluentinc/kafka-javascript": "^1.8.2",
@@ -68,7 +69,10 @@
     "amqplib": "^0.10.9",
     "nats": "^2.29.3",
     "pg": "^8.20.0",
-    "redis": "^4.7.1"
+    "protobufjs": "^8.7.1",
+    "redis": "^4.7.1",
+    "snappyjs": "^0.7.0",
+    "ws": "^8.21.1"
   },
   "publishConfig": {
     "access": "public"
@@ -76,12 +80,14 @@
   "devDependencies": {
     "@types/amqplib": "^0.10.7",
     "@types/node": "^20.19.37",
+    "@types/snappyjs": "^0.7.1",
+    "@types/ws": "^8.18.1",
     "c8": "^11.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2"
   },
   "overrides": {
-    "brace-expansion": "5.0.8",
+    "brace-expansion": "5.0.9",
     "tar": "7.5.21"
   }
 }

package/dist/cjs/internal-build.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLACKBOX_LICENSING_API_BASE_URL_TOKEN = void 0;
-exports.BLACKBOX_LICENSING_API_BASE_URL_TOKEN = "";