@ultimat3/scraping 31.4.0 → 31.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/scraping",
-  "version": "31.4.0",
+  "version": "31.4.2",
   "description": "Browser automation as a job: scrape() returns a JobHandle",
   "keywords": [
     "ultimate",
@@ -43,10 +43,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "31.4.0",
-    "@ultimat3/core": "31.4.0",
-    "@ultimat3/jobs": "31.4.0",
-    "@ultimat3/schema": "31.4.0",
-    "@ultimat3/storage": "31.4.0"
+    "@ultimat3/action": "31.4.2",
+    "@ultimat3/core": "31.4.2",
+    "@ultimat3/jobs": "31.4.2",
+    "@ultimat3/schema": "31.4.2",
+    "@ultimat3/storage": "31.4.2"
   }
 }

package/src/cdp-connection.ts

@@ -96,6 +96,12 @@ export interface CdpConnectionOptions {
   readonly endpoint: string;
   /** Per-call deadline. A CDP call that never answers is a suite that never finishes. */
   readonly timeoutMs: number;
+  /**
+   * The handshake's deadline, when it is not a call's: a launcher dials a browser that is still
+   * starting, inside what is left of its LAUNCH deadline (`cdp-launch-wire.ts`). `timeoutMs` if
+   * unset.
+   */
+  readonly connectTimeoutMs?: number | undefined;
 }
 
 /**
@@ -120,14 +126,15 @@ export async function cdpConnect(options: CdpConnectionOptions): Promise<CdpConn
     `the CDP endpoint is ${options.endpoint === '' ? 'empty' : 'not a WebSocket url'}`,
     'pass the `webSocketDebuggerUrl` Chrome prints on stderr, or the one /json/version answers',
   );
+  const connectTimeoutMs = options.connectTimeoutMs ?? options.timeoutMs;
   const socket = new WebSocket(options.endpoint);
   await new Promise<void>((resolve, reject) => {
     // The socket is CLOSED on both failures: a handshake that timed out otherwise kept dialling
     // in the background, holding a descriptor and a pending connection for a caller that gave up.
     const timer = setTimeout(() => {
       socket.close();
-      reject(new CdpTimeoutError({ method: 'connect', timeoutMs: options.timeoutMs }));
-    }, options.timeoutMs);
+      reject(new CdpTimeoutError({ method: 'connect', timeoutMs: connectTimeoutMs }));
+    }, connectTimeoutMs);
     socket.onopen = (): void => {
       clearTimeout(timer);
       resolve();

package/src/cdp-launch-wire.ts

@@ -68,27 +68,20 @@ export function devToolsEndpoint(text: string): string | undefined {
 const ANNOUNCE_POLL_MS = 25;
 
 /**
- * Dial, inside what is left of the LAUNCH deadline — `cdpConnect`'s own deadline is the per-call one
- * the connection keeps afterwards, so it cannot also be the launch's. A dial that loses the race
- * and connects later is closed, never left holding a socket nobody reads.
+ * Dial, inside what is left of the LAUNCH deadline. The handshake gets `leftMs`; `timeoutMs` is the
+ * per-call deadline the connection keeps afterwards, and it was the handshake's too until windows
+ * CI (run 42978963381) gave up on a cold Chrome 10 s into the upgrade with 50 s of its launch left —
+ * a browser that has bound its port is still starting, not dead. `cdpConnect` closes a socket whose
+ * handshake ran out, so a late upgrade never holds a socket nobody reads.
  */
 async function dialWithin(
   endpoint: string,
   leftMs: number,
   timeoutMs: number,
 ): Promise<CdpConnection> {
-  const dialing = cdpConnect({ endpoint, timeoutMs });
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const late = new Promise<never>((_, reject) => {
-    timer = setTimeout(
-      () => reject(new CdpTimeoutError({ method: 'connect', timeoutMs: leftMs })),
-      leftMs,
-    );
-  });
   try {
-    return await Promise.race([dialing, late]);
+    return await cdpConnect({ endpoint, timeoutMs, connectTimeoutMs: leftMs });
   } catch (error) {
-    void dialing.then((connection) => connection.close()).catch(() => undefined);
     // A timeout stays one — the launcher reads it as the deadline. Any other refusal names the
     // endpoint it was for: the browser announced it, so the dial is the step that failed.
     if (error instanceof CdpTimeoutError) throw error;
@@ -96,8 +89,6 @@ async function dialWithin(
       method: `connect ${endpoint}`,
       detail: renderThrowable(error),
     });
-  } finally {
-    clearTimeout(timer);
   }
 }