@loadstrike/loadstrike-sdk 1.0.30401 → 1.0.31001

package/dist/cjs/runtime.js

@@ -16,6 +16,8 @@ const reporting_js_1 = require("./reporting.js");
 const sinks_js_1 = require("./sinks.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");
 exports.LoadStrikeNodeType = {
@@ -3455,8 +3457,8 @@ class LoadStrikeRunner {
         }));
         const sinkErrors = [];
         const policyErrors = [];
-        const sinkRetryCount = Math.max(this.options.sinkRetryCount ?? 2, 0);
-        const sinkRetryBackoffMs = Math.max(this.options.sinkRetryBackoffMs ?? 25, 0);
+        const sinkRetryCount = (0, sink_retry_policy_js_1.normalizeSinkRetryCount)(this.options.sinkRetryCount);
+        const sinkRetryBackoffMs = (0, sink_retry_policy_js_1.normalizeSinkRetryBackoffMs)(this.options.sinkRetryBackoffMs);
         const policies = this.options.runtimePolicies ?? [];
         const runtimePolicyErrorMode = normalizedRuntimePolicyErrorMode(this.options.runtimePolicyErrorMode);
         const plugins = this.options.reportingSinks === undefined && this.options.workerPlugins === undefined &&
@@ -3550,14 +3552,14 @@ class LoadStrikeRunner {
                 await init(baseContext, this.options.infraConfig ?? {});
             }
         }
-        await this.initializeSinks(sinkStates, baseContext, this.options.infraConfig ?? {}, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+        await this.initializeSinks(sinkStates, baseContext, this.options.infraConfig ?? {}, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
         for (const plugin of plugins) {
             const start = resolveWorkerPluginStart(plugin);
             if (start) {
                 await start(sessionInfo);
             }
         }
-        await this.startSinks(sinkStates, sessionInfo, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+        await this.startSinks(sinkStates, sessionInfo, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
         const iterationObservationRunId = String(this.internalOptions.iterationObservationRunId
             ?? sessionInfo.portalReportingRunId
             ?? sessionInfo.PortalReportingRunId
@@ -3588,7 +3590,10 @@ class LoadStrikeRunner {
             expectedResultOwnerCount64: iterationObservationExpectedResultOwnerCount64,
             processGroup: iterationObservationProcessGroup,
             settings: resolveIterationObservationSettings(this.options),
-            sinks: reporterIterationObservationSinks
+            sinks: reporterIterationObservationSinks,
+            sinkRetryCount,
+            sinkRetryBackoffMs,
+            logger: runLogger
         });
         const emitRealtimeSnapshot = async () => {
             if (realtimeInFlight) {
@@ -3600,7 +3605,7 @@ class LoadStrikeRunner {
                     .map((value) => value.build(scenarioDurationsMs.get(value.scenarioName) ?? Math.max(Date.now() - started.getTime(), 0)))
                     .sort((left, right) => left.sortIndex - right.sortIndex);
                 const metricsSnapshot = collectMetricStats(allRegisteredMetrics, Date.now() - started.getTime());
-                await this.emitRealtimeStats(sinkStates, snapshot, metricsSnapshot, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+                await this.emitRealtimeStats(sinkStates, snapshot, metricsSnapshot, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
                 if (toBoolean(this.options.displayConsoleMetrics, true)) {
                     const requestCount = snapshot.reduce((sum, value) => sum + value.allRequestCount, 0);
                     const okCount = snapshot.reduce((sum, value) => sum + value.allOkCount, 0);
@@ -3791,8 +3796,8 @@ class LoadStrikeRunner {
             finalizedResult.logFiles = mergeStringArrays(finalizedResult.logFiles, loggerSetup.logFiles);
             finalizedResult.reportFiles = this.writeReports(finalizedResult);
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
-            await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
-            await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+            await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
+            await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
             sinksStopped = true;
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
             finalizedResult.sinkErrors = sinkErrors
@@ -3805,7 +3810,7 @@ class LoadStrikeRunner {
                 await iterationObservationReporter.sealAndDrain().catch(() => { });
             }
             if (!sinksStopped) {
-                await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors);
+                await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
             }
             if (!pluginsStopped) {
                 await this.stopPlugins(plugins, pluginLifecycleErrors, runLogger);
@@ -4113,9 +4118,9 @@ class LoadStrikeRunner {
         }
         return filtered;
     }
-    async initializeSinks(sinkStates, context, infraConfig, retryCount, retryBackoffMs, sinkErrors) {
+    async initializeSinks(sinkStates, context, infraConfig, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "init", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "init", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const init = resolveSinkInit(state.sink);
                 if (init) {
                     await init(context, infraConfig);
@@ -4123,9 +4128,9 @@ class LoadStrikeRunner {
             });
         }
     }
-    async startSinks(sinkStates, session, retryCount, retryBackoffMs, sinkErrors) {
+    async startSinks(sinkStates, session, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "start", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "start", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const start = resolveSinkStart(state.sink);
                 if (start) {
                     await start(session);
@@ -4133,9 +4138,9 @@ class LoadStrikeRunner {
             });
         }
     }
-    async emitRealtimeStats(sinkStates, scenarioStats, metrics, retryCount, retryBackoffMs, sinkErrors) {
+    async emitRealtimeStats(sinkStates, scenarioStats, metrics, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "realtime", retryCount, retryBackoffMs, sinkErrors, false, true, async () => {
+            await this.invokeSinkAction(state, "realtime", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, true, async () => {
                 const saveRealtimeStats = resolveSinkSaveRealtimeStats(state.sink);
                 if (saveRealtimeStats) {
                     await saveRealtimeStats(scenarioStats);
@@ -4147,10 +4152,9 @@ class LoadStrikeRunner {
             });
         }
     }
-    async stopSinks(sinkStates, retryCount, retryBackoffMs, sinkErrors) {
-        const shutdownRetryCount = 0;
+    async stopSinks(sinkStates, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "stop", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
+            await this.invokeSinkAction(state, "stop", retryCount, retryBackoffMs, sinkErrors, runId, logger, true, true, async () => {
                 const stop = resolveSinkStop(state.sink);
                 if (stop) {
                     await stop();
@@ -4158,15 +4162,15 @@ class LoadStrikeRunner {
             });
             const dispose = resolveSinkDispose(state.sink);
             if (dispose) {
-                await this.invokeSinkAction(state, "dispose", shutdownRetryCount, retryBackoffMs, sinkErrors, true, true, async () => {
+                await this.invokeSinkAction(state, "dispose", retryCount, retryBackoffMs, sinkErrors, runId, logger, true, true, async () => {
                     await dispose();
                 });
             }
         }
     }
-    async emitRunResult(sinkStates, result, retryCount, retryBackoffMs, sinkErrors) {
+    async emitRunResult(sinkStates, result, retryCount, retryBackoffMs, sinkErrors, runId, logger) {
         for (const state of sinkStates) {
-            await this.invokeSinkAction(state, "run-result", retryCount, retryBackoffMs, sinkErrors, false, false, async () => {
+            await this.invokeSinkAction(state, "run-result", retryCount, retryBackoffMs, sinkErrors, runId, logger, false, false, async () => {
                 const saveRunResult = resolveSinkSaveRunResult(state.sink);
                 if (saveRunResult) {
                     await saveRunResult(result);
@@ -4174,23 +4178,49 @@ class LoadStrikeRunner {
             });
         }
     }
-    async invokeSinkAction(state, phase, retryCount, retryBackoffMs, sinkErrors, ignoreDisabled, disableOnFailure, action) {
+    async invokeSinkAction(state, phase, retryCount, retryBackoffMs, sinkErrors, runId, logger, ignoreDisabled, disableOnFailure, action) {
         if (state.disabled && !ignoreDisabled) {
             return;
         }
-        let attempts = 0;
-        while (attempts <= retryCount) {
-            attempts += 1;
+        const maximumAttempts = (0, sink_retry_policy_js_1.normalizeSinkRetryCount)(retryCount) + 1;
+        const backoffMs = (0, sink_retry_policy_js_1.normalizeSinkRetryBackoffMs)(retryBackoffMs);
+        for (let attempts = 1; attempts <= maximumAttempts; attempts += 1) {
             try {
                 await action();
+                if (attempts > 1) {
+                    (0, iteration_observation_diagnostics_js_1.logIterationObservationRecovery)(logger, {
+                        sinkName: state.name,
+                        operation: "reporting-sink-action",
+                        phase,
+                        runId,
+                        resultOwnerId: "",
+                        observationCount: 0,
+                        attempt: attempts,
+                        maximumAttempts,
+                        nextDelayMs: 0
+                    });
+                }
                 return;
             }
             catch (error) {
-                if (attempts > retryCount) {
+                const exhausted = attempts >= maximumAttempts;
+                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,
+                    operation: "reporting-sink-action",
+                    phase,
+                    runId,
+                    resultOwnerId: "",
+                    observationCount: 0,
+                    attempt: attempts,
+                    maximumAttempts,
+                    nextDelayMs
+                }, error);
+                if (exhausted) {
                     sinkErrors.push({
                         sinkName: state.name,
                         phase,
-                        message: String(error ?? "sink action failed"),
+                        message: "The reporting sink action failed after retries.",
                         attempts
                     });
                     if (disableOnFailure) {
@@ -4198,9 +4228,7 @@ class LoadStrikeRunner {
                     }
                     return;
                 }
-                if (retryBackoffMs > 0) {
-                    await sleep(retryBackoffMs * attempts);
-                }
+                await (0, sink_retry_policy_js_1.waitForSinkRetryDelay)(nextDelayMs);
             }
         }
     }
@@ -4610,7 +4638,18 @@ async function executeScenarioRuntime(args) {
         attachScenarioContextAliases(context);
         const startedUtcNs = (0, iteration_observations_js_1.utcNowNs)();
         const startedAtNs = process.hrtime.bigint();
-        const reply = await executeScenarioInvocation(scenario, context, operation);
+        let policyFailure;
+        let reply;
+        try {
+            reply = await executeScenarioInvocation(scenario, context, operation);
+        }
+        catch (error) {
+            if (!(error instanceof RuntimePolicyCallbackError)) {
+                throw error;
+            }
+            policyFailure = error;
+            reply = LoadStrikeResponse.fail("runtime_policy_error", "", 0);
+        }
         const observedLatencyNs = maxBigInt(process.hrtime.bigint() - startedAtNs, 0n);
         const completedUtcNs = startedUtcNs + observedLatencyNs;
         const observedLatencyMs = Number(observedLatencyNs) / 1000000;
@@ -4625,7 +4664,8 @@ async function executeScenarioRuntime(args) {
             observedLatencyUs: observedLatencyNs / 1000n,
             reportedLatencyUs: normalizeRawObservationLatencyMicroseconds(resolveRecordedLatency(reply.customLatencyMs, observedLatencyMs)),
             steps: attemptSteps,
-            recordedSteps
+            recordedSteps,
+            ...(policyFailure ? { policyFailure } : {})
         };
     };
     const captureAttemptObservation = (operation, globalOrdinal, attemptIndex, isFinalAttempt, attempt, simulationIndex, simulationKind, iterationId, globalSecondaryOrdinal = 0n) => {
@@ -4674,22 +4714,18 @@ async function executeScenarioRuntime(args) {
         const maxAttempts = 1 + (scenario.shouldRestartIterationOnFail() ? restartIterationMaxAttempts : 0);
         while (attempts < maxAttempts && !shouldStopNow()) {
             attempts += 1;
-            let attempt;
-            try {
-                attempt = await runSingleInvocation("Bombing", instanceData, instanceNumber, instanceId, false);
-            }
-            catch (error) {
-                if (error instanceof RuntimePolicyCallbackError) {
-                    stopScenario = true;
-                    scenarioAbortController.abort(error);
-                }
-                throw error;
-            }
-            const shouldRetry = !attempt.reply.isSuccess
+            const attempt = await runSingleInvocation("Bombing", instanceData, instanceNumber, instanceId, false);
+            const shouldRetry = !attempt.policyFailure
+                && !attempt.reply.isSuccess
                 && scenario.shouldRestartIterationOnFail()
                 && attempts < maxAttempts
                 && !shouldStopNow();
             captureAttemptObservation("Bombing", globalOrdinal, attempts - 1, !shouldRetry, attempt, simulationIndex, simulationKind, iterationId, explicitSecondaryOrdinal);
+            if (attempt.policyFailure) {
+                stopScenario = true;
+                scenarioAbortController.abort(attempt.policyFailure);
+                throw attempt.policyFailure;
+            }
             if (!shouldRetry) {
                 for (const step of attempt.recordedSteps) {
                     recordStepReply(step.stepName, step.reply, step.observedLatencyMs, step.sortIndex);
@@ -4716,6 +4752,11 @@ async function executeScenarioRuntime(args) {
             const globalOrdinal = nextObservationOrdinal();
             const attempt = await runSingleInvocation("WarmUp", instanceInfo.instanceData, instanceInfo.instanceNumber, instanceInfo.instanceId, false);
             captureAttemptObservation("WarmUp", globalOrdinal, 0, true, attempt, -1, "SingleInvocation");
+            if (attempt.policyFailure) {
+                stopScenario = true;
+                scenarioAbortController.abort(attempt.policyFailure);
+                throw attempt.policyFailure;
+            }
         }
     };
     const executeV2TimedConstant = async (copies, durationNs, ramping, runSimulationInvocation, segment) => {
@@ -5386,10 +5427,17 @@ async function waitForScenarioTasks(tasks, scenarioName, timeoutSeconds, logger,
         throwPolicyFailure(await settled);
         return;
     }
-    const completed = await Promise.race([
-        settled.then(() => true),
-        delayWithAbort(Math.trunc(timeoutSeconds * 1000), signal).then(() => false)
-    ]);
+    const timeoutController = new AbortController();
+    let completed;
+    try {
+        completed = await Promise.race([
+            settled.then(() => true),
+            delayWithAbort(Math.trunc(timeoutSeconds * 1000), combineAbortSignals(signal, timeoutController.signal)).then(() => false)
+        ]);
+    }
+    finally {
+        timeoutController.abort();
+    }
     if (!completed) {
         if (signal.reason instanceof RuntimePolicyCallbackError) {
             throw signal.reason;
@@ -9451,11 +9499,23 @@ function readRuntimeTrackingId(payload, selector) {
             return null;
         }
         let current = body;
-        for (const segment of selector.slice("json:".length).trim().replace(/^\$\./, "").split(".").filter(Boolean)) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        let segments;
+        try {
+            segments = runtimeSafeJsonPathSegments(path);
+        }
+        catch {
+            return null;
+        }
+        for (const segment of segments) {
             if (!current || typeof current !== "object" || Array.isArray(current)) {
                 return null;
             }
-            current = current[segment];
+            const record = current;
+            if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+                return null;
+            }
+            current = runtimeReadOwnJsonProperty(record, segment);
         }
         return current == null ? null : String(current);
     }
@@ -9479,23 +9539,57 @@ function runtimeParseBodyAsObject(body) {
     }
 }
 function setRuntimeJsonPathValue(body, path, value) {
-    const target = body && typeof body === "object" && !Array.isArray(body)
-        ? { ...body }
-        : {};
-    const segments = path.split(".").filter(Boolean);
+    const target = runtimeCloneJsonRecord(body);
+    const segments = runtimeSafeJsonPathSegments(path);
     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];
+        const next = runtimeReadOwnJsonProperty(current, segment);
+        let child;
         if (!next || typeof next !== "object" || Array.isArray(next)) {
-            current[segment] = {};
+            child = {};
+        }
+        else {
+            child = runtimeCloneJsonRecord(next);
         }
-        current = current[segment];
+        runtimeDefineJsonProperty(current, segment, child);
+        current = child;
+    }
+    runtimeDefineJsonProperty(current, segments[segments.length - 1], value);
+    return target;
+}
+const FORBIDDEN_RUNTIME_JSON_PATH_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function runtimeSafeJsonPathSegments(path) {
+    const segments = path.split(".").filter(Boolean);
+    const forbidden = segments.find((segment) => FORBIDDEN_RUNTIME_JSON_PATH_SEGMENTS.has(segment));
+    if (forbidden) {
+        throw new Error(`Tracking selector contains forbidden JSON path segment '${forbidden}'.`);
+    }
+    return segments;
+}
+function runtimeDefineJsonProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+    });
+}
+function runtimeReadOwnJsonProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function runtimeCloneJsonRecord(value) {
+    const target = {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return target;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        runtimeDefineJsonProperty(target, key, entry);
     }
-    current[segments[segments.length - 1]] = value;
     return target;
 }
 function asTrackingRecord(value) {
@@ -9505,8 +9599,8 @@ function asTrackingRecord(value) {
 }
 function pickTrackingValue(source, ...keys) {
     for (const key of keys) {
-        if (key in source) {
-            return source[key];
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            return runtimeReadOwnJsonProperty(source, key);
         }
     }
     return undefined;
@@ -9760,26 +9854,10 @@ function createDefaultLogger(logFilePath) {
 function wrapLoggerWithMinimumLevel(baseLogger, minimumLogLevel) {
     const threshold = logLevelOrder(minimumLogLevel);
     return {
-        debug: (message) => {
-            if (threshold <= 0) {
-                baseLogger.debug(message);
-            }
-        },
-        info: (message) => {
-            if (threshold <= 1) {
-                baseLogger.info(message);
-            }
-        },
-        warn: (message) => {
-            if (threshold <= 2) {
-                baseLogger.warn(message);
-            }
-        },
-        error: (message) => {
-            if (threshold <= 3) {
-                baseLogger.error(message);
-            }
-        }
+        debug: (message) => threshold <= 0 ? baseLogger.debug(message) : undefined,
+        info: (message) => threshold <= 1 ? baseLogger.info(message) : undefined,
+        warn: (message) => threshold <= 2 ? baseLogger.warn(message) : undefined,
+        error: (message) => threshold <= 3 ? baseLogger.error(message) : undefined
     };
 }
 function formatDefaultLoggerLine(level, message) {
@@ -11293,6 +11371,7 @@ exports.__loadstrikeTestExports = {
     parseStrictBooleanToken,
     percentile,
     pickOptionalTrackingSelectorString,
+    pickTrackingValue,
     pickTrackingNumber,
     produceOrConsumeTrackingPayload,
     readConfiguredSinkName,

package/dist/cjs/sink-retry-policy.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAXIMUM_TIMER_DELAY_MS = exports.MAXIMUM_SINK_RETRY_COUNT = exports.DEFAULT_SINK_RETRY_BACKOFF_MS = exports.DEFAULT_SINK_RETRY_COUNT = void 0;
+exports.normalizeSinkRetryCount = normalizeSinkRetryCount;
+exports.normalizeSinkRetryBackoffMs = normalizeSinkRetryBackoffMs;
+exports.sinkRetryDelayMs = sinkRetryDelayMs;
+exports.waitForSinkRetryDelay = waitForSinkRetryDelay;
+exports.cooperativeSinkRetryYield = cooperativeSinkRetryYield;
+exports.DEFAULT_SINK_RETRY_COUNT = 3;
+exports.DEFAULT_SINK_RETRY_BACKOFF_MS = 250;
+exports.MAXIMUM_SINK_RETRY_COUNT = 100;
+exports.MAXIMUM_TIMER_DELAY_MS = 2147483647;
+function normalizeSinkRetryCount(value) {
+    const resolved = value === undefined ? exports.DEFAULT_SINK_RETRY_COUNT : value;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        return 0;
+    }
+    return Math.min(Math.trunc(resolved), exports.MAXIMUM_SINK_RETRY_COUNT);
+}
+function normalizeSinkRetryBackoffMs(value) {
+    const resolved = value === undefined ? exports.DEFAULT_SINK_RETRY_BACKOFF_MS : value;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        return 0;
+    }
+    return Math.min(Math.trunc(resolved), exports.MAXIMUM_TIMER_DELAY_MS);
+}
+function sinkRetryDelayMs(baseDelayMs, retryNumber) {
+    if (baseDelayMs <= 0) {
+        return 0;
+    }
+    let delayMs = Math.min(Math.trunc(baseDelayMs), exports.MAXIMUM_TIMER_DELAY_MS);
+    const doublings = Math.max(Math.trunc(retryNumber) - 1, 0);
+    for (let index = 0; index < doublings; index += 1) {
+        if (delayMs >= Math.ceil(exports.MAXIMUM_TIMER_DELAY_MS / 2)) {
+            return exports.MAXIMUM_TIMER_DELAY_MS;
+        }
+        delayMs *= 2;
+    }
+    return delayMs;
+}
+async function waitForSinkRetryDelay(delayMs) {
+    if (delayMs <= 0) {
+        await cooperativeSinkRetryYield();
+        return;
+    }
+    await new Promise((resolve) => {
+        setTimeout(resolve, Math.min(delayMs, exports.MAXIMUM_TIMER_DELAY_MS));
+    });
+}
+async function cooperativeSinkRetryYield() {
+    await new Promise((resolve) => setImmediate(resolve));
+}