@loadstrike/loadstrike-sdk 1.0.22601 → 1.0.23001

package/dist/esm/runtime.js

@@ -41,6 +41,33 @@ export const LoadStrikeOperationType = {
     Complete: "Complete",
     Error: "Error"
 };
+export const CrossPlatformTrackingConfiguration = {
+    forDuration(configuration, durationSeconds, cancellationSignal) {
+        if (!configuration || typeof configuration !== "object" || Array.isArray(configuration)) {
+            throw new TypeError("Tracking configuration must be provided.");
+        }
+        if (normalizeTrackingRunMode(pickTrackingString(configuration, "RunMode", "runMode", "GenerateAndCorrelate")) !== "correlateexistingtraffic") {
+            throw new Error("ForDuration can only be used with CorrelateExistingTraffic.");
+        }
+        if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+            throw new RangeError("ForDuration duration must be greater than zero.");
+        }
+        const result = {
+            ...configuration,
+            ObservationDurationSeconds: durationSeconds
+        };
+        if (cancellationSignal !== undefined) {
+            if (!(cancellationSignal instanceof AbortSignal)) {
+                throw new TypeError("ForDuration cancellation signal must be an AbortSignal.");
+            }
+            result.ObservationCancellationSignal = cancellationSignal;
+        }
+        return result;
+    },
+    ForDuration(configuration, durationSeconds, cancellationSignal) {
+        return this.forDuration(configuration, durationSeconds, cancellationSignal);
+    }
+};
 export class LoadStrikePluginDataTable {
     /**
      * Exposes the public constructor operation.
@@ -1712,6 +1739,9 @@ export class LoadStrikeScenario {
             ? mapRuntimeTrackingEndpointSpec(destinationSpec, useLoadStrikeTraceIdHeader)
             : null;
         validateRuntimeTrackingConfiguration(copied, sourceEndpoint, destinationEndpoint);
+        if (isCorrelateExistingTrafficTracking(copied) && this.loadSimulations.length > 0) {
+            throw new Error("CorrelateExistingTraffic uses ForDuration and cannot be combined with WithLoadSimulations.");
+        }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
     }
     /**
@@ -1722,6 +1752,9 @@ export class LoadStrikeScenario {
         if (!simulations.length) {
             throw new Error("At least one load simulation should be provided.");
         }
+        if (isCorrelateExistingTrafficTracking(this.trackingConfiguration)) {
+            throw new Error("CorrelateExistingTraffic uses ForDuration and cannot be combined with WithLoadSimulations.");
+        }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
     }
     /**
@@ -5721,6 +5754,14 @@ class ManagedScenarioTrackingRuntime {
         this.sourceOnlyMode = this.destinationEndpoint == null;
         this.executeOriginalScenarioRun = pickTrackingBoolean(tracking, "ExecuteOriginalScenarioRun", "executeOriginalScenarioRun", false);
         this.correlationTimeoutMs = Math.trunc(pickTrackingNumber(tracking, ["CorrelationTimeoutMs", "correlationTimeoutMs"], pickTrackingNumber(tracking, ["CorrelationTimeoutSeconds", "correlationTimeoutSeconds", "CorrelationTimeout"], 30) * 1000));
+        this.observationDurationMs = Math.trunc(readObservationDurationMs(tracking));
+        const observationCancellationSignal = pickTrackingValue(tracking, "ObservationCancellationSignal", "observationCancellationSignal");
+        if (observationCancellationSignal !== undefined) {
+            if (!(observationCancellationSignal instanceof AbortSignal)) {
+                throw new TypeError("ObservationCancellationSignal must be an AbortSignal.");
+            }
+            this.observationCancellationSignal = observationCancellationSignal;
+        }
         this.timeoutSweepIntervalMs = Math.trunc(pickTrackingNumber(tracking, ["TimeoutSweepIntervalMs", "timeoutSweepIntervalMs"], pickTrackingNumber(tracking, ["TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds"], 1) * 1000));
         this.timeoutBatchSize = Math.trunc(pickTrackingNumber(tracking, ["TimeoutBatchSize", "timeoutBatchSize"], 200));
         this.timeoutCountsAsFailure = pickTrackingBoolean(tracking, "TimeoutCountsAsFailure", "timeoutCountsAsFailure", true);
@@ -5861,8 +5902,7 @@ class ManagedScenarioTrackingRuntime {
             return this.executeSourceOnly();
         }
         if (this.runMode === "correlateexistingtraffic") {
-            const outcome = await this.waitForOutcome(context.scenarioCancellationToken);
-            return this.toResponse(outcome);
+            return await this.observeExistingTraffic(context.scenarioCancellationToken);
         }
         let producedPayload;
         try {
@@ -5938,6 +5978,45 @@ class ManagedScenarioTrackingRuntime {
         });
         return LoadStrikeResponse.ok("source_success");
     }
+    async observeExistingTraffic(signal) {
+        const deadline = Date.now() + this.observationDurationMs;
+        const observationSignal = this.observationCancellationSignal
+            ? combineAbortSignals(signal, this.observationCancellationSignal)
+            : signal;
+        let failureSeen = false;
+        while (Date.now() < deadline && !observationSignal.aborted) {
+            let outcome;
+            try {
+                outcome = await this.waitForOutcomeUntil(deadline, observationSignal);
+            }
+            catch (error) {
+                if (this.observationCancellationSignal?.aborted && !signal.aborted) {
+                    break;
+                }
+                throw error;
+            }
+            if (!outcome) {
+                break;
+            }
+            failureSeen = failureSeen || this.isFailedObservationOutcome(outcome);
+        }
+        this.shutdown = true;
+        await Promise.all([
+            this.sourceLoop,
+            this.destinationLoop,
+            this.timeoutLoop
+        ].filter(Boolean).map((value) => value.catch(() => { })));
+        await this.correlationRuntime.sweepTimeouts(Date.now() + this.correlationTimeoutMs + 1, this.timeoutBatchSize);
+        while (this.outcomeQueue.length > 0) {
+            const outcome = this.outcomeQueue.shift();
+            if (outcome) {
+                failureSeen = failureSeen || this.isFailedObservationOutcome(outcome);
+            }
+        }
+        return failureSeen
+            ? LoadStrikeResponse.fail("tracking_failures", "One or more observed source or destination events did not correlate successfully.", 0)
+            : LoadStrikeResponse.ok("observed");
+    }
     async consumeSourceLoop() {
         while (!this.shutdown) {
             try {
@@ -6151,6 +6230,34 @@ class ManagedScenarioTrackingRuntime {
             }
         }
     }
+    async waitForOutcomeUntil(deadlineMs, signal) {
+        const existing = this.outcomeQueue.shift();
+        if (existing) {
+            return existing;
+        }
+        const remainingMs = deadlineMs - Date.now();
+        if (remainingMs <= 0) {
+            return null;
+        }
+        const waiter = createManagedTrackingWaiter();
+        this.outcomeWaiters.push(waiter);
+        const timeout = sleep(remainingMs).then(() => null);
+        try {
+            return await Promise.race([waiter.promise, timeout, waitForAbort(signal)]);
+        }
+        finally {
+            const index = this.outcomeWaiters.indexOf(waiter);
+            if (index >= 0) {
+                this.outcomeWaiters.splice(index, 1);
+            }
+        }
+    }
+    isFailedObservationOutcome(outcome) {
+        if (outcome.status === "timeout") {
+            return this.timeoutCountsAsFailure;
+        }
+        return outcome.status !== "matched";
+    }
     rejectOutstandingWaiters() {
         for (const rows of this.waiters.values()) {
             for (const waiter of rows) {
@@ -6270,8 +6377,12 @@ function validateRuntimeTrackingConfiguration(tracking, sourceEndpoint, destinat
     if (!metricPrefix.trim()) {
         throw new Error("MetricPrefix must be provided.");
     }
+    const observationDurationMs = readObservationDurationMs(tracking);
     validateRuntimeRedisCorrelationStoreConfiguration(tracking);
     if (runMode === "generateandcorrelate") {
+        if (observationDurationMs > 0) {
+            throw new Error("ForDuration is only supported for CorrelateExistingTraffic.");
+        }
         if (sourceEndpoint.mode !== "Produce") {
             throw new Error("Source endpoint mode must be Produce for GenerateAndCorrelate mode.");
         }
@@ -6281,6 +6392,9 @@ function validateRuntimeTrackingConfiguration(tracking, sourceEndpoint, destinat
         return;
     }
     if (runMode === "correlateexistingtraffic") {
+        if (observationDurationMs <= 0) {
+            throw new Error("CorrelateExistingTraffic requires ForDuration with a duration greater than zero.");
+        }
         if (!destinationEndpoint) {
             throw new Error("Destination endpoint must be provided for CorrelateExistingTraffic mode.");
         }
@@ -6294,6 +6408,15 @@ function validateRuntimeTrackingConfiguration(tracking, sourceEndpoint, destinat
     }
     throw new RangeError(`Unsupported tracking run mode: ${runMode}.`);
 }
+function readObservationDurationMs(tracking) {
+    return pickTrackingNumber(tracking, ["ObservationDurationMs", "observationDurationMs"], pickTrackingNumber(tracking, ["ObservationDurationSeconds", "observationDurationSeconds", "ObservationDuration"], 0) * 1000);
+}
+function isCorrelateExistingTrafficTracking(configuration) {
+    if (!configuration) {
+        return false;
+    }
+    return normalizeTrackingRunMode(pickTrackingString(configuration, "RunMode", "runMode", "GenerateAndCorrelate")) === "correlateexistingtraffic";
+}
 function readUseLoadStrikeTraceIdHeader(tracking) {
     return pickTrackingBoolean(tracking, "UseLoadStrikeTraceIdHeader", "useLoadStrikeTraceIdHeader", false);
 }
@@ -6483,6 +6606,7 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
         nats: asTrackingRecord(pickTrackingValue(spec, "Nats", "nats")),
         redisStreams: asTrackingRecord(pickTrackingValue(spec, "RedisStreams", "redisStreams")),
         azureEventHubs: asTrackingRecord(pickTrackingValue(spec, "AzureEventHubs", "azureEventHubs")),
+        sqs: asTrackingRecord(pickTrackingValue(spec, "Sqs", "sqs")),
         pushDiffusion: asTrackingRecord(pickTrackingValue(spec, "PushDiffusion", "pushDiffusion")),
         delegate: typeof delegateProduce === "function"
             || typeof delegateConsume === "function"

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

@@ -69,6 +69,7 @@ export interface LoadStrikeTrackingConfigurationSpec {
     Source: LoadStrikeEndpointSpec;
     Destination?: LoadStrikeEndpointSpec;
     RunMode?: string;
+    ObservationDurationSeconds?: number;
     CorrelationTimeoutSeconds?: number;
     TimeoutSweepIntervalSeconds?: number;
     TimeoutBatchSize?: number;
@@ -107,6 +108,7 @@ export interface LoadStrikeEndpointSpec {
     Nats?: LoadStrikeNatsEndpointOptions;
     RedisStreams?: LoadStrikeRedisStreamsEndpointOptions;
     AzureEventHubs?: LoadStrikeAzureEventHubsEndpointOptions;
+    Sqs?: LoadStrikeSqsEndpointOptions;
     DelegateStream?: LoadStrikeDelegateEndpointOptions;
     PushDiffusion?: LoadStrikePushDiffusionEndpointOptions;
 }
@@ -202,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;