async function fetchProbeText() {

const elapsedMs = Date.now() - startedAt;

const remainingMs = Math.max(1, timeoutMs - elapsedMs);

const remainingMs = timeoutMs - elapsedMs;

const controller = new AbortController();

const attemptDeadlineMs = Math.min(attemptTimeoutMs, remainingMs);

let timer;

let lastError;

let lastResult;

while (Date.now() - startedAt <= timeoutMs) {

while (Date.now() - startedAt < timeoutMs) {

try {

const { response, text } = await fetchProbeText();

let body;

} catch (error) {

lastError = error instanceof Error ? error.message : String(error);

}

const remainingDelayMs = timeoutMs - (Date.now() - startedAt);

if (remainingDelayMs <= 0) {

break;

}

const delayMs = Math.min(500, remainingDelayMs);

await new Promise((resolve) => {

setTimeout(resolve, 500);

setTimeout(resolve, delayMs);

});

if (delayMs === remainingDelayMs) {

break;

}

}

const suffix = lastResult ? ` (last HTTP ${lastResult.status}: ${lastResult.text})` : "";

}

});

it("keeps failed probe retries inside the total timeout", async () => {

const server = createHttpServer((_request, response) => {

response.writeHead(503, { "content-type": "application/json" });

response.end(JSON.stringify({ ready: false, failing: ["gateway"] }));

});

const baseUrl = await listen(server);

const out = path.join(makeTempDir(), "ready-timeout.json");

const startedAt = Date.now();

try {

const result = await runProbe([

"--base-url",

baseUrl,

"--path",

"/readyz",

"--expect",

"ready",

"--out",

out,

"--timeout-ms",

"50",

"--attempt-timeout-ms",

"25",

]);

expect(result.status).not.toBe(0);

expect(Date.now() - startedAt).toBeLessThan(300);

expect(result.stderr).toContain("probe did not satisfy ready within 50ms");

expect(fs.existsSync(out)).toBe(false);

} finally {

server.close();

}

});

it("allows degraded ready responses only when degraded readiness is explicit", async () => {

const server = createHttpServer((_request, response) => {

response.writeHead(503, { "content-type": "application/json" });