@blaxel/core 0.2.82-preview.146 → 0.2.82

package/dist/cjs-browser/common/h2fetch.js

@@ -2,3 +2,4 @@
 export function createH2Fetch(session) { return (input) => globalThis.fetch(input); }
 export function createPoolBackedH2Fetch(pool, domain) { return (input) => globalThis.fetch(input); }
 export function h2RequestDirect(session, url, init) { return globalThis.fetch(url, init); }
+export function h2RequestDirectFromPool(pool, domain, url, init) { return globalThis.fetch(url, init); }

package/dist/cjs-browser/common/lazyInit.js

@@ -77,7 +77,7 @@ function ensureAutoloaded() {
     const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
     /* eslint-disable */
     const isBrowser = typeof globalThis !== "undefined" && globalThis?.window !== undefined;
-    if (isNode && !isBrowser) {
+    if (isNode && !isBrowser && !settings_js_1.settings.disableH2) {
         try {
             // Pre-warm edge H2 for the configured region so the first
             // SandboxInstance.create() gets an instant session via the pool.

package/dist/cjs-browser/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-preview.146";
-const BUILD_COMMIT = "bd1f2f080c52d701b0dcbcccd73d139be5740ef2";
+const BUILD_VERSION = "0.2.82";
+const BUILD_COMMIT = "4d2b3531bdb9d8a065f6d83822343840ae0b8d65";
 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
@@ -218,6 +218,15 @@ class Settings {
     get region() {
         return env_js_1.env.BL_REGION || undefined;
     }
+    get disableH2() {
+        if (typeof this.config.disableH2 === "boolean") {
+            return this.config.disableH2;
+        }
+        const value = env_js_1.env.BL_DISABLE_H2;
+        if (!value)
+            return false;
+        return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+    }
     async authenticate() {
         await this.credentials.authenticate();
     }

package/dist/cjs-browser/sandbox/action.js

@@ -5,6 +5,7 @@ const client_fetch_1 = require("@hey-api/client-fetch");
 const interceptors_js_1 = require("../client/interceptors.js");
 const responseInterceptor_js_1 = require("../client/responseInterceptor.js");
 const h2fetch_js_1 = require("../common/h2fetch.js");
+const h2pool_js_1 = require("../common/h2pool.js");
 const internal_js_1 = require("../common/internal.js");
 const settings_js_1 = require("../common/settings.js");
 const client_gen_js_1 = require("./client/client.gen.js");
@@ -36,6 +37,7 @@ exports.ResponseError = ResponseError;
 class SandboxAction {
     sandbox;
     _h2Client = null;
+    _h2ClientDomain = null;
     constructor(sandbox) {
         this.sandbox = sandbox;
     }
@@ -62,12 +64,13 @@ class SandboxAction {
                 headers: this.sandbox.headers,
             });
         }
-        const session = this.sandbox.h2Session;
-        if (session && !session.closed && !session.destroyed) {
-            if (!this._h2Client) {
+        const h2Domain = this.sandbox.h2Domain;
+        if (h2Domain) {
+            if (!this._h2Client || this._h2ClientDomain !== h2Domain) {
                 this._h2Client = (0, client_fetch_1.createClient)({
-                    fetch: (0, h2fetch_js_1.createH2Fetch)(session),
+                    fetch: (0, h2fetch_js_1.createPoolBackedH2Fetch)(h2pool_js_1.h2Pool, h2Domain),
                 });
+                this._h2ClientDomain = h2Domain;
                 for (const interceptor of interceptors_js_1.interceptors) {
                     // @ts-expect-error - Interceptor is not typed
                     this._h2Client.interceptors.request.use(interceptor);
@@ -78,8 +81,9 @@ class SandboxAction {
             }
             return this._h2Client;
         }
-        // Invalidate cached H2 client when session is no longer usable
+        // Invalidate cached H2 client when the sandbox no longer has an H2 domain.
         this._h2Client = null;
+        this._h2ClientDomain = null;
         return client_gen_js_1.client;
     }
     /**
@@ -87,9 +91,9 @@ class SandboxAction {
      * globalThis.fetch. Uses a direct H2 path that avoids Request allocation.
      */
     h2Fetch(input, init) {
-        const session = this.sandbox.h2Session;
-        if (session && !session.closed && !session.destroyed) {
-            return (0, h2fetch_js_1.h2RequestDirect)(session, input.toString(), init);
+        const h2Domain = this.sandbox.h2Domain;
+        if (h2Domain) {
+            return (0, h2fetch_js_1.h2RequestDirectFromPool)(h2pool_js_1.h2Pool, h2Domain, input.toString(), init);
         }
         return globalThis.fetch(input, init);
     }

package/dist/cjs-browser/sandbox/interpreter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeInterpreter = void 0;
 const h2fetch_js_1 = require("../common/h2fetch.js");
+const h2pool_js_1 = require("../common/h2pool.js");
 const logger_js_1 = require("../common/logger.js");
 const settings_js_1 = require("../common/settings.js");
 const sandbox_js_1 = require("./sandbox.js");
@@ -28,6 +29,7 @@ class CodeInterpreter extends sandbox_js_1.SandboxInstance {
             status: base.status,
             events: base.events,
             h2Session: base.h2Session,
+            h2Domain: base.h2Domain,
         };
         return new CodeInterpreter(config);
     }
@@ -72,6 +74,7 @@ class CodeInterpreter extends sandbox_js_1.SandboxInstance {
             status: baseInstance.status,
             events: baseInstance.events,
             h2Session: baseInstance.h2Session,
+            h2Domain: baseInstance.h2Domain,
         };
         // Preserve forceUrl, headers, and params from input if provided
         if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
@@ -94,9 +97,9 @@ class CodeInterpreter extends sandbox_js_1.SandboxInstance {
         return this.process.url;
     }
     _fetch(input, init) {
-        const session = this._sandboxConfig.h2Session;
-        if (session && !session.closed && !session.destroyed) {
-            return (0, h2fetch_js_1.h2RequestDirect)(session, input.toString(), init);
+        const h2Domain = this._sandboxConfig.h2Domain;
+        if (h2Domain) {
+            return (0, h2fetch_js_1.h2RequestDirectFromPool)(h2pool_js_1.h2Pool, h2Domain, input.toString(), init);
         }
         return globalThis.fetch(input, init);
     }

package/dist/cjs-browser/sandbox/sandbox.js

@@ -57,7 +57,6 @@ class SandboxInstance {
     codegen;
     system;
     drives;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
     h2Session;
     constructor(sandbox) {
         this.sandbox = sandbox;
@@ -86,27 +85,35 @@ class SandboxInstance {
     get lastUsedAt() {
         return this.sandbox.lastUsedAt;
     }
+    get h2Domain() {
+        return this.sandbox.h2Domain ?? null;
+    }
     /**
      * Warm and attach an H2 session based on the sandbox's region.
      * Shared by create(), get(), list(), and update helpers.
      */
     static async attachH2Session(instance) {
-        const region = instance.spec?.region;
-        if (!region)
+        const edgeDomain = SandboxInstance.edgeDomainForRegion(instance.spec?.region);
+        if (!edgeDomain || settings_js_1.settings.disableH2)
             return instance;
-        const edgeSuffix = settings_js_1.settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
-        const edgeDomain = `any.${region}.${edgeSuffix}`;
         try {
             const { h2Pool } = await Promise.resolve().then(() => __importStar(require("../common/h2pool.js")));
             const h2Session = await h2Pool.get(edgeDomain);
             instance.h2Session = h2Session;
             instance.sandbox.h2Session = h2Session;
+            instance.sandbox.h2Domain = edgeDomain;
         }
         catch {
             // H2 warming is best-effort; fall back to regular fetch
         }
         return instance;
     }
+    static edgeDomainForRegion(region) {
+        if (!region)
+            return null;
+        const edgeSuffix = settings_js_1.settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+        return `any.${region}.${edgeSuffix}`;
+    }
     get expiresIn() {
         return this.sandbox.expiresIn;
     }
@@ -201,10 +208,9 @@ class SandboxInstance {
         }
         sandbox.spec.runtime.image = sandbox.spec.runtime.image || defaultImage;
         sandbox.spec.runtime.memory = sandbox.spec.runtime.memory || defaultMemory;
-        const edgeSuffix = settings_js_1.settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
-        const edgeDomain = sandbox.spec?.region ? `any.${sandbox.spec.region}.${edgeSuffix}` : null;
+        const edgeDomain = SandboxInstance.edgeDomainForRegion(sandbox.spec?.region);
         // Kick off warming so h2Pool.get() can join it during the API call
-        if (edgeDomain) {
+        if (edgeDomain && !settings_js_1.settings.disableH2) {
             Promise.resolve().then(() => __importStar(require("../common/h2pool.js"))).then(({ h2Pool }) => h2Pool.warm(edgeDomain)).catch(() => { });
         }
         const [{ data }, h2Session] = await Promise.all([
@@ -212,10 +218,10 @@ class SandboxInstance {
                 body: sandbox,
                 throwOnError: true,
             }),
-            edgeDomain ? Promise.resolve().then(() => __importStar(require("../common/h2pool.js"))).then(({ h2Pool }) => h2Pool.get(edgeDomain)).catch(() => null) : Promise.resolve(null),
+            edgeDomain && !settings_js_1.settings.disableH2 ? Promise.resolve().then(() => __importStar(require("../common/h2pool.js"))).then(({ h2Pool }) => h2Pool.get(edgeDomain)).catch(() => null) : Promise.resolve(null),
         ]);
         // Inject the H2 session into the config so subsystems can use it
-        const config = { ...data, h2Session };
+        const config = { ...data, h2Session, h2Domain: settings_js_1.settings.disableH2 ? null : edgeDomain };
         const instance = new SandboxInstance(config);
         instance.h2Session = h2Session;
         // Note: H2 session already attached via Promise.all above, no need for attachH2Session()
@@ -224,7 +230,10 @@ class SandboxInstance {
             try {
                 await instance.fs.ls('/');
             }
-            catch { }
+            catch (err) {
+                await SandboxInstance.delete(instance.metadata.name).catch(() => { });
+                throw err;
+            }
         }
         return instance;
     }
@@ -255,6 +264,8 @@ class SandboxInstance {
     async delete() {
         // Don't close the H2 session — it's shared via h2Pool
         this.h2Session = null;
+        this.sandbox.h2Session = null;
+        this.sandbox.h2Domain = null;
         return await SandboxInstance.delete(this.metadata.name);
     }
     static async updateMetadata(sandboxName, metadata) {

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

@@ -1,5 +1,5 @@
 import http2 from "http2";
-import type { h2Pool as H2PoolType } from "./h2pool.js";
+import type { H2Pool } from "./h2pool.js";
 /**
  * Creates a fetch()-compatible function that sends requests over an existing
  * HTTP/2 session. Falls back to globalThis.fetch() only when the session is
@@ -12,12 +12,12 @@ export declare function createH2Fetch(session: http2.ClientHttp2Session): (input
 /**
  * Creates a fetch()-compatible function backed by the H2 session pool.
  *
- * Non-blocking: checks the pool cache synchronously. If a warm session is
- * available it's used immediately; otherwise the request goes through
- * regular fetch with zero delay (the pool keeps warming in the background
- * so subsequent calls get H2).
+ * The pool validates idle sessions before reuse. If no usable H2 session is
+ * available, the request falls back to regular fetch before any H2 frames
+ * are sent.
  */
-export declare function createPoolBackedH2Fetch(pool: typeof H2PoolType, domain: string): (input: Request) => Promise<Response>;
+export declare function createPoolBackedH2Fetch(pool: H2Pool, domain: string): (input: Request) => Promise<Response>;
+export declare function h2RequestDirectFromPool(pool: H2Pool, domain: string, url: string, init?: RequestInit): Promise<Response>;
 /**
  * Low-level H2 request that takes raw URL + init, skipping Request construction.
  * Used by SandboxAction.h2Fetch() for direct calls from subsystems.

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

@@ -1,4 +1,10 @@
 import type http2 from "http2";
+type NowFn = () => number;
+export type H2PoolOptions = {
+    maxIdleMs?: number;
+    pingTimeoutMs?: number;
+    now?: NowFn;
+};
 /**
  * Singleton H2 session pool keyed by edge domain.
  *
@@ -11,6 +17,10 @@ export declare class H2Pool {
     private sessions;
     private inflight;
     private _establish;
+    private readonly maxIdleMs;
+    private readonly pingTimeoutMs;
+    private readonly now;
+    constructor(options?: H2PoolOptions);
     /**
      * Lazily resolve the establish function so the http2 / tls / dns modules
      * are only imported in Node.js environments.
@@ -22,6 +32,13 @@ export declare class H2Pool {
      */
     private establish;
     private attachEvictionListeners;
+    private isClosed;
+    private isIdle;
+    private cache;
+    private markUsed;
+    private evict;
+    private ping;
+    private validateEntry;
     /**
      * Fire-and-forget background warming. Safe to call multiple times for
      * the same domain — only one connection attempt per domain at a time.
@@ -32,6 +49,8 @@ export declare class H2Pool {
      * Never blocks, never establishes — use for non-blocking fast paths.
      */
     tryGet(domain: string): http2.ClientHttp2Session | null;
+    isUsable(session: http2.ClientHttp2Session): boolean;
+    evictSession(domain: string, session: http2.ClientHttp2Session): void;
     /**
      * Get a live H2 session for `domain`. Returns immediately from cache,
      * joins an in-flight warming, or starts a new one.
@@ -41,3 +60,4 @@ export declare class H2Pool {
     closeAll(): void;
 }
 export declare const h2Pool: H2Pool;
+export {};

package/dist/cjs-browser/types/common/settings.d.ts

@@ -11,6 +11,7 @@ export type Config = {
     proxy?: string;
     apikey?: string;
     workspace?: string;
+    disableH2?: boolean;
     /**
      * Client credentials for OAuth2 client_credentials flow.
      *
@@ -49,6 +50,7 @@ declare class Settings {
     get loggerType(): string;
     get tracking(): boolean;
     get region(): string | undefined;
+    get disableH2(): boolean;
     authenticate(): Promise<void>;
 }
 export declare const settings: Settings;

package/dist/cjs-browser/types/sandbox/action.d.ts

@@ -9,6 +9,7 @@ export declare class ResponseError extends Error {
 export declare class SandboxAction {
     protected sandbox: SandboxConfiguration;
     private _h2Client;
+    private _h2ClientDomain;
     constructor(sandbox: SandboxConfiguration);
     get name(): string;
     get fallbackUrl(): string | null;

package/dist/cjs-browser/types/sandbox/sandbox.d.ts

@@ -1,3 +1,4 @@
+import type http2 from "http2";
 import { SandboxLifecycle, Sandbox as SandboxModel } from "../client/index.js";
 import { SandboxCodegen } from "./codegen/index.js";
 import { SandboxDrive } from "./drive/index.js";
@@ -18,18 +19,20 @@ export declare class SandboxInstance {
     codegen: SandboxCodegen;
     system: SandboxSystem;
     drives: SandboxDrive;
-    h2Session: any;
+    h2Session: http2.ClientHttp2Session | null;
     constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata;
     get status(): import("../client/types.gen.js").Status | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
     get spec(): import("../client/types.gen.js").SandboxSpec;
     get lastUsedAt(): string | undefined;
+    get h2Domain(): string | null;
     /**
      * Warm and attach an H2 session based on the sandbox's region.
      * Shared by create(), get(), list(), and update helpers.
      */
     private static attachH2Session;
+    private static edgeDomainForRegion;
     get expiresIn(): number | undefined;
     /**
      * Fetch a resource served on a sandbox port.

package/dist/cjs-browser/types/sandbox/types.d.ts

@@ -26,6 +26,7 @@ export type SandboxConfiguration = {
     headers?: Record<string, string>;
     params?: Record<string, string>;
     h2Session?: http2.ClientHttp2Session | null;
+    h2Domain?: string | null;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;