@blaxel/core 0.2.89 → 0.2.90-preview.182

package/dist/cjs/common/autoload.js

@@ -41,11 +41,13 @@ const client_gen_js_1 = require("../client/client.gen.js");
 const interceptors_js_1 = require("../client/interceptors.js");
 const responseInterceptor_js_1 = require("../client/responseInterceptor.js");
 const client_gen_js_2 = require("../sandbox/client/client.gen.js");
+const controlPlaneFetch_js_1 = require("./controlPlaneFetch.js");
 const settings_js_1 = require("./settings.js");
 var lazyInit_js_1 = require("./lazyInit.js");
 Object.defineProperty(exports, "ensureAutoloaded", { enumerable: true, get: function () { return lazyInit_js_1.ensureAutoloaded; } });
 client_gen_js_1.client.setConfig({
     baseUrl: settings_js_1.settings.baseUrl,
+    fetch: controlPlaneFetch_js_1.controlPlaneFetch,
 });
 // Register request interceptors
 for (const interceptor of interceptors_js_1.interceptors) {
@@ -90,6 +92,7 @@ function initialize(config) {
     settings_js_1.settings.setConfig(config);
     client_gen_js_1.client.setConfig({
         baseUrl: settings_js_1.settings.baseUrl,
+        fetch: controlPlaneFetch_js_1.controlPlaneFetch,
     });
     client_gen_js_2.client.setConfig({
         baseUrl: settings_js_1.settings.baseUrl,

package/dist/cjs/common/controlPlaneFetch.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeFetchSupportsH2 = void 0;
+exports.undiciSupportsNativeH2 = undiciSupportsNativeH2;
+exports.shouldUseControlPlaneH2 = shouldUseControlPlaneH2;
+exports.controlPlaneFetch = controlPlaneFetch;
+const h2fetch_js_1 = require("./h2fetch.js");
+const h2pool_js_1 = require("./h2pool.js");
+const settings_js_1 = require("./settings.js");
+const h2FetchByHost = new Map();
+// Node's global fetch dispatcher only negotiates HTTP/2 by default starting
+// with undici 8 (Node 26+); undici 7 (Node 24) and undici 6 (Node 22) still
+// ALPN to HTTP/1.1 for fetch, verified empirically against api.blaxel.ai. On
+// undici >= 8 the pooled wrapper is redundant, so we prefer the native path.
+function undiciSupportsNativeH2(undiciVersion) {
+    const major = Number(undiciVersion?.split(".")[0] ?? 0);
+    return major >= 8;
+}
+// `process`/`process.versions` is absent on Cloudflare Workers and other
+// non-Node runtimes, and `process.versions.undici` is undefined on Bun/Deno;
+// all of those resolve to `false` and keep the wrapper as the fallback.
+exports.nativeFetchSupportsH2 = typeof process !== "undefined" && undiciSupportsNativeH2(process.versions?.undici);
+function shouldUseControlPlaneH2(url, h2Disabled, proxyConfigured = false, nativeH2 = false, forceWrapper = false) {
+    if (h2Disabled || proxyConfigured)
+        return false;
+    if (url.protocol !== "https:")
+        return false;
+    // Token refresh is sequential and unauthenticated; it cannot contribute to
+    // the create burst TLS storm, and device-mode refresh currently relies on the
+    // native fetch path.
+    if (url.pathname.endsWith("/oauth/token"))
+        return false;
+    if (!(url.hostname.endsWith("blaxel.ai") || url.hostname.endsWith("blaxel.dev"))) {
+        return false;
+    }
+    // Native fetch already negotiates HTTP/2: skip the redundant wrapper unless
+    // explicitly forced (e.g. to exercise the pooled path on a modern runtime).
+    if (nativeH2 && !forceWrapper)
+        return false;
+    return true;
+}
+function controlPlaneFetch(input) {
+    const url = new URL(input.url);
+    const proxyConfigured = Boolean(settings_js_1.settings.config.proxy);
+    // Global disableH2 still wins; disableControlPlaneH2 opts out of just the
+    // control-plane wrapper while leaving data-plane H2 in place.
+    const h2Disabled = settings_js_1.settings.disableH2 || settings_js_1.settings.disableControlPlaneH2;
+    if (!shouldUseControlPlaneH2(url, h2Disabled, proxyConfigured, exports.nativeFetchSupportsH2, settings_js_1.settings.forceControlPlaneH2)) {
+        return globalThis.fetch(input);
+    }
+    let h2Fetch = h2FetchByHost.get(url.hostname);
+    if (!h2Fetch) {
+        h2Fetch = (0, h2fetch_js_1.createPoolBackedH2Fetch)(h2pool_js_1.h2Pool, url.hostname);
+        h2FetchByHost.set(url.hostname, h2Fetch);
+    }
+    return h2Fetch(input);
+}

package/dist/cjs/common/lazyInit.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAutoloaded = ensureAutoloaded;
 const client_gen_js_1 = require("../client/client.gen.js");
 const client_gen_js_2 = require("../sandbox/client/client.gen.js");
+const controlPlaneFetch_js_1 = require("./controlPlaneFetch.js");
 const sentry_js_1 = require("./sentry.js");
 const settings_js_1 = require("./settings.js");
 let autoloaded = false;
@@ -69,7 +70,7 @@ function ensureAutoloaded() {
     // Keep the clients' baseUrl in sync with the now-resolved env. Without
     // this, the module-load `client.setConfig({ baseUrl })` would be stuck on
     // the prod default for users who rely on `config.yaml` (no env vars).
-    client_gen_js_1.client.setConfig({ baseUrl: settings_js_1.settings.baseUrl });
+    client_gen_js_1.client.setConfig({ baseUrl: settings_js_1.settings.baseUrl, fetch: controlPlaneFetch_js_1.controlPlaneFetch });
     client_gen_js_2.client.setConfig({ baseUrl: settings_js_1.settings.baseUrl });
     // Initialize Sentry for SDK error tracking.
     (0, sentry_js_1.initSentry)();
@@ -80,9 +81,9 @@ function ensureAutoloaded() {
     if (isNode && !isBrowser && !settings_js_1.settings.disableH2) {
         try {
             // Pre-warm edge H2 for the configured region so the first
-            // SandboxInstance.create() gets an instant session via the pool.
-            // The control-plane client (api.blaxel.ai) stays on regular fetch
-            // which already benefits from undici's built-in connection pooling.
+            // SandboxInstance.create() gets an instant data-plane session via the
+            // pool. Control-plane H2 is intentionally not warmed; its cold burst
+            // relies on pool deduplication instead.
             const region = settings_js_1.settings.region;
             if (region) {
                 Promise.resolve().then(() => __importStar(require("./h2pool.js"))).then(({ h2Pool }) => {

package/dist/cjs/common/settings.js

@@ -28,8 +28,8 @@ 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.2.89";
-const BUILD_COMMIT = "c481e2f6670b3cef6832875dbc9f2bc6b0b198f4";
+const BUILD_VERSION = "0.2.90-preview.182";
+const BUILD_COMMIT = "78dad6b3e2d47dcf5d8464b9688b0829ddc3369c";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-16";
 // Cache for config.yaml tracking value
@@ -250,6 +250,31 @@ class Settings {
         }
         return isDenoRuntime();
     }
+    // Control-plane-only escape hatch: disables the control-plane H2 wrapper
+    // without affecting data-plane (edge) H2. `disableH2` is the global override
+    // and is checked separately by callers, so it always wins.
+    get disableControlPlaneH2() {
+        if (typeof this.config.disableControlPlaneH2 === "boolean") {
+            return this.config.disableControlPlaneH2;
+        }
+        const value = env_js_1.env.BL_DISABLE_CONTROL_PLANE_H2;
+        if (value) {
+            return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        }
+        return false;
+    }
+    // Forces the control-plane H2 wrapper on even when native fetch already
+    // supports H2 (undici >= 7). `disableH2`/`disableControlPlaneH2` still win.
+    get forceControlPlaneH2() {
+        if (typeof this.config.forceControlPlaneH2 === "boolean") {
+            return this.config.forceControlPlaneH2;
+        }
+        const value = env_js_1.env.BL_FORCE_CONTROL_PLANE_H2;
+        if (value) {
+            return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        }
+        return false;
+    }
     get maxConcurrentH2Requests() {
         if (typeof this.config.maxConcurrentH2Requests === "number") {
             return this.config.maxConcurrentH2Requests;

package/dist/cjs/types/common/controlPlaneFetch.d.ts

@@ -0,0 +1,4 @@
+export declare function undiciSupportsNativeH2(undiciVersion: string | undefined): boolean;
+export declare const nativeFetchSupportsH2: boolean;
+export declare function shouldUseControlPlaneH2(url: URL, h2Disabled: boolean, proxyConfigured?: boolean, nativeH2?: boolean, forceWrapper?: boolean): boolean;
+export declare function controlPlaneFetch(input: Request): Promise<Response>;

package/dist/cjs/types/common/settings.d.ts

@@ -12,6 +12,22 @@ export type Config = {
     apikey?: string;
     workspace?: string;
     disableH2?: boolean;
+    /**
+     * Disables only the control-plane HTTP/2 wrapper, leaving data-plane (edge)
+     * H2 untouched. Use this to route control-plane calls (api.blaxel.{ai,dev})
+     * over native fetch while keeping sandbox/data-plane traffic on the H2 pool.
+     * The global `disableH2` flag still wins: when it is true, both planes use
+     * native fetch regardless of this value. Defaults to `false` (wrapper on).
+     */
+    disableControlPlaneH2?: boolean;
+    /**
+     * Forces the control-plane HTTP/2 wrapper on even when the runtime's native
+     * fetch already negotiates HTTP/2 (undici >= 8 / Node 26+), where it is
+     * otherwise skipped as redundant. Mainly for exercising the pooled path on a
+     * modern runtime. `disableH2` and `disableControlPlaneH2` still win.
+     * Defaults to `false`.
+     */
+    forceControlPlaneH2?: boolean;
     /**
      * Maximum number of concurrent in-flight HTTP/2 requests across the shared
      * H2 session pool. `0` or `undefined` means unlimited (current behavior).
@@ -93,6 +109,8 @@ declare class Settings {
     get tracking(): boolean;
     get region(): string | undefined;
     get disableH2(): boolean;
+    get disableControlPlaneH2(): boolean;
+    get forceControlPlaneH2(): boolean;
     get maxConcurrentH2Requests(): number;
     get maxConcurrentUploadH2Requests(): number;
     get h2StreamWindowSize(): number;