@promigence/sdk 0.1.0-beta.12 → 0.1.0-beta.14

package/dist/http2.js

@@ -6,11 +6,12 @@ import * as zlib from "node:zlib";
 import { __caGuardInternals, guardCertChain } from "./ca-guard.js";
 import { DEFAULT_API_URL } from "./core.js";
 import { customDispatcher } from "./dispatcher.js";
-import { mark, TRACE_ON, traceEvent, traceEventAt } from "./trace.js";
+import { mark, onTraceFlush, TRACE_ON, traceEvent, traceEventAt } from "./trace.js";
 const MAX_SESSIONS = 4;
 const FIRST_SESSIONS = 2;
 const BURST_MIN = 8;
 const HOLD_MS = 10;
+const STANDBY_AFTER_MS = 300;
 const LOAD_FIRST_USE_MS = 120_000;
 const CONNECT_TIMEOUT_MS = 10_000;
 const IDLE_CLOSE_MS = 10_000;
@@ -561,6 +562,7 @@ export const tuning = {
     holdMs: HOLD_MS,
     burstMin: BURST_MIN,
     loadFirstUseMs: LOAD_FIRST_USE_MS,
+    standbyAfterMs: STANDBY_AFTER_MS,
     earlyPlatform: undefined,
     earlyServers: undefined,
     earlyHostsFile: undefined,
@@ -844,19 +846,21 @@ function apiLookup(asked, observe, ipv4First = v4First(), earlyOk = true) {
 const earlies = new Map();
 const MAX_EARLIES = 4;
 const EARLY_MAX_AGE_MS = 60_000;
-const EARLY_TIMEOUT_MS = 2_000;
-const LOOKUP_AT_LOAD = (() => {
+const LOOKUP_FIRST_MS = 150;
+const LOOKUP_TRIES = 3;
+const LOOKUP_AT_MS = [0, 100, 250];
+const DNS_AT_LOAD = (() => {
     try {
-        return nodeDns()?.lookup;
+        return nodeDns();
     }
     catch {
         return undefined;
     }
 })();
+const LOOKUP_AT_LOAD = DNS_AT_LOAD?.lookup;
 function lookupReplaced() {
     try {
-        const d = nodeDns();
-        return d !== undefined && d.lookup !== LOOKUP_AT_LOAD;
+        return DNS_AT_LOAD !== undefined && DNS_AT_LOAD.lookup !== LOOKUP_AT_LOAD;
     }
     catch {
         return true;
@@ -865,8 +869,8 @@ function lookupReplaced() {
 const EARLY_WORKER = `
 const { workerData } = require("node:worker_threads");
 const { isIPv4 } = require("node:net");
-const { port, host, timeoutMs, servers, hostsFile } = workerData;
-const done = (m) => { try { port.postMessage(m); } catch {} try { port.close(); } catch {} };
+const { port, host, timeoutMs, tries, atMs, servers, hostsFile } = workerData;
+const done = (m) => { m.hr = Number(process.hrtime.bigint()) / 1e6; try { port.postMessage(m); } catch {} try { port.close(); } catch {} };
 try {
   let named = false;
   const v4 = [];
@@ -880,12 +884,28 @@ try {
   } catch {}
   if (named) done(v4.length > 0 ? { host, addrs: v4, ttl: 60, at: Date.now() } : { host, none: "hosts" });
   else {
-    const r = new (require("node:dns").Resolver)({ timeout: timeoutMs, tries: 1 });
-    if (Array.isArray(servers) && servers.length > 0) r.setServers(servers);
-    r.resolve4(host, { ttl: true }, (err, recs) => {
-      if (err || !Array.isArray(recs) || recs.length === 0) return done({ host, none: (err && err.code) || "empty" });
-      done({ host, addrs: recs.map((x) => x.address), ttl: Math.min(...recs.map((x) => x.ttl)), at: Date.now() });
-    });
+    const { Resolver } = require("node:dns");
+    const rs = [];
+    const timers = [];
+    let fin = false, asked = 0, failed = 0;
+    const finish = (m) => { if (fin) return; fin = true; for (const t of timers) clearTimeout(t); for (const r of rs) { try { r.cancel(); } catch {} } done(m); };
+    const gaveUp = (why) => { if (++failed < asked) return; if (asked < atMs.length) ask(); else finish({ host, none: why }); };
+    const ask = () => {
+      if (fin || asked >= atMs.length) return;
+      const k = asked++;
+      try {
+        const r = new Resolver({ timeout: timeoutMs, tries });
+        const list = Array.isArray(servers) && servers.length > 0 ? servers : r.getServers();
+        if (list.length > 0) r.setServers(list.map((_, i) => list[(i + k) % list.length]));
+        rs.push(r);
+        r.resolve4(host, { ttl: true }, (err, recs) => {
+          if (fin) return;
+          if (!err && Array.isArray(recs) && recs.length > 0) return finish({ host, addrs: recs.map((x) => x.address), ttl: Math.min(...recs.map((x) => x.ttl)), at: Date.now() });
+          gaveUp((err && err.code) || "empty");
+        });
+      } catch { gaveUp("error"); }
+    };
+    for (const ms of atMs) { if (ms <= 0) ask(); else timers.push(setTimeout(ask, ms)); }
   }
 } catch { done({ host, none: "error" }); }
 `;
@@ -916,7 +936,7 @@ function earlyLookupFor(host) {
         const worker = new Worker(EARLY_WORKER, {
             eval: true,
             workerData: {
-                port: port2, host, timeoutMs: EARLY_TIMEOUT_MS,
+                port: port2, host, timeoutMs: LOOKUP_FIRST_MS, tries: LOOKUP_TRIES, atMs: LOOKUP_AT_MS,
                 servers: tuning.earlyServers ?? (Array.isArray(earlySeam().servers) ? earlySeam().servers : undefined),
                 hostsFile: tuning.earlyHostsFile ?? (typeof earlySeam().hostsFile === "string" ? earlySeam().hostsFile : undefined),
             },
@@ -964,6 +984,10 @@ function settleEarly(e, message) {
     else {
         e.state = "none";
     }
+    if (TRACE_ON) {
+        const at = typeof m?.hr === "number" ? m.hr - (Number(process.hrtime.bigint()) / 1e6 - performance.now()) : performance.now();
+        traceEventAt(e.state === "answered" ? `dns:early-answer ${addrs.length}` : `dns:early-none ${typeof m?.none === "string" ? m.none : "gone"}`, at);
+    }
     safely(() => { e.port.close(); });
     const waiters = e.waiters.splice(0);
     for (const w of waiters)
@@ -1290,12 +1314,13 @@ function targetOf(url, known, remember) {
 }
 function fetchInit(init, deadline) {
     const timeout = AbortSignal.timeout(Math.max(0, Math.ceil(deadline - performance.now())));
+    const dispatcher = init.dispatcher ?? init.dispatcherFor?.(init.timeoutMs);
     return {
         method: init.method,
         headers: init.headers,
         signal: init.signal === undefined ? timeout : AbortSignal.any([timeout, init.signal]),
         ...(init.body === undefined ? {} : { body: init.body }),
-        ...(init.dispatcher === undefined ? {} : { dispatcher: init.dispatcher }),
+        ...(dispatcher === undefined ? {} : { dispatcher }),
     };
 }
 function fetchFailed(cause) {
@@ -1312,27 +1337,45 @@ class HandBack {
 const UNSENT = new HandBack(0, 0);
 const VIA_FETCH = Symbol("via-fetch");
 const THREAD_GRACE_MS = 1_000;
+const THREAD_SWEEP_MS = 250;
+const THREAD_MARKS = 4096;
 const THREAD_PHASES = ["w.got", "w.sent", "w.head", "w.end"];
 class TransportThread {
     origin;
     worker;
     port;
+    acks;
     state = "starting";
     sessions = 0;
     limit = DEFAULT_STREAM_LIMIT;
     everReady = false;
     closedReason = "";
     onFail;
+    startedAt = performance.now();
+    startWaiters = [];
     inflight = new Map();
     nextId = 1;
     listening = false;
+    refd = false;
+    sweep;
+    freeMarks = [];
+    messages = 0;
+    outbox = [];
+    turnOpen = false;
+    posts = 0;
     answered = 0;
     pace = THREAD_DEFAULTS.pace;
     hrOffset = Number(process.hrtime.bigint()) / 1e6 - performance.now();
-    constructor(origin, worker, port) {
+    constructor(origin, worker, port, acks) {
         this.origin = origin;
         this.worker = worker;
         this.port = port;
+        this.acks = acks;
+        for (let i = acks.length - 1; i >= 0; i--)
+            this.freeMarks.push(i);
+    }
+    acked(p) {
+        return Atomics.load(this.acks, p.mark) === p.id;
     }
     poll() {
         for (;;) {
@@ -1349,12 +1392,44 @@ class TransportThread {
         }
     }
     ready() {
-        if (this.state !== "closed")
+        if ((!this.listening || this.state === "starting") && this.state !== "closed")
             this.poll();
-        return this.state === "ready" && this.sessions > 0 && this.inflight.size < this.sessions * this.limit;
+        return this.state === "ready" && this.sessions > 0 && this.inflight.size < this.sessions * this.limit && this.freeMarks.length > 0;
+    }
+    starting() {
+        if (this.state === "starting")
+            this.poll();
+        return this.state === "starting";
+    }
+    whenStarted(cb) {
+        if (!this.starting()) {
+            queueMicrotask(cb);
+            return () => { };
+        }
+        this.startWaiters.push(cb);
+        this.listen();
+        return () => {
+            const i = this.startWaiters.indexOf(cb);
+            if (i >= 0)
+                this.startWaiters.splice(i, 1);
+        };
+    }
+    started() {
+        for (const cb of this.startWaiters.splice(0))
+            safely(cb);
+    }
+    listen() {
+        if (this.listening)
+            return;
+        this.listening = true;
+        this.poll();
+        this.port.on("message", (m) => { this.onMessage(m); });
+        if (!this.refd)
+            safely(() => { this.port.unref(); });
     }
     onMessage(m) {
         const msg = m;
+        this.messages++;
         switch (msg?.t) {
             case "ready":
                 if (this.state === "starting" || this.state === "ready") {
@@ -1374,8 +1449,16 @@ class TransportThread {
                         if (typeof c.index === "number" && typeof c.addr === "string" && typeof c.localPort === "number")
                             traceEventAt(`thread:conn${c.index} ${c.addr} ${c.localPort}`, t);
                     }
+                    if (first)
+                        this.started();
                 }
                 return;
+            case "ev": {
+                const e = msg;
+                if (typeof e.n === "string" && typeof e.hr === "number")
+                    traceEventAt(`thread:w-${e.n}`, e.hr - this.hrOffset);
+                return;
+            }
             case "sessions":
                 if (typeof msg.sessions === "number")
                     this.sessions = msg.sessions;
@@ -1386,17 +1469,12 @@ class TransportThread {
                     if (this.closedReason === "")
                         this.closedReason = msg.reason ?? "draining";
                     traceEvent("thread:draining");
+                    this.started();
                 }
                 return;
             case "closed":
                 this.close(msg.reason ?? "closed");
                 return;
-            case "ack": {
-                const p = this.inflight.get(msg.id ?? -1);
-                if (p !== undefined)
-                    p.acked = true;
-                return;
-            }
             case "res":
             case "err":
                 this.settle(m);
@@ -1472,6 +1550,7 @@ class TransportThread {
             this.port.postMessage({ t: "drain" });
         }
         catch { }
+        this.started();
     }
     close(reason) {
         if (this.state === "closed")
@@ -1480,10 +1559,13 @@ class TransportThread {
         if (this.closedReason === "")
             this.closedReason = reason;
         traceEvent("thread:closed");
+        this.started();
+        this.outbox = [];
         for (const [id, p] of [...this.inflight]) {
+            const sent = this.acked(p);
             this.inflight.delete(id);
             this.release(p);
-            if (!p.acked)
+            if (!sent)
                 p.resolve(UNSENT);
             else if (p.replayable)
                 p.resolve(new HandBack(0, 1));
@@ -1500,23 +1582,50 @@ class TransportThread {
         }
     }
     ref() {
-        if (!this.listening) {
-            this.listening = true;
-            this.poll();
-            this.port.on("message", (m) => { this.onMessage(m); });
-        }
+        this.listen();
+        if (this.refd)
+            return;
+        this.refd = true;
         safely(() => { this.port.ref(); });
         safely(() => { this.worker.ref(); });
+        this.sweep = setInterval(() => { this.sweepBackstops(); }, THREAD_SWEEP_MS);
+        safely(() => { this.sweep?.unref?.(); });
     }
     unref() {
+        if (this.sweep !== undefined) {
+            clearInterval(this.sweep);
+            this.sweep = undefined;
+        }
+        if (!this.refd)
+            return;
+        this.refd = false;
         safely(() => { this.port.unref(); });
         safely(() => { this.worker.unref(); });
     }
+    sweepBackstops() {
+        this.poll();
+        const now = performance.now();
+        let late = false;
+        for (const [id, p] of [...this.inflight]) {
+            if (p.backstopAt > now)
+                continue;
+            late = true;
+            this.inflight.delete(id);
+            this.release(p);
+            try {
+                this.port.postMessage({ t: "cancel", id });
+            }
+            catch { }
+            p.reject(timeoutReason());
+        }
+        if (late)
+            this.close("no answer from the transport thread");
+    }
     release(p) {
         if (p.signal !== undefined && p.onAbort !== undefined)
             p.signal.removeEventListener("abort", p.onAbort);
-        if (p.backstop !== undefined)
-            clearTimeout(p.backstop);
+        Atomics.store(this.acks, p.mark, 0);
+        this.freeMarks.push(p.mark);
         if (this.inflight.size === 0)
             this.unref();
     }
@@ -1541,8 +1650,11 @@ class TransportThread {
             headers["content-length"] = Buffer.byteLength(init.body, "utf8");
         const id = this.nextId++;
         const tr = init.trace;
+        const place = this.freeMarks.pop();
+        if (place === undefined)
+            return Promise.resolve(UNSENT);
         return new Promise((resolve, reject) => {
-            const p = { resolve, reject, method: init.method, replayable, acked: false, trace: tr };
+            const p = { id, resolve, reject, method: init.method, replayable, mark: place, backstopAt: performance.now() + remaining + THREAD_GRACE_MS, trace: tr };
             const signal = init.signal;
             if (signal !== undefined) {
                 p.signal = signal;
@@ -1551,47 +1663,59 @@ class TransportThread {
                         return;
                     this.inflight.delete(id);
                     this.release(p);
-                    try {
-                        this.port.postMessage({ t: "cancel", id });
+                    const queued = this.outbox.findIndex((b) => b.id === id);
+                    if (queued >= 0)
+                        this.outbox.splice(queued, 1);
+                    else {
+                        try {
+                            this.port.postMessage({ t: "cancel", id });
+                        }
+                        catch { }
                     }
-                    catch { }
                     reject(signal.reason);
                 };
                 signal.addEventListener("abort", p.onAbort, { once: true });
             }
-            p.backstop = setTimeout(() => {
-                this.poll();
-                if (!this.inflight.has(id))
-                    return;
-                this.inflight.delete(id);
-                this.release(p);
-                try {
-                    this.port.postMessage({ t: "cancel", id });
-                }
-                catch { }
-                reject(timeoutReason());
-                this.close("no answer from the transport thread");
-            }, remaining + THREAD_GRACE_MS);
-            safely(() => { p.backstop?.unref?.(); });
             this.inflight.set(id, p);
             this.ref();
-            try {
-                const paced = this.pace === "all" || (this.pace === "creates" && init.method === "POST" && CREATE_PATH.test(target.path));
-                this.port.postMessage({ t: "req", id, headers, sensitive: ["authorization"], body: init.body, timeoutMs: remaining, replayable, paced });
+            const paced = this.pace === "all" || (this.pace === "creates" && init.method === "POST" && CREATE_PATH.test(target.path));
+            this.outbox.push({ id, msg: { t: "req", id, mark: place, headers, sensitive: ["authorization"], body: init.body, timeoutMs: remaining, replayable, paced }, p, resolve, trace: tr });
+            if (!this.turnOpen) {
+                this.turnOpen = true;
+                queueMicrotask(() => { this.turnOpen = false; this.handOver(); });
+                this.handOver();
             }
-            catch {
-                this.inflight.delete(id);
-                this.release(p);
-                resolve(UNSENT);
-                return;
+            else if (this.outbox.length >= OUTBOX_GROUP)
+                this.handOver();
+        });
+    }
+    handOver() {
+        if (this.outbox.length === 0)
+            return;
+        const batch = this.outbox;
+        this.outbox = [];
+        try {
+            this.port.postMessage(batch.length === 1 ? batch[0].msg : { t: "reqs", list: batch.map((b) => b.msg) });
+            this.posts++;
+        }
+        catch {
+            for (const b of batch) {
+                if (!this.inflight.has(b.id))
+                    continue;
+                this.inflight.delete(b.id);
+                this.release(b.p);
+                b.resolve(UNSENT);
             }
-            if (tr !== undefined) {
-                mark(tr, "sub");
-                tr.via = "thread";
+            return;
+        }
+        for (const b of batch)
+            if (b.trace !== undefined) {
+                mark(b.trace, "sub");
+                b.trace.via = "thread";
             }
-        });
     }
 }
+const OUTBOX_GROUP = 8;
 let transportThread;
 function threadFor(origin) {
     const t = transportThread;
@@ -1599,6 +1723,55 @@ function threadFor(origin) {
         return undefined;
     return t.ready() && !lookupReplaced() ? t : undefined;
 }
+function startingThread(origin) {
+    const t = transportThread;
+    if (t === undefined || t.origin !== origin || lookupReplaced())
+        return undefined;
+    return t.starting() ? t : undefined;
+}
+let raceTraced = false;
+function firstUp(t, pool, deadline, signal) {
+    const first = !raceTraced;
+    if (first) {
+        raceTraced = true;
+        traceEvent("h2:race");
+    }
+    const stop = new AbortController();
+    const both = signal === undefined ? stop.signal : AbortSignal.any([signal, stop.signal]);
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const forget = t.whenStarted(() => {
+            if (done)
+                return;
+            const ready = threadFor(t.origin);
+            if (ready === undefined)
+                return;
+            done = true;
+            if (first)
+                traceEvent("h2:race-thread");
+            stop.abort();
+            resolve({ thread: ready });
+        });
+        pool.acquire(deadline, both).then((entry) => {
+            if (done) {
+                if (entry !== null)
+                    pool.end(entry);
+                return;
+            }
+            done = true;
+            forget();
+            if (first)
+                traceEvent("h2:race-pool");
+            resolve({ entry });
+        }, (err) => {
+            if (done)
+                return;
+            done = true;
+            forget();
+            reject(err);
+        });
+    });
+}
 function ownFile() {
     const frame = (new Error().stack ?? "").split("\n")[1] ?? "";
     const m = /\((.*):\d+:\d+\)\s*$/.exec(frame) ?? /at (.*):\d+:\d+\s*$/.exec(frame);
@@ -1636,11 +1809,12 @@ function startTransportThread(origin, onFail) {
         const knobs = threadKnobs();
         const file = typeof seam.transportFile === "string" ? seam.transportFile : here.replace(/http2\.js$/, "transport-worker.js");
         const { port1, port2 } = new MessageChannel();
+        const acks = new Int32Array(new SharedArrayBuffer(4 * THREAD_MARKS));
         const worker = new Worker(file.startsWith("file:") ? new URL(file) : file, {
             workerData: {
-                promigenceTransport: true, port: port2, origin: origin.origin, sessions: knobs.sessions, gapUs: knobs.gapUs,
+                promigenceTransport: true, port: port2, acks, origin: origin.origin, sessions: knobs.sessions, gapUs: knobs.gapUs,
                 firstUseMs: tuning.loadFirstUseMs, idleMs: IDLE_CLOSE_MS, connectTimeoutMs: CONNECT_TIMEOUT_MS,
-                lookupTimeoutMs: EARLY_TIMEOUT_MS, trace: TRACE_ON,
+                lookupTimeoutMs: LOOKUP_FIRST_MS, lookupTries: LOOKUP_TRIES, lookupAtMs: LOOKUP_AT_MS, trace: TRACE_ON,
                 servers: tuning.earlyServers ?? (Array.isArray(seam.servers) ? seam.servers : undefined),
                 hostsFile: tuning.earlyHostsFile ?? (typeof seam.hostsFile === "string" ? seam.hostsFile : undefined),
                 distrustedForTest: __caGuardInternals.testHashes(),
@@ -1651,13 +1825,18 @@ function startTransportThread(origin, onFail) {
         });
         worker.unref();
         port1.unref();
-        const t = new TransportThread(origin.origin, worker, port1);
+        const t = new TransportThread(origin.origin, worker, port1, acks);
         t.pace = knobs.pace;
         t.onFail = onFail;
         worker.on("error", () => { t.poll(); t.close("error"); });
         worker.on("exit", () => { t.poll(); t.close("exit"); });
         transportThread = t;
         traceEvent("thread:start");
+        onTraceFlush(() => {
+            t.poll();
+            for (const e of earlies.values())
+                pollEarly(e);
+        });
     }
     catch {
         transportThread = undefined;
@@ -1673,6 +1852,18 @@ function knownPrefix(url) {
     }
     return undefined;
 }
+let lastTargetUrl;
+let lastTargetRead;
+let targetReads = 0;
+function lastTarget(url) {
+    if (url === lastTargetUrl)
+        return lastTargetRead;
+    targetReads++;
+    const target = targetOf(url, knownPrefix(url), remember);
+    lastTargetUrl = url;
+    lastTargetRead = target;
+    return target;
+}
 function remember(p) {
     for (let i = 0; i < prefixes.length; i++)
         if (prefixes[i].text === p.text)
@@ -1708,7 +1899,7 @@ export class Http2Transport {
         const deadline = performance.now() + init.timeoutMs;
         let target;
         try {
-            target = targetOf(url, knownPrefix(url), remember);
+            target = lastTarget(url);
         }
         catch {
             return this.viaFetch(url, init, deadline);
@@ -1732,8 +1923,34 @@ export class Http2Transport {
         const pool = poolFor(target.origin);
         if (!pool.usable())
             return this.viaFetch(url, init, deadline);
+        let raced = false;
         for (;;) {
-            const entry = pool.tryAcquire() ?? await pool.acquire(deadline, init.signal);
+            let entry = pool.tryAcquire();
+            if (entry === undefined) {
+                const starting = raced || resends > 0 || replays > 0 ? undefined : startingThread(target.origin);
+                if (starting !== undefined) {
+                    raced = true;
+                    const won = await firstUp(starting, pool, deadline, init.signal);
+                    if (won.thread !== undefined) {
+                        if (tr !== undefined)
+                            mark(tr, "race");
+                        const out = await won.thread.send(target, init, replayable, deadline);
+                        if (out === VIA_FETCH)
+                            return this.viaFetch(url, init, deadline);
+                        if (!(out instanceof HandBack))
+                            return out;
+                        resends = out.resends;
+                        replays = out.replays;
+                        if (tr !== undefined)
+                            delete tr.via;
+                        continue;
+                    }
+                    entry = won.entry;
+                }
+                else {
+                    entry = await pool.acquire(deadline, init.signal);
+                }
+            }
             if (tr !== undefined)
                 mark(tr, "acq");
             if (entry === null)
@@ -1768,6 +1985,15 @@ export class Http2Transport {
         }
     }
 }
+let sharedFallback;
+let shared;
+export function sharedTransport(fallback) {
+    if (shared === undefined || sharedFallback !== fallback) {
+        shared = new Http2Transport(fallback);
+        sharedFallback = fallback;
+    }
+    return shared;
+}
 export function warmTransport() {
     const res = toResponse(200, { "content-type": "application/json" }, Buffer.from("{}"), "POST");
     res.header("server-timing");
@@ -1780,6 +2006,9 @@ export function warmTransport() {
     exchange({ end() { } }, undefined, { origin: none, host: none, path: none }, undefined, 0).catch(() => { });
 }
 export const __http2Internals = {
+    targetReads() {
+        return targetReads;
+    },
     pools() {
         return [...pools.values()].map((p) => ({
             origin: p.origin.origin,
@@ -1820,11 +2049,17 @@ export const __http2Internals = {
         if (t === undefined)
             return undefined;
         t.poll();
-        return { state: t.state, sessions: t.sessions, limit: t.limit, answered: t.answered, everReady: t.everReady, closedReason: t.closedReason };
+        return { state: t.state, sessions: t.sessions, limit: t.limit, answered: t.answered, everReady: t.everReady, closedReason: t.closedReason, messages: t.messages, posts: t.posts, startedAt: t.startedAt };
     },
     threadKnobs(env) {
         return threadKnobs(env);
     },
+    wedgeThreadForTest() {
+        try {
+            transportThread?.port.postMessage({ t: "wedge-for-test" });
+        }
+        catch { }
+    },
     crashThreadForTest() {
         try {
             transportThread?.port.postMessage({ t: "crash-for-test" });
@@ -1863,6 +2098,15 @@ function isMainThread() {
         return false;
     }
 }
+function standby(url) {
+    try {
+        traceEvent("h2:standby");
+        warmTls();
+        poolFor(url.origin).warm(tuning.loadFirstUseMs);
+    }
+    catch {
+    }
+}
 function connectAtLoad() {
     try {
         if (!isNode() || Number(process.versions.node.split(".")[0]) < 22)
@@ -1883,6 +2127,8 @@ function connectAtLoad() {
                 if (url.protocol === "https:" && !customDispatcher() && earlyPlatform() && v4First() && !threadOff && earlySeam().transportThread !== false) {
                     startTransportThread(url, () => { if (loadTurnRan)
                         warmAtLoad(); });
+                    if (isIP(host) === 0)
+                        earlyLookupFor(host);
                 }
                 else if (url.protocol === "https:" && !customDispatcher() && isIP(host) === 0 && earlyPlatform() && v4First())
                     earlyLookupFor(host);
@@ -1901,10 +2147,27 @@ function connectAtLoad() {
                 const url = new URL(raw ? raw : DEFAULT_API_URL);
                 if (url.protocol !== "https:" || customDispatcher())
                     return;
-                if (transportThread !== undefined && transportThread.origin === url.origin) {
-                    transportThread.poll();
-                    if (transportThread.state !== "closed" || transportThread.everReady)
+                const t = transportThread;
+                if (t !== undefined && t.origin === url.origin) {
+                    t.poll();
+                    if (t.everReady)
                         return;
+                    if (t.state !== "closed") {
+                        const check = () => {
+                            t.poll();
+                            if (t.everReady || t.state === "closed")
+                                return;
+                            const wait = t.startedAt + tuning.standbyAfterMs - performance.now();
+                            if (wait > 0) {
+                                const timer = setTimeout(check, wait);
+                                timer.unref?.();
+                                return;
+                            }
+                            standby(url);
+                        };
+                        check();
+                        return;
+                    }
                 }
                 warmTls();
                 poolFor(url.origin).warm(tuning.loadFirstUseMs);