@blaxel/core 0.2.82 → 0.2.83-dev.151

package/dist/cjs/common/h2fetch.js

@@ -4,6 +4,7 @@ exports.createH2Fetch = createH2Fetch;
 exports.createPoolBackedH2Fetch = createPoolBackedH2Fetch;
 exports.h2RequestDirectFromPool = h2RequestDirectFromPool;
 exports.h2RequestDirect = h2RequestDirect;
+const h2ref_js_1 = require("./h2ref.js");
 const MIN_H2_SESSION_MAX_LISTENERS = 64;
 const sessionsWithListenerBudget = new WeakSet();
 /**
@@ -162,6 +163,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);
         }
@@ -171,6 +174,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
             globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
             return;
         }
+        releaseSessionRef = (0, h2ref_js_1.refH2SessionForActiveRequest)(session);
         options?.onH2RequestCreated?.();
         ensureH2SessionListenerBudget(session);
         const cleanupBeforeResponseListeners = () => {
@@ -178,11 +182,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);
         };
@@ -198,19 +208,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);
             }
         };
@@ -219,6 +231,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;
             }
@@ -242,25 +255,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 }));
         });
@@ -269,6 +288,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
                 return;
             settled = true;
             cleanupBeforeResponseListeners();
+            cleanupActiveRequest();
             reject(err);
         });
         if (body) {

package/dist/cjs/common/h2ref.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markH2SessionIdleUnref = markH2SessionIdleUnref;
+exports.refH2SessionForActiveRequest = refH2SessionForActiveRequest;
+const idleUnrefSessions = new WeakSet();
+const activeRequestCounts = new WeakMap();
+function markH2SessionIdleUnref(session) {
+    idleUnrefSessions.add(session);
+    if ((activeRequestCounts.get(session) ?? 0) === 0) {
+        session.unref();
+    }
+}
+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/cjs/common/h2warm.js

@@ -7,6 +7,7 @@ exports.establishH2 = establishH2;
 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");
 async function establishH2(sniHostname) {
     let timedOut = false;
     let timer;
@@ -42,13 +43,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.
+    (0, h2ref_js_1.markH2SessionIdleUnref)(session);
     return session;
 }

package/dist/cjs/common/settings.js

@@ -11,8 +11,8 @@ const index_js_1 = require("../authentication/index.js");
 const env_js_1 = require("../common/env.js");
 const node_js_1 = require("../common/node.js");
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.82";
-const BUILD_COMMIT = "4d2b3531bdb9d8a065f6d83822343840ae0b8d65";
+const BUILD_VERSION = "0.2.83-dev.151";
+const BUILD_COMMIT = "772f4015ae11cd613a895993318cf7ffa19bead1";
 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

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

@@ -0,0 +1,3 @@
+import type http2 from "http2";
+export declare function markH2SessionIdleUnref(session: http2.ClientHttp2Session): void;
+export declare function refH2SessionForActiveRequest(session: http2.ClientHttp2Session): () => void;