@blaxel/core 0.3.6 → 0.3.7-preview.229

package/dist/cjs-browser/common/h2-runtime.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * HTTP/2 runtime-capability detection.
+ *
+ * The SDK's pooled HTTP/2 transport relies on the runtime's HTTP/2 client
+ * managing connection-level flow control correctly. One runtime does not:
+ *
+ *   Bun < 1.3.11 never sends a connection-level WINDOW_UPDATE frame. The pooled
+ *   H2 session therefore freezes after exactly 65535 cumulative body bytes (the
+ *   default connection receive window that Bun never grows), and every request
+ *   on that session hangs until the edge resets the streams (~330s).
+ *   Fixed in Bun 1.3.11: https://bun.com/blog/bun-v1.3.11
+ *
+ * This module centralizes the version gate so the settings layer, the unit
+ * tests, and the cross-runtime environment tests all agree on ONE definition of
+ * "is this a Bun that breaks pooled H2". Keeping a single source of truth is the
+ * whole point: the bug this guards against is subtle and the parse is easy to
+ * get subtly wrong (see `stripPrerelease`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.H2_DEFAULT_CONNECTION_WINDOW_BYTES = exports.BUN_H2_FIXED_VERSION = void 0;
+exports.parseSemver = parseSemver;
+exports.isBrokenBunVersion = isBrokenBunVersion;
+exports.detectBunVersion = detectBunVersion;
+exports.isBrokenBunH2Runtime = isBrokenBunH2Runtime;
+/** First Bun release with a working connection-level WINDOW_UPDATE. */
+exports.BUN_H2_FIXED_VERSION = "1.3.11";
+/**
+ * The default HTTP/2 connection-level receive window, in bytes (2^16 - 1). This
+ * is the exact number of cumulative body bytes after which a broken-Bun pooled
+ * session freezes: the window opens to 65535 and, absent a WINDOW_UPDATE, never
+ * reopens. Node grows it (see `establishH2`'s `setLocalWindowSize`); Bun < 1.3.11
+ * does not.
+ */
+exports.H2_DEFAULT_CONNECTION_WINDOW_BYTES = 65535;
+/**
+ * Parse a `major.minor.patch` version, tolerating a pre-release/build suffix
+ * (e.g. `1.3.11-canary.1`, `1.4.0+build`). Returns `null` when the input is
+ * absent or not a recognizable semver triple.
+ */
+function parseSemver(version) {
+    if (!version)
+        return null;
+    // Strip any pre-release ("-canary.1") or build ("+abc") metadata first so a
+    // tagged build compares by its release numbers, then take the leading triple.
+    const core = version.split("-")[0].split("+")[0].trim();
+    const parts = core.split(".");
+    if (parts.length === 0)
+        return null;
+    const nums = parts.slice(0, 3).map((p) => Number(p));
+    if (nums.some((n) => !Number.isInteger(n) || n < 0))
+        return null;
+    const [maj = 0, min = 0, patch = 0] = nums;
+    return [maj, min, patch];
+}
+/**
+ * Given a Bun version string, is this a Bun whose HTTP/2 client breaks the
+ * pooled transport (Bun < 1.3.11)? A falsy/undefined version means "not Bun",
+ * which returns `false`. An unparseable version is treated as broken (`true`):
+ * we cannot prove it is safe, and forcing H2 off is the safe default.
+ */
+function isBrokenBunVersion(version) {
+    if (!version)
+        return false;
+    const parsed = parseSemver(version);
+    if (parsed === null)
+        return true;
+    const [maj, min, patch] = parsed;
+    return maj < 1 || (maj === 1 && (min < 3 || (min === 3 && patch < 11)));
+}
+/**
+ * The running runtime's Bun version, or `undefined` when not on Bun (Node,
+ * Deno, browsers, workers). Deno also exposes `process.versions` but never sets
+ * `.bun`, so this stays `undefined` there.
+ */
+function detectBunVersion() {
+    return globalThis.process?.versions?.bun;
+}
+/**
+ * Is the CURRENT runtime a Bun that breaks the pooled H2 transport? This is the
+ * predicate the settings layer uses to force H2 off.
+ */
+function isBrokenBunH2Runtime() {
+    return isBrokenBunVersion(detectBunVersion());
+}

package/dist/cjs-browser/common/h2-runtime.test.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const env_js_1 = require("./env.js");
+const h2_runtime_js_1 = require("./h2-runtime.js");
+// The Bun H2 flow-control bug (never sends connection-level WINDOW_UPDATE, so a
+// pooled session freezes after 65535 cumulative body bytes) was fixed in
+// 1.3.11. Everything below < 1.3.11 must be classified "broken"; >= 1.3.11 must
+// be "fixed". A non-Bun runtime (no version) is never broken. This is the
+// single most important gate in the SDK's H2 story, so we pin it exhaustively.
+(0, vitest_1.describe)("parseSemver", () => {
+    (0, vitest_1.it)("parses a plain major.minor.patch triple", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.3.11")).toEqual([1, 3, 11]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("0.0.0")).toEqual([0, 0, 0]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("22.14.0")).toEqual([22, 14, 0]);
+    });
+    (0, vitest_1.it)("tolerates missing minor/patch", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("2")).toEqual([2, 0, 0]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.4")).toEqual([1, 4, 0]);
+    });
+    (0, vitest_1.it)("strips pre-release and build metadata before comparing", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.3.11-canary.1")).toEqual([1, 3, 11]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.3.10-debug")).toEqual([1, 3, 10]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.4.0+build.7")).toEqual([1, 4, 0]);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("2.0.0-alpha+exp.sha.5114f85")).toEqual([2, 0, 0]);
+    });
+    (0, vitest_1.it)("returns null for absent or non-numeric input", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)(undefined)).toBeNull();
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)(null)).toBeNull();
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("")).toBeNull();
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("latest")).toBeNull();
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("v1.2.3")).toBeNull();
+        (0, vitest_1.expect)((0, h2_runtime_js_1.parseSemver)("1.x.0")).toBeNull();
+    });
+});
+(0, vitest_1.describe)("isBrokenBunVersion", () => {
+    (0, vitest_1.it)("treats a missing version as not-Bun (never broken)", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(undefined)).toBe(false);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(null)).toBe(false);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)("")).toBe(false);
+    });
+    // The full boundary matrix. Left column = Bun version string, right = whether
+    // the pooled H2 transport is broken on it.
+    const matrix = [
+        // Ancient / pre-1.0 — all broken.
+        ["0.1.0", true],
+        ["0.8.1", true],
+        ["0.9.9", true],
+        // 1.0.x – 1.2.x — broken.
+        ["1.0.0", true],
+        ["1.1.34", true],
+        ["1.2.0", true],
+        ["1.2.21", true],
+        // 1.3.0 – 1.3.10 — the affected line, still broken.
+        ["1.3.0", true],
+        ["1.3.1", true],
+        ["1.3.9", true],
+        ["1.3.10", true],
+        // 1.3.11 — the exact fix boundary. Fixed.
+        ["1.3.11", false],
+        // Everything after — fixed.
+        ["1.3.12", false],
+        ["1.3.100", false],
+        ["1.4.0", false],
+        ["1.10.0", false],
+        ["2.0.0", false],
+        ["10.0.0", false],
+    ];
+    vitest_1.it.each(matrix)("Bun %s -> broken=%s", (version, expected) => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(version)).toBe(expected);
+    });
+    // Pre-release / canary builds must compare by their release numbers so a
+    // "1.3.11-canary" is treated as fixed and a "1.3.10-debug" as broken. This is
+    // the exact parse subtlety the earlier duplicated gate got wrong.
+    const prereleaseMatrix = [
+        ["1.3.10-canary.20250101", true],
+        ["1.3.11-canary.20250101", false],
+        ["1.3.11-debug", false],
+        ["1.4.0-canary", false],
+        ["1.2.99-alpha", true],
+    ];
+    vitest_1.it.each(prereleaseMatrix)("Bun %s (pre-release) -> broken=%s", (version, expected) => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(version)).toBe(expected);
+    });
+    (0, vitest_1.it)("classifies an unparseable Bun version as broken (safe default)", () => {
+        // A non-empty but unrecognizable version means we cannot prove it is safe,
+        // so we err toward disabling H2.
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)("weird-build")).toBe(true);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)("nightly")).toBe(true);
+    });
+    (0, vitest_1.it)("agrees with the documented fix boundary constant", () => {
+        const [maj, min, patch] = (0, h2_runtime_js_1.parseSemver)(h2_runtime_js_1.BUN_H2_FIXED_VERSION);
+        // One patch below the fix is broken; the fix itself is not.
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(`${maj}.${min}.${patch - 1}`)).toBe(true);
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunVersion)(`${maj}.${min}.${patch}`)).toBe(false);
+    });
+});
+(0, vitest_1.describe)("detectBunVersion / isBrokenBunH2Runtime (current runtime)", () => {
+    (0, vitest_1.it)("reports the running Bun version, or undefined off Bun", () => {
+        const detected = (0, h2_runtime_js_1.detectBunVersion)();
+        const actual = globalThis.process?.versions?.bun;
+        (0, vitest_1.expect)(detected).toBe(actual);
+    });
+    (0, vitest_1.it)("runtime predicate matches the version predicate for this runtime", () => {
+        (0, vitest_1.expect)((0, h2_runtime_js_1.isBrokenBunH2Runtime)()).toBe((0, h2_runtime_js_1.isBrokenBunVersion)((0, h2_runtime_js_1.detectBunVersion)()));
+    });
+});
+(0, vitest_1.describe)("H2_DEFAULT_CONNECTION_WINDOW_BYTES", () => {
+    (0, vitest_1.it)("is 2^16 - 1 (the window a broken Bun never grows)", () => {
+        (0, vitest_1.expect)(h2_runtime_js_1.H2_DEFAULT_CONNECTION_WINDOW_BYTES).toBe(65535);
+        (0, vitest_1.expect)(h2_runtime_js_1.H2_DEFAULT_CONNECTION_WINDOW_BYTES).toBe(2 ** 16 - 1);
+    });
+});
+// End-to-end: the settings.disableH2 getter must honor the runtime gate. We
+// simulate different Bun versions by injecting process.versions.bun, since the
+// getter reads it live on every access.
+(0, vitest_1.describe)("settings.disableH2 honors the Bun version gate", () => {
+    const originalBun = globalThis.process?.versions?.bun;
+    (0, vitest_1.afterEach)(async () => {
+        if (globalThis.process?.versions) {
+            if (originalBun === undefined) {
+                delete globalThis.process.versions.bun;
+            }
+            else {
+                globalThis.process.versions.bun = originalBun;
+            }
+        }
+        delete env_js_1.env.BL_DISABLE_H2;
+        const { settings } = await Promise.resolve().then(() => __importStar(require("./settings.js")));
+        delete settings.config.disableH2;
+    });
+    function setBunVersion(version) {
+        if (!globalThis.process?.versions)
+            return false;
+        if (version === undefined) {
+            delete globalThis.process.versions.bun;
+        }
+        else {
+            globalThis.process.versions.bun = version;
+        }
+        return true;
+    }
+    (0, vitest_1.it)("forces H2 OFF on a broken Bun regardless of config/env", async () => {
+        if (!setBunVersion("1.3.10"))
+            return;
+        delete env_js_1.env.BL_DISABLE_H2;
+        const { settings } = await Promise.resolve().then(() => __importStar(require("./settings.js")));
+        // Even explicitly asking for H2 on cannot override the safety gate.
+        settings.config.disableH2 = false;
+        (0, vitest_1.expect)(settings.disableH2).toBe(true);
+    });
+    (0, vitest_1.it)("leaves H2 ON (default) on a fixed Bun", async () => {
+        if (!setBunVersion("1.3.11"))
+            return;
+        delete env_js_1.env.BL_DISABLE_H2;
+        const { settings } = await Promise.resolve().then(() => __importStar(require("./settings.js")));
+        delete settings.config.disableH2;
+        (0, vitest_1.expect)(settings.disableH2).toBe(false);
+    });
+    (0, vitest_1.it)("still respects an explicit opt-out on a fixed Bun", async () => {
+        if (!setBunVersion("1.4.0"))
+            return;
+        const { settings } = await Promise.resolve().then(() => __importStar(require("./settings.js")));
+        settings.config.disableH2 = true;
+        (0, vitest_1.expect)(settings.disableH2).toBe(true);
+    });
+});

package/dist/cjs-browser/common/settings.js

@@ -11,6 +11,7 @@ const credentials_js_1 = require("../authentication/credentials.js");
 const index_js_1 = require("../authentication/index.js");
 const env_js_1 = require("../common/env.js");
 const errors_js_1 = require("../common/errors.js");
+const h2_runtime_js_1 = require("../common/h2-runtime.js");
 const logger_js_1 = require("../common/logger.js");
 const node_js_1 = require("../common/node.js");
 /**
@@ -29,21 +30,17 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.3.6";
-const BUILD_COMMIT = "3189881cfb78a38e368844ba3fc867f83933cade";
+const BUILD_VERSION = "0.3.7-preview.229";
+const BUILD_COMMIT = "23d40862a7ff5f350d98700c4c2e47adb91eddc5";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2
 // session freezes after exactly 65535 cumulative body bytes and every request
 // on it hangs until the edge resets the streams (~330s).
 // Fixed in Bun 1.3.11: https://bun.com/blog/bun-v1.3.11
-function isBrokenBunH2() {
-    const v = globalThis.process?.versions?.bun;
-    if (!v)
-        return false;
-    const [maj = 0, min = 0, patch = 0] = v.split("-")[0].split(".").map(Number);
-    return maj < 1 || (maj === 1 && (min < 3 || (min === 3 && patch < 11)));
-}
+// The version gate lives in ./h2-runtime.ts so settings, unit tests, and the
+// cross-runtime environment tests share ONE definition.
+const isBrokenBunH2 = h2_runtime_js_1.isBrokenBunH2Runtime;
 // Warn at most once when H2 is force-disabled on a broken Bun runtime.
 let brokenBunH2Warned = false;
 // Cache for config.yaml tracking value

package/dist/cjs-browser/common/settings.test.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const apikey_js_1 = require("../authentication/apikey.js");
 const env_js_1 = require("./env.js");
+const h2_runtime_js_1 = require("./h2-runtime.js");
 (0, vitest_1.describe)('Settings.apiVersion', () => {
     (0, vitest_1.beforeEach)(() => {
         // Reset the module-level settings singleton between tests if needed
@@ -68,13 +69,10 @@ const env_js_1 = require("./env.js");
         const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
         delete settings.config.disableH2;
     });
-    const onBrokenBun = (() => {
-        const v = globalThis.process?.versions?.bun;
-        if (!v)
-            return false;
-        const [maj = 0, min = 0, patch = 0] = v.split('.').map(Number);
-        return maj < 1 || (maj === 1 && (min < 3 || (min === 3 && patch < 11)));
-    })();
+    // On a broken-Bun runtime the getter force-returns true regardless of
+    // config/env, so the "H2 on by default" expectations below do not hold there.
+    // Use the SAME predicate the getter uses so the skip and the behavior agree.
+    const onBrokenBun = (0, h2_runtime_js_1.isBrokenBunH2Runtime)();
     vitest_1.it.skipIf(onBrokenBun)('enables H2 by default', async () => {
         delete env_js_1.env.BL_DISABLE_H2;
         const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
@@ -87,3 +85,169 @@ const env_js_1 = require("./env.js");
         (0, vitest_1.expect)(settings.disableH2).toBe(true);
     });
 });
+// The H2 tuning knobs all share the same resolution order: an explicit
+// `settings.config` value wins, then the env var (`env` reads through to
+// process.env), then a hard-coded default. Numeric knobs also reject
+// unparseable/out-of-range env strings and fall back to the default. These are
+// the values that flow into establishH2 (window sizes) and the per-domain
+// concurrency gates, so an off-by-one here silently changes transport behavior.
+(0, vitest_1.describe)('Settings H2 tuning knobs (config > env > default)', () => {
+    // Snapshot every H2 env var so a test that sets one cannot leak into another.
+    const H2_ENV_VARS = [
+        'BL_DISABLE_CONTROL_PLANE_H2',
+        'BL_FORCE_CONTROL_PLANE_H2',
+        'BL_MAX_H2_INFLIGHT',
+        'BL_MAX_UPLOAD_H2_INFLIGHT',
+        'BL_H2_STREAM_WINDOW',
+        'BL_H2_CONNECTION_WINDOW',
+    ];
+    const originalEnv = {};
+    (0, vitest_1.beforeEach)(() => {
+        for (const key of H2_ENV_VARS) {
+            originalEnv[key] = process.env[key];
+            delete process.env[key];
+        }
+    });
+    (0, vitest_1.afterEach)(async () => {
+        for (const key of H2_ENV_VARS) {
+            if (originalEnv[key] === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = originalEnv[key];
+        }
+        const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+        delete settings.config.disableControlPlaneH2;
+        delete settings.config.forceControlPlaneH2;
+        delete settings.config.maxConcurrentH2Requests;
+        delete settings.config.maxConcurrentUploadH2Requests;
+        delete settings.config.h2StreamWindowSize;
+        delete settings.config.h2ConnectionWindowSize;
+    });
+    (0, vitest_1.describe)('disableControlPlaneH2', () => {
+        (0, vitest_1.it)('defaults to false', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.disableControlPlaneH2).toBe(false);
+        });
+        vitest_1.it.each(['1', 'true', 'yes', 'on', 'TRUE', 'On'])('treats env %s as true', async (value) => {
+            process.env.BL_DISABLE_CONTROL_PLANE_H2 = value;
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.disableControlPlaneH2).toBe(true);
+        });
+        vitest_1.it.each(['0', 'false', 'no', 'off', ''])('treats env %s as false', async (value) => {
+            process.env.BL_DISABLE_CONTROL_PLANE_H2 = value;
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.disableControlPlaneH2).toBe(false);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_DISABLE_CONTROL_PLANE_H2 = '1';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.disableControlPlaneH2 = false;
+            (0, vitest_1.expect)(settings.disableControlPlaneH2).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('forceControlPlaneH2', () => {
+        (0, vitest_1.it)('defaults to false', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.forceControlPlaneH2).toBe(false);
+        });
+        (0, vitest_1.it)('reads a truthy env var', async () => {
+            process.env.BL_FORCE_CONTROL_PLANE_H2 = 'yes';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.forceControlPlaneH2).toBe(true);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_FORCE_CONTROL_PLANE_H2 = '1';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.forceControlPlaneH2 = false;
+            (0, vitest_1.expect)(settings.forceControlPlaneH2).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('maxConcurrentH2Requests', () => {
+        (0, vitest_1.it)('defaults to 0 (unlimited)', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentH2Requests).toBe(0);
+        });
+        (0, vitest_1.it)('parses the env var', async () => {
+            process.env.BL_MAX_H2_INFLIGHT = '8';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentH2Requests).toBe(8);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_MAX_H2_INFLIGHT = '8';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.maxConcurrentH2Requests = 3;
+            (0, vitest_1.expect)(settings.maxConcurrentH2Requests).toBe(3);
+        });
+        (0, vitest_1.it)('falls back to the default on an unparseable env var', async () => {
+            process.env.BL_MAX_H2_INFLIGHT = 'not-a-number';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentH2Requests).toBe(0);
+        });
+    });
+    (0, vitest_1.describe)('maxConcurrentUploadH2Requests', () => {
+        (0, vitest_1.it)('defaults to 2 (the measured rapid-reset-safe cap)', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentUploadH2Requests).toBe(2);
+        });
+        (0, vitest_1.it)('parses the env var, including 0 to disable the cap', async () => {
+            process.env.BL_MAX_UPLOAD_H2_INFLIGHT = '0';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentUploadH2Requests).toBe(0);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_MAX_UPLOAD_H2_INFLIGHT = '5';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.maxConcurrentUploadH2Requests = 4;
+            (0, vitest_1.expect)(settings.maxConcurrentUploadH2Requests).toBe(4);
+        });
+        (0, vitest_1.it)('falls back to the default on an unparseable env var', async () => {
+            process.env.BL_MAX_UPLOAD_H2_INFLIGHT = 'xyz';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.maxConcurrentUploadH2Requests).toBe(2);
+        });
+    });
+    (0, vitest_1.describe)('h2StreamWindowSize', () => {
+        (0, vitest_1.it)('defaults to 16 MiB', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2StreamWindowSize).toBe(16 * 1024 * 1024);
+        });
+        (0, vitest_1.it)('parses a positive env var', async () => {
+            process.env.BL_H2_STREAM_WINDOW = String(4 * 1024 * 1024);
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2StreamWindowSize).toBe(4 * 1024 * 1024);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_H2_STREAM_WINDOW = '123456';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.h2StreamWindowSize = 654321;
+            (0, vitest_1.expect)(settings.h2StreamWindowSize).toBe(654321);
+        });
+        vitest_1.it.each(['0', '-1', 'nan'])('ignores non-positive/unparseable env value %s and uses the default', async (value) => {
+            process.env.BL_H2_STREAM_WINDOW = value;
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2StreamWindowSize).toBe(16 * 1024 * 1024);
+        });
+    });
+    (0, vitest_1.describe)('h2ConnectionWindowSize', () => {
+        (0, vitest_1.it)('defaults to 32 MiB', async () => {
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2ConnectionWindowSize).toBe(32 * 1024 * 1024);
+        });
+        (0, vitest_1.it)('parses a positive env var', async () => {
+            process.env.BL_H2_CONNECTION_WINDOW = String(8 * 1024 * 1024);
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2ConnectionWindowSize).toBe(8 * 1024 * 1024);
+        });
+        (0, vitest_1.it)('config value wins over the env var', async () => {
+            process.env.BL_H2_CONNECTION_WINDOW = '111';
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            settings.config.h2ConnectionWindowSize = 222;
+            (0, vitest_1.expect)(settings.h2ConnectionWindowSize).toBe(222);
+        });
+        vitest_1.it.each(['0', '-100', 'foo'])('ignores non-positive/unparseable env value %s and uses the default', async (value) => {
+            process.env.BL_H2_CONNECTION_WINDOW = value;
+            const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
+            (0, vitest_1.expect)(settings.h2ConnectionWindowSize).toBe(32 * 1024 * 1024);
+        });
+    });
+});

package/dist/cjs-browser/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./agents/index.js"), exports);
 __exportStar(require("./client/client.js"), exports);
 __exportStar(require("./common/autoload.js"), exports);
 __exportStar(require("./common/env.js"), exports);
+__exportStar(require("./common/h2-runtime.js"), exports);
 __exportStar(require("./common/node.js"), exports);
 __exportStar(require("./common/errors.js"), exports);
 __exportStar(require("./common/internal.js"), exports);

package/dist/cjs-browser/types/common/h2-runtime.d.ts

@@ -0,0 +1,52 @@
+/**
+ * HTTP/2 runtime-capability detection.
+ *
+ * The SDK's pooled HTTP/2 transport relies on the runtime's HTTP/2 client
+ * managing connection-level flow control correctly. One runtime does not:
+ *
+ *   Bun < 1.3.11 never sends a connection-level WINDOW_UPDATE frame. The pooled
+ *   H2 session therefore freezes after exactly 65535 cumulative body bytes (the
+ *   default connection receive window that Bun never grows), and every request
+ *   on that session hangs until the edge resets the streams (~330s).
+ *   Fixed in Bun 1.3.11: https://bun.com/blog/bun-v1.3.11
+ *
+ * This module centralizes the version gate so the settings layer, the unit
+ * tests, and the cross-runtime environment tests all agree on ONE definition of
+ * "is this a Bun that breaks pooled H2". Keeping a single source of truth is the
+ * whole point: the bug this guards against is subtle and the parse is easy to
+ * get subtly wrong (see `stripPrerelease`).
+ */
+/** First Bun release with a working connection-level WINDOW_UPDATE. */
+export declare const BUN_H2_FIXED_VERSION: "1.3.11";
+/**
+ * The default HTTP/2 connection-level receive window, in bytes (2^16 - 1). This
+ * is the exact number of cumulative body bytes after which a broken-Bun pooled
+ * session freezes: the window opens to 65535 and, absent a WINDOW_UPDATE, never
+ * reopens. Node grows it (see `establishH2`'s `setLocalWindowSize`); Bun < 1.3.11
+ * does not.
+ */
+export declare const H2_DEFAULT_CONNECTION_WINDOW_BYTES: 65535;
+/**
+ * Parse a `major.minor.patch` version, tolerating a pre-release/build suffix
+ * (e.g. `1.3.11-canary.1`, `1.4.0+build`). Returns `null` when the input is
+ * absent or not a recognizable semver triple.
+ */
+export declare function parseSemver(version: string | undefined | null): [number, number, number] | null;
+/**
+ * Given a Bun version string, is this a Bun whose HTTP/2 client breaks the
+ * pooled transport (Bun < 1.3.11)? A falsy/undefined version means "not Bun",
+ * which returns `false`. An unparseable version is treated as broken (`true`):
+ * we cannot prove it is safe, and forcing H2 off is the safe default.
+ */
+export declare function isBrokenBunVersion(version: string | undefined | null): boolean;
+/**
+ * The running runtime's Bun version, or `undefined` when not on Bun (Node,
+ * Deno, browsers, workers). Deno also exposes `process.versions` but never sets
+ * `.bun`, so this stays `undefined` there.
+ */
+export declare function detectBunVersion(): string | undefined;
+/**
+ * Is the CURRENT runtime a Bun that breaks the pooled H2 transport? This is the
+ * predicate the settings layer uses to force H2 off.
+ */
+export declare function isBrokenBunH2Runtime(): boolean;

package/dist/cjs-browser/types/common/h2-runtime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs-browser/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./agents/index.js";
 export * from "./client/client.js";
 export * from "./common/autoload.js";
 export * from "./common/env.js";
+export * from "./common/h2-runtime.js";
 export * from "./common/node.js";
 export * from "./common/errors.js";
 export * from "./common/internal.js";