@loadstrike/loadstrike-sdk 1.0.31601 → 1.0.32601

package/dist/cjs/local.js

@@ -55,9 +55,8 @@ const childProcess = __importStar(require("node:child_process"));
 const node_crypto_1 = require("node:crypto");
 const correlation_js_1 = require("./correlation.js");
 const transports_js_1 = require("./transports.js");
-const internal_build_js_1 = require("./internal-build.js");
+const reporting_containment_js_1 = require("./reporting-containment.js");
 const DEFAULT_LICENSING_API_BASE_URL = "https://licensing.loadstrike.com";
-let developmentLicensingApiBaseUrlOverride;
 const BUILT_IN_WORKER_PLUGIN_NAMES = new Set([
     "loadstrike failed responses",
     "loadstrike correlation"
@@ -111,7 +110,7 @@ class LoadStrikeLocalClient {
         _LoadStrikeLocalClient_signingKeyCache.set(this, new Map());
         _LoadStrikeLocalClient_heartbeatDrains.set(this, new WeakMap());
         assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
-        __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, resolveLicensingApiBaseUrl(), "f");
+        __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, DEFAULT_LICENSING_API_BASE_URL, "f");
         this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
     }
     portalReportingIngestUrl() {
@@ -119,6 +118,7 @@ class LoadStrikeLocalClient {
     }
     async run(request) {
         const sanitized = sanitizeRequest(request);
+        validateContainmentRequest(sanitized);
         const licenseSession = await this.acquireLicenseLease(sanitized);
         try {
             const createdUtc = new Date();
@@ -574,66 +574,27 @@ function sanitizeRequest(request) {
         RunArgs: runArgs
     };
 }
-function normalizeLicensingApiBaseUrl(value) {
-    const normalized = (value ?? "").trim();
-    return normalized || DEFAULT_LICENSING_API_BASE_URL;
-}
-function resolveLicensingApiBaseUrl() {
-    return normalizeLicensingApiBaseUrl(developmentLicensingApiBaseUrlOverride ?? resolveInternalBlackBoxLicensingApiBaseUrl());
-}
-function setDevelopmentLicensingApiBaseUrlOverride(value) {
-    if (value != null && value.trim()) {
-        assertInternalTestHarnessLicensingOverride();
-        const normalized = normalizeLicensingApiBaseUrl(value);
-        if (!isLoopbackHttpBaseUrl(normalized)) {
-            throw new TypeError("Internal development licensing API overrides must use a loopback http URL.");
+function validateContainmentRequest(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    for (const scenarioValue of scenarios) {
+        const scenario = asRecord(scenarioValue);
+        const tracking = asRecord(pickValue(scenario, "Tracking", "tracking"));
+        for (const field of ["Source", "Destination"]) {
+            const endpoint = asRecord(pickValue(tracking, field, field.toLowerCase()));
+            if (Object.keys(endpoint).length > 0) {
+                (0, transports_js_1.validateNativeEndpointExecutionSupport)(endpoint);
+            }
         }
-        developmentLicensingApiBaseUrlOverride = normalized;
-        return;
-    }
-    if (value != null) {
-        assertInternalTestHarnessLicensingOverride();
-    }
-    developmentLicensingApiBaseUrlOverride = undefined;
-}
-function assertInternalTestHarnessLicensingOverride() {
-    if (isInternalTestHarnessCall()) {
-        return;
-    }
-    throw new TypeError("Internal development licensing API override is available only to LoadStrike SDK tests.");
-}
-function isInternalTestHarnessCall() {
-    const stack = String(new Error().stack ?? "").replace(/\\/g, "/").toLowerCase();
-    return stack.includes("/sdk/ts/tests/");
-}
-function isLoopbackHttpBaseUrl(value) {
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        return false;
-    }
-    if (parsed.protocol !== "http:") {
-        return false;
     }
-    const host = parsed.hostname.trim().toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1" || host.endsWith(".localhost");
-}
-function resolveInternalBlackBoxLicensingApiBaseUrl() {
-    const compiledToken = String(internal_build_js_1.BLACKBOX_LICENSING_API_BASE_URL_TOKEN ?? "").trim();
-    if (!compiledToken) {
-        return undefined;
-    }
-    const envToken = String(process.env.LOADSTRIKE_INTERNAL_BLACKBOX_API_BASE_URL_TOKEN ?? "").trim();
-    if (!envToken || envToken !== compiledToken) {
-        return undefined;
-    }
-    const candidate = normalizeLicensingApiBaseUrl(process.env.LOADSTRIKE_INTERNAL_BLACKBOX_API_BASE_URL);
-    if (!isLoopbackHttpBaseUrl(candidate)) {
-        return undefined;
+    const context = asRecord(request.Context);
+    const reportingSinks = asList(pickValue(context, "ReportingSinks", "reportingSinks"));
+    for (const [key, value] of Object.entries(context)) {
+        const normalizedKey = key.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+        if (normalizedKey === "infraconfig") {
+            (0, reporting_containment_js_1.assertNoUnsupportedReportingInfraConfig)(value, reportingSinks);
+        }
     }
-    return candidate;
+    (0, reporting_containment_js_1.assertNoUnsupportedReportingSinkGraph)(reportingSinks);
 }
 function normalizeTimeoutMs(value) {
     if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
@@ -1341,6 +1302,20 @@ function mapEndpointSpec(spec, useLoadStrikeTraceIdHeader = false) {
         redisStreams: asRecord(pickValue(spec, "RedisStreams", "redisStreams")),
         azureEventHubs: asRecord(pickValue(spec, "AzureEventHubs", "azureEventHubs")),
         pushDiffusion: asRecord(pickValue(spec, "PushDiffusion", "pushDiffusion")),
+        grpc: mapEndpointProtocolOptions(spec, ["Grpc", "grpc"], [
+            "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",
+            "NativeClient", "nativeClient"
+        ]),
+        webSocket: mapEndpointProtocolOptions(spec, ["WebSocket", "webSocket"], [
+            "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", "NativeClient", "nativeClient"
+        ]),
         delegate: (typeof delegateProduce === "function"
             || typeof delegateConsume === "function"
             || typeof delegateProduceAsync === "function"
@@ -1363,6 +1338,19 @@ function mapEndpointSpec(spec, useLoadStrikeTraceIdHeader = false) {
             : undefined
     };
 }
+function mapEndpointProtocolOptions(spec, nestedKeys, flatKeys) {
+    const nested = asRecord(pickValue(spec, ...nestedKeys));
+    if (Object.keys(nested).length > 0) {
+        return nested;
+    }
+    const options = {};
+    for (const key of flatKeys) {
+        if (Object.prototype.hasOwnProperty.call(spec, key)) {
+            options[key] = spec[key];
+        }
+    }
+    return options;
+}
 function normalizePayload(payload, endpoint, index) {
     const resolvedBody = payload?.body ?? endpoint.messagePayload;
     const normalized = {
@@ -2319,8 +2307,6 @@ exports.__loadstrikeTestExports = {
     mapEnvironmentClassification,
     mapEndpointSpec,
     normalizeEndpointPayloadValue,
-    normalizeLicensingApiBaseUrl,
-    resolveLicensingApiBaseUrl,
     normalizeNodeType,
     normalizePayload,
     normalizeStringArray,
@@ -2339,7 +2325,6 @@ exports.__loadstrikeTestExports = {
     sanitizeLooseJson,
     sanitizeRequest,
     setJsonPathValue,
-    setDevelopmentLicensingApiBaseUrlOverride,
     sleep,
     stringOrDefault,
     toBoolean,

package/dist/cjs/reporting-containment.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoUnsupportedReportingInfraConfig = assertNoUnsupportedReportingInfraConfig;
+exports.assertNoUnsupportedReportingSinkGraph = assertNoUnsupportedReportingSinkGraph;
+const UNBOUND_EXPANDED_SECTIONS = [
+    ["PrometheusRemoteWrite", "PrometheusRemoteWriteReportingSink"],
+    ["CloudWatch", "CloudWatchReportingSink"],
+    ["Dynatrace", "DynatraceReportingSink"],
+    ["NewRelic", "NewRelicReportingSink"],
+    ["Elasticsearch", "ElasticsearchReportingSink"],
+    ["OpenSearch", "OpenSearchReportingSink"],
+    ["Kafka", "KafkaReportingSink"],
+    ["StatsD", "StatsDReportingSink"],
+    ["DogStatsD", "DogStatsDReportingSink"],
+    ["Netdata", "NetdataStatsDReportingSink"],
+    ["Jsonl", "JsonlFileReportingSink"],
+    ["Webhook", "GenericWebhookReportingSink"]
+];
+function assertNoUnsupportedReportingInfraConfig(infraConfig, sinks = []) {
+    if (!isRecord(infraConfig)) {
+        return;
+    }
+    const selectedSections = selectedExpandedReportingSections(sinks);
+    for (const [sectionName, sinkType] of UNBOUND_EXPANDED_SECTIONS) {
+        if (selectedSections.has(sectionName)
+            && hasNonEmptyReportingSectionAlias(infraConfig, sectionName)) {
+            throw new Error(`Configuration section 'LoadStrike:ReportingSinks:${sectionName}' is not bound automatically by the TypeScript SDK. `
+                + `Construct ${sinkType} explicitly and pass its options directly.`);
+        }
+    }
+}
+function selectedExpandedReportingSections(sinks) {
+    const selected = new Set();
+    const visited = new Set();
+    const inspect = (sink) => {
+        if (!isRecord(sink) || visited.has(sink)) {
+            return;
+        }
+        visited.add(sink);
+        const identities = [
+            sink.licenseFeature,
+            sink.LicenseFeature,
+            sink.feature,
+            sink.Feature
+        ];
+        if (!hasReportingSinkLifecycle(sink)) {
+            identities.push(sink.kind, sink.Kind);
+        }
+        const normalizedIdentities = identities
+            .map(normalizeExpandedSinkIdentity)
+            .filter(Boolean);
+        for (const identity of normalizedIdentities) {
+            const sectionName = EXPANDED_SECTION_BY_IDENTITY.get(identity);
+            if (sectionName) {
+                selected.add(sectionName);
+            }
+        }
+        const children = Array.isArray(sink.sinks)
+            ? sink.sinks
+            : Array.isArray(sink.Sinks)
+                ? sink.Sinks
+                : [];
+        for (const child of children) {
+            inspect(child);
+        }
+    };
+    for (const sink of sinks) {
+        inspect(sink);
+    }
+    return selected;
+}
+const EXPANDED_SECTION_BY_IDENTITY = new Map([
+    ["prometheusremotewrite", "PrometheusRemoteWrite"],
+    ["cloudwatch", "CloudWatch"],
+    ["dynatrace", "Dynatrace"],
+    ["elasticsearch", "Elasticsearch"],
+    ["opensearch", "OpenSearch"],
+    ["newrelic", "NewRelic"],
+    ["webhook", "Webhook"],
+    ["genericwebhook", "Webhook"],
+    ["kafka", "Kafka"],
+    ["statsd", "StatsD"],
+    ["dogstatsd", "DogStatsD"],
+    ["netdata", "Netdata"],
+    ["netdatastatsd", "Netdata"],
+    ["jsonl", "Jsonl"],
+    ["jsonlfile", "Jsonl"]
+]);
+function normalizeExpandedSinkIdentity(value) {
+    let normalized = normalizeIdentityToken(value);
+    const featurePrefix = "extensionsreportingsinks";
+    if (normalized.startsWith(featurePrefix)) {
+        normalized = normalized.slice(featurePrefix.length);
+    }
+    const classSuffix = "reportingsink";
+    if (normalized.endsWith(classSuffix)) {
+        normalized = normalized.slice(0, -classSuffix.length);
+    }
+    return normalized;
+}
+function assertNoUnsupportedReportingSinkGraph(sinks) {
+    const visited = new Set();
+    const active = new Set();
+    const inspect = (sink) => {
+        if (!isRecord(sink)) {
+            return;
+        }
+        if (active.has(sink)) {
+            throw new Error("Composite reporting sink graph cannot contain a cycle.");
+        }
+        if (visited.has(sink)) {
+            return;
+        }
+        active.add(sink);
+        const identityTokens = [sink.sinkName, sink.SinkName, sink.kind, sink.Kind]
+            .map(normalizeIdentityToken)
+            .filter(Boolean);
+        const featureTokens = [sink.licenseFeature, sink.LicenseFeature, sink.feature, sink.Feature]
+            .map((value) => String(value ?? "").trim().toLowerCase())
+            .filter(Boolean);
+        const hasLifecycle = hasReportingSinkLifecycle(sink);
+        const displayName = directVendorDisplayName(hasLifecycle ? [] : identityTokens, hasLifecycle ? [] : featureTokens);
+        if (displayName) {
+            throw unsupportedDirectVendorReportingError(displayName);
+        }
+        if (identityTokens.includes("composite") || identityTokens.includes("compositereportingsink")) {
+            const children = Array.isArray(sink.sinks)
+                ? sink.sinks
+                : Array.isArray(sink.Sinks)
+                    ? sink.Sinks
+                    : [];
+            for (const child of children) {
+                inspect(child);
+            }
+        }
+        active.delete(sink);
+        visited.add(sink);
+    };
+    for (const sink of sinks) {
+        inspect(sink);
+    }
+}
+function hasNonEmptyReportingSectionAlias(infraConfig, sectionName) {
+    const segments = ["LoadStrike", "ReportingSinks", sectionName];
+    const values = [
+        ...readDirectValuesCaseInsensitive(infraConfig, segments.join(":")),
+        ...readDirectValuesCaseInsensitive(infraConfig, segments.join(".")),
+        ...readNestedValuesCaseInsensitive(infraConfig, segments)
+    ];
+    return values.some(isNonEmptySection);
+}
+function readDirectValuesCaseInsensitive(record, key) {
+    const expected = key.toLowerCase();
+    return Object.entries(record)
+        .filter(([candidate]) => candidate.toLowerCase() === expected)
+        .map(([, value]) => value);
+}
+function readNestedValuesCaseInsensitive(record, segments) {
+    let current = [record];
+    for (const segment of segments) {
+        const next = [];
+        for (const candidate of current) {
+            if (isRecord(candidate)) {
+                next.push(...readDirectValuesCaseInsensitive(candidate, segment));
+            }
+        }
+        if (next.length === 0) {
+            return [];
+        }
+        current = next;
+    }
+    return current;
+}
+function isNonEmptySection(value) {
+    if (value == null) {
+        return false;
+    }
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (isRecord(value)) {
+        return Object.keys(value).length > 0;
+    }
+    return true;
+}
+function directVendorDisplayName(identityTokens, featureTokens) {
+    if (identityTokens.includes("prometheusremotewrite")
+        || identityTokens.includes("prometheusremotewritereportingsink")
+        || featureTokens.includes("extensions.reporting_sinks.prometheus_remote_write")) {
+        return "Prometheus Remote Write";
+    }
+    if (identityTokens.includes("cloudwatch")
+        || identityTokens.includes("cloudwatchreportingsink")
+        || featureTokens.includes("extensions.reporting_sinks.cloudwatch")) {
+        return "CloudWatch";
+    }
+    if (identityTokens.includes("dynatrace")
+        || identityTokens.includes("dynatracereportingsink")
+        || featureTokens.includes("extensions.reporting_sinks.dynatrace")) {
+        return "Dynatrace";
+    }
+    if (identityTokens.includes("newrelic")
+        || identityTokens.includes("newrelicreportingsink")
+        || featureTokens.includes("extensions.reporting_sinks.new_relic")) {
+        return "New Relic";
+    }
+    return undefined;
+}
+function unsupportedDirectVendorReportingError(displayName) {
+    return new Error(`Direct ${displayName} reporting is not supported by the TypeScript SDK. `
+        + "Use GenericWebhookReportingSink through a converting gateway or a custom LoadStrikeReportingSink.");
+}
+function normalizeIdentityToken(value) {
+    return String(value ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}
+function hasReportingSinkLifecycle(sink) {
+    return [
+        "init",
+        "Init",
+        "start",
+        "Start",
+        "saveRealtimeStats",
+        "SaveRealtimeStats",
+        "saveRealtimeMetrics",
+        "SaveRealtimeMetrics",
+        "saveRunResult",
+        "SaveRunResult",
+        "saveIterationBatch",
+        "SaveIterationBatch",
+        "stop",
+        "Stop"
+    ].some((member) => typeof sink[member] === "function");
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/cjs/runtime.js

@@ -16,12 +16,15 @@ const reporting_js_1 = require("./reporting.js");
 const report_history_js_1 = require("./report-history.js");
 const local_report_input_js_1 = require("./local-report-input.js");
 const sinks_js_1 = require("./sinks.js");
+const reporting_sink_http_error_js_1 = require("./internal/reporting-sink-http-error.js");
+const reporting_containment_js_1 = require("./reporting-containment.js");
 const load_engine_v2_js_1 = require("./load-engine-v2.js");
 const iteration_observations_js_1 = require("./iteration-observations.js");
 const iteration_observation_diagnostics_js_1 = require("./iteration-observation-diagnostics.js");
 const sink_retry_policy_js_1 = require("./sink-retry-policy.js");
 const LOAD_ENGINE_V2_SCHEDULER_DISTRIBUTIONS = Symbol("loadstrike.load-engine-v2.scheduler-distributions");
 const PORTAL_RUN_TOKEN_PROVIDER = Symbol.for("loadstrike.internal.portal-run-token-provider");
+const REPORTING_INTERVAL_SECONDS = Symbol.for("loadstrike.internal.reporting-interval-seconds");
 exports.LoadStrikeNodeType = {
     SingleNode: "SingleNode",
     Coordinator: "Coordinator",
@@ -747,6 +750,15 @@ class ScenarioStatsAccumulator {
         return attachScenarioStatsAliases(scenario);
     }
 }
+function isRetryableReportingSinkError(sink, error) {
+    if (!(sink instanceof sinks_js_1.PrometheusRemoteWriteReportingSink)) {
+        return true;
+    }
+    if (!(error instanceof reporting_sink_http_error_js_1.ReportingSinkHttpError)) {
+        return true;
+    }
+    return error.status === 429 || error.status < 400 || error.status >= 500;
+}
 class LoadStrikeResponse {
     /**
      * Creates a successful reply.
@@ -3495,6 +3507,8 @@ class LoadStrikeRunner {
         return this.buildContext();
     }
     async run(args = []) {
+        (0, reporting_containment_js_1.assertNoUnsupportedReportingSinkGraph)(this.options.reportingSinks ?? []);
+        assertNoUnsupportedNativeTrackingScenarios(this.scenarios);
         if (this.contextConfigurators.length) {
             return new LoadStrikeRunner(this.scenarios, this.buildContext().toRunnerOptions(), [], this.internalOptions).run(args);
         }
@@ -3506,7 +3520,7 @@ class LoadStrikeRunner {
         const scenarioAccumulators = new Map();
         const scenarioDurationsMs = new Map();
         const stepStats = new Map();
-        const sinks = (this.options.reportingSinks ?? []).map((sink) => (0, sinks_js_1.cloneReportingSinkForRun)(sink));
+        const sinks = (this.options.reportingSinks ?? []).map((sink) => (0, sinks_js_1.cloneReportingSinkForRun)(sink, this.options.infraConfig ?? {}));
         const sinkStates = sinks.map((sink, index) => ({
             sink,
             disabled: false,
@@ -3631,6 +3645,12 @@ class LoadStrikeRunner {
             testInfo,
             getNodeInfo: () => attachNodeInfoAliases({ ...nodeInfo })
         };
+        Object.defineProperty(baseContext, REPORTING_INTERVAL_SECONDS, {
+            value: this.options.reportingIntervalSeconds ?? 5,
+            enumerable: false,
+            configurable: false,
+            writable: false
+        });
         attachBaseContextAliases(baseContext);
         const sinkSession = {
             startedUtc: createdUtc,
@@ -3685,6 +3705,7 @@ class LoadStrikeRunner {
             name: state.name,
             iterationObservationPortalSink: Boolean(state.sink.iterationObservationPortalSink),
             iterationObservationShapeLimited: Boolean(state.sink.iterationObservationShapeLimited),
+            retryableErrorClassifier: (error) => isRetryableReportingSinkError(state.sink, error),
             saveIterationBatch: resolveSinkSaveIterationBatch(state.sink),
             completeIterationObservationStream: resolveSinkCompleteIterationObservationStream(state.sink)
         }));
@@ -4319,7 +4340,9 @@ class LoadStrikeRunner {
                 return;
             }
             catch (error) {
-                const exhausted = attempts >= maximumAttempts;
+                const retryable = isRetryableReportingSinkError(state.sink, error);
+                const exhausted = attempts >= maximumAttempts || !retryable;
+                const reportedMaximumAttempts = retryable ? maximumAttempts : attempts;
                 const nextDelayMs = exhausted ? 0 : (0, sink_retry_policy_js_1.sinkRetryDelayMs)(backoffMs, attempts);
                 (0, iteration_observation_diagnostics_js_1.logIterationObservationFailure)(logger, exhausted ? "error" : "warn", {
                     sinkName: state.name,
@@ -4329,7 +4352,7 @@ class LoadStrikeRunner {
                     resultOwnerId: "",
                     observationCount: 0,
                     attempt: attempts,
-                    maximumAttempts,
+                    maximumAttempts: reportedMaximumAttempts,
                     nextDelayMs
                 }, error);
                 if (exhausted) {
@@ -8896,6 +8919,7 @@ class ManagedScenarioTrackingRuntime {
     }
     async dispose() {
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         this.rejectOutstandingWaiters();
         await Promise.all([
             this.sourceLoop,
@@ -8961,6 +8985,7 @@ class ManagedScenarioTrackingRuntime {
             failureSeen = failureSeen || this.isFailedObservationOutcome(outcome);
         }
         this.shutdown = true;
+        this.interruptEndpointAdapters();
         await Promise.all([
             this.sourceLoop,
             this.destinationLoop,
@@ -8977,6 +9002,20 @@ class ManagedScenarioTrackingRuntime {
             ? LoadStrikeResponse.fail("tracking_failures", "One or more observed source or destination events did not correlate successfully.", 0)
             : LoadStrikeResponse.ok("observed");
     }
+    interruptEndpointAdapters() {
+        try {
+            this.sourceAdapter.interrupt?.();
+        }
+        catch {
+            // Shutdown remains best-effort and still disposes every adapter below.
+        }
+        try {
+            this.destinationAdapter?.interrupt?.();
+        }
+        catch {
+            // Shutdown remains best-effort and still disposes every adapter below.
+        }
+    }
     async consumeSourceLoop() {
         while (!this.shutdown) {
             try {
@@ -9568,6 +9607,20 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
         azureEventHubs: asTrackingRecord(pickTrackingValue(spec, "AzureEventHubs", "azureEventHubs")),
         sqs: asTrackingRecord(pickTrackingValue(spec, "Sqs", "sqs")),
         pushDiffusion: asTrackingRecord(pickTrackingValue(spec, "PushDiffusion", "pushDiffusion")),
+        grpc: mapRuntimeEndpointProtocolOptions(spec, ["Grpc", "grpc"], [
+            "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",
+            "NativeClient", "nativeClient"
+        ]),
+        webSocket: mapRuntimeEndpointProtocolOptions(spec, ["WebSocket", "webSocket"], [
+            "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", "NativeClient", "nativeClient"
+        ]),
         delegate: typeof delegateProduce === "function"
             || typeof delegateConsume === "function"
             || typeof delegateProduceAsync === "function"
@@ -9590,6 +9643,19 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
             : undefined
     };
 }
+function mapRuntimeEndpointProtocolOptions(spec, nestedKeys, flatKeys) {
+    const nested = asTrackingRecord(pickTrackingValue(spec, ...nestedKeys));
+    if (Object.keys(nested).length > 0) {
+        return nested;
+    }
+    const options = {};
+    for (const key of flatKeys) {
+        if (Object.prototype.hasOwnProperty.call(spec, key)) {
+            options[key] = pickTrackingValue(spec, key);
+        }
+    }
+    return options;
+}
 function normalizeRuntimeTrackingPayload(payload, endpoint, index) {
     const normalized = {
         headers: {
@@ -10353,6 +10419,20 @@ function assertNoDisableLicenseEnforcementOption(value, source) {
         }
     }
 }
+function assertNoUnsupportedNativeTrackingScenarios(scenarios) {
+    for (const scenario of scenarios) {
+        const tracking = scenario.getTrackingConfiguration();
+        if (!tracking) {
+            continue;
+        }
+        for (const field of ["Source", "Destination"]) {
+            const endpoint = asTrackingRecord(pickTrackingValue(tracking, field, field.toLowerCase()));
+            if (Object.keys(endpoint).length > 0) {
+                (0, transports_js_1.validateNativeEndpointExecutionSupport)(endpoint);
+            }
+        }
+    }
+}
 function normalizeRunContextCollectionShapes(values) {
     assertNoDisableLicenseEnforcementOption(values, "LoadStrikeContext");
     const normalized = {