@blaxel/core 0.3.12-preview.254 → 0.3.12-preview.255

package/dist/cjs/common/h2fetch.js

@@ -12,6 +12,7 @@ exports.h2RequestDirect = h2RequestDirect;
 const http2_1 = __importDefault(require("http2"));
 const settings_js_1 = require("./settings.js");
 const h2ref_js_1 = require("./h2ref.js");
+const h2stats_js_1 = require("./h2stats.js");
 // Statuses the Response constructor refuses to pair with a body. Handing it one
 // throws, so a 204 (e.g. from a DELETE) would blow up instead of resolving.
 const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
@@ -169,6 +170,7 @@ async function withUploadSlot(domain, fn) {
 function createH2Fetch(session) {
     return (input) => {
         if (session.closed || session.destroyed) {
+            (0, h2stats_js_1.recordH2Fallback)(new URL(input.url).hostname, "session-unusable");
             return globalThis.fetch(input);
         }
         return _h2Request(session, input);
@@ -234,6 +236,7 @@ async function h2GatewayAttempt(pool, domain, send, fallback) {
             let h2RequestCreated = false;
             try {
                 return await send(session, {
+                    domain,
                     onH2RequestCreated: () => {
                         h2RequestCreated = true;
                     },
@@ -252,6 +255,7 @@ async function h2GatewayAttempt(pool, domain, send, fallback) {
         // No usable session: free the slot before falling back over a different
         // connection (no stream opens on the shared session).
         rel();
+        (0, h2stats_js_1.recordH2Fallback)(domain, "no-session");
         return await fallback();
     }
     catch (err) {
@@ -291,6 +295,7 @@ function h2RequestDirectInternal(session, url, init, options) {
         // Pre-flight fallback (session unusable): no stream opens on the shared
         // session, so free any held slot before going over globalThis.fetch.
         options?.releaseSlot?.();
+        (0, h2stats_js_1.recordH2Fallback)(options?.domain ?? new URL(url).hostname, "session-unusable");
         return globalThis.fetch(url, init);
     }
     const parsed = new URL(url);
@@ -333,6 +338,7 @@ function h2RequestDirectInternal(session, url, init, options) {
             // nothing has been sent on the wire yet). No stream opens on the shared
             // session, so free any held slot before falling back.
             options?.releaseSlot?.();
+            (0, h2stats_js_1.recordH2Fallback)(options?.domain ?? parsed.hostname, "unsupported-body");
             return globalThis.fetch(url, init);
         }
         if (!h2Headers["content-length"]) {
@@ -412,6 +418,7 @@ function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit, op
             // H2 frames were sent. No stream opened on the shared session, so free
             // the slot before retrying over globalThis.fetch.
             releaseSlot();
+            (0, h2stats_js_1.recordH2Fallback)(options?.domain ?? new URL(fallbackUrl).hostname, session.closed || session.destroyed ? "session-unusable" : "request-rejected");
             globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
             return;
         }

package/dist/cjs/common/h2pool.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.h2Pool = exports.H2Pool = void 0;
+const h2stats_js_1 = require("./h2stats.js");
 const DEFAULT_MAX_IDLE_MS = 5_000;
 const DEFAULT_PING_TIMEOUT_MS = 500;
 /**
@@ -75,6 +76,22 @@ class H2Pool {
         this.attachEvictionListeners(domain, session);
         return session;
     }
+    startEstablish(domain) {
+        const pending = this.establish(domain)
+            .then((session) => {
+            this.cache(domain, session);
+            return session;
+        })
+            .catch((error) => {
+            (0, h2stats_js_1.recordH2EstablishFailure)(domain, error);
+            return null;
+        })
+            .finally(() => {
+            this.inflight.delete(domain);
+        });
+        this.inflight.set(domain, pending);
+        return pending;
+    }
     attachEvictionListeners(domain, session) {
         const evict = () => {
             // Only evict if this specific session is still the cached one.
@@ -193,16 +210,7 @@ class H2Pool {
             return;
         if (this.inflight.has(domain))
             return;
-        const p = this.establish(domain)
-            .then((session) => {
-            this.cache(domain, session);
-            return session;
-        })
-            .catch(() => null)
-            .finally(() => {
-            this.inflight.delete(domain);
-        });
-        this.inflight.set(domain, p);
+        void this.startEstablish(domain);
     }
     /**
      * Synchronous cache check. Returns a live cached session or `null`.
@@ -250,17 +258,7 @@ class H2Pool {
         const freshCached = this.tryGet(domain);
         if (freshCached)
             return freshCached;
-        const p = this.establish(domain)
-            .then((session) => {
-            this.cache(domain, session);
-            return session;
-        })
-            .catch(() => null)
-            .finally(() => {
-            this.inflight.delete(domain);
-        });
-        this.inflight.set(domain, p);
-        return p;
+        return this.startEstablish(domain);
     }
     /** Close all sessions (for cleanup). */
     closeAll() {

package/dist/cjs/common/h2stats.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotH2TransportStats = snapshotH2TransportStats;
+exports.resetH2TransportStats = resetH2TransportStats;
+exports.recordH2EstablishFailure = recordH2EstablishFailure;
+exports.recordH2Fallback = recordH2Fallback;
+const logger_js_1 = require("./logger.js");
+const emptyReasons = () => ({
+    "no-session": 0,
+    "request-rejected": 0,
+    "session-unusable": 0,
+    "unsupported-body": 0,
+});
+const MAX_TRACKED_DOMAINS = 100;
+const H2_DEBUG_STATS_SYMBOL = Symbol.for("blaxel.h2stats");
+const h2DebugStatsEnabled = typeof process !== "undefined" && process.env?.BL_H2_DEBUG_STATS === "1";
+function publishDebugSnapshot(snapshot) {
+    if (!h2DebugStatsEnabled)
+        return;
+    try {
+        globalThis[H2_DEBUG_STATS_SYMBOL] = snapshot;
+    }
+    catch {
+        // Debug diagnostics must never change transport behavior.
+    }
+}
+const emptyDomainStats = () => ({
+    establishFailures: 0,
+    fetchFallbacks: 0,
+    fallbacksByReason: emptyReasons(),
+});
+class H2TransportStatsStore {
+    totals = emptyDomainStats();
+    byDomain = new Map();
+    snapshot() {
+        return {
+            ...this.clone(this.totals),
+            byDomain: Object.fromEntries([...this.byDomain].map(([domain, stats]) => [domain, this.clone(stats)])),
+        };
+    }
+    reset() {
+        this.totals = emptyDomainStats();
+        this.byDomain.clear();
+        publishDebugSnapshot(this.snapshot());
+    }
+    /** @internal */
+    recordEstablishFailure(domain, error) {
+        this.totals.establishFailures++;
+        this.forDomain(domain).establishFailures++;
+        try {
+            const message = error instanceof Error ? error.message : String(error);
+            logger_js_1.logger.debug(`H2 session establishment failed for ${domain}: ${message}`);
+        }
+        catch {
+            // Diagnostics must never change transport behavior.
+        }
+        publishDebugSnapshot(this.snapshot());
+    }
+    /** @internal */
+    recordFallback(domain, reason) {
+        this.totals.fetchFallbacks++;
+        this.totals.fallbacksByReason[reason]++;
+        const stats = this.forDomain(domain);
+        stats.fetchFallbacks++;
+        stats.fallbacksByReason[reason]++;
+        try {
+            logger_js_1.logger.debug(`H2 transport falling back to fetch for ${domain}: ${reason}`);
+        }
+        catch {
+            // Diagnostics must never change transport behavior.
+        }
+        publishDebugSnapshot(this.snapshot());
+    }
+    forDomain(domain) {
+        let stats = this.byDomain.get(domain);
+        if (stats) {
+            this.byDomain.delete(domain);
+        }
+        else {
+            if (this.byDomain.size >= MAX_TRACKED_DOMAINS) {
+                const oldest = this.byDomain.keys().next().value;
+                if (oldest !== undefined)
+                    this.byDomain.delete(oldest);
+            }
+            stats = emptyDomainStats();
+        }
+        this.byDomain.set(domain, stats);
+        return stats;
+    }
+    clone(stats) {
+        return {
+            establishFailures: stats.establishFailures,
+            fetchFallbacks: stats.fetchFallbacks,
+            fallbacksByReason: { ...stats.fallbacksByReason },
+        };
+    }
+}
+const store = new H2TransportStatsStore();
+publishDebugSnapshot(store.snapshot());
+/** @internal */
+function snapshotH2TransportStats() {
+    return store.snapshot();
+}
+/** @internal */
+function resetH2TransportStats() {
+    store.reset();
+}
+/** @internal */
+function recordH2EstablishFailure(domain, error) {
+    store.recordEstablishFailure(domain, error);
+}
+/** @internal */
+function recordH2Fallback(domain, reason) {
+    store.recordFallback(domain, reason);
+}

package/dist/cjs/common/settings.js

@@ -30,8 +30,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.3.12-preview.254";
-const BUILD_COMMIT = "c57f438aac364b3b4137e7e4ec37d446fec85006";
+const BUILD_VERSION = "0.3.12-preview.255";
+const BUILD_COMMIT = "0a7ecff86c697285b849e61a8cc5219e85b5ba89";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2

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

@@ -32,6 +32,7 @@ export declare class H2Pool {
      * over session failures at the fetch layer.
      */
     private establish;
+    private startEstablish;
     private attachEvictionListeners;
     private isClosed;
     private isIdle;

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

@@ -0,0 +1,17 @@
+export type H2FallbackReason = "no-session" | "request-rejected" | "session-unusable" | "unsupported-body";
+export type H2TransportDomainStats = {
+    establishFailures: number;
+    fetchFallbacks: number;
+    fallbacksByReason: Record<H2FallbackReason, number>;
+};
+export type H2TransportStatsSnapshot = H2TransportDomainStats & {
+    byDomain: Record<string, H2TransportDomainStats>;
+};
+/** @internal */
+export declare function snapshotH2TransportStats(): H2TransportStatsSnapshot;
+/** @internal */
+export declare function resetH2TransportStats(): void;
+/** @internal */
+export declare function recordH2EstablishFailure(domain: string, error: unknown): void;
+/** @internal */
+export declare function recordH2Fallback(domain: string, reason: H2FallbackReason): void;