@loadstrike/loadstrike-sdk 0.1.0

package/dist/cjs/local.js

@@ -0,0 +1,1884 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadStrikeLocalClient = exports.DEFAULT_LICENSING_API_BASE_URL = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const fs = __importStar(require("node:fs"));
+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");
+exports.DEFAULT_LICENSING_API_BASE_URL = "https://licensing.loadstrike.com";
+const BUILT_IN_WORKER_PLUGIN_NAMES = new Set([
+    "loadstrike failed responses",
+    "loadstrike correlation"
+]);
+const SINK_FEATURE_BY_KIND = {
+    influxdb: "extensions.reporting_sinks.influxdb",
+    timescaledb: "extensions.reporting_sinks.timescaledb",
+    grafanaloki: "extensions.reporting_sinks.grafana_loki",
+    datadog: "extensions.reporting_sinks.datadog",
+    splunk: "extensions.reporting_sinks.splunk",
+    otelcollector: "extensions.reporting_sinks.otel_collector"
+};
+const TRACKING_FEATURE_BY_KIND = {
+    http: "endpoint.http",
+    kafka: "endpoint.kafka",
+    rabbitmq: "endpoint.rabbitmq",
+    azureeventhubs: "endpoint.azure_event_hubs",
+    pushdiffusion: "endpoint.push_diffusion",
+    delegatestream: "endpoint.delegate_stream",
+    nats: "endpoint.nats",
+    redisstreams: "endpoint.redis_streams"
+};
+const CI_ENVIRONMENT_VARIABLES = [
+    "GITHUB_ACTIONS",
+    "GITLAB_CI",
+    "TF_BUILD",
+    "BUILD_BUILDID",
+    "JENKINS_URL",
+    "TEAMCITY_VERSION",
+    "CIRCLECI",
+    "BUILDKITE",
+    "TRAVIS",
+    "APPVEYOR",
+    "BITBUCKET_BUILD_NUMBER",
+    "CODEBUILD_BUILD_ID",
+    "DRONE",
+    "SEMAPHORE",
+    "HEROKU_TEST_RUN_ID"
+];
+class LoadStrikeLocalClient {
+    constructor(options = {}) {
+        this.signingKeyCache = new Map();
+        assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
+        this.licensingApiBaseUrl = normalizeLicensingApiBaseUrl(options.licensingApiBaseUrl);
+        this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
+    }
+    async run(request) {
+        const sanitized = sanitizeRequest(request);
+        const licenseSession = await this.acquireLicenseLease(sanitized);
+        try {
+            const createdUtc = new Date();
+            const context = asRecord(sanitized.Context);
+            const scenarios = Array.isArray(sanitized.Scenarios) ? sanitized.Scenarios : [];
+            let allRequestCount = 0;
+            let allOkCount = 0;
+            let allFailCount = 0;
+            const thresholdResults = [];
+            const scenarioRows = [];
+            for (const [index, scenarioValue] of scenarios.entries()) {
+                const scenario = asRecord(scenarioValue);
+                const name = stringOrDefault(scenario.Name, "unknown");
+                const requestCount = computeScenarioRequestCount(scenario);
+                const startedMs = Date.now();
+                const scenarioOutcome = await evaluateScenarioOutcome(scenario, requestCount, context);
+                const durationMs = Math.max(Date.now() - startedMs, 0);
+                const okCount = scenarioOutcome.okCount;
+                const failCount = scenarioOutcome.failCount;
+                const actualRequestCount = scenarioOutcome.requestCount;
+                allRequestCount += actualRequestCount;
+                allOkCount += okCount;
+                allFailCount += failCount;
+                thresholdResults.push(...evaluateScenarioThresholds(scenario, {
+                    scenarioName: name,
+                    requestCount: actualRequestCount,
+                    okCount,
+                    failCount,
+                    durationMs
+                }));
+                scenarioRows.push(buildScenarioStatsContractRow(name, index, actualRequestCount, okCount, failCount, durationMs));
+            }
+            const completedUtc = new Date();
+            return {
+                CompletedUtc: completedUtc,
+                Stats: buildNodeStatsContract(context, createdUtc, completedUtc, {
+                    allRequestCount,
+                    allOkCount,
+                    allFailCount,
+                    scenarios: scenarioRows,
+                    thresholds: thresholdResults
+                })
+            };
+        }
+        finally {
+            await this.releaseLicenseLease(licenseSession, sanitized);
+        }
+    }
+    async acquireLicenseLease(request) {
+        return this.validateLicenseIfRequired(request);
+    }
+    async releaseLicenseLease(session, request) {
+        await this.stopLicenseLeaseIfRequired(session, request);
+    }
+    async validateLicenseIfRequired(request) {
+        const context = asRecord(request.Context);
+        const nodeType = normalizeNodeType(pickValue(context, "NodeType", "nodeType"));
+        if (nodeType === "agent") {
+            return {};
+        }
+        const runnerKey = stringOrDefault(context.RunnerKey, "").trim();
+        if (!runnerKey) {
+            throw new Error("Runner key is required. Call WithRunnerKey(...) before Run().");
+        }
+        const sessionId = stringOrDefault(context.SessionId, "").trim() || generateSessionId();
+        context.SessionId = sessionId;
+        const machineName = node_os_1.default.hostname();
+        const environmentClassification = detectEnvironmentClassification(nodeType);
+        const computedDeviceHash = deviceHash();
+        const requestedFeatures = collectRequestedFeatures(request);
+        const payload = {
+            RunnerKey: runnerKey,
+            RequestedFeatures: requestedFeatures,
+            SessionId: sessionId,
+            TestSuite: stringOrDefault(context.TestSuite, ""),
+            TestName: stringOrDefault(context.TestName, ""),
+            NodeType: stringOrDefault(context.NodeType, nodeType),
+            MachineName: machineName,
+            EnvironmentClassification: environmentClassification,
+            DeviceHash: computedDeviceHash
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
+        try {
+            const { response, json } = await this.postLicensingRequest("/api/v1/licenses/validate", payload, controller.signal);
+            if (!response.ok || json.IsValid !== true) {
+                const denialCode = stringOrDefault(json.DenialCode, "unknown_denial");
+                const details = stringOrDefault(json.Message, "No additional details provided.");
+                throw new Error(`Runner key validation denied for '${runnerKey}'. Reason: ${denialCode}. ${details}`);
+            }
+            const runToken = stringOrDefault(pickValue(json, "RunToken", "SignedRunToken", "Token", "runToken"), "").trim();
+            if (!runToken) {
+                throw new Error("Runner key validation failed: run token is missing.");
+            }
+            await this.verifySignedRunToken(runToken, request, requestedFeatures, runnerKey, sessionId, computedDeviceHash);
+            const heartbeatIntervalSeconds = Math.max(asInt(pickValue(json, "HeartbeatIntervalSeconds", "heartbeatIntervalSeconds")), 1);
+            const heartbeatTimer = setInterval(() => {
+                void this.sendRunTokenHeartbeat({
+                    runToken,
+                    sessionId,
+                    deviceHash: computedDeviceHash,
+                    machineName,
+                    environmentClassification
+                }).catch(() => {
+                    // Best-effort heartbeat: server-side lease expiration is authoritative.
+                });
+            }, heartbeatIntervalSeconds * 1000);
+            if (typeof heartbeatTimer.unref === "function") {
+                heartbeatTimer.unref();
+            }
+            return {
+                runToken,
+                sessionId,
+                deviceHash: computedDeviceHash,
+                machineName,
+                environmentClassification,
+                heartbeatTimer
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async verifySignedRunToken(runToken, request, requestedFeatures, runnerKey, sessionId, deviceHashValue) {
+        const parsed = parseJwt(runToken);
+        const keyId = stringOrDefault(parsed.header.kid, "default");
+        const algorithm = stringOrDefault(parsed.header.alg, "RS256").toUpperCase();
+        if (algorithm !== "RS256") {
+            throw new Error("Runner key validation denied. DenialCode=invalid_run_token_signature, Message=Invalid run token signature.");
+        }
+        const keyRecord = await this.getSigningKey(keyId, algorithm);
+        if (!verifyJwtSignature(runToken, keyRecord, algorithm)) {
+            throw new Error("Runner key validation denied. DenialCode=invalid_run_token_signature, Message=Invalid run token signature.");
+        }
+        enforceJwtLifetime(parsed.payload);
+        const tokenIssuer = stringOrDefault(parsed.payload.iss, "").trim();
+        if (!keyRecord.issuer || tokenIssuer !== keyRecord.issuer) {
+            throw new Error("Runner key validation failed: run token issuer does not match.");
+        }
+        const rawAudience = parsed.payload.aud;
+        const tokenAudiences = Array.isArray(rawAudience)
+            ? rawAudience.map((entry) => stringOrDefault(entry, "").trim()).filter((entry) => entry.length > 0)
+            : stringOrDefault(rawAudience, "").trim()
+                ? [stringOrDefault(rawAudience, "").trim()]
+                : [];
+        if (!keyRecord.audience || !tokenAudiences.includes(keyRecord.audience)) {
+            throw new Error("Runner key validation failed: run token audience does not match.");
+        }
+        const tokenRunnerKey = stringOrDefault(parsed.payload.runner_key, "").trim();
+        if (tokenRunnerKey !== runnerKey) {
+            throw new Error("Runner key validation failed: run token runner key does not match.");
+        }
+        const tokenSessionId = stringOrDefault(parsed.payload.session_id, "").trim();
+        if (tokenSessionId !== sessionId) {
+            throw new Error("Runner key validation failed: run token session id does not match.");
+        }
+        const tokenDeviceHash = stringOrDefault(parsed.payload.device_hash, "").trim();
+        if (tokenDeviceHash !== deviceHashValue) {
+            throw new Error("Runner key validation failed: run token device hash does not match.");
+        }
+        enforceEntitlementClaims(parsed.payload, requestedFeatures);
+        enforceRuntimePolicyClaims(parsed.payload, request);
+    }
+    async getSigningKey(keyId, algorithm) {
+        const nowMs = Date.now();
+        const cacheKey = this.licensingApiBaseUrl.toLowerCase();
+        const cached = this.signingKeyCache.get(cacheKey);
+        if (cached && cached.expiresAtUtc > nowMs) {
+            return cached;
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
+        try {
+            const { response, json } = await this.getLicensingRequest("/api/v1/licenses/signing-public-key", controller.signal);
+            if (!response.ok) {
+                throw new Error(`Failed to resolve licensing signing key. status=${response.status}`);
+            }
+            const resolvedAlgorithm = stringOrDefault(pickValue(json, "Algorithm", "alg"), algorithm).toUpperCase();
+            const publicKeyPem = stringOrDefault(pickValue(json, "PublicKeyPem", "PublicKey", "Pem"), "");
+            if (!publicKeyPem.trim()) {
+                throw new Error("Runner key validation failed: signing key response is empty.");
+            }
+            const keyRecord = {
+                keyId: stringOrDefault(pickValue(json, "KeyId", "Kid", "kid"), keyId),
+                algorithm: resolvedAlgorithm,
+                issuer: stringOrDefault(pickValue(json, "Issuer", "issuer"), ""),
+                audience: stringOrDefault(pickValue(json, "Audience", "audience"), ""),
+                publicKeyPem,
+                expiresAtUtc: nowMs + (15 * 60 * 1000)
+            };
+            this.signingKeyCache.set(cacheKey, keyRecord);
+            return keyRecord;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async sendRunTokenHeartbeat(payload, signal) {
+        const heartbeatPayload = {
+            RunToken: payload.runToken,
+            SessionId: payload.sessionId,
+            DeviceHash: payload.deviceHash,
+            MachineName: payload.machineName,
+            EnvironmentClassification: payload.environmentClassification
+        };
+        const controller = signal ? null : new AbortController();
+        const timer = controller
+            ? setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs)
+            : null;
+        const { response } = await this.postLicensingRequest("/api/v1/licenses/heartbeat", heartbeatPayload, signal ?? controller.signal);
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (!response.ok) {
+            throw new Error(`Runner key validation denied. DenialCode=run_token_heartbeat_failed, Message=Run token heartbeat failed with status ${response.status}.`);
+        }
+    }
+    async stopLicenseLeaseIfRequired(session, _request) {
+        if (session.heartbeatTimer) {
+            clearInterval(session.heartbeatTimer);
+        }
+        if (!session.runToken) {
+            return;
+        }
+        const payload = {
+            RunToken: session.runToken,
+            SessionId: session.sessionId ?? "",
+            DeviceHash: session.deviceHash ?? ""
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
+        try {
+            await this.postLicensingRequest("/api/v1/licenses/stop", payload, controller.signal);
+        }
+        catch {
+            // Stop is best-effort for local execution.
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async postLicensingRequest(path, payload, signal) {
+        const response = await fetch(`${this.licensingApiBaseUrl.replace(/\/+$/, "")}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            },
+            body: JSON.stringify(payload),
+            signal
+        });
+        let json = {};
+        try {
+            json = (await response.json());
+        }
+        catch {
+            json = {};
+        }
+        return { response, json };
+    }
+    async getLicensingRequest(path, signal) {
+        const response = await fetch(`${this.licensingApiBaseUrl.replace(/\/+$/, "")}${path}`, {
+            method: "GET",
+            headers: {
+                Accept: "application/json"
+            },
+            signal
+        });
+        let json = {};
+        try {
+            json = (await response.json());
+        }
+        catch {
+            json = {};
+        }
+        return { response, json };
+    }
+}
+exports.LoadStrikeLocalClient = LoadStrikeLocalClient;
+function assertNoDisableLicenseEnforcementOption(value, source) {
+    if (value == null || typeof value !== "object" || Array.isArray(value)) {
+        return;
+    }
+    for (const key of Object.keys(value)) {
+        const normalized = key.toLowerCase().replace(/[^a-z0-9]+/g, "");
+        if (normalized === "disablelicenseenforcement") {
+            throw new TypeError(`${source} cannot include disable license enforcement options.`);
+        }
+    }
+}
+function sanitizeRequest(request) {
+    const context = request.Context ?? {};
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    const runArgs = Array.isArray(request.RunArgs) ? request.RunArgs : [];
+    return {
+        Context: context,
+        Scenarios: scenarios,
+        RunArgs: runArgs
+    };
+}
+function normalizeLicensingApiBaseUrl(value) {
+    const normalized = (value ?? "").trim();
+    return normalized || exports.DEFAULT_LICENSING_API_BASE_URL;
+}
+function normalizeTimeoutMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return 10000;
+    }
+    return Math.trunc(value);
+}
+function generateSessionId() {
+    return (0, node_crypto_1.randomUUID)().replace(/-/g, "");
+}
+function collectRequestedFeatures(request) {
+    const context = asRecord(request.Context);
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    const features = new Set([
+        "core.runtime",
+        "reporting.formats.standard"
+    ]);
+    if (toBoolean(pickValue(context, "LocalDevClusterEnabled", "localDevClusterEnabled"), false)) {
+        features.add("cluster.local_dev");
+    }
+    if (stringOrDefault(pickValue(context, "NatsServerUrl", "natsServerUrl"), "").trim()) {
+        features.add("cluster.distributed.nats");
+    }
+    const hasAdvancedTargeting = normalizeStringArray(pickValue(context, "AgentTargetScenarios", "agentTargetScenarios")).length > 0
+        || normalizeStringArray(pickValue(context, "CoordinatorTargetScenarios", "coordinatorTargetScenarios")).length > 0
+        || resolveTimeoutSeconds(context, "ClusterCommandTimeoutSeconds", "clusterCommandTimeoutSeconds", "ClusterCommandTimeoutMs", "clusterCommandTimeoutMs", 120) !== 120;
+    if (hasAdvancedTargeting) {
+        features.add("cluster.targeting_and_tuning.advanced");
+    }
+    if (countCustomWorkerPlugins(context) > 0) {
+        features.add("extensions.worker_plugins.custom");
+    }
+    const reportingSinks = asList(pickValue(context, "ReportingSinks", "reportingSinks"));
+    let hasCustomSink = false;
+    for (const sink of reportingSinks) {
+        const sinkRecord = asRecord(sink);
+        const runtimeSink = isRuntimeReportingSink(sink);
+        const explicitFeature = stringOrDefault(pickValue(sinkRecord, "LicenseFeature", "licenseFeature", "Feature", "feature"), stringOrDefault(sink.licenseFeature, stringOrDefault(sink.LicenseFeature, ""))).trim();
+        if (explicitFeature) {
+            features.add(explicitFeature);
+            continue;
+        }
+        if (!runtimeSink) {
+            const sinkKind = stringOrDefault(pickValue(sinkRecord, "Kind", "kind"), "").trim();
+            const normalizedKind = sinkKind.toLowerCase().replace(/[^a-z0-9]+/g, "");
+            const mappedKindFeature = SINK_FEATURE_BY_KIND[normalizedKind];
+            if (mappedKindFeature) {
+                features.add(mappedKindFeature);
+                continue;
+            }
+        }
+        hasCustomSink = true;
+    }
+    if (hasCustomSink) {
+        features.add("extensions.reporting_sinks.custom");
+    }
+    if (pickValue(context, "ReportFinalizer", "reportFinalizer") != null) {
+        features.add("policy.report_finalizer_and_threshold_controls");
+    }
+    for (const scenarioValue of scenarios) {
+        const scenario = asRecord(scenarioValue);
+        for (const feature of normalizeStringArray(pickValue(scenario, "LicenseFeatures", "licenseFeatures"))) {
+            features.add(feature);
+        }
+        if (asList(scenario.Thresholds).length > 0) {
+            features.add("policy.report_finalizer_and_threshold_controls");
+        }
+        const tracking = asRecord(scenario.Tracking);
+        const source = asRecord(tracking.Source);
+        const destination = asRecord(tracking.Destination);
+        if (!Object.keys(source).length && !Object.keys(destination).length) {
+            continue;
+        }
+        const sourceKind = stringOrDefault(pickValue(source, "Kind", "kind"), "").trim().toLowerCase();
+        if (sourceKind && TRACKING_FEATURE_BY_KIND[sourceKind]) {
+            features.add(TRACKING_FEATURE_BY_KIND[sourceKind]);
+        }
+        const destinationKind = stringOrDefault(pickValue(destination, "Kind", "kind"), "").trim().toLowerCase();
+        if (destinationKind && TRACKING_FEATURE_BY_KIND[destinationKind]) {
+            features.add(TRACKING_FEATURE_BY_KIND[destinationKind]);
+        }
+        else if (Object.keys(source).length > 0) {
+            features.add("crossplatform.source_only_reporting");
+        }
+        features.add("crossplatform.tracking.selectors");
+        features.add("reporting.correlation.grouped");
+        const correlationStore = asRecord(pickValue(tracking, "CorrelationStore", "correlationStore"));
+        const storeKind = stringOrDefault(pickValue(correlationStore, "Kind", "kind"), "").trim().toLowerCase();
+        if (storeKind === "redis") {
+            features.add("correlation.store.redis");
+        }
+    }
+    return Array.from(features)
+        .map((feature) => feature.trim().toLowerCase())
+        .filter((feature) => feature.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+function mapEnvironmentClassification(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "ci") {
+        return 1;
+    }
+    if (normalized === "kubernetes") {
+        return 2;
+    }
+    if (normalized === "clustercontroller") {
+        return 3;
+    }
+    return 0;
+}
+function detectEnvironmentClassification(nodeType) {
+    if (isCiHost()) {
+        return 1;
+    }
+    if (isKubernetesHost()) {
+        return 2;
+    }
+    if (isLocalHost()) {
+        return 0;
+    }
+    return nodeType === "coordinator" ? 3 : 1;
+}
+function isCiHost() {
+    if (hasTruthyEnv("CI")) {
+        return true;
+    }
+    return CI_ENVIRONMENT_VARIABLES.some((name) => hasNonBlankEnv(name));
+}
+function isKubernetesHost() {
+    return hasNonBlankEnv("KUBERNETES_SERVICE_HOST")
+        || hasNonBlankEnv("KUBERNETES_PORT")
+        || fs.existsSync("/var/run/secrets/kubernetes.io/serviceaccount/token");
+}
+function isLocalHost() {
+    if (process.platform === "win32") {
+        return !isWindowsServerProduct(readWindowsProductName());
+    }
+    if (process.platform === "darwin") {
+        return true;
+    }
+    if (process.platform === "linux") {
+        return isLinuxLocalHost();
+    }
+    const osDescription = resolveOsDescription().toLowerCase();
+    return osDescription.includes("android")
+        || osDescription.includes("ios")
+        || osDescription.includes("iphone")
+        || osDescription.includes("ipad");
+}
+function isLinuxLocalHost() {
+    if (isWslHost()) {
+        return !isWindowsServerProduct(readWslWindowsProductName());
+    }
+    if (isContainerHost()) {
+        return false;
+    }
+    const osDescription = resolveOsDescription().toLowerCase();
+    if (osDescription.includes("android")) {
+        return true;
+    }
+    return hasLinuxDesktopSession();
+}
+function isContainerHost() {
+    if (hasTruthyEnv("container")) {
+        return true;
+    }
+    if (fs.existsSync("/.dockerenv") || fs.existsSync("/run/.containerenv")) {
+        return true;
+    }
+    return fileContains("/proc/1/cgroup", ["docker", "containerd", "podman", "kubepods", "lxc"])
+        || fileContains("/proc/self/cgroup", ["docker", "containerd", "podman", "kubepods", "lxc"]);
+}
+function isWslHost() {
+    return hasNonBlankEnv("WSL_INTEROP")
+        || hasNonBlankEnv("WSL_DISTRO_NAME")
+        || fileContains("/proc/version", ["microsoft"])
+        || fileContains("/proc/sys/kernel/osrelease", ["microsoft"]);
+}
+function hasLinuxDesktopSession() {
+    if (["DISPLAY", "WAYLAND_DISPLAY", "XDG_CURRENT_DESKTOP", "DESKTOP_SESSION", "MIR_SOCKET"].some((name) => hasNonBlankEnv(name))) {
+        return true;
+    }
+    const sessionType = stringOrDefault(process.env.XDG_SESSION_TYPE, "").trim().toLowerCase();
+    return sessionType === "x11" || sessionType === "wayland";
+}
+function hasNonBlankEnv(name) {
+    const value = process.env[name];
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasTruthyEnv(name) {
+    const value = process.env[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+function fileContains(path, markers) {
+    try {
+        if (!fs.existsSync(path)) {
+            return false;
+        }
+        const content = fs.readFileSync(path, "utf8");
+        return markers.some((marker) => content.toLowerCase().includes(marker.toLowerCase()));
+    }
+    catch {
+        return false;
+    }
+}
+function isWindowsServerProduct(value) {
+    return value.trim().toLowerCase().includes("server");
+}
+function resolveOsDescription() {
+    const osVersion = node_os_1.default.version;
+    return typeof osVersion === "function"
+        ? osVersion.call(node_os_1.default)
+        : `${node_os_1.default.type()} ${node_os_1.default.release()}`;
+}
+function deviceHash() {
+    const components = [];
+    const osDescription = resolveOsDescription();
+    addIfNotBlank(components, osDescription);
+    addIfNotBlank(components, node_os_1.default.arch());
+    addIfNotBlank(components, node_os_1.default.hostname());
+    if (process.platform === "win32") {
+        addIfNotBlank(components, readWindowsMachineGuid());
+    }
+    else if (process.platform === "linux") {
+        addIfNotBlank(components, readLinuxMachineId());
+    }
+    else if (process.platform === "darwin") {
+        addIfNotBlank(components, readMacPlatformUuid());
+    }
+    if (!components.length) {
+        components.push(node_os_1.default.hostname());
+    }
+    const raw = components
+        .map((value) => value.trim().toLowerCase())
+        .filter((value) => value.length > 0)
+        .join("|");
+    return (0, node_crypto_1.createHash)("sha256").update(raw).digest("hex");
+}
+function addIfNotBlank(values, value) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        values.push(value);
+    }
+}
+function readWindowsMachineGuid() {
+    try {
+        const output = childProcess.execFileSync("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        const match = output.match(/MachineGuid\s+REG_\w+\s+([^\r\n]+)/i);
+        return match?.[1]?.trim() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function readWindowsProductName() {
+    try {
+        const output = childProcess.execFileSync("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "/v", "ProductName"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        const match = output.match(/ProductName\s+REG_\w+\s+([^\r\n]+)/i);
+        return match?.[1]?.trim() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function readLinuxMachineId() {
+    for (const path of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+            if (!fs.existsSync(path)) {
+                continue;
+            }
+            const value = fs.readFileSync(path, "utf8").trim();
+            if (value.length > 0) {
+                return value;
+            }
+        }
+        catch {
+            // Ignore fallback failure.
+        }
+    }
+    return "";
+}
+function readMacPlatformUuid() {
+    try {
+        const output = childProcess.execFileSync("/usr/sbin/ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+        return match?.[1]?.trim() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function readWslWindowsProductName() {
+    try {
+        const output = childProcess.execFileSync("cmd.exe", ["/c", "reg", "query", "HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "/v", "ProductName"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        const match = output.match(/ProductName\s+REG_\w+\s+([^\r\n]+)/i);
+        return match?.[1]?.trim() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+async function evaluateScenarioOutcome(scenario, requestCount, context) {
+    const tracking = asRecord(scenario.Tracking);
+    const sourceSpec = asRecord(tracking.Source);
+    if (!Object.keys(sourceSpec).length) {
+        return { requestCount, okCount: requestCount, failCount: 0 };
+    }
+    const sourceEndpoint = mapEndpointSpec(sourceSpec);
+    const destinationSpec = asRecord(tracking.Destination);
+    const hasDestination = Object.keys(destinationSpec).length > 0;
+    const destinationEndpoint = hasDestination ? mapEndpointSpec(destinationSpec) : null;
+    validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndpoint);
+    const sourceAdapter = transports_js_1.EndpointAdapterFactory.create(sourceEndpoint);
+    const destinationAdapter = destinationEndpoint ? transports_js_1.EndpointAdapterFactory.create(destinationEndpoint) : null;
+    const correlationTimeoutOverride = pickValue(tracking, "CorrelationTimeoutMs", "correlationTimeoutMs");
+    const correlationTimeoutSeconds = pickValue(tracking, "CorrelationTimeoutSeconds", "correlationTimeoutSeconds", "CorrelationTimeout");
+    const timeoutMs = correlationTimeoutOverride != null && String(correlationTimeoutOverride).trim() !== ""
+        ? asInt(correlationTimeoutOverride)
+        : Math.trunc((correlationTimeoutSeconds == null || String(correlationTimeoutSeconds).trim() === ""
+            ? 30
+            : asNumber(correlationTimeoutSeconds)) * 1000);
+    const timeoutCountsAsFailure = toBoolean(pickValue(tracking, "TimeoutCountsAsFailure", "timeoutCountsAsFailure"), true);
+    const correlationStore = mapCorrelationStore(tracking, buildTrackingRunNamespace(stringOrDefault(pickValue(context, "SessionId", "sessionId"), "session"), stringOrDefault(pickValue(scenario, "Name", "name"), "scenario"), sourceEndpoint.name, destinationEndpoint?.name));
+    const timeoutSweepIntervalOverride = pickValue(tracking, "TimeoutSweepIntervalMs", "timeoutSweepIntervalMs");
+    const timeoutSweepIntervalSeconds = pickValue(tracking, "TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds");
+    const timeoutSweepIntervalMs = timeoutSweepIntervalOverride != null && String(timeoutSweepIntervalOverride).trim() !== ""
+        ? asInt(timeoutSweepIntervalOverride)
+        : Math.trunc((timeoutSweepIntervalSeconds == null || String(timeoutSweepIntervalSeconds).trim() === ""
+            ? 1
+            : asNumber(timeoutSweepIntervalSeconds)) * 1000);
+    const timeoutBatchSizeValue = pickValue(tracking, "TimeoutBatchSize", "timeoutBatchSize");
+    const timeoutBatchSize = timeoutBatchSizeValue == null || String(timeoutBatchSizeValue).trim() === ""
+        ? 200
+        : asInt(timeoutBatchSizeValue);
+    const runtime = new correlation_js_1.CrossPlatformTrackingRuntime({
+        sourceTrackingField: sourceEndpoint.trackingField,
+        destinationTrackingField: destinationEndpoint?.trackingField,
+        destinationGatherByField: destinationEndpoint?.gatherByField,
+        correlationTimeoutMs: timeoutMs,
+        timeoutCountsAsFailure,
+        store: correlationStore ?? undefined
+    });
+    const runMode = stringOrDefault(pickValue(tracking, "RunMode", "runMode"), "GenerateAndCorrelate").trim().toLowerCase();
+    const sourceOnlyMode = !destinationEndpoint;
+    const restartOnFail = toBoolean(pickValue(scenario, "RestartIterationOnFail", "restartIterationOnFail"), false);
+    const restartMaxAttempts = Math.max(asInt(pickValue(context, "RestartIterationMaxAttempts", "restartIterationMaxAttempts")), 0);
+    const maxFailCount = Math.max(asInt(pickValue(scenario, "MaxFailCount", "maxFailCount")), 0);
+    const scenarioCompletionTimeoutSeconds = Math.max(asNumber(pickValue(context, "ScenarioCompletionTimeoutSeconds", "scenarioCompletionTimeoutSeconds")), 0);
+    const scenarioDeadlineMs = scenarioCompletionTimeoutSeconds > 0
+        ? Date.now() + Math.trunc(scenarioCompletionTimeoutSeconds * 1000)
+        : Number.POSITIVE_INFINITY;
+    let okCount = 0;
+    let failCount = 0;
+    let nowMs = Date.now();
+    let processedIterations = 0;
+    let lastSweepAtMs = nowMs;
+    for (let i = 0; i < requestCount; i += 1) {
+        if (Date.now() > scenarioDeadlineMs) {
+            break;
+        }
+        let iterationComplete = false;
+        let attempts = 0;
+        const maxAttempts = 1 + (restartOnFail ? restartMaxAttempts : 0);
+        while (!iterationComplete) {
+            attempts += 1;
+            if (Date.now() > scenarioDeadlineMs) {
+                iterationComplete = true;
+                break;
+            }
+            let sourcePayload = runMode === "correlateexistingtraffic"
+                ? await sourceAdapter.consume()
+                : await sourceAdapter.produce();
+            sourcePayload = normalizePayload(sourcePayload, sourceEndpoint, i);
+            const sourceTrackingId = sourceOnlyMode
+                ? readTrackingId(sourcePayload, sourceEndpoint.trackingField)
+                : await runtime.onSourceProduced(sourcePayload, nowMs);
+            if (!sourceTrackingId) {
+                if (restartOnFail && attempts < maxAttempts) {
+                    nowMs += 1;
+                    continue;
+                }
+                failCount += 1;
+                iterationComplete = true;
+                nowMs += 1;
+                break;
+            }
+            if (sourceOnlyMode || !destinationAdapter || !destinationEndpoint) {
+                okCount += 1;
+                iterationComplete = true;
+                nowMs += 1;
+                break;
+            }
+            let destinationPayload = await destinationAdapter.consume();
+            destinationPayload = normalizePayload(destinationPayload, destinationEndpoint, i);
+            let matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
+            const correlationDeadlineMs = nowMs + timeoutMs;
+            while (!matched && Date.now() <= scenarioDeadlineMs && nowMs < correlationDeadlineMs) {
+                const remainingTimeoutMs = correlationDeadlineMs - nowMs;
+                if (remainingTimeoutMs <= 0) {
+                    break;
+                }
+                await sleep(Math.min(destinationEndpoint.pollIntervalMs ?? 250, remainingTimeoutMs));
+                destinationPayload = normalizePayload(await destinationAdapter.consume(), destinationEndpoint, i);
+                matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
+                if (matched) {
+                    break;
+                }
+                nowMs += Math.max(destinationEndpoint.pollIntervalMs ?? 250, 1);
+            }
+            if (matched) {
+                okCount += 1;
+                iterationComplete = true;
+            }
+            else if (restartOnFail && attempts < maxAttempts) {
+                nowMs += 2;
+                continue;
+            }
+            else {
+                await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
+                failCount += 1;
+                iterationComplete = true;
+            }
+            nowMs += 2;
+        }
+        processedIterations += 1;
+        if (timeoutSweepIntervalMs > 0 && nowMs - lastSweepAtMs >= timeoutSweepIntervalMs) {
+            const swept = await runtime.sweepTimeouts(nowMs, timeoutBatchSize || undefined);
+            if (swept > 0) {
+                if (timeoutCountsAsFailure) {
+                    failCount += swept;
+                }
+                else {
+                    okCount += swept;
+                }
+            }
+            lastSweepAtMs = nowMs;
+        }
+        if (maxFailCount > 0 && failCount >= maxFailCount) {
+            break;
+        }
+    }
+    let expired = 0;
+    let sweptChunk = 0;
+    do {
+        sweptChunk = await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
+        expired += sweptChunk;
+    } while (timeoutBatchSize > 0 && sweptChunk >= timeoutBatchSize);
+    if (expired > 0) {
+        if (timeoutCountsAsFailure) {
+            failCount += expired;
+        }
+        else {
+            okCount += expired;
+        }
+    }
+    if (processedIterations < requestCount && Date.now() > scenarioDeadlineMs) {
+        const timedOutIterations = requestCount - processedIterations;
+        if (timeoutCountsAsFailure) {
+            failCount += timedOutIterations;
+        }
+        else {
+            okCount += timedOutIterations;
+        }
+    }
+    return { requestCount: processedIterations, okCount, failCount };
+}
+function validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndpoint) {
+    if (sourceEndpoint.gatherByField?.trim()) {
+        throw new Error("GatherByField is supported on destination endpoint only.");
+    }
+    const correlationTimeoutOverride = pickValue(tracking, "CorrelationTimeoutMs", "correlationTimeoutMs");
+    const correlationTimeoutSeconds = pickValue(tracking, "CorrelationTimeoutSeconds", "correlationTimeoutSeconds", "CorrelationTimeout");
+    const correlationTimeoutMs = correlationTimeoutOverride != null && String(correlationTimeoutOverride).trim() !== ""
+        ? asInt(correlationTimeoutOverride)
+        : Math.trunc((correlationTimeoutSeconds == null || String(correlationTimeoutSeconds).trim() === ""
+            ? 30
+            : asNumber(correlationTimeoutSeconds)) * 1000);
+    if (correlationTimeoutMs <= 0) {
+        throw new RangeError("CorrelationTimeout must be greater than zero.");
+    }
+    const timeoutSweepIntervalOverride = pickValue(tracking, "TimeoutSweepIntervalMs", "timeoutSweepIntervalMs");
+    const timeoutSweepIntervalSeconds = pickValue(tracking, "TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds");
+    const timeoutSweepIntervalMs = timeoutSweepIntervalOverride != null && String(timeoutSweepIntervalOverride).trim() !== ""
+        ? asInt(timeoutSweepIntervalOverride)
+        : Math.trunc((timeoutSweepIntervalSeconds == null || String(timeoutSweepIntervalSeconds).trim() === ""
+            ? 1
+            : asNumber(timeoutSweepIntervalSeconds)) * 1000);
+    if (timeoutSweepIntervalMs <= 0) {
+        throw new RangeError("TimeoutSweepInterval must be greater than zero.");
+    }
+    const timeoutBatchSizeValue = pickValue(tracking, "TimeoutBatchSize", "timeoutBatchSize");
+    const timeoutBatchSize = timeoutBatchSizeValue == null || String(timeoutBatchSizeValue).trim() === ""
+        ? 200
+        : asInt(timeoutBatchSizeValue);
+    if (timeoutBatchSize <= 0) {
+        throw new RangeError("TimeoutBatchSize must be greater than zero.");
+    }
+    const metricPrefix = stringOrDefault(pickValue(tracking, "MetricPrefix", "metricPrefix"), "tracking");
+    if (!metricPrefix.trim()) {
+        throw new Error("MetricPrefix must be provided.");
+    }
+    validateRedisCorrelationStoreConfiguration(tracking);
+    const runModeRaw = stringOrDefault(pickValue(tracking, "RunMode", "runMode"), "GenerateAndCorrelate").trim().toLowerCase();
+    const runMode = runModeRaw === "sourceonly" ? "generateandcorrelate" : runModeRaw;
+    if (runMode === "generateandcorrelate") {
+        if (sourceEndpoint.mode !== "Produce") {
+            throw new Error("Source endpoint mode must be Produce for GenerateAndCorrelate mode.");
+        }
+        if (destinationEndpoint && destinationEndpoint.mode !== "Consume") {
+            throw new Error("Destination endpoint mode must be Consume for GenerateAndCorrelate mode.");
+        }
+        return;
+    }
+    if (runMode === "correlateexistingtraffic") {
+        if (!destinationEndpoint) {
+            throw new Error("Destination endpoint must be provided for CorrelateExistingTraffic mode.");
+        }
+        if (sourceEndpoint.mode !== "Consume") {
+            throw new Error("Source endpoint mode must be Consume for CorrelateExistingTraffic mode.");
+        }
+        if (destinationEndpoint.mode !== "Consume") {
+            throw new Error("Destination endpoint mode must be Consume for CorrelateExistingTraffic mode.");
+        }
+        return;
+    }
+    throw new RangeError(`Unsupported tracking run mode: ${runModeRaw}.`);
+}
+function normalizeHttpTrackingPayloadSourceValue(value) {
+    const normalized = String(value ?? "").trim().toLowerCase().replace(/_/g, "");
+    switch (normalized) {
+        case "":
+            return undefined;
+        case "request":
+            return "Request";
+        case "response":
+        case "body":
+        case "responsebody":
+        case "headers":
+        case "responseheaders":
+        case "status":
+        case "statuscode":
+        case "responsestatuscode":
+            return "Response";
+        default:
+            return value;
+    }
+}
+function inferLegacyHttpResponseSourceValue(value) {
+    const normalized = String(value ?? "").trim().toLowerCase().replace(/_/g, "");
+    switch (normalized) {
+        case "body":
+        case "responsebody":
+            return "ResponseBody";
+        case "headers":
+        case "responseheaders":
+            return "ResponseHeaders";
+        case "status":
+        case "statuscode":
+        case "responsestatuscode":
+            return "ResponseStatusCode";
+        default:
+            return undefined;
+    }
+}
+function mapEndpointSpec(spec) {
+    const pollIntervalOverride = pickValue(spec, "PollIntervalMs", "pollIntervalMs");
+    const pollIntervalSeconds = pickValue(spec, "PollIntervalSeconds", "pollIntervalSeconds", "PollInterval");
+    const pollIntervalMs = pollIntervalOverride != null && String(pollIntervalOverride).trim() !== ""
+        ? asInt(pollIntervalOverride)
+        : Math.trunc((pollIntervalSeconds == null || String(pollIntervalSeconds).trim() === ""
+            ? 0.25
+            : asNumber(pollIntervalSeconds)) * 1000);
+    const httpSpec = asRecord(pickValue(spec, "Http", "http"));
+    const delegateSpec = asRecord(pickValue(spec, "delegate", "Delegate", "DelegateStream"));
+    const payloadType = stringOrDefault(pickValue(spec, "MessagePayloadType", "messagePayloadType"), "").trim();
+    const serializerSettings = asRecord(pickValue(spec, "JsonSerializerSettings", "jsonSerializerSettings", "JsonSettings"));
+    const convertSettings = asRecord(pickValue(spec, "JsonConvertSettings", "jsonConvertSettings", "ConvertSettings"));
+    const delegateProduce = pickValue(delegateSpec, "produce", "Produce");
+    const delegateConsume = pickValue(delegateSpec, "consume", "Consume");
+    const delegateProduceAsync = pickValue(delegateSpec, "produceAsync", "ProduceAsync");
+    const delegateConsumeAsync = pickValue(delegateSpec, "consumeAsync", "ConsumeAsync");
+    const httpAuthSpec = asRecord(pickValue(httpSpec, "Auth", "auth"));
+    const oauthSpec = asRecord(pickValue(httpAuthSpec, "OAuth2ClientCredentials", "oauth2ClientCredentials"));
+    const oauthScopes = normalizeStringArray(pickValue(oauthSpec, "Scopes", "scopes"));
+    const authScopes = normalizeStringArray(pickValue(httpAuthSpec, "Scopes", "scopes"));
+    const resolvedScopes = oauthScopes.length ? oauthScopes : authScopes;
+    const scopeValue = stringOrDefault(pickValue(httpAuthSpec, "Scope", "scope"), resolvedScopes.length ? resolvedScopes.join(" ") : "");
+    const additionalFormFields = toStringMap(pickValue(oauthSpec, "AdditionalFormFields", "additionalFormFields"));
+    const rawTrackingPayloadSource = stringOrDefault(pickValue(httpSpec, "TrackingPayloadSource", "trackingPayloadSource"), "");
+    const trackingPayloadSource = normalizeHttpTrackingPayloadSourceValue(rawTrackingPayloadSource);
+    const explicitResponseSource = stringOrDefault(pickValue(httpSpec, "ResponseSource", "responseSource"), "");
+    const consumeArrayPath = stringOrDefault(pickValue(httpSpec, "ConsumeArrayPath", "consumeArrayPath"), "");
+    const consumeJsonArrayResponse = toBoolean(pickValue(httpSpec, "ConsumeJsonArrayResponse", "consumeJsonArrayResponse"), false);
+    return {
+        kind: stringOrDefault(pickValue(spec, "Kind", "kind"), "DelegateStream"),
+        mode: stringOrDefault(pickValue(spec, "Mode", "mode"), "Produce"),
+        name: stringOrDefault(pickValue(spec, "Name", "name"), "endpoint"),
+        trackingField: readTrackingSelectorValue(pickValue(spec, "TrackingField", "trackingField"), "header:x-correlation-id"),
+        gatherByField: readOptionalTrackingSelectorValue(pickValue(spec, "GatherByField", "gatherByField")),
+        autoGenerateTrackingIdWhenMissing: toBoolean(pickValue(spec, "AutoGenerateTrackingIdWhenMissing", "autoGenerateTrackingIdWhenMissing"), true),
+        pollIntervalMs,
+        messageHeaders: toStringMap(pickValue(spec, "MessageHeaders", "messageHeaders")),
+        messagePayload: normalizeEndpointPayloadValue(pickValue(spec, "MessagePayload", "messagePayload"), payloadType, serializerSettings, convertSettings),
+        messagePayloadType: payloadType || undefined,
+        jsonSerializerSettings: Object.keys(serializerSettings).length ? serializerSettings : undefined,
+        jsonConvertSettings: Object.keys(convertSettings).length ? convertSettings : undefined,
+        contentType: stringOrDefault(pickValue(spec, "ContentType", "contentType"), "") || undefined,
+        connectionMetadata: toStringMap(pickValue(spec, "ConnectionMetadata", "connectionMetadata")),
+        http: Object.keys(httpSpec).length
+            ? {
+                url: stringOrDefault(pickValue(httpSpec, "Url", "url"), ""),
+                method: stringOrDefault(pickValue(httpSpec, "Method", "method"), "GET"),
+                bodyType: stringOrDefault(pickValue(httpSpec, "BodyType", "bodyType"), "Json"),
+                responseSource: stringOrDefault(explicitResponseSource || inferLegacyHttpResponseSourceValue(rawTrackingPayloadSource), "None"),
+                trackingPayloadSource,
+                consumeArrayPath: consumeArrayPath || undefined,
+                consumeJsonArrayResponse,
+                requestTimeoutSeconds: (() => {
+                    const requestTimeout = pickValue(httpSpec, "RequestTimeoutSeconds", "requestTimeoutSeconds");
+                    return requestTimeout == null || String(requestTimeout).trim() === ""
+                        ? undefined
+                        : asNumber(requestTimeout);
+                })(),
+                tokenRequestHeaders: toStringMap(pickValue(httpSpec, "TokenRequestHeaders", "tokenRequestHeaders")),
+                auth: Object.keys(httpAuthSpec).length
+                    ? {
+                        mode: stringOrDefault(pickValue(httpAuthSpec, "Mode", "mode", "Type", "type"), "None"),
+                        username: stringOrDefault(pickValue(httpAuthSpec, "Username", "username"), "") || undefined,
+                        password: (() => {
+                            const password = pickValue(httpAuthSpec, "Password", "password");
+                            return password == null ? undefined : String(password).trim();
+                        })(),
+                        bearerToken: stringOrDefault(pickValue(httpAuthSpec, "BearerToken", "bearerToken"), "") || undefined,
+                        tokenUrl: stringOrDefault(pickValue(httpAuthSpec, "TokenUrl", "tokenUrl", "TokenEndpoint", "tokenEndpoint")
+                            ?? pickValue(oauthSpec, "TokenEndpoint", "tokenEndpoint"), "") || undefined,
+                        clientId: stringOrDefault(pickValue(httpAuthSpec, "ClientId", "clientId") ?? pickValue(oauthSpec, "ClientId", "clientId"), "") || undefined,
+                        clientSecret: stringOrDefault(pickValue(httpAuthSpec, "ClientSecret", "clientSecret") ?? pickValue(oauthSpec, "ClientSecret", "clientSecret"), "") || undefined,
+                        scope: scopeValue || undefined,
+                        scopes: resolvedScopes.length ? resolvedScopes : undefined,
+                        audience: stringOrDefault(pickValue(httpAuthSpec, "Audience", "audience"), "") || undefined,
+                        tokenHeaderName: stringOrDefault(pickValue(httpAuthSpec, "TokenHeaderName", "tokenHeaderName"), "") || undefined,
+                        additionalFormFields: Object.keys(additionalFormFields).length ? additionalFormFields : undefined,
+                        oauth2ClientCredentials: Object.keys(oauthSpec).length
+                            ? {
+                                tokenEndpoint: stringOrDefault(pickValue(oauthSpec, "TokenEndpoint", "tokenEndpoint"), "") || undefined,
+                                clientId: stringOrDefault(pickValue(oauthSpec, "ClientId", "clientId"), "") || undefined,
+                                clientSecret: stringOrDefault(pickValue(oauthSpec, "ClientSecret", "clientSecret"), "") || undefined,
+                                scopes: resolvedScopes.length ? resolvedScopes : undefined,
+                                additionalFormFields: Object.keys(additionalFormFields).length ? additionalFormFields : undefined
+                            }
+                            : undefined
+                    }
+                    : undefined
+            }
+            : undefined,
+        kafka: asRecord(pickValue(spec, "Kafka", "kafka")),
+        rabbitMq: asRecord(pickValue(spec, "RabbitMq", "rabbitMq")),
+        nats: asRecord(pickValue(spec, "Nats", "nats")),
+        redisStreams: asRecord(pickValue(spec, "RedisStreams", "redisStreams")),
+        azureEventHubs: asRecord(pickValue(spec, "AzureEventHubs", "azureEventHubs")),
+        pushDiffusion: asRecord(pickValue(spec, "PushDiffusion", "pushDiffusion")),
+        delegate: (typeof delegateProduce === "function"
+            || typeof delegateConsume === "function"
+            || typeof delegateProduceAsync === "function"
+            || typeof delegateConsumeAsync === "function")
+            ? {
+                produce: typeof delegateProduce === "function"
+                    ? delegateProduce
+                    : undefined,
+                consume: typeof delegateConsume === "function"
+                    ? delegateConsume
+                    : undefined,
+                produceAsync: typeof delegateProduceAsync === "function"
+                    ? delegateProduceAsync
+                    : undefined,
+                consumeAsync: typeof delegateConsumeAsync === "function"
+                    ? delegateConsumeAsync
+                    : undefined,
+                connectionMetadata: toStringMap(pickValue(delegateSpec, "ConnectionMetadata", "connectionMetadata"))
+            }
+            : undefined
+    };
+}
+function normalizePayload(payload, endpoint, index) {
+    const resolvedBody = payload?.body ?? endpoint.messagePayload;
+    const normalized = {
+        headers: {
+            ...(endpoint.messageHeaders ?? {}),
+            ...(payload?.headers ?? {})
+        },
+        body: normalizeEndpointPayloadValue(resolvedBody, endpoint.messagePayloadType, endpoint.jsonSerializerSettings, endpoint.jsonConvertSettings)
+    };
+    const selector = endpoint.trackingField.trim();
+    if (!selector) {
+        return normalized;
+    }
+    const existing = readTrackingId(normalized, selector);
+    if (existing || !endpoint.autoGenerateTrackingIdWhenMissing) {
+        return normalized;
+    }
+    const generated = `${endpoint.name}-auto-${index + 1}`;
+    if (selector.toLowerCase().startsWith("header:")) {
+        const headerName = selector.slice("header:".length).trim();
+        if (headerName) {
+            normalized.headers = normalized.headers ?? {};
+            normalized.headers[headerName] = generated;
+        }
+        return normalized;
+    }
+    if (selector.toLowerCase().startsWith("json:")) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        normalized.body = setJsonPathValue(normalized.body, path, generated);
+    }
+    return normalized;
+}
+function readTrackingId(payload, selector) {
+    const normalized = selector.trim().toLowerCase();
+    if (normalized.startsWith("header:")) {
+        const expected = selector.slice("header:".length).trim().toLowerCase();
+        const headers = payload.headers ?? {};
+        for (const [key, value] of Object.entries(headers)) {
+            const normalizedValue = String(value ?? "").trim();
+            if (key.toLowerCase() === expected && normalizedValue) {
+                return normalizedValue;
+            }
+        }
+        return null;
+    }
+    if (normalized.startsWith("json:")) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        const body = parseBodyAsObject(payload.body);
+        if (!body) {
+            return null;
+        }
+        let current = body;
+        for (const segment of path.split(".").filter(Boolean)) {
+            if (current && typeof current === "object" && !Array.isArray(current)) {
+                current = current[segment];
+            }
+            else {
+                return null;
+            }
+        }
+        return current == null ? null : String(current);
+    }
+    return null;
+}
+function readTrackingSelectorValue(value, fallback) {
+    return readOptionalTrackingSelectorValue(value) ?? fallback;
+}
+function readOptionalTrackingSelectorValue(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value.trim() || undefined;
+    }
+    if (value instanceof correlation_js_1.TrackingFieldSelector) {
+        return value.toString();
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        const location = record.Location ?? record.location ?? record.Kind ?? record.kind;
+        if (location != null || record.Path != null || record.path != null) {
+            return new correlation_js_1.TrackingFieldSelector(location, String(record.Path ?? record.path ?? "")).toString();
+        }
+    }
+    return undefined;
+}
+function setJsonPathValue(body, path, value) {
+    const target = body && typeof body === "object" && !Array.isArray(body)
+        ? { ...body }
+        : {};
+    const segments = path.split(".").filter(Boolean);
+    if (!segments.length) {
+        return target;
+    }
+    let current = target;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        const next = current[segment];
+        if (!next || typeof next !== "object" || Array.isArray(next)) {
+            current[segment] = {};
+        }
+        current = current[segment];
+    }
+    current[segments[segments.length - 1]] = value;
+    return target;
+}
+function mapCorrelationStore(tracking, runNamespace) {
+    const storeSpec = asRecord(pickValue(tracking, "CorrelationStore", "correlationStore"));
+    const kind = stringOrDefault(pickValue(storeSpec, "Kind", "kind"), "").trim().toLowerCase();
+    const redisSpec = asRecord(pickValue(storeSpec, "Redis", "redis"));
+    const useRedis = kind === "redis" || kind === "rediscorrelationstore" || Object.keys(redisSpec).length > 0;
+    if (!useRedis) {
+        return null;
+    }
+    const options = readRedisCorrelationStoreOptions(redisSpec);
+    return correlation_js_1.RedisCorrelationStore.fromOptions(options, runNamespace);
+}
+function validateRedisCorrelationStoreConfiguration(tracking) {
+    const storeSpec = asRecord(pickValue(tracking, "CorrelationStore", "correlationStore"));
+    const kind = stringOrDefault(pickValue(storeSpec, "Kind", "kind"), "").trim().toLowerCase();
+    const redisSpec = asRecord(pickValue(storeSpec, "Redis", "redis"));
+    const useRedis = kind === "redis" || kind === "rediscorrelationstore" || Object.keys(redisSpec).length > 0;
+    if (!useRedis) {
+        return;
+    }
+    const configuration = correlation_js_1.CorrelationStoreConfiguration.RedisStore(readRedisCorrelationStoreOptions(redisSpec));
+    configuration.validate();
+}
+function readRedisCorrelationStoreOptions(redisSpec) {
+    const options = new correlation_js_1.RedisCorrelationStoreOptions();
+    options.ConnectionString = stringOrDefault(pickValue(redisSpec, "ConnectionString", "connectionString"), "");
+    const database = pickValue(redisSpec, "Database", "database");
+    if (database != null && String(database).trim() !== "") {
+        options.Database = asInt(database);
+    }
+    options.KeyPrefix = stringOrDefault(pickValue(redisSpec, "KeyPrefix", "keyPrefix"), options.KeyPrefix);
+    const entryTtlSeconds = asNumber(pickValue(redisSpec, "EntryTtlSeconds", "entryTtlSeconds", "EntryTtl", "entryTtl"));
+    if (!Number.isNaN(entryTtlSeconds)) {
+        options.EntryTtlSeconds = entryTtlSeconds;
+    }
+    return options;
+}
+function buildTrackingRunNamespace(sessionId, scenarioName, sourceName, destinationName) {
+    return [
+        sanitizeTrackingNamespacePart(sessionId),
+        sanitizeTrackingNamespacePart(scenarioName),
+        sanitizeTrackingNamespacePart(sourceName),
+        sanitizeTrackingNamespacePart(destinationName ?? "source-only")
+    ].join(":");
+}
+function sanitizeTrackingNamespacePart(value) {
+    return String(value ?? "")
+        .trim()
+        .replace(/[<>:"/\\|?*\x00-\x1F]/g, "_")
+        .replace(/\s+/g, "_");
+}
+function normalizeEndpointPayloadValue(value, payloadType, serializerSettings = {}, convertSettings = {}) {
+    if (value == null) {
+        return value;
+    }
+    const normalizedType = stringOrDefault(payloadType, "").trim().toLowerCase();
+    if (typeof value === "string") {
+        const text = value.trim();
+        if (!text) {
+            return value;
+        }
+        if (normalizedType === "text" || normalizedType === "string") {
+            return value;
+        }
+        if (normalizedType === "number") {
+            const parsed = Number.parseFloat(text);
+            return Number.isFinite(parsed) ? parsed : value;
+        }
+        if (normalizedType === "boolean") {
+            const lowered = text.toLowerCase();
+            if (lowered === "true" || lowered === "1" || lowered === "yes") {
+                return true;
+            }
+            if (lowered === "false" || lowered === "0" || lowered === "no") {
+                return false;
+            }
+            return value;
+        }
+        if (normalizedType === "base64") {
+            try {
+                return Buffer.from(text, "base64").toString("utf8");
+            }
+            catch {
+                return value;
+            }
+        }
+        const prefersJson = normalizedType === "json" || normalizedType === "object" || normalizedType === "auto" || !normalizedType;
+        if (!prefersJson) {
+            return value;
+        }
+        const strict = tryParseJson(text);
+        if (strict !== undefined) {
+            return strict;
+        }
+        const allowRelaxed = toBoolean(pickValue(serializerSettings, "AllowTrailingCommas", "allowTrailingCommas", "AllowSingleQuotes", "allowSingleQuotes"), true) || toBoolean(pickValue(convertSettings, "AllowTrailingCommas", "allowTrailingCommas", "AllowSingleQuotes", "allowSingleQuotes"), true);
+        if (!allowRelaxed) {
+            return value;
+        }
+        const relaxed = tryParseJson(sanitizeLooseJson(text));
+        return relaxed === undefined ? value : relaxed;
+    }
+    return value;
+}
+function parseBodyAsObject(body) {
+    if (body && typeof body === "object" && !Array.isArray(body)) {
+        return body;
+    }
+    if (typeof body !== "string" || !body.trim()) {
+        return null;
+    }
+    const parsed = normalizeEndpointPayloadValue(body, "json");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+    }
+    return null;
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeLooseJson(value) {
+    let normalized = value.trim();
+    normalized = normalized.replace(/,\s*([}\]])/g, "$1");
+    normalized = normalized.replace(/'([^']*)'/g, (_match, group) => `"${group.replace(/"/g, '\\"')}"`);
+    return normalized;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
+}
+function computeScenarioRequestCount(scenario) {
+    const simulations = Array.isArray(scenario.LoadSimulations) ? scenario.LoadSimulations : [];
+    let total = 0;
+    for (const item of simulations) {
+        const simulation = asRecord(item);
+        const kind = stringOrDefault(simulation.Kind, "");
+        const rate = asInt(simulation.Rate);
+        const minRate = asInt(simulation.MinRate);
+        const maxRate = asInt(simulation.MaxRate);
+        const copies = Math.max(asInt(simulation.Copies), 1);
+        const iterations = Math.max(asInt(simulation.Iterations), 0);
+        const intervalSeconds = Math.max(asNumber(simulation.IntervalSeconds), 1);
+        const duringSeconds = Math.max(asNumber(simulation.DuringSeconds), 0);
+        switch (kind) {
+            case "IterationsForConstant":
+                total += copies * iterations;
+                break;
+            case "IterationsForInject":
+                total += iterations;
+                break;
+            case "Inject":
+                total += Math.ceil((duringSeconds / intervalSeconds) * Math.max(rate, 0));
+                break;
+            case "InjectRandom":
+                total += Math.ceil((duringSeconds / intervalSeconds) * ((Math.max(minRate, 0) + Math.max(maxRate, 0)) / 2));
+                break;
+            case "RampingInject":
+                total += Math.ceil((duringSeconds / intervalSeconds) * Math.max(rate, 0) * 0.5);
+                break;
+            case "KeepConstant":
+                total += Math.ceil(duringSeconds) * copies;
+                break;
+            case "RampingConstant":
+                total += Math.ceil(duringSeconds) * Math.max(Math.ceil(copies * 0.5), 1);
+                break;
+            default:
+                break;
+        }
+    }
+    return Math.max(total, 0);
+}
+function buildNodeStatsContract(context, createdUtc, completedUtc, values) {
+    const durationMs = Math.max(completedUtc.getTime() - createdUtc.getTime(), 0);
+    return {
+        AllBytes: 0,
+        AllFailCount: values.allFailCount,
+        AllOkCount: values.allOkCount,
+        AllRequestCount: values.allRequestCount,
+        DurationMs: durationMs,
+        NodeInfo: buildNodeInfoContract(context),
+        TestInfo: buildTestInfoContract(context, createdUtc),
+        Metrics: {
+            DurationMs: 0,
+            Counters: [],
+            Gauges: []
+        },
+        Scenarios: values.scenarios,
+        Thresholds: values.thresholds,
+        Plugins: []
+    };
+}
+function buildScenarioStatsContractRow(scenarioName, sortIndex, requestCount, okCount, failCount, durationMs) {
+    return {
+        ScenarioName: scenarioName,
+        SortIndex: sortIndex,
+        AllBytes: 0,
+        AllFailCount: failCount,
+        AllOkCount: okCount,
+        AllRequestCount: requestCount,
+        CurrentOperation: "Complete",
+        DurationMs: durationMs,
+        Ok: buildMeasurementStatsContract(okCount, requestCount, durationMs),
+        Fail: buildMeasurementStatsContract(failCount, requestCount, durationMs),
+        Steps: []
+    };
+}
+function buildMeasurementStatsContract(count, totalCount, durationMs) {
+    return {
+        Request: {
+            Count: count,
+            Percent: totalCount <= 0 ? 0 : Math.round((100 * count) / totalCount),
+            Rps: durationMs <= 0 ? 0 : count / (durationMs / 1000)
+        },
+        Latency: {
+            MinMs: 0,
+            MeanMs: 0,
+            MaxMs: 0,
+            StdDev: 0,
+            Percent50: 0,
+            Percent75: 0,
+            Percent95: 0,
+            Percent99: 0
+        },
+        DataTransfer: {
+            AllBytes: 0,
+            MinBytes: 0,
+            MeanBytes: 0,
+            MaxBytes: 0,
+            StdDev: 0,
+            Percent50: 0,
+            Percent75: 0,
+            Percent95: 0,
+            Percent99: 0
+        },
+        StatusCodes: []
+    };
+}
+function buildNodeInfoContract(context) {
+    return {
+        CoresCount: Math.max(node_os_1.default.cpus()?.length ?? 1, 1),
+        CurrentOperation: "Complete",
+        DotNetVersion: process.version,
+        MachineName: node_os_1.default.hostname(),
+        EngineVersion: "loadstrike-ts-sdk",
+        NodeType: toContractNodeType(pickValue(context, "NodeType", "nodeType")),
+        OS: `${node_os_1.default.platform()} ${node_os_1.default.release()}`,
+        Processor: node_os_1.default.cpus()?.[0]?.model ?? "unknown"
+    };
+}
+function buildTestInfoContract(context, createdUtc) {
+    return {
+        ClusterId: stringOrDefault(pickValue(context, "ClusterId", "clusterId"), "local"),
+        CreatedUtc: createdUtc,
+        SessionId: stringOrDefault(pickValue(context, "SessionId", "sessionId"), ""),
+        TestName: stringOrDefault(pickValue(context, "TestName", "testName"), ""),
+        TestSuite: stringOrDefault(pickValue(context, "TestSuite", "testSuite"), "")
+    };
+}
+function evaluateScenarioThresholds(scenario, values) {
+    const thresholds = Array.isArray(scenario.Thresholds) ? scenario.Thresholds : [];
+    const results = [];
+    for (const item of thresholds) {
+        const threshold = asRecord(item);
+        const scope = stringOrDefault(threshold.Scope, "").toLowerCase();
+        const stepName = stringOrDefault(threshold.StepName, "");
+        const field = stringOrDefault(threshold.Field, "").toLowerCase();
+        const operator = stringOrDefault(threshold.Operator, "").toLowerCase();
+        const expected = asNumber(threshold.Value);
+        const abortWhenErrorCount = asNullableInt(pickValue(threshold, "AbortWhenErrorCount", "abortWhenErrorCount"));
+        const startCheckAfterSeconds = Math.max(asNumber(pickValue(threshold, "StartCheckAfterSeconds", "startCheckAfterSeconds")), 0);
+        const checkExpression = buildThresholdExpression(scope, stepName);
+        if (startCheckAfterSeconds > 0 && values.durationMs < Math.trunc(startCheckAfterSeconds * 1000)) {
+            results.push({
+                ScenarioName: values.scenarioName,
+                StepName: stepName,
+                CheckExpression: checkExpression,
+                ErrorCount: 0,
+                IsFailed: false,
+                ExceptionMessage: ""
+            });
+            continue;
+        }
+        const actual = field === "allokcount"
+            ? values.okCount
+            : field === "allfailcount"
+                ? values.failCount
+                : field === "durationms"
+                    ? values.durationMs
+                    : values.requestCount;
+        let errorCount = 0;
+        if (scope === "step" && stepName.trim().length > 0) {
+            errorCount += 1;
+        }
+        else {
+            let failed = false;
+            if (operator === "gt") {
+                failed = !(actual > expected);
+            }
+            else if (operator === "gte") {
+                failed = !(actual >= expected);
+            }
+            else if (operator === "lt") {
+                failed = !(actual < expected);
+            }
+            else if (operator === "lte") {
+                failed = !(actual <= expected);
+            }
+            else if (operator === "eq") {
+                failed = actual !== expected;
+            }
+            else if (operator === "neq") {
+                failed = actual === expected;
+            }
+            if (failed) {
+                errorCount += 1;
+            }
+        }
+        let isFailed = errorCount > 0;
+        if (abortWhenErrorCount != null && errorCount >= abortWhenErrorCount) {
+            isFailed = true;
+        }
+        results.push({
+            ScenarioName: values.scenarioName,
+            StepName: stepName,
+            CheckExpression: checkExpression,
+            ErrorCount: errorCount,
+            IsFailed: isFailed,
+            ExceptionMessage: ""
+        });
+    }
+    return results;
+}
+function buildThresholdExpression(scope, stepName) {
+    if (scope === "step" || stepName.trim().length > 0) {
+        return `step-threshold:${stepName}`;
+    }
+    if (scope === "metric") {
+        return "metric-threshold";
+    }
+    if (scope === "scenario") {
+        return "scenario-threshold";
+    }
+    return "threshold";
+}
+function pickValue(record, ...keys) {
+    for (const key of keys) {
+        if (key in record) {
+            return record[key];
+        }
+    }
+    return undefined;
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function isRuntimeReportingSink(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return [
+        "init",
+        "Init",
+        "start",
+        "Start",
+        "saveRealtimeStats",
+        "SaveRealtimeStats",
+        "saveRealtimeMetrics",
+        "SaveRealtimeMetrics",
+        "saveFinalStats",
+        "SaveFinalStats",
+        "stop",
+        "Stop"
+    ].some((name) => typeof record[name] === "function");
+}
+function toStringMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item != null) {
+            output[key] = String(item);
+        }
+    }
+    return output;
+}
+function stringOrDefault(value, fallback) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value == null) {
+        return fallback;
+    }
+    return String(value);
+}
+function asInt(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    const parsed = Number.parseInt(String(value ?? "0"), 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function asNullableInt(value) {
+    if (value == null) {
+        return undefined;
+    }
+    return asInt(value);
+}
+function asNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    const parsed = Number.parseFloat(String(value ?? "0"));
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function toBoolean(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1" || normalized === "yes") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0" || normalized === "no") {
+            return false;
+        }
+    }
+    return fallback;
+}
+function parseJwt(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+        throw new Error("Invalid run token format.");
+    }
+    const [headerSegment, payloadSegment, signatureSegment] = parts;
+    const header = decodeJwtJsonSegment(headerSegment);
+    const payload = decodeJwtJsonSegment(payloadSegment);
+    return {
+        header,
+        payload,
+        signingInput: `${headerSegment}.${payloadSegment}`,
+        signature: decodeBase64Url(signatureSegment)
+    };
+}
+function decodeJwtJsonSegment(segment) {
+    const decoded = decodeBase64Url(segment).toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Invalid run token payload.");
+    }
+    return parsed;
+}
+function decodeBase64Url(value) {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const remainder = normalized.length % 4;
+    const padded = remainder ? normalized.padEnd(normalized.length + (4 - remainder), "=") : normalized;
+    return Buffer.from(padded, "base64");
+}
+function verifyJwtSignature(token, keyRecord, algorithm) {
+    const parsed = parseJwt(token);
+    if (algorithm !== "RS256") {
+        return false;
+    }
+    if (!keyRecord.publicKeyPem) {
+        return false;
+    }
+    const verifier = (0, node_crypto_1.createVerify)("RSA-SHA256");
+    verifier.update(parsed.signingInput);
+    verifier.end();
+    return verifier.verify(keyRecord.publicKeyPem, parsed.signature);
+}
+function enforceJwtLifetime(payload) {
+    const clockSkewSeconds = 30;
+    const nowSeconds = Math.trunc(Date.now() / 1000);
+    const exp = readEpochClaim(payload, "exp", "Exp");
+    if (!exp || exp <= 0) {
+        throw new Error("Runner key validation failed: run token expiration is missing.");
+    }
+    if (nowSeconds > (exp + clockSkewSeconds)) {
+        throw new Error("Runner key validation failed: run token is expired.");
+    }
+    const nbf = readEpochClaim(payload, "nbf", "Nbf");
+    if (nbf && nbf > 0 && (nowSeconds + clockSkewSeconds) < nbf) {
+        throw new Error("Runner key validation failed: run token is not yet valid.");
+    }
+}
+function readEpochClaim(payload, ...keys) {
+    const value = pickValue(payload, ...keys);
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    const text = String(value).trim();
+    if (!text) {
+        return null;
+    }
+    const parsed = Number.parseFloat(text);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return Math.trunc(parsed);
+}
+function enforceEntitlementClaims(payload, requestedFeatures) {
+    const entitlements = collectClaimStrings(payload, "entitlements", "Entitlements", "features", "Features", "feature", "Feature");
+    const normalized = new Set(entitlements.map((value) => value.toLowerCase()));
+    for (const feature of requestedFeatures) {
+        if (!normalized.has(feature.toLowerCase())) {
+            throw new Error(`Runner key validation denied. DenialCode=missing_entitlement, Message=Missing entitlement for ${feature}.`);
+        }
+    }
+}
+function enforceRuntimePolicyClaims(payload, request) {
+    const policy = resolveRuntimePolicy(payload);
+    if (!Object.keys(policy).length) {
+        return;
+    }
+    const context = asRecord(request.Context);
+    const maxScenarios = asInt(pickValue(policy, "maxScenarios", "MaxScenarios"));
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    if (maxScenarios > 0 && scenarios.length > maxScenarios) {
+        throw new Error(`Runner key validation denied. DenialCode=max_scenarios_exceeded, Message=Scenario count ${scenarios.length} exceeds policy limit ${maxScenarios}.`);
+    }
+    const maxAgents = asInt(pickValue(policy, "maxAgentsCount", "MaxAgentsCount"));
+    const agentsCount = Math.max(asInt(pickValue(context, "AgentsCount", "agentsCount")), 1);
+    if (maxAgents > 0 && agentsCount > maxAgents) {
+        throw new Error(`Runner key validation denied. DenialCode=max_agents_exceeded, Message=Agents count ${agentsCount} exceeds policy limit ${maxAgents}.`);
+    }
+    const maxCustomWorkerPlugins = asInt(pickValue(policy, "maxCustomWorkerPlugins", "MaxCustomWorkerPlugins"));
+    const customWorkerPluginsCount = countCustomWorkerPlugins(context);
+    if (maxCustomWorkerPlugins > 0 && customWorkerPluginsCount > maxCustomWorkerPlugins) {
+        throw new Error("Runner key validation denied. DenialCode=max_custom_worker_plugins_exceeded, "
+            + `Message=Custom worker plugin count ${customWorkerPluginsCount} exceeds policy limit ${maxCustomWorkerPlugins}.`);
+    }
+    const maxReportingSinks = asInt(pickValue(policy, "maxReportingSinks", "MaxReportingSinks"));
+    const reportingSinksCount = asList(pickValue(context, "ReportingSinks", "reportingSinks")).length;
+    if (maxReportingSinks > 0 && reportingSinksCount > maxReportingSinks) {
+        throw new Error("Runner key validation denied. DenialCode=max_reporting_sinks_exceeded, "
+            + `Message=Reporting sink count ${reportingSinksCount} exceeds policy limit ${maxReportingSinks}.`);
+    }
+    const maxTargetScenarioCount = asInt(pickValue(policy, "maxTargetScenarioCount", "MaxTargetScenarioCount"));
+    const targetedScenarioCount = countTargetedScenarios(context);
+    if (maxTargetScenarioCount > 0 && targetedScenarioCount > maxTargetScenarioCount) {
+        throw new Error("Runner key validation denied. DenialCode=max_target_scenarios_exceeded, "
+            + `Message=Targeted scenario count ${targetedScenarioCount} exceeds policy limit ${maxTargetScenarioCount}.`);
+    }
+    const maxClusterCommandTimeoutSeconds = asInt(pickValue(policy, "maxClusterCommandTimeoutSeconds", "MaxClusterCommandTimeoutSeconds"));
+    const clusterCommandTimeoutSeconds = resolveTimeoutSeconds(context, "ClusterCommandTimeoutSeconds", "clusterCommandTimeoutSeconds", "ClusterCommandTimeoutMs", "clusterCommandTimeoutMs", 120);
+    if (maxClusterCommandTimeoutSeconds > 0
+        && clusterCommandTimeoutSeconds > maxClusterCommandTimeoutSeconds) {
+        throw new Error("Runner key validation denied. DenialCode=cluster_command_timeout_exceeded, "
+            + `Message=Cluster command timeout ${clusterCommandTimeoutSeconds.toFixed(3)}s exceeds policy limit ${maxClusterCommandTimeoutSeconds}s.`);
+    }
+    const maxScenarioCompletionTimeoutSeconds = asInt(pickValue(policy, "maxScenarioCompletionTimeoutSeconds", "MaxScenarioCompletionTimeoutSeconds"));
+    const scenarioCompletionTimeoutSeconds = resolveTimeoutSeconds(context, "ScenarioCompletionTimeoutSeconds", "scenarioCompletionTimeoutSeconds", "ScenarioCompletionTimeoutMs", "scenarioCompletionTimeoutMs", 30);
+    if (maxScenarioCompletionTimeoutSeconds > 0
+        && scenarioCompletionTimeoutSeconds > maxScenarioCompletionTimeoutSeconds) {
+        throw new Error("Runner key validation denied. DenialCode=scenario_completion_timeout_exceeded, "
+            + `Message=Scenario completion timeout ${scenarioCompletionTimeoutSeconds.toFixed(3)}s exceeds policy limit ${maxScenarioCompletionTimeoutSeconds}s.`);
+    }
+}
+function normalizeStringArray(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => stringOrDefault(entry, "").trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (typeof value === "string" && value.trim()) {
+        return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    }
+    return [];
+}
+function collectClaimStrings(payload, ...keys) {
+    const values = [];
+    for (const key of keys) {
+        if (!(key in payload)) {
+            continue;
+        }
+        values.push(...normalizeStringArray(payload[key]));
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = value.toLowerCase();
+        if (seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        deduped.push(value);
+    }
+    return deduped;
+}
+function resolveRuntimePolicy(payload) {
+    const policy = asRecord(pickValue(payload, "runtimePolicy", "RuntimePolicy", "policy", "Policy"));
+    policy.maxAgentsCount = pickPositiveInt(policy, payload, "maxAgentsCount", "MaxAgentsCount", "policy.max_agents_count");
+    policy.maxScenarios = pickPositiveInt(policy, payload, "maxScenarios", "MaxScenarios", "maxScenarioCount", "MaxScenarioCount", "policy.max_scenario_count");
+    policy.maxCustomWorkerPlugins = pickPositiveInt(policy, payload, "maxCustomWorkerPlugins", "MaxCustomWorkerPlugins", "policy.max_custom_worker_plugins");
+    policy.maxReportingSinks = pickPositiveInt(policy, payload, "maxReportingSinks", "MaxReportingSinks", "policy.max_reporting_sinks");
+    policy.maxTargetScenarioCount = pickPositiveInt(policy, payload, "maxTargetScenarioCount", "MaxTargetScenarioCount", "policy.max_target_scenario_count");
+    policy.maxClusterCommandTimeoutSeconds = pickPositiveInt(policy, payload, "maxClusterCommandTimeoutSeconds", "MaxClusterCommandTimeoutSeconds", "policy.max_cluster_command_timeout_seconds");
+    policy.maxScenarioCompletionTimeoutSeconds = pickPositiveInt(policy, payload, "maxScenarioCompletionTimeoutSeconds", "MaxScenarioCompletionTimeoutSeconds", "policy.max_scenario_completion_timeout_seconds");
+    return policy;
+}
+function pickPositiveInt(primary, secondary, ...keys) {
+    let value = pickValue(primary, ...keys);
+    if (value == null) {
+        value = pickValue(secondary, ...keys);
+    }
+    const parsed = asInt(value);
+    return parsed > 0 ? parsed : 0;
+}
+function normalizeNodeType(value) {
+    const normalized = stringOrDefault(value, "single").trim().toLowerCase();
+    if (normalized === "0" || normalized === "single" || normalized === "singlenode") {
+        return "single";
+    }
+    if (normalized === "1" || normalized === "coordinator") {
+        return "coordinator";
+    }
+    if (normalized === "2" || normalized === "agent") {
+        return "agent";
+    }
+    return normalized;
+}
+function toContractNodeType(value) {
+    switch (normalizeNodeType(value)) {
+        case "coordinator":
+            return "Coordinator";
+        case "agent":
+            return "Agent";
+        case "single":
+        case "singlenode":
+            return "SingleNode";
+        default:
+            return stringOrDefault(value, "SingleNode");
+    }
+}
+function countTargetedScenarios(context) {
+    const values = [
+        ...normalizeStringArray(pickValue(context, "TargetScenarios", "targetScenarios")),
+        ...normalizeStringArray(pickValue(context, "AgentTargetScenarios", "agentTargetScenarios")),
+        ...normalizeStringArray(pickValue(context, "CoordinatorTargetScenarios", "coordinatorTargetScenarios"))
+    ];
+    return new Set(values.map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0)).size;
+}
+function countCustomWorkerPlugins(context) {
+    const workerPlugins = asList(pickValue(context, "WorkerPlugins", "workerPlugins"));
+    let count = 0;
+    for (const plugin of workerPlugins) {
+        const pluginRecord = asRecord(plugin);
+        const pluginName = stringOrDefault(pickValue(pluginRecord, "PluginName", "pluginName"), stringOrDefault(plugin.pluginName, stringOrDefault(plugin.PluginName, ""))).trim().toLowerCase();
+        if (!pluginName || BUILT_IN_WORKER_PLUGIN_NAMES.has(pluginName)) {
+            continue;
+        }
+        count += 1;
+    }
+    return count;
+}
+function resolveTimeoutSeconds(context, secondsKey, secondsAlias, millisecondsKey, millisecondsAlias, defaultSeconds = 0) {
+    const seconds = asNumber(pickValue(context, secondsKey, secondsAlias));
+    if (seconds > 0) {
+        return seconds;
+    }
+    const milliseconds = asNumber(pickValue(context, millisecondsKey, millisecondsAlias));
+    if (milliseconds > 0) {
+        return milliseconds / 1000;
+    }
+    return defaultSeconds;
+}
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}