s3mini 0.9.0 → 0.9.2

package/dist/s3mini.d.ts

@@ -7,6 +7,7 @@ interface S3Config {
     requestAbortTimeout?: number;
     logger?: Logger;
     fetch?: typeof fetch;
+    minPartSize?: number;
 }
 interface SSECHeaders {
     'x-amz-server-side-encryption-customer-algorithm': string;
@@ -124,13 +125,11 @@ interface CopyObjectResult {
     etag: string;
     lastModified?: Date;
 }
-/**
- * Where Buffer is available, e.g. when @types/node is loaded, we want to use it.
- * But it should be excluded in other environments (e.g. Cloudflare).
- */
+type BinaryData = ArrayBuffer | Uint8Array;
 type MaybeBuffer = typeof globalThis extends {
     Buffer?: infer B;
-} ? B extends new (...a: unknown[]) => unknown ? InstanceType<B> : ArrayBuffer | Uint8Array : ArrayBuffer | Uint8Array;
+} ? B extends new (...a: unknown[]) => unknown ? InstanceType<B> | BinaryData : BinaryData : BinaryData;
+type DataInput = string | MaybeBuffer | ReadableStream | File | Blob;
 
 /**
  * S3 class for interacting with S3-compatible object storage services.
@@ -164,9 +163,10 @@ declare class S3mini {
     readonly requestAbortTimeout?: number;
     readonly logger?: Logger;
     readonly _fetch: typeof fetch;
+    readonly minPartSize: number;
     private signingKeyDate?;
     private signingKey?;
-    constructor({ accessKeyId, secretAccessKey, endpoint, region, requestSizeInBytes, requestAbortTimeout, logger, fetch, }: S3Config);
+    constructor({ accessKeyId, secretAccessKey, endpoint, region, requestSizeInBytes, requestAbortTimeout, logger, fetch, minPartSize, }: S3Config);
     private _sanitize;
     private _log;
     private _validateConstructorParams;
@@ -182,7 +182,6 @@ declare class S3mini {
     private _checkPrefix;
     private _checkOpts;
     private _filterIfHeaders;
-    private _validateData;
     private _validateUploadPartParams;
     private _sign;
     private _signedRequest;
@@ -353,7 +352,7 @@ declare class S3mini {
     /**
      * Uploads an object to the S3-compatible service.
      * @param {string} key - The key/path where the object will be stored.
-     * @param {string | Buffer} data - The data to upload (string or Buffer).
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data to upload (string or Buffer).
      * @param {string} [fileType='application/octet-stream'] - The MIME type of the file.
      * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
      * @param {IT.AWSHeaders} [additionalHeaders] - Additional x-amz-* headers specific to this request, if any.
@@ -367,7 +366,38 @@ declare class S3mini {
      * const buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
      * await s3.putObject('image.png', buffer, 'image/png');
      */
-    putObject(key: string, data: string | MaybeBuffer, fileType?: string, ssecHeaders?: SSECHeaders, additionalHeaders?: AWSHeaders): Promise<Response>;
+    putObject(key: string, data: string | DataInput | ReadableStream | File | Blob, fileType?: string, ssecHeaders?: SSECHeaders, additionalHeaders?: AWSHeaders, contentLength?: number): Promise<Response>;
+    /**
+     * Put object that automatically chooses single PUT vs multipart.
+     * Same signature/shape as putObject so callers don't need to change.
+     * @param {string} key - The key/path where the object will be stored.
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data to upload (string or Buffer).
+     * @param {string} [fileType='application/octet-stream'] - The MIME type of the file.
+     * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
+     * @param {IT.AWSHeaders} [additionalHeaders] - Additional x-amz-* headers specific to this request, if any.
+     * @param {number} [contentLength] - Optional known content length of data.
+     * @returns {Promise<Response | { ok: boolean; status: number; headers: Map<string, string> }>} A promise that resolves to the Response object from the upload request.
+     * @throws {TypeError} If data is not a string or Buffer.
+     * @example
+     * // Upload text file
+     * await s3.putAnyObject('hello.txt', 'Hello, World!', 'text/plain');
+     *
+     * // Upload binary data
+     * const buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+     * await s3.putAnyObject('image.png', buffer, 'image/png');
+     */
+    putAnyObject(key: string, data: DataInput, fileType?: string, ssecHeaders?: SSECHeaders, additionalHeaders?: AWSHeaders, contentLength?: number): Promise<Response | {
+        ok: boolean;
+        status: number;
+        headers: Map<string, string>;
+    }>;
+    private _multipartUpload;
+    private _uploadKnownSizePartsParallel;
+    private _uploadPartsOptimized;
+    private _uploadStreamingParts;
+    private _uploadPartWithRetry;
+    private _safeAbortUpload;
+    private _createSuccessResponse;
     /**
      * Initiates a multipart upload and returns the upload ID.
      * @param {string} key - The key/path where the object will be stored.
@@ -380,12 +410,12 @@ declare class S3mini {
      * const uploadId = await s3.getMultipartUploadId('large-file.zip', 'application/zip');
      * console.log(`Started multipart upload: ${uploadId}`);
      */
-    getMultipartUploadId(key: string, fileType?: string, ssecHeaders?: SSECHeaders): Promise<string>;
+    getMultipartUploadId(key: string, fileType?: string, ssecHeaders?: SSECHeaders, additionalHeaders?: AWSHeaders): Promise<string>;
     /**
      * Uploads a part in a multipart upload.
      * @param {string} key - The key of the object being uploaded.
      * @param {string} uploadId - The upload ID from getMultipartUploadId.
-     * @param {Buffer | string} data - The data for this part.
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data for this part.
      * @param {number} partNumber - The part number (must be between 1 and 10,000).
      * @param {Record<string, unknown>} [opts={}] - Additional options for the request.
      * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
@@ -400,7 +430,7 @@ declare class S3mini {
      * );
      * console.log(`Part ${part.partNumber} uploaded with ETag: ${part.etag}`);
      */
-    uploadPart(key: string, uploadId: string, data: MaybeBuffer | string, partNumber: number, opts?: Record<string, unknown>, ssecHeaders?: SSECHeaders): Promise<UploadPart>;
+    uploadPart(key: string, uploadId: string, data: DataInput, partNumber: number, opts?: Record<string, unknown>, ssecHeaders?: SSECHeaders, additionalHeaders?: AWSHeaders): Promise<UploadPart>;
     /**
      * Completes a multipart upload by combining all uploaded parts.
      * @param {string} key - The key of the object being uploaded.
@@ -559,6 +589,29 @@ declare class S3mini {
     private _parseErrorXml;
     private _handleErrorResponse;
     private _buildCanonicalQueryString;
+    /**
+     * Generates a pre-signed URL for direct client access to an S3 object.
+     * The URL embeds authentication in query parameters instead of headers,
+     * allowing unauthenticated HTTP clients to perform the specified operation.
+     *
+     * @param {'GET' | 'PUT'} method - HTTP method ('GET' for download, 'PUT' for upload)
+     * @param {string} key - The object key/path
+     * @param {number} [expiresIn=3600] - URL expiration time in seconds (1–604800)
+     * @param {Record<string, string>} [queryParams={}] - Additional query parameters to sign
+     * @returns {Promise<string>} Pre-signed URL string
+     * @throws {TypeError} If key is empty or expiresIn is out of range
+     * @example
+     * // Download URL valid for 1 hour
+     * const url = await s3.getPresignedUrl('GET', 'photos/vacation.jpg');
+     *
+     * // Upload URL valid for 5 minutes
+     * const url = await s3.getPresignedUrl('PUT', 'uploads/file.bin', 300);
+     *
+     * // Client-side usage (no credentials needed)
+     * await fetch(url, { method: 'PUT', body: data });
+     */
+    getPresignedUrl(method: 'GET' | 'PUT', key: string, expiresIn?: number, queryParams?: Record<string, string>): Promise<string>;
+    private _presign;
     private _getSignatureKey;
 }
 

package/dist/s3mini.js

@@ -10,6 +10,7 @@ const XML_CONTENT_TYPE = 'application/xml';
 const SENSITIVE_KEYS_REDACTED = new Set(['accesskeyid', 'secretaccesskey', 'sessiontoken', 'password', 'token']);
 const IFHEADERS = new Set(['if-match', 'if-none-match', 'if-modified-since', 'if-unmodified-since']);
 const DEFAULT_REQUEST_SIZE_IN_BYTES = 8 * 1024 * 1024;
+const MIN_PART_SIZE = 8 * 1024 * 1024;
 // Headers
 const HEADER_AMZ_CONTENT_SHA256 = 'x-amz-content-sha256';
 const HEADER_AMZ_CHECKSUM_SHA256 = 'x-amz-checksum-sha256';
@@ -27,7 +28,6 @@ const ERROR_ENDPOINT_REQUIRED = `${ERROR_PREFIX}endpoint must be a non-empty str
 const ERROR_ENDPOINT_FORMAT = `${ERROR_PREFIX}endpoint must be a valid URL. Expected format: https://<host>[:port][/base-path]`;
 const ERROR_KEY_REQUIRED = `${ERROR_PREFIX}key must be a non-empty string`;
 const ERROR_UPLOAD_ID_REQUIRED = `${ERROR_PREFIX}uploadId must be a non-empty string`;
-const ERROR_DATA_BUFFER_REQUIRED = `${ERROR_PREFIX}data must be a Buffer or string`;
 const ERROR_PREFIX_TYPE = `${ERROR_PREFIX}prefix must be a string`;
 const ERROR_DELIMITER_REQUIRED = `${ERROR_PREFIX}delimiter must be a string`;
 
@@ -41,11 +41,30 @@ const getByteSize = (data) => {
     if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
         return data.byteLength;
     }
-    if (data instanceof Blob) {
+    if (data instanceof Blob || data instanceof File) {
         return data.size;
     }
+    if (data instanceof ReadableStream) {
+        return Number.NaN; // size unknown
+    }
     throw new Error('Unsupported data type');
 };
+const toUint8Array = (data) => {
+    if (typeof data === 'string') {
+        return ENCODR.encode(data);
+    }
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    // Node Buffer
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return null;
+};
 /**
  * Turn a raw ArrayBuffer into its hexadecimal representation.
  * @param {ArrayBuffer} buffer The raw bytes.
@@ -253,6 +272,81 @@ const runInBatches = async (tasks, batchSize = 30, minIntervalMs = 0) => {
         }
     }
 };
+const generateParts = async function* (data, partSize) {
+    const bytes = toUint8Array(data);
+    if (bytes) {
+        yield* generateBufferParts(bytes, partSize);
+    }
+    else if (data instanceof Blob) {
+        yield* generateBlobParts(data, partSize);
+    }
+    else if (data instanceof ReadableStream) {
+        yield* generateStreamParts(data, partSize);
+    }
+    else {
+        throw new TypeError(`${ERROR_PREFIX}Unsupported data type for multipart upload`);
+    }
+};
+function* generateBufferParts(bytes, partSize) {
+    for (let offset = 0; offset < bytes.byteLength; offset += partSize) {
+        yield bytes.subarray(offset, Math.min(offset + partSize, bytes.byteLength));
+    }
+}
+/**
+ * Zero-copy: yields Blob slices. Data is only read when fetch consumes it.
+ */
+const generateBlobParts = function* (blob, partSize) {
+    for (let offset = 0; offset < blob.size; offset += partSize) {
+        yield blob.slice(offset, Math.min(offset + partSize, blob.size));
+    }
+};
+const generateStreamParts = async function* (stream, partSize) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let buffered = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (value) {
+                chunks.push(value);
+                buffered += value.byteLength;
+                while (buffered >= partSize) {
+                    yield extractPart(chunks, partSize);
+                    buffered -= partSize;
+                }
+            }
+            if (done) {
+                break;
+            }
+        }
+        // Yield remaining
+        if (buffered > 0) {
+            yield extractPart(chunks, buffered);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+};
+const extractPart = (chunks, size) => {
+    const part = new Uint8Array(size);
+    let offset = 0;
+    while (offset < size && chunks.length > 0) {
+        const chunk = chunks[0];
+        const needed = size - offset;
+        if (chunk.byteLength <= needed) {
+            part.set(chunk, offset);
+            offset += chunk.byteLength;
+            chunks.shift();
+        }
+        else {
+            part.set(chunk.subarray(0, needed), offset);
+            chunks[0] = chunk.subarray(needed);
+            offset = size;
+        }
+    }
+    return part.buffer;
+};
 
 /**
  * S3 class for interacting with S3-compatible object storage services.
@@ -291,6 +385,7 @@ class S3mini {
      * @param {number} [config.requestAbortTimeout=undefined] - The timeout in milliseconds after which a request should be aborted (careful on streamed requests).
      * @param {Object} [config.logger=null] - A logger object with methods like info, warn, error.
      * @param {typeof fetch} [config.fetch=globalThis.fetch] - Custom fetch implementation to use for HTTP requests.
+     * @param {number} [config.minPartSize=8388608] - The minimum part size for multipart uploads in bytes (default is 8MB).
      * @throws {TypeError} Will throw an error if required parameters are missing or of incorrect type.
      */
     #accessKeyId;
@@ -302,9 +397,10 @@ class S3mini {
     requestAbortTimeout;
     logger;
     _fetch;
+    minPartSize;
     signingKeyDate;
     signingKey;
-    constructor({ accessKeyId, secretAccessKey, endpoint, region = 'auto', requestSizeInBytes = DEFAULT_REQUEST_SIZE_IN_BYTES, requestAbortTimeout = undefined, logger = undefined, fetch = globalThis.fetch, }) {
+    constructor({ accessKeyId, secretAccessKey, endpoint, region = 'auto', requestSizeInBytes = DEFAULT_REQUEST_SIZE_IN_BYTES, requestAbortTimeout = undefined, logger = undefined, fetch = globalThis.fetch, minPartSize = MIN_PART_SIZE, }) {
         this._validateConstructorParams(accessKeyId, secretAccessKey, endpoint);
         this.#accessKeyId = accessKeyId;
         this.#secretAccessKey = secretAccessKey;
@@ -315,6 +411,7 @@ class S3mini {
         this.requestAbortTimeout = requestAbortTimeout;
         this.logger = logger;
         this._fetch = (input, init) => fetch(input, init);
+        this.minPartSize = minPartSize;
     }
     _sanitize(obj) {
         if (typeof obj !== 'object' || obj === null) {
@@ -441,13 +538,19 @@ class S3mini {
         }
         return { filteredOpts, conditionalHeaders };
     }
-    _validateData(data) {
-        if (!((globalThis.Buffer && data instanceof globalThis.Buffer) || typeof data === 'string')) {
-            this._log('error', ERROR_DATA_BUFFER_REQUIRED);
-            throw new TypeError(ERROR_DATA_BUFFER_REQUIRED);
-        }
-        return data;
-    }
+    // private _validateData(data: unknown): BodyInit {
+    //   if (data instanceof ArrayBuffer) {
+    //     return data;
+    //   }
+    //   if (data instanceof Uint8Array) {
+    //     return data as unknown as BodyInit;
+    //   }
+    //   if ((globalThis.Buffer && data instanceof globalThis.Buffer) || typeof data === 'string') {
+    //     return data as BodyInit;
+    //   }
+    //   this._log('error', C.ERROR_DATA_BUFFER_REQUIRED);
+    //   throw new TypeError(C.ERROR_DATA_BUFFER_REQUIRED);
+    // }
     _validateUploadPartParams(key, uploadId, data, partNumber, opts) {
         this._checkKey(key);
         if (typeof uploadId !== 'string' || uploadId.trim().length === 0) {
@@ -459,7 +562,7 @@ class S3mini {
             throw new TypeError(`${ERROR_PREFIX}partNumber must be a positive integer`);
         }
         this._checkOpts(opts);
-        return this._validateData(data);
+        return data;
     }
     async _sign(method, keyPath, query = {}, headers = {}) {
         // Create URL without appending keyPath first
@@ -686,6 +789,7 @@ class S3mini {
             tolerated: [200, 404],
         });
         if (res.status === 404) {
+            void res.body?.cancel();
             return null;
         }
         if (res.status !== 200) {
@@ -729,11 +833,16 @@ class S3mini {
         const objects = [];
         // Extract regular objects from Contents
         if (contents) {
-            if (Array.isArray(contents)) {
-                objects.push(...contents);
-            }
-            else {
-                objects.push(contents);
+            const raw = Array.isArray(contents) ? contents : [contents];
+            for (const item of raw) {
+                const o = item;
+                objects.push({
+                    Key: o.Key ?? o.key ?? '',
+                    Size: Number(o.Size ?? o.size ?? 0),
+                    LastModified: new Date(o.LastModified ?? o.lastModified ?? 0),
+                    ETag: o.ETag ?? o.etag ?? '',
+                    StorageClass: o.StorageClass ?? o.storageClass ?? '',
+                });
             }
         }
         // Extract directory prefixes from CommonPrefixes
@@ -820,6 +929,7 @@ class S3mini {
         if (s === 200) {
             return res.text();
         }
+        void res.body?.cancel();
         return null;
     }
     /**
@@ -839,6 +949,7 @@ class S3mini {
         if (res.status === 200) {
             return res;
         }
+        void res.body?.cancel();
         return null;
     }
     /**
@@ -858,6 +969,7 @@ class S3mini {
         if (res.status === 200) {
             return res.arrayBuffer();
         }
+        void res.body?.cancel();
         return null;
     }
     /**
@@ -877,6 +989,7 @@ class S3mini {
         if (res.status === 200) {
             return res.json();
         }
+        void res.body?.cancel();
         return null;
     }
     /**
@@ -896,6 +1009,7 @@ class S3mini {
             });
             const s = res.status;
             if (s === 404 || s === 412 || s === 304) {
+                void res.body?.cancel();
                 return { etag: null, data: null };
             }
             const etag = res.headers.get(HEADER_ETAG);
@@ -949,7 +1063,9 @@ class S3mini {
         }
         catch (err) {
             this._log('error', `Error getting content length for object ${key}: ${String(err)}`);
-            throw new Error(`${ERROR_PREFIX}Error getting content length for object ${key}: ${String(err)}`);
+            throw new Error(`${ERROR_PREFIX}Error getting content length for object ${key}: ${String(err)}`, {
+                cause: err,
+            });
         }
     }
     /**
@@ -1006,7 +1122,7 @@ class S3mini {
     /**
      * Uploads an object to the S3-compatible service.
      * @param {string} key - The key/path where the object will be stored.
-     * @param {string | Buffer} data - The data to upload (string or Buffer).
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data to upload (string or Buffer).
      * @param {string} [fileType='application/octet-stream'] - The MIME type of the file.
      * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
      * @param {IT.AWSHeaders} [additionalHeaders] - Additional x-amz-* headers specific to this request, if any.
@@ -1020,11 +1136,12 @@ class S3mini {
      * const buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
      * await s3.putObject('image.png', buffer, 'image/png');
      */
-    async putObject(key, data, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders) {
+    async putObject(key, data, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders, contentLength) {
+        const size = contentLength ?? getByteSize(data);
         return this._signedRequest('PUT', key, {
-            body: this._validateData(data),
+            body: data,
             headers: {
-                [HEADER_CONTENT_LENGTH]: getByteSize(data),
+                ...(size && { [HEADER_CONTENT_LENGTH]: size }),
                 [HEADER_CONTENT_TYPE]: fileType,
                 ...additionalHeaders,
                 ...ssecHeaders,
@@ -1032,6 +1149,130 @@ class S3mini {
             tolerated: [200],
         });
     }
+    /**
+     * Put object that automatically chooses single PUT vs multipart.
+     * Same signature/shape as putObject so callers don't need to change.
+     * @param {string} key - The key/path where the object will be stored.
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data to upload (string or Buffer).
+     * @param {string} [fileType='application/octet-stream'] - The MIME type of the file.
+     * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
+     * @param {IT.AWSHeaders} [additionalHeaders] - Additional x-amz-* headers specific to this request, if any.
+     * @param {number} [contentLength] - Optional known content length of data.
+     * @returns {Promise<Response | { ok: boolean; status: number; headers: Map<string, string> }>} A promise that resolves to the Response object from the upload request.
+     * @throws {TypeError} If data is not a string or Buffer.
+     * @example
+     * // Upload text file
+     * await s3.putAnyObject('hello.txt', 'Hello, World!', 'text/plain');
+     *
+     * // Upload binary data
+     * const buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+     * await s3.putAnyObject('image.png', buffer, 'image/png');
+     */
+    async putAnyObject(key, data, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders, contentLength) {
+        const size = contentLength ?? getByteSize(data);
+        // Single PUT for small files
+        if (!Number.isNaN(size) && size <= this.minPartSize) {
+            return this.putObject(key, data, fileType, ssecHeaders, additionalHeaders, contentLength);
+        }
+        this._checkKey(key);
+        return this._multipartUpload(key, data, fileType, ssecHeaders, additionalHeaders);
+    }
+    async _multipartUpload(key, data, fileType, ssecHeaders, additionalHeaders) {
+        const uploadId = await this.getMultipartUploadId(key, fileType, ssecHeaders, additionalHeaders);
+        try {
+            const parts = await this._uploadPartsOptimized(key, uploadId, data, ssecHeaders, additionalHeaders);
+            parts.sort((a, b) => a.partNumber - b.partNumber);
+            const result = await this.completeMultipartUpload(key, uploadId, parts);
+            return this._createSuccessResponse(result.etag || '');
+        }
+        catch (err) {
+            await this._safeAbortUpload(key, uploadId);
+            throw err;
+        }
+    }
+    async _uploadKnownSizePartsParallel(key, uploadId, data, ssecHeaders, additionalHeaders, concurrency = 4, maxRetries = 3) {
+        const partSize = this.minPartSize;
+        const totalSize = data instanceof Blob ? data.size : data.byteLength;
+        const totalParts = Math.ceil(totalSize / partSize);
+        const results = new Array(totalParts);
+        let nextIndex = 0;
+        const worker = async () => {
+            while (true) {
+                const index = nextIndex++;
+                if (index >= totalParts) {
+                    return;
+                }
+                const start = index * partSize;
+                const end = Math.min(start + partSize, totalSize);
+                const part = data instanceof Blob
+                    ? await data.slice(start, end).arrayBuffer() // Must await - R2 needs actual bytes
+                    : data.subarray(start, end);
+                results[index] = await this._uploadPartWithRetry(key, uploadId, part, index + 1, ssecHeaders, additionalHeaders, maxRetries);
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, totalParts) }, () => worker()));
+        return results;
+    }
+    async _uploadPartsOptimized(key, uploadId, data, ssecHeaders, additionalHeaders, concurrency = 4, maxRetries = 3) {
+        const bytes = toUint8Array(data);
+        if (bytes) {
+            return this._uploadKnownSizePartsParallel(key, uploadId, bytes, ssecHeaders, additionalHeaders, concurrency, maxRetries);
+        }
+        if (data instanceof Blob) {
+            return this._uploadKnownSizePartsParallel(key, uploadId, data, ssecHeaders, additionalHeaders, concurrency, maxRetries);
+        }
+        return this._uploadStreamingParts(key, uploadId, data, ssecHeaders, additionalHeaders, concurrency, maxRetries);
+    }
+    async _uploadStreamingParts(key, uploadId, stream, ssecHeaders, additionalHeaders, concurrency = 4, maxRetries = 3) {
+        const parts = [];
+        const active = new Set();
+        let partNumber = 0;
+        for await (const partData of generateParts(stream, this.minPartSize)) {
+            const currentPartNumber = ++partNumber;
+            while (active.size >= concurrency) {
+                await Promise.race(active);
+            }
+            const p = this._uploadPartWithRetry(key, uploadId, partData, currentPartNumber, ssecHeaders, additionalHeaders, maxRetries).then(part => {
+                parts.push(part);
+                active.delete(p);
+            });
+            active.add(p);
+        }
+        await Promise.all(active);
+        return parts;
+    }
+    async _uploadPartWithRetry(key, uploadId, data, partNumber, ssecHeaders, additionalHeaders, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.uploadPart(key, uploadId, data, partNumber, {}, ssecHeaders, additionalHeaders);
+            }
+            catch (err) {
+                if (attempt === maxRetries) {
+                    throw err;
+                }
+                await new Promise(r => setTimeout(r, Math.min(1000 * 2 ** attempt, 10000)));
+            }
+        }
+        throw new Error('Unreachable');
+    }
+    async _safeAbortUpload(key, uploadId) {
+        try {
+            await this.abortMultipartUpload(key, uploadId);
+        }
+        catch (err) {
+            this._log('warn', `Failed to abort multipart upload: ${String(err)}`);
+        }
+    }
+    _createSuccessResponse(etag) {
+        if (typeof Response !== 'undefined') {
+            const headers = new Headers();
+            if (etag) {
+                headers.set('ETag', etag);
+            }
+            return new Response('', { status: 200, headers });
+        }
+        return { ok: true, status: 200, headers: new Map([['ETag', etag]]) };
+    }
     /**
      * Initiates a multipart upload and returns the upload ID.
      * @param {string} key - The key/path where the object will be stored.
@@ -1044,13 +1285,13 @@ class S3mini {
      * const uploadId = await s3.getMultipartUploadId('large-file.zip', 'application/zip');
      * console.log(`Started multipart upload: ${uploadId}`);
      */
-    async getMultipartUploadId(key, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders) {
+    async getMultipartUploadId(key, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders) {
         this._checkKey(key);
         if (typeof fileType !== 'string') {
             throw new TypeError(`${ERROR_PREFIX}fileType must be a string`);
         }
         const query = { uploads: '' };
-        const headers = { [HEADER_CONTENT_TYPE]: fileType, ...ssecHeaders };
+        const headers = { [HEADER_CONTENT_TYPE]: fileType, ...ssecHeaders, ...additionalHeaders };
         const res = await this._signedRequest('POST', key, {
             query,
             headers,
@@ -1075,7 +1316,7 @@ class S3mini {
      * Uploads a part in a multipart upload.
      * @param {string} key - The key of the object being uploaded.
      * @param {string} uploadId - The upload ID from getMultipartUploadId.
-     * @param {Buffer | string} data - The data for this part.
+     * @param {string | IT.MaybeBuffer | ReadableStream | File | Blob} data - The data for this part.
      * @param {number} partNumber - The part number (must be between 1 and 10,000).
      * @param {Record<string, unknown>} [opts={}] - Additional options for the request.
      * @param {IT.SSECHeaders} [ssecHeaders] - Server-Side Encryption headers, if any.
@@ -1090,15 +1331,17 @@ class S3mini {
      * );
      * console.log(`Part ${part.partNumber} uploaded with ETag: ${part.etag}`);
      */
-    async uploadPart(key, uploadId, data, partNumber, opts = {}, ssecHeaders) {
+    async uploadPart(key, uploadId, data, partNumber, opts = {}, ssecHeaders, additionalHeaders) {
         const body = this._validateUploadPartParams(key, uploadId, data, partNumber, opts);
         const query = { uploadId, partNumber, ...opts };
+        const size = getByteSize(data);
         const res = await this._signedRequest('PUT', key, {
             query,
             body,
             headers: {
-                [HEADER_CONTENT_LENGTH]: getByteSize(data),
+                ...(size && !Number.isNaN(size) && { [HEADER_CONTENT_LENGTH]: size }),
                 ...ssecHeaders,
+                ...additionalHeaders,
             },
         });
         return { partNumber, etag: sanitizeETag(res.headers.get('etag') || '') };
@@ -1538,6 +1781,66 @@ class S3mini {
             .sort((a, b) => a.localeCompare(b))
             .join('&');
     }
+    /**
+     * Generates a pre-signed URL for direct client access to an S3 object.
+     * The URL embeds authentication in query parameters instead of headers,
+     * allowing unauthenticated HTTP clients to perform the specified operation.
+     *
+     * @param {'GET' | 'PUT'} method - HTTP method ('GET' for download, 'PUT' for upload)
+     * @param {string} key - The object key/path
+     * @param {number} [expiresIn=3600] - URL expiration time in seconds (1–604800)
+     * @param {Record<string, string>} [queryParams={}] - Additional query parameters to sign
+     * @returns {Promise<string>} Pre-signed URL string
+     * @throws {TypeError} If key is empty or expiresIn is out of range
+     * @example
+     * // Download URL valid for 1 hour
+     * const url = await s3.getPresignedUrl('GET', 'photos/vacation.jpg');
+     *
+     * // Upload URL valid for 5 minutes
+     * const url = await s3.getPresignedUrl('PUT', 'uploads/file.bin', 300);
+     *
+     * // Client-side usage (no credentials needed)
+     * await fetch(url, { method: 'PUT', body: data });
+     */
+    async getPresignedUrl(method, key, expiresIn = 3600, queryParams = {}) {
+        this._checkKey(key);
+        if (!Number.isFinite(expiresIn) || expiresIn <= 0 || expiresIn > 604800) {
+            throw new TypeError(`${ERROR_PREFIX}expiresIn must be between 1 and 604800 seconds`);
+        }
+        return this._presign(method, uriResourceEscape(key), Math.floor(expiresIn), queryParams);
+    }
+    async _presign(method, keyPath, expiresIn, queryParams) {
+        const url = new URL(this.endpoint);
+        if (keyPath.length > 0) {
+            url.pathname =
+                url.pathname === '/' ? `/${keyPath.replace(/^\/+/, '')}` : `${url.pathname}/${keyPath.replace(/^\/+/, '')}`;
+        }
+        const d = new Date();
+        const year = d.getUTCFullYear();
+        const month = String(d.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(d.getUTCDate()).padStart(2, '0');
+        const shortDatetime = `${year}${month}${day}`;
+        const fullDatetime = `${shortDatetime}T${String(d.getUTCHours()).padStart(2, '0')}${String(d.getUTCMinutes()).padStart(2, '0')}${String(d.getUTCSeconds()).padStart(2, '0')}Z`;
+        const credentialScope = `${shortDatetime}/${this.region}/${S3_SERVICE}/${AWS_REQUEST_TYPE}`;
+        const signedHeaders = 'host';
+        const allQueryParams = {
+            ...queryParams,
+            'X-Amz-Algorithm': AWS_ALGORITHM,
+            'X-Amz-Credential': `${this.#accessKeyId}/${credentialScope}`,
+            'X-Amz-Date': fullDatetime,
+            'X-Amz-Expires': String(expiresIn),
+            'X-Amz-SignedHeaders': signedHeaders,
+        };
+        const canonicalQueryString = this._buildCanonicalQueryString(allQueryParams);
+        const canonicalRequest = `${method}\n${url.pathname}\n${canonicalQueryString}\nhost:${url.host}\n\n${signedHeaders}\n${UNSIGNED_PAYLOAD}`;
+        const stringToSign = `${AWS_ALGORITHM}\n${fullDatetime}\n${credentialScope}\n${hexFromBuffer(await sha256(canonicalRequest))}`;
+        if (shortDatetime !== this.signingKeyDate || !this.signingKey) {
+            this.signingKeyDate = shortDatetime;
+            this.signingKey = await this._getSignatureKey(shortDatetime);
+        }
+        const signature = hexFromBuffer(await hmac(this.signingKey, stringToSign));
+        return `${url.origin}${url.pathname}?${canonicalQueryString}&X-Amz-Signature=${signature}`;
+    }
     async _getSignatureKey(dateStamp) {
         const kDate = await hmac(`AWS4${this.#secretAccessKey}`, dateStamp);
         const kRegion = await hmac(kDate, this.region);