@blaxel/core 0.2.80-preview.139 → 0.2.80

package/dist/cjs/common/h2fetch.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createH2Fetch = createH2Fetch;
 exports.createPoolBackedH2Fetch = createPoolBackedH2Fetch;
 exports.h2RequestDirect = h2RequestDirect;
-const H2_REQUEST_TIMEOUT_MS = 10_000;
 /**
  * Creates a fetch()-compatible function that sends requests over an existing
- * HTTP/2 session. Falls back to global fetch() if the session is closed,
- * destroyed, or if the H2 request times out.
+ * HTTP/2 session. Falls back to globalThis.fetch() only when the session is
+ * closed/destroyed at call time (pre-flight, nothing sent on the wire).
+ *
+ * Any failure after session.request() succeeds propagates to the caller:
+ * this transport never retries. Retry and timeout policy are caller concerns.
  */
 function createH2Fetch(session) {
     return (input) => {
@@ -78,7 +80,8 @@ function h2RequestDirect(session, url, init) {
         }
         else {
             // FormData, ReadableStream, Blob, etc. can't be serialized to Buffer
-            // for manual H2 framing — fall back to regular fetch.
+            // for manual H2 framing — fall back to regular fetch (pre-flight,
+            // nothing has been sent on the wire yet).
             return globalThis.fetch(url, init);
         }
         if (!h2Headers["content-length"]) {
@@ -116,42 +119,49 @@ async function _h2Request(session, input) {
 }
 function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit) {
     return new Promise((resolve, reject) => {
+        let settled = false;
+        let responded = false;
+        let streamController = null;
+        let streamClosed = false;
         let req;
         try {
             req = session.request(h2Headers);
         }
         catch {
-            return globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+            // Pre-flight fallback: session.request() threw synchronously, so no
+            // H2 frames were sent. Safe to retry over globalThis.fetch.
+            globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+            return;
         }
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
+        const abort = () => {
             req.close();
-            globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
-        }, H2_REQUEST_TIMEOUT_MS);
+            const abortError = new DOMException("The operation was aborted.", "AbortError");
+            if (!responded) {
+                if (!settled) {
+                    settled = true;
+                    reject(abortError);
+                }
+                return;
+            }
+            if (!streamClosed) {
+                streamClosed = true;
+                streamController?.error(abortError);
+            }
+        };
         if (signal) {
             if (signal.aborted) {
-                clearTimeout(timer);
                 req.close();
+                settled = true;
                 reject(new DOMException("The operation was aborted.", "AbortError"));
                 return;
             }
-            signal.addEventListener("abort", () => {
-                clearTimeout(timer);
-                req.close();
-                if (!settled) {
-                    settled = true;
-                    reject(new DOMException("The operation was aborted.", "AbortError"));
-                }
-            }, { once: true });
+            signal.addEventListener("abort", abort, { once: true });
         }
-        let settled = false;
         req.on("response", (headers) => {
-            clearTimeout(timer);
             if (settled)
                 return;
             settled = true;
+            responded = true;
             const status = headers[":status"] ?? 200;
             const resHeaders = new Headers();
             for (const [k, v] of Object.entries(headers)) {
@@ -161,9 +171,9 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit) {
                     continue;
                 resHeaders.set(k, Array.isArray(v) ? v.join(", ") : String(v));
             }
-            let streamClosed = false;
             const readable = new ReadableStream({
                 start(controller) {
+                    streamController = controller;
                     req.on("data", (chunk) => {
                         if (!streamClosed)
                             controller.enqueue(new Uint8Array(chunk));
@@ -180,23 +190,15 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit) {
                             controller.error(err);
                         }
                     });
-                    signal?.addEventListener("abort", () => {
-                        req.close();
-                        if (!streamClosed) {
-                            streamClosed = true;
-                            controller.error(new DOMException("The operation was aborted.", "AbortError"));
-                        }
-                    }, { once: true });
                 },
             });
             resolve(new Response(readable, { status, headers: resHeaders }));
         });
-        req.on("error", () => {
-            clearTimeout(timer);
+        req.on("error", (err) => {
             if (settled)
                 return;
             settled = true;
-            globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+            reject(err);
         });
         if (body) {
             req.end(body);

package/dist/cjs/common/h2pool.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.h2Pool = void 0;
+exports.h2Pool = exports.H2Pool = void 0;
 /**
  * Singleton H2 session pool keyed by edge domain.
  *
@@ -49,13 +49,32 @@ class H2Pool {
     /**
      * Lazily resolve the establish function so the http2 / tls / dns modules
      * are only imported in Node.js environments.
+     *
+     * Wires up self-healing eviction: the session is removed from the cache
+     * as soon as it emits `goaway`, `error`, or `close`, so `tryGet()` never
+     * returns a dead session. This replaces the old behavior of papering
+     * over session failures at the fetch layer.
      */
     async establish(domain) {
         if (!this._establish) {
             const { establishH2 } = await Promise.resolve().then(() => __importStar(require("./h2warm.js")));
             this._establish = establishH2;
         }
-        return this._establish(domain);
+        const session = await this._establish(domain);
+        this.attachEvictionListeners(domain, session);
+        return session;
+    }
+    attachEvictionListeners(domain, session) {
+        const evict = () => {
+            // Only evict if this specific session is still the cached one.
+            // A newer session may have taken its place after reconnect.
+            if (this.sessions.get(domain) === session) {
+                this.sessions.delete(domain);
+            }
+        };
+        session.on("goaway", evict);
+        session.on("error", evict);
+        session.on("close", evict);
     }
     /**
      * Fire-and-forget background warming. Safe to call multiple times for
@@ -134,4 +153,5 @@ class H2Pool {
         this.inflight.clear();
     }
 }
+exports.H2Pool = H2Pool;
 exports.h2Pool = new H2Pool();

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.80-preview.139";
-const BUILD_COMMIT = "90ee846099b1f428daba9643df172bf43a5fd53e";
+const BUILD_VERSION = "0.2.80";
+const BUILD_COMMIT = "800934e57ec03de060b909ccb1f5599343cae9e5";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

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

@@ -2,8 +2,11 @@ import http2 from "http2";
 import type { h2Pool as H2PoolType } from "./h2pool.js";
 /**
  * Creates a fetch()-compatible function that sends requests over an existing
- * HTTP/2 session. Falls back to global fetch() if the session is closed,
- * destroyed, or if the H2 request times out.
+ * HTTP/2 session. Falls back to globalThis.fetch() only when the session is
+ * closed/destroyed at call time (pre-flight, nothing sent on the wire).
+ *
+ * Any failure after session.request() succeeds propagates to the caller:
+ * this transport never retries. Retry and timeout policy are caller concerns.
  */
 export declare function createH2Fetch(session: http2.ClientHttp2Session): (input: Request) => Promise<Response>;
 /**

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

@@ -7,15 +7,21 @@ import type http2 from "http2";
  *   an in-flight warming, or establishes a fresh one.
  * - Closed / destroyed sessions are automatically evicted.
  */
-declare class H2Pool {
+export declare class H2Pool {
     private sessions;
     private inflight;
     private _establish;
     /**
      * Lazily resolve the establish function so the http2 / tls / dns modules
      * are only imported in Node.js environments.
+     *
+     * Wires up self-healing eviction: the session is removed from the cache
+     * as soon as it emits `goaway`, `error`, or `close`, so `tryGet()` never
+     * returns a dead session. This replaces the old behavior of papering
+     * over session failures at the fetch layer.
      */
     private establish;
+    private attachEvictionListeners;
     /**
      * Fire-and-forget background warming. Safe to call multiple times for
      * the same domain — only one connection attempt per domain at a time.
@@ -35,4 +41,3 @@ declare class H2Pool {
     closeAll(): void;
 }
 export declare const h2Pool: H2Pool;
-export {};