@loadstrike/loadstrike-sdk 1.0.22601 → 1.0.23001

package/dist/cjs/runtime.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__loadstrikeTestExports = exports.LoadStrikeRunner = exports.LoadStrikeScenario = exports.LoadStrikeContext = exports.ScenarioTrackingExtensions = exports.CrossPlatformScenarioConfigurator = exports.LoadStrikeThreshold = exports.LoadStrikeMetric = exports.LoadStrikeGauge = exports.LoadStrikeCounter = exports.LoadStrikeSimulation = exports.LoadStrikeStep = exports.LoadStrikeResponse = exports.LoadStrikePluginData = exports.LoadStrikePluginDataTable = exports.LoadStrikeOperationType = exports.LoadStrikeScenarioOperation = exports.LoadStrikeLogLevel = exports.LoadStrikeReportFormat = exports.LoadStrikeNodeType = void 0;
+exports.__loadstrikeTestExports = exports.LoadStrikeRunner = exports.LoadStrikeScenario = exports.LoadStrikeContext = exports.ScenarioTrackingExtensions = exports.CrossPlatformScenarioConfigurator = exports.LoadStrikeThreshold = exports.LoadStrikeMetric = exports.LoadStrikeGauge = exports.LoadStrikeCounter = exports.LoadStrikeSimulation = exports.LoadStrikeStep = exports.LoadStrikeResponse = exports.LoadStrikePluginData = exports.LoadStrikePluginDataTable = exports.CrossPlatformTrackingConfiguration = exports.LoadStrikeOperationType = exports.LoadStrikeScenarioOperation = exports.LoadStrikeLogLevel = exports.LoadStrikeReportFormat = exports.LoadStrikeNodeType = void 0;
 const node_fs_1 = require("node:fs");
 const node_crypto_1 = require("node:crypto");
 const node_os_1 = __importDefault(require("node:os"));
@@ -47,6 +47,33 @@ exports.LoadStrikeOperationType = {
     Complete: "Complete",
     Error: "Error"
 };
+exports.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);
+    }
+};
 class LoadStrikePluginDataTable {
     /**
      * Exposes the public constructor operation.
@@ -1730,6 +1757,9 @@ 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);
     }
     /**
@@ -1740,6 +1770,9 @@ 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);
     }
     /**
@@ -5741,6 +5774,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);
@@ -5881,8 +5922,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 {
@@ -5958,6 +5998,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 {
@@ -6171,6 +6250,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) {
@@ -6290,8 +6397,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.");
         }
@@ -6301,6 +6412,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.");
         }
@@ -6314,6 +6428,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);
 }
@@ -6503,6 +6626,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/cjs/transports.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__loadstrikeTestExports = exports.EndpointAdapterFactory = exports.KafkaSaslOptions = exports.HttpAuthOptions = exports.HttpOAuth2ClientCredentialsOptions = exports.PushDiffusionEndpointDefinition = exports.DelegateStreamEndpointDefinition = exports.AzureEventHubsEndpointDefinition = exports.RedisStreamsEndpointDefinition = exports.NatsEndpointDefinition = exports.RabbitMqEndpointDefinition = exports.KafkaEndpointDefinition = exports.HttpEndpointDefinition = exports.TrafficEndpointDefinition = exports.LOADSTRIKE_TRACE_ID_TRACKING_FIELD = exports.LOADSTRIKE_TRACE_ID_HEADER = void 0;
+exports.__loadstrikeTestExports = exports.EndpointAdapterFactory = exports.KafkaSaslOptions = exports.HttpAuthOptions = exports.HttpOAuth2ClientCredentialsOptions = exports.PushDiffusionEndpointDefinition = exports.DelegateStreamEndpointDefinition = exports.SqsEndpointDefinition = exports.AzureEventHubsEndpointDefinition = exports.RedisStreamsEndpointDefinition = exports.NatsEndpointDefinition = exports.RabbitMqEndpointDefinition = exports.KafkaEndpointDefinition = exports.HttpEndpointDefinition = exports.TrafficEndpointDefinition = exports.LOADSTRIKE_TRACE_ID_TRACKING_FIELD = exports.LOADSTRIKE_TRACE_ID_HEADER = void 0;
 const node_crypto_1 = require("node:crypto");
 const correlation_js_1 = require("./correlation.js");
 exports.LOADSTRIKE_TRACE_ID_HEADER = "loadstrike-trace-id";
@@ -254,6 +254,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);
@@ -299,6 +328,7 @@ exports.RabbitMqEndpointDefinition = RabbitMqEndpointDefinitionModel;
 exports.NatsEndpointDefinition = NatsEndpointDefinitionModel;
 exports.RedisStreamsEndpointDefinition = RedisStreamsEndpointDefinitionModel;
 exports.AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinitionModel;
+exports.SqsEndpointDefinition = SqsEndpointDefinitionModel;
 exports.DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 exports.PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
 exports.HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
@@ -662,6 +692,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");
@@ -798,6 +866,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();
     }
@@ -812,6 +881,7 @@ const protocolBus = new class InMemoryProtocolBus {
         this.redisCounters.clear();
         this.eventHubs.clear();
         this.eventHubOffsets.clear();
+        this.sqsQueues.clear();
         this.pushTopics.clear();
         this.pushOffsets.clear();
     }
@@ -976,6 +1046,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")
@@ -1717,6 +1806,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 Promise.resolve().then(() => __importStar(require("@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 Promise.resolve().then(() => __importStar(require("@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 Promise.resolve().then(() => __importStar(require("@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);
@@ -1747,6 +1934,8 @@ 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":
@@ -1875,6 +2064,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",
@@ -1935,6 +2146,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))
     };
@@ -1992,6 +2204,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",
@@ -2273,6 +2501,9 @@ function validateEndpointDefinition(endpoint) {
         case "AzureEventHubs":
             validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate);
             return;
+        case "Sqs":
+            validateSqsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
         case "PushDiffusion":
             validatePushDiffusionEndpoint(endpoint, mode);
             return;
@@ -2494,6 +2725,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") {
@@ -2858,6 +3115,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];
@@ -3741,6 +4004,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);
@@ -3775,6 +4061,9 @@ exports.__loadstrikeTestExports = {
     RedisStreamsEndpointAdapter,
     RedisStreamsEndpointDefinition: exports.RedisStreamsEndpointDefinition,
     RedisStreamsEndpointDefinitionModel,
+    SqsEndpointAdapter,
+    SqsEndpointDefinition: exports.SqsEndpointDefinition,
+    SqsEndpointDefinitionModel,
     bufferToUint8Array,
     applyHttpAuthHeaders,
     buildHttpRequestBody,
@@ -3809,6 +4098,11 @@ exports.__loadstrikeTestExports = {
     shouldUseConfluentKafkaClient,
     toHeaderRecord,
     toKafkaHeadersWithContentType,
+    toSqsMessageAttributes,
+    fromSqsMessageAttributes,
+    setSqsClientFactoryForTests: (factory) => {
+        sqsClientFactoryForTests = factory;
+    },
     validateHttpEndpoint,
     validateTrackingSelectorPath
 };