@blaxel/core 0.3.1-preview.210 → 0.3.1-preview.212

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

@@ -28,8 +28,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.1-preview.210";
-const BUILD_COMMIT = "1cf2f890404700f7be699c0a1ef0cf137db7efcf";
+const BUILD_VERSION = "0.3.1-preview.212";
+const BUILD_COMMIT = "06b4bb451ef8797cbc2cd3e3a957d62c45f2cc12";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Cache for config.yaml tracking value

package/dist/cjs-browser/common/transient-retry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTransientResetError = isTransientResetError;
+exports.backoffDelayMs = backoffDelayMs;
 exports.retryOnTransientReset = retryOnTransientReset;
 const settings_js_1 = require("./settings.js");
 // Markers that, when present anywhere in the error chain, are unambiguous
@@ -107,7 +108,8 @@ const DEFAULT_MAX_DELAY_MS = 2000;
 // single wait never blocks unreasonably long. Exponential (rather than linear)
 // gives a later attempt room to span a multi-second sandbox cold-start/standby
 // wake, which is the window a first-call reset falls into, while early attempts
-// stay fast for the common quick-reset case.
+// stay fast for the common quick-reset case. Exported so other polling paths
+// (e.g. the create-504 wait in sandbox.ts) share the same delay curve.
 function backoffDelayMs(attempt, baseDelayMs, maxDelayMs) {
     const exponential = baseDelayMs * Math.pow(2, attempt - 1);
     const capped = Math.min(exponential, maxDelayMs);

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

@@ -37,6 +37,7 @@ exports.SandboxInstance = void 0;
 const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
+const transient_retry_js_1 = require("../common/transient-retry.js");
 const pagination_js_1 = require("../common/pagination.js");
 const settings_js_1 = require("../common/settings.js");
 const index_js_2 = require("./codegen/index.js");
@@ -67,6 +68,15 @@ const TRANSIENT_SANDBOX_STATUSES = new Set([
 ]);
 const TRANSIENT_STATUS_MAX_WAIT_MS = 30_000;
 const TRANSIENT_STATUS_POLL_MS = 500;
+// A create that outlives the edge's 60s origin-read timeout gets a 504 from
+// CloudFront while the control plane keeps deploying the sandbox for up to
+// 300s (ENG-3662 timeout ladder inversion). The 504 body is edge HTML with no
+// usable payload, so the record is polled instead until it settles.
+// Polling backs off exponentially (1s, 2s, 4s, then 5s + jitter) so a fleet of
+// clients stuck in this window does not hammer the control plane every second.
+const CREATE_GATEWAY_TIMEOUT_MAX_WAIT_MS = 120_000;
+const CREATE_GATEWAY_TIMEOUT_BASE_POLL_MS = 1_000;
+const CREATE_GATEWAY_TIMEOUT_MAX_POLL_MS = 5_000;
 const isSandboxNotFound = (e) => {
     if (typeof e !== "object" || e === null)
         return false;
@@ -241,14 +251,25 @@ class SandboxInstance {
         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([
+        const [createResult, h2Session] = await Promise.all([
             (0, index_js_1.createSandbox)({
                 body: sandbox,
                 query: createIfNotExist ? { createIfNotExist } : undefined,
-                throwOnError: true,
             }),
             edgeDomain && !settings_js_1.settings.disableH2 ? Promise.resolve().then(() => __importStar(require("../common/h2pool.js"))).then(({ h2Pool }) => h2Pool.get(edgeDomain)).catch(() => null) : Promise.resolve(null),
         ]);
+        let data = createResult.data;
+        if (createResult.error !== undefined) {
+            const name = sandbox.metadata.name;
+            if (createResult.response.status === 504 && name) {
+                // The edge gave up on the connection but the creation is still running
+                // server-side; wait for the record instead of failing (ENG-3662).
+                data = await SandboxInstance.waitAfterCreateGatewayTimeout(name, createResult.error);
+            }
+            else {
+                throw createResult.error;
+            }
+        }
         // Inject the H2 session into the config so subsystems can use it
         const config = { ...data, h2Session, h2Domain: settings_js_1.settings.disableH2 ? null : edgeDomain };
         const instance = new SandboxInstance(config);
@@ -388,6 +409,12 @@ class SandboxInstance {
     static async createIfNotExists(sandbox) {
         const ATTEMPTS = 3;
         let lastStatus = "unknown";
+        // The 'vanished' window (create 409s while get 404s) is driven by the same
+        // transient causes as 'dying': an in-flight delete finishing, or a
+        // concurrent create whose row is not readable yet. Give it the same time
+        // budget as waitWhileSandboxDying instead of burning the attempt budget
+        // 500ms apart (~1s total), which threw on deletes taking >1s (ENG-3667).
+        const vanishedDeadline = Date.now() + TRANSIENT_STATUS_MAX_WAIT_MS;
         for (let i = 0; i < ATTEMPTS; ++i) {
             const finalAttempt = i === ATTEMPTS - 1;
             try {
@@ -399,6 +426,12 @@ class SandboxInstance {
                     if (!name) {
                         throw new Error("Sandbox name is required");
                     }
+                    // The controlplane tags the creation-lock 409 with
+                    // reason=CREATION_IN_PROGRESS when the conflict comes from a
+                    // concurrent create still in flight (ENG-3776). The field is absent
+                    // on older controlplanes and on real row conflicts, so it only
+                    // sharpens the give-up error; the polling behavior is the same.
+                    const creationInProgress = e.reason === "CREATION_IN_PROGRESS";
                     // Get the existing sandbox to check its status
                     let sandboxInstance;
                     try {
@@ -406,10 +439,14 @@ class SandboxInstance {
                     }
                     catch (getError) {
                         if (isSandboxNotFound(getError)) {
-                            // The record vanished between the create conflict and this status check
-                            // (its deletion just finished); give the control plane a beat and retry.
-                            lastStatus = "vanished";
-                            if (!finalAttempt) {
+                            // The record vanished between the create conflict and this status check.
+                            lastStatus = creationInProgress ? "creation in progress" : "vanished";
+                            if (Date.now() < vanishedDeadline) {
+                                // Inside the transient window: poll without consuming attempts.
+                                await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
+                                --i;
+                            }
+                            else if (!finalAttempt) {
                                 await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
                             }
                             continue;
@@ -435,6 +472,35 @@ class SandboxInstance {
         }
         throw new Error(`Unable to create sandbox after ${ATTEMPTS} attempts. Last conflicting status: ${lastStatus}.`);
     }
+    // Poll the record after a create was cut by the edge with a 504 while the
+    // control plane is still deploying it. Resolves with the sandbox once it
+    // reaches DEPLOYED; throws on FAILED or once the wait budget is spent.
+    static async waitAfterCreateGatewayTimeout(name, createError) {
+        logger_js_1.logger.debug(`Sandbox ${name} creation timed out at the edge (504); polling the record while it finishes deploying`);
+        const deadline = Date.now() + CREATE_GATEWAY_TIMEOUT_MAX_WAIT_MS;
+        let attempt = 0;
+        while (Date.now() < deadline) {
+            attempt++;
+            await new Promise((resolve) => setTimeout(resolve, (0, transient_retry_js_1.backoffDelayMs)(attempt, CREATE_GATEWAY_TIMEOUT_BASE_POLL_MS, CREATE_GATEWAY_TIMEOUT_MAX_POLL_MS)));
+            let current;
+            try {
+                const { data } = await (0, index_js_1.getSandbox)({ path: { sandboxName: name }, throwOnError: true });
+                current = data;
+            }
+            catch (e) {
+                // The record can lag behind the accepted create; keep waiting on 404.
+                if (isSandboxNotFound(e))
+                    continue;
+                throw e;
+            }
+            if (current.status === "DEPLOYED")
+                return current;
+            if (current.status === "FAILED") {
+                throw new Error(`Sandbox ${name} failed to deploy after the create timed out at the edge (504).`);
+            }
+        }
+        throw createError;
+    }
     // Poll the record until an in-flight delete/deactivation settles (or the record
     // disappears), bounded by TRANSIENT_STATUS_MAX_WAIT_MS. Errors from get (e.g. 404
     // once the record is gone) end the wait: the caller's create retry decides next.

package/dist/cjs-browser/types/common/transient-retry.d.ts

@@ -11,6 +11,7 @@
  * identically.
  */
 export declare function isTransientResetError(error: unknown): boolean;
+export declare function backoffDelayMs(attempt: number, baseDelayMs: number, maxDelayMs: number): number;
 export type RetryOptions = {
     retries?: number;
     baseDelayMs?: number;

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

@@ -97,6 +97,7 @@ export declare class SandboxInstance {
     static updateLifecycle(sandboxName: string, lifecycle: SandboxLifecycle | null): Promise<SandboxInstance>;
     static updateNetwork(sandboxName: string, network: SandboxUpdateNetwork): Promise<SandboxInstance>;
     static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    private static waitAfterCreateGatewayTimeout;
     private static waitWhileSandboxDying;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }