@blaxel/core 0.2.71-dev.101 → 0.2.71-dev.106

package/dist/cjs/sandbox/sandbox.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxInstance = void 0;
 const uuid_1 = require("uuid");
@@ -24,6 +57,8 @@ class SandboxInstance {
     codegen;
     system;
     drives;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    h2Session;
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.process = new index_js_6.SandboxProcess(sandbox);
@@ -34,6 +69,7 @@ class SandboxInstance {
         this.codegen = new index_js_2.SandboxCodegen(sandbox);
         this.system = new system_js_1.SandboxSystem(sandbox);
         this.drives = new index_js_3.SandboxDrive(sandbox);
+        this.h2Session = null;
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -50,6 +86,27 @@ class SandboxInstance {
     get lastUsedAt() {
         return this.sandbox.lastUsedAt;
     }
+    /**
+     * 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)
+            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;
+        }
+        catch {
+            // H2 warming is best-effort; fall back to regular fetch
+        }
+        return instance;
+    }
     get expiresIn() {
         return this.sandbox.expiresIn;
     }
@@ -131,11 +188,24 @@ class SandboxInstance {
         }
         sandbox.spec.runtime.image = sandbox.spec.runtime.image || defaultImage;
         sandbox.spec.runtime.memory = sandbox.spec.runtime.memory || defaultMemory;
-        const { data } = await (0, index_js_1.createSandbox)({
-            body: sandbox,
-            throwOnError: true,
-        });
-        const instance = new SandboxInstance(data);
+        const edgeSuffix = settings_js_1.settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+        const edgeDomain = sandbox.spec?.region ? `any.${sandbox.spec.region}.${edgeSuffix}` : null;
+        // Kick off warming so h2Pool.get() can join it during the API call
+        if (edgeDomain) {
+            Promise.resolve().then(() => __importStar(require("../common/h2pool.js"))).then(({ h2Pool }) => h2Pool.warm(edgeDomain)).catch(() => { });
+        }
+        const [{ data }, h2Session] = await Promise.all([
+            (0, index_js_1.createSandbox)({
+                body: sandbox,
+                throwOnError: true,
+            }),
+            edgeDomain ? 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 instance = new SandboxInstance(config);
+        instance.h2Session = h2Session;
+        // Note: H2 session already attached via Promise.all above, no need for attachH2Session()
         // TODO remove this part once we have a better way to handle this
         if (safe) {
             try {
@@ -152,11 +222,13 @@ class SandboxInstance {
             },
             throwOnError: true,
         });
-        return new SandboxInstance(data);
+        const instance = new SandboxInstance(data);
+        return SandboxInstance.attachH2Session(instance);
     }
     static async list() {
         const { data } = await (0, index_js_1.listSandboxes)({ throwOnError: true });
-        return data.map((sandbox) => new SandboxInstance(sandbox));
+        const instances = data.map((sandbox) => new SandboxInstance(sandbox));
+        return Promise.all(instances.map((instance) => SandboxInstance.attachH2Session(instance)));
     }
     static async delete(sandboxName) {
         const { data } = await (0, index_js_1.deleteSandbox)({
@@ -168,6 +240,8 @@ class SandboxInstance {
         return data;
     }
     async delete() {
+        // Don't close the H2 session — it's shared via h2Pool
+        this.h2Session = null;
         return await SandboxInstance.delete(this.metadata.name);
     }
     static async updateMetadata(sandboxName, metadata) {
@@ -179,7 +253,7 @@ class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async updateTtl(sandboxName, ttl) {
         const sandbox = await SandboxInstance.get(sandboxName);
@@ -190,7 +264,7 @@ class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async updateLifecycle(sandboxName, lifecycle) {
         const sandbox = await SandboxInstance.get(sandboxName);
@@ -201,7 +275,7 @@ class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async createIfNotExists(sandbox) {
         try {

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

@@ -1,3 +1,8 @@
 import { Config } from "./settings.js";
 export declare function initialize(config: Config): void;
 export declare function authenticate(): Promise<void>;
+/**
+ * Close all pooled H2 connections. Call this for explicit cleanup
+ * (e.g. in test teardown or before process exit).
+ */
+export declare function closeConnections(): Promise<void>;

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

@@ -0,0 +1,22 @@
+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.
+ */
+export declare function createH2Fetch(session: http2.ClientHttp2Session): (input: Request) => Promise<Response>;
+/**
+ * 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).
+ */
+export declare function createPoolBackedH2Fetch(pool: typeof H2PoolType, domain: string): (input: Request) => Promise<Response>;
+/**
+ * Low-level H2 request that takes raw URL + init, skipping Request construction.
+ * Used by SandboxAction.h2Fetch() for direct calls from subsystems.
+ */
+export declare function h2RequestDirect(session: http2.ClientHttp2Session, url: string, init?: RequestInit): Promise<Response>;

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

@@ -0,0 +1,38 @@
+import type http2 from "http2";
+/**
+ * Singleton H2 session pool keyed by edge domain.
+ *
+ * - `warm(domain)` starts a background connection (fire-and-forget).
+ * - `get(domain)` returns a live session immediately if cached, or awaits
+ *   an in-flight warming, or establishes a fresh one.
+ * - Closed / destroyed sessions are automatically evicted.
+ */
+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.
+     */
+    private establish;
+    /**
+     * Fire-and-forget background warming. Safe to call multiple times for
+     * the same domain — only one connection attempt per domain at a time.
+     */
+    warm(domain: string): void;
+    /**
+     * Synchronous cache check. Returns a live cached session or `null`.
+     * Never blocks, never establishes — use for non-blocking fast paths.
+     */
+    tryGet(domain: string): http2.ClientHttp2Session | null;
+    /**
+     * Get a live H2 session for `domain`. Returns immediately from cache,
+     * joins an in-flight warming, or starts a new one.
+     */
+    get(domain: string): Promise<http2.ClientHttp2Session | null>;
+    /** Close all sessions (for cleanup). */
+    closeAll(): void;
+}
+export declare const h2Pool: H2Pool;
+export {};

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

@@ -0,0 +1,2 @@
+import http2 from "http2";
+export declare function establishH2(sniHostname: string): Promise<http2.ClientHttp2Session>;

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

@@ -1,3 +1,4 @@
+import { type Client } from "@hey-api/client-fetch";
 import { SandboxConfiguration } from "./types.js";
 export declare class ResponseError extends Error {
     response: Response;
@@ -7,12 +8,18 @@ export declare class ResponseError extends Error {
 }
 export declare class SandboxAction {
     protected sandbox: SandboxConfiguration;
+    private _h2Client;
     constructor(sandbox: SandboxConfiguration);
     get name(): string;
     get fallbackUrl(): string | null;
     get externalUrl(): string;
     get internalUrl(): string;
-    get client(): import("@hey-api/client-fetch").Client;
+    get client(): Client;
+    /**
+     * Routes through the H2 session when available, falling back to
+     * globalThis.fetch. Uses a direct H2 path that avoids Request allocation.
+     */
+    protected h2Fetch(input: string | URL, init?: RequestInit): Promise<Response>;
     get forcedUrl(): string | import("url").URL | null;
     get url(): string;
     handleResponseError(response: Response, data: unknown, error: unknown): void;

package/dist/cjs/types/sandbox/interpreter.d.ts

@@ -12,6 +12,7 @@ export declare class CodeInterpreter extends SandboxInstance {
         safe?: boolean;
     }): Promise<CodeInterpreter>;
     get _jupyterUrl(): string;
+    private _fetch;
     static OutputMessage: {
         new (text: string, timestamp: number | null, isStderr: boolean): {
             text: string;

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

@@ -18,12 +18,18 @@ export declare class SandboxInstance {
     codegen: SandboxCodegen;
     system: SandboxSystem;
     drives: SandboxDrive;
+    h2Session: any;
     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;
+    /**
+     * Warm and attach an H2 session based on the sandbox's region.
+     * Shared by create(), get(), list(), and update helpers.
+     */
+    private static attachH2Session;
     get expiresIn(): number | undefined;
     wait({ maxWait, interval }?: {
         maxWait?: number;

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

@@ -1,3 +1,4 @@
+import type http2 from "http2";
 import { Port, Sandbox, SandboxLifecycle, VolumeAttachment, SandboxNetwork } from "../client/types.gen";
 import { PostProcessResponse, ProcessRequest } from "./client";
 export interface SessionCreateOptions {
@@ -24,6 +25,7 @@ export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
+    h2Session?: http2.ClientHttp2Session | null;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;