@loadstrike/loadstrike-sdk 1.0.22801 → 1.0.23001

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
 };

package/dist/esm/autopilot.js

@@ -12,11 +12,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LoadStrikeAutopilotResult_httpRequest;
 import fs from "node:fs";
 import { LoadStrikeResponse, LoadStrikeScenario, LoadStrikeSimulation, LoadStrikeThreshold } from "./runtime.js";
+import { LoadStrikeLocalClient } from "./local.js";
 import { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
 const REDACTED = "[REDACTED]";
 const ENV_MARKER_PREFIX = "${LOADSTRIKE_ENV:";
 const ENV_MARKER_SUFFIX = "}";
 const TRACE_TO_TEST_AUTOPILOT_FEATURE = "autopilot.trace_to_test";
+let autopilotLicenseValidationBypassForTests = false;
 const SECRET_KEYS = new Set([
     "authorization",
     "proxy_authorization",
@@ -88,9 +90,10 @@ export class LoadStrikeAutopilotResult {
 }
 _LoadStrikeAutopilotResult_httpRequest = new WeakMap();
 export class LoadStrikeAutopilot {
-    static generate(request) {
+    static async generate(request) {
         const artifact = loadAutopilotArtifact(request);
         const options = request.Options ?? {};
+        await validateGenerationEntitlement(options);
         const result = inferAutopilotResult(artifact, options);
         if (options.IncludePreviewReport) {
             result.PreviewReport = buildPreviewReport(result);
@@ -101,6 +104,57 @@ export class LoadStrikeAutopilot {
         return LoadStrikeAutopilot.generate(request);
     }
 }
+export const __private = {
+    setAutopilotLicenseValidationBypassForTests(value) {
+        autopilotLicenseValidationBypassForTests = value;
+    }
+};
+async function validateGenerationEntitlement(options) {
+    if (autopilotLicenseValidationBypassForTests) {
+        return;
+    }
+    const licensePayload = {
+        Context: {
+            RunnerKey: options.RunnerKey ?? "",
+            LicenseValidationTimeoutSeconds: options.LicenseValidationTimeoutSeconds,
+            TestSuite: "loadstrike-autopilot",
+            TestName: options.ScenarioName?.trim() || "autopilot-generation"
+        },
+        Scenarios: [
+            {
+                Name: "autopilot-generation",
+                InternalLicenseFeatures: [TRACE_TO_TEST_AUTOPILOT_FEATURE]
+            }
+        ],
+        RunArgs: []
+    };
+    const client = new LoadStrikeLocalClient({
+        licenseValidationTimeoutMs: normalizeLicenseValidationTimeoutMs(options.LicenseValidationTimeoutSeconds)
+    });
+    let session;
+    try {
+        session = await client.acquireLicenseLease(licensePayload);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.toLowerCase().includes("runner key is required")) {
+            throw new Error("Runner key is required for Trace-To-Test Autopilot generation. " +
+                "Set Options.RunnerKey before calling LoadStrikeAutopilot.generate(...).");
+        }
+        throw error;
+    }
+    finally {
+        if (session) {
+            await client.releaseLicenseLease(session, licensePayload);
+        }
+    }
+}
+function normalizeLicenseValidationTimeoutMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return Math.trunc(value * 1000);
+}
 function loadAutopilotArtifact(request) {
     if (!request || typeof request.Kind !== "string" || !request.Kind.trim()) {
         throw new Error("Autopilot kind must be provided.");

package/dist/esm/index.js

@@ -2,5 +2,5 @@ export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
 export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } 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 { 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 { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";