@loadstrike/loadstrike-sdk 1.0.31601 → 1.0.32601

package/dist/esm/transports.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
 import { TrackingFieldSelector } from "./correlation.js";
 export const LOADSTRIKE_TRACE_ID_HEADER = "loadstrike-trace-id";
 export const LOADSTRIKE_TRACE_ID_TRACKING_FIELD = `header:${LOADSTRIKE_TRACE_ID_HEADER}`;
+const NATIVE_GRPC_EXECUTION_UNAVAILABLE_MESSAGE = "Native gRPC execution is not available in this SDK version. Provide the endpoint Produce/Consume delegate instead.";
 class TrafficEndpointDefinitionModel {
     get JsonSerializerSettings() {
         return this.JsonSettings;
@@ -421,6 +423,15 @@ class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     }
     Validate() {
         super.Validate();
+        const hasModeAsyncDelegate = this.Mode === "Produce"
+            ? typeof this.ProduceAsync === "function"
+            : typeof this.ConsumeAsync === "function";
+        const hasModeDelegate = this.Mode === "Produce"
+            ? typeof this.Produce === "function" || hasModeAsyncDelegate
+            : typeof this.Consume === "function" || hasModeAsyncDelegate;
+        if (this.NativeClient && !hasModeDelegate) {
+            throw new Error(NATIVE_GRPC_EXECUTION_UNAVAILABLE_MESSAGE);
+        }
         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.");
@@ -428,57 +439,204 @@ class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         if (this.DeadlineSeconds <= 0) {
             throw new RangeError("Deadline must be greater than zero.");
         }
-        this.NativeClient?.validate();
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
+        if (this.Mode === "Produce" && !hasModeDelegate && !this.NativeClient) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
+        if (this.Mode === "Consume" && !hasModeDelegate && !this.NativeClient) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
 }
+const webSocketReconnectValidationInputs = new WeakMap();
+const webSocketMessageValidationInputs = new WeakMap();
+const webSocketExpectedValidationInputs = new WeakMap();
+const webSocketNativeValidationInputs = new WeakMap();
+const NATIVE_WEBSOCKET_RECONNECT_INPUT_FIELDS = [
+    ["MaxAttempts", "maxAttempts"],
+    ["DelayMs", "delayMs"],
+    ["DelaySeconds", "delaySeconds", "Delay", "delay"]
+];
+const NATIVE_WEBSOCKET_MESSAGE_INPUT_FIELDS = [
+    ["Kind", "kind"],
+    ["TextPayload", "textPayload"],
+    ["BinaryPayload", "binaryPayload"]
+];
+const NATIVE_WEBSOCKET_EXPECTED_INPUT_FIELDS = [
+    ["ContainsText", "containsText"],
+    ["ContainsBytes", "containsBytes"],
+    ["TimeoutMs", "timeoutMs"],
+    ["TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout"]
+];
+const NATIVE_WEBSOCKET_CLIENT_INPUT_FIELDS = [
+    ["Headers", "headers"],
+    ["Cookies", "cookies"],
+    ["PingIntervalMs", "pingIntervalMs"],
+    ["PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval"],
+    ["Reconnect", "reconnect"],
+    ["Messages", "messages"],
+    ["ExpectedMessages", "expectedMessages"]
+];
+function captureSelectedNativeWebSocketFields(source, fieldGroups) {
+    const captured = {};
+    for (const fieldGroup of fieldGroups) {
+        const canonicalName = fieldGroup[0];
+        for (const fieldName of fieldGroup) {
+            if (fieldName in source) {
+                captured[canonicalName] = source[fieldName];
+                break;
+            }
+        }
+    }
+    return captured;
+}
+function captureNativeWebSocketRecordEntries(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const captured = {};
+    for (const [key, entry] of Object.entries(value)) {
+        captured[key] = entry;
+    }
+    return captured;
+}
+function captureNativeWebSocketReconnectInput(source) {
+    return captureSelectedNativeWebSocketFields(source, NATIVE_WEBSOCKET_RECONNECT_INPUT_FIELDS);
+}
+function captureNativeWebSocketMessageInput(source) {
+    const captured = captureSelectedNativeWebSocketFields(source, NATIVE_WEBSOCKET_MESSAGE_INPUT_FIELDS);
+    if (Array.isArray(captured.BinaryPayload)) {
+        captured.BinaryPayload = Array.from(captured.BinaryPayload);
+    }
+    return captured;
+}
+function captureNativeWebSocketExpectedInput(source) {
+    const captured = captureSelectedNativeWebSocketFields(source, NATIVE_WEBSOCKET_EXPECTED_INPUT_FIELDS);
+    if (Array.isArray(captured.ContainsBytes)) {
+        captured.ContainsBytes = Array.from(captured.ContainsBytes);
+    }
+    return captured;
+}
+function captureNativeWebSocketOptionsInput(source) {
+    const captured = captureSelectedNativeWebSocketFields(source, NATIVE_WEBSOCKET_CLIENT_INPUT_FIELDS);
+    if ("Headers" in captured) {
+        captured.Headers = captureNativeWebSocketRecordEntries(captured.Headers);
+    }
+    if (Array.isArray(captured.Cookies)) {
+        captured.Cookies = Array.from(captured.Cookies);
+    }
+    if (isRecord(captured.Reconnect) && !(captured.Reconnect instanceof WebSocketReconnectPolicy)) {
+        captured.Reconnect = captureNativeWebSocketReconnectInput(captured.Reconnect);
+    }
+    if (Array.isArray(captured.Messages)) {
+        captured.Messages = captured.Messages.map((entry) => (entry instanceof WebSocketMessageSpec || !isRecord(entry)
+            ? entry
+            : captureNativeWebSocketMessageInput(entry)));
+    }
+    if (Array.isArray(captured.ExpectedMessages)) {
+        captured.ExpectedMessages = captured.ExpectedMessages.map((entry) => (entry instanceof WebSocketExpectedMessage || !isRecord(entry)
+            ? entry
+            : captureNativeWebSocketExpectedInput(entry)));
+    }
+    return captured;
+}
+function snapshotNativeWebSocketInput(value, seen = new WeakMap()) {
+    if (value == null || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof WebSocketReconnectPolicy
+        || value instanceof WebSocketMessageSpec
+        || value instanceof WebSocketExpectedMessage) {
+        return value;
+    }
+    const existing = seen.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+    }
+    if (Array.isArray(value)) {
+        const clone = [];
+        seen.set(value, clone);
+        for (const entry of value) {
+            clone.push(snapshotNativeWebSocketInput(entry, seen));
+        }
+        return clone;
+    }
+    const clone = {};
+    seen.set(value, clone);
+    for (const [key, entry] of Object.entries(value)) {
+        clone[key] = snapshotNativeWebSocketInput(entry, seen);
+    }
+    return clone;
+}
+function defineSynchronizedPublicAlias(target, alias, read, write) {
+    Object.defineProperty(target, alias, {
+        configurable: true,
+        enumerable: true,
+        get: read,
+        set: write
+    });
+}
 export 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);
+        defineSynchronizedPublicAlias(this, "maxAttempts", () => this.MaxAttempts, (value) => {
+            this.MaxAttempts = value;
+        });
+        defineSynchronizedPublicAlias(this, "delaySeconds", () => this.DelaySeconds, (value) => {
+            this.DelaySeconds = value;
+        });
+        const raw = captureNativeWebSocketReconnectInput(asRecordOrEmpty(initial));
+        webSocketReconnectValidationInputs.set(this, snapshotNativeWebSocketInput(raw));
+        this.MaxAttempts = (pickEndpointValue(raw, "MaxAttempts", "maxAttempts") ?? 0);
         this.maxAttempts = this.MaxAttempts;
-        const delayMs = pickOptionalEndpointNumber(raw, "DelayMs", "delayMs");
+        const delayMs = pickEndpointValue(raw, "DelayMs", "delayMs");
+        const delaySeconds = pickEndpointValue(raw, "DelaySeconds", "delaySeconds", "Delay", "delay");
         this.DelaySeconds = delayMs != null
             ? delayMs / 1000
-            : (pickOptionalEndpointNumber(raw, "DelaySeconds", "delaySeconds", "Delay", "delay") ?? 1);
+            : (delaySeconds ?? 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.");
-        }
+        validateNativeWebSocketReconnectPolicy(webSocketReconnectValidationInputs.get(this) ?? {});
+        validateNativeWebSocketReconnectPolicy(this);
     }
 }
 export class WebSocketMessageSpec {
     constructor(initial = {}) {
         this.Kind = "Text";
         this.kind = "Text";
-        const raw = asRecordOrEmpty(initial);
+        defineSynchronizedPublicAlias(this, "kind", () => this.Kind, (value) => {
+            this.Kind = value;
+        });
+        defineSynchronizedPublicAlias(this, "textPayload", () => this.TextPayload, (value) => {
+            this.TextPayload = value;
+        });
+        defineSynchronizedPublicAlias(this, "binaryPayload", () => this.BinaryPayload, (value) => {
+            this.BinaryPayload = value;
+        });
+        const raw = captureNativeWebSocketMessageInput(asRecordOrEmpty(initial));
+        webSocketMessageValidationInputs.set(this, snapshotNativeWebSocketInput(raw));
         this.Kind = pickOptionalEndpointString(raw, "Kind", "kind") ?? "Text";
         this.kind = this.Kind;
-        this.TextPayload = pickOptionalEndpointString(raw, "TextPayload", "textPayload");
+        this.TextPayload = pickOptionalEndpointExactString(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 = Uint8Array.from(binary.map((value) => Number(value)));
         }
         this.binaryPayload = this.BinaryPayload;
     }
@@ -492,42 +650,48 @@ export class WebSocketMessageSpec {
         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.");
-        }
+        validateOriginalNativeWebSocketMessage(webSocketMessageValidationInputs.get(this) ?? {});
+        validateNativeWebSocketMessage(this);
     }
 }
 export class WebSocketExpectedMessage {
     constructor(initial = {}) {
         this.TimeoutSeconds = 30;
         this.timeoutSeconds = 30;
-        const raw = asRecordOrEmpty(initial);
-        this.ContainsText = pickOptionalEndpointString(raw, "ContainsText", "containsText");
+        defineSynchronizedPublicAlias(this, "containsText", () => this.ContainsText, (value) => {
+            this.ContainsText = value;
+        });
+        defineSynchronizedPublicAlias(this, "containsBytes", () => this.ContainsBytes, (value) => {
+            this.ContainsBytes = value;
+        });
+        defineSynchronizedPublicAlias(this, "timeoutSeconds", () => this.TimeoutSeconds, (value) => {
+            this.TimeoutSeconds = value;
+        });
+        const raw = captureNativeWebSocketExpectedInput(asRecordOrEmpty(initial));
+        webSocketExpectedValidationInputs.set(this, snapshotNativeWebSocketInput(raw));
+        this.ContainsText = pickOptionalEndpointExactString(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 = Uint8Array.from(bytes.map((value) => Number(value)));
         }
         this.containsBytes = this.ContainsBytes;
-        const timeoutMs = pickOptionalEndpointNumber(raw, "TimeoutMs", "timeoutMs");
+        const timeoutMs = pickEndpointValue(raw, "TimeoutMs", "timeoutMs");
+        const timeoutSeconds = pickEndpointValue(raw, "TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout");
         this.TimeoutSeconds = timeoutMs != null
             ? timeoutMs / 1000
-            : (pickOptionalEndpointNumber(raw, "TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout") ?? 30);
+            : (timeoutSeconds ?? 30);
         this.timeoutSeconds = this.TimeoutSeconds;
     }
     Validate() {
         this.validate();
     }
     validate() {
-        if (this.TimeoutSeconds <= 0) {
-            throw new RangeError("Timeout must be greater than zero.");
-        }
+        validateNativeWebSocketExpectedMessage(webSocketExpectedValidationInputs.get(this) ?? {});
+        validateNativeWebSocketExpectedMessage(this);
     }
 }
 export class WebSocketNativeClientOptions {
@@ -542,13 +706,32 @@ export class WebSocketNativeClientOptions {
         this.messages = [];
         this.ExpectedMessages = [];
         this.expectedMessages = [];
-        const raw = asRecordOrEmpty(initial);
+        defineSynchronizedPublicAlias(this, "headers", () => this.Headers, (value) => {
+            this.Headers = value;
+        });
+        defineSynchronizedPublicAlias(this, "cookies", () => this.Cookies, (value) => {
+            this.Cookies = value;
+        });
+        defineSynchronizedPublicAlias(this, "pingIntervalSeconds", () => this.PingIntervalSeconds, (value) => {
+            this.PingIntervalSeconds = value;
+        });
+        defineSynchronizedPublicAlias(this, "reconnect", () => this.Reconnect, (value) => {
+            this.Reconnect = value;
+        });
+        defineSynchronizedPublicAlias(this, "messages", () => this.Messages, (value) => {
+            this.Messages = value;
+        });
+        defineSynchronizedPublicAlias(this, "expectedMessages", () => this.ExpectedMessages, (value) => {
+            this.ExpectedMessages = value;
+        });
+        const raw = captureNativeWebSocketOptionsInput(asRecordOrEmpty(initial));
+        webSocketNativeValidationInputs.set(this, snapshotNativeWebSocketInput(raw));
         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");
+        const pingMs = pickEndpointValue(raw, "PingIntervalMs", "pingIntervalMs");
+        const pingSeconds = pickEndpointValue(raw, "PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval");
         this.PingIntervalSeconds = pingMs != null ? pingMs / 1000 : pingSeconds;
         this.pingIntervalSeconds = this.PingIntervalSeconds;
         const reconnect = pickEndpointValue(raw, "Reconnect", "reconnect");
@@ -565,16 +748,8 @@ export class WebSocketNativeClientOptions {
         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();
-        }
+        validateNativeWebSocketOptions(webSocketNativeValidationInputs.get(this) ?? {});
+        validateNativeWebSocketOptions(this);
     }
 }
 class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
@@ -590,6 +765,23 @@ class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     }
     Validate() {
         super.Validate();
+        const hasModeAsyncDelegate = this.Mode === "Produce"
+            ? typeof this.ProduceAsync === "function"
+            : typeof this.ConsumeAsync === "function";
+        const hasModeDelegate = this.Mode === "Produce"
+            ? typeof this.Produce === "function" || hasModeAsyncDelegate
+            : typeof this.Consume === "function" || hasModeAsyncDelegate;
+        if (this.NativeClient != null && !hasModeDelegate) {
+            if (this.Mode === "Consume" && this.TrackingField.trim().toLowerCase().startsWith("header:")) {
+                throw new Error("Native WebSocket Consume cannot use a header TrackingField because WebSocket messages do not contain HTTP response headers.");
+            }
+            if (this.Mode === "Consume" && this.GatherByField?.trim().toLowerCase().startsWith("header:")) {
+                throw new Error("Native WebSocket Consume cannot use a header GatherByField because WebSocket messages do not contain HTTP response headers.");
+            }
+            validateNativeWebSocketSubprotocols(this.Subprotocols);
+            validateNativeWebSocketHeaderLayer(this.ConnectionMetadata, "ConnectionMetadata");
+            validateNativeWebSocketOptionsWithInstance(this.NativeClient);
+        }
         const url = requireNonEmptyString(this.Url, "Url must be provided for WebSocket endpoint definitions.");
         let parsed;
         try {
@@ -598,20 +790,17 @@ class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         catch {
             throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
         }
-        if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+        if ((parsed.protocol !== "ws:" && parsed.protocol !== "wss:")
+            || !parsed.hostname
+            || Boolean(parsed.hash)) {
             throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
         }
-        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.");
-        }
-        this.NativeClient?.validate();
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
+        validateNativeWebSocketTimerDelay(undefined, this.ConnectTimeoutSeconds, "ConnectTimeout");
+        validateNativeWebSocketTimerDelay(undefined, this.CloseTimeoutSeconds, "CloseTimeout");
+        if (this.Mode === "Produce" && !hasModeDelegate && this.NativeClient == null) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
+        if (this.Mode === "Consume" && !hasModeDelegate && this.NativeClient == null) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
@@ -1138,25 +1327,31 @@ function initializeWebSocketEndpointDefinitionModel(target, initial) {
     if (url) {
         target.Url = url;
     }
-    const subprotocols = pickEndpointStringArray(raw, "Subprotocols", "subprotocols");
-    if (subprotocols) {
-        target.Subprotocols = subprotocols;
+    const subprotocols = pickEndpointValue(raw, "Subprotocols", "subprotocols");
+    if (subprotocols != null) {
+        target.Subprotocols = normalizeWebSocketEndpointStringArrayInput(subprotocols);
     }
-    const connectMs = pickOptionalEndpointNumber(raw, "ConnectTimeoutMs", "connectTimeoutMs");
-    const connectSeconds = pickOptionalEndpointNumber(raw, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
+    const connectMs = pickEndpointValue(raw, "ConnectTimeoutMs", "connectTimeoutMs");
+    const connectSeconds = pickEndpointValue(raw, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
     if (connectMs != null) {
-        target.ConnectTimeoutSeconds = connectMs / 1000;
+        const normalized = normalizeWebSocketEndpointNumberInput(connectMs);
+        target.ConnectTimeoutSeconds = typeof normalized === "number"
+            ? normalized / 1000
+            : normalized;
     }
     else if (connectSeconds != null) {
-        target.ConnectTimeoutSeconds = connectSeconds;
+        target.ConnectTimeoutSeconds = normalizeWebSocketEndpointNumberInput(connectSeconds);
     }
-    const closeMs = pickOptionalEndpointNumber(raw, "CloseTimeoutMs", "closeTimeoutMs");
-    const closeSeconds = pickOptionalEndpointNumber(raw, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
+    const closeMs = pickEndpointValue(raw, "CloseTimeoutMs", "closeTimeoutMs");
+    const closeSeconds = pickEndpointValue(raw, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
     if (closeMs != null) {
-        target.CloseTimeoutSeconds = closeMs / 1000;
+        const normalized = normalizeWebSocketEndpointNumberInput(closeMs);
+        target.CloseTimeoutSeconds = typeof normalized === "number"
+            ? normalized / 1000
+            : normalized;
     }
     else if (closeSeconds != null) {
-        target.CloseTimeoutSeconds = closeSeconds;
+        target.CloseTimeoutSeconds = normalizeWebSocketEndpointNumberInput(closeSeconds);
     }
     const produce = pickEndpointFunction(raw, "Produce", "produce");
     if (produce) {
@@ -1175,15 +1370,45 @@ function initializeWebSocketEndpointDefinitionModel(target, initial) {
         target.ConsumeAsync = consumeAsync;
     }
     if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
-        target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
+        target.ConnectionMetadata = normalizeWebSocketEndpointMetadataInput(pickEndpointValue(raw, "ConnectionMetadata", "connectionMetadata"));
     }
     if (hasAnyEndpointField(raw, ["NativeClient", "nativeClient"])) {
         const nativeClient = pickEndpointValue(raw, "NativeClient", "nativeClient");
         target.NativeClient = nativeClient instanceof WebSocketNativeClientOptions
             ? nativeClient
-            : new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient));
+            : isRecord(nativeClient)
+                ? new WebSocketNativeClientOptions(nativeClient)
+                : nativeClient;
     }
 }
+function normalizeWebSocketEndpointNumberInput(value) {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return value;
+}
+function normalizeWebSocketEndpointStringArrayInput(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value.map((entry) => typeof entry === "string" ? entry.trim() : entry);
+}
+function normalizeWebSocketEndpointMetadataInput(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        normalized[key] = entry;
+    }
+    return normalized;
+}
 function validateTrafficEndpointDefinitionModel(target) {
     requireNonEmptyString(target.Name, "Endpoint name must be provided.");
     if (target.Mode !== "Produce" && target.Mode !== "Consume") {
@@ -1517,13 +1742,12 @@ class CallbackAdapter {
             return null;
         }
         const resolved = prepareProducedPayload(this.endpoint, payload);
-        const structuredDelegate = resolveStructuredProduceDelegate(this.endpoint);
-        if (structuredDelegate) {
-            return await invokeStructuredProduceDelegate(this.endpoint, resolved, structuredDelegate);
+        const callbacks = selectProduceCallbackGroup(this.endpoint);
+        if (callbacks.asyncDelegate) {
+            return await invokeStructuredProduceDelegate(this.endpoint, resolved, callbacks.asyncDelegate);
         }
-        const delegate = resolveProduceDelegate(this.endpoint);
-        if (delegate) {
-            const next = await delegate(clonePayload(resolved));
+        if (callbacks.syncDelegate) {
+            const next = await callbacks.syncDelegate(clonePayload(resolved));
             return next == null ? null : normalizeTrackingPayload(next);
         }
         return clonePayload(resolved);
@@ -1535,19 +1759,17 @@ class CallbackAdapter {
         if (this.consumeQueue.length > 0) {
             return this.consumeQueue.shift() ?? null;
         }
-        const structuredDelegate = resolveStructuredConsumeDelegate(this.endpoint);
-        if (structuredDelegate) {
-            const next = await structuredDelegate();
-            return normalizeConsumedDelegatePayload(next);
-        }
-        const streamDelegate = resolveStructuredConsumeStreamDelegate(this.endpoint);
-        if (streamDelegate) {
-            this.ensureConsumeStreamStarted(streamDelegate);
+        const callbacks = selectConsumeCallbackGroup(this.endpoint);
+        if (callbacks.asyncDelegate) {
+            if (callbacks.asyncDelegate.length === 0) {
+                const next = await callbacks.asyncDelegate();
+                return normalizeConsumedDelegatePayload(next);
+            }
+            this.ensureConsumeStreamStarted(callbacks.asyncDelegate);
             return this.consumeQueue.shift() ?? null;
         }
-        const delegate = resolveConsumeDelegate(this.endpoint);
-        if (delegate) {
-            const next = await delegate();
+        if (callbacks.syncDelegate) {
+            const next = await callbacks.syncDelegate();
             return next == null ? null : normalizeTrackingPayload(next);
         }
         return this.defaultPayload();
@@ -2313,7 +2535,610 @@ class DelegateStreamEndpointAdapter extends CallbackAdapter {
 }
 class GrpcEndpointAdapter extends CallbackAdapter {
 }
+const NATIVE_WEBSOCKET_FRAME_QUEUE_CAPACITY = 64;
+const NATIVE_WEBSOCKET_FRAME_QUEUE_MAX_BYTES = 1024 * 1024;
+const NATIVE_WEBSOCKET_MAX_PAYLOAD_BYTES = 1024 * 1024;
+class NativeWebSocketAbortError extends Error {
+    constructor() {
+        super("WebSocket native client was interrupted.");
+        this.name = "AbortError";
+    }
+}
+class NativeWebSocketPeerClosedError extends Error {
+    constructor(code, reason) {
+        super(code == null
+            ? "WebSocket peer closed before the operation completed."
+            : `WebSocket peer closed before the operation completed (code ${code}${reason ? `: ${reason}` : ""}).`);
+    }
+}
+class NativeWebSocketReceiveTimeoutError extends Error {
+    constructor() {
+        super("WebSocket receive timed out before the expected message arrived.");
+    }
+}
+class NativeWebSocketSendTimeoutError extends Error {
+    constructor() {
+        super("WebSocket send timed out before the frame was written.");
+        this.code = "ETIMEDOUT";
+    }
+}
+class NativeWebSocketQueueOverflowError extends Error {
+    constructor() {
+        super("WebSocket receive queue exceeded its bounded frame limit.");
+    }
+}
+class NativeWebSocketFrameQueue {
+    constructor(socket) {
+        this.socket = socket;
+        this.frames = [];
+        this.queuedBytes = 0;
+        this.terminalError = null;
+        this.wakeResolver = null;
+        this.onMessage = (data, isBinary) => {
+            const copy = copyNativeWebSocketRawData(data);
+            if (this.frames.length >= NATIVE_WEBSOCKET_FRAME_QUEUE_CAPACITY
+                || this.queuedBytes + copy.byteLength > NATIVE_WEBSOCKET_FRAME_QUEUE_MAX_BYTES) {
+                this.fail(new NativeWebSocketQueueOverflowError());
+                this.socket.terminate();
+                return;
+            }
+            this.frames.push({ data: copy, isBinary });
+            this.queuedBytes += copy.byteLength;
+            this.wake();
+        };
+        this.onError = (error) => {
+            this.fail(error);
+        };
+        this.onClose = (code, reason) => {
+            this.fail(new NativeWebSocketPeerClosedError(code, reason.toString("utf8")));
+        };
+        socket.on("message", this.onMessage);
+        socket.on("error", this.onError);
+        socket.on("close", this.onClose);
+    }
+    async next(deadlineMs, signal) {
+        while (true) {
+            if (signal.aborted) {
+                throw new NativeWebSocketAbortError();
+            }
+            if (isNativeWebSocketOverflowError(this.terminalError)) {
+                throw this.terminalError;
+            }
+            const frame = this.frames.shift();
+            if (frame) {
+                this.queuedBytes -= frame.data.byteLength;
+                return frame;
+            }
+            if (this.terminalError) {
+                throw this.terminalError;
+            }
+            const remainingMs = deadlineMs - Date.now();
+            if (remainingMs <= 0) {
+                throw new NativeWebSocketReceiveTimeoutError();
+            }
+            await this.waitForFrame(remainingMs, signal);
+        }
+    }
+    dispose() {
+        this.socket.off("message", this.onMessage);
+        this.socket.off("error", this.onError);
+        this.socket.off("close", this.onClose);
+        this.wake();
+    }
+    waitForFrame(timeoutMs, signal) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                signal.removeEventListener("abort", onAbort);
+                if (this.wakeResolver === onWake) {
+                    this.wakeResolver = null;
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            };
+            const onWake = () => finish();
+            const onAbort = () => finish(new NativeWebSocketAbortError());
+            const timeout = setTimeout(() => finish(new NativeWebSocketReceiveTimeoutError()), timeoutMs);
+            this.wakeResolver = onWake;
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) {
+                onAbort();
+            }
+        });
+    }
+    fail(error) {
+        this.terminalError ?? (this.terminalError = error);
+        this.wake();
+    }
+    wake() {
+        const resolve = this.wakeResolver;
+        this.wakeResolver = null;
+        resolve?.();
+    }
+}
+function isNativeWebSocketOverflowError(error) {
+    return error instanceof NativeWebSocketQueueOverflowError
+        || String(error?.code ?? "") === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+}
+function copyNativeWebSocketRawData(data) {
+    if (Array.isArray(data)) {
+        return new Uint8Array(Buffer.concat(data));
+    }
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data.slice(0));
+    }
+    return new Uint8Array(Buffer.from(data));
+}
 class WebSocketEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.nativeAbort = new AbortController();
+        this.activeSockets = new Set();
+    }
+    async produce(payload) {
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const delegates = selectProduceCallbackGroup(this.endpoint);
+        if (delegates.asyncDelegate || delegates.syncDelegate) {
+            return super.produce(payload);
+        }
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const configuration = normalizeNativeWebSocketConfiguration(this.endpoint, resolved);
+        await this.executeNative(configuration);
+        resolved.producedUtc ?? (resolved.producedUtc = new Date().toISOString());
+        return resolved;
+    }
+    async consume() {
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const delegates = selectConsumeCallbackGroup(this.endpoint);
+        if (delegates.asyncDelegate || delegates.syncDelegate) {
+            return super.consume();
+        }
+        const configuration = normalizeNativeWebSocketConfiguration(this.endpoint);
+        return this.executeNative(configuration);
+    }
+    interrupt() {
+        if (!this.nativeAbort.signal.aborted) {
+            this.nativeAbort.abort();
+        }
+        for (const socket of this.activeSockets) {
+            socket.terminate();
+        }
+    }
+    async dispose() {
+        this.interrupt();
+    }
+    async executeNative(configuration) {
+        const totalAttempts = configuration.maxAttempts + 1;
+        let lastError;
+        for (let attempt = 1; attempt <= totalAttempts; attempt += 1) {
+            if (this.nativeAbort.signal.aborted) {
+                throw new NativeWebSocketAbortError();
+            }
+            try {
+                return await this.executeNativeOnce(configuration);
+            }
+            catch (error) {
+                lastError = error;
+                if (!isReconnectableNativeWebSocketError(error) || attempt >= totalAttempts) {
+                    throw error;
+                }
+                await waitForNativeWebSocketRetry(configuration.reconnectDelayMs, this.nativeAbort.signal);
+            }
+        }
+        throw lastError;
+    }
+    async executeNativeOnce(configuration) {
+        const options = {
+            headers: configuration.headers,
+            handshakeTimeout: configuration.connectTimeoutMs,
+            followRedirects: false,
+            maxPayload: NATIVE_WEBSOCKET_MAX_PAYLOAD_BYTES
+        };
+        const socket = configuration.subprotocols.length > 0
+            ? new WebSocket(configuration.url, configuration.subprotocols, options)
+            : new WebSocket(configuration.url, options);
+        this.activeSockets.add(socket);
+        const frames = new NativeWebSocketFrameQueue(socket);
+        let pingTimer;
+        try {
+            await waitForNativeWebSocketOpen(socket, configuration.connectTimeoutMs, this.nativeAbort.signal);
+            if (configuration.pingIntervalMs != null) {
+                pingTimer = setInterval(() => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.ping();
+                    }
+                }, configuration.pingIntervalMs);
+                pingTimer.unref?.();
+            }
+            for (const message of configuration.messages) {
+                await sendNativeWebSocketFrame(socket, message, configuration.connectTimeoutMs, this.nativeAbort.signal);
+            }
+            if (this.endpoint.mode === "Produce") {
+                for (const expected of configuration.expectedMessages) {
+                    await receiveExpectedNativeWebSocketFrame(frames, expected, this.nativeAbort.signal);
+                }
+                return null;
+            }
+            if (configuration.expectedMessages.length > 0) {
+                let payload = null;
+                for (const expected of configuration.expectedMessages) {
+                    const frame = await receiveExpectedNativeWebSocketFrame(frames, expected, this.nativeAbort.signal);
+                    payload = nativeWebSocketFrameToTrackingPayload(frame);
+                }
+                return payload;
+            }
+            const frame = await frames.next(Date.now() + configuration.connectTimeoutMs, this.nativeAbort.signal);
+            return nativeWebSocketFrameToTrackingPayload(frame);
+        }
+        finally {
+            if (pingTimer) {
+                clearInterval(pingTimer);
+            }
+            frames.dispose();
+            await closeNativeWebSocket(socket, configuration.closeTimeoutMs);
+            this.activeSockets.delete(socket);
+        }
+    }
+}
+function normalizeNativeWebSocketConfiguration(endpoint, payload) {
+    const options = asRecordOrEmpty(endpoint.webSocket);
+    const native = asRecordOrEmpty(pickEndpointValue(options, "NativeClient", "nativeClient"));
+    const reconnect = asRecordOrEmpty(pickEndpointValue(native, "Reconnect", "reconnect"));
+    if (payload) {
+        validateNativeWebSocketHeaderLayer(payload.headers ?? {}, "payload headers");
+    }
+    const headers = mergeNativeWebSocketHeaders(toStringRecord(pickEndpointValue(native, "Headers", "headers")), resolveConnectionMetadata(endpoint), payload?.headers ?? {});
+    const configuredCookies = pickEndpointValue(native, "Cookies", "cookies");
+    const cookies = Array.isArray(configuredCookies)
+        ? configuredCookies.map((value) => String(value).trim())
+        : [];
+    if (cookies.length > 0) {
+        const cookieName = Object.keys(headers).find((name) => name.toLowerCase() === "cookie");
+        const existing = cookieName ? headers[cookieName] : "";
+        if (cookieName) {
+            delete headers[cookieName];
+        }
+        headers.Cookie = [existing, ...cookies].filter(Boolean).join("; ");
+    }
+    const rawMessages = pickEndpointValue(native, "Messages", "messages");
+    const messages = Array.isArray(rawMessages)
+        ? rawMessages.map(normalizeNativeWebSocketMessage)
+        : [];
+    if (messages.length === 0 && payload) {
+        const projected = projectNativeWebSocketPayload(payload.body);
+        if (projected) {
+            messages.push(projected);
+        }
+    }
+    if (endpoint.mode === "Produce" && messages.length === 0) {
+        throw new Error("Native WebSocket Produce requires at least one configured message or a projected payload body.");
+    }
+    const rawExpected = pickEndpointValue(native, "ExpectedMessages", "expectedMessages");
+    const expectedMessages = Array.isArray(rawExpected)
+        ? rawExpected.map(normalizeNativeWebSocketExpectedMessage)
+        : [];
+    const connectTimeoutMs = nativeWebSocketTimeoutMs(options, 30000, ["ConnectTimeoutMs", "connectTimeoutMs"], ["ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout"]);
+    const closeTimeoutMs = nativeWebSocketTimeoutMs(options, 5000, ["CloseTimeoutMs", "closeTimeoutMs"], ["CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout"]);
+    const pingMsValue = pickEndpointValue(native, "PingIntervalMs", "pingIntervalMs");
+    const pingSecondsValue = pickEndpointValue(native, "PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval");
+    const pingIntervalMs = pingMsValue != null
+        ? Number(pingMsValue)
+        : (pingSecondsValue != null ? Number(pingSecondsValue) * 1000 : undefined);
+    const delayMsValue = pickEndpointValue(reconnect, "DelayMs", "delayMs");
+    const delaySecondsValue = pickEndpointValue(reconnect, "DelaySeconds", "delaySeconds", "Delay", "delay");
+    return {
+        url: optionString(options, "Url", "url"),
+        subprotocols: nativeWebSocketStringArray(pickEndpointValue(options, "Subprotocols", "subprotocols")),
+        connectTimeoutMs,
+        closeTimeoutMs,
+        headers,
+        pingIntervalMs,
+        maxAttempts: Number(pickEndpointValue(reconnect, "MaxAttempts", "maxAttempts") ?? 0),
+        reconnectDelayMs: delayMsValue != null
+            ? Number(delayMsValue)
+            : Number(delaySecondsValue ?? 1) * 1000,
+        messages,
+        expectedMessages
+    };
+}
+function nativeWebSocketTimeoutMs(options, fallbackMs, millisecondKeys, secondKeys) {
+    const millisecondValue = pickEndpointValue(options, ...millisecondKeys);
+    if (millisecondValue != null) {
+        return Number(millisecondValue);
+    }
+    const secondValue = pickEndpointValue(options, ...secondKeys);
+    return secondValue == null ? fallbackMs : Number(secondValue) * 1000;
+}
+function nativeWebSocketStringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry).trim()) : [];
+}
+function normalizeNativeWebSocketMessage(value) {
+    const options = asRecordOrEmpty(value);
+    const kind = optionString(options, "Kind", "kind").toLowerCase();
+    if (kind === "binary") {
+        const bytes = pickEndpointValue(options, "BinaryPayload", "binaryPayload");
+        return {
+            data: bytes instanceof Uint8Array ? new Uint8Array(bytes) : Uint8Array.from(bytes),
+            isBinary: true
+        };
+    }
+    return {
+        data: String(pickEndpointValue(options, "TextPayload", "textPayload") ?? ""),
+        isBinary: false
+    };
+}
+function normalizeNativeWebSocketExpectedMessage(value) {
+    const options = asRecordOrEmpty(value);
+    const bytes = pickEndpointValue(options, "ContainsBytes", "containsBytes");
+    return {
+        containsText: pickEndpointValue(options, "ContainsText", "containsText") == null
+            ? undefined
+            : String(pickEndpointValue(options, "ContainsText", "containsText")),
+        containsBytes: bytes == null
+            ? undefined
+            : (bytes instanceof Uint8Array ? new Uint8Array(bytes) : Uint8Array.from(bytes)),
+        timeoutMs: nativeWebSocketTimeoutMs(options, 30000, ["TimeoutMs", "timeoutMs"], ["TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout"])
+    };
+}
+function projectNativeWebSocketPayload(value) {
+    if (value == null) {
+        return null;
+    }
+    if (value instanceof Uint8Array) {
+        return { data: new Uint8Array(value), isBinary: true };
+    }
+    if (value instanceof ArrayBuffer) {
+        return { data: new Uint8Array(value), isBinary: true };
+    }
+    if (typeof value === "string") {
+        return { data: value, isBinary: false };
+    }
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined) {
+        throw new TypeError("Native WebSocket payload cannot be serialized as JSON.");
+    }
+    return {
+        data: serialized,
+        isBinary: false
+    };
+}
+function mergeNativeWebSocketHeaders(...layers) {
+    const merged = new Map();
+    for (const layer of layers) {
+        for (const [name, value] of Object.entries(layer)) {
+            merged.set(name.toLowerCase(), { name, value: String(value) });
+        }
+    }
+    return Object.fromEntries([...merged.values()].map(({ name, value }) => [name, value]));
+}
+function waitForNativeWebSocketOpen(socket, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            socket.off("open", onOpen);
+            socket.off("error", onError);
+            socket.off("close", onClose);
+            socket.off("unexpected-response", onUnexpectedResponse);
+            signal.removeEventListener("abort", onAbort);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const onOpen = () => finish();
+        const onError = (error) => finish(error);
+        const onClose = (code, reason) => {
+            finish(new NativeWebSocketPeerClosedError(code, reason.toString("utf8")));
+        };
+        const onUnexpectedResponse = (_request, response) => {
+            response.resume();
+            finish(new Error(`WebSocket opening handshake was rejected with HTTP status ${response.statusCode ?? "unknown"}.`));
+            socket.terminate();
+        };
+        const onAbort = () => {
+            finish(new NativeWebSocketAbortError());
+            socket.terminate();
+        };
+        const timeout = setTimeout(() => {
+            const error = new Error("WebSocket connection timed out.");
+            error.code = "ETIMEDOUT";
+            finish(error);
+            socket.terminate();
+        }, timeoutMs);
+        socket.once("open", onOpen);
+        socket.once("error", onError);
+        socket.once("close", onClose);
+        socket.once("unexpected-response", onUnexpectedResponse);
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+    });
+}
+function sendNativeWebSocketFrame(socket, message, timeoutMs, signal) {
+    if (signal.aborted) {
+        return Promise.reject(new NativeWebSocketAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timeout;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            signal.removeEventListener("abort", onAbort);
+            error ? reject(error) : resolve();
+        };
+        const onAbort = () => {
+            finish(new NativeWebSocketAbortError());
+            socket.terminate();
+        };
+        const onTimeout = () => {
+            finish(new NativeWebSocketSendTimeoutError());
+            socket.terminate();
+        };
+        timeout = setTimeout(onTimeout, timeoutMs);
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            socket.send(message.data, { binary: message.isBinary }, (error) => {
+                finish(error ? normalizeNativeWebSocketSendError(socket, error) : undefined);
+            });
+        }
+        catch (error) {
+            finish(normalizeNativeWebSocketSendError(socket, error));
+        }
+    });
+}
+function normalizeNativeWebSocketSendError(socket, error) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const code = String(normalized.code ?? "");
+    const isClosingState = socket.readyState === WebSocket.CLOSING
+        || socket.readyState === WebSocket.CLOSED;
+    const isWsNotOpenStateError = /^WebSocket is not open: readyState [23] \((?:CLOSING|CLOSED)\)$/.test(normalized.message);
+    return !code && isClosingState && isWsNotOpenStateError
+        ? new NativeWebSocketPeerClosedError()
+        : normalized;
+}
+async function receiveExpectedNativeWebSocketFrame(frames, expected, signal) {
+    const deadline = Date.now() + expected.timeoutMs;
+    while (true) {
+        const frame = await frames.next(deadline, signal);
+        if (nativeWebSocketFrameMatches(frame, expected)) {
+            return frame;
+        }
+    }
+}
+function nativeWebSocketFrameMatches(frame, expected) {
+    if (expected.containsBytes) {
+        return bufferContains(frame.data, expected.containsBytes);
+    }
+    if (expected.containsText != null) {
+        return !frame.isBinary && Buffer.from(frame.data).toString("utf8").includes(expected.containsText);
+    }
+    return frame.data.byteLength > 0;
+}
+function bufferContains(value, expected) {
+    if (expected.byteLength === 0) {
+        return true;
+    }
+    return Buffer.from(value).indexOf(Buffer.from(expected)) >= 0;
+}
+function nativeWebSocketFrameToTrackingPayload(frame) {
+    if (frame.isBinary) {
+        return attachPayloadHelpers({
+            headers: {},
+            body: new Uint8Array(frame.data),
+            contentType: "application/octet-stream"
+        });
+    }
+    const text = Buffer.from(frame.data).toString("utf8");
+    let body = text;
+    let contentType = "text/plain";
+    try {
+        body = JSON.parse(text);
+        contentType = "application/json";
+    }
+    catch {
+        // Non-JSON text is returned verbatim.
+    }
+    return attachPayloadHelpers({ headers: {}, body, contentType });
+}
+function isReconnectableNativeWebSocketError(error) {
+    if (error instanceof NativeWebSocketPeerClosedError) {
+        return true;
+    }
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const code = String(error.code ?? "");
+    return new Set([
+        "ECONNABORTED",
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "EHOSTUNREACH",
+        "ENETUNREACH",
+        "ENOTFOUND",
+        "EAI_AGAIN",
+        "EPIPE",
+        "ETIMEDOUT"
+    ]).has(code);
+}
+function waitForNativeWebSocketRetry(delayMs, signal) {
+    if (signal.aborted) {
+        return Promise.reject(new NativeWebSocketAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new NativeWebSocketAbortError());
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function closeNativeWebSocket(socket, timeoutMs) {
+    if (socket.readyState === WebSocket.CLOSED) {
+        return Promise.resolve();
+    }
+    if (socket.readyState === WebSocket.CONNECTING) {
+        socket.terminate();
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            socket.off("close", onClose);
+            socket.off("error", onError);
+            resolve();
+        };
+        const onClose = () => finish();
+        const onError = () => finish();
+        const timeout = setTimeout(() => {
+            socket.terminate();
+            finish();
+        }, timeoutMs);
+        socket.once("close", onClose);
+        socket.once("error", onError);
+        try {
+            socket.close(1000);
+        }
+        catch {
+            socket.terminate();
+            finish();
+        }
+    });
 }
 export class EndpointAdapterFactory {
     static create(endpoint) {
@@ -2322,6 +3147,7 @@ export class EndpointAdapterFactory {
         }
         const normalized = normalizeEndpointDefinition(endpoint);
         validateEndpointDefinition(normalized);
+        validateRawNativeWebSocketHeaderInputs(endpoint, normalized);
         switch (normalized.kind) {
             case "Http":
                 return new HttpEndpointAdapter(normalized);
@@ -2350,6 +3176,56 @@ export class EndpointAdapterFactory {
         }
     }
 }
+function validateRawNativeWebSocketHeaderInputs(input, endpoint) {
+    if (endpoint.kind !== "WebSocket") {
+        return;
+    }
+    const callbacks = endpoint.mode === "Produce"
+        ? selectProduceCallbackGroup(endpoint)
+        : selectConsumeCallbackGroup(endpoint);
+    if (callbacks.asyncDelegate || callbacks.syncDelegate) {
+        return;
+    }
+    const raw = asRecordOrEmpty(input);
+    const options = pickEndpointTransportRecord(raw, "WebSocket", "WebSocket", ["webSocket", "WebSocket"], WEB_SOCKET_ENDPOINT_FLAT_KEYS);
+    if (pickEndpointValue(options, "NativeClient", "nativeClient") == null) {
+        return;
+    }
+    const protocolMetadata = pickEndpointValue(options, "ConnectionMetadata", "connectionMetadata");
+    if (protocolMetadata != null) {
+        validateNativeWebSocketHeaderLayer(protocolMetadata, "ConnectionMetadata");
+    }
+    const rootMetadata = pickEndpointValue(raw, "ConnectionMetadata", "connectionMetadata");
+    if (rootMetadata != null && rootMetadata !== protocolMetadata) {
+        validateNativeWebSocketHeaderLayer(rootMetadata, "ConnectionMetadata");
+    }
+    const delegate = pickEndpointValue(raw, "Delegate", "delegate", "DelegateStream");
+    if (isRecord(delegate)) {
+        const delegateMetadata = pickEndpointValue(delegate, "ConnectionMetadata", "connectionMetadata");
+        if (delegateMetadata != null) {
+            validateNativeWebSocketHeaderLayer(delegateMetadata, "ConnectionMetadata");
+        }
+    }
+}
+export function validateNativeEndpointExecutionSupport(endpoint) {
+    const normalized = normalizeEndpointDefinition(endpoint);
+    if (!normalized || typeof normalized !== "object") {
+        return;
+    }
+    validateRawNativeWebSocketHeaderInputs(endpoint, normalized);
+    const kind = String(normalized.kind ?? "").trim().toLowerCase();
+    const modeToken = String(normalized.mode ?? "").trim().toLowerCase();
+    if (modeToken !== "produce" && modeToken !== "consume") {
+        return;
+    }
+    const mode = modeToken === "produce" ? "Produce" : "Consume";
+    if (kind === "grpc") {
+        validateGrpcEndpoint(normalized, mode);
+    }
+    else if (kind === "websocket") {
+        validateWebSocketEndpoint(normalized, mode);
+    }
+}
 const HTTP_ENDPOINT_FLAT_KEYS = [
     "Url",
     "url",
@@ -2576,7 +3452,9 @@ const WEB_SOCKET_ENDPOINT_FLAT_KEYS = [
     "ConsumeAsync",
     "consumeAsync",
     "ConnectionMetadata",
-    "connectionMetadata"
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
 ];
 function normalizeEndpointDefinition(endpoint) {
     if (!endpoint || typeof endpoint !== "object") {
@@ -2882,6 +3760,10 @@ function pickOptionalEndpointString(record, ...keys) {
     const value = optionString(record, ...keys).trim();
     return value ? value : undefined;
 }
+function pickOptionalEndpointExactString(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    return typeof value === "string" ? value : undefined;
+}
 function pickOptionalEndpointStringAllowEmpty(record, ...keys) {
     const value = pickEndpointValue(record, ...keys);
     return typeof value === "string" ? value.trim() : undefined;
@@ -2985,8 +3867,10 @@ function validateEndpointDefinition(endpoint) {
     if (mode !== "Produce" && mode !== "Consume") {
         throw new Error(`Unsupported endpoint mode: ${mode}.`);
     }
-    const hasProduceDelegate = Boolean(resolveProduceDelegate(endpoint) || resolveStructuredProduceDelegate(endpoint));
-    const hasConsumeDelegate = Boolean(resolveConsumeDelegate(endpoint) || resolveStructuredConsumeDelegate(endpoint) || resolveStructuredConsumeStreamDelegate(endpoint));
+    const produceCallbacks = selectProduceCallbackGroup(endpoint);
+    const consumeCallbacks = selectConsumeCallbackGroup(endpoint);
+    const hasProduceDelegate = Boolean(produceCallbacks.asyncDelegate || produceCallbacks.syncDelegate);
+    const hasConsumeDelegate = Boolean(consumeCallbacks.asyncDelegate || consumeCallbacks.syncDelegate);
     const hasModeDelegate = mode === "Produce" ? hasProduceDelegate : hasConsumeDelegate;
     switch (kind) {
         case "Http":
@@ -3098,7 +3982,14 @@ function validateDelegateStreamEndpoint(endpoint, mode) {
     }
 }
 function validateGrpcEndpoint(endpoint, mode) {
+    const callbacks = mode === "Produce"
+        ? selectProduceCallbackGroup(endpoint)
+        : selectConsumeCallbackGroup(endpoint);
     const options = asRecordOrEmpty(endpoint.grpc);
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null && !callbacks.asyncDelegate && !callbacks.syncDelegate) {
+        throw new Error(NATIVE_GRPC_EXECUTION_UNAVAILABLE_MESSAGE);
+    }
     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.");
@@ -3109,18 +4000,17 @@ function validateGrpcEndpoint(endpoint, mode) {
         || (hasOptionValue(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline") && deadlineSeconds <= 0)) {
         throw new RangeError("Deadline must be greater than zero.");
     }
-    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
-    if (nativeClient != null) {
-        new GrpcNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
-    }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
+    if (mode === "Produce" && !callbacks.asyncDelegate && !callbacks.syncDelegate && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
+    if (mode === "Consume" && !callbacks.asyncDelegate && !callbacks.syncDelegate && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
 function validateWebSocketEndpoint(endpoint, mode) {
+    const callbacks = mode === "Produce"
+        ? selectProduceCallbackGroup(endpoint)
+        : selectConsumeCallbackGroup(endpoint);
     const options = asRecordOrEmpty(endpoint.webSocket);
     const url = requireNonEmptyString(optionString(options, "Url", "url"), "Url must be provided for WebSocket endpoint definitions.");
     let parsed;
@@ -3130,32 +4020,277 @@ function validateWebSocketEndpoint(endpoint, mode) {
     catch {
         throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
     }
-    if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    if ((parsed.protocol !== "ws:" && parsed.protocol !== "wss:")
+        || !parsed.hostname
+        || Boolean(parsed.hash)) {
         throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
     }
-    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.");
-    }
+    validateNativeWebSocketTimerDelay(hasOptionValue(options, "ConnectTimeoutMs", "connectTimeoutMs")
+        ? optionNumber(options, "ConnectTimeoutMs", "connectTimeoutMs")
+        : undefined, hasOptionValue(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout")
+        ? optionNumber(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout")
+        : undefined, "ConnectTimeout");
+    validateNativeWebSocketTimerDelay(hasOptionValue(options, "CloseTimeoutMs", "closeTimeoutMs")
+        ? optionNumber(options, "CloseTimeoutMs", "closeTimeoutMs")
+        : undefined, hasOptionValue(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout")
+        ? optionNumber(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout")
+        : undefined, "CloseTimeout");
     const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
-    if (nativeClient != null) {
-        new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
+    const hasSelectedDelegate = Boolean(callbacks.asyncDelegate || callbacks.syncDelegate);
+    if (nativeClient != null && !hasSelectedDelegate) {
+        if (mode === "Consume" && endpoint.trackingField.trim().toLowerCase().startsWith("header:")) {
+            throw new Error("Native WebSocket Consume cannot use a header TrackingField because WebSocket messages do not contain HTTP response headers.");
+        }
+        if (mode === "Consume" && endpoint.gatherByField?.trim().toLowerCase().startsWith("header:")) {
+            throw new Error("Native WebSocket Consume cannot use a header GatherByField because WebSocket messages do not contain HTTP response headers.");
+        }
+        validateNativeWebSocketSubprotocols(pickEndpointValue(options, "Subprotocols", "subprotocols"));
+        validateNativeWebSocketOptionsWithInstance(nativeClient);
+        validateNativeWebSocketHeaderLayer(resolveConnectionMetadata(endpoint), "ConnectionMetadata");
     }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
+    if (mode === "Produce" && !callbacks.asyncDelegate && !callbacks.syncDelegate && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
+    if (mode === "Consume" && !callbacks.asyncDelegate && !callbacks.syncDelegate && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
+const NATIVE_WEBSOCKET_MANAGED_HEADERS = new Set([
+    "connection",
+    "content-length",
+    "expect",
+    "host",
+    "sec-websocket-accept",
+    "sec-websocket-extensions",
+    "sec-websocket-key",
+    "sec-websocket-protocol",
+    "sec-websocket-version",
+    "upgrade"
+]);
+const NATIVE_WEBSOCKET_HTTP_TOKEN_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+const NATIVE_WEBSOCKET_MAX_RECONNECT_ATTEMPTS = 2147483646;
+const NATIVE_WEBSOCKET_MAX_TIMER_DELAY_MS = 2147483647;
+function validateNativeWebSocketReconnectPolicy(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("WebSocket NativeClient.Reconnect must be an object.");
+    }
+    const maxAttempts = pickEndpointValue(value, "MaxAttempts", "maxAttempts");
+    if (maxAttempts != null) {
+        const number = nativeWebSocketStrictNumber(maxAttempts, "MaxAttempts");
+        if (!Number.isInteger(number) || number < 0 || number > NATIVE_WEBSOCKET_MAX_RECONNECT_ATTEMPTS) {
+            throw new RangeError("MaxAttempts must be a finite nonnegative whole number.");
+        }
+    }
+    validateNativeWebSocketTimerDelay(pickEndpointValue(value, "DelayMs", "delayMs"), pickEndpointValue(value, "DelaySeconds", "delaySeconds", "Delay", "delay"), "Delay", true);
+}
+function validateNativeWebSocketOptions(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("WebSocket NativeClient must be an object.");
+    }
+    const native = value;
+    const headers = pickEndpointValue(native, "Headers", "headers");
+    if (headers != null) {
+        validateNativeWebSocketHeaderLayer(headers, "NativeClient.Headers");
+    }
+    const cookies = pickEndpointValue(native, "Cookies", "cookies");
+    if (cookies != null && !Array.isArray(cookies)) {
+        throw new TypeError("WebSocket NativeClient.Cookies must be an array.");
+    }
+    if (Array.isArray(cookies)) {
+        cookies.forEach((cookie, index) => {
+            if (typeof cookie !== "string") {
+                throw new TypeError(`WebSocket NativeClient.Cookies[${index}] must be a string.`);
+            }
+            if (!cookie.trim()) {
+                throw new Error(`WebSocket NativeClient.Cookies[${index}] must not be blank.`);
+            }
+            if (/\r|\n/.test(cookie)) {
+                throw new Error(`WebSocket NativeClient.Cookies[${index}] must not contain CR or LF characters.`);
+            }
+        });
+    }
+    const pingMs = pickEndpointValue(native, "PingIntervalMs", "pingIntervalMs");
+    const pingSeconds = pickEndpointValue(native, "PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval");
+    validateNativeWebSocketTimerDelay(pingMs, pingSeconds, "PingInterval");
+    const reconnectValue = pickEndpointValue(native, "Reconnect", "reconnect");
+    if (reconnectValue != null) {
+        validateNativeWebSocketReconnectPolicy(reconnectValue);
+        if (reconnectValue instanceof WebSocketReconnectPolicy) {
+            reconnectValue.validate();
+        }
+    }
+    const messages = pickEndpointValue(native, "Messages", "messages");
+    if (messages != null && !Array.isArray(messages)) {
+        throw new TypeError("WebSocket NativeClient.Messages must be an array.");
+    }
+    if (Array.isArray(messages)) {
+        for (const message of messages) {
+            if (message instanceof WebSocketMessageSpec) {
+                message.validate();
+            }
+            else {
+                validateNativeWebSocketMessage(message);
+            }
+        }
+    }
+    const expectedMessages = pickEndpointValue(native, "ExpectedMessages", "expectedMessages");
+    if (expectedMessages != null && !Array.isArray(expectedMessages)) {
+        throw new TypeError("WebSocket NativeClient.ExpectedMessages must be an array.");
+    }
+    if (Array.isArray(expectedMessages)) {
+        for (const expected of expectedMessages) {
+            if (expected instanceof WebSocketExpectedMessage) {
+                expected.validate();
+            }
+            else {
+                validateNativeWebSocketExpectedMessage(expected);
+            }
+        }
+    }
+}
+function validateNativeWebSocketOptionsWithInstance(value) {
+    validateNativeWebSocketOptions(value);
+    if (value instanceof WebSocketNativeClientOptions) {
+        value.validate();
+    }
+}
+function validateNativeWebSocketHeaderLayer(value, layerName) {
+    if (!isRecord(value)) {
+        throw new TypeError(`WebSocket ${layerName} must be an object.`);
+    }
+    for (const [name, headerValue] of Object.entries(value)) {
+        const normalizedName = name.trim();
+        if (!normalizedName) {
+            throw new Error(`WebSocket ${layerName} contains an empty header name.`);
+        }
+        if (name !== normalizedName) {
+            throw new Error(`WebSocket ${layerName} header names must not contain surrounding whitespace.`);
+        }
+        if (/\r|\n/.test(name) || /\r|\n/.test(String(headerValue ?? ""))) {
+            throw new Error(`WebSocket ${layerName} must not contain CR or LF characters.`);
+        }
+        if (!NATIVE_WEBSOCKET_HTTP_TOKEN_PATTERN.test(normalizedName)) {
+            throw new Error(`WebSocket ${layerName} contains an invalid HTTP header name.`);
+        }
+        if (typeof headerValue !== "string") {
+            throw new TypeError(`WebSocket ${layerName} header values must be strings.`);
+        }
+        if (NATIVE_WEBSOCKET_MANAGED_HEADERS.has(normalizedName.toLowerCase())) {
+            throw new Error(`WebSocket ${layerName} must not configure ws-managed header '${normalizedName}'.`);
+        }
+    }
+}
+function validateNativeWebSocketSubprotocols(value) {
+    if (value == null) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new TypeError("WebSocket Subprotocols must be an array.");
+    }
+    const seen = new Set();
+    value.forEach((protocol, index) => {
+        if (typeof protocol !== "string" || !protocol.trim()) {
+            throw new TypeError(`WebSocket Subprotocols[${index}] must be a nonblank string.`);
+        }
+        const normalized = protocol.trim();
+        if (!NATIVE_WEBSOCKET_HTTP_TOKEN_PATTERN.test(normalized)) {
+            throw new Error(`WebSocket Subprotocols[${index}] must be a valid RFC 6455 protocol token.`);
+        }
+        if (seen.has(normalized)) {
+            throw new Error("WebSocket Subprotocols must not contain duplicate values.");
+        }
+        seen.add(normalized);
+    });
+}
+function validateOriginalNativeWebSocketMessage(value) {
+    validateNativeWebSocketMessage({
+        Kind: pickEndpointValue(value, "Kind", "kind") ?? "Text",
+        TextPayload: pickEndpointValue(value, "TextPayload", "textPayload"),
+        BinaryPayload: pickEndpointValue(value, "BinaryPayload", "binaryPayload")
+    });
+}
+function validateNativeWebSocketMessage(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("WebSocket NativeClient.Messages entries must be message objects.");
+    }
+    const kind = optionString(value, "Kind", "kind").toLowerCase();
+    if (kind !== "text" && kind !== "binary") {
+        throw new Error("WebSocket Message kind must be Text or Binary.");
+    }
+    if (kind === "text") {
+        if (typeof pickEndpointValue(value, "TextPayload", "textPayload") !== "string") {
+            throw new TypeError("Text WebSocket messages require TextPayload.");
+        }
+        return;
+    }
+    validateNativeWebSocketBytes(pickEndpointValue(value, "BinaryPayload", "binaryPayload"), "WebSocket binary payload");
+}
+function validateNativeWebSocketExpectedMessage(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("WebSocket NativeClient.ExpectedMessages entries must be expected-message objects.");
+    }
+    const containsText = pickEndpointValue(value, "ContainsText", "containsText");
+    if (containsText != null && typeof containsText !== "string") {
+        throw new TypeError("WebSocket expected ContainsText must be a string.");
+    }
+    const containsBytes = pickEndpointValue(value, "ContainsBytes", "containsBytes");
+    if (containsBytes != null) {
+        validateNativeWebSocketBytes(containsBytes, "WebSocket expected ContainsBytes");
+    }
+    const timeoutMs = pickEndpointValue(value, "TimeoutMs", "timeoutMs");
+    const timeoutSeconds = pickEndpointValue(value, "TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout");
+    validateNativeWebSocketTimerDelay(timeoutMs, timeoutSeconds, "Timeout");
+}
+function validateNativeWebSocketBytes(value, fieldName) {
+    if (value instanceof Uint8Array) {
+        return;
+    }
+    if (!Array.isArray(value) || value.some((byte) => (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255))) {
+        throw new TypeError(`${fieldName} must contain only byte values from 0 through 255.`);
+    }
+}
+function validateNativeWebSocketTimerDelay(millisecondValue, secondValue, fieldName, allowZero = false) {
+    const validateValue = (value, multiplier) => {
+        const number = nativeWebSocketStrictNumber(value, fieldName);
+        if (allowZero ? number < 0 : number <= 0) {
+            throw new RangeError(allowZero
+                ? `${fieldName} must be zero or greater and finite.`
+                : `${fieldName} must be greater than zero and finite.`);
+        }
+        if (number > NATIVE_WEBSOCKET_MAX_TIMER_DELAY_MS / multiplier) {
+            throw new RangeError(`${fieldName} must not exceed 2,147,483,647 milliseconds.`);
+        }
+        return number * multiplier;
+    };
+    const milliseconds = millisecondValue == null
+        ? undefined
+        : validateValue(millisecondValue, 1);
+    const seconds = secondValue == null
+        ? undefined
+        : validateValue(secondValue, 1000);
+    return milliseconds ?? seconds;
+}
+function nativeWebSocketStrictNumber(value, fieldName) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`${fieldName} must be a finite number.`);
+    }
+    return value;
+}
+function validateUnsupportedNativeEndpointMode(endpoint, protocol, mode, hasSelectedDelegate) {
+    const options = protocol === "gRPC"
+        ? asRecordOrEmpty(endpoint.grpc)
+        : asRecordOrEmpty(endpoint.webSocket);
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null && !hasSelectedDelegate) {
+        throw unsupportedNativeEndpointModeError(protocol, mode);
+    }
+}
+function unsupportedNativeEndpointModeError(protocol, mode) {
+    const callbackName = mode === "Produce" ? "Produce" : "Consume";
+    const asyncCallbackName = `${callbackName}Async`;
+    return new Error(`Native ${protocol} ${mode} mode is not supported by the TypeScript SDK. `
+        + `Provide a ${callbackName} or ${asyncCallbackName} callback instead.`);
+}
 function validateHttpAuthOptions(options) {
     const auth = options.auth;
     if (!auth) {
@@ -3330,13 +4465,13 @@ function validatePushDiffusionEndpoint(endpoint, mode) {
     }
     requireNonEmptyString(optionString(options, "ServerUrl", "serverUrl"), "ServerUrl must be provided for Push Diffusion endpoint.");
     requireNonEmptyString(optionString(options, "TopicPath", "topicPath"), "TopicPath must be provided for Push Diffusion endpoint.");
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+    const callbacks = mode === "Produce"
+        ? selectProduceCallbackGroup(endpoint)
+        : selectConsumeCallbackGroup(endpoint);
+    if (mode === "Produce" && !callbacks.asyncDelegate && !callbacks.syncDelegate) {
         throw new Error("PublishAsync delegate must be provided for Push Diffusion producer endpoint.");
     }
-    if (mode === "Consume"
-        && !resolveStructuredConsumeDelegate(endpoint)
-        && !resolveStructuredConsumeStreamDelegate(endpoint)
-        && !resolveConsumeDelegate(endpoint)) {
+    if (mode === "Consume" && !callbacks.asyncDelegate && !callbacks.syncDelegate) {
         throw new Error("SubscribeAsync delegate must be provided for Push Diffusion consumer endpoint.");
     }
 }
@@ -4077,60 +5212,109 @@ function parseBodyObject(body) {
         return null;
     }
 }
+function selectProduceCallbackGroup(endpoint) {
+    const genericAsync = endpoint.delegate?.produceAsync;
+    const genericSync = endpoint.delegate?.produce;
+    if (typeof genericAsync === "function" || typeof genericSync === "function") {
+        return {
+            asyncDelegate: typeof genericAsync === "function" ? genericAsync : undefined,
+            syncDelegate: typeof genericSync === "function" ? genericSync : undefined
+        };
+    }
+    let activeAsync;
+    let activeSync;
+    if (endpoint.kind === "PushDiffusion") {
+        activeAsync = endpoint.pushDiffusion?.PublishAsync
+            ?? endpoint.pushDiffusion?.publishAsync;
+    }
+    else if (endpoint.kind === "Grpc") {
+        activeAsync = endpoint.grpc?.ProduceAsync
+            ?? endpoint.grpc?.produceAsync;
+        activeSync = endpoint.grpc?.Produce
+            ?? endpoint.grpc?.produce;
+    }
+    else if (endpoint.kind === "WebSocket") {
+        activeAsync = endpoint.webSocket?.ProduceAsync
+            ?? endpoint.webSocket?.produceAsync;
+        activeSync = endpoint.webSocket?.Produce
+            ?? endpoint.webSocket?.produce;
+    }
+    return {
+        asyncDelegate: typeof activeAsync === "function"
+            ? activeAsync
+            : undefined,
+        syncDelegate: typeof activeSync === "function"
+            ? activeSync
+            : undefined
+    };
+}
+function selectConsumeCallbackGroup(endpoint) {
+    const genericAsync = endpoint.delegate?.consumeAsync;
+    const genericSync = endpoint.delegate?.consume;
+    if (typeof genericAsync === "function" || typeof genericSync === "function") {
+        return {
+            asyncDelegate: typeof genericAsync === "function" ? genericAsync : undefined,
+            syncDelegate: typeof genericSync === "function" ? genericSync : undefined
+        };
+    }
+    let activeAsync;
+    let activeSync;
+    if (endpoint.kind === "PushDiffusion") {
+        activeAsync = endpoint.pushDiffusion?.SubscribeAsync
+            ?? endpoint.pushDiffusion?.subscribeAsync;
+    }
+    else if (endpoint.kind === "Grpc") {
+        activeAsync = endpoint.grpc?.ConsumeAsync
+            ?? endpoint.grpc?.consumeAsync;
+        activeSync = endpoint.grpc?.Consume
+            ?? endpoint.grpc?.consume;
+    }
+    else if (endpoint.kind === "WebSocket") {
+        activeAsync = endpoint.webSocket?.ConsumeAsync
+            ?? endpoint.webSocket?.consumeAsync;
+        activeSync = endpoint.webSocket?.Consume
+            ?? endpoint.webSocket?.consume;
+    }
+    return {
+        asyncDelegate: typeof activeAsync === "function" ? activeAsync : undefined,
+        syncDelegate: typeof activeSync === "function"
+            ? activeSync
+            : undefined
+    };
+}
 function resolveStructuredProduceDelegate(endpoint) {
-    return endpoint.delegate?.produceAsync
-        ?? endpoint.pushDiffusion?.PublishAsync
-        ?? endpoint.pushDiffusion?.publishAsync
-        ?? endpoint.grpc?.ProduceAsync
-        ?? endpoint.grpc?.produceAsync
-        ?? endpoint.webSocket?.ProduceAsync
-        ?? endpoint.webSocket?.produceAsync;
+    return selectProduceCallbackGroup(endpoint).asyncDelegate;
+}
+function resolveProduceDelegate(endpoint) {
+    return selectProduceCallbackGroup(endpoint).syncDelegate;
 }
 function resolveStructuredConsumeDelegate(endpoint) {
-    const delegate = endpoint.delegate?.consumeAsync
-        ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync
-        ?? endpoint.grpc?.ConsumeAsync
-        ?? endpoint.grpc?.consumeAsync
-        ?? endpoint.webSocket?.ConsumeAsync
-        ?? endpoint.webSocket?.consumeAsync;
+    const delegate = selectConsumeCallbackGroup(endpoint).asyncDelegate;
     return typeof delegate === "function" && delegate.length === 0
         ? delegate
         : undefined;
 }
 function resolveStructuredConsumeStreamDelegate(endpoint) {
-    const delegate = endpoint.delegate?.consumeAsync
-        ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync
-        ?? endpoint.grpc?.ConsumeAsync
-        ?? endpoint.grpc?.consumeAsync
-        ?? endpoint.webSocket?.ConsumeAsync
-        ?? endpoint.webSocket?.consumeAsync;
+    const delegate = selectConsumeCallbackGroup(endpoint).asyncDelegate;
     return typeof delegate === "function" && delegate.length > 0
         ? delegate
         : undefined;
 }
-function resolveProduceDelegate(endpoint) {
-    return endpoint.delegate?.produce
-        ?? endpoint.grpc?.Produce
-        ?? endpoint.grpc?.produce
-        ?? endpoint.webSocket?.Produce
-        ?? endpoint.webSocket?.produce;
-}
 function resolveConsumeDelegate(endpoint) {
-    return endpoint.delegate?.consume
-        ?? endpoint.grpc?.Consume
-        ?? endpoint.grpc?.consume
-        ?? endpoint.webSocket?.Consume
-        ?? endpoint.webSocket?.consume;
+    return selectConsumeCallbackGroup(endpoint).syncDelegate;
 }
 function resolveConnectionMetadata(endpoint) {
+    const activeProtocolMetadata = endpoint.kind === "PushDiffusion"
+        ? toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties)
+        : endpoint.kind === "Grpc"
+            ? toStringRecord(endpoint.grpc?.ConnectionMetadata ?? endpoint.grpc?.connectionMetadata)
+            : endpoint.kind === "WebSocket"
+                ? toStringRecord(endpoint.webSocket?.ConnectionMetadata ?? endpoint.webSocket?.connectionMetadata)
+                : {};
     return {
+        ...activeProtocolMetadata,
         ...(endpoint.connectionMetadata ?? {}),
-        ...(endpoint.delegate?.connectionMetadata ?? {}),
-        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties),
-        ...toStringRecord(endpoint.grpc?.ConnectionMetadata ?? endpoint.grpc?.connectionMetadata),
-        ...toStringRecord(endpoint.webSocket?.ConnectionMetadata ?? endpoint.webSocket?.connectionMetadata)
+        ...(endpoint.delegate?.connectionMetadata ?? {})
     };
 }
 function isStructuredProduceResult(value) {