@loadstrike/loadstrike-sdk 1.0.26701 → 1.0.27101

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.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.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,74 @@ class PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefinitionMode
         }
     }
 }
+class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Grpc";
+        this.Target = "";
+        this.ServiceName = "";
+        this.MethodName = "";
+        this.MethodType = "Unary";
+        this.DeadlineSeconds = 30;
+        this.ConnectionMetadata = {};
+        this.Metadata = {};
+        initializeGrpcEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.Target, "Target must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.ServiceName, "ServiceName must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.MethodName, "MethodName must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.MethodType, "MethodType must be provided for gRPC endpoint definitions.");
+        if (this.DeadlineSeconds <= 0) {
+            throw new RangeError("Deadline must be greater than zero.");
+        }
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+            throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+        }
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+            throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+        }
+    }
+}
+class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "WebSocket";
+        this.Url = "";
+        this.Subprotocols = [];
+        this.ConnectTimeoutSeconds = 30;
+        this.CloseTimeoutSeconds = 5;
+        this.ConnectionMetadata = {};
+        initializeWebSocketEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        const url = requireNonEmptyString(this.Url, "Url must be provided for WebSocket endpoint definitions.");
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        }
+        if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        }
+        if (this.ConnectTimeoutSeconds <= 0) {
+            throw new RangeError("ConnectTimeout must be greater than zero.");
+        }
+        if (this.CloseTimeoutSeconds <= 0) {
+            throw new RangeError("CloseTimeout must be greater than zero.");
+        }
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+            throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+        }
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+            throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+        }
+    }
+}
 exports.TrafficEndpointDefinition = TrafficEndpointDefinitionModel;
 exports.HttpEndpointDefinition = HttpEndpointDefinitionModel;
 exports.KafkaEndpointDefinition = KafkaEndpointDefinitionModel;
@@ -331,6 +399,8 @@ exports.AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinitionModel
 exports.SqsEndpointDefinition = SqsEndpointDefinitionModel;
 exports.DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 exports.PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
+exports.GrpcEndpointDefinition = GrpcEndpointDefinitionModel;
+exports.WebSocketEndpointDefinition = WebSocketEndpointDefinitionModel;
 exports.HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
 exports.HttpAuthOptions = HttpAuthOptionsModel;
 exports.KafkaSaslOptions = KafkaSaslOptionsModel;
@@ -780,6 +850,101 @@ function initializePushDiffusionEndpointDefinitionModel(target, initial) {
         target.SubscribeAsync = subscribeAsync;
     }
 }
+function initializeGrpcEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const targetUrl = pickOptionalEndpointString(raw, "Target", "target");
+    if (targetUrl) {
+        target.Target = targetUrl;
+    }
+    const serviceName = pickOptionalEndpointString(raw, "ServiceName", "serviceName");
+    if (serviceName) {
+        target.ServiceName = serviceName;
+    }
+    const methodName = pickOptionalEndpointString(raw, "MethodName", "methodName");
+    if (methodName) {
+        target.MethodName = methodName;
+    }
+    const methodType = pickOptionalEndpointString(raw, "MethodType", "methodType");
+    if (methodType) {
+        target.MethodType = methodType;
+    }
+    const deadlineMs = pickOptionalEndpointNumber(raw, "DeadlineMs", "deadlineMs");
+    const deadlineSeconds = pickOptionalEndpointNumber(raw, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+    if (deadlineMs != null) {
+        target.DeadlineSeconds = deadlineMs / 1000;
+    }
+    else if (deadlineSeconds != null) {
+        target.DeadlineSeconds = deadlineSeconds;
+    }
+    const produce = pickEndpointFunction(raw, "Produce", "produce");
+    if (produce) {
+        target.Produce = produce;
+    }
+    const consume = pickEndpointFunction(raw, "Consume", "consume");
+    if (consume) {
+        target.Consume = consume;
+    }
+    const produceAsync = pickEndpointFunction(raw, "ProduceAsync", "produceAsync");
+    if (produceAsync) {
+        target.ProduceAsync = produceAsync;
+    }
+    const consumeAsync = pickEndpointFunction(raw, "ConsumeAsync", "consumeAsync");
+    if (consumeAsync) {
+        target.ConsumeAsync = consumeAsync;
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
+        target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
+    }
+    if (hasAnyEndpointField(raw, ["Metadata", "metadata"])) {
+        target.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
+    }
+}
+function initializeWebSocketEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const url = pickOptionalEndpointString(raw, "Url", "url");
+    if (url) {
+        target.Url = url;
+    }
+    const subprotocols = pickEndpointStringArray(raw, "Subprotocols", "subprotocols");
+    if (subprotocols) {
+        target.Subprotocols = subprotocols;
+    }
+    const connectMs = pickOptionalEndpointNumber(raw, "ConnectTimeoutMs", "connectTimeoutMs");
+    const connectSeconds = pickOptionalEndpointNumber(raw, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
+    if (connectMs != null) {
+        target.ConnectTimeoutSeconds = connectMs / 1000;
+    }
+    else if (connectSeconds != null) {
+        target.ConnectTimeoutSeconds = connectSeconds;
+    }
+    const closeMs = pickOptionalEndpointNumber(raw, "CloseTimeoutMs", "closeTimeoutMs");
+    const closeSeconds = pickOptionalEndpointNumber(raw, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
+    if (closeMs != null) {
+        target.CloseTimeoutSeconds = closeMs / 1000;
+    }
+    else if (closeSeconds != null) {
+        target.CloseTimeoutSeconds = closeSeconds;
+    }
+    const produce = pickEndpointFunction(raw, "Produce", "produce");
+    if (produce) {
+        target.Produce = produce;
+    }
+    const consume = pickEndpointFunction(raw, "Consume", "consume");
+    if (consume) {
+        target.Consume = consume;
+    }
+    const produceAsync = pickEndpointFunction(raw, "ProduceAsync", "produceAsync");
+    if (produceAsync) {
+        target.ProduceAsync = produceAsync;
+    }
+    const consumeAsync = pickEndpointFunction(raw, "ConsumeAsync", "consumeAsync");
+    if (consumeAsync) {
+        target.ConsumeAsync = consumeAsync;
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
+        target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
+    }
+}
 function validateTrafficEndpointDefinitionModel(target) {
     requireNonEmptyString(target.Name, "Endpoint name must be provided.");
     if (target.Mode !== "Produce" && target.Mode !== "Consume") {
@@ -1914,6 +2079,10 @@ class PushDiffusionEndpointAdapter extends CallbackAdapter {
 }
 class DelegateStreamEndpointAdapter extends CallbackAdapter {
 }
+class GrpcEndpointAdapter extends CallbackAdapter {
+}
+class WebSocketEndpointAdapter extends CallbackAdapter {
+}
 class EndpointAdapterFactory {
     static create(endpoint) {
         if (endpoint instanceof TrafficEndpointDefinitionModel) {
@@ -1940,6 +2109,10 @@ class EndpointAdapterFactory {
                 return new PushDiffusionEndpointAdapter(normalized);
             case "DelegateStream":
                 return new DelegateStreamEndpointAdapter(normalized);
+            case "Grpc":
+                return new GrpcEndpointAdapter(normalized);
+            case "WebSocket":
+                return new WebSocketEndpointAdapter(normalized);
             default:
                 throw new Error(`Unsupported endpoint kind: ${String(normalized?.kind ?? "")}.`);
         }
@@ -2114,6 +2287,62 @@ const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
     "ConnectionMetadata",
     "connectionMetadata"
 ];
+const GRPC_ENDPOINT_FLAT_KEYS = [
+    "Target",
+    "target",
+    "ServiceName",
+    "serviceName",
+    "MethodName",
+    "methodName",
+    "MethodType",
+    "methodType",
+    "Deadline",
+    "deadline",
+    "DeadlineSeconds",
+    "deadlineSeconds",
+    "DeadlineMs",
+    "deadlineMs",
+    "Metadata",
+    "metadata",
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata"
+];
+const WEB_SOCKET_ENDPOINT_FLAT_KEYS = [
+    "Url",
+    "url",
+    "Subprotocols",
+    "subprotocols",
+    "ConnectTimeout",
+    "connectTimeout",
+    "ConnectTimeoutSeconds",
+    "connectTimeoutSeconds",
+    "ConnectTimeoutMs",
+    "connectTimeoutMs",
+    "CloseTimeout",
+    "closeTimeout",
+    "CloseTimeoutSeconds",
+    "closeTimeoutSeconds",
+    "CloseTimeoutMs",
+    "closeTimeoutMs",
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata"
+];
 function normalizeEndpointDefinition(endpoint) {
     if (!endpoint || typeof endpoint !== "object") {
         return endpoint;
@@ -2148,7 +2377,9 @@ function normalizeEndpointDefinition(endpoint) {
         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))
+        delegate: normalizeDelegateEndpointOptions(pickEndpointTransportRecord(raw, kind, "DelegateStream", ["delegate", "Delegate", "DelegateStream"], DELEGATE_STREAM_ENDPOINT_FLAT_KEYS)),
+        grpc: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Grpc", ["grpc", "Grpc"], GRPC_ENDPOINT_FLAT_KEYS)),
+        webSocket: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "WebSocket", ["webSocket", "WebSocket"], WEB_SOCKET_ENDPOINT_FLAT_KEYS))
     };
 }
 function resolveEndpointKind(raw) {
@@ -2234,6 +2465,28 @@ function resolveEndpointKind(raw) {
     ])) {
         return "PushDiffusion";
     }
+    if (Object.keys(pickEndpointRecord(raw, "grpc", "Grpc")).length || hasAnyEndpointField(raw, [
+        "Target",
+        "target",
+        "ServiceName",
+        "serviceName",
+        "MethodName",
+        "methodName",
+        "MethodType",
+        "methodType"
+    ])) {
+        return "Grpc";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "webSocket", "WebSocket")).length || hasAnyEndpointField(raw, [
+        "Subprotocols",
+        "subprotocols",
+        "ConnectTimeoutSeconds",
+        "connectTimeoutSeconds",
+        "CloseTimeoutSeconds",
+        "closeTimeoutSeconds"
+    ])) {
+        return "WebSocket";
+    }
     if (Object.keys(pickEndpointRecord(raw, "delegate", "Delegate", "DelegateStream")).length || hasAnyEndpointField(raw, [
         "Produce",
         "produce",
@@ -2477,10 +2730,8 @@ function validateEndpointDefinition(endpoint) {
     if (mode !== "Produce" && mode !== "Consume") {
         throw new Error(`Unsupported endpoint mode: ${mode}.`);
     }
-    const hasProduceDelegate = typeof endpoint.delegate?.produce === "function"
-        || typeof endpoint.delegate?.produceAsync === "function";
-    const hasConsumeDelegate = typeof endpoint.delegate?.consume === "function"
-        || typeof endpoint.delegate?.consumeAsync === "function";
+    const hasProduceDelegate = Boolean(resolveProduceDelegate(endpoint) || resolveStructuredProduceDelegate(endpoint));
+    const hasConsumeDelegate = Boolean(resolveConsumeDelegate(endpoint) || resolveStructuredConsumeDelegate(endpoint) || resolveStructuredConsumeStreamDelegate(endpoint));
     const hasModeDelegate = mode === "Produce" ? hasProduceDelegate : hasConsumeDelegate;
     switch (kind) {
         case "Http":
@@ -2510,6 +2761,12 @@ function validateEndpointDefinition(endpoint) {
         case "DelegateStream":
             validateDelegateStreamEndpoint(endpoint, mode);
             return;
+        case "Grpc":
+            validateGrpcEndpoint(endpoint, mode);
+            return;
+        case "WebSocket":
+            validateWebSocketEndpoint(endpoint, mode);
+            return;
         default:
             throw new Error(`Unsupported endpoint kind: ${kind}.`);
     }
@@ -2585,6 +2842,57 @@ function validateDelegateStreamEndpoint(endpoint, mode) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
+function validateGrpcEndpoint(endpoint, mode) {
+    const options = asRecordOrEmpty(endpoint.grpc);
+    requireNonEmptyString(optionString(options, "Target", "target"), "Target must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "ServiceName", "serviceName"), "ServiceName must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "MethodName", "methodName"), "MethodName must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "MethodType", "methodType") || "Unary", "MethodType must be provided for gRPC endpoint definitions.");
+    const deadlineMs = optionNumber(options, "DeadlineMs", "deadlineMs");
+    const deadlineSeconds = optionNumber(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+    if ((hasOptionValue(options, "DeadlineMs", "deadlineMs") && deadlineMs <= 0)
+        || (hasOptionValue(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline") && deadlineSeconds <= 0)) {
+        throw new RangeError("Deadline must be greater than zero.");
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+        throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+    }
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
+function validateWebSocketEndpoint(endpoint, mode) {
+    const options = asRecordOrEmpty(endpoint.webSocket);
+    const url = requireNonEmptyString(optionString(options, "Url", "url"), "Url must be provided for WebSocket endpoint definitions.");
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+    }
+    if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+    }
+    const connectMs = optionNumber(options, "ConnectTimeoutMs", "connectTimeoutMs");
+    const connectSeconds = optionNumber(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
+    const closeMs = optionNumber(options, "CloseTimeoutMs", "closeTimeoutMs");
+    const closeSeconds = optionNumber(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
+    if ((hasOptionValue(options, "ConnectTimeoutMs", "connectTimeoutMs") && connectMs <= 0)
+        || (hasOptionValue(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout") && connectSeconds <= 0)) {
+        throw new RangeError("ConnectTimeout must be greater than zero.");
+    }
+    if ((hasOptionValue(options, "CloseTimeoutMs", "closeTimeoutMs") && closeMs <= 0)
+        || (hasOptionValue(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout") && closeSeconds <= 0)) {
+        throw new RangeError("CloseTimeout must be greater than zero.");
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+        throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+    }
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
 function validateHttpAuthOptions(options) {
     const auth = options.auth;
     if (!auth) {
@@ -3227,6 +3535,10 @@ function createDelegateRequestEndpointView(endpoint) {
             return new exports.AzureEventHubsEndpointDefinition(endpoint);
         case "PushDiffusion":
             return new exports.PushDiffusionEndpointDefinition(endpoint);
+        case "Grpc":
+            return new exports.GrpcEndpointDefinition(endpoint);
+        case "WebSocket":
+            return new exports.WebSocketEndpointDefinition(endpoint);
         default:
             return new exports.DelegateStreamEndpointDefinition(endpoint);
     }
@@ -3445,12 +3757,20 @@ function parseBodyObject(body) {
 function resolveStructuredProduceDelegate(endpoint) {
     return endpoint.delegate?.produceAsync
         ?? endpoint.pushDiffusion?.PublishAsync
-        ?? endpoint.pushDiffusion?.publishAsync;
+        ?? endpoint.pushDiffusion?.publishAsync
+        ?? endpoint.grpc?.ProduceAsync
+        ?? endpoint.grpc?.produceAsync
+        ?? endpoint.webSocket?.ProduceAsync
+        ?? endpoint.webSocket?.produceAsync;
 }
 function resolveStructuredConsumeDelegate(endpoint) {
     const delegate = endpoint.delegate?.consumeAsync
         ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync;
+        ?? endpoint.pushDiffusion?.subscribeAsync
+        ?? endpoint.grpc?.ConsumeAsync
+        ?? endpoint.grpc?.consumeAsync
+        ?? endpoint.webSocket?.ConsumeAsync
+        ?? endpoint.webSocket?.consumeAsync;
     return typeof delegate === "function" && delegate.length === 0
         ? delegate
         : undefined;
@@ -3458,22 +3778,36 @@ function resolveStructuredConsumeDelegate(endpoint) {
 function resolveStructuredConsumeStreamDelegate(endpoint) {
     const delegate = endpoint.delegate?.consumeAsync
         ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync;
+        ?? endpoint.pushDiffusion?.subscribeAsync
+        ?? endpoint.grpc?.ConsumeAsync
+        ?? endpoint.grpc?.consumeAsync
+        ?? endpoint.webSocket?.ConsumeAsync
+        ?? endpoint.webSocket?.consumeAsync;
     return typeof delegate === "function" && delegate.length > 0
         ? delegate
         : undefined;
 }
 function resolveProduceDelegate(endpoint) {
-    return endpoint.delegate?.produce;
+    return endpoint.delegate?.produce
+        ?? endpoint.grpc?.Produce
+        ?? endpoint.grpc?.produce
+        ?? endpoint.webSocket?.Produce
+        ?? endpoint.webSocket?.produce;
 }
 function resolveConsumeDelegate(endpoint) {
-    return endpoint.delegate?.consume;
+    return endpoint.delegate?.consume
+        ?? endpoint.grpc?.Consume
+        ?? endpoint.grpc?.consume
+        ?? endpoint.webSocket?.Consume
+        ?? endpoint.webSocket?.consume;
 }
 function resolveConnectionMetadata(endpoint) {
     return {
         ...(endpoint.connectionMetadata ?? {}),
         ...(endpoint.delegate?.connectionMetadata ?? {}),
-        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties)
+        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties),
+        ...toStringRecord(endpoint.grpc?.ConnectionMetadata ?? endpoint.grpc?.connectionMetadata),
+        ...toStringRecord(endpoint.webSocket?.ConnectionMetadata ?? endpoint.webSocket?.connectionMetadata)
     };
 }
 function isStructuredProduceResult(value) {

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, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.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 { 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, 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, GrpcEndpointDefinition, WebSocketEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";

package/dist/esm/local.js

@@ -1,3 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LoadStrikeLocalClient_licensingApiBaseUrl, _LoadStrikeLocalClient_signingKeyCache;
 import os from "node:os";
 import * as fs from "node:fs";
 import * as childProcess from "node:child_process";
@@ -28,7 +40,9 @@ const TRACKING_FEATURE_BY_KIND = {
     delegatestream: "endpoint.delegate_stream",
     nats: "endpoint.nats",
     redisstreams: "endpoint.redis_streams",
-    sqs: "endpoint.sqs"
+    sqs: "endpoint.sqs",
+    grpc: "endpoint.grpc",
+    websocket: "endpoint.websocket"
 };
 const CI_ENVIRONMENT_VARIABLES = [
     "GITHUB_ACTIONS",
@@ -53,13 +67,14 @@ export class LoadStrikeLocalClient {
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
      */
     constructor(options = {}) {
-        this.signingKeyCache = new Map();
+        _LoadStrikeLocalClient_licensingApiBaseUrl.set(this, void 0);
+        _LoadStrikeLocalClient_signingKeyCache.set(this, new Map());
         assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
-        this.licensingApiBaseUrl = resolveLicensingApiBaseUrl();
+        __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, resolveLicensingApiBaseUrl(), "f");
         this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
     }
     portalReportingIngestUrl() {
-        return `${this.licensingApiBaseUrl.replace(/\/+$/, "")}/api/v1/reporting/ingest`;
+        return `${__classPrivateFieldGet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, "f").replace(/\/+$/, "")}/api/v1/reporting/ingest`;
     }
     async run(request) {
         const sanitized = sanitizeRequest(request);
@@ -328,8 +343,8 @@ export class LoadStrikeLocalClient {
         const nowMs = Date.now();
         const normalizedKeyId = stringOrDefault(keyId, "default").trim() || "default";
         const normalizedAlgorithm = stringOrDefault(algorithm, "RS256").toUpperCase();
-        const cacheKey = `${this.licensingApiBaseUrl.toLowerCase()}|${normalizedAlgorithm}:${normalizedKeyId}`;
-        const cached = this.signingKeyCache.get(cacheKey);
+        const cacheKey = `${__classPrivateFieldGet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, "f").toLowerCase()}|${normalizedAlgorithm}:${normalizedKeyId}`;
+        const cached = __classPrivateFieldGet(this, _LoadStrikeLocalClient_signingKeyCache, "f").get(cacheKey);
         if (cached && cached.expiresAtUtc > nowMs) {
             return cached;
         }
@@ -357,7 +372,7 @@ export class LoadStrikeLocalClient {
                 publicKeyPem,
                 expiresAtUtc: nowMs + (15 * 60 * 1000)
             };
-            this.signingKeyCache.set(cacheKey, keyRecord);
+            __classPrivateFieldGet(this, _LoadStrikeLocalClient_signingKeyCache, "f").set(cacheKey, keyRecord);
             return keyRecord;
         }
         finally {
@@ -409,7 +424,7 @@ export class LoadStrikeLocalClient {
         }
     }
     async postLicensingRequest(path, payload, signal) {
-        const response = await fetch(`${this.licensingApiBaseUrl.replace(/\/+$/, "")}${path}`, {
+        const response = await fetch(`${__classPrivateFieldGet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, "f").replace(/\/+$/, "")}${path}`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -428,7 +443,7 @@ export class LoadStrikeLocalClient {
         return { response, json };
     }
     async getLicensingRequest(path, signal) {
-        const response = await fetch(`${this.licensingApiBaseUrl.replace(/\/+$/, "")}${path}`, {
+        const response = await fetch(`${__classPrivateFieldGet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, "f").replace(/\/+$/, "")}${path}`, {
             method: "GET",
             headers: {
                 Accept: "application/json"
@@ -445,6 +460,7 @@ export class LoadStrikeLocalClient {
         return { response, json };
     }
 }
+_LoadStrikeLocalClient_licensingApiBaseUrl = new WeakMap(), _LoadStrikeLocalClient_signingKeyCache = new WeakMap();
 function assertNoDisableLicenseEnforcementOption(value, source) {
     if (value == null || typeof value !== "object" || Array.isArray(value)) {
         return;
@@ -474,7 +490,43 @@ function resolveLicensingApiBaseUrl() {
     return normalizeLicensingApiBaseUrl(developmentLicensingApiBaseUrlOverride);
 }
 function setDevelopmentLicensingApiBaseUrlOverride(value) {
-    developmentLicensingApiBaseUrlOverride = value;
+    if (value != null && value.trim()) {
+        assertInternalTestHarnessLicensingOverride();
+        const normalized = normalizeLicensingApiBaseUrl(value);
+        if (!isLoopbackHttpBaseUrl(normalized)) {
+            throw new TypeError("Internal development licensing API overrides must use a loopback http URL.");
+        }
+        developmentLicensingApiBaseUrlOverride = normalized;
+        return;
+    }
+    if (value != null) {
+        assertInternalTestHarnessLicensingOverride();
+    }
+    developmentLicensingApiBaseUrlOverride = undefined;
+}
+function assertInternalTestHarnessLicensingOverride() {
+    if (isInternalTestHarnessCall()) {
+        return;
+    }
+    throw new TypeError("Internal development licensing API override is available only to LoadStrike SDK tests.");
+}
+function isInternalTestHarnessCall() {
+    const stack = String(new Error().stack ?? "").replace(/\\/g, "/").toLowerCase();
+    return stack.includes("/sdk/ts/tests/");
+}
+function isLoopbackHttpBaseUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== "http:") {
+        return false;
+    }
+    const host = parsed.hostname.trim().toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1" || host.endsWith(".localhost");
 }
 function normalizeTimeoutMs(value) {
     if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {