@blaxel/core 0.2.80-preview.139 → 0.2.80

package/dist/esm/common/h2fetch.js

@@ -1,8 +1,10 @@
-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.
  */
 export function createH2Fetch(session) {
     return (input) => {
@@ -73,7 +75,8 @@ export 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"]) {
@@ -111,42 +114,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)) {
@@ -156,9 +166,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));
@@ -175,23 +185,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/esm/common/h2pool.js

@@ -6,20 +6,39 @@
  *   an in-flight warming, or establishes a fresh one.
  * - Closed / destroyed sessions are automatically evicted.
  */
-class H2Pool {
+export class H2Pool {
     sessions = new Map();
     inflight = new Map();
     _establish = null;
     /**
      * 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 import("./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

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.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;