fix(init): bound waitForRpc per-request so wait-l1 can't hang forever

waitForRpc looped on a 60s deadline but awaited fetch() with no per-request
timeout. Docker's published port accepts TCP before anvil serves HTTP, so a
single fetch could block indefinitely; the loop never re-checked the deadline
and the 60s timeout never fired. In CI this hung wait-l1 for the full 75min
job timeout (3 of 4 first-wave publish jobs), defeating the init retry loop
(which only recovers from init exiting, not hanging).

Add signal: AbortSignal.timeout(pollIntervalMs) to the fetch so a hung request
aborts and the loop enforces its deadline, throwing the existing 'not ready'
error. Fixes wait-l1/l2/l3 alike. Regression test stubs a never-resolving
fetch and asserts waitForRpc rejects within its timeout.

Defense-in-depth: wrap each CI init attempt in 'timeout 1500' so any future
unforeseen hang is bounded and the retry loop's reset can recover.

Author: douglance

.github/workflows/release-testnode-image.yml

@@ -160,12 +160,16 @@ jobs:
           for attempt in $(seq 1 "$max"); do
             echo "::group::init attempt $attempt/$max ($SNAPSHOT_ID)"
             # shellcheck disable=SC2086
-            pnpm dev init \
+            # Bound each attempt so an unforeseen hang can't consume the whole
+            # job; 1500s comfortably exceeds a healthy ~10-15min init and keeps
+            # 3 attempts within timeout-minutes: 75. The retry loop resets with
+            # `docker compose ... down -v` below so a timed-out attempt recovers.
+            timeout 1500 pnpm dev init \
               --nitro-contracts-version "$NC_VERSION" \
               $EXTRA \
               --capture-id "$SNAPSHOT_ID" \
               --rebuild \
-              --skip-post-capture-verify || echo "init exited non-zero on attempt $attempt"
+              --skip-post-capture-verify || echo "init exited/timed out on attempt $attempt"
             echo "::endgroup::"
             if [ -f "$MANIFEST" ]; then
               echo "snapshot captured on attempt $attempt"

packages/core/src/docker.ts

@@ -91,6 +91,10 @@ export async function waitForRpc(
 					method: "eth_chainId",
 					params: [],
 				}),
+				// Bound each request so a hung connection (e.g. docker-proxy
+				// accepting TCP before anvil serves HTTP) aborts and lets the
+				// loop re-check the deadline instead of blocking forever.
+				signal: AbortSignal.timeout(pollIntervalMs),
 			});
 			if (response.ok) {
 				return;

packages/core/test/docker.test.ts

@@ -169,4 +169,24 @@ describe("waitForRpc", () => {
 		await expect(waitForRpc("http://localhost:8545", 5000, 10)).resolves.toBeUndefined();
 		expect(fetchSpy).toHaveBeenCalledTimes(3);
 	});
+
+	it("rejects on overall timeout even when individual fetches never resolve", async () => {
+		// Simulate docker-proxy accepting the TCP connection but never serving
+		// HTTP: fetch connects and never resolves on its own, mirroring real
+		// fetch by rejecting only when its abort signal fires. Without a
+		// per-request signal (the bug) every call hangs forever and the loop
+		// never re-checks the deadline.
+		fetchSpy.mockImplementation(
+			(_url: string, init?: RequestInit) =>
+				new Promise((_resolve, reject) => {
+					init?.signal?.addEventListener("abort", () =>
+						reject(new DOMException("The operation was aborted.", "AbortError")),
+					);
+				}),
+		);
+
+		await expect(waitForRpc("http://localhost:8545", 200, 20)).rejects.toThrow(
+			"RPC at http://localhost:8545 not ready",
+		);
+	});
 });