@aws-sdk/lib-transfer-manager 0.0.0-stage → 0.1.0

package/dist-es/submodules/transfer-manager/S3TransferManager.js

@@ -0,0 +1,2229 @@
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, UploadPartCommand, } from "@aws-sdk/client-s3";
+import { isThrottlingError, isTransientError } from "@smithy/core/retry";
+import { createReadStream, existsSync } from "node:fs";
+import { open, opendir, realpath, stat } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { byteLength, getChunk } from "./chunker";
+import { createDestinationDirectory, createLocalParentDirectories, deriveLocalPath, handleFailure, isFolderObject, Semaphore, validateDirectory, } from "./directory-transfer-utils";
+import { FileManager } from "./file-manager";
+import { LogLevel } from "./log-level";
+import { OrderedPartQueue } from "./ordered-part-queue";
+class S3TransferManagerBase {
+    static MIN_PART_SIZE = 5 * 1024 * 1024;
+    s3;
+    targetPartSizeBytes;
+    multipartUploadThresholdBytes;
+    requestChecksumCalculation;
+    responseChecksumValidation;
+    multipartDownloadType;
+    eventListeners;
+    abortCleanupFunctions = new WeakMap();
+    maxConcurrentDownloads;
+    maxConcurrentUploads;
+    workerThreadCount;
+    workerHttpHandler;
+    logger;
+    deps;
+    constructor(config, deps) {
+        this.deps = deps;
+        this.requestChecksumCalculation = config.requestChecksumCalculation ?? "WHEN_SUPPORTED";
+        this.responseChecksumValidation = config.responseChecksumValidation ?? "WHEN_SUPPORTED";
+        this.maxConcurrentUploads = config.maxConcurrentUploads ?? 32;
+        this.maxConcurrentDownloads = config.maxConcurrentDownloads ?? 32;
+        this.workerThreadCount = config.workerThreadCount ?? this.deps.defaultWorkerCount();
+        this.logger = config.logger ?? new LogLevel("warn");
+        this.s3 =
+            config.s3 ??
+                new S3Client({
+                    requestChecksumCalculation: this.requestChecksumCalculation,
+                    responseChecksumValidation: this.responseChecksumValidation,
+                });
+        if (this.workerThreadCount > 1) {
+            this.workerHttpHandler = new this.deps.WorkerHttpHandler({
+                workerThreadCount: this.workerThreadCount,
+                maxConcurrentUploads: this.maxConcurrentUploads,
+                maxConcurrentDownloads: this.maxConcurrentDownloads,
+                useODirect: config.useODirect,
+                logger: this.logger,
+            });
+            if (this.s3.config) {
+                this.s3.config.requestHandler = this.workerHttpHandler;
+            }
+        }
+        this.targetPartSizeBytes = config.targetPartSizeBytes ?? 8 * 1024 * 1024;
+        this.multipartUploadThresholdBytes = config.multipartUploadThresholdBytes ?? 16 * 1024 * 1024;
+        this.multipartDownloadType = config.multipartDownloadType ?? "PART";
+        this.eventListeners = {
+            transferInitiated: config.eventListeners?.transferInitiated ?? [],
+            bytesTransferred: config.eventListeners?.bytesTransferred ?? [],
+            transferComplete: config.eventListeners?.transferComplete ?? [],
+            transferFailed: config.eventListeners?.transferFailed ?? [],
+        };
+        this.validateConfig();
+    }
+    addEventListener(type, callback, options) {
+        const eventType = type;
+        const listeners = this.eventListeners[eventType];
+        if (!listeners) {
+            throw new Error(`Unknown event type: ${eventType}`);
+        }
+        const once = typeof options !== "boolean" && options?.once;
+        const signal = typeof options !== "boolean" ? options?.signal : undefined;
+        let updatedCallback = callback;
+        if (signal?.aborted) {
+            return;
+        }
+        if (signal) {
+            const removeListenerAfterAbort = () => {
+                this.removeEventListener(eventType, updatedCallback);
+                this.abortCleanupFunctions.delete(signal);
+            };
+            this.abortCleanupFunctions.set(signal, () => signal.removeEventListener("abort", removeListenerAfterAbort));
+            signal.addEventListener("abort", removeListenerAfterAbort, {
+                once: true,
+            });
+        }
+        if (once) {
+            updatedCallback = (event) => {
+                if (typeof callback === "function") {
+                    callback(event);
+                }
+                else {
+                    callback.handleEvent(event);
+                }
+                this.removeEventListener(eventType, updatedCallback);
+            };
+        }
+        listeners.push(updatedCallback);
+    }
+    dispatchEvent(event) {
+        const eventType = event.type;
+        const listeners = this.eventListeners[eventType];
+        if (listeners) {
+            for (const listener of listeners) {
+                if (typeof listener === "function") {
+                    listener(event);
+                }
+                else {
+                    listener.handleEvent(event);
+                }
+            }
+        }
+        return true;
+    }
+    removeEventListener(type, callback, options) {
+        const eventType = type;
+        const listeners = this.eventListeners[eventType];
+        if (listeners) {
+            if (eventType === "transferInitiated" ||
+                eventType === "bytesTransferred" ||
+                eventType === "transferFailed" ||
+                eventType === "transferComplete") {
+                const eventListener = callback;
+                let index = listeners.indexOf(eventListener);
+                while (index !== -1) {
+                    listeners.splice(index, 1);
+                    index = listeners.indexOf(eventListener);
+                }
+            }
+            else {
+                throw new Error(`Unknown event type: ${type}`);
+            }
+        }
+    }
+    async upload(request, transferOptions) {
+        return this.uploadInternal(request, transferOptions, true);
+    }
+    async uploadInternal(request, transferOptions, emitEvents = true) {
+        const totalContentLength = request.ContentLength ?? byteLength(request.Body);
+        if (totalContentLength === undefined) {
+            throw new Error("Unable to determine content length for upload");
+        }
+        this.checkAborted(transferOptions);
+        if (emitEvents) {
+            this.addEventListeners(transferOptions?.eventListeners);
+            this.dispatchTransferInitiatedEvent(request, totalContentLength);
+        }
+        const removeLocalEventListeners = () => {
+            this.removeEventListeners(transferOptions?.eventListeners);
+            if (transferOptions?.abortSignal) {
+                this.abortCleanupFunctions.get(transferOptions.abortSignal)?.();
+                this.abortCleanupFunctions.delete(transferOptions.abortSignal);
+            }
+        };
+        try {
+            let response;
+            if (totalContentLength < this.multipartUploadThresholdBytes) {
+                response = await this.uploadSinglePart(request, totalContentLength, transferOptions, emitEvents);
+            }
+            else if (this.workerThreadCount > 1 && this.isFileBody(request.Body)) {
+                response = await this.threadedUploadInPartsFromFile(request, totalContentLength, transferOptions, emitEvents);
+            }
+            else if (this.workerThreadCount > 1 && this.isInMemoryBody(request.Body)) {
+                if (typeof request.Body === "string") {
+                    request = {
+                        ...request,
+                        Body: new TextEncoder().encode(request.Body),
+                    };
+                }
+                response = await this.threadedUploadInParts(request, totalContentLength, transferOptions, emitEvents);
+            }
+            else {
+                response = await this.uploadInParts(request, totalContentLength, transferOptions, emitEvents);
+            }
+            if (emitEvents) {
+                this.dispatchEvent(Object.assign(new Event("transferComplete"), {
+                    request,
+                    response,
+                    snapshot: {
+                        transferredBytes: totalContentLength,
+                        totalBytes: totalContentLength,
+                    },
+                }));
+            }
+            removeLocalEventListeners();
+            return response;
+        }
+        catch (error) {
+            if (emitEvents) {
+                this.dispatchTransferFailedEvent(request, totalContentLength, error);
+            }
+            removeLocalEventListeners();
+            throw error;
+        }
+    }
+    async download(request, transferOptions) {
+        const partNumber = request.PartNumber;
+        if (typeof partNumber === "number") {
+            throw new Error("partNumber included: S3 Transfer Manager does not support downloads for specific parts. Use GetObjectCommand instead");
+        }
+        const metadata = {};
+        const streams = [];
+        const requests = [];
+        let totalSize;
+        this.checkAborted(transferOptions);
+        this.addEventListeners(transferOptions?.eventListeners);
+        const checksumValidationEnabled = request.ChecksumMode === "ENABLED" || this.responseChecksumValidation === "WHEN_SUPPORTED";
+        let onStreamConsumed;
+        const removeLocalEventListeners = () => {
+            this.removeEventListeners(transferOptions?.eventListeners);
+            if (transferOptions?.abortSignal) {
+                this.abortCleanupFunctions.get(transferOptions.abortSignal)?.();
+                this.abortCleanupFunctions.delete(transferOptions.abortSignal);
+            }
+        };
+        const resolvedTransferOptions = transferOptions ?? {};
+        const downloadArgs = [
+            request,
+            resolvedTransferOptions,
+            streams,
+            requests,
+            metadata,
+            checksumValidationEnabled,
+        ];
+        try {
+            let responseMetadata;
+            if (this.multipartDownloadType === "PART") {
+                if (this.workerHttpHandler) {
+                    responseMetadata = await this.downloadByPartWithWorkers(...downloadArgs);
+                }
+                else {
+                    responseMetadata = await this.downloadByPart(...downloadArgs);
+                }
+            }
+            else if (this.multipartDownloadType === "RANGE") {
+                if (this.workerHttpHandler && !request.Range) {
+                    responseMetadata = await this.downloadByRangeWithWorkers(...downloadArgs);
+                }
+                else {
+                    responseMetadata = await this.downloadByRange(...downloadArgs);
+                }
+            }
+            totalSize = responseMetadata.totalSize;
+            onStreamConsumed = responseMetadata.onStreamConsumed;
+        }
+        catch (error) {
+            await this.deps.destroyStreams(streams);
+            removeLocalEventListeners();
+            throw error;
+        }
+        const response = {
+            ...metadata,
+            Body: await this.deps.joinStreams(streams, {
+                onBytes: (byteLength, index) => {
+                    this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                        request: requests[index],
+                        snapshot: {
+                            transferredBytes: byteLength,
+                            totalBytes: totalSize,
+                        },
+                    }));
+                },
+                onCompletion: (byteLength, index) => {
+                    this.dispatchEvent(Object.assign(new Event("transferComplete"), {
+                        request: requests[index],
+                        response,
+                        snapshot: {
+                            transferredBytes: byteLength,
+                            totalBytes: totalSize,
+                        },
+                    }));
+                    removeLocalEventListeners();
+                },
+                onFailure: (error, index) => {
+                    this.dispatchEvent(Object.assign(new Event("transferFailed"), {
+                        request: requests[index],
+                        snapshot: {
+                            transferredBytes: error,
+                            totalBytes: totalSize,
+                        },
+                    }));
+                    removeLocalEventListeners();
+                },
+                onStreamConsumed,
+            }),
+        };
+        return response;
+    }
+    async downloadToFile(request, transferOptions) {
+        return this.downloadToFileInternal(request, transferOptions, true);
+    }
+    async downloadToFileInternal(request, transferOptions, emitEvents = true) {
+        if (!request.destination || request.destination === "") {
+            throw new Error("destination must be a non-empty string");
+        }
+        const resolvedDestination = resolve(request.destination);
+        if (request.failIfExists && existsSync(resolvedDestination)) {
+            throw new Error(`File already exists at destination: ${resolvedDestination}`);
+        }
+        this.checkAborted(transferOptions);
+        if (emitEvents) {
+            this.addEventListeners(transferOptions?.eventListeners);
+        }
+        const removeLocalEventListeners = () => {
+            this.removeEventListeners(transferOptions?.eventListeners);
+            if (transferOptions?.abortSignal) {
+                this.abortCleanupFunctions.get(transferOptions.abortSignal)?.();
+                this.abortCleanupFunctions.delete(transferOptions.abortSignal);
+            }
+        };
+        const checksumValidationEnabled = request.ChecksumMode === "ENABLED" || this.responseChecksumValidation === "WHEN_SUPPORTED";
+        const { destination, failIfExists, ...getObjectFields } = request;
+        if (this.multipartDownloadType === "RANGE") {
+            try {
+                const result = await this.downloadToFileByRange(request, resolvedDestination, transferOptions, emitEvents);
+                removeLocalEventListeners();
+                return result;
+            }
+            catch (error) {
+                removeLocalEventListeners();
+                throw error;
+            }
+        }
+        const initialPartRequest = {
+            ...getObjectFields,
+            PartNumber: 1,
+            ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+        };
+        let initialResponse;
+        try {
+            initialResponse = await this.s3.send(new GetObjectCommand(initialPartRequest), transferOptions);
+        }
+        catch (error) {
+            removeLocalEventListeners();
+            throw error;
+        }
+        if (initialResponse.Body && initialResponse.Body instanceof Readable) {
+            initialResponse.Body.on("error", () => { });
+        }
+        const totalSize = initialResponse.ContentRange
+            ? Number.parseInt(initialResponse.ContentRange.split("/")[1])
+            : (initialResponse.ContentLength ?? 0);
+        const partsCount = initialResponse.PartsCount ?? 1;
+        const eTag = initialResponse.ETag ?? undefined;
+        if (emitEvents) {
+            this.dispatchTransferInitiatedEvent(request, totalSize);
+        }
+        const fileManager = new FileManager();
+        let tempFilePath;
+        try {
+            if (partsCount === 1) {
+                tempFilePath = await fileManager.createTempFile(resolvedDestination, totalSize);
+                fileManager.registerCleanupHandler(tempFilePath);
+                await this.writeResponseBodyToFile(initialResponse.Body, tempFilePath, initialResponse.ContentRange, 0);
+                if (emitEvents) {
+                    this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                        request,
+                        snapshot: {
+                            transferredBytes: totalSize,
+                            totalBytes: totalSize,
+                        },
+                    }));
+                }
+                await fileManager.atomicRename(tempFilePath, resolvedDestination);
+                fileManager.unregisterCleanupHandler(tempFilePath);
+                const response = this.buildDownloadToFileResponse(initialResponse, totalSize, request, emitEvents);
+                removeLocalEventListeners();
+                return response;
+            }
+            tempFilePath = await fileManager.createTempFile(resolvedDestination, totalSize);
+            fileManager.registerCleanupHandler(tempFilePath);
+            let transferredBytes = 0;
+            const partSize = initialResponse.ContentLength ?? 0;
+            await this.writeResponseBodyToFile(initialResponse.Body, tempFilePath, initialResponse.ContentRange, 0);
+            transferredBytes += partSize;
+            if (emitEvents) {
+                this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                    request,
+                    snapshot: {
+                        transferredBytes,
+                        totalBytes: totalSize,
+                    },
+                }));
+            }
+            const partResults = [];
+            partResults.push({ partNumber: 1, bytesWritten: partSize });
+            const semaphore = new Semaphore(this.maxConcurrentDownloads);
+            const abortController = new AbortController();
+            let failed = false;
+            let failureError;
+            const userSignal = transferOptions?.abortSignal;
+            if (userSignal) {
+                const onUserAbort = () => abortController.abort();
+                userSignal.addEventListener("abort", onUserAbort, { once: true });
+            }
+            const remainingPartTasks = [];
+            for (let part = 2; part <= partsCount; part++) {
+                if (failed || abortController.signal.aborted)
+                    break;
+                this.checkAborted(transferOptions);
+                await semaphore.acquire();
+                if (failed || abortController.signal.aborted) {
+                    semaphore.release();
+                    break;
+                }
+                const partNumber = part;
+                const partOffset = (partNumber - 1) * partSize;
+                const expectedLength = Math.min(partSize, totalSize - partOffset);
+                const partGetRequest = {
+                    ...getObjectFields,
+                    PartNumber: partNumber,
+                    IfMatch: eTag,
+                    ...(checksumValidationEnabled && {
+                        ChecksumMode: "ENABLED",
+                    }),
+                };
+                const task = (async () => {
+                    try {
+                        if (this.workerHttpHandler) {
+                            const resultToken = `download-${partNumber}-${Date.now()}`;
+                            const downloadOptions = {
+                                filePath: tempFilePath,
+                                offset: partOffset,
+                                expectedLength,
+                                resultToken,
+                            };
+                            await this.s3.send(new GetObjectCommand(partGetRequest), {
+                                ...transferOptions,
+                                downloadDataToFile: downloadOptions,
+                            });
+                            const downloadResult = this.s3.config.requestHandler.getDownloadResult(resultToken);
+                            if (!downloadResult) {
+                                throw new Error(`Missing download result for part ${partNumber}`);
+                            }
+                            partResults.push({
+                                partNumber,
+                                bytesWritten: downloadResult.bytesWritten,
+                            });
+                        }
+                        else {
+                            const partResponse = await this.s3.send(new GetObjectCommand(partGetRequest), transferOptions);
+                            if (partResponse.Body && partResponse.Body instanceof Readable) {
+                                partResponse.Body.on("error", () => { });
+                            }
+                            this.validatePartDownload(partResponse.ContentRange, partNumber, partSize);
+                            await this.writeResponseBodyToFile(partResponse.Body, tempFilePath, partResponse.ContentRange, partOffset);
+                            partResults.push({
+                                partNumber,
+                                bytesWritten: partResponse.ContentLength ?? expectedLength,
+                            });
+                        }
+                        transferredBytes += expectedLength;
+                        if (emitEvents) {
+                            this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                                request: partGetRequest,
+                                snapshot: {
+                                    transferredBytes,
+                                    totalBytes: totalSize,
+                                },
+                            }));
+                        }
+                    }
+                    catch (error) {
+                        if (!failed) {
+                            failed = true;
+                            failureError = error;
+                            abortController.abort();
+                        }
+                    }
+                    finally {
+                        semaphore.release();
+                    }
+                })();
+                remainingPartTasks.push(task);
+            }
+            await Promise.allSettled(remainingPartTasks);
+            if (abortController.signal.aborted && !failed) {
+                const abortError = Object.assign(new Error("Transfer aborted."), {
+                    name: "AbortError",
+                });
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalSize, abortError, emitEvents);
+                removeLocalEventListeners();
+                throw abortError;
+            }
+            if (failed) {
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalSize, failureError, emitEvents);
+                removeLocalEventListeners();
+                throw failureError;
+            }
+            if (partResults.length !== partsCount) {
+                const error = new Error(`The number of parts downloaded (${partResults.length}) does not match the expected number (${partsCount})`);
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalSize, error, emitEvents);
+                removeLocalEventListeners();
+                throw error;
+            }
+            const totalBytesWritten = partResults.reduce((sum, p) => sum + p.bytesWritten, 0);
+            if (totalBytesWritten !== totalSize) {
+                const error = new Error(`Total bytes written (${totalBytesWritten}) does not match expected object size (${totalSize})`);
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalSize, error, emitEvents);
+                removeLocalEventListeners();
+                throw error;
+            }
+            await fileManager.atomicRename(tempFilePath, resolvedDestination);
+            fileManager.unregisterCleanupHandler(tempFilePath);
+            const response = this.buildDownloadToFileResponse(initialResponse, totalSize, request, emitEvents);
+            removeLocalEventListeners();
+            return response;
+        }
+        catch (error) {
+            if (tempFilePath) {
+                await fileManager.deleteTempFile(tempFilePath).catch(() => { });
+                fileManager.unregisterCleanupHandler(tempFilePath);
+            }
+            removeLocalEventListeners();
+            throw error;
+        }
+    }
+    async downloadToFileByRange(request, resolvedDestination, transferOptions, emitEvents) {
+        const { destination, failIfExists, ...getObjectFields } = request;
+        const checksumValidationEnabled = request.ChecksumMode === "ENABLED" || this.responseChecksumValidation === "WHEN_SUPPORTED";
+        const fileManager = new FileManager();
+        let tempFilePath;
+        try {
+            const rangeSize = this.targetPartSizeBytes;
+            const initialRangeRequest = {
+                ...getObjectFields,
+                Range: `bytes=0-${rangeSize - 1}`,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            const initialResponse = await this.s3.send(new GetObjectCommand(initialRangeRequest), transferOptions);
+            if (initialResponse.Body && initialResponse.Body instanceof Readable) {
+                initialResponse.Body.on("error", () => { });
+            }
+            this.validateRangeDownload(`bytes=0-${rangeSize - 1}`, initialResponse.ContentRange);
+            const totalContentLength = Number.parseInt(initialResponse.ContentRange.split("/")[1]);
+            const responseContentLength = initialResponse.ContentLength ?? 0;
+            if (responseContentLength === totalContentLength) {
+                tempFilePath = await fileManager.createTempFile(resolvedDestination, totalContentLength);
+                fileManager.registerCleanupHandler(tempFilePath);
+                await this.writeResponseBodyToFile(initialResponse.Body, tempFilePath, initialResponse.ContentRange, 0);
+                await fileManager.atomicRename(tempFilePath, resolvedDestination);
+                fileManager.unregisterCleanupHandler(tempFilePath);
+                if (emitEvents) {
+                    this.dispatchTransferInitiatedEvent(request, totalContentLength);
+                    this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                        request,
+                        snapshot: {
+                            transferredBytes: totalContentLength,
+                            totalBytes: totalContentLength,
+                        },
+                    }));
+                }
+                return this.buildDownloadToFileResponse(initialResponse, totalContentLength, request, emitEvents);
+            }
+            const eTag = initialResponse.ETag ?? undefined;
+            const expectedRequestCount = Math.ceil(totalContentLength / rangeSize);
+            if (emitEvents) {
+                this.dispatchTransferInitiatedEvent(request, totalContentLength);
+            }
+            tempFilePath = await fileManager.createTempFile(resolvedDestination, totalContentLength);
+            fileManager.registerCleanupHandler(tempFilePath);
+            await this.writeResponseBodyToFile(initialResponse.Body, tempFilePath, initialResponse.ContentRange, 0);
+            const rangeResults = [];
+            rangeResults.push({ index: 0, bytesWritten: responseContentLength });
+            let transferredBytes = responseContentLength;
+            if (emitEvents) {
+                this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                    request: initialRangeRequest,
+                    snapshot: {
+                        transferredBytes,
+                        totalBytes: totalContentLength,
+                    },
+                }));
+            }
+            const semaphore = new Semaphore(this.maxConcurrentDownloads);
+            const abortController = new AbortController();
+            let failed = false;
+            let failureError;
+            const userSignal = transferOptions?.abortSignal;
+            if (userSignal) {
+                userSignal.addEventListener("abort", () => abortController.abort(), {
+                    once: true,
+                });
+            }
+            const rangeTasks = [];
+            let rangeIndex = 1;
+            for (let offset = rangeSize; offset < totalContentLength; offset += rangeSize) {
+                if (failed || abortController.signal.aborted)
+                    break;
+                this.checkAborted(transferOptions);
+                await semaphore.acquire();
+                if (failed || abortController.signal.aborted) {
+                    semaphore.release();
+                    break;
+                }
+                const start = offset;
+                const end = Math.min(offset + rangeSize - 1, totalContentLength - 1);
+                const currentIndex = rangeIndex++;
+                const rangeGetRequest = {
+                    ...getObjectFields,
+                    Range: `bytes=${start}-${end}`,
+                    IfMatch: eTag,
+                    ...(checksumValidationEnabled && {
+                        ChecksumMode: "ENABLED",
+                    }),
+                };
+                const task = (async () => {
+                    try {
+                        const expectedLength = end - start + 1;
+                        if (this.workerHttpHandler) {
+                            const resultToken = `download-range-${currentIndex}-${Date.now()}`;
+                            const downloadOptions = {
+                                filePath: tempFilePath,
+                                offset: start,
+                                expectedLength,
+                                resultToken,
+                            };
+                            const rangeResponse = await this.s3.send(new GetObjectCommand(rangeGetRequest), {
+                                ...transferOptions,
+                                downloadDataToFile: downloadOptions,
+                            });
+                            this.validateRangeDownload(`bytes=${start}-${end}`, rangeResponse.ContentRange);
+                            const downloadResult = this.s3.config.requestHandler.getDownloadResult(resultToken);
+                            if (!downloadResult) {
+                                throw new Error(`Missing download result for range ${start}-${end}`);
+                            }
+                            rangeResults.push({
+                                index: currentIndex,
+                                bytesWritten: downloadResult.bytesWritten,
+                            });
+                        }
+                        else {
+                            const rangeResponse = await this.s3.send(new GetObjectCommand(rangeGetRequest), transferOptions);
+                            this.validateRangeDownload(`bytes=${start}-${end}`, rangeResponse.ContentRange);
+                            if (rangeResponse.Body && rangeResponse.Body instanceof Readable) {
+                                rangeResponse.Body.on("error", () => { });
+                            }
+                            await this.writeResponseBodyToFile(rangeResponse.Body, tempFilePath, rangeResponse.ContentRange, start);
+                            rangeResults.push({
+                                index: currentIndex,
+                                bytesWritten: rangeResponse.ContentLength ?? expectedLength,
+                            });
+                        }
+                        transferredBytes += end - start + 1;
+                        if (emitEvents) {
+                            this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                                request: rangeGetRequest,
+                                snapshot: {
+                                    transferredBytes,
+                                    totalBytes: totalContentLength,
+                                },
+                            }));
+                        }
+                    }
+                    catch (error) {
+                        if (!failed) {
+                            failed = true;
+                            failureError = error;
+                            abortController.abort();
+                        }
+                    }
+                    finally {
+                        semaphore.release();
+                    }
+                })();
+                rangeTasks.push(task);
+            }
+            await Promise.allSettled(rangeTasks);
+            if (abortController.signal.aborted && !failed) {
+                const abortError = Object.assign(new Error("Transfer aborted."), {
+                    name: "AbortError",
+                });
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalContentLength, abortError, emitEvents);
+                throw abortError;
+            }
+            if (failed) {
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalContentLength, failureError, emitEvents);
+                throw failureError;
+            }
+            const actualRequestCount = rangeResults.length;
+            if (actualRequestCount !== expectedRequestCount) {
+                const error = new Error(`Expected ${expectedRequestCount} ranged GET requests but sent ${actualRequestCount}`);
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalContentLength, error, emitEvents);
+                throw error;
+            }
+            const totalBytesWritten = rangeResults.reduce((sum, r) => sum + r.bytesWritten, 0);
+            if (totalBytesWritten !== totalContentLength) {
+                const error = new Error(`Total bytes written (${totalBytesWritten}) does not match expected object size (${totalContentLength})`);
+                await this.handleDownloadCleanup(fileManager, tempFilePath, request, totalContentLength, error, emitEvents);
+                throw error;
+            }
+            await fileManager.atomicRename(tempFilePath, resolvedDestination);
+            fileManager.unregisterCleanupHandler(tempFilePath);
+            return this.buildDownloadToFileResponse(initialResponse, totalContentLength, request, emitEvents);
+        }
+        catch (error) {
+            if (tempFilePath) {
+                await fileManager.deleteTempFile(tempFilePath).catch(() => { });
+                fileManager.unregisterCleanupHandler(tempFilePath);
+            }
+            throw error;
+        }
+    }
+    async writeResponseBodyToFile(body, filePath, contentRange, fallbackOffset) {
+        const start = parseContentRangeStart(contentRange) ?? fallbackOffset;
+        const fd = await open(filePath, "r+");
+        try {
+            let offset = start;
+            if (typeof body[Symbol.asyncIterator] === "function") {
+                for await (const chunk of body) {
+                    await fd.write(chunk, 0, chunk.length, offset);
+                    offset += chunk.length;
+                }
+            }
+            else if (typeof body.transformToByteArray === "function") {
+                const bytes = await body.transformToByteArray();
+                await fd.write(bytes, 0, bytes.length, offset);
+                offset += bytes.length;
+            }
+            return offset - start;
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    async uploadDirectory(request, transferOptions) {
+        const maxConcurrency = request.maxConcurrency ?? 100;
+        if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) {
+            throw new Error("maxConcurrency must be a positive integer");
+        }
+        const absoluteSource = await validateDirectory(request.source);
+        const failurePolicy = request.failurePolicy ?? "terminate";
+        const semaphore = new Semaphore(maxConcurrency);
+        const abortController = new AbortController();
+        const inFlight = new Set();
+        let objectsUploaded = 0;
+        let objectsFailed = 0;
+        let terminated = false;
+        let terminationError;
+        this.checkAborted(transferOptions);
+        this.addEventListeners(transferOptions?.eventListeners);
+        let transferredBytes = 0;
+        let transferredFiles = 0;
+        let totalFiles = undefined;
+        let totalBytes = undefined;
+        let traversalComplete = false;
+        const userSignal = transferOptions?.abortSignal;
+        const onUserAbort = () => {
+            if (!terminated) {
+                terminated = true;
+                terminationError = Object.assign(new Error("Transfer aborted."), { name: "AbortError" });
+            }
+            abortController.abort();
+        };
+        const removeLocalEventListeners = () => {
+            this.removeEventListeners(transferOptions?.eventListeners);
+            userSignal?.removeEventListener("abort", onUserAbort);
+        };
+        this.dispatchEvent(Object.assign(new Event("transferInitiated"), {
+            request,
+            snapshot: {
+                transferredBytes: 0,
+                totalBytes: undefined,
+                transferredFiles: 0,
+                totalFiles: undefined,
+            },
+        }));
+        userSignal?.addEventListener("abort", onUserAbort, { once: true });
+        let discoveredFiles = 0;
+        let discoveredBytes = 0;
+        for await (const filePath of this.traverseDirectory(absoluteSource, {
+            recursive: request.recursive ?? false,
+            followSymbolicLinks: request.followSymbolicLinks ?? false,
+        })) {
+            if (terminated || abortController.signal.aborted)
+                break;
+            this.checkAborted(transferOptions);
+            if (request.filter) {
+                const include = request.filter instanceof RegExp ? matchesFilterRegExp(request.filter, filePath) : request.filter(filePath);
+                if (!include)
+                    continue;
+            }
+            const fileStat = await stat(filePath);
+            discoveredFiles++;
+            discoveredBytes += fileStat.size;
+            const count = fileStat.size >= this.multipartUploadThresholdBytes
+                ? Math.min(Math.ceil(fileStat.size / this.targetPartSizeBytes), this.maxConcurrentUploads)
+                : 1;
+            await semaphore.acquire(count);
+            if (terminated || abortController.signal.aborted) {
+                semaphore.release(count);
+                break;
+            }
+            const task = (async () => {
+                try {
+                    const key = this.deriveS3Key(absoluteSource, filePath, request.s3Prefix);
+                    let putRequest = {
+                        Bucket: request.bucket,
+                        Key: key,
+                        Body: createReadStream(filePath),
+                        ContentLength: fileStat.size,
+                    };
+                    if (request.uploadObjectRequestModifier) {
+                        putRequest = request.uploadObjectRequestModifier(putRequest);
+                    }
+                    await this.uploadInternal(putRequest, {
+                        abortSignal: abortController.signal,
+                    }, false);
+                    objectsUploaded++;
+                    transferredFiles++;
+                    transferredBytes += fileStat.size;
+                    this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                        request,
+                        snapshot: {
+                            transferredBytes,
+                            totalBytes: traversalComplete ? totalBytes : undefined,
+                            transferredFiles,
+                            totalFiles: traversalComplete ? totalFiles : undefined,
+                        },
+                    }));
+                }
+                catch (error) {
+                    if (terminated || abortController.signal.aborted) {
+                        objectsFailed++;
+                        return;
+                    }
+                    const context = {
+                        request,
+                        objectRequest: {
+                            Bucket: request.bucket,
+                            Key: this.deriveS3Key(absoluteSource, filePath, request.s3Prefix),
+                        },
+                        error,
+                    };
+                    const result = await handleFailure(failurePolicy, context, abortController);
+                    if (result === "terminate") {
+                        terminated = true;
+                        if (!terminationError) {
+                            terminationError = error;
+                        }
+                    }
+                    objectsFailed++;
+                }
+                finally {
+                    semaphore.release(count);
+                }
+            })();
+            inFlight.add(task);
+            task.finally(() => inFlight.delete(task));
+        }
+        traversalComplete = true;
+        totalFiles = discoveredFiles;
+        totalBytes = discoveredBytes;
+        await Promise.allSettled([...inFlight]);
+        if (terminated && terminationError) {
+            this.dispatchEvent(Object.assign(new Event("transferFailed"), {
+                request,
+                snapshot: {
+                    transferredBytes,
+                    totalBytes,
+                    transferredFiles,
+                    totalFiles,
+                },
+            }));
+            removeLocalEventListeners();
+            throw terminationError;
+        }
+        this.dispatchEvent(Object.assign(new Event("transferComplete"), {
+            request,
+            response: { objectsUploaded, objectsFailed },
+            snapshot: {
+                transferredBytes,
+                totalBytes,
+                transferredFiles,
+                totalFiles,
+            },
+        }));
+        removeLocalEventListeners();
+        return { objectsUploaded, objectsFailed };
+    }
+    async downloadDirectory(request, transferOptions) {
+        const maxConcurrency = request.maxConcurrency ?? 100;
+        if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) {
+            throw new Error("maxConcurrency must be a positive integer");
+        }
+        const destination = await createDestinationDirectory(request.destination);
+        const failurePolicy = request.failurePolicy ?? "terminate";
+        const semaphore = new Semaphore(maxConcurrency);
+        const abortController = new AbortController();
+        const inFlight = new Set();
+        let objectsDownloaded = 0;
+        let objectsFailed = 0;
+        let terminated = false;
+        let terminationError;
+        this.checkAborted(transferOptions);
+        this.addEventListeners(transferOptions?.eventListeners);
+        let transferredBytes = 0;
+        let transferredFiles = 0;
+        let discoveredFiles = 0;
+        let discoveredBytes = 0;
+        let totalFiles = undefined;
+        let totalBytes = undefined;
+        let traversalComplete = false;
+        const userSignal = transferOptions?.abortSignal;
+        const onUserAbort = () => {
+            if (!terminated) {
+                terminated = true;
+                terminationError = Object.assign(new Error("Transfer aborted."), { name: "AbortError" });
+            }
+            abortController.abort();
+        };
+        const removeLocalEventListeners = () => {
+            this.removeEventListeners(transferOptions?.eventListeners);
+            userSignal?.removeEventListener("abort", onUserAbort);
+            if (transferOptions?.abortSignal) {
+                this.abortCleanupFunctions.get(transferOptions.abortSignal)?.();
+                this.abortCleanupFunctions.delete(transferOptions.abortSignal);
+            }
+        };
+        this.dispatchEvent(Object.assign(new Event("transferInitiated"), {
+            request,
+            snapshot: {
+                transferredBytes: 0,
+                totalBytes: undefined,
+                transferredFiles: 0,
+                totalFiles: undefined,
+            },
+        }));
+        userSignal?.addEventListener("abort", onUserAbort, { once: true });
+        try {
+            let continuationToken;
+            do {
+                if (terminated || abortController.signal.aborted)
+                    break;
+                this.checkAborted(transferOptions);
+                const listRequest = {
+                    Bucket: request.bucket,
+                    Prefix: request.s3Prefix,
+                    Delimiter: undefined,
+                    ContinuationToken: continuationToken,
+                };
+                const listResponse = await this.s3.send(new ListObjectsV2Command(listRequest), {
+                    abortSignal: abortController.signal,
+                });
+                continuationToken = listResponse.IsTruncated ? listResponse.NextContinuationToken : undefined;
+                for (const object of listResponse.Contents ?? []) {
+                    if (terminated || abortController.signal.aborted)
+                        break;
+                    this.checkAborted(transferOptions);
+                    if (isFolderObject(object)) {
+                        continue;
+                    }
+                    if (!object.Key) {
+                        continue;
+                    }
+                    if (request.filter) {
+                        const include = request.filter instanceof RegExp
+                            ? matchesFilterRegExp(request.filter, object.Key)
+                            : request.filter(object);
+                        if (!include) {
+                            continue;
+                        }
+                    }
+                    const currentObject = object;
+                    const key = currentObject.Key;
+                    await semaphore.acquire();
+                    if (terminated || abortController.signal.aborted) {
+                        semaphore.release();
+                        break;
+                    }
+                    const task = (async () => {
+                        let objectRequest = {
+                            Bucket: request.bucket,
+                            Key: key,
+                        };
+                        try {
+                            const localPath = deriveLocalPath(destination, key);
+                            await createLocalParentDirectories(destination, localPath);
+                            if (request.downloadObjectRequestModifier) {
+                                objectRequest = request.downloadObjectRequestModifier(objectRequest);
+                            }
+                            await this.downloadToFileInternal({
+                                ...objectRequest,
+                                destination: localPath,
+                            }, {
+                                abortSignal: abortController.signal,
+                            }, false);
+                            objectsDownloaded++;
+                            transferredFiles++;
+                            transferredBytes += currentObject.Size ?? 0;
+                            this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                                request,
+                                snapshot: {
+                                    transferredBytes,
+                                    totalBytes: traversalComplete ? totalBytes : undefined,
+                                    transferredFiles,
+                                    totalFiles: traversalComplete ? totalFiles : undefined,
+                                },
+                            }));
+                        }
+                        catch (error) {
+                            if (terminated || abortController.signal.aborted) {
+                                objectsFailed++;
+                                return;
+                            }
+                            const context = {
+                                request,
+                                objectRequest,
+                                error,
+                            };
+                            const result = await handleFailure(failurePolicy, context, abortController);
+                            if (result === "terminate") {
+                                terminated = true;
+                                if (!terminationError) {
+                                    terminationError = error;
+                                }
+                            }
+                            objectsFailed++;
+                        }
+                        finally {
+                            semaphore.release();
+                        }
+                    })();
+                    inFlight.add(task);
+                    task.finally(() => inFlight.delete(task));
+                    discoveredFiles++;
+                    discoveredBytes += currentObject.Size ?? 0;
+                }
+            } while (continuationToken);
+        }
+        catch (error) {
+            if (!terminated) {
+                terminated = true;
+                terminationError = error;
+            }
+            abortController.abort();
+        }
+        traversalComplete = true;
+        totalFiles = discoveredFiles;
+        totalBytes = discoveredBytes;
+        await Promise.allSettled([...inFlight]);
+        if (terminated && terminationError) {
+            this.dispatchEvent(Object.assign(new Event("transferFailed"), {
+                request,
+                snapshot: {
+                    transferredBytes,
+                    totalBytes,
+                    transferredFiles,
+                    totalFiles,
+                },
+            }));
+            removeLocalEventListeners();
+            throw terminationError;
+        }
+        this.dispatchEvent(Object.assign(new Event("transferComplete"), {
+            request,
+            response: { objectsDownloaded, objectsFailed },
+            snapshot: {
+                transferredBytes,
+                totalBytes,
+                transferredFiles,
+                totalFiles,
+            },
+        }));
+        removeLocalEventListeners();
+        return { objectsDownloaded, objectsFailed };
+    }
+    async downloadByPart(request, transferOptions, streams, requests, metadata, checksumValidationEnabled) {
+        let totalSize;
+        let streamConsumedCallback;
+        this.checkAborted(transferOptions);
+        if (request.Range == null) {
+            const initialPartRequest = {
+                ...request,
+                PartNumber: 1,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            try {
+                const initialPart = await this.s3.send(new GetObjectCommand(initialPartRequest), transferOptions);
+                await internalEventHandler.afterInitialGetObject();
+                const partSize = initialPart.ContentLength;
+                const initialETag = initialPart.ETag ?? undefined;
+                totalSize = initialPart.ContentRange ? Number.parseInt(initialPart.ContentRange.split("/")[1]) : 0;
+                this.dispatchTransferInitiatedEvent(request, totalSize);
+                if (initialPart.Body) {
+                    if (initialPart.Body && typeof initialPart.Body.getReader === "function") {
+                        const reader = initialPart.Body.getReader();
+                        initialPart.Body.getReader = function () {
+                            return reader;
+                        };
+                    }
+                    streams.push(Promise.resolve(initialPart.Body));
+                    requests.push(initialPartRequest);
+                }
+                this.processResponseMetadata(initialPart, metadata, totalSize);
+                let partCount = 1;
+                if (initialPart.PartsCount > 1) {
+                    const partTasks = [];
+                    const partRequests = [];
+                    for (let part = 2; part <= initialPart.PartsCount; part++) {
+                        const getObjectRequest = {
+                            ...request,
+                            PartNumber: part,
+                            IfMatch: initialETag,
+                            ...(checksumValidationEnabled && {
+                                ChecksumMode: "ENABLED",
+                            }),
+                        };
+                        partRequests.push(getObjectRequest);
+                        partTasks.push(() => {
+                            this.checkAborted(transferOptions);
+                            return this.s3
+                                .send(new GetObjectCommand(getObjectRequest), transferOptions)
+                                .then((response) => {
+                                this.validatePartDownload(response.ContentRange, part, partSize ?? 0);
+                                if (response.Body && typeof response.Body.getReader === "function") {
+                                    const reader = response.Body.getReader();
+                                    response.Body.getReader = function () {
+                                        return reader;
+                                    };
+                                }
+                                return response.Body;
+                            })
+                                .catch((error) => {
+                                this.dispatchTransferFailedEvent(getObjectRequest, totalSize, error);
+                                throw error;
+                            });
+                        });
+                    }
+                    const { promises: pendingStreams, onStreamConsumed } = this.createConcurrentTaskPool(partTasks, this.maxConcurrentDownloads);
+                    streams.push(...pendingStreams);
+                    requests.push(...partRequests);
+                    streamConsumedCallback = onStreamConsumed;
+                    partCount += partTasks.length;
+                    if (partCount !== initialPart.PartsCount) {
+                        throw new Error(`The number of parts downloaded (${partCount}) does not match the expected number (${initialPart.PartsCount})`);
+                    }
+                }
+            }
+            catch (error) {
+                this.dispatchTransferFailedEvent(request, totalSize, error);
+                throw error;
+            }
+        }
+        else {
+            this.checkAborted(transferOptions);
+            try {
+                const getObjectRequest = {
+                    ...request,
+                    ...(checksumValidationEnabled && {
+                        ChecksumMode: "ENABLED",
+                    }),
+                };
+                const getObject = await this.s3.send(new GetObjectCommand(getObjectRequest), transferOptions);
+                totalSize = getObject.ContentRange ? Number.parseInt(getObject.ContentRange.split("/")[1]) : 0;
+                this.dispatchTransferInitiatedEvent(request, totalSize);
+                if (getObject.Body) {
+                    streams.push(Promise.resolve(getObject.Body));
+                    requests.push(getObjectRequest);
+                }
+                this.processResponseMetadata(getObject, metadata, totalSize);
+            }
+            catch (error) {
+                this.dispatchTransferFailedEvent(request, undefined, error);
+                throw error;
+            }
+        }
+        return {
+            totalSize,
+            onStreamConsumed: streamConsumedCallback,
+        };
+    }
+    async downloadByRange(request, transferOptions, streams, requests, metadata, checksumValidationEnabled) {
+        let streamConsumedCallback;
+        this.checkAborted(transferOptions);
+        const headResponse = await this.s3.send(new HeadObjectCommand({ Bucket: request.Bucket, Key: request.Key }), transferOptions);
+        if (headResponse.ContentLength === 0) {
+            const getObjectRequest = {
+                ...request,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            const response = await this.s3.send(new GetObjectCommand(getObjectRequest), transferOptions);
+            this.dispatchTransferInitiatedEvent(request, 0);
+            if (response.Body)
+                streams.push(Promise.resolve(response.Body));
+            requests.push(getObjectRequest);
+            this.processResponseMetadata(response, metadata, 0);
+            return { totalSize: 0 };
+        }
+        let left = 0;
+        let right = this.targetPartSizeBytes - 1;
+        let maxRange = Number.POSITIVE_INFINITY;
+        let remainingLength = 1;
+        let totalSize;
+        let initialETag;
+        if (request.Range != null) {
+            const [userRangeLeft, userRangeRight] = request.Range.replace("bytes=", "").split("-").map(Number);
+            maxRange = userRangeRight;
+            left = userRangeLeft;
+            right = Math.min(userRangeRight, left + S3TransferManagerBase.MIN_PART_SIZE - 1);
+            totalSize = userRangeRight + 1;
+        }
+        try {
+            const getObjectRequest = {
+                ...request,
+                Range: `bytes=${left}-${right}`,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            const initialRangeGet = await this.s3.send(new GetObjectCommand(getObjectRequest), transferOptions);
+            await internalEventHandler.afterInitialGetObject();
+            this.validateRangeDownload(`bytes=${left}-${right}`, initialRangeGet.ContentRange);
+            initialETag = initialRangeGet.ETag ?? undefined;
+            if (!totalSize) {
+                totalSize = initialRangeGet.ContentRange
+                    ? Number.parseInt(initialRangeGet.ContentRange.split("/")[1])
+                    : undefined;
+            }
+            if (initialRangeGet.Body && typeof initialRangeGet.Body.getReader === "function") {
+                const reader = initialRangeGet.Body.getReader();
+                initialRangeGet.Body.getReader = function () {
+                    return reader;
+                };
+            }
+            this.dispatchTransferInitiatedEvent(request, totalSize);
+            streams.push(Promise.resolve(initialRangeGet.Body));
+            requests.push(getObjectRequest);
+            this.processResponseMetadata(initialRangeGet, metadata, totalSize);
+        }
+        catch (error) {
+            this.dispatchTransferFailedEvent(request, totalSize, error);
+            throw error;
+        }
+        let expectedRequestCount = 1;
+        if (totalSize) {
+            const contentLength = totalSize;
+            const remainingBytes = Math.max(0, contentLength - (right - left + 1));
+            const additionalRequests = Math.ceil(remainingBytes / S3TransferManagerBase.MIN_PART_SIZE);
+            expectedRequestCount += additionalRequests;
+        }
+        left = right + 1;
+        right = Math.min(left + S3TransferManagerBase.MIN_PART_SIZE - 1, maxRange);
+        remainingLength = totalSize ? Math.min(right - left + 1, Math.max(0, totalSize - left)) : 0;
+        const rangeTasks = [];
+        const rangeRequests = [];
+        while (remainingLength > 0) {
+            const range = `bytes=${left}-${right}`;
+            const getObjectRequest = {
+                ...request,
+                Range: range,
+                IfMatch: initialETag,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            rangeRequests.push(getObjectRequest);
+            rangeTasks.push(() => {
+                this.checkAborted(transferOptions);
+                return this.s3
+                    .send(new GetObjectCommand(getObjectRequest), transferOptions)
+                    .then((response) => {
+                    this.validateRangeDownload(range, response.ContentRange);
+                    if (response.Body && typeof response.Body.getReader === "function") {
+                        const reader = response.Body.getReader();
+                        response.Body.getReader = function () {
+                            return reader;
+                        };
+                    }
+                    return response.Body;
+                })
+                    .catch((error) => {
+                    this.dispatchTransferFailedEvent(getObjectRequest, totalSize, error);
+                    throw error;
+                });
+            });
+            left = right + 1;
+            right = Math.min(left + S3TransferManagerBase.MIN_PART_SIZE - 1, maxRange);
+            remainingLength = totalSize ? Math.min(right - left + 1, Math.max(0, totalSize - left)) : 0;
+        }
+        if (rangeTasks.length > 0) {
+            const { promises: pendingStreams, onStreamConsumed } = this.createConcurrentTaskPool(rangeTasks, this.maxConcurrentDownloads);
+            streams.push(...pendingStreams);
+            requests.push(...rangeRequests);
+            streamConsumedCallback = onStreamConsumed;
+        }
+        const actualRequestCount = 1 + rangeTasks.length;
+        if (expectedRequestCount !== actualRequestCount) {
+            throw new Error(`The number of ranged GET requests sent (${actualRequestCount}) does not match the expected number (${expectedRequestCount})`);
+        }
+        return {
+            totalSize,
+            onStreamConsumed: streamConsumedCallback,
+        };
+    }
+    async downloadByPartWithWorkers(request, transferOptions, streams, requests, metadata, checksumValidationEnabled) {
+        this.checkAborted(transferOptions);
+        const { Range: _range, ...requestWithoutRange } = request;
+        const initialPartRequest = {
+            ...requestWithoutRange,
+            PartNumber: 1,
+            ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+        };
+        const initialPart = await this.s3.send(new GetObjectCommand(initialPartRequest), transferOptions);
+        await internalEventHandler.afterInitialGetObject();
+        const partSize = initialPart.ContentLength;
+        const initialETag = initialPart.ETag ?? undefined;
+        const totalSize = initialPart.ContentRange
+            ? Number.parseInt(initialPart.ContentRange.split("/")[1])
+            : (initialPart.ContentLength ?? 0);
+        const partsCount = initialPart.PartsCount ?? 1;
+        this.dispatchTransferInitiatedEvent(request, totalSize);
+        if (initialPart.Body) {
+            if (typeof initialPart.Body.getReader === "function") {
+                const reader = initialPart.Body.getReader();
+                initialPart.Body.getReader = function () {
+                    return reader;
+                };
+            }
+            streams.push(Promise.resolve(initialPart.Body));
+            requests.push(initialPartRequest);
+        }
+        this.processResponseMetadata(initialPart, metadata, totalSize);
+        if (partsCount <= 1) {
+            return { totalSize };
+        }
+        this.checkAborted(transferOptions);
+        const remainingParts = partsCount - 1;
+        const queue = new OrderedPartQueue(remainingParts);
+        const abortController = new AbortController();
+        const userSignal = transferOptions?.abortSignal;
+        if (userSignal) {
+            userSignal.addEventListener("abort", () => abortController.abort(), {
+                once: true,
+            });
+        }
+        let inFlight = 0;
+        let nextDispatchResolve = null;
+        const waitForSlot = () => {
+            if (inFlight < this.maxConcurrentDownloads) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                nextDispatchResolve = resolve;
+            });
+        };
+        const releaseSlot = () => {
+            if (inFlight <= 0) {
+                throw new Error("releaseSlot called with no in-flight requests");
+            }
+            inFlight--;
+            if (nextDispatchResolve && inFlight < this.maxConcurrentDownloads) {
+                const resolve = nextDispatchResolve;
+                nextDispatchResolve = null;
+                resolve();
+            }
+        };
+        const dispatchPromise = (async () => {
+            for (let partNumber = 2; partNumber <= partsCount; partNumber++) {
+                if (abortController.signal.aborted || queue.hasError())
+                    break;
+                this.checkAborted(transferOptions);
+                await waitForSlot();
+                if (abortController.signal.aborted || queue.hasError())
+                    break;
+                inFlight++;
+                const rangeIndex = partNumber - 2;
+                const partGetRequest = {
+                    ...requestWithoutRange,
+                    PartNumber: partNumber,
+                    IfMatch: initialETag,
+                    ...(checksumValidationEnabled && {
+                        ChecksumMode: "ENABLED",
+                    }),
+                };
+                requests.push(partGetRequest);
+                const resultToken = `download-transfer-part-${rangeIndex}-${Date.now()}`;
+                const transferOptions_ = {
+                    expectedSize: partSize,
+                    rangeIndex,
+                    checksumAlgorithm: checksumValidationEnabled ? "CRC32" : undefined,
+                    resultToken,
+                };
+                this.s3
+                    .send(new GetObjectCommand(partGetRequest), {
+                    ...transferOptions,
+                    downloadStream: transferOptions_,
+                })
+                    .then(() => {
+                    const transferResult = this.s3.config.requestHandler.getStreamDownloadResult(resultToken);
+                    if (!transferResult) {
+                        queue.setError(new Error(`Missing download result for part ${partNumber}`));
+                        abortController.abort();
+                        return;
+                    }
+                    this.validatePartDownload(transferResult.headers["content-range"], partNumber, partSize);
+                    queue.enqueue(rangeIndex, transferResult.buffer, transferResult.byteLength);
+                })
+                    .catch((error) => {
+                    queue.setError(error);
+                    abortController.abort();
+                })
+                    .finally(() => {
+                    releaseSlot();
+                });
+            }
+        })().catch((err) => {
+            if (!queue.hasError()) {
+                queue.setError(err);
+            }
+        });
+        let reading = false;
+        const transferStream = new Readable({
+            read() {
+                if (reading)
+                    return;
+                reading = true;
+                queue
+                    .dequeue()
+                    .then((item) => {
+                    reading = false;
+                    if (item === null) {
+                        if (queue.hasError()) {
+                            this.destroy(queue.getError());
+                            return;
+                        }
+                        this.push(null);
+                        return;
+                    }
+                    const buf = Buffer.from(item.buffer, 0, item.byteLength);
+                    this.push(buf);
+                })
+                    .catch((err) => {
+                    reading = false;
+                    this.destroy(err);
+                });
+            },
+            destroy(err, callback) {
+                if (err) {
+                    queue.setError(err);
+                    abortController.abort();
+                }
+                callback(err);
+            },
+        });
+        streams.push(Promise.resolve(transferStream));
+        return { totalSize };
+    }
+    async downloadByRangeWithWorkers(request, transferOptions, streams, requests, metadata, checksumValidationEnabled) {
+        this.checkAborted(transferOptions);
+        const headResponse = await this.s3.send(new HeadObjectCommand({ Bucket: request.Bucket, Key: request.Key }), transferOptions);
+        await internalEventHandler.afterInitialGetObject();
+        if (headResponse.ContentLength === 0) {
+            const getObjectRequest = {
+                ...request,
+                ...(checksumValidationEnabled && { ChecksumMode: "ENABLED" }),
+            };
+            const response = await this.s3.send(new GetObjectCommand(getObjectRequest), transferOptions);
+            this.dispatchTransferInitiatedEvent(request, 0);
+            if (response.Body)
+                streams.push(Promise.resolve(response.Body));
+            requests.push(getObjectRequest);
+            this.processResponseMetadata(response, metadata, 0);
+            return { totalSize: 0 };
+        }
+        const totalSize = headResponse.ContentLength;
+        const partSize = this.targetPartSizeBytes;
+        const totalParts = Math.ceil(totalSize / partSize);
+        const eTag = headResponse.ETag ?? undefined;
+        this.dispatchTransferInitiatedEvent(request, totalSize);
+        Object.assign(metadata, {
+            ContentLength: totalSize,
+            ContentRange: `bytes 0-${totalSize - 1}/${totalSize}`,
+            ContentType: headResponse.ContentType,
+            ETag: headResponse.ETag,
+            LastModified: headResponse.LastModified,
+            $metadata: headResponse.$metadata,
+        });
+        const queue = new OrderedPartQueue(totalParts);
+        const abortController = new AbortController();
+        const userSignal = transferOptions?.abortSignal;
+        if (userSignal) {
+            userSignal.addEventListener("abort", () => abortController.abort(), {
+                once: true,
+            });
+        }
+        let inFlight = 0;
+        let nextDispatchResolve = null;
+        const waitForSlot = () => {
+            if (inFlight < this.maxConcurrentDownloads) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                nextDispatchResolve = resolve;
+            });
+        };
+        const releaseSlot = () => {
+            if (inFlight <= 0) {
+                throw new Error("releaseSlot called with no in-flight requests");
+            }
+            inFlight--;
+            if (nextDispatchResolve && inFlight < this.maxConcurrentDownloads) {
+                const resolve = nextDispatchResolve;
+                nextDispatchResolve = null;
+                resolve();
+            }
+        };
+        const dispatchPromise = (async () => {
+            for (let rangeIndex = 0; rangeIndex < totalParts; rangeIndex++) {
+                if (abortController.signal.aborted || queue.hasError())
+                    break;
+                this.checkAborted(transferOptions);
+                await waitForSlot();
+                if (abortController.signal.aborted || queue.hasError())
+                    break;
+                inFlight++;
+                const start = rangeIndex * partSize;
+                const end = Math.min(start + partSize - 1, totalSize - 1);
+                const expectedLength = end - start + 1;
+                const rangeGetRequest = {
+                    ...request,
+                    Range: `bytes=${start}-${end}`,
+                    IfMatch: eTag,
+                    ...(checksumValidationEnabled && {
+                        ChecksumMode: "ENABLED",
+                    }),
+                };
+                requests.push(rangeGetRequest);
+                const resultToken = `download-transfer-range-${rangeIndex}-${Date.now()}`;
+                const transferOpts = {
+                    expectedSize: expectedLength,
+                    rangeIndex,
+                    checksumAlgorithm: checksumValidationEnabled ? "CRC32" : undefined,
+                    resultToken,
+                };
+                this.s3
+                    .send(new GetObjectCommand(rangeGetRequest), {
+                    ...transferOptions,
+                    downloadStream: transferOpts,
+                })
+                    .then(() => {
+                    const transferResult = this.s3.config.requestHandler.getStreamDownloadResult(resultToken);
+                    if (!transferResult) {
+                        queue.setError(new Error(`Missing download result for range ${start}-${end}`));
+                        abortController.abort();
+                        return;
+                    }
+                    this.validateRangeDownload(`bytes=${start}-${end}`, transferResult.headers["content-range"]);
+                    queue.enqueue(rangeIndex, transferResult.buffer, transferResult.byteLength);
+                })
+                    .catch((error) => {
+                    queue.setError(error);
+                    abortController.abort();
+                })
+                    .finally(() => {
+                    releaseSlot();
+                });
+            }
+        })().catch((err) => {
+            if (!queue.hasError()) {
+                queue.setError(err);
+            }
+        });
+        let reading = false;
+        const transferStream = new Readable({
+            read() {
+                if (reading)
+                    return;
+                reading = true;
+                queue
+                    .dequeue()
+                    .then((item) => {
+                    reading = false;
+                    if (item === null) {
+                        if (queue.hasError()) {
+                            this.destroy(queue.getError());
+                            return;
+                        }
+                        this.push(null);
+                        return;
+                    }
+                    const buf = Buffer.from(item.buffer, 0, item.byteLength);
+                    this.push(buf);
+                })
+                    .catch((err) => {
+                    reading = false;
+                    this.destroy(err);
+                });
+            },
+            destroy(err, callback) {
+                if (err) {
+                    queue.setError(err);
+                    abortController.abort();
+                }
+                callback(err);
+            },
+        });
+        streams.push(Promise.resolve(transferStream));
+        return { totalSize };
+    }
+    addEventListeners(eventListeners) {
+        for (const listeners of this.iterateListeners(eventListeners)) {
+            for (const listener of listeners) {
+                this.addEventListener(listener.eventType, listener.callback);
+            }
+        }
+    }
+    removeEventListeners(eventListeners) {
+        for (const listeners of this.iterateListeners(eventListeners)) {
+            for (const listener of listeners) {
+                this.removeEventListener(listener.eventType, listener.callback);
+            }
+        }
+    }
+    assignMetadata(container, response) {
+        for (const key in response) {
+            if (key === "Body") {
+                continue;
+            }
+            container[key] = response[key];
+        }
+    }
+    buildDownloadToFileResponse(initialResponse, totalSize, request, emitEvents) {
+        const metadata = {};
+        this.assignMetadata(metadata, initialResponse);
+        metadata.ContentLength = totalSize;
+        metadata.ContentRange = `bytes 0-${totalSize - 1}/${totalSize}`;
+        if (initialResponse.ChecksumType === "COMPOSITE") {
+            metadata.ChecksumCRC32 = undefined;
+            metadata.ChecksumCRC32C = undefined;
+            metadata.ChecksumSHA1 = undefined;
+            metadata.ChecksumSHA256 = undefined;
+        }
+        const response = {
+            ...metadata,
+            bytesWritten: totalSize,
+        };
+        if (emitEvents) {
+            this.dispatchEvent(Object.assign(new Event("transferComplete"), {
+                request,
+                response,
+                snapshot: {
+                    transferredBytes: totalSize,
+                    totalBytes: totalSize,
+                },
+            }));
+        }
+        return response;
+    }
+    async handleDownloadCleanup(fileManager, tempFilePath, request, totalSize, error, emitEvents) {
+        await fileManager.deleteTempFile(tempFilePath);
+        fileManager.unregisterCleanupHandler(tempFilePath);
+        if (emitEvents) {
+            this.dispatchTransferFailedEvent(request, totalSize, error);
+        }
+    }
+    updateResponseLengthAndRange(response, totalSize) {
+        if (totalSize !== undefined) {
+            response.ContentLength = totalSize;
+            response.ContentRange = `bytes 0-${totalSize - 1}/${totalSize}`;
+        }
+    }
+    updateChecksumValues(initialPart, metadata) {
+        if (initialPart.ChecksumType === "COMPOSITE") {
+            metadata.ChecksumCRC32 = undefined;
+            metadata.ChecksumCRC32C = undefined;
+            metadata.ChecksumSHA1 = undefined;
+            metadata.ChecksumSHA256 = undefined;
+        }
+    }
+    processResponseMetadata(response, metadata, totalSize) {
+        this.updateResponseLengthAndRange(response, totalSize);
+        this.assignMetadata(metadata, response);
+        this.updateChecksumValues(response, metadata);
+    }
+    checkAborted(transferOptions) {
+        if (transferOptions?.abortSignal?.aborted) {
+            throw Object.assign(new Error("Transfer aborted."), {
+                name: "AbortError",
+            });
+        }
+    }
+    validateConfig() {
+        if (this.targetPartSizeBytes < S3TransferManagerBase.MIN_PART_SIZE) {
+            throw new Error(`targetPartSizeBytes must be at least ${S3TransferManagerBase.MIN_PART_SIZE} bytes`);
+        }
+    }
+    dispatchTransferInitiatedEvent(request, totalSize) {
+        this.dispatchEvent(Object.assign(new Event("transferInitiated"), {
+            request,
+            snapshot: {
+                transferredBytes: 0,
+                totalBytes: totalSize,
+            },
+        }));
+        return true;
+    }
+    dispatchTransferFailedEvent(request, totalSize, error) {
+        this.dispatchEvent(Object.assign(new Event("transferFailed"), {
+            request,
+            error,
+            snapshot: {
+                transferredBytes: 0,
+                totalBytes: totalSize,
+            },
+        }));
+        return true;
+    }
+    *iterateListeners(eventListeners = {}) {
+        for (const key in eventListeners) {
+            const eventType = key;
+            const listeners = eventListeners[eventType];
+            if (Array.isArray(listeners)) {
+                for (const callback of listeners) {
+                    yield [
+                        {
+                            eventType: eventType,
+                            callback: callback,
+                        },
+                    ];
+                }
+            }
+        }
+    }
+    createConcurrentTaskPool(tasks, maxConcurrent) {
+        if (tasks.length === 0)
+            return { promises: [], onStreamConsumed: () => { } };
+        const resolvers = [];
+        const promises = tasks.map(() => {
+            let resolve;
+            let reject;
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            resolvers.push({ resolve, reject });
+            return promise;
+        });
+        let nextToLaunch = 0;
+        let failed = false;
+        const launchTask = (index) => {
+            tasks[index]().then((result) => {
+                resolvers[index].resolve(result);
+            }, (error) => {
+                failed = true;
+                resolvers[index].reject(error);
+            });
+        };
+        const initialBatch = Math.min(maxConcurrent, tasks.length);
+        for (let i = 0; i < initialBatch; i++) {
+            launchTask(nextToLaunch++);
+        }
+        const onStreamConsumed = (_index) => {
+            if (failed || nextToLaunch >= tasks.length)
+                return;
+            launchTask(nextToLaunch++);
+        };
+        return { promises, onStreamConsumed };
+    }
+    validatePartDownload(contentRange, partNumber, partSize) {
+        if (!contentRange) {
+            throw new Error(`Missing ContentRange for part ${partNumber}.`);
+        }
+        const match = contentRange.match(/bytes (\d+)-(\d+)\/(\d+)/);
+        if (!match)
+            throw new Error(`Invalid ContentRange format: ${contentRange}`);
+        const start = Number.parseInt(match[1]);
+        const end = Number.parseInt(match[2]);
+        const total = Number.parseInt(match[3]) - 1;
+        const expectedStart = (partNumber - 1) * partSize;
+        const expectedEnd = Math.min(expectedStart + partSize - 1, total);
+        if (start !== expectedStart) {
+            throw new Error(`Expected part ${partNumber} to start at ${expectedStart} but got ${start}`);
+        }
+        if (end !== expectedEnd) {
+            throw new Error(`Expected part ${partNumber} to end at ${expectedEnd} but got ${end}`);
+        }
+    }
+    validateRangeDownload(requestRange, responseRange) {
+        if (!responseRange) {
+            throw new Error(`Missing ContentRange for range ${requestRange}.`);
+        }
+        const match = responseRange.match(/bytes (\d+)-(\d+)\/(\d+)/);
+        if (!match)
+            throw new Error(`Invalid ContentRange format: ${responseRange}`);
+        const start = Number.parseInt(match[1]);
+        const end = Number.parseInt(match[2]);
+        const total = Number.parseInt(match[3]) - 1;
+        const rangeMatch = requestRange.match(/bytes=(\d+)-(\d+)/);
+        if (!rangeMatch)
+            throw new Error(`Invalid Range format: ${requestRange}`);
+        const expectedStart = Number.parseInt(rangeMatch[1]);
+        const expectedEnd = Number.parseInt(rangeMatch[2]);
+        if (start !== expectedStart) {
+            throw new Error(`Expected range to start at ${expectedStart} but got ${start}`);
+        }
+        if (end === expectedEnd) {
+            return;
+        }
+        if (end === total) {
+            return;
+        }
+        throw new Error(`Expected range to end at ${expectedEnd} but got ${end}`);
+    }
+    async uploadSinglePart(request, contentLength, transferOptions, emitEvents) {
+        const putObjectRequest = { ...request };
+        this.checkAborted(transferOptions);
+        const response = await this.s3.send(new PutObjectCommand(putObjectRequest), transferOptions);
+        if (emitEvents) {
+            this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                request,
+                snapshot: {
+                    transferredBytes: contentLength,
+                    totalBytes: contentLength,
+                },
+            }));
+        }
+        return response;
+    }
+    calculatePartSize(contentLength) {
+        const partSize = Math.max(this.targetPartSizeBytes, Math.ceil(contentLength / 10_000));
+        const expectedPartsCount = Math.ceil(contentLength / partSize);
+        return { partSize, expectedPartsCount };
+    }
+    isFileBody(body) {
+        return typeof body?.pipe === "function" && typeof body.path === "string";
+    }
+    isInMemoryBody(body) {
+        return body instanceof Uint8Array || typeof body === "string";
+    }
+    async threadedUploadInPartsFromFile(request, contentLength, transferOptions, emitEvents) {
+        const { partSize } = this.calculatePartSize(contentLength);
+        const body = request.Body;
+        const filePath = body.path;
+        const startOffset = typeof body.start === "number" ? body.start : 0;
+        const buildDataSource = (checksumAlgorithm, checksumHeader) => ({
+            type: "file",
+            filePath,
+            partSize,
+            totalFileSize: contentLength,
+            startOffset,
+            checksumAlgorithm,
+            checksumHeader,
+        });
+        return this.threadedMultipartUpload(request, contentLength, buildDataSource, transferOptions, emitEvents);
+    }
+    async threadedUploadInParts(request, contentLength, transferOptions, emitEvents) {
+        const { partSize } = this.calculatePartSize(contentLength);
+        const body = request.Body;
+        const isSharedBufferBody = body.buffer instanceof SharedArrayBuffer;
+        const sharedBuffer = isSharedBufferBody ? body.buffer : new SharedArrayBuffer(body.byteLength);
+        if (!isSharedBufferBody) {
+            new Uint8Array(sharedBuffer).set(body);
+        }
+        const startOffset = isSharedBufferBody ? body.byteOffset : 0;
+        const buildDataSource = (checksumAlgorithm, checksumHeader) => ({
+            type: "sharedBuffer",
+            sharedBuffer,
+            startOffset,
+            partSize,
+            totalSize: contentLength,
+            checksumAlgorithm,
+            checksumHeader,
+        });
+        return this.threadedMultipartUpload(request, contentLength, buildDataSource, transferOptions, emitEvents);
+    }
+    async getWorkerUploadMaxAttempts() {
+        const maxAttemptsProvider = this.s3.config.maxAttempts;
+        return maxAttemptsProvider();
+    }
+    isRetryableWorkerUploadError(error) {
+        const sdkError = error;
+        return isThrottlingError(sdkError) || isTransientError(sdkError);
+    }
+    async waitForWorkerUploadRetry(attempt) {
+        const maxDelayMs = 1_000;
+        const baseDelayMs = 100;
+        const exponentialDelayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+        const jitteredDelayMs = Math.round(exponentialDelayMs * (0.5 + Math.random()));
+        await new Promise((resolve) => setTimeout(resolve, jitteredDelayMs));
+    }
+    async threadedMultipartUpload(request, contentLength, buildDataSource, transferOptions, emitEvents) {
+        const { partSize, expectedPartsCount } = this.calculatePartSize(contentLength);
+        this.checkAborted(transferOptions);
+        const createMpuRequest = { ...request };
+        const hasFullObjectChecksum = request.ContentMD5 ||
+            request.ChecksumCRC32 ||
+            request.ChecksumCRC32C ||
+            request.ChecksumCRC64NVME ||
+            request.ChecksumSHA1 ||
+            request.ChecksumSHA256;
+        if (hasFullObjectChecksum) {
+            createMpuRequest.ChecksumType = "FULL_OBJECT";
+        }
+        if (!createMpuRequest.ChecksumAlgorithm && this.requestChecksumCalculation === "WHEN_SUPPORTED") {
+            createMpuRequest.ChecksumAlgorithm = request.ChecksumAlgorithm ?? "CRC32";
+        }
+        const createMpuResponse = await this.s3.send(new CreateMultipartUploadCommand(createMpuRequest), transferOptions);
+        const uploadId = createMpuResponse.UploadId;
+        const checksumAlgorithm = createMpuRequest.ChecksumAlgorithm;
+        const checksumHeader = checksumAlgorithm ? `x-amz-checksum-${checksumAlgorithm.toLowerCase()}` : undefined;
+        const dataSource = buildDataSource(checksumAlgorithm, checksumHeader);
+        const abortController = new AbortController();
+        const uploadAbortSignal = abortController.signal;
+        const maxWorkerUploadAttempts = await this.getWorkerUploadMaxAttempts();
+        const sendUploadPart = async (partNumber, length) => {
+            for (let attempt = 1;; attempt++) {
+                if (uploadAbortSignal.aborted) {
+                    throw Object.assign(new Error("Upload aborted due to part failure."), { name: "AbortError" });
+                }
+                this.checkAborted(transferOptions);
+                const partRequest = {
+                    ...request,
+                    Body: this.deps.createEmptyReadable(),
+                    UploadId: uploadId,
+                    PartNumber: partNumber,
+                    ContentLength: length,
+                    ...(checksumAlgorithm && {
+                        ChecksumAlgorithm: checksumAlgorithm,
+                    }),
+                };
+                try {
+                    return await this.s3.send(new UploadPartCommand(partRequest), {
+                        ...transferOptions,
+                        dataSource,
+                    });
+                }
+                catch (error) {
+                    if (attempt >= maxWorkerUploadAttempts || !this.isRetryableWorkerUploadError(error)) {
+                        throw error;
+                    }
+                    const errorName = error.name ?? "unknown error";
+                    this.logger.warn(`Retrying UploadPart ${partNumber} for ${request.Key} after ${errorName} ` +
+                        `(attempt ${attempt + 1}/${maxWorkerUploadAttempts}).`);
+                    await this.waitForWorkerUploadRetry(attempt);
+                }
+            }
+        };
+        try {
+            const completedParts = [];
+            let bytesUploaded = 0;
+            let nextPartNumber = 1;
+            const uploadPart = async () => {
+                while (true) {
+                    const partNumber = nextPartNumber++;
+                    if (partNumber > expectedPartsCount)
+                        return;
+                    if (uploadAbortSignal.aborted) {
+                        throw Object.assign(new Error("Upload aborted due to part failure."), { name: "AbortError" });
+                    }
+                    this.checkAborted(transferOptions);
+                    const offset = (partNumber - 1) * partSize;
+                    const length = Math.min(partSize, contentLength - offset);
+                    const partResponse = await sendUploadPart(partNumber, length);
+                    const completedPart = {
+                        PartNumber: partNumber,
+                        ETag: partResponse.ETag,
+                    };
+                    if (partResponse.ChecksumCRC32)
+                        completedPart.ChecksumCRC32 = partResponse.ChecksumCRC32;
+                    if (partResponse.ChecksumCRC32C)
+                        completedPart.ChecksumCRC32C = partResponse.ChecksumCRC32C;
+                    if (partResponse.ChecksumCRC64NVME)
+                        completedPart.ChecksumCRC64NVME = partResponse.ChecksumCRC64NVME;
+                    if (partResponse.ChecksumSHA1)
+                        completedPart.ChecksumSHA1 = partResponse.ChecksumSHA1;
+                    if (partResponse.ChecksumSHA256)
+                        completedPart.ChecksumSHA256 = partResponse.ChecksumSHA256;
+                    completedParts.push(completedPart);
+                    bytesUploaded += length;
+                    if (emitEvents) {
+                        this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                            request,
+                            snapshot: {
+                                transferredBytes: bytesUploaded,
+                                totalBytes: contentLength,
+                            },
+                        }));
+                    }
+                }
+            };
+            const partUploads = [];
+            for (let i = 0; i < this.maxConcurrentUploads; i++) {
+                partUploads.push(uploadPart().catch((error) => {
+                    abortController.abort();
+                    throw error;
+                }));
+            }
+            await Promise.all(partUploads);
+            if (completedParts.length !== expectedPartsCount) {
+                throw new Error(`Expected ${expectedPartsCount} parts but uploaded ${completedParts.length} parts`);
+            }
+            completedParts.sort((a, b) => a.PartNumber - b.PartNumber);
+            this.checkAborted(transferOptions);
+            const { Body: _body, ...completeRequestFields } = request;
+            const completeRequest = {
+                ...completeRequestFields,
+                UploadId: uploadId,
+                MultipartUpload: { Parts: completedParts },
+                MpuObjectSize: contentLength,
+            };
+            if (hasFullObjectChecksum) {
+                completeRequest.ChecksumType = "FULL_OBJECT";
+                if (request.ChecksumCRC32)
+                    completeRequest.ChecksumCRC32 = request.ChecksumCRC32;
+                if (request.ChecksumCRC32C)
+                    completeRequest.ChecksumCRC32C = request.ChecksumCRC32C;
+                if (request.ChecksumCRC64NVME)
+                    completeRequest.ChecksumCRC64NVME = request.ChecksumCRC64NVME;
+            }
+            try {
+                return await this.s3.send(new CompleteMultipartUploadCommand(completeRequest), transferOptions);
+            }
+            catch (completeMpuError) {
+                this.logger.warn(`CompleteMultipartUpload failed for upload ID ${uploadId}: ${completeMpuError.message}`);
+                throw completeMpuError;
+            }
+        }
+        catch (error) {
+            const { Body: _abortBody, ...abortRequestFields } = request;
+            const abortRequest = {
+                ...abortRequestFields,
+                UploadId: uploadId,
+            };
+            try {
+                await this.s3.send(new AbortMultipartUploadCommand(abortRequest), transferOptions);
+            }
+            catch (abortError) {
+                this.logger.warn(`Failed to abort multipart upload ${uploadId}:`, abortError);
+            }
+            throw error;
+        }
+    }
+    async uploadInParts(request, contentLength, transferOptions, emitEvents) {
+        const { partSize, expectedPartsCount } = this.calculatePartSize(contentLength);
+        this.checkAborted(transferOptions);
+        const createMpuRequest = { ...request };
+        const hasFullObjectChecksum = request.ContentMD5 ||
+            request.ChecksumCRC32 ||
+            request.ChecksumCRC32C ||
+            request.ChecksumCRC64NVME ||
+            request.ChecksumSHA1 ||
+            request.ChecksumSHA256;
+        if (hasFullObjectChecksum) {
+            createMpuRequest.ChecksumType = "FULL_OBJECT";
+        }
+        if (!createMpuRequest.ChecksumAlgorithm && this.requestChecksumCalculation === "WHEN_SUPPORTED") {
+            createMpuRequest.ChecksumAlgorithm = request.ChecksumAlgorithm ?? "CRC32";
+        }
+        const createMpuResponse = await this.s3.send(new CreateMultipartUploadCommand(createMpuRequest), transferOptions);
+        const uploadId = createMpuResponse.UploadId;
+        const abortController = new AbortController();
+        const uploadAbortSignal = abortController.signal;
+        try {
+            const completedParts = [];
+            const dataFeeder = getChunk(request.Body, partSize);
+            let bytesUploaded = 0;
+            const uploadPart = async (dataFeeder) => {
+                for await (const dataPart of dataFeeder) {
+                    if (uploadAbortSignal.aborted) {
+                        throw Object.assign(new Error("Upload aborted due to part failure."), { name: "AbortError" });
+                    }
+                    this.checkAborted(transferOptions);
+                    this.validateUploadPart(dataPart, partSize);
+                    const partRequest = {
+                        ...request,
+                        Body: dataPart.data,
+                        UploadId: uploadId,
+                        PartNumber: dataPart.partNumber,
+                        ContentLength: byteLength(dataPart.data),
+                        ...(this.requestChecksumCalculation === "WHEN_SUPPORTED" && {
+                            ChecksumAlgorithm: request.ChecksumAlgorithm,
+                        }),
+                    };
+                    const partResponse = await this.s3.send(new UploadPartCommand(partRequest), transferOptions);
+                    const checksumAlgorithm = partRequest.ChecksumAlgorithm;
+                    if (checksumAlgorithm &&
+                        !partResponse.ChecksumCRC32 &&
+                        !partResponse.ChecksumCRC32C &&
+                        !partResponse.ChecksumCRC64NVME &&
+                        !partResponse.ChecksumSHA1 &&
+                        !partResponse.ChecksumSHA256) {
+                        throw new Error(`Checksum was requested for part ${dataPart.partNumber} using ${checksumAlgorithm}, but no checksum was returned in the response. ` +
+                            `If running in a browser, ensure your S3 bucket CORS configuration is enabled. `);
+                    }
+                    const completedPart = {
+                        PartNumber: dataPart.partNumber,
+                        ETag: partResponse.ETag,
+                    };
+                    if (partResponse.ChecksumCRC32)
+                        completedPart.ChecksumCRC32 = partResponse.ChecksumCRC32;
+                    if (partResponse.ChecksumCRC32C)
+                        completedPart.ChecksumCRC32C = partResponse.ChecksumCRC32C;
+                    if (partResponse.ChecksumCRC64NVME)
+                        completedPart.ChecksumCRC64NVME = partResponse.ChecksumCRC64NVME;
+                    if (partResponse.ChecksumSHA1)
+                        completedPart.ChecksumSHA1 = partResponse.ChecksumSHA1;
+                    if (partResponse.ChecksumSHA256)
+                        completedPart.ChecksumSHA256 = partResponse.ChecksumSHA256;
+                    completedParts.push(completedPart);
+                    const partLength = byteLength(dataPart.data);
+                    bytesUploaded += partLength;
+                    if (emitEvents) {
+                        this.dispatchEvent(Object.assign(new Event("bytesTransferred"), {
+                            request,
+                            snapshot: {
+                                transferredBytes: bytesUploaded,
+                                totalBytes: contentLength,
+                            },
+                        }));
+                    }
+                }
+            };
+            const partUploads = [];
+            for (let i = 0; i < this.maxConcurrentUploads; i++) {
+                partUploads.push(uploadPart(dataFeeder).catch((error) => {
+                    abortController.abort();
+                    throw error;
+                }));
+            }
+            await Promise.all(partUploads);
+            if (completedParts.length !== expectedPartsCount) {
+                throw new Error(`Expected ${expectedPartsCount} parts but uploaded ${completedParts.length} parts`);
+            }
+            completedParts.sort((a, b) => a.PartNumber - b.PartNumber);
+            this.checkAborted(transferOptions);
+            const { Body: _body, ...completeRequestFields } = request;
+            const completeRequest = {
+                ...completeRequestFields,
+                UploadId: uploadId,
+                MultipartUpload: { Parts: completedParts },
+                MpuObjectSize: contentLength,
+            };
+            if (hasFullObjectChecksum) {
+                completeRequest.ChecksumType = "FULL_OBJECT";
+                if (request.ChecksumCRC32)
+                    completeRequest.ChecksumCRC32 = request.ChecksumCRC32;
+                if (request.ChecksumCRC32C)
+                    completeRequest.ChecksumCRC32C = request.ChecksumCRC32C;
+                if (request.ChecksumCRC64NVME)
+                    completeRequest.ChecksumCRC64NVME = request.ChecksumCRC64NVME;
+            }
+            try {
+                return await this.s3.send(new CompleteMultipartUploadCommand(completeRequest), transferOptions);
+            }
+            catch (completeMpuError) {
+                this.logger.warn(`CompleteMultipartUpload failed for upload ID ${uploadId}: ${completeMpuError.message}`);
+                throw completeMpuError;
+            }
+        }
+        catch (error) {
+            const { Body: _abortBody, ...abortRequestFields } = request;
+            const abortRequest = {
+                ...abortRequestFields,
+                UploadId: uploadId,
+            };
+            try {
+                await this.s3.send(new AbortMultipartUploadCommand(abortRequest), transferOptions);
+            }
+            catch (abortError) {
+                this.logger.warn(`Failed to abort multipart upload ${uploadId}:`, abortError);
+            }
+            throw error;
+        }
+    }
+    async *traverseDirectory(source, options) {
+        const visited = new Set();
+        const dir = await opendir(source, { recursive: options.recursive });
+        for await (const entry of dir) {
+            const fullPath = join(entry.parentPath ?? entry.path ?? source, entry.name);
+            if (entry.isSymbolicLink()) {
+                if (!options.followSymbolicLinks)
+                    continue;
+                const realPath = await realpath(fullPath);
+                const linkStat = await stat(realPath);
+                if (linkStat.isDirectory()) {
+                    if (visited.has(realPath)) {
+                        throw new Error(`Circular symbolic link detected: ${fullPath} -> ${realPath}`);
+                    }
+                    visited.add(realPath);
+                    yield* this.traverseDirectory(realPath, options);
+                    continue;
+                }
+                if (!linkStat.isFile())
+                    continue;
+            }
+            else if (!entry.isFile()) {
+                continue;
+            }
+            yield fullPath;
+        }
+    }
+    deriveS3Key(source, filePath, s3Prefix) {
+        let relativePath = relative(source, filePath);
+        if (sep !== "/") {
+            relativePath = relativePath.split(sep).join("/");
+        }
+        if (!s3Prefix)
+            return relativePath;
+        const normalizedPrefix = s3Prefix.endsWith("/") ? s3Prefix : s3Prefix + "/";
+        return normalizedPrefix + relativePath;
+    }
+    validateUploadPart(dataPart, partSize) {
+        const actualPartSize = byteLength(dataPart.data);
+        if (actualPartSize === undefined) {
+            throw new Error(`A dataPart was generated without a measurable data chunk size for part number ${dataPart.partNumber}`);
+        }
+        if (dataPart.partNumber === 1 && dataPart.lastPart) {
+            return;
+        }
+        if (!dataPart.lastPart && actualPartSize !== partSize) {
+            throw new Error(`The byte size for part number ${dataPart.partNumber}, size ${actualPartSize} does not match expected size ${partSize}`);
+        }
+    }
+}
+export const bindS3TransferManager = (deps) => class S3TransferManager extends S3TransferManagerBase {
+    constructor(config = {}) {
+        super(config, deps);
+    }
+};
+function matchesFilterRegExp(filter, value) {
+    filter.lastIndex = 0;
+    return filter.test(value);
+}
+function parseContentRangeStart(contentRange) {
+    if (!contentRange)
+        return undefined;
+    const match = contentRange.match(/^bytes\s+(\d+)-/);
+    return match ? Number(match[1]) : undefined;
+}
+export const internalEventHandler = {
+    async afterInitialGetObject() { },
+};