@loadstrike/loadstrike-sdk 1.0.26901 → 1.0.27101

package/dist/esm/local.js

@@ -40,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",

package/dist/esm/runtime.js

@@ -1604,6 +1604,112 @@ export class LoadStrikeContext {
         return this.assignState(this.values, scenarios, this.runArgs);
     }
 }
+const ACCESSIBILITY_TESTING_FEATURE = "testing.accessibility";
+const BROWSER_WEB_VITALS_FEATURE = "testing.browser_web_vitals";
+export class LoadStrikeAccessibility {
+    static createScenario(name, options, check) {
+        if (typeof name !== "string" || !name.trim()) {
+            throw new Error("Scenario name must be provided.");
+        }
+        validateAbsoluteUrl(options?.url, "Accessibility check URL");
+        if (typeof check !== "function") {
+            throw new TypeError("Accessibility check callback must be provided.");
+        }
+        return LoadStrikeScenario
+            .create(name, async (scenarioContext) => {
+            const result = await check({ options, scenarioContext });
+            const failure = evaluateAccessibilityResult(options, result);
+            return failure
+                ? LoadStrikeResponse.fail("accessibility", failure)
+                : LoadStrikeResponse.ok("200", 0, `Accessibility check passed with ${(result.violations ?? []).length} violation(s).`);
+        })
+            .withoutWarmUp()
+            .__loadStrikeWithInternalLicenseFeatures(ACCESSIBILITY_TESTING_FEATURE);
+    }
+    static CreateScenario(name, options, check) {
+        return LoadStrikeAccessibility.createScenario(name, options, check);
+    }
+}
+export class LoadStrikeBrowserWebVitals {
+    static createScenario(name, options, measure) {
+        if (typeof name !== "string" || !name.trim()) {
+            throw new Error("Scenario name must be provided.");
+        }
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        if (typeof measure !== "function") {
+            throw new TypeError("Browser Web Vitals measurement callback must be provided.");
+        }
+        return LoadStrikeScenario
+            .create(name, async (scenarioContext) => {
+            const result = await measure({ options, scenarioContext });
+            const failure = evaluateWebVitalsResult(options, result);
+            return failure
+                ? LoadStrikeResponse.fail("web_vitals", failure)
+                : LoadStrikeResponse.ok("200", 0, "Browser Web Vitals check passed.");
+        })
+            .withoutWarmUp()
+            .__loadStrikeWithInternalLicenseFeatures(BROWSER_WEB_VITALS_FEATURE);
+    }
+    static CreateScenario(name, options, measure) {
+        return LoadStrikeBrowserWebVitals.createScenario(name, options, measure);
+    }
+}
+function validateAbsoluteUrl(value, label) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${label} must be provided.`);
+    }
+    try {
+        const parsed = new URL(value);
+        if (!parsed.protocol || !parsed.host) {
+            throw new Error("invalid");
+        }
+    }
+    catch {
+        throw new Error(`${label} must be an absolute URL.`);
+    }
+}
+function evaluateAccessibilityResult(options, result) {
+    if (!result) {
+        return "Accessibility check did not return a result.";
+    }
+    const violations = Array.isArray(result.violations) ? result.violations : [];
+    const maxViolations = Math.max(0, Number(options.maxViolations ?? 0));
+    const critical = countAccessibilityImpact(violations, "critical");
+    const serious = countAccessibilityImpact(violations, "serious");
+    const maxCritical = Math.max(0, Number(options.maxCriticalViolations ?? 0));
+    const maxSerious = Math.max(0, Number(options.maxSeriousViolations ?? 0));
+    if (violations.length > maxViolations) {
+        return `Accessibility violations ${violations.length} exceeded limit ${maxViolations}.`;
+    }
+    if (critical > maxCritical) {
+        return `Critical accessibility violations ${critical} exceeded limit ${maxCritical}.`;
+    }
+    if (serious > maxSerious) {
+        return `Serious accessibility violations ${serious} exceeded limit ${maxSerious}.`;
+    }
+    return "";
+}
+function countAccessibilityImpact(violations, impact) {
+    return violations.filter((violation) => String(violation.impact ?? "").toLowerCase() === impact).length;
+}
+function evaluateWebVitalsResult(options, result) {
+    if (!result) {
+        return "Browser Web Vitals check did not return a result.";
+    }
+    return firstWebVitalViolation(["LCP", result.largestContentfulPaintMs, options.maxLargestContentfulPaintMs, "ms"], ["INP", result.interactionToNextPaintMs, options.maxInteractionToNextPaintMs, "ms"], ["CLS", result.cumulativeLayoutShift, options.maxCumulativeLayoutShift, ""], ["FCP", result.firstContentfulPaintMs, options.maxFirstContentfulPaintMs, "ms"], ["TTFB", result.timeToFirstByteMs, options.maxTimeToFirstByteMs, "ms"]);
+}
+function firstWebVitalViolation(...values) {
+    for (const [name, actualRaw, limitRaw, unit] of values) {
+        const actual = Number(actualRaw);
+        const limit = Number(limitRaw);
+        if (!Number.isFinite(actual) || !Number.isFinite(limit) || actual <= limit) {
+            continue;
+        }
+        const suffix = unit ? ` ${unit}` : "";
+        return `${name} ${actual}${suffix} exceeded limit ${limit}${suffix}.`;
+    }
+    return "";
+}
 export class LoadStrikeScenario {
     constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail, internalLicenseFeatures = []) {
         this.name = name;

package/dist/esm/transports.js

@@ -285,6 +285,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.");
+        }
+    }
+}
 export const TrafficEndpointDefinition = TrafficEndpointDefinitionModel;
 export const HttpEndpointDefinition = HttpEndpointDefinitionModel;
 export const KafkaEndpointDefinition = KafkaEndpointDefinitionModel;
@@ -295,6 +363,8 @@ export const AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinition
 export const SqsEndpointDefinition = SqsEndpointDefinitionModel;
 export const DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 export const PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
+export const GrpcEndpointDefinition = GrpcEndpointDefinitionModel;
+export const WebSocketEndpointDefinition = WebSocketEndpointDefinitionModel;
 export const HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
 export const HttpAuthOptions = HttpAuthOptionsModel;
 export const KafkaSaslOptions = KafkaSaslOptionsModel;
@@ -744,6 +814,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") {
@@ -1878,6 +2043,10 @@ class PushDiffusionEndpointAdapter extends CallbackAdapter {
 }
 class DelegateStreamEndpointAdapter extends CallbackAdapter {
 }
+class GrpcEndpointAdapter extends CallbackAdapter {
+}
+class WebSocketEndpointAdapter extends CallbackAdapter {
+}
 export class EndpointAdapterFactory {
     static create(endpoint) {
         if (endpoint instanceof TrafficEndpointDefinitionModel) {
@@ -1904,6 +2073,10 @@ export 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 ?? "")}.`);
         }
@@ -2077,6 +2250,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;
@@ -2111,7 +2340,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) {
@@ -2197,6 +2428,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",
@@ -2440,10 +2693,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":
@@ -2473,6 +2724,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}.`);
     }
@@ -2548,6 +2805,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) {
@@ -3190,6 +3498,10 @@ function createDelegateRequestEndpointView(endpoint) {
             return new AzureEventHubsEndpointDefinition(endpoint);
         case "PushDiffusion":
             return new PushDiffusionEndpointDefinition(endpoint);
+        case "Grpc":
+            return new GrpcEndpointDefinition(endpoint);
+        case "WebSocket":
+            return new WebSocketEndpointDefinition(endpoint);
         default:
             return new DelegateStreamEndpointDefinition(endpoint);
     }
@@ -3408,12 +3720,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;
@@ -3421,22 +3741,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/types/contracts.d.ts

@@ -111,6 +111,8 @@ export interface LoadStrikeEndpointSpec {
     Sqs?: LoadStrikeSqsEndpointOptions;
     DelegateStream?: LoadStrikeDelegateEndpointOptions;
     PushDiffusion?: LoadStrikePushDiffusionEndpointOptions;
+    Grpc?: LoadStrikeGrpcEndpointOptions;
+    WebSocket?: LoadStrikeWebSocketEndpointOptions;
 }
 export interface LoadStrikeHttpEndpointOptions {
     Url?: string;
@@ -230,6 +232,22 @@ export interface LoadStrikePushDiffusionEndpointOptions {
     PublishCallbackUrl?: string;
     SubscribeCallbackUrl?: string;
 }
+export interface LoadStrikeGrpcEndpointOptions {
+    Target?: string;
+    ServiceName?: string;
+    MethodName?: string;
+    MethodType?: string;
+    DeadlineSeconds?: number;
+    Metadata?: Record<string, string>;
+    ConnectionMetadata?: Record<string, string>;
+}
+export interface LoadStrikeWebSocketEndpointOptions {
+    Url?: string;
+    Subprotocols?: string[];
+    ConnectTimeoutSeconds?: number;
+    CloseTimeoutSeconds?: number;
+    ConnectionMetadata?: Record<string, string>;
+}
 export interface LoadStrikeReportingSinkSpec {
     Kind: string;
     InfluxDb?: LoadStrikeInfluxDbSinkOptions;

package/dist/types/index.d.ts

@@ -1,12 +1,12 @@
-export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeSqsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
+export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeSqsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeGrpcEndpointOptions, LoadStrikeWebSocketEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
 export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export type { LoadStrikeAutopilotEndpoint, LoadStrikeAutopilotEndpointBinding, LoadStrikeAutopilotLoadSimulationSuggestion, LoadStrikeAutopilotMessageSample, LoadStrikeAutopilotOptions, LoadStrikeAutopilotPlan, LoadStrikeAutopilotPreviewReport, LoadStrikeAutopilotReadinessFailure, LoadStrikeAutopilotRedaction, LoadStrikeAutopilotRequest, LoadStrikeAutopilotResultShape, LoadStrikeAutopilotScenarioPlan, LoadStrikeAutopilotSecretBinding, LoadStrikeAutopilotThresholdSuggestion, LoadStrikeAutopilotTrackingSelectorSuggestion } from "./autopilot-contracts.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
-export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
-export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeBaseContext, LoadStrikeCounterStats, LoadStrikeDataTransferStats, LoadStrikeGaugeStats, LoadStrikeLogger, LoadStrikeLoadSimulationStats, LoadStrikeMeasurementStats, LoadStrikeMetricStats, LoadStrikeNodeInfo, LoadStrikeMetricValue, LoadStrikeRandom, LoadStrikeReply, LoadStrikeLatencyCount, LoadStrikeLatencyStats, LoadStrikeLoadSimulation, LoadStrikeScenarioInfo, LoadStrikeScenarioInitContext, LoadStrikeScenarioPartition, LoadStrikeScenarioStartInfo, LoadStrikeScenarioContext, LoadStrikeScenarioStats, LoadStrikeTestInfo, LoadStrikeScenarioRuntime, LoadStrikeSessionStartInfo, LoadStrikeSinkSession, LoadStrikeSinkError, LoadStrikeStatusCodeStats, LoadStrikeThresholdResult, LoadStrikeThresholdPredicateContext, LoadStrikeStepReply, LoadStrikeStepStats, LoadStrikeStepRuntime, LoadStrikeThresholdOptions, LoadStrikeRequestStats, LoadStrikeWorkerPlugin } 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 type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeAccessibilityOptions, LoadStrikeAccessibilityViolation, LoadStrikeAccessibilityResult, LoadStrikeAccessibilityCheckContext, LoadStrikeBrowserWebVitalsOptions, LoadStrikeBrowserWebVitalsResult, LoadStrikeBrowserWebVitalsContext, LoadStrikeBaseContext, LoadStrikeCounterStats, LoadStrikeDataTransferStats, LoadStrikeGaugeStats, LoadStrikeLogger, LoadStrikeLoadSimulationStats, LoadStrikeMeasurementStats, LoadStrikeMetricStats, LoadStrikeNodeInfo, LoadStrikeMetricValue, LoadStrikeRandom, LoadStrikeReply, LoadStrikeLatencyCount, LoadStrikeLatencyStats, LoadStrikeLoadSimulation, LoadStrikeScenarioInfo, LoadStrikeScenarioInitContext, LoadStrikeScenarioPartition, LoadStrikeScenarioStartInfo, LoadStrikeScenarioContext, LoadStrikeScenarioStats, LoadStrikeTestInfo, LoadStrikeScenarioRuntime, LoadStrikeSessionStartInfo, LoadStrikeSinkSession, LoadStrikeSinkError, LoadStrikeStatusCodeStats, LoadStrikeThresholdResult, LoadStrikeThresholdPredicateContext, LoadStrikeStepReply, LoadStrikeStepStats, LoadStrikeStepRuntime, LoadStrikeThresholdOptions, LoadStrikeRequestStats, LoadStrikeWorkerPlugin } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
 export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, CorrelationStoreKind, CorrelationRuntimeOptions, CorrelationRuntimePlugin, CorrelationRuntimeStats, CorrelationStore, SourceProduceResult, TrackingFieldLocation, TrackingPayload } 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 type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, SqsEndpointOptions, PushDiffusionEndpointOptions, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } 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 type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, SqsEndpointOptions, PushDiffusionEndpointOptions, GrpcEndpointOptions, WebSocketEndpointOptions, GrpcEndpointDefinition as GrpcEndpointDefinitionShape, WebSocketEndpointDefinition as WebSocketEndpointDefinitionShape, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
 export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.js";