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

package/dist-cjs/submodules/transfer-manager/index.js

@@ -0,0 +1,3166 @@
+const { isReadableStream, sdkStreamMixin } = require("@smithy/core/serde");
+const { Readable } = require("node:stream");
+const { S3Client, GetObjectCommand, ListObjectsV2Command, HeadObjectCommand, PutObjectCommand, CreateMultipartUploadCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, UploadPartCommand } = require("@aws-sdk/client-s3");
+const { isThrottlingError, isTransientError } = require("@smithy/core/retry");
+const { ReadStream, lstatSync, existsSync, unlinkSync, createReadStream } = require("node:fs");
+const { stat, mkdir, realpath, open, rename, unlink, opendir } = require("node:fs/promises");
+const path = require("node:path");
+const { resolve, sep, isAbsolute, relative, dirname, join } = require("node:path");
+const { Buffer: Buffer$1 } = require("buffer");
+const { randomBytes } = require("node:crypto");
+const { HttpResponse } = require("@smithy/core/protocols");
+const { NodeHttpHandler } = require("@smithy/node-http-handler");
+const { cpus } = require("node:os");
+const { Worker } = require("node:worker_threads");
+
+async function joinStreams(streams, eventListeners) {
+    const firstStream = await streams[0];
+    if (isReadableStream(firstStream)) {
+        const newReadableStream = new ReadableStream({
+            async start(controller) {
+                for await (const chunk of iterateStreams(streams, eventListeners)) {
+                    controller.enqueue(chunk);
+                }
+                controller.close();
+            },
+        });
+        return sdkStreamMixin(newReadableStream);
+    }
+    else {
+        streams.forEach((stream) => stream?.catch(() => { }));
+        return sdkStreamMixin(Readable.from(iterateStreams(streams, eventListeners)));
+    }
+}
+async function* iterateStreams(promises, eventListeners) {
+    for (const p of promises) {
+        p?.catch(() => { });
+    }
+    let bytesTransferred = 0;
+    let index = 0;
+    for (const streamPromise of promises) {
+        if (!streamPromise) {
+            throw new Error("Stream promise is undefined - lazy prefetch may not have completed");
+        }
+        let stream;
+        try {
+            stream = await streamPromise;
+        }
+        catch (e) {
+            await destroyStreams(promises);
+            eventListeners?.onFailure?.(e, index);
+            throw e;
+        }
+        if (isReadableStream(stream)) {
+            const reader = stream.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    yield value;
+                    bytesTransferred += value.byteLength;
+                    eventListeners?.onBytes?.(bytesTransferred, index);
+                }
+            }
+            catch (e) {
+                await destroyStreams(promises);
+                eventListeners?.onFailure?.(e, index);
+                throw e;
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        else if (stream instanceof Readable) {
+            try {
+                for await (const chunk of stream) {
+                    yield chunk;
+                    const chunkSize = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk);
+                    bytesTransferred += chunkSize;
+                    eventListeners?.onBytes?.(bytesTransferred, index);
+                }
+            }
+            catch (e) {
+                await destroyStreams(promises);
+                eventListeners?.onFailure?.(e, index);
+                throw e;
+            }
+        }
+        else {
+            await destroyStreams(promises);
+            const failure = new Error(`unhandled stream type ${stream?.constructor?.name}`);
+            eventListeners?.onFailure?.(failure, index);
+            throw failure;
+        }
+        eventListeners?.onStreamConsumed?.(index);
+        index++;
+    }
+    eventListeners?.onCompletion?.(bytesTransferred, index - 1);
+}
+async function destroyStreams(promises) {
+    await Promise.all(promises.map(async (streamPromise) => {
+        if (!streamPromise)
+            return;
+        return streamPromise
+            .then((stream) => {
+            if (stream instanceof Readable) {
+                stream.on("error", () => { });
+                stream.destroy();
+                return;
+            }
+            else if (isReadableStream(stream)) {
+                return stream.cancel();
+            }
+        })
+            .catch((e) => { });
+    }));
+}
+
+const byteLength = (input) => {
+    if (input == null) {
+        return 0;
+    }
+    if (typeof input === "string") {
+        return Buffer$1.byteLength(input);
+    }
+    if (typeof input.byteLength === "number") {
+        return input.byteLength;
+    }
+    else if (typeof input.length === "number") {
+        return input.length;
+    }
+    else if (typeof input.size === "number") {
+        return input.size;
+    }
+    else if (input instanceof ReadStream) {
+        const { start: rangeStart, end: rangeEnd } = input;
+        let size;
+        try {
+            size = lstatSync(input.path).size;
+        }
+        catch {
+            return undefined;
+        }
+        const start = typeof rangeStart === "number" ? rangeStart : 0;
+        const endExclusive = Number.isFinite(rangeEnd) ? Math.min(rangeEnd + 1, size) : size;
+        return Math.max(0, endExclusive - start);
+    }
+    else if (typeof input.start === "number" && typeof input.end === "number") {
+        return input.end + 1 - input.start;
+    }
+    return undefined;
+};
+async function* getChunkStream(data, partSize, getNextData) {
+    let partNumber = 1;
+    const currentBuffer = { chunks: [], length: 0 };
+    for await (const datum of getNextData(data)) {
+        currentBuffer.chunks.push(datum);
+        currentBuffer.length += datum.byteLength;
+        while (currentBuffer.length > partSize) {
+            const dataChunk = currentBuffer.chunks.length > 1 ? Buffer$1.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
+            yield { partNumber, data: dataChunk.subarray(0, partSize) };
+            currentBuffer.chunks = [dataChunk.subarray(partSize)];
+            currentBuffer.length = currentBuffer.chunks[0].byteLength;
+            partNumber += 1;
+        }
+    }
+    yield {
+        partNumber,
+        data: currentBuffer.chunks.length !== 1 ? Buffer$1.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
+        lastPart: true,
+    };
+}
+async function* getChunkUint8Array(data, partSize) {
+    let partNumber = 1;
+    let startByte = 0;
+    let endByte = partSize;
+    while (endByte < data.byteLength) {
+        yield { partNumber, data: data.subarray(startByte, endByte) };
+        partNumber += 1;
+        startByte = endByte;
+        endByte = startByte + partSize;
+    }
+    yield { partNumber, data: data.subarray(startByte), lastPart: true };
+}
+async function* getDataReadable(data) {
+    for await (const chunk of data) {
+        if (Buffer$1.isBuffer(chunk) || chunk instanceof Uint8Array) {
+            yield chunk;
+        }
+        else {
+            yield Buffer$1.from(chunk);
+        }
+    }
+}
+async function* getDataReadableStream(data) {
+    const reader = data.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (Buffer$1.isBuffer(value) || value instanceof Uint8Array) {
+                yield value;
+            }
+            else {
+                yield Buffer$1.from(value);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+const getChunk = (data, partSize) => {
+    if (data instanceof Uint8Array) {
+        return getChunkUint8Array(data, partSize);
+    }
+    if (data instanceof String || typeof data === "string") {
+        return getChunkUint8Array(Buffer$1.from(data), partSize);
+    }
+    if (data instanceof ReadableStream) {
+        return getChunkStream(data, partSize, getDataReadableStream);
+    }
+    if (typeof data.stream === "function") {
+        return getChunkStream(data.stream(), partSize, getDataReadableStream);
+    }
+    if (Symbol.asyncIterator in data || typeof data[Symbol.asyncIterator] === "function") {
+        return getChunkStream(data, partSize, getDataReadable);
+    }
+    throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
+};
+
+class Semaphore {
+    limit;
+    inFlightRequests = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async acquire(count = 1) {
+        if (this.inFlightRequests < this.limit) {
+            this.inFlightRequests += count;
+            return;
+        }
+        await new Promise((resolve) => this.waiters.push(resolve));
+        this.inFlightRequests += count;
+    }
+    release(count = 1) {
+        this.inFlightRequests -= count;
+        while (this.waiters.length > 0 && this.inFlightRequests < this.limit) {
+            const next = this.waiters.shift();
+            if (next) {
+                next();
+            }
+        }
+    }
+}
+async function validateDirectory(dirPath) {
+    const absolutePath = resolve(dirPath);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch (error) {
+        throw new Error(`Cannot access directory at: ${absolutePath}, ${error.message}`);
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${absolutePath}`);
+    }
+    return absolutePath;
+}
+async function handleFailure(policy, context, abortController) {
+    if (policy === "terminate") {
+        abortController.abort();
+        return "terminate";
+    }
+    if (policy === "continue") {
+        return "continue";
+    }
+    try {
+        const result = await policy(context);
+        if (result === "terminate") {
+            abortController.abort();
+        }
+        return result;
+    }
+    catch {
+        abortController.abort();
+        return "terminate";
+    }
+}
+async function createDestinationDirectory(dirPath) {
+    const absolutePath = resolve(dirPath);
+    if (existsSync(absolutePath)) {
+        return validateDirectory(absolutePath);
+    }
+    await mkdir(absolutePath, { recursive: true });
+    return absolutePath;
+}
+function isFolderObject(object) {
+    return (object.Key?.endsWith("/") ?? false) && (object.Size ?? 0) === 0;
+}
+function deriveLocalPath(destination, key) {
+    const normalizedKey = sep === "/" ? key : key.split("/").join(sep);
+    if (isAbsolute(normalizedKey)) {
+        throw new Error(`Object key resolves to an absolute path and would escape the destination directory: ${key}`);
+    }
+    const fullPath = resolve(destination, normalizedKey);
+    const destinationWithSep = destination.endsWith(sep) ? destination : destination + sep;
+    if (fullPath !== destination && !fullPath.startsWith(destinationWithSep)) {
+        throw new Error(`Object key "${key}" resolves to a path outside the destination directory. Path traversal is not allowed.`);
+    }
+    return fullPath;
+}
+async function createLocalParentDirectories(destination, localPath) {
+    const canonicalDestination = await realpath(destination);
+    const relativeParent = relative(destination, dirname(localPath));
+    let currentDirectory = destination;
+    for (const segment of relativeParent.split(sep)) {
+        if (!segment || segment === ".") {
+            continue;
+        }
+        currentDirectory = join(currentDirectory, segment);
+        await mkdir(currentDirectory, { recursive: true });
+        const canonicalDirectory = await realpath(currentDirectory);
+        const canonicalRelative = relative(canonicalDestination, canonicalDirectory);
+        if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${sep}`) || isAbsolute(canonicalRelative)) {
+            throw new Error("Symbolic links outside the destination are not allowed.");
+        }
+    }
+}
+
+class FileManager {
+    cleanupHandlers = new Map();
+    async createTempFile(destination, totalSize) {
+        const tempFilePath = `${destination}.s3tmp.${this.generateUniqueId()}`;
+        const fd = await open(tempFilePath, "wx");
+        try {
+            await fd.truncate(totalSize);
+        }
+        finally {
+            await fd.close();
+        }
+        return tempFilePath;
+    }
+    async atomicRename(tempFilePath, destination) {
+        try {
+            await rename(tempFilePath, destination);
+        }
+        catch (renameError) {
+            if (renameError.code === "EEXIST" || renameError.code === "EPERM") {
+                try {
+                    await unlink(destination);
+                    await rename(tempFilePath, destination);
+                }
+                catch (fallbackError) {
+                    await this.deleteTempFile(tempFilePath);
+                    throw new Error(`Failed to rename temp file to destination: ${fallbackError.message || fallbackError.code}`);
+                }
+            }
+            else {
+                await this.deleteTempFile(tempFilePath);
+                throw new Error(`Failed to rename temp file to destination: ${renameError.message || renameError.code}`);
+            }
+        }
+    }
+    async deleteTempFile(tempFilePath) {
+        this.unregisterCleanupHandler(tempFilePath);
+        try {
+            await unlink(tempFilePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    registerCleanupHandler(tempFilePath) {
+        const exitHandler = () => {
+            try {
+                unlinkSync(tempFilePath);
+            }
+            catch {
+            }
+        };
+        process.on("exit", exitHandler);
+        this.cleanupHandlers.set(tempFilePath, { exitHandler });
+    }
+    unregisterCleanupHandler(tempFilePath) {
+        const handlers = this.cleanupHandlers.get(tempFilePath);
+        if (handlers) {
+            process.removeListener("exit", handlers.exitHandler);
+            this.cleanupHandlers.delete(tempFilePath);
+        }
+    }
+    generateUniqueId() {
+        return randomBytes(4).toString("hex");
+    }
+}
+
+class LogLevel {
+    minimum;
+    logger;
+    static LEVELS = ["trace", "debug", "info", "warn", "error"];
+    level = 5;
+    constructor(minimum, logger = console) {
+        this.minimum = minimum;
+        this.logger = logger;
+        const index = LogLevel.LEVELS.indexOf(minimum);
+        if (index === -1) {
+            throw new Error(`Log level must be one of ${LogLevel.LEVELS.join(", ")}`);
+        }
+        this.level = index;
+    }
+    trace(...args) {
+        this.level <= 0 && this.logger.trace?.(...args);
+    }
+    debug(...args) {
+        this.level <= 1 && this.logger.debug?.(...args);
+    }
+    info(...args) {
+        this.level <= 2 && this.logger.info?.(...args);
+    }
+    warn(...args) {
+        this.level <= 3 && this.logger.warn?.(...args);
+    }
+    error(...args) {
+        this.level <= 4 && this.logger.error?.(...args);
+    }
+}
+
+class OrderedPartQueue {
+    pending = new Map();
+    nextExpected = 0;
+    totalParts;
+    waitingConsumer = null;
+    error = undefined;
+    constructor(totalParts) {
+        this.totalParts = totalParts;
+    }
+    enqueue(rangeIndex, buffer, byteLength) {
+        if (this.error)
+            return;
+        if (rangeIndex === this.nextExpected && this.waitingConsumer) {
+            const consumer = this.waitingConsumer;
+            this.waitingConsumer = null;
+            this.nextExpected++;
+            consumer({ buffer, byteLength });
+        }
+        else {
+            this.pending.set(rangeIndex, { buffer, byteLength });
+        }
+    }
+    async dequeue() {
+        if (this.error) {
+            throw this.error;
+        }
+        if (this.nextExpected >= this.totalParts) {
+            return null;
+        }
+        const ready = this.pending.get(this.nextExpected);
+        if (ready) {
+            this.pending.delete(this.nextExpected);
+            this.nextExpected++;
+            return ready;
+        }
+        return new Promise((resolve) => {
+            this.waitingConsumer = resolve;
+        });
+    }
+    setError(error) {
+        this.error = error;
+        if (this.waitingConsumer) {
+            const consumer = this.waitingConsumer;
+            this.waitingConsumer = null;
+            consumer(null);
+        }
+    }
+    hasError() {
+        return this.error !== undefined;
+    }
+    getError() {
+        return this.error;
+    }
+    get pendingCount() {
+        return this.pending.size;
+    }
+}
+
+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();
+            }
+        };
+        (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();
+            }
+        };
+        (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}`);
+        }
+    }
+}
+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;
+}
+const internalEventHandler = {
+    async afterInitialGetObject() { },
+};
+
+function buildDownloadError(msg) {
+    const error = new Error(msg.error);
+    if (msg.name)
+        error.name = msg.name;
+    if (msg.code)
+        error.code = msg.code;
+    return error;
+}
+function createEmptyReadable() {
+    return new Readable({
+        read() {
+            this.push(null);
+        },
+    });
+}
+function defaultWorkerCount() {
+    return cpus().length;
+}
+class WorkerHttpHandler {
+    workers = [];
+    inflightRequests = new Map();
+    inflightDownloads = new Map();
+    inflightStreamDownloads = new Map();
+    nextRequestId = 0;
+    workerInflightCounts = [];
+    workerThreadCount;
+    maxConcurrentUploads;
+    maxConcurrentDownloads;
+    useODirect;
+    logger;
+    initialized = false;
+    initPromise;
+    fallbackHandler;
+    completedDownloads = new Map();
+    completedTransfers = new Map();
+    metadata = { handlerProtocol: "http/1.1" };
+    constructor(options) {
+        this.workerThreadCount = options?.workerThreadCount ?? defaultWorkerCount();
+        this.maxConcurrentUploads = options?.maxConcurrentUploads ?? 32;
+        this.maxConcurrentDownloads = options?.maxConcurrentDownloads ?? 32;
+        this.useODirect = options?.useODirect ?? false;
+        this.logger = options?.logger;
+        this.fallbackHandler = new NodeHttpHandler();
+    }
+    getDownloadResult(token) {
+        const result = this.completedDownloads.get(token);
+        if (result) {
+            this.completedDownloads.delete(token);
+        }
+        return result;
+    }
+    getStreamDownloadResult(token) {
+        const result = this.completedTransfers.get(token);
+        if (result) {
+            this.completedTransfers.delete(token);
+        }
+        return result;
+    }
+    resolveWorkerConfig() {
+        const submodulePath = path.join(__dirname, "..", "worker", "index.js");
+        if (existsSync(submodulePath)) {
+            return { workerPath: submodulePath };
+        }
+        const tsPath = path.join(__dirname, "..", "worker", "index.ts");
+        if (existsSync(tsPath)) {
+            return { workerPath: tsPath, workerOptions: { execArgv: ["--require", "tsx/cjs"] } };
+        }
+        return { workerPath: submodulePath };
+    }
+    ensureInitialized() {
+        if (this.initialized)
+            return Promise.resolve();
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = new Promise((resolve, reject) => {
+            const { workerPath, workerOptions } = this.resolveWorkerConfig();
+            let readyCount = 0;
+            let errorCount = 0;
+            let settled = false;
+            this.workerInflightCounts = new Array(this.workerThreadCount).fill(0);
+            for (let i = 0; i < this.workerThreadCount; i++) {
+                const worker = new Worker(workerPath, workerOptions);
+                this.workers.push(worker);
+                const workerIndex = i;
+                worker.on("message", (msg) => {
+                    if (msg.type === "ready") {
+                        worker.postMessage({
+                            type: "config",
+                            maxSockets: Math.max(50, Math.ceil(Math.max(this.maxConcurrentUploads, this.maxConcurrentDownloads) / this.workerThreadCount)),
+                            useODirect: this.useODirect,
+                        });
+                        readyCount++;
+                        if (!settled && readyCount === this.workerThreadCount) {
+                            settled = true;
+                            this.initialized = true;
+                            resolve();
+                        }
+                        return;
+                    }
+                    if (msg.type === "workerLog") {
+                        this.logger?.[msg.level]?.(`[S3TransferManager:worker] ${msg.message}`);
+                        return;
+                    }
+                    if (msg.type === "httpResponse") {
+                        const pending = this.inflightRequests.get(msg.id);
+                        this.inflightRequests.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            pending.resolve({
+                                response: new HttpResponse({
+                                    statusCode: msg.response.statusCode,
+                                    headers: msg.response.headers,
+                                    body: msg.response.body,
+                                }),
+                            });
+                        }
+                        return;
+                    }
+                    if (msg.type === "httpError") {
+                        const pending = this.inflightRequests.get(msg.id);
+                        this.inflightRequests.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            const error = Object.assign(new Error(msg.error), {
+                                ...(msg.code && { code: msg.code }),
+                                ...(msg.name && { name: msg.name }),
+                            });
+                            pending.reject(error);
+                        }
+                        return;
+                    }
+                    if (msg.type === "httpDownloadResult") {
+                        const pending = this.inflightDownloads.get(msg.id);
+                        this.inflightDownloads.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            pending.resolve({
+                                statusCode: msg.statusCode,
+                                headers: msg.headers,
+                                bytesWritten: msg.bytesWritten,
+                                checksum: msg.checksum,
+                            });
+                        }
+                        return;
+                    }
+                    if (msg.type === "httpDownloadError") {
+                        const pending = this.inflightDownloads.get(msg.id);
+                        this.inflightDownloads.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            pending.reject(buildDownloadError(msg));
+                            return;
+                        }
+                        const pendingTransfer = this.inflightStreamDownloads.get(msg.id);
+                        this.inflightStreamDownloads.delete(msg.id);
+                        if (pendingTransfer) {
+                            this.workerInflightCounts[pendingTransfer.workerIndex]--;
+                            pendingTransfer.reject(buildDownloadError(msg));
+                        }
+                        return;
+                    }
+                    if (msg.type === "httpDownloadHttpError") {
+                        const pending = this.inflightDownloads.get(msg.id);
+                        this.inflightDownloads.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            pending.resolve({
+                                statusCode: msg.statusCode,
+                                headers: msg.headers,
+                                bytesWritten: 0,
+                                errorBody: msg.body,
+                            });
+                            return;
+                        }
+                        const pendingTransfer = this.inflightStreamDownloads.get(msg.id);
+                        this.inflightStreamDownloads.delete(msg.id);
+                        if (pendingTransfer) {
+                            this.workerInflightCounts[pendingTransfer.workerIndex]--;
+                            pendingTransfer.resolve({
+                                rangeIndex: -1,
+                                buffer: new ArrayBuffer(0),
+                                byteLength: 0,
+                                statusCode: msg.statusCode,
+                                headers: msg.headers,
+                                errorBody: msg.body,
+                            });
+                        }
+                        return;
+                    }
+                    if (msg.type === "httpDownloadStreamResult") {
+                        const pending = this.inflightStreamDownloads.get(msg.id);
+                        this.inflightStreamDownloads.delete(msg.id);
+                        if (pending) {
+                            this.workerInflightCounts[pending.workerIndex]--;
+                            pending.resolve({
+                                rangeIndex: msg.rangeIndex,
+                                buffer: msg.buffer,
+                                byteLength: msg.byteLength,
+                                statusCode: msg.statusCode,
+                                headers: msg.headers,
+                                checksum: msg.checksum,
+                            });
+                        }
+                        return;
+                    }
+                });
+                worker.on("error", (err) => {
+                    if (!settled) {
+                        errorCount++;
+                        if (errorCount + readyCount === this.workerThreadCount) {
+                            settled = true;
+                            this.initPromise = undefined;
+                            reject(new Error(`Failed to initialize worker threads: ${err.message}`));
+                        }
+                    }
+                    for (const [id, pending] of this.inflightRequests) {
+                        if (pending.workerIndex === workerIndex) {
+                            pending.reject(err);
+                            this.inflightRequests.delete(id);
+                        }
+                    }
+                    for (const [id, pending] of this.inflightDownloads) {
+                        if (pending.workerIndex === workerIndex) {
+                            pending.reject(err);
+                            this.inflightDownloads.delete(id);
+                        }
+                    }
+                    for (const [id, pending] of this.inflightStreamDownloads) {
+                        if (pending.workerIndex === workerIndex) {
+                            pending.reject(err);
+                            this.inflightStreamDownloads.delete(id);
+                        }
+                    }
+                    this.workerInflightCounts[workerIndex] = Infinity;
+                });
+            }
+        });
+        return this.initPromise;
+    }
+    pickWorkerIndex() {
+        let minIndex = 0;
+        for (let i = 1; i < this.workerInflightCounts.length; i++) {
+            if (this.workerInflightCounts[i] < this.workerInflightCounts[minIndex]) {
+                minIndex = i;
+            }
+        }
+        return minIndex;
+    }
+    dispatchToWorker(id, message) {
+        const workerIndex = this.pickWorkerIndex();
+        this.workerInflightCounts[workerIndex]++;
+        return new Promise((resolve, reject) => {
+            this.inflightRequests.set(id, { resolve, reject, workerIndex });
+            this.workers[workerIndex].postMessage(message);
+        });
+    }
+    dispatchDownloadToWorker(id, message) {
+        const workerIndex = this.pickWorkerIndex();
+        this.workerInflightCounts[workerIndex]++;
+        return new Promise((resolve, reject) => {
+            this.inflightDownloads.set(id, { resolve, reject, workerIndex });
+            this.workers[workerIndex].postMessage(message);
+        });
+    }
+    extractPartNumber(request) {
+        const partNumber = request.query?.partNumber;
+        if (partNumber) {
+            return Number(Array.isArray(partNumber) ? partNumber[0] : partNumber);
+        }
+        return undefined;
+    }
+    returnBuffer(buffer, workerIndex) {
+        const targetIndex = workerIndex ?? this.nextRequestId % this.workers.length;
+        const message = { type: "returnBuffer", buffer };
+        this.workers[targetIndex]?.postMessage(message, [buffer]);
+    }
+    async handle(request, options) {
+        const downloadDataToFile = options?.downloadDataToFile;
+        if (downloadDataToFile) {
+            await this.ensureInitialized();
+            const id = this.nextRequestId++;
+            const serializedRequest = {
+                method: request.method,
+                protocol: request.protocol,
+                hostname: request.hostname,
+                port: request.port,
+                path: request.path,
+                query: request.query,
+                headers: request.headers,
+            };
+            const message = {
+                type: "httpDownloadToFile",
+                id,
+                request: serializedRequest,
+                filePath: downloadDataToFile.filePath,
+                offset: downloadDataToFile.offset,
+                expectedLength: downloadDataToFile.expectedLength,
+                checksumAlgorithm: downloadDataToFile.checksumAlgorithm,
+            };
+            const result = await this.dispatchDownloadToWorker(id, message);
+            if (result.errorBody !== undefined) {
+                return {
+                    response: new HttpResponse({
+                        statusCode: result.statusCode,
+                        headers: result.headers,
+                        body: Readable.from([Buffer.from(result.errorBody)]),
+                    }),
+                };
+            }
+            if (downloadDataToFile.resultToken) {
+                this.completedDownloads.set(downloadDataToFile.resultToken, {
+                    bytesWritten: result.bytesWritten,
+                    checksum: result.checksum,
+                });
+            }
+            const responseHeaders = {};
+            for (const [key, value] of Object.entries(result.headers)) {
+                if (!key.startsWith("x-amz-checksum-")) {
+                    responseHeaders[key] = value;
+                }
+            }
+            return {
+                response: new HttpResponse({
+                    statusCode: result.statusCode,
+                    headers: responseHeaders,
+                    body: createEmptyReadable(),
+                }),
+            };
+        }
+        const downloadStream = options?.downloadStream;
+        if (downloadStream) {
+            await this.ensureInitialized();
+            const id = this.nextRequestId++;
+            const serializedRequest = {
+                method: request.method,
+                protocol: request.protocol,
+                hostname: request.hostname,
+                port: request.port,
+                path: request.path,
+                query: request.query,
+                headers: request.headers,
+            };
+            const message = {
+                type: "httpDownloadStream",
+                id,
+                request: serializedRequest,
+                expectedSize: downloadStream.expectedSize,
+                rangeIndex: downloadStream.rangeIndex,
+                checksumAlgorithm: downloadStream.checksumAlgorithm,
+            };
+            const workerIndex = this.pickWorkerIndex();
+            this.workerInflightCounts[workerIndex]++;
+            const result = await new Promise((resolve, reject) => {
+                this.inflightStreamDownloads.set(id, { resolve, reject, workerIndex });
+                this.workers[workerIndex].postMessage(message);
+            });
+            if (result.errorBody !== undefined) {
+                return {
+                    response: new HttpResponse({
+                        statusCode: result.statusCode,
+                        headers: result.headers,
+                        body: Readable.from([Buffer.from(result.errorBody)]),
+                    }),
+                };
+            }
+            const responseHeaders = {};
+            for (const [key, value] of Object.entries(result.headers)) {
+                if (!key.startsWith("x-amz-checksum-")) {
+                    responseHeaders[key] = value;
+                }
+            }
+            if (downloadStream.resultToken) {
+                this.completedTransfers.set(downloadStream.resultToken, result);
+            }
+            return {
+                response: new HttpResponse({
+                    statusCode: result.statusCode,
+                    headers: responseHeaders,
+                    body: createEmptyReadable(),
+                }),
+            };
+        }
+        const dataSource = options?.dataSource;
+        const partNumber = this.extractPartNumber(request);
+        if (!dataSource || !partNumber) {
+            return this.fallbackHandler.handle(request, options);
+        }
+        await this.ensureInitialized();
+        const id = this.nextRequestId++;
+        const serializedRequest = {
+            method: request.method,
+            protocol: request.protocol,
+            hostname: request.hostname,
+            port: request.port,
+            path: request.path,
+            query: request.query,
+            headers: request.headers,
+        };
+        if (dataSource.type === "file") {
+            const { filePath, partSize, totalFileSize, startOffset = 0, checksumAlgorithm, checksumHeader } = dataSource;
+            const partOffset = (partNumber - 1) * partSize;
+            const length = Math.min(partSize, totalFileSize - partOffset);
+            const offset = startOffset + partOffset;
+            const message = {
+                type: "httpRequestFromFile",
+                id,
+                request: serializedRequest,
+                filePath,
+                offset,
+                length,
+                checksumAlgorithm,
+                checksumHeader,
+            };
+            return this.dispatchToWorker(id, message);
+        }
+        const { sharedBuffer, startOffset = 0, partSize, totalSize, checksumAlgorithm, checksumHeader } = dataSource;
+        const partOffset = (partNumber - 1) * partSize;
+        const offset = startOffset + partOffset;
+        const length = Math.min(partSize, totalSize - partOffset);
+        const message = {
+            type: "httpRequestFromRAM",
+            id,
+            request: serializedRequest,
+            sharedBuffer,
+            offset,
+            length,
+            checksumAlgorithm,
+            checksumHeader,
+        };
+        return this.dispatchToWorker(id, message);
+    }
+    updateHttpClientConfig(_key, _value) { }
+    httpHandlerConfigs() {
+        return {};
+    }
+    destroy() {
+        for (const worker of this.workers) {
+            worker.postMessage({ type: "done" });
+        }
+        this.workers = [];
+        this.workerInflightCounts = [];
+        this.initialized = false;
+        this.initPromise = undefined;
+        this.fallbackHandler.destroy();
+    }
+}
+
+class S3TransferManager extends bindS3TransferManager({
+    joinStreams,
+    destroyStreams,
+    WorkerHttpHandler,
+    createEmptyReadable,
+    defaultWorkerCount,
+}) {
+}
+
+exports.S3TransferManager = S3TransferManager;