promigence 0.1.0-beta.12

package/dist/sdk/http2.js

@@ -0,0 +1,1921 @@
+import * as http2 from "node:http2";
+import { isIP } from "node:net";
+import * as tls from "node:tls";
+import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
+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";
+const MAX_SESSIONS = 4;
+const FIRST_SESSIONS = 2;
+const BURST_MIN = 8;
+const HOLD_MS = 10;
+const LOAD_FIRST_USE_MS = 120_000;
+const CONNECT_TIMEOUT_MS = 10_000;
+const IDLE_CLOSE_MS = 10_000;
+const PING_TIMEOUT_MS = 2_000;
+const RETRY_AFTER_MS = 30_000;
+const MAX_UNPROCESSED_RESENDS = 3;
+const MAX_REPLAYS = 1;
+const MAX_CONNECT_FAILURES = 3;
+const MAX_BAD_SESSIONS = 3;
+const MAX_STREAM_FAILURES = 5;
+const DEFAULT_STREAM_LIMIT = 100;
+const MAX_STREAM_LIMIT = 1_000;
+const STREAM_WINDOW = 8 * 1024 * 1024;
+const SESSION_WINDOW = 32 * 1024 * 1024;
+const { NGHTTP2_CANCEL, NGHTTP2_REFUSED_STREAM, NGHTTP2_HTTP_1_1_REQUIRED } = http2.constants;
+const FETCH_AT_LOAD = globalThis.fetch;
+const PROXY_VARS = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"];
+const OFF = new Set(["0", "false", "off", "no"]);
+const NOT_IN_H2 = new Set(["connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "host", "te"]);
+export function http2Allowed(opt, env = process.env) {
+    try {
+        const envFlag = env["PROMIGENCE_HTTP2"]?.trim().toLowerCase();
+        const wanted = opt ?? (envFlag === undefined || envFlag === "" ? true : !OFF.has(envFlag));
+        if (!wanted)
+            return false;
+        if (!isNode())
+            return false;
+        if (typeof http2.connect !== "function")
+            return false;
+        if (globalThis.fetch !== FETCH_AT_LOAD)
+            return false;
+        if (customDispatcher())
+            return false;
+        if (PROXY_VARS.some((k) => (env[k] ?? "").trim() !== ""))
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isNode() {
+    const v = typeof process === "object" ? process.versions : undefined;
+    return Boolean(v?.["node"]) && !v?.["bun"] && !v?.["deno"];
+}
+let tlsWarmed = false;
+export function warmTls() {
+    if (tlsWarmed)
+        return;
+    tlsWarmed = true;
+    try {
+        if (isNode())
+            tls.createSecureContext();
+    }
+    catch {
+    }
+}
+const utf8 = new TextDecoder("utf-8");
+export class H2Response {
+    status;
+    raw;
+    bytes;
+    ok;
+    built;
+    constructor(status, raw, bytes) {
+        this.status = status;
+        this.raw = raw;
+        this.bytes = bytes;
+        this.ok = status >= 200 && status < 300;
+    }
+    replayed = false;
+    header(name) {
+        const v = this.raw[name.toLowerCase()];
+        if (v === undefined)
+            return null;
+        return Array.isArray(v) ? v.join(", ") : String(v);
+    }
+    textNow() {
+        const b = this.bytes;
+        if (b === null || b.length === 0)
+            return "";
+        return utf8.decode(b);
+    }
+    get headers() {
+        if (this.built === undefined) {
+            const h = new Headers();
+            for (const [k, v] of Object.entries(this.raw)) {
+                if (k.startsWith(":") || v === undefined)
+                    continue;
+                if (Array.isArray(v))
+                    for (const x of v)
+                        h.append(k, x);
+                else
+                    h.append(k, String(v));
+            }
+            this.built = h;
+        }
+        return this.built;
+    }
+    text() {
+        return Promise.resolve(this.textNow());
+    }
+}
+class OriginPool {
+    origin;
+    sessions = [];
+    connecting;
+    backgrounds = [];
+    opening;
+    holding = false;
+    parked;
+    warmed = 0;
+    off = false;
+    offReason = "";
+    suspendedUntil = 0;
+    connectFailures = 0;
+    badSessions = 0;
+    streamFailures = 0;
+    opened = 0;
+    knownLimit;
+    constructor(origin) {
+        this.origin = origin;
+    }
+    usable() {
+        return !this.off && Date.now() >= this.suspendedUntil;
+    }
+    turnOff(reason) {
+        if (!this.off) {
+            this.off = true;
+            this.offReason = reason;
+        }
+    }
+    tryAcquire() {
+        if (this.holding)
+            return undefined;
+        const best = this.leastLoaded();
+        if (best === undefined)
+            return undefined;
+        if (best.gotSettings && best.active >= streamLimit(best) && this.sessions.length < MAX_SESSIONS)
+            return undefined;
+        this.begin(best);
+        return best;
+    }
+    acquire(deadline, signal) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        return new Promise((resolve, reject) => {
+            let done = false;
+            let rounds = 0;
+            let counted;
+            const settle = () => {
+                done = true;
+                clearTimeout(timer);
+                if (signal !== undefined)
+                    signal.removeEventListener("abort", onAbort);
+                if (counted !== undefined && !counted.released)
+                    counted.waiters--;
+                counted = undefined;
+            };
+            const onAbort = () => { if (!done) {
+                settle();
+                reject(signal?.reason);
+            } };
+            const timer = setTimeout(() => { if (!done) {
+                settle();
+                reject(timeoutReason());
+            } }, Math.max(0, deadline - performance.now()));
+            timer.unref?.();
+            if (signal !== undefined)
+                signal.addEventListener("abort", onAbort, { once: true });
+            const attempt = (opened) => {
+                if (done)
+                    return;
+                counted = undefined;
+                try {
+                    if (!this.usable()) {
+                        settle();
+                        resolve(null);
+                        return;
+                    }
+                    const ready = this.tryAcquire();
+                    if (ready !== undefined) {
+                        settle();
+                        resolve(ready);
+                        return;
+                    }
+                    if (opened === null || ++rounds > MAX_SESSIONS + 1) {
+                        const any = this.leastLoaded();
+                        if (any !== undefined)
+                            this.begin(any);
+                        settle();
+                        resolve(any ?? null);
+                        return;
+                    }
+                    if (!this.connecting) {
+                        this.unpark();
+                        const opening = this.leastLoaded() === undefined ? this.openFirst(false) : this.open();
+                        this.connecting = opening.finally(() => { this.connecting = undefined; });
+                    }
+                    this.hold();
+                    const o = this.opening;
+                    if (o !== undefined && !o.released) {
+                        o.waiters++;
+                        counted = o;
+                    }
+                    this.connecting.then(attempt, () => attempt(null));
+                }
+                catch {
+                    settle();
+                    resolve(null);
+                }
+            };
+            attempt(undefined);
+        });
+    }
+    leastLoaded() {
+        let best;
+        for (const e of this.sessions) {
+            if (e.retired || e.session.closed || e.session.destroyed)
+                continue;
+            if (!best || e.active < best.active)
+                best = e;
+        }
+        return best;
+    }
+    warm(firstUseMs) {
+        if (!this.usable() || this.connecting !== undefined || this.leastLoaded() !== undefined || this.parked !== undefined)
+            return;
+        const route = backgroundRoute(this.origin);
+        if (route.kind === "none") {
+            traceEvent("h2:warm-none");
+            return;
+        }
+        if (route.kind === "wait") {
+            const parked = { cancelled: false };
+            this.parked = parked;
+            traceEvent("h2:warm-park");
+            onEarlyAnswer(route.early, () => {
+                if (parked.cancelled || this.parked !== parked)
+                    return;
+                this.parked = undefined;
+                const next = backgroundRoute(this.origin);
+                if (next.kind === "answer")
+                    this.startWarm(firstUseMs, next.answer);
+                else
+                    traceEvent("h2:warm-none");
+            });
+            return;
+        }
+        this.startWarm(firstUseMs, route.kind === "answer" ? route.answer : undefined);
+    }
+    startWarm(firstUseMs, pre) {
+        if (!this.usable() || this.connecting !== undefined || this.leastLoaded() !== undefined)
+            return;
+        if (pre !== undefined && !busyElsewhere()) {
+            traceEvent("h2:warm-idle");
+            return;
+        }
+        this.warmed++;
+        traceEvent("h2:warm");
+        const opening = this.openFirst(true, firstUseMs, pre).finally(() => { this.connecting = undefined; });
+        this.connecting = opening;
+        opening.catch(() => { });
+    }
+    isConnecting() { return this.connecting !== undefined; }
+    isParked() { return this.parked !== undefined; }
+    unpark() {
+        if (this.parked === undefined)
+            return;
+        this.parked.cancelled = true;
+        this.parked = undefined;
+        traceEvent("h2:warm-unpark");
+    }
+    hold() {
+        for (const bg of this.backgrounds) {
+            if (bg.held)
+                continue;
+            bg.held = true;
+            safely(() => { bg.socket?.ref(); });
+            safely(() => { bg.timer?.ref?.(); });
+        }
+    }
+    track() {
+        const bg = { held: false, done: false, socket: undefined, timer: undefined };
+        this.backgrounds.push(bg);
+        return bg;
+    }
+    untrack(bg) {
+        const k = this.backgrounds.indexOf(bg);
+        if (k >= 0)
+            this.backgrounds.splice(k, 1);
+    }
+    openFirst(background, firstUseMs, pre) {
+        const n = sessionsWanted();
+        const idle = firstUseMs === undefined ? {} : { firstUseMs };
+        const ownOpts = pre === undefined ? idle : { ...idle, preResolved: pre };
+        if (n <= 1) {
+            if (!background)
+                return this.open(undefined, ownOpts);
+            const bg = this.track();
+            return this.open(bg, ownOpts).finally(() => { this.untrack(bg); });
+        }
+        let resolve;
+        const handed = new Promise((r) => { resolve = r; });
+        const own = this.track();
+        const o = { waiters: 0, pending: 1, first: null, own, released: false, hold: undefined, resolve };
+        this.opening = o;
+        let started = false;
+        const observe = (answer) => {
+            if (started || o.released || !this.usable())
+                return;
+            started = true;
+            for (const order of extraOrders(answer, n)) {
+                o.pending++;
+                traceEvent("h2:extra");
+                const bg = { held: false, done: false, socket: undefined, timer: undefined };
+                this.open(bg, { ...idle, answer: order }).then((e) => { this.settled(o, e, false); }, () => { this.settled(o, null, false); });
+            }
+        };
+        this.open(own, pre === undefined ? { ...idle, observe } : ownOpts).finally(() => { this.untrack(own); })
+            .then((e) => { this.settled(o, e, true); }, () => { this.settled(o, null, true); });
+        if (pre !== undefined)
+            observe(pre);
+        return handed;
+    }
+    settled(o, entry, own) {
+        o.pending--;
+        if (o.released)
+            return;
+        if (entry !== null && o.first === null)
+            o.first = entry;
+        if (o.first === null) {
+            if (own || o.pending === 0)
+                this.release(o);
+            return;
+        }
+        if (o.pending === 0) {
+            this.release(o);
+            return;
+        }
+        if (o.hold !== undefined)
+            return;
+        if (o.waiters >= tuning.burstMin && tuning.holdMs > 0) {
+            this.holding = true;
+            traceEvent("h2:hold");
+            o.hold = setTimeout(() => { this.release(o); }, tuning.holdMs);
+            return;
+        }
+        this.release(o);
+    }
+    release(o) {
+        if (o.released)
+            return;
+        o.released = true;
+        if (o.hold !== undefined) {
+            clearTimeout(o.hold);
+            o.hold = undefined;
+        }
+        if (this.opening === o) {
+            this.opening = undefined;
+            this.holding = false;
+        }
+        this.untrack(o.own);
+        if (!o.own.done && o.own.held) {
+            o.own.held = false;
+            safely(() => { o.own.socket?.unref(); });
+            safely(() => { o.own.timer?.unref?.(); });
+        }
+        traceEvent("h2:release");
+        o.resolve(o.first);
+    }
+    async open(bg, o = {}) {
+        const growing = this.leastLoaded() !== undefined;
+        const extra = o.answer !== undefined;
+        const pre = o.preResolved;
+        let asked = { v4: false, early: false };
+        const lookup = extra ? fixedLookup(o.answer) : pre !== undefined ? fixedLookup(pre) : apiLookup(asked, o.observe);
+        let res = await tlsConnect(this.origin, bg, lookup, extra || pre !== undefined);
+        if ((pre !== undefined || asked.early) && !(res.ok && res.socket.alpnProtocol === "h2") && !givenUp(res)) {
+            if (res.ok)
+                res.socket.destroy();
+            if (pre !== undefined && (bg === undefined || !bg.held))
+                return null;
+            traceEvent("dns:fallback");
+            if (bg !== undefined)
+                bg.done = false;
+            asked = { v4: false, early: false };
+            res = await tlsConnect(this.origin, bg, apiLookup(asked, undefined, undefined, false), false);
+        }
+        if (!res.ok && res.phase === "tcp" && asked.v4 && res.error?.givenUp !== true) {
+            traceEvent("dns:both");
+            if (bg !== undefined)
+                bg.done = false;
+            res = await tlsConnect(this.origin, bg, apiLookup({ v4: false }, undefined, false), extra);
+        }
+        if (!res.ok) {
+            if (growing || extra)
+                return null;
+            if (o.observe !== undefined && this.leastLoaded() !== undefined)
+                return null;
+            if (bg !== undefined && !bg.held && res.phase === "tcp")
+                return null;
+            if (res.phase === "tls") {
+                this.turnOff(`TLS handshake failed: ${errCode(res.error)}`);
+            }
+            else if (++this.connectFailures >= MAX_CONNECT_FAILURES) {
+                this.turnOff(`connect failed ${this.connectFailures} times: ${errCode(res.error)}`);
+            }
+            else {
+                this.suspendedUntil = Date.now() + RETRY_AFTER_MS;
+            }
+            return null;
+        }
+        const socket = res.socket;
+        if (socket.alpnProtocol !== "h2") {
+            socket.destroy();
+            if (!extra)
+                this.turnOff(`server chose ${socket.alpnProtocol || "no protocol"} over h2`);
+            return null;
+        }
+        this.connectFailures = 0;
+        let session;
+        try {
+            session = http2.connect(this.origin.origin, {
+                createConnection: () => socket,
+                settings: { enablePush: false, initialWindowSize: STREAM_WINDOW },
+                ...(this.knownLimit === undefined ? {} : { peerMaxConcurrentStreams: this.knownLimit }),
+            });
+        }
+        catch (err) {
+            socket.destroy();
+            if (!extra)
+                this.turnOff(`http2.connect threw: ${errCode(err)}`);
+            return null;
+        }
+        const entry = {
+            session, active: 0, retired: false, goawayLast: undefined, idleTimer: undefined,
+            pinging: false, lostStreams: 0, gotSettings: false,
+        };
+        traceEvent("h2:session");
+        session.on("remoteSettings", (settings) => {
+            traceEvent("h2:settings");
+            entry.gotSettings = true;
+            const m = settings.maxConcurrentStreams;
+            if (typeof m === "number" && m > 0)
+                this.knownLimit = Math.min(m, MAX_STREAM_LIMIT);
+        });
+        session.on("error", () => { this.retire(entry); });
+        session.on("goaway", (_code, lastStreamId) => {
+            entry.goawayLast = Math.min(entry.goawayLast ?? lastStreamId, lastStreamId);
+            this.retire(entry);
+        });
+        session.on("close", () => { this.retire(entry); });
+        safely(() => session.setLocalWindowSize(SESSION_WINDOW));
+        session.on("frameError", () => { });
+        this.sessions.push(entry);
+        this.opened++;
+        this.markIdle(entry, o.firstUseMs);
+        return entry;
+    }
+    retire(entry) {
+        if (entry.idleTimer !== undefined) {
+            clearTimeout(entry.idleTimer);
+            entry.idleTimer = undefined;
+        }
+        if (entry.retired)
+            return;
+        entry.retired = true;
+        const i = this.sessions.indexOf(entry);
+        if (i >= 0)
+            this.sessions.splice(i, 1);
+        if (entry.active === 0)
+            safely(() => entry.session.unref());
+    }
+    begin(entry) {
+        if (entry.idleTimer !== undefined) {
+            clearTimeout(entry.idleTimer);
+            entry.idleTimer = undefined;
+        }
+        if (entry.active++ === 0)
+            safely(() => entry.session.ref());
+    }
+    end(entry) {
+        entry.active = Math.max(0, entry.active - 1);
+        if (entry.active === 0)
+            this.markIdle(entry);
+    }
+    markIdle(entry, ms = IDLE_CLOSE_MS) {
+        safely(() => entry.session.unref());
+        if (entry.retired)
+            return;
+        entry.idleTimer = setTimeout(() => {
+            entry.idleTimer = undefined;
+            if (entry.active !== 0)
+                return;
+            this.retire(entry);
+            safely(() => entry.session.close());
+        }, ms);
+        entry.idleTimer.unref?.();
+    }
+    succeeded() {
+        this.streamFailures = 0;
+        this.badSessions = 0;
+    }
+    streamFailed(entry, sessionDying) {
+        if (sessionDying) {
+            if (entry.lostStreams++ === 0 && ++this.badSessions >= MAX_BAD_SESSIONS) {
+                this.turnOff(`${this.badSessions} sessions in a row died with requests in flight`);
+            }
+            return;
+        }
+        if (++this.streamFailures >= MAX_STREAM_FAILURES)
+            this.turnOff(`${this.streamFailures} requests in a row failed on a live session`);
+    }
+    checkAlive(entry) {
+        if (entry.pinging || entry.retired)
+            return;
+        entry.pinging = true;
+        const drop = () => {
+            if (++this.badSessions >= MAX_BAD_SESSIONS)
+                this.turnOff(`${this.badSessions} sessions in a row stopped answering`);
+            this.retire(entry);
+            safely(() => entry.session.destroy());
+        };
+        const timer = setTimeout(drop, PING_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            const sent = entry.session.ping((err) => {
+                entry.pinging = false;
+                clearTimeout(timer);
+                if (err)
+                    drop();
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                entry.pinging = false;
+            }
+        }
+        catch {
+            clearTimeout(timer);
+            entry.pinging = false;
+            drop();
+        }
+    }
+}
+export const tuning = {
+    sessions: undefined,
+    holdMs: HOLD_MS,
+    burstMin: BURST_MIN,
+    loadFirstUseMs: LOAD_FIRST_USE_MS,
+    earlyPlatform: undefined,
+    earlyServers: undefined,
+    earlyHostsFile: undefined,
+};
+let sessionsFromEnv;
+function sessionsWanted() {
+    if (tuning.sessions !== undefined)
+        return parseSessions(String(tuning.sessions));
+    if (sessionsFromEnv === undefined) {
+        let raw;
+        try {
+            raw = process.env["PROMIGENCE_HTTP2_SESSIONS"];
+        }
+        catch {
+            raw = undefined;
+        }
+        sessionsFromEnv = parseSessions(raw);
+    }
+    return sessionsFromEnv;
+}
+export function parseSessions(raw) {
+    const t = raw?.trim().toLowerCase() ?? "";
+    if (t === "")
+        return FIRST_SESSIONS;
+    if (OFF.has(t))
+        return 1;
+    const n = Number(t);
+    if (!Number.isInteger(n) || n < 0)
+        return FIRST_SESSIONS;
+    return Math.max(1, Math.min(MAX_SESSIONS, n));
+}
+export function extraOrders(answer, sessions) {
+    if (sessions <= 1 || answer.length < 2)
+        return [];
+    const family = answer[0].family;
+    const seen = new Set();
+    const mine = [];
+    const other = [];
+    for (const a of answer) {
+        if (typeof a?.address !== "string" || seen.has(a.address))
+            continue;
+        seen.add(a.address);
+        (a.family === family ? mine : other).push(a);
+    }
+    const rot = (list, by) => {
+        if (list.length === 0)
+            return [];
+        const k = by % list.length;
+        return [...list.slice(k), ...list.slice(0, k)];
+    };
+    const out = [];
+    for (let i = 1; i < Math.min(sessions, mine.length); i++)
+        out.push([...rot(mine, i), ...rot(other, i)]);
+    return out;
+}
+function streamLimit(entry) {
+    try {
+        const m = entry.session.remoteSettings?.maxConcurrentStreams;
+        return typeof m === "number" && m > 0 ? Math.min(m, MAX_STREAM_LIMIT) : DEFAULT_STREAM_LIMIT;
+    }
+    catch {
+        return DEFAULT_STREAM_LIMIT;
+    }
+}
+function safely(fn) {
+    try {
+        fn();
+    }
+    catch { }
+}
+function errCode(err) {
+    const e = err;
+    return e?.code ?? e?.message ?? String(err);
+}
+const TRANSIENT = new Set(["ECONNRESET", "ETIMEDOUT", "EPIPE", "ECONNABORTED", "EHOSTUNREACH", "ENETUNREACH", "EAI_AGAIN"]);
+const IDLE_CHECK_MS = 5;
+const onTheWire = new Set();
+let idleCheck;
+function activeResources() {
+    try {
+        const info = process.getActiveResourcesInfo;
+        return typeof info === "function" ? info.call(process) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function watchWire(w) {
+    onTheWire.add(w);
+    if (idleCheck !== undefined)
+        return;
+    idleCheck = setInterval(checkIdle, IDLE_CHECK_MS);
+    safely(() => { idleCheck?.unref?.(); });
+}
+function unwatchWire(w) {
+    if (!onTheWire.delete(w))
+        return;
+    if (onTheWire.size === 0 && idleCheck !== undefined) {
+        clearInterval(idleCheck);
+        idleCheck = undefined;
+    }
+}
+function checkIdle() {
+    const info = activeResources();
+    if (info === undefined)
+        return;
+    let connects = 0, lookups = 0, timers = 0;
+    for (const t of info) {
+        if (t === "ConnectWrap")
+            connects++;
+        else if (t === "GetAddrInfoReqWrap")
+            lookups++;
+        else if (t === "Timeout")
+            timers++;
+        else if (t !== "PipeWrap" && t !== "TTYWrap")
+            return;
+    }
+    let c = 0, l = 0, t = 0;
+    for (const w of onTheWire) {
+        if (w.bg.held)
+            return;
+        if (w.tcp)
+            c++;
+        if (w.lookup)
+            l++;
+        if (w.attemptTimer)
+            t++;
+    }
+    if (connects > c || lookups > l || timers > t)
+        return;
+    for (const w of [...onTheWire])
+        safely(w.giveUp);
+}
+function tlsConnect(origin, bg, lookup, fixed = false) {
+    return new Promise((resolve) => {
+        const host = origin.hostname.replace(/^\[(.*)\]$/, "$1");
+        const port = origin.port ? Number(origin.port) : 443;
+        let tcpUp = false;
+        let done = false;
+        let socket;
+        const release = () => {
+            if (bg !== undefined && !bg.held && !done)
+                safely(() => { socket.unref(); });
+        };
+        let wire;
+        const finish = (r) => {
+            if (done)
+                return;
+            done = true;
+            if (bg !== undefined)
+                bg.done = true;
+            if (wire !== undefined)
+                unwatchWire(wire);
+            clearTimeout(timer);
+            socket.removeListener("error", onError);
+            if (bg !== undefined)
+                socket.removeListener("connectionAttempt", release);
+            if (!r.ok)
+                socket.destroy();
+            resolve(r);
+        };
+        const onError = (error) => {
+            const phase = tcpUp && !TRANSIENT.has(errCode(error)) ? "tls" : "tcp";
+            finish({ ok: false, phase, error });
+        };
+        const timer = setTimeout(() => {
+            finish({ ok: false, phase: "tcp", error: Object.assign(new Error("connect timed out"), { code: "ETIMEDOUT" }) });
+        }, CONNECT_TIMEOUT_MS);
+        try {
+            traceEvent("tls:connect");
+            socket = tls.connect({
+                host,
+                port,
+                ...(isIP(host) ? {} : { servername: host }),
+                ALPNProtocols: ["h2", "http/1.1"],
+                checkServerIdentity: guardCertChain,
+                ...(lookup === undefined || isIP(host) ? {} : { lookup }),
+            });
+            traceEvent("tls:connect-returned");
+        }
+        catch (error) {
+            clearTimeout(timer);
+            resolve({ ok: false, phase: "tls", error });
+            return;
+        }
+        if (bg !== undefined) {
+            bg.socket = socket;
+            bg.timer = timer;
+            if (!bg.held)
+                safely(() => { timer.unref?.(); });
+            release();
+            socket.on("connectionAttempt", release);
+            const w = {
+                bg, lookup: !isIP(host) && !fixed, tcp: false, attemptTimer: false, addresses: new Set(), attempts: 0,
+                giveUp: () => finish({ ok: false, phase: "tcp", error: Object.assign(new Error("connect given up: nothing else keeps the process alive"), { code: "ECONNABORTED", givenUp: true }) }),
+            };
+            const attemptOver = () => { w.tcp = false; w.attemptTimer = false; };
+            socket.on("lookup", (_err, ip) => { w.lookup = false; if (typeof ip === "string")
+                w.addresses.add(ip); });
+            socket.on("connectionAttempt", () => { w.tcp = true; w.attempts++; w.attemptTimer = w.addresses.size > w.attempts; });
+            socket.on("connectionAttemptFailed", attemptOver);
+            socket.on("connectionAttemptTimeout", attemptOver);
+            socket.once("connect", () => { attemptOver(); unwatchWire(w); });
+            wire = w;
+            watchWire(w);
+        }
+        socket.once("connect", () => { tcpUp = true; release(); traceEvent("tcp:connected"); });
+        socket.once("secureConnect", () => { traceEvent("tls:secure"); finish({ ok: true, socket }); });
+        socket.on("error", onError);
+    });
+}
+function nodeDns() {
+    try {
+        const get = process.getBuiltinModule;
+        return typeof get === "function" ? get("node:dns") : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+let familySetting;
+function v4First() {
+    if (familySetting === undefined) {
+        let raw;
+        try {
+            raw = process.env["PROMIGENCE_DNS_FAMILY"];
+        }
+        catch {
+            raw = undefined;
+        }
+        familySetting = raw?.trim() === "0" ? 0 : 4;
+    }
+    return familySetting === 4;
+}
+export function lookupApiName(dnsLookup, hostname, options, callback, asked, ipv4First = true) {
+    const o = options;
+    const either = o.family === undefined || o.family === 0 || o.family === "IPv4or6";
+    if (!ipv4First || !either) {
+        dnsLookup(hostname, options, callback);
+        return;
+    }
+    dnsLookup(hostname, { ...options, family: 4 }, (err, address, family) => {
+        const found = err === null && (Array.isArray(address) ? address.length > 0 : typeof address === "string" && address !== "");
+        if (!found) {
+            dnsLookup(hostname, options, callback);
+            return;
+        }
+        asked.v4 = true;
+        callback(null, address, family);
+    });
+}
+function apiLookup(asked, observe, ipv4First = v4First(), earlyOk = true) {
+    if (!ipv4First && observe === undefined)
+        return undefined;
+    const dns = nodeDns();
+    if (dns === undefined)
+        return undefined;
+    return ((hostname, options, callback) => {
+        const lookup = dns.lookup;
+        const early = earlyOk && observe !== undefined && ipv4First ? earlyForRequest(hostname, options, lookup) : undefined;
+        if (early !== undefined) {
+            asked.early = true;
+            traceEvent("dns:early");
+            const all = options.all === true;
+            process.nextTick(() => {
+                if (all)
+                    callback(null, early);
+                else
+                    callback(null, early[0].address, 4);
+                safely(() => observe(early));
+            });
+            return;
+        }
+        lookupApiName(lookup, hostname, options, (err, address, family) => {
+            callback(err, address, family);
+            if (observe !== undefined && err === null && Array.isArray(address))
+                safely(() => observe(address));
+        }, asked, ipv4First);
+    });
+}
+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 = (() => {
+    try {
+        return nodeDns()?.lookup;
+    }
+    catch {
+        return undefined;
+    }
+})();
+function lookupReplaced() {
+    try {
+        const d = nodeDns();
+        return d !== undefined && d.lookup !== LOOKUP_AT_LOAD;
+    }
+    catch {
+        return true;
+    }
+}
+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 {} };
+try {
+  let named = false;
+  const v4 = [];
+  try {
+    for (const line of require("node:fs").readFileSync(hostsFile || "/etc/hosts", "utf8").split("\\n")) {
+      const f = line.replace(/#.*/, "").trim().split(/\\s+/);
+      if (f.length < 2 || !f.slice(1).some((n) => n.toLowerCase() === host)) continue;
+      named = true;
+      if (isIPv4(f[0]) && !v4.includes(f[0])) v4.push(f[0]);
+    }
+  } 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() });
+    });
+  }
+} catch { done({ host, none: "error" }); }
+`;
+const EARLY_SEAM = Symbol.for("promigence.sdk.early-seam");
+function earlySeam() {
+    const v = globalThis[EARLY_SEAM];
+    return v !== null && typeof v === "object" ? v : {};
+}
+function earlyPlatform() {
+    const seam = earlySeam().platform;
+    return (tuning.earlyPlatform ?? (typeof seam === "string" ? seam : undefined) ?? process.platform) === "linux";
+}
+function busyElsewhere() {
+    const info = activeResources();
+    if (info === undefined)
+        return true;
+    return info.some((t) => t !== "PipeWrap" && t !== "TTYWrap" && t !== "MessagePort" && t !== "Worker");
+}
+function earlyLookupFor(host) {
+    const known = earlies.get(host);
+    if (known !== undefined)
+        return known;
+    if (!earlyPlatform() || earlies.size >= MAX_EARLIES)
+        return undefined;
+    try {
+        const { port1, port2 } = new MessageChannel();
+        port1.unref();
+        const worker = new Worker(EARLY_WORKER, {
+            eval: true,
+            workerData: {
+                port: port2, host, timeoutMs: EARLY_TIMEOUT_MS,
+                servers: tuning.earlyServers ?? (Array.isArray(earlySeam().servers) ? earlySeam().servers : undefined),
+                hostsFile: tuning.earlyHostsFile ?? (typeof earlySeam().hostsFile === "string" ? earlySeam().hostsFile : undefined),
+            },
+            transferList: [port2],
+            env: {},
+            argv: [],
+            execArgv: [],
+        });
+        worker.unref();
+        const e = { host, port: port1, state: "pending", waiters: [], listening: false };
+        worker.on("error", () => { settleEarly(e, undefined); });
+        worker.on("exit", () => { pollEarly(e); if (e.state === "pending")
+            settleEarly(e, undefined); });
+        earlies.set(host, e);
+        traceEvent("dns:early-start");
+        return e;
+    }
+    catch {
+        return undefined;
+    }
+}
+function pollEarly(e) {
+    if (e.state !== "pending")
+        return;
+    try {
+        const got = receiveMessageOnPort(e.port);
+        if (got !== undefined)
+            settleEarly(e, got.message);
+    }
+    catch {
+        settleEarly(e, undefined);
+    }
+}
+function settleEarly(e, message) {
+    if (e.state !== "pending")
+        return;
+    const m = message;
+    const addrs = Array.isArray(m?.addrs) ? m.addrs.filter((a) => typeof a === "string" && isIP(a) === 4) : [];
+    if (m !== undefined && m.host === e.host && addrs.length > 0 && typeof m.at === "number") {
+        e.state = "answered";
+        e.answer = addrs.map((address) => ({ address, family: 4 }));
+        const ttlMs = typeof m.ttl === "number" && m.ttl >= 0 ? m.ttl * 1000 : 0;
+        e.until = m.at + Math.min(ttlMs, EARLY_MAX_AGE_MS);
+    }
+    else {
+        e.state = "none";
+    }
+    safely(() => { e.port.close(); });
+    const waiters = e.waiters.splice(0);
+    for (const w of waiters)
+        safely(w);
+}
+function onEarlyAnswer(e, cb) {
+    pollEarly(e);
+    if (e.state !== "pending") {
+        process.nextTick(cb);
+        return;
+    }
+    e.waiters.push(cb);
+    if (e.listening)
+        return;
+    e.listening = true;
+    try {
+        e.port.on("message", (m) => { settleEarly(e, m); });
+        e.port.unref();
+    }
+    catch {
+        settleEarly(e, undefined);
+    }
+}
+function earlyFresh(e) {
+    pollEarly(e);
+    if (e.state !== "answered" || e.answer === undefined || e.until === undefined || Date.now() > e.until)
+        return undefined;
+    return e.answer.map((a) => ({ ...a }));
+}
+function backgroundRoute(origin) {
+    try {
+        const host = origin.hostname.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+        if (isIP(host) !== 0 || !earlyPlatform() || lookupReplaced() || !v4First())
+            return { kind: "lookup" };
+        const e = earlyLookupFor(host);
+        if (e === undefined)
+            return { kind: "none" };
+        const answer = earlyFresh(e);
+        if (answer !== undefined)
+            return { kind: "answer", answer };
+        return e.state === "pending" ? { kind: "wait", early: e } : { kind: "none" };
+    }
+    catch {
+        return { kind: "none" };
+    }
+}
+function earlyForRequest(hostname, options, lookup) {
+    try {
+        if (lookup !== LOOKUP_AT_LOAD)
+            return undefined;
+        const o = options;
+        if (!(o.family === undefined || o.family === 0 || o.family === 4 || o.family === "IPv4or6"))
+            return undefined;
+        const e = earlies.get(hostname.toLowerCase());
+        return e === undefined ? undefined : earlyFresh(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+function givenUp(res) {
+    return !res.ok && res.error?.givenUp === true;
+}
+function fixedLookup(answer) {
+    return ((_hostname, options, callback) => {
+        const all = options.all === true;
+        process.nextTick(() => {
+            if (all)
+                callback(null, answer);
+            else
+                callback(null, answer[0].address, answer[0].family);
+        });
+    });
+}
+function timeoutReason() {
+    try {
+        return new DOMException("The operation was aborted due to timeout", "TimeoutError");
+    }
+    catch {
+        return Object.assign(new Error("The operation was aborted due to timeout"), { name: "TimeoutError" });
+    }
+}
+function exchange(pool, entry, target, init, deadline) {
+    return new Promise((resolve) => {
+        const remaining = deadline - performance.now();
+        if (remaining <= 0) {
+            pool.end(entry);
+            resolve({ kind: "aborted", reason: timeoutReason() });
+            return;
+        }
+        const headers = {
+            ":method": init.method,
+            ":path": target.path,
+            ":scheme": "https",
+            ":authority": target.host,
+        };
+        for (const k in init.headers) {
+            const name = k.toLowerCase();
+            if (!NOT_IN_H2.has(name))
+                headers[name] = init.headers[k];
+        }
+        headers[http2.sensitiveHeaders] = ["authorization"];
+        const body = init.body === undefined ? undefined : Buffer.from(init.body, "utf8");
+        if (body !== undefined)
+            headers["content-length"] = body.length;
+        let stream;
+        try {
+            stream = entry.session.request(headers, { endStream: body === undefined });
+        }
+        catch (error) {
+            pool.end(entry);
+            const code = errCode(error);
+            if (entry.session.closed || entry.session.destroyed || code === "ERR_HTTP2_GOAWAY_SESSION"
+                || code === "ERR_HTTP2_INVALID_SESSION" || code === "ERR_HTTP2_OUT_OF_STREAMS") {
+                pool.retire(entry);
+                if (code === "ERR_HTTP2_OUT_OF_STREAMS")
+                    safely(() => entry.session.close());
+                resolve({ kind: "failed", error, processed: "no" });
+            }
+            else {
+                resolve({ kind: "use-fetch" });
+            }
+            return;
+        }
+        const tr = init.trace;
+        if (tr !== undefined) {
+            mark(tr, "req");
+            tr.via = "h2";
+        }
+        let status = 0;
+        let resHeaders;
+        let first;
+        let chunks;
+        let settled = false;
+        let streamError;
+        const signal = init.signal;
+        const finish = (o) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (signal !== undefined)
+                signal.removeEventListener("abort", onAbort);
+            resolve(o);
+        };
+        const onTimeout = () => {
+            if (settled)
+                return;
+            safely(() => stream.close(NGHTTP2_CANCEL));
+            pool.streamFailed(entry, false);
+            pool.checkAlive(entry);
+            finish({ kind: "aborted", reason: timeoutReason() });
+        };
+        const onAbort = () => {
+            safely(() => stream.close(NGHTTP2_CANCEL));
+            finish({ kind: "aborted", reason: signal?.reason });
+        };
+        const timer = setTimeout(onTimeout, remaining);
+        timer.unref?.();
+        if (signal !== undefined) {
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
+        stream.on("response", (h) => {
+            resHeaders = h;
+            status = Number(h[":status"]);
+            if (tr !== undefined) {
+                mark(tr, "hdr");
+                tr.status = status;
+                const rx = h["x-promigence-rx-ns"], tx = h["x-promigence-tx-ns"];
+                if (typeof rx === "string")
+                    tr.rx = rx;
+                if (typeof tx === "string")
+                    tr.tx = tx;
+            }
+        });
+        stream.on("data", (c) => {
+            if (first === undefined)
+                first = c;
+            else
+                (chunks ??= [first]).push(c);
+        });
+        stream.on("error", (err) => { streamError = err; });
+        stream.on("end", () => {
+            if (tr !== undefined)
+                mark(tr, "end");
+            if (settled || status === 0)
+                return;
+            if (status === 421) {
+                pool.turnOff("421 Misdirected Request");
+                finish({ kind: "use-fetch" });
+                return;
+            }
+            try {
+                const raw = chunks !== undefined ? Buffer.concat(chunks) : (first ?? EMPTY);
+                const response = toResponse(status, resHeaders ?? {}, raw, init.method);
+                if (tr !== undefined)
+                    mark(tr, "out");
+                pool.succeeded();
+                finish({ kind: "response", response });
+            }
+            catch (error) {
+                finish({ kind: "failed", error, processed: "yes" });
+            }
+        });
+        stream.on("close", () => {
+            pool.end(entry);
+            if (settled)
+                return;
+            if (signal?.aborted) {
+                finish({ kind: "aborted", reason: signal.reason });
+                return;
+            }
+            const rst = stream.rstCode;
+            const sessionDying = entry.session.destroyed || entry.session.closed || entry.retired;
+            const error = streamError ?? Object.assign(new Error(`HTTP/2 stream closed (code ${rst ?? "?"})`), { code: "ERR_HTTP2_STREAM_ERROR" });
+            if (rst === NGHTTP2_HTTP_1_1_REQUIRED && status === 0) {
+                pool.turnOff("server asked for HTTP/1.1");
+                finish({ kind: "use-fetch" });
+                return;
+            }
+            let processed;
+            if (status !== 0)
+                processed = "yes";
+            else if (rst === NGHTTP2_REFUSED_STREAM)
+                processed = "no";
+            else if (stream.id === undefined)
+                processed = "no";
+            else if (entry.goawayLast !== undefined && stream.id > entry.goawayLast)
+                processed = "no";
+            else
+                processed = "maybe";
+            if (processed !== "no")
+                pool.streamFailed(entry, sessionDying);
+            finish({ kind: "failed", error, processed });
+        });
+        if (body !== undefined) {
+            stream.end(body);
+        }
+        if (tr !== undefined)
+            mark(tr, "sub");
+    });
+}
+const EMPTY = Buffer.alloc(0);
+function toResponse(status, raw, body, method) {
+    const nullBody = method === "HEAD" || status === 204 || status === 205 || status === 304;
+    const enc = raw["content-encoding"];
+    const bytes = nullBody ? null : decodeBody(body, typeof enc === "string" ? enc : null);
+    return new H2Response(status, raw, bytes);
+}
+function decodeBody(body, encoding) {
+    if (!encoding || body.length === 0)
+        return body;
+    const codings = encoding.toLowerCase().split(",").map((s) => s.trim()).filter((s) => s && s !== "identity");
+    let out = body;
+    for (const c of codings.reverse()) {
+        if (c === "gzip" || c === "x-gzip")
+            out = zlib.gunzipSync(out);
+        else if (c === "br")
+            out = zlib.brotliDecompressSync(out);
+        else if (c === "deflate") {
+            try {
+                out = zlib.inflateSync(out);
+            }
+            catch {
+                out = zlib.inflateRawSync(out);
+            }
+        }
+        else
+            return body;
+    }
+    return out;
+}
+const pools = new Map();
+function poolFor(origin) {
+    let p = pools.get(origin);
+    if (!p) {
+        p = new OriginPool(new URL(origin));
+        pools.set(origin, p);
+    }
+    return p;
+}
+function plainPath(url, at) {
+    if (url.charCodeAt(at) !== 0x2f)
+        return false;
+    let query = false;
+    for (let i = at + 1; i < url.length; i++) {
+        const c = url.charCodeAt(i);
+        if ((c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a) || (c >= 0x30 && c <= 0x39))
+            continue;
+        if (c === 0x2f || c === 0x2d || c === 0x5f || c === 0x7e || c === 0x3d || c === 0x26)
+            continue;
+        if (c === 0x3f && !query && i + 1 < url.length) {
+            query = true;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function targetOf(url, known, remember) {
+    if (known !== undefined && url.startsWith(known.text) && plainPath(url, known.text.length)) {
+        return { origin: known.origin, host: known.host, path: url.slice(known.text.length) };
+    }
+    const u = new URL(url);
+    if (u.protocol !== "https:")
+        return undefined;
+    const path = u.pathname + u.search;
+    const target = { origin: u.origin, host: u.host, path };
+    if (remember !== undefined && url.startsWith("https://")) {
+        let end = 8;
+        while (end < url.length) {
+            const c = url.charCodeAt(end);
+            if (c === 0x2f || c === 0x3f || c === 0x23 || c === 0x5c)
+                break;
+            end++;
+        }
+        if (end > 8 && url.charCodeAt(end) === 0x2f)
+            remember({ text: url.slice(0, end), origin: target.origin, host: target.host });
+    }
+    return target;
+}
+function fetchInit(init, deadline) {
+    const timeout = AbortSignal.timeout(Math.max(0, Math.ceil(deadline - performance.now())));
+    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 }),
+    };
+}
+function fetchFailed(cause) {
+    return new TypeError("fetch failed", { cause });
+}
+class HandBack {
+    resends;
+    replays;
+    constructor(resends, replays) {
+        this.resends = resends;
+        this.replays = replays;
+    }
+}
+const UNSENT = new HandBack(0, 0);
+const VIA_FETCH = Symbol("via-fetch");
+const THREAD_GRACE_MS = 1_000;
+const THREAD_PHASES = ["w.got", "w.sent", "w.head", "w.end"];
+class TransportThread {
+    origin;
+    worker;
+    port;
+    state = "starting";
+    sessions = 0;
+    limit = DEFAULT_STREAM_LIMIT;
+    everReady = false;
+    closedReason = "";
+    onFail;
+    inflight = new Map();
+    nextId = 1;
+    listening = false;
+    answered = 0;
+    pace = THREAD_DEFAULTS.pace;
+    hrOffset = Number(process.hrtime.bigint()) / 1e6 - performance.now();
+    constructor(origin, worker, port) {
+        this.origin = origin;
+        this.worker = worker;
+        this.port = port;
+    }
+    poll() {
+        for (;;) {
+            let got;
+            try {
+                got = receiveMessageOnPort(this.port);
+            }
+            catch {
+                got = undefined;
+            }
+            if (got === undefined)
+                break;
+            this.onMessage(got.message);
+        }
+    }
+    ready() {
+        if (this.state !== "closed")
+            this.poll();
+        return this.state === "ready" && this.sessions > 0 && this.inflight.size < this.sessions * this.limit;
+    }
+    onMessage(m) {
+        const msg = m;
+        switch (msg?.t) {
+            case "ready":
+                if (this.state === "starting" || this.state === "ready") {
+                    const first = !this.everReady;
+                    this.state = "ready";
+                    this.everReady = true;
+                    this.sessions = msg.sessions ?? 1;
+                    if (typeof msg.limit === "number" && msg.limit > 0)
+                        this.limit = first ? msg.limit : Math.min(this.limit, msg.limit);
+                    const hr = msg.hr;
+                    if (typeof hr === "number") {
+                        const t = hr - this.hrOffset;
+                        traceEventAt(`thread:session${this.sessions}`, t);
+                        if (first)
+                            traceEventAt(`thread:limit${this.limit}`, t);
+                        const c = msg;
+                        if (typeof c.index === "number" && typeof c.addr === "string" && typeof c.localPort === "number")
+                            traceEventAt(`thread:conn${c.index} ${c.addr} ${c.localPort}`, t);
+                    }
+                }
+                return;
+            case "sessions":
+                if (typeof msg.sessions === "number")
+                    this.sessions = msg.sessions;
+                return;
+            case "draining":
+                if (this.state !== "closed" && this.state !== "draining") {
+                    this.state = "draining";
+                    if (this.closedReason === "")
+                        this.closedReason = msg.reason ?? "draining";
+                    traceEvent("thread:draining");
+                }
+                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);
+                return;
+        }
+    }
+    settle(m) {
+        const id = m["id"];
+        const p = this.inflight.get(id);
+        if (p === undefined)
+            return;
+        this.inflight.delete(id);
+        this.release(p);
+        if (m["t"] === "res") {
+            this.answered++;
+            const body = Buffer.from(m["body"]);
+            let res;
+            try {
+                res = toResponse(m["status"], (m["headers"] ?? {}), body, p.method);
+            }
+            catch (error) {
+                p.reject(fetchFailed(error));
+                return;
+            }
+            if (m["replayed"] === true)
+                res.replayed = true;
+            const tr = p.trace;
+            if (tr !== undefined) {
+                tr.status = res.status;
+                const h = (m["headers"] ?? {});
+                const rx = h["x-promigence-rx-ns"], tx = h["x-promigence-tx-ns"];
+                if (typeof rx === "string")
+                    tr.rx = rx;
+                if (typeof tx === "string")
+                    tr.tx = tx;
+                if (typeof m["conn"] === "number")
+                    tr.conn = m["conn"];
+                const w = m["w"];
+                if (Array.isArray(w)) {
+                    for (let i = 0; i < THREAD_PHASES.length; i++)
+                        if (typeof w[i] === "number" && w[i] > 0)
+                            tr.t[THREAD_PHASES[i]] = w[i] - this.hrOffset;
+                }
+            }
+            p.resolve(res);
+            return;
+        }
+        if (m["kind"] === "timeout") {
+            this.stopUsing("a request timed out");
+            p.reject(timeoutReason());
+            return;
+        }
+        if (m["kind"] === "back") {
+            this.stopUsing("no session");
+            p.resolve(new HandBack(Number(m["resends"]) || 0, Number(m["replays"]) || 0));
+            return;
+        }
+        if (m["processed"] === "no") {
+            this.stopUsing("requests refused");
+            p.resolve(VIA_FETCH);
+            return;
+        }
+        this.stopUsing("a request failed");
+        p.reject(fetchFailed(Object.assign(new Error(String(m["message"] ?? "HTTP/2 stream error")), { code: m["code"] })));
+    }
+    stopUsing(reason) {
+        if (this.state !== "starting" && this.state !== "ready")
+            return;
+        this.state = "draining";
+        this.closedReason = reason;
+        traceEvent("thread:draining");
+        try {
+            this.port.postMessage({ t: "drain" });
+        }
+        catch { }
+    }
+    close(reason) {
+        if (this.state === "closed")
+            return;
+        this.state = "closed";
+        if (this.closedReason === "")
+            this.closedReason = reason;
+        traceEvent("thread:closed");
+        for (const [id, p] of [...this.inflight]) {
+            this.inflight.delete(id);
+            this.release(p);
+            if (!p.acked)
+                p.resolve(UNSENT);
+            else if (p.replayable)
+                p.resolve(new HandBack(0, 1));
+            else
+                p.reject(fetchFailed(Object.assign(new Error(`the transport thread ended: ${reason}`), { code: "ERR_HTTP2_SESSION_ERROR" })));
+        }
+        safely(() => { this.port.close(); });
+        this.unref();
+        if (!this.everReady) {
+            const f = this.onFail;
+            this.onFail = undefined;
+            if (f !== undefined)
+                safely(f);
+        }
+    }
+    ref() {
+        if (!this.listening) {
+            this.listening = true;
+            this.poll();
+            this.port.on("message", (m) => { this.onMessage(m); });
+        }
+        safely(() => { this.port.ref(); });
+        safely(() => { this.worker.ref(); });
+    }
+    unref() {
+        safely(() => { this.port.unref(); });
+        safely(() => { this.worker.unref(); });
+    }
+    release(p) {
+        if (p.signal !== undefined && p.onAbort !== undefined)
+            p.signal.removeEventListener("abort", p.onAbort);
+        if (p.backstop !== undefined)
+            clearTimeout(p.backstop);
+        if (this.inflight.size === 0)
+            this.unref();
+    }
+    send(target, init, replayable, deadline) {
+        const remaining = Math.ceil(deadline - performance.now());
+        if (remaining <= 0)
+            return Promise.reject(timeoutReason());
+        if (init.signal?.aborted)
+            return Promise.reject(init.signal.reason);
+        const headers = {
+            ":method": init.method,
+            ":path": target.path,
+            ":scheme": "https",
+            ":authority": target.host,
+        };
+        for (const k in init.headers) {
+            const name = k.toLowerCase();
+            if (!NOT_IN_H2.has(name))
+                headers[name] = init.headers[k];
+        }
+        if (init.body !== undefined)
+            headers["content-length"] = Buffer.byteLength(init.body, "utf8");
+        const id = this.nextId++;
+        const tr = init.trace;
+        return new Promise((resolve, reject) => {
+            const p = { resolve, reject, method: init.method, replayable, acked: false, trace: tr };
+            const signal = init.signal;
+            if (signal !== undefined) {
+                p.signal = signal;
+                p.onAbort = () => {
+                    if (!this.inflight.has(id))
+                        return;
+                    this.inflight.delete(id);
+                    this.release(p);
+                    try {
+                        this.port.postMessage({ t: "cancel", id });
+                    }
+                    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 });
+            }
+            catch {
+                this.inflight.delete(id);
+                this.release(p);
+                resolve(UNSENT);
+                return;
+            }
+            if (tr !== undefined) {
+                mark(tr, "sub");
+                tr.via = "thread";
+            }
+        });
+    }
+}
+let transportThread;
+function threadFor(origin) {
+    const t = transportThread;
+    if (t === undefined || t.origin !== origin)
+        return undefined;
+    return t.ready() && !lookupReplaced() ? t : undefined;
+}
+function ownFile() {
+    const frame = (new Error().stack ?? "").split("\n")[1] ?? "";
+    const m = /\((.*):\d+:\d+\)\s*$/.exec(frame) ?? /at (.*):\d+:\d+\s*$/.exec(frame);
+    return m?.[1] ?? "";
+}
+const THREAD_DEFAULTS = { sessions: 8, gapUs: 2000, pace: "all" };
+const THREAD_MAX_SESSIONS = 32;
+const THREAD_MAX_GAP_US = 10_000;
+const CREATE_PATH = /\/(?:runs|sandboxes)(?:\?|$)/;
+function threadKnobs(env = process.env) {
+    const read = (name, dflt, off, min, max) => {
+        const raw = (env[name] ?? "").trim().toLowerCase();
+        if (raw === "")
+            return dflt;
+        if (OFF.has(raw))
+            return off;
+        const n = Number(raw);
+        return Number.isInteger(n) && n >= min ? Math.min(max, n) : dflt;
+    };
+    const p = (env["PROMIGENCE_HTTP2_PACE"] ?? "").trim().toLowerCase();
+    return {
+        sessions: read("PROMIGENCE_HTTP2_SESSIONS", THREAD_DEFAULTS.sessions, 1, 1, THREAD_MAX_SESSIONS),
+        gapUs: read("PROMIGENCE_HTTP2_STREAM_GAP_US", THREAD_DEFAULTS.gapUs, 0, 0, THREAD_MAX_GAP_US),
+        pace: p === "all" || p === "creates" ? p : OFF.has(p) ? "off" : THREAD_DEFAULTS.pace,
+    };
+}
+function startTransportThread(origin, onFail) {
+    if (transportThread !== undefined)
+        return;
+    try {
+        const here = ownFile();
+        if (!/http2\.js$/.test(here))
+            return;
+        const seam = earlySeam();
+        const knobs = threadKnobs();
+        const file = typeof seam.transportFile === "string" ? seam.transportFile : here.replace(/http2\.js$/, "transport-worker.js");
+        const { port1, port2 } = new MessageChannel();
+        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,
+                firstUseMs: tuning.loadFirstUseMs, idleMs: IDLE_CLOSE_MS, connectTimeoutMs: CONNECT_TIMEOUT_MS,
+                lookupTimeoutMs: EARLY_TIMEOUT_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(),
+            },
+            transferList: [port2],
+            argv: [],
+            execArgv: [],
+        });
+        worker.unref();
+        port1.unref();
+        const t = new TransportThread(origin.origin, worker, port1);
+        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");
+    }
+    catch {
+        transportThread = undefined;
+    }
+}
+const prefixes = [];
+const MAX_PREFIXES = 4;
+function knownPrefix(url) {
+    for (let i = 0; i < prefixes.length; i++) {
+        const p = prefixes[i];
+        if (url.startsWith(p.text) && url.charCodeAt(p.text.length) === 0x2f)
+            return p;
+    }
+    return undefined;
+}
+function remember(p) {
+    for (let i = 0; i < prefixes.length; i++)
+        if (prefixes[i].text === p.text)
+            return;
+    prefixes.unshift(p);
+    if (prefixes.length > MAX_PREFIXES)
+        prefixes.pop();
+}
+export class Http2Transport {
+    fallback;
+    constructor(fallback) {
+        this.fallback = fallback;
+    }
+    preconnect(url) {
+        try {
+            const u = new URL(url);
+            if (u.protocol !== "https:" || customDispatcher())
+                return;
+            poolFor(u.origin).warm();
+        }
+        catch {
+        }
+    }
+    viaFetch(url, init, deadline) {
+        if (init.trace !== undefined)
+            init.trace.via = "fetch";
+        return this.fallback(url, fetchInit(init, deadline));
+    }
+    async fetch(url, init, replayable) {
+        const tr = init.trace;
+        if (tr !== undefined)
+            mark(tr, "h2");
+        const deadline = performance.now() + init.timeoutMs;
+        let target;
+        try {
+            target = targetOf(url, knownPrefix(url), remember);
+        }
+        catch {
+            return this.viaFetch(url, init, deadline);
+        }
+        if (target === undefined || customDispatcher())
+            return this.viaFetch(url, init, deadline);
+        let resends = 0;
+        let replays = 0;
+        const thread = threadFor(target.origin);
+        if (thread !== undefined) {
+            const out = await 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;
+        }
+        const pool = poolFor(target.origin);
+        if (!pool.usable())
+            return this.viaFetch(url, init, deadline);
+        for (;;) {
+            const entry = pool.tryAcquire() ?? await pool.acquire(deadline, init.signal);
+            if (tr !== undefined)
+                mark(tr, "acq");
+            if (entry === null)
+                return this.viaFetch(url, init, deadline);
+            let out;
+            try {
+                out = await exchange(pool, entry, target, init, deadline);
+            }
+            catch {
+                pool.turnOff("internal error");
+                out = { kind: "failed", error: new Error("HTTP/2 transport error"), processed: "maybe" };
+            }
+            switch (out.kind) {
+                case "response":
+                    if (replays > 0)
+                        out.response.replayed = true;
+                    return out.response;
+                case "aborted":
+                    throw out.reason;
+                case "use-fetch":
+                    return this.viaFetch(url, init, deadline);
+                case "failed":
+                    if (out.processed === "no") {
+                        if (++resends <= MAX_UNPROCESSED_RESENDS)
+                            continue;
+                        return this.viaFetch(url, init, deadline);
+                    }
+                    if (out.processed === "maybe" && replayable && replays++ < MAX_REPLAYS)
+                        continue;
+                    throw fetchFailed(out.error);
+            }
+        }
+    }
+}
+export function warmTransport() {
+    const res = toResponse(200, { "content-type": "application/json" }, Buffer.from("{}"), "POST");
+    res.header("server-timing");
+    res.textNow();
+    plainPath("https://a/b?c=d", 9);
+    targetOf("https://a/b?c=d", undefined);
+    const p = new Http2Transport(globalThis.fetch).fetch(undefined, undefined, false);
+    p.catch(() => { });
+    const none = "";
+    exchange({ end() { } }, undefined, { origin: none, host: none, path: none }, undefined, 0).catch(() => { });
+}
+export const __http2Internals = {
+    pools() {
+        return [...pools.values()].map((p) => ({
+            origin: p.origin.origin,
+            sessions: p.sessions.length,
+            opened: p.opened,
+            warmed: p.warmed,
+            connecting: p.isConnecting(),
+            parked: p.isParked(),
+            off: p.off,
+            suspended: !p.off && !p.usable(),
+            offReason: p.offReason,
+            active: p.sessions.reduce((a, e) => a + e.active, 0),
+            split: p.sessions.map((e) => e.active),
+        }));
+    },
+    targetOf(url, known) {
+        let prefix;
+        const target = targetOf(url, known, (p) => { prefix = p; });
+        return { target, prefix };
+    },
+    prefixes() {
+        return prefixes.map((p) => p.text);
+    },
+    reset() {
+        for (const p of pools.values()) {
+            for (const e of [...p.sessions]) {
+                p.retire(e);
+                safely(() => e.session.destroy());
+            }
+        }
+        pools.clear();
+    },
+    pool(origin) {
+        return new OriginPool(new URL(origin));
+    },
+    thread() {
+        const t = transportThread;
+        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 };
+    },
+    threadKnobs(env) {
+        return threadKnobs(env);
+    },
+    crashThreadForTest() {
+        try {
+            transportThread?.port.postMessage({ t: "crash-for-test" });
+        }
+        catch { }
+    },
+    early: {
+        start(host) {
+            return earlyLookupFor(host.toLowerCase()) !== undefined;
+        },
+        state(host) {
+            const e = earlies.get(host.toLowerCase());
+            if (e === undefined)
+                return undefined;
+            const fresh = earlyFresh(e);
+            return { state: e.state, ...(e.answer === undefined ? {} : { answer: e.answer }), fresh: fresh !== undefined };
+        },
+        hosts() {
+            return [...earlies.keys()];
+        },
+        reset() {
+            for (const e of earlies.values())
+                safely(() => { e.port.close(); });
+            earlies.clear();
+        },
+    },
+};
+const AT_LOAD = Symbol.for("promigence.sdk.connect-at-load");
+function isMainThread() {
+    try {
+        const get = process.getBuiltinModule;
+        const wt = typeof get === "function" ? get("node:worker_threads") : undefined;
+        return wt?.isMainThread === true;
+    }
+    catch {
+        return false;
+    }
+}
+function connectAtLoad() {
+    try {
+        if (!isNode() || Number(process.versions.node.split(".")[0]) < 22)
+            return;
+        const off = () => OFF.has((process.env["PROMIGENCE_PRECONNECT"] ?? "").trim().toLowerCase());
+        if (off())
+            return;
+        const g = globalThis;
+        if (g[AT_LOAD] !== undefined)
+            return;
+        g[AT_LOAD] = true;
+        try {
+            if ((process.env["PROMIGENCE_API_KEY"] ?? "").trim() !== "" && isMainThread() && http2Allowed(undefined, process.env)) {
+                const raw = process.env["PROMIGENCE_API_URL"];
+                const url = new URL(raw ? raw : DEFAULT_API_URL);
+                const host = url.hostname.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+                const threadOff = OFF.has((process.env["PROMIGENCE_TRANSPORT_THREAD"] ?? "").trim().toLowerCase());
+                if (url.protocol === "https:" && !customDispatcher() && earlyPlatform() && v4First() && !threadOff && earlySeam().transportThread !== false) {
+                    startTransportThread(url, () => { if (loadTurnRan)
+                        warmAtLoad(); });
+                }
+                else if (url.protocol === "https:" && !customDispatcher() && isIP(host) === 0 && earlyPlatform() && v4First())
+                    earlyLookupFor(host);
+            }
+        }
+        catch {
+        }
+        let loadTurnRan = false;
+        const warmAtLoad = () => {
+            try {
+                if (off() || (process.env["PROMIGENCE_API_KEY"] ?? "").trim() === "")
+                    return;
+                if (!isMainThread() || !http2Allowed(undefined, process.env))
+                    return;
+                const raw = process.env["PROMIGENCE_API_URL"];
+                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)
+                        return;
+                }
+                warmTls();
+                poolFor(url.origin).warm(tuning.loadFirstUseMs);
+            }
+            catch {
+            }
+        };
+        const immediate = setImmediate(() => { loadTurnRan = true; warmAtLoad(); });
+        immediate.unref?.();
+    }
+    catch {
+    }
+}
+connectAtLoad();