@blaxel/core 0.2.85 → 0.2.86-preview.161

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.85";
-const BUILD_COMMIT = "a9c088b49239125f1b129fbc95d1887556112a33";
+const BUILD_VERSION = "0.2.86-preview.161";
+const BUILD_COMMIT = "a5bdac720290868983bb67563ff7068c1cf8c67f";
 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
@@ -232,6 +232,32 @@ class Settings {
         }
         return isDenoRuntime();
     }
+    get maxConcurrentH2Requests() {
+        if (typeof this.config.maxConcurrentH2Requests === "number") {
+            return this.config.maxConcurrentH2Requests;
+        }
+        const value = env_js_1.env.BL_MAX_H2_INFLIGHT;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        return 0;
+    }
+    get fsPartRetries() {
+        if (typeof this.config.fsPartRetries === "number") {
+            return this.config.fsPartRetries;
+        }
+        const value = env_js_1.env.BL_FS_PART_RETRIES;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        return 0;
+    }
     async authenticate() {
         await this.credentials.authenticate();
     }

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

@@ -9,6 +9,94 @@ const index_js_1 = require("../client/index.js");
 const MULTIPART_THRESHOLD = 5 * 1024 * 1024; // 5MB
 const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB per part
 const MAX_PARALLEL_UPLOADS = 3; // Number of parallel part uploads
+// Base backoff between part-upload retries, in milliseconds. Grows linearly
+// per attempt and is jittered to avoid synchronized retries (thundering herd)
+// when several parallel parts fail against the same edge at the same time.
+const RETRY_BASE_DELAY_MS = 200;
+// Markers that, when present anywhere in the error chain, are unambiguous
+// signals of a transient HTTP/2 stream reset or connection drop. These are
+// protocol/transport level codes, not application payloads, so substring
+// matching them does not over-match a server-sent error body. Each entry is
+// matched case-sensitively against the error message and its cause.
+//
+// Deliberately excluded: bare "INTERNAL_ERROR" and "fetch failed". Both are
+// too generic on their own (an application 500 body or any failed fetch would
+// match), so we only treat them as transient when paired with a transport
+// error code on the cause (see isTransientUploadError).
+const TRANSIENT_RESET_MARKERS = [
+    "ENHANCE_YOUR_CALM", // H2 flow-control backpressure reset
+    "NGHTTP2_INTERNAL_ERROR", // H2 internal stream error (qualified form)
+    "ERR_HTTP2", // node http2 error code family
+    "GOAWAY", // peer is draining the connection
+    "HTTP/2 session closed before response", // thrown by our own h2 transport
+    "HTTP/2 session sent GOAWAY before response",
+];
+// Node-level error codes (from `error.code` / `error.cause.code`) that mean
+// the connection itself dropped mid-flight and the request never completed.
+// These are safe to retry for an idempotent part upload.
+const TRANSIENT_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "EPIPE",
+    "ERR_HTTP2_STREAM_ERROR",
+    "ERR_HTTP2_GOAWAY_SESSION",
+    "ERR_HTTP2_SESSION_ERROR",
+]);
+function collectErrorText(error) {
+    const messages = [];
+    const codes = [];
+    // Walk the error -> cause chain (bounded) so a transport error wrapped by a
+    // higher-level "fetch failed" is still classified correctly.
+    let current = error;
+    for (let depth = 0; depth < 5 && current && typeof current === "object"; depth++) {
+        const node = current;
+        if (typeof node.message === "string")
+            messages.push(node.message);
+        if (typeof node.code === "string")
+            codes.push(node.code);
+        current = node.cause;
+    }
+    return { messages, codes };
+}
+function isTransientUploadError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const { messages, codes } = collectErrorText(error);
+    // 1. An explicit transient transport error code anywhere in the chain.
+    if (codes.some((code) => TRANSIENT_ERROR_CODES.has(code))) {
+        return true;
+    }
+    // 2. An unambiguous protocol-level reset marker in any message.
+    if (messages.some((text) => TRANSIENT_RESET_MARKERS.some((marker) => text.includes(marker)))) {
+        return true;
+    }
+    return false;
+}
+function nextRetryDelayMs(attempt) {
+    // Linear backoff (200ms, 400ms, ...) plus up to one extra base delay of
+    // random jitter so concurrent part retries do not all fire on the same tick.
+    const base = RETRY_BASE_DELAY_MS * attempt;
+    const jitter = Math.floor(Math.random() * RETRY_BASE_DELAY_MS);
+    return base + jitter;
+}
+async function retryOnTransient(fn) {
+    const retries = settings_js_1.settings.fsPartRetries; // 0 = off (current default behavior)
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            attempt++;
+            if (retries <= 0 || attempt > retries || !isTransientUploadError(error)) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, nextRetryDelayMs(attempt)));
+        }
+    }
+}
 class SandboxFileSystem extends action_js_1.SandboxAction {
     process;
     constructor(sandbox, process) {
@@ -426,7 +514,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
                     const start = (partNumber - 1) * CHUNK_SIZE;
                     const end = Math.min(start + CHUNK_SIZE, size);
                     const chunk = blob.slice(start, end);
-                    batch.push(this.uploadPart(uploadId, partNumber, chunk));
+                    batch.push(retryOnTransient(() => this.uploadPart(uploadId, partNumber, chunk)));
                 }
                 // Wait for batch to complete
                 const batchResults = await Promise.all(batch);

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

@@ -12,6 +12,16 @@ export type Config = {
     apikey?: string;
     workspace?: string;
     disableH2?: boolean;
+    /**
+     * Maximum number of concurrent in-flight HTTP/2 requests across the shared
+     * H2 session pool. `0` or `undefined` means unlimited (current behavior).
+     */
+    maxConcurrentH2Requests?: number;
+    /**
+     * Number of retry attempts for transient resets on multipart part uploads.
+     * `0` or `undefined` disables retry (current behavior).
+     */
+    fsPartRetries?: number;
     /**
      * Client credentials for OAuth2 client_credentials flow.
      *
@@ -51,6 +61,8 @@ declare class Settings {
     get tracking(): boolean;
     get region(): string | undefined;
     get disableH2(): boolean;
+    get maxConcurrentH2Requests(): number;
+    get fsPartRetries(): number;
     authenticate(): Promise<void>;
 }
 export declare const settings: Settings;