@blaxel/core 0.2.83-preview.150 → 0.2.83

package/dist/esm/common/h2fetch.js

@@ -1,3 +1,4 @@
+import { refH2SessionForActiveRequest } from "./h2ref.js";
 const MIN_H2_SESSION_MAX_LISTENERS = 64;
 const sessionsWithListenerBudget = new WeakSet();
 /**
@@ -156,6 +157,8 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
         let streamController = null;
         let streamClosed = false;
         let req = null;
+        let releaseSessionRef = () => { };
+        let abort = null;
         try {
             req = session.request(h2Headers);
         }
@@ -165,6 +168,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
             globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
             return;
         }
+        releaseSessionRef = refH2SessionForActiveRequest(session);
         options?.onH2RequestCreated?.();
         ensureH2SessionListenerBudget(session);
         const cleanupBeforeResponseListeners = () => {
@@ -172,11 +176,17 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
             session.off("goaway", onSessionGoaway);
             session.off("error", onSessionError);
         };
+        const cleanupActiveRequest = () => {
+            if (abort)
+                signal?.removeEventListener("abort", abort);
+            releaseSessionRef();
+        };
         const rejectBeforeResponse = (err) => {
             if (settled)
                 return;
             settled = true;
             cleanupBeforeResponseListeners();
+            cleanupActiveRequest();
             req?.close();
             reject(err);
         };
@@ -192,19 +202,21 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
         session.once("close", onSessionClose);
         session.once("goaway", onSessionGoaway);
         session.once("error", onSessionError);
-        const abort = () => {
+        abort = () => {
             req?.close();
             const abortError = new DOMException("The operation was aborted.", "AbortError");
             if (!responded) {
                 if (!settled) {
                     settled = true;
                     cleanupBeforeResponseListeners();
+                    cleanupActiveRequest();
                     reject(abortError);
                 }
                 return;
             }
             if (!streamClosed) {
                 streamClosed = true;
+                cleanupActiveRequest();
                 streamController?.error(abortError);
             }
         };
@@ -213,6 +225,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
                 req.close();
                 cleanupBeforeResponseListeners();
                 settled = true;
+                cleanupActiveRequest();
                 reject(new DOMException("The operation was aborted.", "AbortError"));
                 return;
             }
@@ -236,25 +249,31 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
             const readable = new ReadableStream({
                 start(controller) {
                     streamController = controller;
+                    const finishStream = (finish) => {
+                        if (streamClosed)
+                            return;
+                        streamClosed = true;
+                        cleanupActiveRequest();
+                        finish();
+                    };
                     req.on("data", (chunk) => {
                         if (!streamClosed)
                             controller.enqueue(new Uint8Array(chunk));
                     });
                     req.on("end", () => {
-                        if (!streamClosed) {
-                            streamClosed = true;
-                            signal?.removeEventListener("abort", abort);
-                            controller.close();
-                        }
+                        finishStream(() => controller.close());
                     });
                     req.on("error", (err) => {
-                        if (!streamClosed) {
-                            streamClosed = true;
-                            signal?.removeEventListener("abort", abort);
-                            controller.error(err);
-                        }
+                        finishStream(() => controller.error(err));
                     });
                 },
+                cancel() {
+                    req?.close();
+                    if (streamClosed)
+                        return;
+                    streamClosed = true;
+                    cleanupActiveRequest();
+                },
             });
             resolve(new Response(readable, { status, headers: resHeaders }));
         });
@@ -263,6 +282,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
                 return;
             settled = true;
             cleanupBeforeResponseListeners();
+            cleanupActiveRequest();
             reject(err);
         });
         if (body) {

package/dist/esm/common/h2ref.js

@@ -0,0 +1,29 @@
+const idleUnrefSessions = new WeakSet();
+const activeRequestCounts = new WeakMap();
+export function markH2SessionIdleUnref(session) {
+    idleUnrefSessions.add(session);
+    if ((activeRequestCounts.get(session) ?? 0) === 0) {
+        session.unref();
+    }
+}
+export function refH2SessionForActiveRequest(session) {
+    if (!idleUnrefSessions.has(session))
+        return () => { };
+    const previousActiveRequests = activeRequestCounts.get(session) ?? 0;
+    activeRequestCounts.set(session, previousActiveRequests + 1);
+    if (previousActiveRequests === 0)
+        session.ref();
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const activeRequests = activeRequestCounts.get(session);
+        if (activeRequests === undefined || activeRequests <= 1) {
+            activeRequestCounts.delete(session);
+            session.unref();
+            return;
+        }
+        activeRequestCounts.set(session, activeRequests - 1);
+    };
+}

package/dist/esm/common/h2warm.js

@@ -1,6 +1,7 @@
 import dns from "dns/promises";
 import http2 from "http2";
 import tls from "tls";
+import { markH2SessionIdleUnref } from "./h2ref.js";
 export async function establishH2(sniHostname) {
     let timedOut = false;
     let timer;
@@ -36,13 +37,13 @@ async function _establishH2(sniHostname) {
             // Ensure the TLS socket is cleaned up on connection error
             if (!tlsSocket.destroyed)
                 tlsSocket.destroy();
-            reject(err);
+            reject(err instanceof Error ? err : new Error(String(err)));
         });
     });
     // 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()));
-    // Unref so the session doesn't prevent process exit
-    session.unref();
+    // Unref so the idle session doesn't prevent process exit.
+    markH2SessionIdleUnref(session);
     return session;
 }

package/dist/esm/common/settings.js

@@ -5,8 +5,8 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../common/node.js";
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.83-preview.150";
-const BUILD_COMMIT = "73012d5f15da52b069b9cc136ca22126168ac7a8";
+const BUILD_VERSION = "0.2.83";
+const BUILD_COMMIT = "d6f07458e0f766e5ef3c547eec3b0e00cf3297f7";
 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