@loadstrike/loadstrike-sdk 1.0.10101 → 1.0.15201

package/dist/types/sinks.d.ts

@@ -1,5 +1,133 @@
-import type { ILoadStrikeReportingSink, LoadStrikeBaseContext, LoadStrikeMetricStats, LoadStrikeNodeStats, LoadStrikeReportingSink, LoadStrikeRunResult, LoadStrikeScenarioStats, LoadStrikeSessionStartInfo } from "./runtime.js";
+import type { ILoadStrikeReportingSink, LoadStrikeBaseContext, LoadStrikeMetricStats, LoadStrikeMetricValue, LoadStrikeNodeInfo, LoadStrikePluginData, LoadStrikeReportingSink, LoadStrikeRunResult, LoadStrikeScenarioStats, LoadStrikeSessionStartInfo, LoadStrikeSinkError, LoadStrikeStepStats, LoadStrikeTestInfo, LoadStrikeThresholdResult } from "./runtime.js";
+interface LoadStrikeNodeStats {
+    startedUtc: string;
+    completedUtc: string;
+    allBytes: number;
+    allRequestCount: number;
+    allOkCount: number;
+    allFailCount: number;
+    failedThresholds: number;
+    durationMs: number;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    thresholds: LoadStrikeThresholdResult[];
+    thresholdResults: LoadStrikeThresholdResult[];
+    metrics: LoadStrikeMetricStats;
+    metricValues: LoadStrikeMetricValue[];
+    scenarioStats: LoadStrikeScenarioStats[];
+    stepStats: LoadStrikeStepStats[];
+    pluginsData: LoadStrikePluginData[];
+    disabledSinks: string[];
+    sinkErrors: LoadStrikeSinkError[];
+    reportFiles: string[];
+    logFiles: string[];
+    findScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    getScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
+    FindScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    GetScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
+}
 type SinkFetch = (input: string, init?: RequestInit) => Promise<Response>;
+interface ReportingSinkEvent {
+    eventType: string;
+    occurredUtc: Date;
+    sessionId: string;
+    testSuite: string;
+    testName: string;
+    clusterId: string;
+    nodeType: string;
+    machineName: string;
+    scenarioName: string | null;
+    stepName: string | null;
+    tags: Record<string, string>;
+    fields: Record<string, unknown>;
+}
+interface SinkSessionMetadata {
+    sessionId: string;
+    testSuite: string;
+    testName: string;
+    clusterId: string;
+    nodeType: string;
+    machineName: string;
+    startedUtc: string;
+}
+interface InfluxDbResolvedOptions {
+    configurationSectionPath: string;
+    baseUrl: string;
+    writeEndpointPath: string;
+    organization: string;
+    bucket: string;
+    token: string;
+    measurementName: string;
+    metricsMeasurementName: string;
+    timeoutSeconds: number;
+    timeoutMs?: number;
+    staticTags: Record<string, string>;
+}
+interface GrafanaLokiResolvedOptions {
+    configurationSectionPath: string;
+    baseUrl: string;
+    pushEndpointPath: string;
+    metricsBaseUrl: string;
+    metricsEndpointPath: string;
+    bearerToken: string;
+    username: string;
+    password: string;
+    tenantId: string;
+    timeoutSeconds: number;
+    timeoutMs?: number;
+    staticLabels: Record<string, string>;
+    metricsHeaders: Record<string, string>;
+}
+interface TimescaleDbResolvedOptions {
+    configurationSectionPath: string;
+    connectionString: string;
+    schema: string;
+    tableName: string;
+    metricsTableName: string;
+    createSchemaIfMissing: boolean;
+    enableHypertableIfAvailable: boolean;
+    staticTags: Record<string, string>;
+    insert?: (qualifiedTableName: string, rows: Array<Record<string, unknown>>) => Promise<void> | void;
+    insertMetrics?: (qualifiedTableName: string, rows: Array<Record<string, unknown>>) => Promise<void> | void;
+}
+interface DatadogResolvedOptions {
+    configurationSectionPath: string;
+    baseUrl: string;
+    logsEndpointPath: string;
+    metricsEndpointPath: string;
+    apiKey: string;
+    applicationKey: string;
+    source: string;
+    service: string;
+    host: string;
+    timeoutSeconds: number;
+    timeoutMs?: number;
+    staticTags: Record<string, string>;
+    staticAttributes: Record<string, string>;
+}
+interface SplunkResolvedOptions {
+    configurationSectionPath: string;
+    baseUrl: string;
+    eventEndpointPath: string;
+    token: string;
+    source: string;
+    sourcetype: string;
+    index: string;
+    host: string;
+    timeoutSeconds: number;
+    timeoutMs?: number;
+    staticFields: Record<string, string>;
+}
+interface OtelCollectorResolvedOptions {
+    configurationSectionPath: string;
+    baseUrl: string;
+    logsEndpointPath: string;
+    metricsEndpointPath: string;
+    timeoutSeconds: number;
+    timeoutMs?: number;
+    headers: Record<string, string>;
+    staticResourceAttributes: Record<string, string>;
+}
 export interface InfluxDbSinkOptionsInput {
     ConfigurationSectionPath?: string;
     configurationSectionPath?: string;
@@ -258,7 +386,7 @@ export declare class MemoryReportingSink implements LoadStrikeReportingSink {
     }>;
     readonly realtimeSnapshots: LoadStrikeScenarioStats[][];
     readonly realtimeMetrics: LoadStrikeMetricStats[];
-    readonly finalResults: LoadStrikeNodeStats[];
+    readonly finalResults: LoadStrikeRunResult[];
     readonly runResults: Array<Record<string, unknown>>;
     readonly sessions: LoadStrikeSessionStartInfo[];
     stopCount: number;
@@ -270,8 +398,6 @@ export declare class MemoryReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): void;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): void;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): void;
-    saveFinalStats(result: LoadStrikeNodeStats): void;
-    SaveFinalStats(result: LoadStrikeNodeStats): void;
     saveRunResult(result: LoadStrikeRunResult): void;
     SaveRunResult(result: LoadStrikeRunResult): void;
     stop(): void;
@@ -290,9 +416,7 @@ export declare class ConsoleReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): void;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): void;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): void;
-    saveFinalStats(result: LoadStrikeNodeStats): void;
-    SaveFinalStats(result: LoadStrikeNodeStats): void;
-    saveRunResult(_result: LoadStrikeRunResult): void;
+    saveRunResult(result: LoadStrikeRunResult): void;
     SaveRunResult(result: LoadStrikeRunResult): void;
     stop(): void;
     Stop(): void;
@@ -310,8 +434,6 @@ export declare class CompositeReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): Promise<void>;
@@ -335,8 +457,6 @@ export declare class InfluxDbReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): void;
@@ -364,8 +484,6 @@ export declare class GrafanaLokiReportingSink implements LoadStrikeReportingSink
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): void;
@@ -394,8 +512,6 @@ export declare class TimescaleDbReportingSink implements LoadStrikeReportingSink
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): Promise<void>;
@@ -425,8 +541,6 @@ export declare class DatadogReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): void;
@@ -454,8 +568,6 @@ export declare class SplunkReportingSink implements LoadStrikeReportingSink {
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): void;
@@ -483,8 +595,6 @@ export declare class OtelCollectorReportingSink implements LoadStrikeReportingSi
     SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
     saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
     SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
-    saveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
-    SaveFinalStats(result: LoadStrikeNodeStats): Promise<void>;
     saveRunResult(result: LoadStrikeRunResult): Promise<void>;
     SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
     stop(): void;
@@ -494,4 +604,85 @@ export declare class OtelCollectorReportingSink implements LoadStrikeReportingSi
     private getSession;
     private persistEvents;
 }
+declare function createRealtimeStatsEvents(session: SinkSessionMetadata, scenarios: LoadStrikeScenarioStats[]): ReportingSinkEvent[];
+declare function createFinalStatsEvents(session: SinkSessionMetadata, stats: LoadStrikeNodeStats): ReportingSinkEvent[];
+declare function createRunResultEvents(session: SinkSessionMetadata, result: LoadStrikeRunResult): ReportingSinkEvent[];
+declare function createReportingEvent(session: SinkSessionMetadata, occurredUtc: Date, eventType: string, scenarioName: string | null, stepName: string | null, tags: Record<string, string>, fields: Record<string, unknown>): ReportingSinkEvent;
+declare function toOtelAnyValue(value: unknown): Record<string, unknown>;
+declare function sinkSessionMetadataFromContext(context: LoadStrikeBaseContext, session?: LoadStrikeSessionStartInfo): SinkSessionMetadata;
+declare function mergeInfluxOptions(target: InfluxDbResolvedOptions, source: Partial<InfluxDbResolvedOptions>): void;
+declare function mergeGrafanaLokiOptions(target: GrafanaLokiResolvedOptions, source: Partial<GrafanaLokiResolvedOptions>): void;
+declare function mergeTimescaleDbOptions(target: TimescaleDbResolvedOptions, source: Partial<TimescaleDbResolvedOptions>): void;
+declare function mergeDatadogOptions(target: DatadogResolvedOptions, source: Partial<DatadogResolvedOptions>): void;
+declare function mergeSplunkOptions(target: SplunkResolvedOptions, source: Partial<SplunkResolvedOptions>): void;
+declare function mergeOtelCollectorOptions(target: OtelCollectorResolvedOptions, source: Partial<OtelCollectorResolvedOptions>): void;
+declare function resolveConfigSection(source: Record<string, unknown>, path: string): Record<string, unknown>;
+declare function pickRecordValue(record: Record<string, unknown>, ...keys: string[]): unknown;
+declare function optionString(record: Record<string, unknown>, ...keys: string[]): string;
+declare function pickBooleanValue(record: Record<string, unknown>, fallback: boolean, ...keys: string[]): boolean;
+declare function optionNumber(record: Record<string, unknown>, ...keys: string[]): number | undefined;
+declare function normalizeStringMap(value: unknown): Record<string, string>;
+declare function resolveTimeoutMs(timeoutSeconds: number | undefined, timeoutMs: number | undefined): number;
+declare function normalizePath(path: string): string;
+declare function trimTrailingSlashes(value: string): string;
+declare function sanitizeGrafanaLabelKey(value: string): string;
+declare function sanitizeGrafanaLabelValue(value: string): string;
+declare function replaceLiteral(value: string, search: string, replacement: string): string;
+declare function normalizePluginFieldName(value: string): string;
+declare function normalizePluginFieldValue(value: unknown): unknown;
+declare function tryReadText(row: Record<string, unknown>, key: string): string | null;
+declare function cleanNullableText(value: string | null | undefined): string | null;
+declare function validateIdentifier(value: string, parameterName: string): void;
+declare function quoteIdentifier(schema: string, tableName: string): string;
+declare function normalizeConfigKey(value: string): string;
+declare function cloneBaseContext(context: LoadStrikeBaseContext): LoadStrikeBaseContext;
+declare function cloneSessionStartInfo(session: LoadStrikeSessionStartInfo): LoadStrikeSessionStartInfo;
+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<void>;
+export declare const __loadstrikeTestExports: {
+    GrafanaLokiReportingSink: typeof GrafanaLokiReportingSink;
+    InfluxDbReportingSink: typeof InfluxDbReportingSink;
+    OtelCollectorReportingSink: typeof OtelCollectorReportingSink;
+    SplunkReportingSink: typeof SplunkReportingSink;
+    TimescaleDbReportingSink: typeof TimescaleDbReportingSink;
+    cleanNullableText: typeof cleanNullableText;
+    cloneBaseContext: typeof cloneBaseContext;
+    cloneMetricStats: typeof cloneMetricStats;
+    cloneNodeStats: typeof cloneNodeStats;
+    cloneScenarioStats: typeof cloneScenarioStats;
+    cloneSessionStartInfo: typeof cloneSessionStartInfo;
+    createFinalStatsEvents: typeof createFinalStatsEvents;
+    createRealtimeStatsEvents: typeof createRealtimeStatsEvents;
+    createRunResultEvents: typeof createRunResultEvents;
+    createReportingEvent: typeof createReportingEvent;
+    mergeDatadogOptions: typeof mergeDatadogOptions;
+    mergeInfluxOptions: typeof mergeInfluxOptions;
+    mergeGrafanaLokiOptions: typeof mergeGrafanaLokiOptions;
+    mergeOtelCollectorOptions: typeof mergeOtelCollectorOptions;
+    mergeSplunkOptions: typeof mergeSplunkOptions;
+    mergeTimescaleDbOptions: typeof mergeTimescaleDbOptions;
+    normalizeConfigKey: typeof normalizeConfigKey;
+    normalizePath: typeof normalizePath;
+    normalizePluginFieldName: typeof normalizePluginFieldName;
+    normalizePluginFieldValue: typeof normalizePluginFieldValue;
+    normalizeStringMap: typeof normalizeStringMap;
+    optionNumber: typeof optionNumber;
+    optionString: typeof optionString;
+    pickBooleanValue: typeof pickBooleanValue;
+    pickRecordValue: typeof pickRecordValue;
+    postWithTimeout: typeof postWithTimeout;
+    quoteIdentifier: typeof quoteIdentifier;
+    replaceLiteral: typeof replaceLiteral;
+    resolveConfigSection: typeof resolveConfigSection;
+    resolveTimeoutMs: typeof resolveTimeoutMs;
+    sanitizeGrafanaLabelKey: typeof sanitizeGrafanaLabelKey;
+    sanitizeGrafanaLabelValue: typeof sanitizeGrafanaLabelValue;
+    sinkSessionMetadataFromContext: typeof sinkSessionMetadataFromContext;
+    toOtelAnyValue: typeof toOtelAnyValue;
+    trimTrailingSlashes: typeof trimTrailingSlashes;
+    tryReadText: typeof tryReadText;
+    validateIdentifier: typeof validateIdentifier;
+};
 export {};

package/dist/types/transports.d.ts

@@ -218,6 +218,10 @@ export interface AzureEventHubsEndpointOptions {
     consumerGroup?: string;
     PartitionId?: string;
     partitionId?: string;
+    PartitionKey?: string;
+    partitionKey?: string;
+    PartitionCount?: number;
+    partitionCount?: number;
     StartFromEarliest?: boolean;
     startFromEarliest?: boolean;
     [key: string]: unknown;
@@ -515,6 +519,10 @@ export interface AzureEventHubsEndpointDefinition extends TrafficEndpointDefinit
     consumerGroup?: string;
     PartitionId?: string;
     partitionId?: string;
+    PartitionKey?: string;
+    partitionKey?: string;
+    PartitionCount?: number;
+    partitionCount?: number;
     StartFromEarliest?: boolean;
     startFromEarliest?: boolean;
 }
@@ -696,6 +704,8 @@ declare class AzureEventHubsEndpointDefinitionModel extends TrafficEndpointDefin
     ConsumerGroup: string;
     StartFromEarliest: boolean;
     PartitionId?: string;
+    PartitionKey?: string;
+    PartitionCount?: number;
     constructor(initial?: AzureEventHubsEndpointDefinitionInit);
     Validate(): void;
 }
@@ -739,7 +749,139 @@ export interface EndpointAdapter {
     consume(): Promise<TrackingPayload | null>;
     dispose?(): Promise<void>;
 }
+declare class CallbackAdapter implements EndpointAdapter {
+    protected readonly endpoint: EndpointDefinition;
+    private readonly consumeQueue;
+    private consumeStreamStarted;
+    constructor(endpoint: EndpointDefinition);
+    produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
+    consume(): Promise<TrackingPayload | null>;
+    dispose(): Promise<void>;
+    protected defaultPayload(): TrackingPayload;
+    private ensureConsumeStreamStarted;
+}
+declare class HttpEndpointAdapter extends CallbackAdapter {
+    private readonly httpConsumeQueue;
+    private oauthToken;
+    produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
+    consume(): Promise<TrackingPayload | null>;
+    private resolveOAuthToken;
+}
+declare class RedisStreamsEndpointAdapter extends CallbackAdapter {
+    private clientPromise;
+    private groupReady;
+    produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
+    consume(): Promise<TrackingPayload | null>;
+    dispose(): Promise<void>;
+    private getClient;
+    private ensureConsumerGroup;
+}
+declare class AzureEventHubsEndpointAdapter extends CallbackAdapter {
+    private producerPromise;
+    private consumerPromise;
+    private subscriptionPromise;
+    private subscription;
+    private readonly queue;
+    produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
+    consume(): Promise<TrackingPayload | null>;
+    dispose(): Promise<void>;
+    private getProducer;
+    private getConsumer;
+    private ensureSubscriptionStarted;
+}
 export declare class EndpointAdapterFactory {
     static create(endpoint: EndpointDefinitionInput): EndpointAdapter;
 }
+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>;
+declare function buildHttpRequestBody(body: unknown, bodyType: NonNullable<HttpEndpointOptions["bodyType"]>, contentType: string): unknown;
+declare function partitionFromKey(value: string, partitionCount: number): string;
+declare function attachPayloadHelpers(payload: TrackingPayload): TrackingPayload;
+declare function attachDotNetTrackingPayloadAliases<T extends TrackingPayload>(payload: T): T;
+declare function attachStructuredProducedMessageRequestAliases(request: ProducedMessageRequest, endpoint: EndpointDefinition): ProducedMessageRequest;
+declare function createDelegateRequestEndpointView(endpoint: EndpointDefinition): Record<string, unknown>;
+declare function prepareProducedPayload(endpoint: EndpointDefinition, payload?: TrackingPayload): TrackingPayload;
+declare function serializePayloadBody(body: unknown, contentType?: string): Uint8Array;
+declare function deserializeBrokerPayloadBody(body: Uint8Array, contentType?: string, messagePayloadType?: string): unknown;
+declare function extractTrackingValue(payload: TrackingPayload, selector: string): string | null;
+declare function injectTrackingValue(payload: TrackingPayload, selector: string, value: string): boolean;
+declare function setJsonBodyValue(body: unknown, path: string, value: string): unknown;
+declare function parseBodyObject(body: unknown): Record<string, unknown> | null;
+declare function resolveConnectionMetadata(endpoint: EndpointDefinition): Record<string, string>;
+declare function canonicalizeHttpResponseSource(value: string): HttpResponseSource;
+declare function inferLegacyHttpResponseSource(value: string | undefined): HttpResponseSource | undefined;
+declare function buildKafkaClientOptions(endpoint: EndpointDefinition): any;
+declare function shouldUseConfluentKafkaClient(endpoint: EndpointDefinition): boolean;
+declare function buildConfluentKafkaClientOptions(endpoint: EndpointDefinition): Record<string, unknown>;
+declare function resolveKafkaOAuthBearerToken(options: Record<string, unknown>): Promise<string>;
+declare function mapKafkaSaslMechanism(mechanism: string): string;
+declare function mapConfluentKafkaSecurityProtocol(protocol: string): string;
+declare function mapConfluentKafkaSaslMechanism(mechanism: string): string;
+declare function toKafkaHeadersWithContentType(headers: Record<string, string>, contentType?: string): Record<string, Buffer>;
+declare function fromKafkaHeaders(headers: Record<string, Buffer | Uint8Array | string | Array<Buffer | Uint8Array | string> | undefined> | undefined): Record<string, string>;
+declare function headerValue(headers: Record<string, Buffer | Uint8Array | string | Array<Buffer | Uint8Array | string> | undefined> | undefined, expected: string): string | undefined;
+declare function createNatsHeaders(headers: Record<string, string>, contentType?: string): Promise<any | null>;
+declare function toHeaderRecord(value: unknown): Record<string, string>;
+declare function bufferToUint8Array(value: unknown): Uint8Array;
+declare function readFirstRedisStreamEntry(value: unknown): {
+    id: string;
+    fields: Record<string, Uint8Array>;
+} | null;
+declare function createRedisStreamPayload(fields: Record<string, Uint8Array>, endpoint: EndpointDefinition): TrackingPayload;
+declare function payloadBodyAsUtf8(body: unknown): string;
+export declare const __loadstrikeTestExports: {
+    AzureEventHubsEndpointAdapter: typeof AzureEventHubsEndpointAdapter;
+    AzureEventHubsEndpointDefinition: typeof AzureEventHubsEndpointDefinitionModel;
+    AzureEventHubsEndpointDefinitionModel: typeof AzureEventHubsEndpointDefinitionModel;
+    CallbackAdapter: typeof CallbackAdapter;
+    DelegateStreamEndpointDefinition: typeof DelegateStreamEndpointDefinitionModel;
+    DelegateStreamEndpointDefinitionModel: typeof DelegateStreamEndpointDefinitionModel;
+    HttpEndpointAdapter: typeof HttpEndpointAdapter;
+    NatsEndpointDefinition: typeof NatsEndpointDefinitionModel;
+    NatsEndpointDefinitionModel: typeof NatsEndpointDefinitionModel;
+    PushDiffusionEndpointDefinition: typeof PushDiffusionEndpointDefinitionModel;
+    PushDiffusionEndpointDefinitionModel: typeof PushDiffusionEndpointDefinitionModel;
+    RabbitMqEndpointDefinition: typeof RabbitMqEndpointDefinitionModel;
+    RabbitMqEndpointDefinitionModel: typeof RabbitMqEndpointDefinitionModel;
+    RedisStreamsEndpointAdapter: typeof RedisStreamsEndpointAdapter;
+    RedisStreamsEndpointDefinition: typeof RedisStreamsEndpointDefinitionModel;
+    RedisStreamsEndpointDefinitionModel: typeof RedisStreamsEndpointDefinitionModel;
+    bufferToUint8Array: typeof bufferToUint8Array;
+    applyHttpAuthHeaders: typeof applyHttpAuthHeaders;
+    buildHttpRequestBody: typeof buildHttpRequestBody;
+    buildConfluentKafkaClientOptions: typeof buildConfluentKafkaClientOptions;
+    buildKafkaClientOptions: typeof buildKafkaClientOptions;
+    canonicalizeHttpResponseSource: typeof canonicalizeHttpResponseSource;
+    createDelegateRequestEndpointView: typeof createDelegateRequestEndpointView;
+    createNatsHeaders: typeof createNatsHeaders;
+    createRedisStreamPayload: typeof createRedisStreamPayload;
+    deserializeBrokerPayloadBody: typeof deserializeBrokerPayloadBody;
+    extractTrackingValue: typeof extractTrackingValue;
+    fromKafkaHeaders: typeof fromKafkaHeaders;
+    headerValue: typeof headerValue;
+    attachDotNetTrackingPayloadAliases: typeof attachDotNetTrackingPayloadAliases;
+    attachPayloadHelpers: typeof attachPayloadHelpers;
+    attachStructuredProducedMessageRequestAliases: typeof attachStructuredProducedMessageRequestAliases;
+    inferLegacyHttpResponseSource: typeof inferLegacyHttpResponseSource;
+    injectTrackingValue: typeof injectTrackingValue;
+    mapConfluentKafkaSaslMechanism: typeof mapConfluentKafkaSaslMechanism;
+    mapConfluentKafkaSecurityProtocol: typeof mapConfluentKafkaSecurityProtocol;
+    mapKafkaSaslMechanism: typeof mapKafkaSaslMechanism;
+    parseBodyObject: typeof parseBodyObject;
+    partitionFromKey: typeof partitionFromKey;
+    payloadBodyAsUtf8: typeof payloadBodyAsUtf8;
+    prepareProducedPayload: typeof prepareProducedPayload;
+    protocolBus: unknown;
+    readFirstRedisStreamEntry: typeof readFirstRedisStreamEntry;
+    resolveConnectionMetadata: typeof resolveConnectionMetadata;
+    resolveKafkaOAuthBearerToken: typeof resolveKafkaOAuthBearerToken;
+    serializePayloadBody: typeof serializePayloadBody;
+    setJsonBodyValue: typeof setJsonBodyValue;
+    shouldUseConfluentKafkaClient: typeof shouldUseConfluentKafkaClient;
+    toHeaderRecord: typeof toHeaderRecord;
+    toKafkaHeadersWithContentType: typeof toKafkaHeadersWithContentType;
+    validateHttpEndpoint: typeof validateHttpEndpoint;
+    validateTrackingSelectorPath: typeof validateTrackingSelectorPath;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.10101",
+  "version": "1.0.15201",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",
@@ -40,12 +40,6 @@
       "require": "./dist/cjs/contracts.js",
       "default": "./dist/esm/contracts.js"
     },
-    "./local": {
-      "types": "./dist/types/local.d.ts",
-      "import": "./dist/esm/local.js",
-      "require": "./dist/cjs/local.js",
-      "default": "./dist/esm/local.js"
-    },
     "./correlation": {
       "types": "./dist/types/correlation.d.ts",
       "import": "./dist/esm/correlation.js",
@@ -57,18 +51,6 @@
       "import": "./dist/esm/transports.js",
       "require": "./dist/cjs/transports.js",
       "default": "./dist/esm/transports.js"
-    },
-    "./cluster": {
-      "types": "./dist/types/cluster.d.ts",
-      "import": "./dist/esm/cluster.js",
-      "require": "./dist/cjs/cluster.js",
-      "default": "./dist/esm/cluster.js"
-    },
-    "./sinks": {
-      "types": "./dist/types/sinks.d.ts",
-      "import": "./dist/esm/sinks.js",
-      "require": "./dist/cjs/sinks.js",
-      "default": "./dist/esm/sinks.js"
     }
   },
   "files": [
@@ -83,7 +65,11 @@
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:post": "node ./scripts/postbuild.mjs",
     "clean": "rimraf dist",
-    "test": "npm run test:coverage",
+    "audit": "npm audit --audit-level=moderate",
+    "audit:fix": "npm audit fix --package-lock-only",
+    "pretest": "npm run build",
+    "test": "node ./tests/end-end/published-package-sdk.dispatcher.mjs",
+    "test:clean": "npm run clean && npm test",
     "test:coverage": "c8 --check-coverage --lines 89.5 --branches 81.6 --functions 95.5 node ./scripts/run-tests.mjs",
     "test:unit": "node ./scripts/run-tests.mjs",
     "test:broker": "node --test --test-concurrency=1 tests/broker-integration.test.mjs tests/broker-distributed.test.mjs"
@@ -107,5 +93,8 @@
     "c8": "^11.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2"
+  },
+  "overrides": {
+    "brace-expansion": "5.0.5"
   }
 }