import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

import { MAX_TIMER_TIMEOUT_MS } from "../shared/number-coercion.js";

const transportReadyMocks = vi.hoisted(() => ({

injectedSleepError: null as Error | null,

expect(runtime.error).toHaveBeenCalled();

});

it("caps oversized timeout values before computing the deadline", async () => {

vi.setSystemTime(1_000);

const runtime = createRuntime();

const waitPromise = waitForTransportReady({

label: "test transport",

timeoutMs: Number.MAX_SAFE_INTEGER,

logAfterMs: Number.MAX_SAFE_INTEGER,

pollIntervalMs: Number.MAX_SAFE_INTEGER,

runtime,

check: async () => ({ ok: false, error: "still down" }),

});

const asserted = expect(waitPromise).rejects.toThrow("test transport not ready");

await vi.advanceTimersByTimeAsync(1);

expect(runtime.error).not.toHaveBeenCalled();

await vi.advanceTimersByTimeAsync(MAX_TIMER_TIMEOUT_MS - 1);

await asserted;

expect(latestRuntimeErrorMessage(runtime)).toContain(

`not ready after ${MAX_TIMER_TIMEOUT_MS}ms`,

);

});

it("returns early when aborted", async () => {

const runtime = createRuntime();

const controller = new AbortController();

import { danger } from "../globals.js";

import type { RuntimeEnv } from "../runtime.js";

import { resolveTimerTimeoutMs } from "../shared/number-coercion.js";

import { sleepWithAbort } from "./backoff.js";

export type TransportReadyResult = {

export async function waitForTransportReady(params: WaitForTransportReadyParams): Promise<void> {

const started = Date.now();

const timeoutMs = Math.max(0, params.timeoutMs);

const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 0, 0);

const deadline = started + timeoutMs;

const logAfterMs = Math.max(0, params.logAfterMs ?? timeoutMs);

const logIntervalMs = Math.max(1_000, params.logIntervalMs ?? 30_000);

const pollIntervalMs = Math.max(50, params.pollIntervalMs ?? 150);

const logAfterMs = resolveTimerTimeoutMs(params.logAfterMs, timeoutMs, 0);

const logIntervalMs = resolveTimerTimeoutMs(params.logIntervalMs, 30_000, 1_000);

const pollIntervalMs = resolveTimerTimeoutMs(params.pollIntervalMs, 150, 50);

let nextLogAt = started + logAfterMs;

let lastError: string | null = null;