@blaxel/core 0.2.80-preview.138 → 0.2.80-preview.140

package/dist/esm/client/interceptors.js

@@ -1,7 +1,36 @@
+import { ensureAutoloaded } from "../common/lazyInit.js";
 import { settings } from "../common/settings.js";
+// Default baseUrl baked into the generated control-plane client. Requests
+// carrying this prefix came from the module-load client config, before
+// `ensureAutoloaded()` had a chance to resolve the real env from
+// `~/.blaxel/config.yaml`.
+const DEFAULT_CONTROLPLANE_BASE_URL = "https://api.blaxel.ai/v0";
 export const interceptors = [
     // Authentication interceptor
     async (request, options) => {
+        // Trigger deferred autoload side-effects (lazy credential resolution,
+        // client baseUrl sync, Sentry init, H2 warming) on the first actual SDK
+        // use, rather than at module-import time.
+        ensureAutoloaded();
+        // If lazy env resolution just moved the effective baseUrl off the
+        // module-load default (e.g. a user with `env: dev` in config.yaml but
+        // no BL_ENV env var), the very first request was built against the
+        // stale prod URL. Rebase it to the correct environment. Subsequent
+        // requests use the updated `client.setConfig()` applied in
+        // `ensureAutoloaded()`, so this branch only fires once.
+        //
+        // This must happen before the `authenticated === false` early return:
+        // the OAuth token request issued by `ClientCredentials.authenticate()`
+        // itself is unauthenticated, and if the user calls `authenticate()`
+        // before any other SDK call it is the very first request and also
+        // needs to be rebased to the correct environment.
+        const correctBase = settings.baseUrl;
+        if (correctBase !== DEFAULT_CONTROLPLANE_BASE_URL &&
+            request.url.startsWith(DEFAULT_CONTROLPLANE_BASE_URL)) {
+            const newUrl = correctBase.replace(/\/$/, "") +
+                request.url.slice(DEFAULT_CONTROLPLANE_BASE_URL.length);
+            request = new Request(newUrl, request);
+        }
         if (options.authenticated === false) {
             return request;
         }

package/dist/esm/common/autoload.js

@@ -2,8 +2,8 @@ import { client } from "../client/client.gen.js";
 import { interceptors } from "../client/interceptors.js";
 import { responseInterceptors } from "../client/responseInterceptor.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
-import { initSentry } from "./sentry.js";
 import { settings } from "./settings.js";
+export { ensureAutoloaded } from "./lazyInit.js";
 client.setConfig({
     baseUrl: settings.baseUrl,
 });
@@ -19,34 +19,15 @@ for (const interceptor of responseInterceptors) {
     client.interceptors.response.use(interceptor);
     clientSandbox.interceptors.response.use(interceptor);
 }
-// Initialize Sentry for SDK error tracking immediately when module loads
-initSentry();
-// Background H2 connection warming (Node.js only)
-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) {
-    try {
-        // Pre-warm edge H2 for the configured region so the first
-        // SandboxInstance.create() gets an instant session via the pool.
-        // The control-plane client (api.blaxel.ai) stays on regular fetch
-        // which already benefits from undici's built-in connection pooling.
-        const region = settings.region;
-        if (region) {
-            import("./h2pool.js").then(({ h2Pool }) => {
-                const edgeSuffix = settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
-                h2Pool.warm(`any.${region}.${edgeSuffix}`);
-            }).catch(() => { });
-        }
-    }
-    catch {
-        // Silently ignore warming failures
-    }
-}
 /**
  * Configure the SDK programmatically at runtime, instead of relying on
  * environment variables or config files.
  *
+ * You do not need to call {@link authenticate} yourself: the SDK
+ * transparently authenticates (and refreshes tokens when needed) on every
+ * request. Only call `authenticate()` directly if you want to fail fast on
+ * invalid credentials before making any API call.
+ *
  * @example
  * // With an API key
  * initialize({ workspace: 'my-workspace', apiKey: 'bl_...' });
@@ -57,7 +38,6 @@ if (isNode && !isBrowser) {
  *   workspace: 'my-workspace',
  *   clientCredentials: { clientId: '...', clientSecret: '...' },
  * });
- * await authenticate();
  *
  * @example
  * // With client credentials (pre-encoded Base64 string)
@@ -65,7 +45,6 @@ if (isNode && !isBrowser) {
  *   workspace: 'my-workspace',
  *   clientCredentials: 'base64-encoded-string',
  * });
- * await authenticate();
  */
 export function initialize(config) {
     settings.setConfig(config);

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/lazyInit.js

@@ -0,0 +1,62 @@
+import { client } from "../client/client.gen.js";
+import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { initSentry } from "./sentry.js";
+import { settings } from "./settings.js";
+let autoloaded = false;
+/**
+ * Perform the observable side-effects that the SDK needs for error
+ * reporting, low-latency sandbox sessions, and correct environment
+ * routing:
+ *
+ *   - Resolve credentials (which reads `~/.blaxel/config.yaml` once and
+ *     populates `BL_ENV` if the user has a dev workspace configured).
+ *   - Re-apply the control-plane and sandbox clients' `baseUrl` so they
+ *     target the now-env-aware endpoint.
+ *   - Initialize the lightweight Sentry client (registers
+ *     `uncaughtExceptionMonitor` and patches `console.error` in Node).
+ *   - Pre-warm the edge H2 connection pool for `settings.region`.
+ *
+ * These used to run at module load, but that meant `import "@blaxel/core"`
+ * alone had observable side-effects. They are now deferred until the SDK
+ * is first actually used — the request interceptor calls this on the
+ * first HTTP request.
+ */
+export function ensureAutoloaded() {
+    if (autoloaded)
+        return;
+    autoloaded = true;
+    // Trigger lazy credential resolution. This may read `~/.blaxel/config.yaml`
+    // and set `process.env.BL_ENV` if the user has a dev workspace configured,
+    // which in turn affects `settings.baseUrl`.
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    settings.credentials;
+    // Keep the clients' baseUrl in sync with the now-resolved env. Without
+    // this, the module-load `client.setConfig({ baseUrl })` would be stuck on
+    // the prod default for users who rely on `config.yaml` (no env vars).
+    client.setConfig({ baseUrl: settings.baseUrl });
+    clientSandbox.setConfig({ baseUrl: settings.baseUrl });
+    // Initialize Sentry for SDK error tracking.
+    initSentry();
+    // Background H2 connection warming (Node.js only)
+    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) {
+        try {
+            // Pre-warm edge H2 for the configured region so the first
+            // SandboxInstance.create() gets an instant session via the pool.
+            // The control-plane client (api.blaxel.ai) stays on regular fetch
+            // which already benefits from undici's built-in connection pooling.
+            const region = settings.region;
+            if (region) {
+                import("./h2pool.js").then(({ h2Pool }) => {
+                    const edgeSuffix = settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+                    h2Pool.warm(`any.${region}.${edgeSuffix}`);
+                }).catch(() => { });
+            }
+        }
+        catch {
+            // Silently ignore warming failures
+        }
+    }
+}

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.138";
-const BUILD_COMMIT = "a58f8cc475d6ca3147ed31106d71a68e504c55a0";
+const BUILD_VERSION = "0.2.80-preview.140";
+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;
@@ -66,20 +66,32 @@ function getOsArch() {
     return "browser/unknown";
 }
 class Settings {
-    credentials;
+    _credentials;
     config;
     constructor() {
-        this.credentials = authentication();
+        // `credentials` are resolved lazily on first access so that simply
+        // importing `@blaxel/core` does not read `~/.blaxel/config.yaml`
+        // or mutate `process.env.BL_ENV`. See the `credentials` getter.
+        this._credentials = null;
         this.config = {
             proxy: "",
             apikey: "",
             workspace: "",
         };
     }
+    get credentials() {
+        if (this._credentials === null) {
+            this._credentials = authentication();
+        }
+        return this._credentials;
+    }
+    set credentials(value) {
+        this._credentials = value;
+    }
     setConfig(config) {
         this.config = config;
         if (config.apiKey) {
-            this.credentials = new ApiKey({
+            this._credentials = new ApiKey({
                 apiKey: config.apiKey,
                 workspace: config.workspace,
             });
@@ -88,7 +100,7 @@ class Settings {
             const encoded = typeof config.clientCredentials === 'string'
                 ? config.clientCredentials
                 : btoa(`${config.clientCredentials.clientId}:${config.clientCredentials.clientSecret}`);
-            this.credentials = new ClientCredentials({
+            this._credentials = new ClientCredentials({
                 clientCredentials: encoded,
                 workspace: config.workspace,
             });