@loadstrike/loadstrike-sdk 1.0.27101 → 1.0.29201

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.WebSocketEndpointDefinition = exports.GrpcEndpointDefinition = 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;
+exports.__loadstrikeTestExports = exports.EndpointAdapterFactory = exports.KafkaSaslOptions = exports.HttpAuthOptions = exports.HttpOAuth2ClientCredentialsOptions = exports.WebSocketEndpointDefinition = exports.GrpcEndpointDefinition = exports.PushDiffusionEndpointDefinition = exports.DelegateStreamEndpointDefinition = exports.SqsEndpointDefinition = exports.AzureEventHubsEndpointDefinition = exports.RedisStreamsEndpointDefinition = exports.NatsEndpointDefinition = exports.RabbitMqEndpointDefinition = exports.KafkaEndpointDefinition = exports.HttpEndpointDefinition = exports.TrafficEndpointDefinition = exports.WebSocketNativeClientOptions = exports.WebSocketExpectedMessage = exports.WebSocketMessageSpec = exports.WebSocketReconnectPolicy = exports.ProtocolMetricSnapshot = exports.GrpcStatusMapper = exports.GrpcNativeClientOptions = exports.GrpcMethodTypes = 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";
@@ -321,6 +321,129 @@ class PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefinitionMode
         }
     }
 }
+exports.GrpcMethodTypes = {
+    Unary: "Unary",
+    ServerStreaming: "ServerStreaming",
+    ClientStreaming: "ClientStreaming",
+    BidirectionalStreaming: "BidirectionalStreaming"
+};
+class GrpcNativeClientOptions {
+    constructor(initial = {}) {
+        this.UseReflection = false;
+        this.UseTls = true;
+        this.AllowUntrustedCertificates = false;
+        this.DeadlineSeconds = 30;
+        this.Metadata = {};
+        this.RequestPayloadJsonStream = [];
+        const raw = asRecordOrEmpty(initial);
+        this.ProtoFilePath = pickOptionalEndpointString(raw, "ProtoFilePath", "protoFilePath");
+        this.DescriptorSetPath = pickOptionalEndpointString(raw, "DescriptorSetPath", "descriptorSetPath");
+        this.UseReflection = pickEndpointBoolean(raw, "UseReflection", "useReflection") ?? false;
+        this.UseTls = pickEndpointBoolean(raw, "UseTls", "useTls") ?? true;
+        this.AllowUntrustedCertificates = pickEndpointBoolean(raw, "AllowUntrustedCertificates", "allowUntrustedCertificates") ?? false;
+        const deadlineMs = pickOptionalEndpointNumber(raw, "DeadlineMs", "deadlineMs");
+        const deadlineSeconds = pickOptionalEndpointNumber(raw, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+        this.DeadlineSeconds = deadlineMs != null ? deadlineMs / 1000 : (deadlineSeconds ?? 30);
+        this.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
+        this.RequestPayloadJson = pickOptionalEndpointString(raw, "RequestPayloadJson", "requestPayloadJson");
+        this.RequestPayloadJsonStream = pickEndpointStringArray(raw, "RequestPayloadJsonStream", "requestPayloadJsonStream") ?? [];
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.DeadlineSeconds <= 0) {
+            throw new RangeError("Deadline must be greater than zero.");
+        }
+    }
+}
+exports.GrpcNativeClientOptions = GrpcNativeClientOptions;
+exports.GrpcStatusMapper = {
+    fromStatusCode(statusCode) {
+        const names = {
+            0: "OK",
+            1: "CANCELLED",
+            2: "UNKNOWN",
+            3: "INVALID_ARGUMENT",
+            4: "DEADLINE_EXCEEDED",
+            5: "NOT_FOUND",
+            6: "ALREADY_EXISTS",
+            7: "PERMISSION_DENIED",
+            8: "RESOURCE_EXHAUSTED",
+            9: "FAILED_PRECONDITION",
+            10: "ABORTED",
+            11: "OUT_OF_RANGE",
+            12: "UNIMPLEMENTED",
+            13: "INTERNAL",
+            14: "UNAVAILABLE",
+            15: "DATA_LOSS",
+            16: "UNAUTHENTICATED"
+        };
+        const normalized = Number.isFinite(statusCode) ? Math.trunc(statusCode) : 2;
+        const statusName = names[normalized] ?? "UNKNOWN";
+        return {
+            statusCode: normalized,
+            StatusCode: normalized,
+            statusName,
+            StatusName: statusName,
+            isSuccess: normalized === 0,
+            IsSuccess: normalized === 0
+        };
+    },
+    FromStatusCode(statusCode) {
+        return this.fromStatusCode(statusCode);
+    }
+};
+class ProtocolMetricSnapshot {
+    constructor(initial = {}) {
+        this.protocol = "";
+        this.Protocol = "";
+        this.requests = 0;
+        this.Requests = 0;
+        this.messagesSent = 0;
+        this.MessagesSent = 0;
+        this.messagesReceived = 0;
+        this.MessagesReceived = 0;
+        this.latencyMs = 0;
+        this.LatencyMs = 0;
+        this.streamDurationMs = 0;
+        this.StreamDurationMs = 0;
+        this.bytesSent = 0;
+        this.BytesSent = 0;
+        this.bytesReceived = 0;
+        this.BytesReceived = 0;
+        this.reconnects = 0;
+        this.Reconnects = 0;
+        this.errors = 0;
+        this.Errors = 0;
+        this.status = "";
+        this.Status = "";
+        const raw = asRecordOrEmpty(initial);
+        this.protocol = pickOptionalEndpointString(raw, "protocol", "Protocol") ?? "";
+        this.Protocol = this.protocol;
+        this.requests = pickOptionalEndpointNumber(raw, "requests", "Requests") ?? 0;
+        this.Requests = this.requests;
+        this.messagesSent = pickOptionalEndpointNumber(raw, "messagesSent", "MessagesSent") ?? 0;
+        this.MessagesSent = this.messagesSent;
+        this.messagesReceived = pickOptionalEndpointNumber(raw, "messagesReceived", "MessagesReceived") ?? 0;
+        this.MessagesReceived = this.messagesReceived;
+        this.latencyMs = pickOptionalEndpointNumber(raw, "latencyMs", "LatencyMs") ?? 0;
+        this.LatencyMs = this.latencyMs;
+        this.streamDurationMs = pickOptionalEndpointNumber(raw, "streamDurationMs", "StreamDurationMs") ?? 0;
+        this.StreamDurationMs = this.streamDurationMs;
+        this.bytesSent = pickOptionalEndpointNumber(raw, "bytesSent", "BytesSent") ?? 0;
+        this.BytesSent = this.bytesSent;
+        this.bytesReceived = pickOptionalEndpointNumber(raw, "bytesReceived", "BytesReceived") ?? 0;
+        this.BytesReceived = this.bytesReceived;
+        this.reconnects = pickOptionalEndpointNumber(raw, "reconnects", "Reconnects") ?? 0;
+        this.Reconnects = this.reconnects;
+        this.errors = pickOptionalEndpointNumber(raw, "errors", "Errors") ?? 0;
+        this.Errors = this.errors;
+        this.status = pickOptionalEndpointString(raw, "status", "Status") ?? "";
+        this.Status = this.status;
+    }
+}
+exports.ProtocolMetricSnapshot = ProtocolMetricSnapshot;
 class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -343,14 +466,159 @@ class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         if (this.DeadlineSeconds <= 0) {
             throw new RangeError("Deadline must be greater than zero.");
         }
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+        this.NativeClient?.validate();
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
 }
+class WebSocketReconnectPolicy {
+    constructor(initial = {}) {
+        this.MaxAttempts = 0;
+        this.maxAttempts = 0;
+        this.DelaySeconds = 1;
+        this.delaySeconds = 1;
+        const raw = asRecordOrEmpty(initial);
+        this.MaxAttempts = Math.trunc(pickOptionalEndpointNumber(raw, "MaxAttempts", "maxAttempts") ?? 0);
+        this.maxAttempts = this.MaxAttempts;
+        const delayMs = pickOptionalEndpointNumber(raw, "DelayMs", "delayMs");
+        this.DelaySeconds = delayMs != null
+            ? delayMs / 1000
+            : (pickOptionalEndpointNumber(raw, "DelaySeconds", "delaySeconds", "Delay", "delay") ?? 1);
+        this.delaySeconds = this.DelaySeconds;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.MaxAttempts < 0) {
+            throw new RangeError("MaxAttempts cannot be negative.");
+        }
+        if (this.DelaySeconds < 0) {
+            throw new RangeError("Delay cannot be negative.");
+        }
+    }
+}
+exports.WebSocketReconnectPolicy = WebSocketReconnectPolicy;
+class WebSocketMessageSpec {
+    constructor(initial = {}) {
+        this.Kind = "Text";
+        this.kind = "Text";
+        const raw = asRecordOrEmpty(initial);
+        this.Kind = pickOptionalEndpointString(raw, "Kind", "kind") ?? "Text";
+        this.kind = this.Kind;
+        this.TextPayload = pickOptionalEndpointString(raw, "TextPayload", "textPayload");
+        this.textPayload = this.TextPayload;
+        const binary = pickEndpointValue(raw, "BinaryPayload", "binaryPayload");
+        if (binary instanceof Uint8Array) {
+            this.BinaryPayload = binary;
+        }
+        else if (Array.isArray(binary)) {
+            this.BinaryPayload = Uint8Array.from(binary.map((value) => Number(value) & 0xff));
+        }
+        this.binaryPayload = this.BinaryPayload;
+    }
+    static Text(payload) {
+        return new WebSocketMessageSpec({ Kind: "Text", TextPayload: payload });
+    }
+    static Binary(payload) {
+        return new WebSocketMessageSpec({ Kind: "Binary", BinaryPayload: payload });
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.Kind.toLowerCase() === "text" && this.TextPayload == null) {
+            throw new Error("Text WebSocket messages require TextPayload.");
+        }
+        if (this.Kind.toLowerCase() === "binary" && this.BinaryPayload == null) {
+            throw new Error("Binary WebSocket messages require BinaryPayload.");
+        }
+    }
+}
+exports.WebSocketMessageSpec = WebSocketMessageSpec;
+class WebSocketExpectedMessage {
+    constructor(initial = {}) {
+        this.TimeoutSeconds = 30;
+        this.timeoutSeconds = 30;
+        const raw = asRecordOrEmpty(initial);
+        this.ContainsText = pickOptionalEndpointString(raw, "ContainsText", "containsText");
+        this.containsText = this.ContainsText;
+        const bytes = pickEndpointValue(raw, "ContainsBytes", "containsBytes");
+        if (bytes instanceof Uint8Array) {
+            this.ContainsBytes = bytes;
+        }
+        else if (Array.isArray(bytes)) {
+            this.ContainsBytes = Uint8Array.from(bytes.map((value) => Number(value) & 0xff));
+        }
+        this.containsBytes = this.ContainsBytes;
+        const timeoutMs = pickOptionalEndpointNumber(raw, "TimeoutMs", "timeoutMs");
+        this.TimeoutSeconds = timeoutMs != null
+            ? timeoutMs / 1000
+            : (pickOptionalEndpointNumber(raw, "TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout") ?? 30);
+        this.timeoutSeconds = this.TimeoutSeconds;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.TimeoutSeconds <= 0) {
+            throw new RangeError("Timeout must be greater than zero.");
+        }
+    }
+}
+exports.WebSocketExpectedMessage = WebSocketExpectedMessage;
+class WebSocketNativeClientOptions {
+    constructor(initial = {}) {
+        this.Headers = {};
+        this.headers = {};
+        this.Cookies = [];
+        this.cookies = [];
+        this.Reconnect = new WebSocketReconnectPolicy();
+        this.reconnect = this.Reconnect;
+        this.Messages = [];
+        this.messages = [];
+        this.ExpectedMessages = [];
+        this.expectedMessages = [];
+        const raw = asRecordOrEmpty(initial);
+        this.Headers = pickEndpointStringRecord(raw, "Headers", "headers");
+        this.headers = this.Headers;
+        this.Cookies = pickEndpointStringArray(raw, "Cookies", "cookies") ?? [];
+        this.cookies = this.Cookies;
+        const pingMs = pickOptionalEndpointNumber(raw, "PingIntervalMs", "pingIntervalMs");
+        const pingSeconds = pickOptionalEndpointNumber(raw, "PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval");
+        this.PingIntervalSeconds = pingMs != null ? pingMs / 1000 : pingSeconds;
+        this.pingIntervalSeconds = this.PingIntervalSeconds;
+        const reconnect = pickEndpointValue(raw, "Reconnect", "reconnect");
+        this.Reconnect = reconnect instanceof WebSocketReconnectPolicy
+            ? reconnect
+            : new WebSocketReconnectPolicy(asRecordOrEmpty(reconnect));
+        this.reconnect = this.Reconnect;
+        this.Messages = normalizeWebSocketMessages(pickEndpointValue(raw, "Messages", "messages"));
+        this.messages = this.Messages;
+        this.ExpectedMessages = normalizeWebSocketExpectedMessages(pickEndpointValue(raw, "ExpectedMessages", "expectedMessages"));
+        this.expectedMessages = this.ExpectedMessages;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.PingIntervalSeconds != null && this.PingIntervalSeconds <= 0) {
+            throw new RangeError("PingInterval must be greater than zero.");
+        }
+        this.Reconnect.validate();
+        for (const message of this.Messages) {
+            message.validate();
+        }
+        for (const expected of this.ExpectedMessages) {
+            expected.validate();
+        }
+    }
+}
+exports.WebSocketNativeClientOptions = WebSocketNativeClientOptions;
 class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -381,10 +649,11 @@ class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         if (this.CloseTimeoutSeconds <= 0) {
             throw new RangeError("CloseTimeout must be greater than zero.");
         }
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+        this.NativeClient?.validate();
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
@@ -898,6 +1167,12 @@ function initializeGrpcEndpointDefinitionModel(target, initial) {
     if (hasAnyEndpointField(raw, ["Metadata", "metadata"])) {
         target.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
     }
+    if (hasAnyEndpointField(raw, ["NativeClient", "nativeClient"])) {
+        const nativeClient = pickEndpointValue(raw, "NativeClient", "nativeClient");
+        target.NativeClient = nativeClient instanceof GrpcNativeClientOptions
+            ? nativeClient
+            : new GrpcNativeClientOptions(asRecordOrEmpty(nativeClient));
+    }
 }
 function initializeWebSocketEndpointDefinitionModel(target, initial) {
     const raw = asRecordOrEmpty(initial);
@@ -944,6 +1219,12 @@ function initializeWebSocketEndpointDefinitionModel(target, initial) {
     if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
         target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
     }
+    if (hasAnyEndpointField(raw, ["NativeClient", "nativeClient"])) {
+        const nativeClient = pickEndpointValue(raw, "NativeClient", "nativeClient");
+        target.NativeClient = nativeClient instanceof WebSocketNativeClientOptions
+            ? nativeClient
+            : new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient));
+    }
 }
 function validateTrafficEndpointDefinitionModel(target) {
     requireNonEmptyString(target.Name, "Endpoint name must be provided.");
@@ -2285,7 +2566,9 @@ const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
     "ConsumeAsync",
     "consumeAsync",
     "ConnectionMetadata",
-    "connectionMetadata"
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
 ];
 const GRPC_ENDPOINT_FLAT_KEYS = [
     "Target",
@@ -2313,7 +2596,9 @@ const GRPC_ENDPOINT_FLAT_KEYS = [
     "ConsumeAsync",
     "consumeAsync",
     "ConnectionMetadata",
-    "connectionMetadata"
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
 ];
 const WEB_SOCKET_ENDPOINT_FLAT_KEYS = [
     "Url",
@@ -2473,7 +2758,9 @@ function resolveEndpointKind(raw) {
         "MethodName",
         "methodName",
         "MethodType",
-        "methodType"
+        "methodType",
+        "NativeClient",
+        "nativeClient"
     ])) {
         return "Grpc";
     }
@@ -2483,7 +2770,9 @@ function resolveEndpointKind(raw) {
         "ConnectTimeoutSeconds",
         "connectTimeoutSeconds",
         "CloseTimeoutSeconds",
-        "closeTimeoutSeconds"
+        "closeTimeoutSeconds",
+        "NativeClient",
+        "nativeClient"
     ])) {
         return "WebSocket";
     }
@@ -2617,6 +2906,22 @@ function normalizeDelegateEndpointOptions(options) {
 function normalizeProtocolOptions(options) {
     return Object.keys(options).length ? options : undefined;
 }
+function normalizeWebSocketMessages(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => entry instanceof WebSocketMessageSpec
+        ? entry
+        : new WebSocketMessageSpec(asRecordOrEmpty(entry)));
+}
+function normalizeWebSocketExpectedMessages(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => entry instanceof WebSocketExpectedMessage
+        ? entry
+        : new WebSocketExpectedMessage(asRecordOrEmpty(entry)));
+}
 function pickEndpointValue(record, ...keys) {
     return pickProtocolValue(record, ...keys);
 }
@@ -2854,10 +3159,14 @@ function validateGrpcEndpoint(endpoint, mode) {
         || (hasOptionValue(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline") && deadlineSeconds <= 0)) {
         throw new RangeError("Deadline must be greater than zero.");
     }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null) {
+        new GrpcNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
@@ -2886,10 +3195,14 @@ function validateWebSocketEndpoint(endpoint, mode) {
         || (hasOptionValue(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout") && closeSeconds <= 0)) {
         throw new RangeError("CloseTimeout must be greater than zero.");
     }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null) {
+        new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
-export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikeAccessibility, LoadStrikeBrowserWebVitals, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
+export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikeAccessibility, LoadStrikeAccessibilityAdapters, LoadStrikeAccessibilityBaseline, LoadStrikeAccessibilityCiGate, LoadStrikeAccessibilityScanner, LoadStrikeBrowserWebVitals, LoadStrikeBrowserWebVitalsCollector, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
-export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, WebSocketEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
-export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
+export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, GrpcMethodTypes, GrpcNativeClientOptions, GrpcStatusMapper, ProtocolMetricSnapshot, WebSocketEndpointDefinition, WebSocketExpectedMessage, WebSocketMessageSpec, WebSocketNativeClientOptions, WebSocketReconnectPolicy, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
+export { DatadogReportingSink, DatadogReportingSinkOptions, DogStatsDReportingSink, CloudWatchReportingSink, DynatraceReportingSink, ElasticsearchReportingSink, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, GenericWebhookReportingSink, InfluxDbReportingSink, InfluxDbReportingSinkOptions, JsonlFileReportingSink, KafkaReportingSink, NetdataStatsDReportingSink, NewRelicReportingSink, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, OpenSearchReportingSink, PortalReportingSink, PrometheusRemoteWriteReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, StatsDReportingSink, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";

package/dist/esm/local.js

@@ -168,7 +168,9 @@ export class LoadStrikeLocalClient {
             NodeType: stringOrDefault(context.NodeType, nodeType),
             MachineName: machineName,
             EnvironmentClassification: environmentClassification,
-            DeviceHash: computedDeviceHash
+            DeviceHash: computedDeviceHash,
+            Scenarios: buildLicenseScenarioMetadata(request),
+            ScenarioSourceAnalysis: buildScenarioSourceAnalysisMetadata(request)
         };
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
@@ -1538,6 +1540,74 @@ function computeScenarioRequestCount(scenario) {
     }
     return Math.max(total, 0);
 }
+function buildLicenseScenarioMetadata(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    return scenarios.map((item) => {
+        const scenario = asRecord(item);
+        const scenarioName = stringOrDefault(scenario.ScenarioName ?? scenario.scenarioName ?? scenario.Name ?? scenario.name, "");
+        return {
+            Name: scenarioName,
+            ScenarioName: scenarioName,
+            Simulations: normalizeLicenseSimulations(scenario.LoadSimulations)
+        };
+    });
+}
+function normalizeLicenseSimulations(value) {
+    const simulations = Array.isArray(value) ? value : [];
+    return simulations.map((item) => {
+        const simulation = asRecord(item);
+        return {
+            Kind: stringOrDefault(simulation.Kind ?? simulation.kind, ""),
+            Rate: positiveOrUndefined(simulation.Rate ?? simulation.rate),
+            MinRate: positiveOrUndefined(simulation.MinRate ?? simulation.minRate),
+            MaxRate: positiveOrUndefined(simulation.MaxRate ?? simulation.maxRate),
+            Copies: positiveOrUndefined(simulation.Copies ?? simulation.copies),
+            Iterations: positiveOrUndefined(simulation.Iterations ?? simulation.iterations),
+            IntervalSeconds: positiveNumberOrUndefined(simulation.IntervalSeconds ?? simulation.intervalSeconds),
+            DurationSeconds: positiveNumberOrUndefined(simulation.DurationSeconds ?? simulation.durationSeconds ?? simulation.DuringSeconds ?? simulation.duringSeconds),
+            Children: normalizeLicenseSimulations(simulation.Children ?? simulation.children)
+        };
+    });
+}
+function buildScenarioSourceAnalysisMetadata(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    return scenarios.map((item) => {
+        const scenario = asRecord(item);
+        const source = asRecord(scenario.ScenarioSourceAnalysis ?? scenario.scenarioSourceAnalysis ?? scenario.SourceAnalysis);
+        const scenarioName = stringOrDefault(source.ScenarioName ?? source.scenarioName ?? scenario.Name ?? scenario.name, "");
+        const scenarioBlockLineCount = Math.max(asInt(source.ScenarioBlockLineCount ?? source.scenarioBlockLineCount), 1);
+        const localMethodLineCount = Math.max(asInt(source.LocalMethodLineCount
+            ?? source.localMethodLineCount
+            ?? source.TransitiveLocalMethodLineCount
+            ?? source.transitiveLocalMethodLineCount), 0);
+        const totalCountedLineCount = Math.max(asInt(source.TotalCountedLineCount ?? source.totalCountedLineCount), scenarioBlockLineCount + localMethodLineCount);
+        const warningsValue = source.Warnings ?? source.warnings;
+        const warnings = Array.isArray(warningsValue)
+            ? warningsValue.map((warning) => stringOrDefault(warning, "")).filter((warning) => warning.length > 0)
+            : ["Scenario source analysis was synthesized from scenario metadata."];
+        return {
+            ScenarioName: scenarioName,
+            Language: stringOrDefault(source.Language ?? source.language, "TypeScript/JavaScript"),
+            AnalyzerVersion: stringOrDefault(source.AnalyzerVersion ?? source.analyzerVersion, "function-source-v1"),
+            ScenarioBlockLineCount: scenarioBlockLineCount,
+            LocalMethodLineCount: localMethodLineCount,
+            TotalCountedLineCount: totalCountedLineCount,
+            IgnoredExternalCallCount: Math.max(asInt(source.IgnoredExternalCallCount
+                ?? source.ignoredExternalCallCount
+                ?? source.IgnoredLibraryCallCount
+                ?? source.ignoredLibraryCallCount), 0),
+            Warnings: warnings
+        };
+    });
+}
+function positiveOrUndefined(value) {
+    const normalized = asInt(value);
+    return normalized > 0 ? normalized : undefined;
+}
+function positiveNumberOrUndefined(value) {
+    const normalized = asNumber(value);
+    return normalized > 0 ? normalized : undefined;
+}
 function buildNodeStatsContract(context, createdUtc, completedUtc, values) {
     const durationMs = Math.max(completedUtc.getTime() - createdUtc.getTime(), 0);
     return {