});

}

function remainingDeadlineMs(deadline) {

return Math.max(1, deadline - Date.now());

}

async function openSocket(url, timeoutMs = 10_000) {

const ws = new WebSocket(url);

await waitForWebSocketOpen(ws, timeoutMs, "ws open timeout");

const deadline = Date.now() + timeoutMs;

const delayImpl = deps.delay ?? delay;

const onceFrameImpl = deps.onceFrame ?? onceFrame;

const openSocketImpl = deps.openSocket ?? ((targetUrl) => openSocket(targetUrl));

const openSocketImpl = deps.openSocket ?? openSocket;

const protocolVersion = deps.protocolVersion ?? (await readProtocolVersion());

const stdout = deps.stdout ?? console.log;

let lastError;

while (Date.now() < deadline) {

let ws;

try {

ws = await openSocketImpl(url);

ws = await openSocketImpl(url, remainingDeadlineMs(deadline));

ws.send(

JSON.stringify({

type: "req",

const connectRes = await onceFrameImpl(

ws,

(frame) => frame?.type === "res" && frame?.id === "c1",

remainingDeadlineMs(deadline),

);

if (!connectRes.ok) {

lastError = responseError("connect", connectRes);

const healthRes = await onceFrameImpl(

ws,

(frame) => frame?.type === "res" && frame?.id === "h1",

remainingDeadlineMs(deadline),

);

if (healthRes.ok) {

if (!hasGatewayHealthSummaryPayload(healthRes)) {

ws?.close();

}

await delayImpl(500);

const retryDelayMs = Math.min(500, deadline - Date.now());

if (retryDelayMs > 0) {

await delayImpl(retryDelayMs);

}

}

throw lastError ?? new Error("connect failed: timeout");

// Gateway Network Client tests cover gateway network client script behavior.

import { EventEmitter } from "node:events";

import { describe, expect, it } from "vitest";

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

import { runGatewayNetworkClient } from "../../scripts/e2e/lib/gateway-network/client.mjs";

import { readGatewayNetworkClientConnectTimeoutMs } from "../../scripts/e2e/lib/gateway-network/limits.mjs";

import { onceFrame } from "../../scripts/e2e/lib/gateway-network/ws-frames.mjs";

stdout,

deps: {

delay: async () => {},

onceFrame: async (_ws: unknown, predicate: (frame: unknown) => boolean) => {

onceFrame: async (

_ws: unknown,

predicate: (frame: unknown) => boolean,

_timeoutMs?: number,

) => {

const frame = {

type: "res",

id: sentMethods.at(-1) === "connect" ? "c1" : "h1",

expect(harness.closeCount).toBe(1);

});

it("bounds socket and frame waits by the client deadline", async () => {

const harness = createNetworkClientHarness([{ ok: true }, healthResponse()]);

const openSocket = vi.fn(harness.deps.openSocket);

const onceFrame = vi.fn(harness.deps.onceFrame);

await runGatewayNetworkClient(

{ token: "secret-token", url: "ws://127.0.0.1:12345", timeoutMs: 250 },

{

...harness.deps,

onceFrame,

openSocket,

},

);

expect(openSocket.mock.calls[0]?.[1]).toBeGreaterThan(0);

expect(openSocket.mock.calls[0]?.[1]).toBeLessThanOrEqual(250);

expect(onceFrame.mock.calls.map((call) => call[2])).toHaveLength(2);

for (const frameTimeoutMs of onceFrame.mock.calls.map((call) => call[2])) {

expect(frameTimeoutMs).toBeGreaterThan(0);

expect(frameTimeoutMs).toBeLessThanOrEqual(250);

}

});

it("does not sleep past the remaining client deadline between retries", async () => {

const delays: number[] = [];

let now = 1_000;

const dateSpy = vi.spyOn(Date, "now").mockImplementation(() => now);

try {

await expect(

runGatewayNetworkClient(

{ token: "secret-token", url: "ws://127.0.0.1:12345", timeoutMs: 250 },

{

delay: async (ms: number) => {

delays.push(ms);

now += ms;

},

openSocket: async () => {

now += 200;

throw new Error("ECONNREFUSED");

},

protocolVersion: 1,

stdout: () => {},

},

),

).rejects.toThrow("ECONNREFUSED");

} finally {

dateSpy.mockRestore();

}

expect(delays).toEqual([50]);

});

it("fails a connected socket whose health success lacks summary evidence", async () => {

const harness = createNetworkClientHarness([{ ok: true }, { ok: true }]);