@blaxel/core 0.2.88 → 0.2.89-preview.179

package/dist/cjs/common/h2warm.js

@@ -8,6 +8,7 @@ const promises_1 = __importDefault(require("dns/promises"));
 const http2_1 = __importDefault(require("http2"));
 const tls_1 = __importDefault(require("tls"));
 const h2ref_js_1 = require("./h2ref.js");
+const settings_js_1 = require("./settings.js");
 async function establishH2(sniHostname) {
     let timedOut = false;
     let timer;
@@ -34,8 +35,13 @@ async function _establishH2(sniHostname) {
         servername: sniHostname,
         ALPNProtocols: ["h2"],
     });
+    // Raise the per-stream receive window (SETTINGS_INITIAL_WINDOW_SIZE) well above
+    // Node's 64KB default. With the default, the server can only send one 64KB
+    // burst per round trip, capping a single download at window/RTT (~3MB/s at
+    // 20ms RTT) no matter the payload size.
     const session = http2_1.default.connect(`https://${sniHostname}:443`, {
         createConnection: () => tlsSocket,
+        settings: { initialWindowSize: settings_js_1.settings.h2StreamWindowSize },
     });
     await new Promise((resolve, reject) => {
         session.on("connect", resolve);
@@ -46,6 +52,17 @@ async function _establishH2(sniHostname) {
             reject(err instanceof Error ? err : new Error(String(err)));
         });
     });
+    // Raise the connection-level receive window too. Node defaults it to 64KB and
+    // never grows it, so it throttles the entire session (shared across every
+    // stream) — which is why adding read concurrency does not help. setLocalWindowSize
+    // is best-effort: guard it so an older runtime without it never breaks warm-up.
+    try {
+        session
+            .setLocalWindowSize?.(settings_js_1.settings.h2ConnectionWindowSize);
+    }
+    catch {
+        // ignore — fall back to the default window
+    }
     // Complete the SETTINGS exchange so the first real request has zero
     // protocol overhead. This RTT is hidden by the parallel createSandbox() call.
     await new Promise((resolve) => session.ping(() => resolve()));

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.88";
-const BUILD_COMMIT = "3d4dcbfdf0ac479adef35da9cd8523954af3e7f7";
+const BUILD_VERSION = "0.2.89-preview.179";
+const BUILD_COMMIT = "c481e2f6670b3cef6832875dbc9f2bc6b0b198f4";
 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
@@ -276,6 +276,32 @@ class Settings {
         }
         return 2;
     }
+    get h2StreamWindowSize() {
+        if (typeof this.config.h2StreamWindowSize === "number") {
+            return this.config.h2StreamWindowSize;
+        }
+        const value = env_js_1.env.BL_H2_STREAM_WINDOW;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+        return 16 * 1024 * 1024;
+    }
+    get h2ConnectionWindowSize() {
+        if (typeof this.config.h2ConnectionWindowSize === "number") {
+            return this.config.h2ConnectionWindowSize;
+        }
+        const value = env_js_1.env.BL_H2_CONNECTION_WINDOW;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+        return 32 * 1024 * 1024;
+    }
     get fsPartRetries() {
         if (typeof this.config.fsPartRetries === "number") {
             return this.config.fsPartRetries;

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

@@ -40,6 +40,20 @@ export type Config = {
      * (process.exec, drives.mount, etc.).
      */
     sandboxReadRetries?: number;
+    /**
+     * Per-stream HTTP/2 flow-control window in bytes, advertised to the server as
+     * SETTINGS_INITIAL_WINDOW_SIZE. Node defaults this to 64KB, which caps a single
+     * download at window/RTT (~3MB/s at 20ms RTT) regardless of payload size.
+     * Defaults to 16MB so large reads are bandwidth-bound, not latency-bound.
+     */
+    h2StreamWindowSize?: number;
+    /**
+     * Connection-level HTTP/2 flow-control window in bytes, applied via
+     * session.setLocalWindowSize(). Node defaults this to 64KB and never grows it,
+     * so it throttles the WHOLE session (shared across all streams) — which is why
+     * adding read concurrency does not help. Defaults to 32MB.
+     */
+    h2ConnectionWindowSize?: number;
     /**
      * Client credentials for OAuth2 client_credentials flow.
      *
@@ -81,6 +95,8 @@ declare class Settings {
     get disableH2(): boolean;
     get maxConcurrentH2Requests(): number;
     get maxConcurrentUploadH2Requests(): number;
+    get h2StreamWindowSize(): number;
+    get h2ConnectionWindowSize(): number;
     get fsPartRetries(): number;
     get sandboxReadRetries(): number;
     /**