@loadstrike/loadstrike-sdk 1.0.22801 → 1.0.23201

package/dist/esm/sinks.js

@@ -1,4 +1,5 @@
 import { LoadStrikePluginData as LoadStrikePluginDataModel, LoadStrikePluginDataTable as LoadStrikePluginDataTableModel } from "./runtime.js";
+import { createHash } from "node:crypto";
 import { Pool } from "pg";
 const DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:InfluxDb";
 const DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:GrafanaLoki";
@@ -372,6 +373,91 @@ export class CompositeReportingSink {
         await this.stop();
     }
 }
+export class PortalReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "portal";
+        this.SinkName = "portal";
+        this.licenseFeature = "extensions.reporting_sinks.portal";
+        this.LicenseFeature = "extensions.reporting_sinks.portal";
+        this.baseContext = null;
+        this.session = null;
+        this.runToken = "";
+        this.ingestUrl = "";
+        const source = asRecord(options);
+        this.timeoutMs = resolveTimeoutMs(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"), optionNumber(source, "timeoutMs", "TimeoutMs"));
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, _infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.runToken = String(session.runToken ?? session.RunToken ?? "").trim();
+        this.ingestUrl = String(session.portalReportingIngestUrl ?? session.PortalReportingIngestUrl ?? "").trim();
+        if (!this.runToken || !this.ingestUrl) {
+            throw new Error("PortalReportingSink requires a managed portal reporting session.");
+        }
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        await postWithTimeout(this.fetchImpl, this.ingestUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                runToken: this.runToken,
+                events: events.map((event, index) => portalEventPayload(event, index))
+            })
+        }, this.timeoutMs, "PortalReportingSink");
+    }
+}
 export class InfluxDbReportingSink {
     constructor(options = {}) {
         this.sinkName = "influxdb";
@@ -1528,6 +1614,37 @@ function createReportingEvent(session, occurredUtc, eventType, scenarioName, ste
         fields: eventFields
     };
 }
+function portalEventPayload(event, index) {
+    return {
+        eventId: portalEventId(event, index),
+        runId: event.sessionId,
+        eventType: event.eventType,
+        occurredUtc: event.occurredUtc.toISOString(),
+        sessionId: event.sessionId,
+        testSuite: event.testSuite,
+        testName: event.testName,
+        clusterId: event.clusterId,
+        nodeType: event.nodeType,
+        machineName: event.machineName,
+        scenarioName: event.scenarioName,
+        stepName: event.stepName,
+        tags: { ...event.tags },
+        fields: deepCloneRecord(event.fields)
+    };
+}
+function portalEventId(event, index) {
+    const material = JSON.stringify({
+        sessionId: event.sessionId,
+        eventType: event.eventType,
+        occurredUtc: event.occurredUtc.toISOString(),
+        scenarioName: event.scenarioName ?? "",
+        stepName: event.stepName ?? "",
+        index,
+        tags: event.tags,
+        fields: event.fields
+    });
+    return `lsr_${createHash("sha256").update(material).digest("hex").slice(0, 40)}`;
+}
 function addMeasurementFields(fields, prefix, measurement) {
     const request = measurement?.request ?? { count: 0, percent: 0, rps: 0 };
     const latency = measurement?.latency ?? {
@@ -2553,7 +2670,9 @@ function cloneSessionStartInfo(session) {
         ...cloneBaseContext(session),
         startedUtc: session.startedUtc,
         scenarioNames: [...session.scenarioNames],
-        scenarios: session.scenarios.map((value) => ({ ...value }))
+        scenarios: session.scenarios.map((value) => ({ ...value })),
+        runToken: session.runToken,
+        portalReportingIngestUrl: session.portalReportingIngestUrl
     };
 }
 function cloneNodeInfo(nodeInfo) {
@@ -2655,23 +2774,7 @@ function runResultToNodeStats(result) {
         disabledSinks: [...(result.disabledSinks ?? [])],
         sinkErrors: (result.sinkErrors ?? []).map((value) => ({ ...value })),
         reportFiles: [...(result.reportFiles ?? [])],
-        logFiles: [...(result.logFiles ?? [])],
-        findScenarioStats: (scenarioName) => result.scenarioStats.find((value) => value.scenarioName === scenarioName),
-        getScenarioStats: (scenarioName) => {
-            const scenario = result.scenarioStats.find((value) => value.scenarioName === scenarioName);
-            if (!scenario) {
-                throw new Error(`Scenario stats not found: ${scenarioName}`);
-            }
-            return scenario;
-        },
-        FindScenarioStats: (scenarioName) => result.scenarioStats.find((value) => value.scenarioName === scenarioName),
-        GetScenarioStats: (scenarioName) => {
-            const scenario = result.scenarioStats.find((value) => value.scenarioName === scenarioName);
-            if (!scenario) {
-                throw new Error(`Scenario stats not found: ${scenarioName}`);
-            }
-            return scenario;
-        }
+        logFiles: [...(result.logFiles ?? [])]
     };
 }
 function deepCloneRecord(value) {

package/dist/esm/transports.js

@@ -218,6 +218,35 @@ class AzureEventHubsEndpointDefinitionModel extends TrafficEndpointDefinitionMod
         }
     }
 }
+class SqsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Sqs";
+        this.QueueUrl = "";
+        this.Region = "";
+        this.WaitTimeSeconds = 1;
+        this.MaxNumberOfMessages = 1;
+        this.DeleteAfterConsume = true;
+        initializeSqsEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.QueueUrl, "QueueUrl must be provided for AWS SQS endpoint.");
+        requireNonEmptyString(this.Region, "Region must be provided for AWS SQS endpoint.");
+        if (String(this.AccessKeyId ?? "").trim() && !String(this.SecretAccessKey ?? "").trim()) {
+            throw new Error("SecretAccessKey must be provided when AccessKeyId is configured for AWS SQS endpoint.");
+        }
+        if (this.WaitTimeSeconds < 0 || this.WaitTimeSeconds > 20) {
+            throw new RangeError("WaitTimeSeconds must be between 0 and 20 for AWS SQS endpoint.");
+        }
+        if (this.MaxNumberOfMessages <= 0 || this.MaxNumberOfMessages > 10) {
+            throw new RangeError("MaxNumberOfMessages must be between 1 and 10 for AWS SQS endpoint.");
+        }
+        if (this.VisibilityTimeoutSeconds != null && this.VisibilityTimeoutSeconds < 0) {
+            throw new RangeError("VisibilityTimeoutSeconds must be zero or greater when configured.");
+        }
+    }
+}
 class DelegateStreamEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -263,6 +292,7 @@ export const RabbitMqEndpointDefinition = RabbitMqEndpointDefinitionModel;
 export const NatsEndpointDefinition = NatsEndpointDefinitionModel;
 export const RedisStreamsEndpointDefinition = RedisStreamsEndpointDefinitionModel;
 export const AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinitionModel;
+export const SqsEndpointDefinition = SqsEndpointDefinitionModel;
 export const DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 export const PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
 export const HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
@@ -626,6 +656,44 @@ function initializeAzureEventHubsEndpointDefinitionModel(target, initial) {
         target.PartitionCount = pickOptionalEndpointNumber(raw, "PartitionCount", "partitionCount");
     }
 }
+function initializeSqsEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const queueUrl = pickOptionalEndpointString(raw, "QueueUrl", "queueUrl");
+    if (queueUrl) {
+        target.QueueUrl = queueUrl;
+    }
+    const region = pickOptionalEndpointString(raw, "Region", "region");
+    if (region) {
+        target.Region = region;
+    }
+    if (hasAnyEndpointField(raw, ["ServiceUrl", "serviceUrl"])) {
+        target.ServiceUrl = pickOptionalEndpointString(raw, "ServiceUrl", "serviceUrl");
+    }
+    if (hasAnyEndpointField(raw, ["AccessKeyId", "accessKeyId"])) {
+        target.AccessKeyId = pickOptionalEndpointString(raw, "AccessKeyId", "accessKeyId");
+    }
+    if (hasAnyEndpointField(raw, ["SecretAccessKey", "secretAccessKey"])) {
+        target.SecretAccessKey = pickOptionalEndpointStringAllowEmpty(raw, "SecretAccessKey", "secretAccessKey");
+    }
+    if (hasAnyEndpointField(raw, ["SessionToken", "sessionToken"])) {
+        target.SessionToken = pickOptionalEndpointString(raw, "SessionToken", "sessionToken");
+    }
+    const waitTimeSeconds = pickOptionalEndpointNumber(raw, "WaitTimeSeconds", "waitTimeSeconds");
+    if (waitTimeSeconds != null) {
+        target.WaitTimeSeconds = waitTimeSeconds;
+    }
+    const maxNumberOfMessages = pickOptionalEndpointNumber(raw, "MaxNumberOfMessages", "maxNumberOfMessages");
+    if (maxNumberOfMessages != null) {
+        target.MaxNumberOfMessages = maxNumberOfMessages;
+    }
+    if (hasAnyEndpointField(raw, ["VisibilityTimeoutSeconds", "visibilityTimeoutSeconds"])) {
+        target.VisibilityTimeoutSeconds = pickOptionalEndpointNumber(raw, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+    }
+    const deleteAfterConsume = pickEndpointBoolean(raw, "DeleteAfterConsume", "deleteAfterConsume");
+    if (deleteAfterConsume != null) {
+        target.DeleteAfterConsume = deleteAfterConsume;
+    }
+}
 function initializeDelegateStreamEndpointDefinitionModel(target, initial) {
     const raw = asRecordOrEmpty(initial);
     const produce = pickEndpointFunction(raw, "Produce", "produce");
@@ -762,6 +830,7 @@ const protocolBus = new class InMemoryProtocolBus {
         this.redisCounters = new Map();
         this.eventHubs = new Map();
         this.eventHubOffsets = new Map();
+        this.sqsQueues = new Map();
         this.pushTopics = new Map();
         this.pushOffsets = new Map();
     }
@@ -776,6 +845,7 @@ const protocolBus = new class InMemoryProtocolBus {
         this.redisCounters.clear();
         this.eventHubs.clear();
         this.eventHubOffsets.clear();
+        this.sqsQueues.clear();
         this.pushTopics.clear();
         this.pushOffsets.clear();
     }
@@ -940,6 +1010,25 @@ const protocolBus = new class InMemoryProtocolBus {
         this.eventHubOffsets.set(cursorKey, rows.length);
         return null;
     }
+    produceSqs(endpoint, payload) {
+        const options = endpoint.sqs ?? {};
+        const queueUrl = optionString(options, "QueueUrl", "queueUrl") || endpoint.name;
+        const queue = this.sqsQueues.get(queueUrl) ?? [];
+        queue.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.sqsQueues.set(queueUrl, queue);
+        return clonePayload(payload);
+    }
+    consumeSqs(endpoint) {
+        const options = endpoint.sqs ?? {};
+        const queueUrl = optionString(options, "QueueUrl", "queueUrl") || endpoint.name;
+        const queue = this.sqsQueues.get(queueUrl) ?? [];
+        if (!queue.length) {
+            return null;
+        }
+        const next = queue.shift() ?? null;
+        this.sqsQueues.set(queueUrl, queue);
+        return next ? clonePayload(next.payload) : null;
+    }
     producePush(endpoint, payload) {
         const options = endpoint.pushDiffusion ?? {};
         const topic = optionString(options, "TopicPath", "topicPath")
@@ -1681,6 +1770,104 @@ class AzureEventHubsEndpointAdapter extends CallbackAdapter {
         await this.subscriptionPromise;
     }
 }
+let sqsClientFactoryForTests = null;
+class SqsEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.clientPromise = null;
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.sqs ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const { SendMessageCommand } = await import("@aws-sdk/client-sqs");
+        await client.send(new SendMessageCommand({
+            QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+            MessageBody: payloadBodyAsUtf8(wire.body),
+            MessageAttributes: toSqsMessageAttributes(wire.headers, wire.contentType)
+        }));
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.sqs ?? {};
+        const { ReceiveMessageCommand, DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const input = {
+            QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+            MaxNumberOfMessages: hasOptionValue(options, "MaxNumberOfMessages", "maxNumberOfMessages")
+                ? optionNumber(options, "MaxNumberOfMessages", "maxNumberOfMessages")
+                : 1,
+            WaitTimeSeconds: hasOptionValue(options, "WaitTimeSeconds", "waitTimeSeconds")
+                ? optionNumber(options, "WaitTimeSeconds", "waitTimeSeconds")
+                : 1,
+            MessageAttributeNames: ["All"]
+        };
+        const visibilityTimeout = optionNumber(options, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+        if (visibilityTimeout > 0) {
+            input.VisibilityTimeout = visibilityTimeout;
+        }
+        const response = await client.send(new ReceiveMessageCommand(input));
+        const message = response.Messages?.[0];
+        if (!message) {
+            return null;
+        }
+        const { headers, contentType } = fromSqsMessageAttributes(message.MessageAttributes);
+        const payload = createBrokerPayload(headers, Buffer.from(message.Body ?? "", "utf8"), this.endpoint, contentType);
+        if (optionBoolean(options, true, "DeleteAfterConsume", "deleteAfterConsume") && message.ReceiptHandle) {
+            await client.send(new DeleteMessageCommand({
+                QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+                ReceiptHandle: message.ReceiptHandle
+            }));
+        }
+        return payload;
+    }
+    async dispose() {
+        const client = await this.clientPromise?.catch(() => null);
+        client?.destroy?.();
+    }
+    async getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = (async () => {
+                if (sqsClientFactoryForTests) {
+                    return await sqsClientFactoryForTests(this.endpoint);
+                }
+                const { SQSClient } = await import("@aws-sdk/client-sqs");
+                const options = this.endpoint.sqs ?? {};
+                const accessKeyId = optionString(options, "AccessKeyId", "accessKeyId");
+                const secretAccessKey = optionString(options, "SecretAccessKey", "secretAccessKey");
+                const config = {
+                    region: optionString(options, "Region", "region")
+                };
+                const serviceUrl = optionString(options, "ServiceUrl", "serviceUrl");
+                if (serviceUrl) {
+                    config.endpoint = serviceUrl;
+                }
+                if (accessKeyId) {
+                    config.credentials = {
+                        accessKeyId,
+                        secretAccessKey,
+                        sessionToken: optionString(options, "SessionToken", "sessionToken") || undefined
+                    };
+                }
+                return new SQSClient(config);
+            })();
+        }
+        return this.clientPromise;
+    }
+}
 class PushDiffusionEndpointAdapter extends CallbackAdapter {
     async produce(payload) {
         return super.produce(payload);
@@ -1711,6 +1898,8 @@ export class EndpointAdapterFactory {
                 return new RedisStreamsEndpointAdapter(normalized);
             case "AzureEventHubs":
                 return new AzureEventHubsEndpointAdapter(normalized);
+            case "Sqs":
+                return new SqsEndpointAdapter(normalized);
             case "PushDiffusion":
                 return new PushDiffusionEndpointAdapter(normalized);
             case "DelegateStream":
@@ -1838,6 +2027,28 @@ const AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS = [
     "StartFromEarliest",
     "startFromEarliest"
 ];
+const SQS_ENDPOINT_FLAT_KEYS = [
+    "QueueUrl",
+    "queueUrl",
+    "Region",
+    "region",
+    "ServiceUrl",
+    "serviceUrl",
+    "AccessKeyId",
+    "accessKeyId",
+    "SecretAccessKey",
+    "secretAccessKey",
+    "SessionToken",
+    "sessionToken",
+    "WaitTimeSeconds",
+    "waitTimeSeconds",
+    "MaxNumberOfMessages",
+    "maxNumberOfMessages",
+    "VisibilityTimeoutSeconds",
+    "visibilityTimeoutSeconds",
+    "DeleteAfterConsume",
+    "deleteAfterConsume"
+];
 const PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS = [
     "ServerUrl",
     "serverUrl",
@@ -1898,6 +2109,7 @@ function normalizeEndpointDefinition(endpoint) {
         nats: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Nats", ["nats", "Nats"], NATS_ENDPOINT_FLAT_KEYS)),
         redisStreams: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "RedisStreams", ["redisStreams", "RedisStreams"], REDIS_STREAMS_ENDPOINT_FLAT_KEYS)),
         azureEventHubs: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "AzureEventHubs", ["azureEventHubs", "AzureEventHubs"], AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS)),
+        sqs: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Sqs", ["sqs", "Sqs"], SQS_ENDPOINT_FLAT_KEYS)),
         pushDiffusion: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "PushDiffusion", ["pushDiffusion", "PushDiffusion"], PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS)),
         delegate: normalizeDelegateEndpointOptions(pickEndpointTransportRecord(raw, kind, "DelegateStream", ["delegate", "Delegate", "DelegateStream"], DELEGATE_STREAM_ENDPOINT_FLAT_KEYS))
     };
@@ -1955,6 +2167,22 @@ function resolveEndpointKind(raw) {
     ])) {
         return "AzureEventHubs";
     }
+    if (Object.keys(pickEndpointRecord(raw, "sqs", "Sqs")).length || hasAnyEndpointField(raw, [
+        "QueueUrl",
+        "queueUrl",
+        "ServiceUrl",
+        "serviceUrl",
+        "WaitTimeSeconds",
+        "waitTimeSeconds",
+        "MaxNumberOfMessages",
+        "maxNumberOfMessages",
+        "VisibilityTimeoutSeconds",
+        "visibilityTimeoutSeconds",
+        "DeleteAfterConsume",
+        "deleteAfterConsume"
+    ])) {
+        return "Sqs";
+    }
     if (Object.keys(pickEndpointRecord(raw, "pushDiffusion", "PushDiffusion")).length || hasAnyEndpointField(raw, [
         "TopicPath",
         "topicPath",
@@ -2236,6 +2464,9 @@ function validateEndpointDefinition(endpoint) {
         case "AzureEventHubs":
             validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate);
             return;
+        case "Sqs":
+            validateSqsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
         case "PushDiffusion":
             validatePushDiffusionEndpoint(endpoint, mode);
             return;
@@ -2457,6 +2688,32 @@ function validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate) {
         throw new RangeError("PartitionCount must be zero or greater when configured.");
     }
 }
+function validateSqsEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.sqs;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`Sqs endpoint in ${mode} mode requires sqs options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "QueueUrl", "queueUrl"), "QueueUrl must be provided for AWS SQS endpoint.");
+    requireNonEmptyString(optionString(options, "Region", "region"), "Region must be provided for AWS SQS endpoint.");
+    if (optionString(options, "AccessKeyId", "accessKeyId") && !optionString(options, "SecretAccessKey", "secretAccessKey")) {
+        throw new Error("SecretAccessKey must be provided when AccessKeyId is configured for AWS SQS endpoint.");
+    }
+    const waitTimeSeconds = optionNumber(options, "WaitTimeSeconds", "waitTimeSeconds");
+    if (waitTimeSeconds < 0 || waitTimeSeconds > 20) {
+        throw new RangeError("WaitTimeSeconds must be between 0 and 20 for AWS SQS endpoint.");
+    }
+    const maxNumberOfMessages = optionNumber(options, "MaxNumberOfMessages", "maxNumberOfMessages") || 1;
+    if (maxNumberOfMessages <= 0 || maxNumberOfMessages > 10) {
+        throw new RangeError("MaxNumberOfMessages must be between 1 and 10 for AWS SQS endpoint.");
+    }
+    const visibilityTimeoutSeconds = optionNumber(options, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+    if (visibilityTimeoutSeconds < 0) {
+        throw new RangeError("VisibilityTimeoutSeconds must be zero or greater when configured.");
+    }
+}
 function validatePushDiffusionEndpoint(endpoint, mode) {
     const options = endpoint.pushDiffusion;
     if (!options || typeof options !== "object") {
@@ -2821,6 +3078,12 @@ function optionNumber(options, ...keys) {
     }
     return 0;
 }
+function hasOptionValue(options, ...keys) {
+    return keys.some((key) => {
+        const value = options[key];
+        return value !== undefined && value !== null && (!(typeof value === "string") || value.trim() !== "");
+    });
+}
 function optionBoolean(options, fallback, ...keys) {
     for (const key of keys) {
         const value = options[key];
@@ -3704,6 +3967,29 @@ function createRedisStreamPayload(fields, endpoint) {
     }
     return createBrokerPayload(headers, body, endpoint, contentType);
 }
+function toSqsMessageAttributes(headers, contentType) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(headers)) {
+        attributes[key] = { DataType: "String", StringValue: String(value ?? "") };
+    }
+    if (contentType) {
+        attributes["content-type"] = { DataType: "String", StringValue: contentType };
+    }
+    return attributes;
+}
+function fromSqsMessageAttributes(attributes) {
+    const headers = {};
+    let contentType;
+    for (const [key, value] of Object.entries(attributes ?? {})) {
+        const text = String(value?.StringValue ?? "");
+        if (key.toLowerCase() === "content-type") {
+            contentType = text;
+            continue;
+        }
+        headers[key] = text;
+    }
+    return { headers, contentType };
+}
 function payloadBodyAsUtf8(body) {
     if (body instanceof Uint8Array) {
         return new TextDecoder().decode(body);
@@ -3738,6 +4024,9 @@ export const __loadstrikeTestExports = {
     RedisStreamsEndpointAdapter,
     RedisStreamsEndpointDefinition,
     RedisStreamsEndpointDefinitionModel,
+    SqsEndpointAdapter,
+    SqsEndpointDefinition,
+    SqsEndpointDefinitionModel,
     bufferToUint8Array,
     applyHttpAuthHeaders,
     buildHttpRequestBody,
@@ -3772,6 +4061,11 @@ export const __loadstrikeTestExports = {
     shouldUseConfluentKafkaClient,
     toHeaderRecord,
     toKafkaHeadersWithContentType,
+    toSqsMessageAttributes,
+    fromSqsMessageAttributes,
+    setSqsClientFactoryForTests: (factory) => {
+        sqsClientFactoryForTests = factory;
+    },
     validateHttpEndpoint,
     validateTrackingSelectorPath
 };

package/dist/types/autopilot-contracts.d.ts

@@ -13,6 +13,8 @@ export interface LoadStrikeAutopilotOptions {
     AllowedReplayHosts?: string[];
     BaseUrlRewrite?: string;
     TrackingSelector?: string;
+    RunnerKey?: string;
+    LicenseValidationTimeoutSeconds?: number;
     SecretBindings?: LoadStrikeAutopilotSecretBinding[];
     EndpointBindings?: LoadStrikeAutopilotEndpointBinding[];
 }

package/dist/types/autopilot.d.ts

@@ -37,7 +37,10 @@ export declare class LoadStrikeAutopilotResult implements LoadStrikeAutopilotRes
     BuildScenario(): LoadStrikeScenario;
 }
 export declare class LoadStrikeAutopilot {
-    static generate(request: LoadStrikeAutopilotRequest): LoadStrikeAutopilotResult;
-    static Generate(request: LoadStrikeAutopilotRequest): LoadStrikeAutopilotResult;
+    static generate(request: LoadStrikeAutopilotRequest): Promise<LoadStrikeAutopilotResult>;
+    static Generate(request: LoadStrikeAutopilotRequest): Promise<LoadStrikeAutopilotResult>;
 }
+export declare const __private: {
+    setAutopilotLicenseValidationBypassForTests(value: boolean): void;
+};
 export {};

package/dist/types/contracts.d.ts

@@ -108,6 +108,7 @@ export interface LoadStrikeEndpointSpec {
     Nats?: LoadStrikeNatsEndpointOptions;
     RedisStreams?: LoadStrikeRedisStreamsEndpointOptions;
     AzureEventHubs?: LoadStrikeAzureEventHubsEndpointOptions;
+    Sqs?: LoadStrikeSqsEndpointOptions;
     DelegateStream?: LoadStrikeDelegateEndpointOptions;
     PushDiffusion?: LoadStrikePushDiffusionEndpointOptions;
 }
@@ -203,6 +204,18 @@ export interface LoadStrikeAzureEventHubsEndpointOptions {
     PartitionKey?: string;
     PartitionCount?: number;
 }
+export interface LoadStrikeSqsEndpointOptions {
+    QueueUrl?: string;
+    Region?: string;
+    ServiceUrl?: string;
+    AccessKeyId?: string;
+    SecretAccessKey?: string;
+    SessionToken?: string;
+    WaitTimeSeconds?: number;
+    MaxNumberOfMessages?: number;
+    VisibilityTimeoutSeconds?: number;
+    DeleteAfterConsume?: boolean;
+}
 export interface LoadStrikeDelegateEndpointOptions {
     ProduceCallbackUrl?: string;
     ConsumeCallbackUrl?: string;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
+export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeSqsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
 export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export type { LoadStrikeAutopilotEndpoint, LoadStrikeAutopilotEndpointBinding, LoadStrikeAutopilotLoadSimulationSuggestion, LoadStrikeAutopilotMessageSample, LoadStrikeAutopilotOptions, LoadStrikeAutopilotPlan, LoadStrikeAutopilotPreviewReport, LoadStrikeAutopilotReadinessFailure, LoadStrikeAutopilotRedaction, LoadStrikeAutopilotRequest, LoadStrikeAutopilotResultShape, LoadStrikeAutopilotScenarioPlan, LoadStrikeAutopilotSecretBinding, LoadStrikeAutopilotThresholdSuggestion, LoadStrikeAutopilotTrackingSelectorSuggestion } from "./autopilot-contracts.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
@@ -6,7 +6,7 @@ export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStri
 export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeBaseContext, LoadStrikeCounterStats, LoadStrikeDataTransferStats, LoadStrikeGaugeStats, LoadStrikeLogger, LoadStrikeLoadSimulationStats, LoadStrikeMeasurementStats, LoadStrikeMetricStats, LoadStrikeNodeInfo, LoadStrikeMetricValue, LoadStrikeRandom, LoadStrikeReply, LoadStrikeLatencyCount, LoadStrikeLatencyStats, LoadStrikeLoadSimulation, LoadStrikeScenarioInfo, LoadStrikeScenarioInitContext, LoadStrikeScenarioPartition, LoadStrikeScenarioStartInfo, LoadStrikeScenarioContext, LoadStrikeScenarioStats, LoadStrikeTestInfo, LoadStrikeScenarioRuntime, LoadStrikeSessionStartInfo, LoadStrikeSinkSession, LoadStrikeSinkError, LoadStrikeStatusCodeStats, LoadStrikeThresholdResult, LoadStrikeThresholdPredicateContext, LoadStrikeStepReply, LoadStrikeStepStats, LoadStrikeStepRuntime, LoadStrikeThresholdOptions, LoadStrikeRequestStats, LoadStrikeWorkerPlugin } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
 export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, CorrelationStoreKind, CorrelationRuntimeOptions, CorrelationRuntimePlugin, CorrelationRuntimeStats, CorrelationStore, SourceProduceResult, TrackingFieldLocation, TrackingPayload } from "./correlation.js";
-export { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, 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, PushDiffusionEndpointOptions, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
-export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
-export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.js";
+export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, 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, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
+export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
+export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.js";

package/dist/types/local.d.ts

@@ -29,6 +29,7 @@ export declare class LoadStrikeLocalClient {
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
      */
     constructor(options?: LoadStrikeLocalClientOptions);
+    portalReportingIngestUrl(): string;
     run(request: LoadStrikeRunRequest): Promise<LoadStrikeRunResponse>;
     acquireLicenseLease(request: LoadStrikeRunRequest): Promise<LicenseValidationSession>;
     releaseLicenseLease(session: LicenseValidationSession, request: LoadStrikeRunRequest): Promise<void>;