@blaxel/core 0.3.13 → 0.3.18-dev.283

package/dist/esm/client/sdk.gen.js

@@ -1616,6 +1616,22 @@ export const updateSandbox = (options) => {
         }
     });
 };
+/**
+ * Archive sandbox
+ * Archives a sandbox. The changes its filesystem accumulated over its image are exported to the archive store, then the sandbox is shut down while its definition is kept, so it can be recreated later with the same disk. Memory and running processes are not preserved, processes are started again from their configuration when the sandbox is unarchived.
+ */
+export const archiveSandbox = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/sandboxes/{sandboxName}/archive',
+        ...options
+    });
+};
 /**
  * Fork sandbox
  * Forks a sandbox into a new sandbox or application. When forking to a sandbox, the target must not already exist (409 if it does). When forking to an application, a new revision is added if the app already exists, or a new application is created. This is a WIP endpoint — the full implementation depends on the execution plane.
@@ -1932,6 +1948,38 @@ export const deleteSandboxSnapshot = (options) => {
         ...options
     });
 };
+/**
+ * Restore sandbox from snapshot
+ * Restores a sandbox to one of its own snapshots. The running sandbox is torn down and rebuilt from the snapshot under the same name and URLs, so everything it held since the snapshot was taken is lost unless it was itself snapshotted.
+ */
+export const restoreSandboxSnapshot = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/sandboxes/{sandboxName}/snapshots/{snapshotId}/restore',
+        ...options
+    });
+};
+/**
+ * Unarchive sandbox
+ * Recreates an archived sandbox from its archive. The recreated sandbox runs the current generation whatever generation it was archived from, restores the archived filesystem before anything starts, and starts the saved processes again with new process identifiers.
+ */
+export const unarchiveSandbox = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/sandboxes/{sandboxName}/unarchive',
+        ...options
+    });
+};
 /**
  * Get sandbox by external ID
  * Returns the most recent non-terminated sandbox matching the given external ID. If no active sandbox is found, returns 404.
@@ -1948,6 +1996,54 @@ export const getSandboxByExternalId = (options) => {
         ...options
     });
 };
+/**
+ * List Workspace Schedule Executions
+ * Returns schedule execution submissions across the workspace, newest first by default. Status describes submission acceptance, not process completion. since and until are inclusive RFC 3339 bounds on creation time.
+ */
+export const listScheduleExecutions = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/schedule-executions',
+        ...options
+    });
+};
+/**
+ * List Workspace Schedules
+ * Returns schedule definitions across the workspace, newest first by default.
+ */
+export const listSchedules = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/schedules',
+        ...options
+    });
+};
+/**
+ * Get Sandbox Scheduling Metrics
+ * Returns active sandbox and scheduling metrics for a UTC minute window. since is inclusive and until is exclusive. The default window is the last 24 hours and the maximum is 7 days. Execution status describes submission acceptance, not process completion. Execution totals begin accumulating when metrics collection is enabled and can lag recent firings briefly.
+ */
+export const getSandboxScheduleMetrics = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/schedules/metrics',
+        ...options
+    });
+};
 /**
  * List service accounts
  * Returns all service accounts in the workspace. Service accounts are machine identities for external systems to authenticate with Blaxel via OAuth or API keys.

package/dist/esm/common/settings.js

@@ -24,8 +24,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.13";
-const BUILD_COMMIT = "615fb5551f22447c530bcaef346d68dc79590758";
+const BUILD_VERSION = "0.3.18-dev.283";
+const BUILD_COMMIT = "fed607fe45d4a15407e77f7c40f31815d763df5a";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2
@@ -94,6 +94,11 @@ function getOsArch() {
     }
     return "browser/unknown";
 }
+/**
+ * An integration built on this SDK identifies itself with one User-Agent
+ * product token: `<name>/<semver>`, lowercase name.
+ */
+const INTEGRATION_TOKEN_PATTERN = /^[a-z0-9][a-z0-9._-]*\/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 class Settings {
     _credentials;
     config;
@@ -190,14 +195,34 @@ class Settings {
     get apiVersion() {
         return env.BL_API_VERSION || BLAXEL_API_VERSION;
     }
+    /**
+     * Product token identifying the integration built on this SDK, or `""`.
+     * Resolved from `config.integration`, then `BL_INTEGRATION`. See `Config.integration`.
+     */
+    get integration() {
+        const value = this.config.integration ?? env.BL_INTEGRATION ?? "";
+        if (!value) {
+            return "";
+        }
+        if (!INTEGRATION_TOKEN_PATTERN.test(value)) {
+            logger.warn(`Ignoring invalid Blaxel integration token "${value}": expected <name>/<semver> with a lowercase name`);
+            return "";
+        }
+        return value;
+    }
+    set integration(value) {
+        this.config.integration = value;
+    }
     get headers() {
         this.assertCredentials();
         const osArch = getOsArch();
+        const sdkUserAgent = `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${this.commit}`;
+        const integration = this.integration;
         return {
             "x-blaxel-authorization": this.authorization,
             "x-blaxel-workspace": this.workspace || "",
             "Blaxel-Version": this.apiVersion,
-            "User-Agent": `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${this.commit}`,
+            "User-Agent": integration ? `${sdkUserAgent} ${integration}` : sdkUserAgent,
         };
     }
     get name() {

package/dist/esm/common/settings.test.js

@@ -216,3 +216,53 @@ describe('Settings H2 tuning knobs (config > env > default)', () => {
         });
     });
 });
+describe('Settings.integration', () => {
+    const sdkUserAgent = /^blaxel\/sdk\/typescript\/\S+ \([^)]+\) blaxel\/\S+/;
+    async function authenticated() {
+        const { settings } = await import('./settings.js');
+        settings.credentials = new ApiKey({ apiKey: 'test-key', workspace: 'test-ws' });
+        delete settings.config.integration;
+        delete process.env.BL_INTEGRATION;
+        return settings;
+    }
+    afterEach(async () => {
+        const { settings } = await import('./settings.js');
+        delete settings.config.integration;
+        delete process.env.BL_INTEGRATION;
+    });
+    it('sends the plain SDK User-Agent by default', async () => {
+        const settings = await authenticated();
+        expect(settings.integration).toBe('');
+        expect(settings.headers['User-Agent']).toMatch(new RegExp(sdkUserAgent.source + '$'));
+    });
+    it('appends the token set programmatically, once', async () => {
+        const settings = await authenticated();
+        settings.integration = 'deepseek-harness-blaxel-sandbox/0.1.2';
+        const userAgent = settings.headers['User-Agent'];
+        expect(userAgent).toMatch(sdkUserAgent);
+        expect(userAgent.endsWith(' deepseek-harness-blaxel-sandbox/0.1.2')).toBe(true);
+        expect(userAgent.split('deepseek-harness-blaxel-sandbox').length).toBe(2);
+    });
+    it('reads BL_INTEGRATION when nothing is set programmatically, and config wins', async () => {
+        const settings = await authenticated();
+        process.env.BL_INTEGRATION = 'herdr/1.4.0-rc.1';
+        expect(settings.headers['User-Agent'].endsWith(' herdr/1.4.0-rc.1')).toBe(true);
+        settings.setConfig({ ...settings.config, integration: 'deepseek-harness-blaxel-sandbox/0.1.2' });
+        expect(settings.headers['User-Agent'].endsWith(' deepseek-harness-blaxel-sandbox/0.1.2')).toBe(true);
+    });
+    it.each(['Deepseek/0.1.2', 'deepseek-harness', 'deepseek/0.1', 'a/1.0.0 b/1.0.0', 'deepseek/0.1.2 (extra)', ' x/1.0.0'])('ignores the invalid token %j', async (value) => {
+        const settings = await authenticated();
+        settings.integration = value;
+        expect(settings.integration).toBe('');
+        expect(settings.headers['User-Agent']).toMatch(new RegExp(sdkUserAgent.source + '$'));
+    });
+    it('changes no header other than User-Agent', async () => {
+        const settings = await authenticated();
+        const plain = { ...settings.headers };
+        settings.integration = 'deepseek-harness-blaxel-sandbox/0.1.2';
+        const tagged = { ...settings.headers };
+        delete plain['User-Agent'];
+        delete tagged['User-Agent'];
+        expect(tagged).toEqual(plain);
+    });
+});

package/dist/esm/common/shell.js

@@ -0,0 +1,15 @@
+/**
+ * Quote a string so a POSIX shell reads it as one literal argument.
+ *
+ * The sandbox process API accepts a single command string, which the server
+ * runs as `sh -c <command>`. Any value interpolated into that string is parsed
+ * by the shell, so an unquoted path containing `;`, `|`, `&&`, `$()`, backticks
+ * or `>` would execute as its own command. Single quotes suppress every form of
+ * shell expansion; the only character they cannot contain is a single quote
+ * itself, which is closed, escaped, and reopened.
+ *
+ * This is the TypeScript equivalent of Python's `shlex.quote`.
+ */
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/esm/sandbox/filesystem/filesystem.js

@@ -2,12 +2,13 @@ import { fs } from "../../common/node.js";
 import { settings } from "../../common/settings.js";
 import { withUploadSlot } from "../../common/h2fetch.js";
 import { isTransientResetError, retryOnTransientReset } from "../../common/transient-retry.js";
+import { shellQuote } from "../../common/shell.js";
 import { SandboxAction } from "../action.js";
 import { deleteFilesystemByPath, deleteFilesystemMultipartByUploadIdAbort, getFilesystemByPath, getFilesystemContentSearchByPath, getFilesystemFindByPath, getFilesystemSearchByPath, getWatchFilesystemByPath, postFilesystemMultipartByUploadIdComplete, postFilesystemMultipartInitiateByPath, putFilesystemByPath, putFilesystemMultipartByUploadIdPart } from "../client/index.js";
 // Multipart upload constants
 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
+const MAX_PARALLEL_UPLOADS = 3; // Maximum workers when the H2 upload cap is disabled
 // The transient-reset classifier and retry loop live in
 // common/transient-retry.ts, shared with the idempotent sandbox-op retry
 // (read/list/etc.) so every path judges "transient" identically. These aliases
@@ -343,8 +344,10 @@ export class SandboxFileSystem extends SandboxAction {
         });
     }
     async cp(source, destination, { maxWait = 180000 } = {}) {
+        // Quote both paths so the shell that runs this command treats them as
+        // single literal arguments instead of interpreting metacharacters in them.
         let process = await this.process.exec({
-            command: `cp -r ${source} ${destination}`,
+            command: `cp -r ${shellQuote(source)} ${shellQuote(destination)}`,
         });
         process = await this.process.wait(process.pid, { maxWait, interval: 100 });
         if (process.status === "failed") {
@@ -498,11 +501,19 @@ export class SandboxFileSystem extends SandboxAction {
             // no h2Domain the parts go over globalThis.fetch on separate connections,
             // so the shared-connection cap does not apply.
             const h2Domain = this.sandbox?.h2Domain;
-            // Upload parts in batches for parallel processing
-            for (let i = 0; i < numParts; i += MAX_PARALLEL_UPLOADS) {
-                const batch = [];
-                for (let j = 0; j < MAX_PARALLEL_UPLOADS && i + j < numParts; j++) {
-                    const partNumber = i + j + 1;
+            // Keep a bounded worker queue full instead of waiting at fixed batch
+            // boundaries. The upload gate remains authoritative across files; its
+            // default of 2 also bounds this queue on H2.
+            const h2UploadLimit = h2Domain ? settings.maxConcurrentUploadH2Requests : 0;
+            const workerCount = Math.min(numParts, h2UploadLimit > 0 ? Math.min(MAX_PARALLEL_UPLOADS, h2UploadLimit) : MAX_PARALLEL_UPLOADS);
+            let nextPartNumber = 1;
+            let stopped = false;
+            let uploadError;
+            const uploadNextPart = async () => {
+                while (!stopped) {
+                    const partNumber = nextPartNumber++;
+                    if (partNumber > numParts)
+                        return;
                     const start = (partNumber - 1) * CHUNK_SIZE;
                     const end = Math.min(start + CHUNK_SIZE, size);
                     const chunk = blob.slice(start, end);
@@ -510,11 +521,20 @@ export class SandboxFileSystem extends SandboxAction {
                     // concurrent part streams, not retry sequences; freed during backoff.
                     const doPart = () => this.uploadPart(uploadId, partNumber, chunk);
                     const partWithSlot = h2Domain ? () => withUploadSlot(h2Domain, doPart) : doPart;
-                    batch.push(retryOnTransient(partWithSlot));
+                    try {
+                        parts.push(await retryOnTransient(partWithSlot));
+                    }
+                    catch (error) {
+                        if (!stopped) {
+                            stopped = true;
+                            uploadError = error;
+                        }
+                    }
                 }
-                // Wait for batch to complete
-                const batchResults = await Promise.all(batch);
-                parts.push(...batchResults);
+            };
+            await Promise.all(Array.from({ length: workerCount }, () => uploadNextPart()));
+            if (stopped) {
+                throw uploadError;
             }
             // Sort parts by partNumber to ensure correct order
             parts.sort((a, b) => (a.partNumber ?? 0) - (b.partNumber ?? 0));

package/dist/esm/sandbox/filesystem/filesystem.test.js

@@ -1,9 +1,61 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { settings } from "../../common/settings.js";
 import { SandboxFileSystem } from "./filesystem.js";
 const waitForPartUpload = () => new Promise((resolve) => setTimeout(resolve, 5));
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
 describe("SandboxFileSystem multipart upload", () => {
-    it("limits concurrent part uploads", async () => {
+    afterEach(() => {
+        delete settings.config.maxConcurrentUploadH2Requests;
+        delete settings.config.fsPartRetries;
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    it("keeps an H2 upload slot busy across former batch boundaries for 100 MiB", async () => {
+        settings.config.maxConcurrentUploadH2Requests = 2;
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        filesystem.sandbox = { h2Domain: "eng-3585.test" };
+        const started = [deferred(), deferred(), deferred(), deferred()];
+        const release = [deferred(), deferred(), deferred(), deferred()];
+        let completedParts = [];
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-1" });
+        filesystem.uploadPart = async (_uploadId, partNumber) => {
+            if (partNumber <= 4) {
+                started[partNumber - 1].resolve();
+                await release[partNumber - 1].promise;
+            }
+            return { partNumber, etag: `etag-${partNumber}` };
+        };
+        filesystem.completeMultipartUpload = (_uploadId, parts) => {
+            completedParts = parts;
+            return Promise.resolve({ message: "ok" });
+        };
+        filesystem.abortMultipartUpload = () => Promise.resolve({ message: "aborted" });
+        const upload = filesystem.uploadWithMultipart("/tmp/large-file.bin", { size: 100 * 1024 * 1024, slice: () => ({}) });
+        await Promise.all([started[0].promise, started[1].promise]);
+        release[0].resolve();
+        await started[2].promise;
+        release[2].resolve();
+        const crossedBatchBoundary = await Promise.race([
+            started[3].promise.then(() => true),
+            new Promise((resolve) => setTimeout(() => resolve(false), 25)),
+        ]);
+        release[1].resolve();
+        await started[3].promise;
+        release[3].resolve();
+        await upload;
+        expect(crossedBatchBoundary).toBe(true);
+        expect(completedParts).toHaveLength(20);
+    });
+    it("limits concurrent H2 part uploads to the existing cap", async () => {
+        settings.config.maxConcurrentUploadH2Requests = 2;
         const filesystem = Object.create(SandboxFileSystem.prototype);
+        filesystem.sandbox = { h2Domain: "concurrency.test" };
         let inFlight = 0;
         let maxInFlight = 0;
         const uploadedParts = [];
@@ -24,8 +76,161 @@ describe("SandboxFileSystem multipart upload", () => {
         filesystem.abortMultipartUpload = () => Promise.resolve({ message: "aborted" });
         const blob = new Blob([new Uint8Array(16 * 1024 * 1024)]);
         await filesystem.uploadWithMultipart("/tmp/large-file.bin", blob);
-        expect(maxInFlight).toBeLessThanOrEqual(3);
+        expect(maxInFlight).toBe(2);
         expect(uploadedParts.sort((a, b) => a - b)).toEqual([1, 2, 3, 4]);
         expect(completedParts.map((part) => part.partNumber)).toEqual([1, 2, 3, 4]);
     });
+    it("uploads every byte exactly once across chunk boundaries", async () => {
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        const partSize = 5 * 1024 * 1024;
+        const source = new Uint8Array(partSize + 17);
+        for (let index = 0; index < source.length; index++) {
+            source[index] = index % 251;
+        }
+        const uploadedChunks = new Map();
+        let completedParts = [];
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-bytes" });
+        filesystem.uploadPart = async (_uploadId, partNumber, fileBlob) => {
+            uploadedChunks.set(partNumber, new Uint8Array(await fileBlob.arrayBuffer()));
+            return { partNumber, etag: `etag-${partNumber}` };
+        };
+        filesystem.completeMultipartUpload = (_uploadId, parts) => {
+            completedParts = parts;
+            return Promise.resolve({ message: "ok" });
+        };
+        filesystem.abortMultipartUpload = () => Promise.resolve({ message: "aborted" });
+        await filesystem.uploadWithMultipart("/tmp/bytes.bin", new Blob([source]));
+        const received = new Uint8Array(source.length);
+        let offset = 0;
+        for (const partNumber of [1, 2]) {
+            const chunk = uploadedChunks.get(partNumber);
+            expect(chunk).toBeDefined();
+            received.set(chunk, offset);
+            offset += chunk.length;
+        }
+        let mismatch = -1;
+        for (let index = 0; index < source.length; index++) {
+            if (received[index] !== source[index]) {
+                mismatch = index;
+                break;
+            }
+        }
+        expect([...uploadedChunks.values()].map((chunk) => chunk.length)).toEqual([partSize, 17]);
+        expect(offset).toBe(source.length);
+        expect(mismatch).toBe(-1);
+        expect(completedParts.map((part) => part.partNumber)).toEqual([1, 2]);
+    });
+    it("retries a transient part failure without duplicating completed parts", async () => {
+        vi.useFakeTimers();
+        vi.spyOn(Math, "random").mockReturnValue(0);
+        settings.config.fsPartRetries = 1;
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        const attempts = new Map();
+        let completedParts = [];
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-retry" });
+        filesystem.uploadPart = (_uploadId, partNumber) => {
+            const attempt = (attempts.get(partNumber) ?? 0) + 1;
+            attempts.set(partNumber, attempt);
+            if (partNumber === 1 && attempt === 1) {
+                return Promise.reject(Object.assign(new Error("connection reset"), { code: "ECONNRESET" }));
+            }
+            return Promise.resolve({ partNumber, etag: `etag-${partNumber}` });
+        };
+        filesystem.completeMultipartUpload = (_uploadId, parts) => {
+            completedParts = parts;
+            return Promise.resolve({ message: "ok" });
+        };
+        filesystem.abortMultipartUpload = () => Promise.resolve({ message: "aborted" });
+        const upload = filesystem.uploadWithMultipart("/tmp/retry.bin", new Blob([new Uint8Array(6 * 1024 * 1024)]));
+        await vi.runAllTimersAsync();
+        await upload;
+        expect(Object.fromEntries(attempts)).toEqual({ 1: 2, 2: 1 });
+        expect(completedParts.map((part) => part.partNumber)).toEqual([1, 2]);
+    });
+    it("stops assigning queued parts after a part failure", async () => {
+        settings.config.maxConcurrentUploadH2Requests = 2;
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        filesystem.sandbox = { h2Domain: "cancellation.test" };
+        const releaseFirstPart = deferred();
+        const secondPartStarted = deferred();
+        const failure = new Error("part 2 failed");
+        const startedParts = [];
+        const events = [];
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-cancel" });
+        filesystem.uploadPart = async (_uploadId, partNumber) => {
+            startedParts.push(partNumber);
+            if (partNumber === 1) {
+                await releaseFirstPart.promise;
+                events.push("part-1-finished");
+                return { partNumber, etag: "etag-1" };
+            }
+            secondPartStarted.resolve();
+            events.push("part-2-failed");
+            throw failure;
+        };
+        filesystem.completeMultipartUpload = () => {
+            throw new Error("completion must not run");
+        };
+        filesystem.abortMultipartUpload = () => {
+            events.push("aborted");
+            return Promise.resolve({ message: "aborted" });
+        };
+        const upload = filesystem.uploadWithMultipart("/tmp/cancel.bin", new Blob([new Uint8Array(16 * 1024 * 1024)]));
+        await secondPartStarted.promise;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        releaseFirstPart.resolve();
+        await expect(upload).rejects.toBe(failure);
+        expect(startedParts).toEqual([1, 2]);
+        expect(events).toEqual(["part-2-failed", "part-1-finished", "aborted"]);
+    });
+    it("keeps sliced part data bounded by the active worker count", async () => {
+        settings.config.maxConcurrentUploadH2Requests = 2;
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        filesystem.sandbox = { h2Domain: "memory.test" };
+        let unsettledSlices = 0;
+        let maxUnsettledSlices = 0;
+        let totalSlices = 0;
+        const fakeBlob = {
+            size: 100 * 1024 * 1024,
+            slice(start, end) {
+                totalSlices += 1;
+                unsettledSlices += 1;
+                maxUnsettledSlices = Math.max(maxUnsettledSlices, unsettledSlices);
+                return { size: end - start };
+            },
+        };
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-memory" });
+        filesystem.uploadPart = async (_uploadId, partNumber) => {
+            await waitForPartUpload();
+            unsettledSlices -= 1;
+            return { partNumber, etag: `etag-${partNumber}` };
+        };
+        filesystem.completeMultipartUpload = () => Promise.resolve({ message: "ok" });
+        filesystem.abortMultipartUpload = () => Promise.resolve({ message: "aborted" });
+        await filesystem.uploadWithMultipart("/tmp/100mb.bin", fakeBlob);
+        expect(totalSlices).toBe(20);
+        expect(maxUnsettledSlices).toBe(2);
+        expect(unsettledSlices).toBe(0);
+    });
+    it("aborts an abandoned multipart upload and preserves the part failure", async () => {
+        settings.config.maxConcurrentUploadH2Requests = 1;
+        const filesystem = Object.create(SandboxFileSystem.prototype);
+        filesystem.sandbox = { h2Domain: "cleanup.test" };
+        const partFailure = new Error("part failed");
+        const abortFailure = new Error("abort failed");
+        const aborts = [];
+        const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        filesystem.initiateMultipartUpload = () => Promise.resolve({ uploadId: "upload-cleanup" });
+        filesystem.uploadPart = () => Promise.reject(partFailure);
+        filesystem.completeMultipartUpload = () => {
+            throw new Error("completion must not run");
+        };
+        filesystem.abortMultipartUpload = (uploadId) => {
+            aborts.push(uploadId);
+            return Promise.reject(abortFailure);
+        };
+        await expect(filesystem.uploadWithMultipart("/tmp/cleanup.bin", new Blob([new Uint8Array(6 * 1024 * 1024)]))).rejects.toBe(partFailure);
+        expect(aborts).toEqual(["upload-cleanup"]);
+        expect(consoleError).toHaveBeenCalledWith("Failed to abort multipart upload:", abortFailure);
+    });
 });