s3mini 0.8.1 → 0.9.1

package/README.md

@@ -1,6 +1,6 @@
 # s3mini | Tiny & fast S3 client for node and edge platforms.
 
-`s3mini` is an ultra-lightweight Typescript client (~18 KB minified, ≈15 % more ops/s) for S3-compatible object storage. It runs on Node, Bun, Cloudflare Workers, and other edge platforms. It has been tested on Cloudflare R2, Backblaze B2, DigitalOcean Spaces, Ceph, Oracle, Garage and MinIO. (No Browser support!)
+`s3mini` is an ultra-lightweight Typescript client (~20 KB minified, ≈15 % more ops/s) for S3-compatible object storage. It runs on Node, Bun, Cloudflare Workers, and other edge platforms. It has been tested on Cloudflare R2, Backblaze B2, DigitalOcean Spaces, Ceph, Oracle, Garage and MinIO. (No Browser support!)
 
 [[github](https://github.com/good-lly/s3mini)]
 [[issues](https://github.com/good-lly/s3mini/issues)]
@@ -8,11 +8,12 @@
 
 ## Features
 
-- 🚀 Light and fast: averages ≈15 % more ops/s and only ~18 KB (minified, not gzipped).
+- 🚀 Light and fast: averages ≈15 % more ops/s and only ~20 KB (minified, not gzipped).
 - 🔧 Zero dependencies; supports AWS SigV4 (no pre-signed requests) and SSE-C headers (tested only on Cloudflare)
 - 🟠 Works on Cloudflare Workers; ideal for edge computing, Node, and Bun (no browser support).
 - 🔑 Only the essential S3 APIs—improved list, put, get, delete, and a few more.
 - 🛠️ Supports multipart uploads.
+- 🎄 Tree-shakeable ES module.
 - 🎯 TypeScript support with type definitions.
 - 📚 Poorly-documented with examples and tests - But widely tested on various S3-compatible services! (Contributions welcome!)
 - 📦 **BYOS3** — _Bring your own S3-compatible bucket_ (tested on Cloudflare R2, Backblaze B2, DigitalOcean Spaces, MinIO, Garage, Micro/Ceph and Oracle Object Storage, Scaleway).
@@ -43,9 +44,6 @@ Dev:
 
 <a href="https://github.com/good-lly/s3mini/issues/"> <img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg" alt="Contributions welcome" /></a>
 
-Performance tests was done on local Minio instance. Your results may vary depending on environment and network conditions, so take it with a grain of salt.
-![performance-image](https://raw.githubusercontent.com/good-lly/s3mini/dev/performance-screenshot.png)
-
 ## Table of Contents
 
 - [Supported Ops](#supported-ops)

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;
@@ -52,9 +53,7 @@ interface ListBucketError {
 }
 type ListBucketResponse = {
     listBucketResult: ListBucketResult;
-} | {
-    error: ListBucketError;
-};
+} | ListBucketError;
 interface ListMultipartUploadSuccess {
     listMultipartUploadsResult: {
         bucket: string;
@@ -126,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.
@@ -166,12 +163,18 @@ 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;
+    /**
+     * Check if credentials are configured (non-empty).
+     * @returns true if both accessKeyId and secretAccessKey are non-empty.
+     */
+    private _hasCredentials;
     private _ensureValidUrl;
     private _validateMethodIsGetOrHead;
     private _checkKey;
@@ -179,7 +182,6 @@ declare class S3mini {
     private _checkPrefix;
     private _checkOpts;
     private _filterIfHeaders;
-    private _validateData;
     private _validateUploadPartParams;
     private _sign;
     private _signedRequest;
@@ -350,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.
@@ -364,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.
@@ -377,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.
@@ -397,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.
@@ -576,5 +609,5 @@ declare const sanitizeETag: (etag: string) => string;
  */
 declare const runInBatches: <T = unknown>(tasks: Iterable<() => Promise<T>>, batchSize?: number, minIntervalMs?: number) => Promise<Array<PromiseSettledResult<T>>>;
 
-export { S3mini, runInBatches, sanitizeETag };
+export { S3mini, S3mini as default, runInBatches, sanitizeETag };
 export type { CompleteMultipartUploadResult, ErrorWithCode, ExistResponseCode, ListBucketResponse, ListMultipartUploadResponse, Logger, S3Config, UploadPart };

package/dist/s3mini.js

@@ -7,9 +7,10 @@ const UNSIGNED_PAYLOAD = 'UNSIGNED-PAYLOAD';
 const DEFAULT_STREAM_CONTENT_TYPE = 'application/octet-stream';
 const XML_CONTENT_TYPE = 'application/xml';
 // List of keys that might contain sensitive information
-const SENSITIVE_KEYS_REDACTED = new Set(['accessKeyId', 'secretAccessKey', 'sessionToken', 'password', 'token']);
+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) {
@@ -358,16 +455,23 @@ class S3mini {
         }
     }
     _validateConstructorParams(accessKeyId, secretAccessKey, endpoint) {
-        if (typeof accessKeyId !== 'string' || accessKeyId.trim().length === 0) {
+        if (typeof accessKeyId !== 'string') {
             throw new TypeError(ERROR_ACCESS_KEY_REQUIRED);
         }
-        if (typeof secretAccessKey !== 'string' || secretAccessKey.trim().length === 0) {
+        if (typeof secretAccessKey !== 'string') {
             throw new TypeError(ERROR_SECRET_KEY_REQUIRED);
         }
         if (typeof endpoint !== 'string' || endpoint.trim().length === 0) {
             throw new TypeError(ERROR_ENDPOINT_REQUIRED);
         }
     }
+    /**
+     * Check if credentials are configured (non-empty).
+     * @returns true if both accessKeyId and secretAccessKey are non-empty.
+     */
+    _hasCredentials() {
+        return this.#accessKeyId.trim().length > 0 && this.#secretAccessKey.trim().length > 0;
+    }
     _ensureValidUrl(raw) {
         const candidate = /^(https?:)?\/\//i.test(raw) ? raw : `https://${raw}`;
         try {
@@ -434,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) {
@@ -452,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
@@ -462,6 +572,11 @@ class S3mini {
             url.pathname =
                 url.pathname === '/' ? `/${keyPath.replace(/^\/+/, '')}` : `${url.pathname}/${keyPath.replace(/^\/+/, '')}`;
         }
+        // If no credentials, return unsigned request (for public bucket access)
+        if (!this._hasCredentials()) {
+            headers[HEADER_HOST] = url.host;
+            return { url: url.toString(), headers };
+        }
         const d = new Date();
         const year = d.getUTCFullYear();
         const month = String(d.getUTCMonth() + 1).padStart(2, '0');
@@ -523,8 +638,7 @@ class S3mini {
         if (Object.keys(query).length > 0) {
             withQuery = true; // append query string to signed URL
         }
-        const filteredOptsStrings = Object.fromEntries(Object.entries(filteredOpts).map(([k, v]) => [k, String(v)]));
-        const finalUrl = withQuery && Object.keys(filteredOpts).length ? `${url}?${new URLSearchParams(filteredOptsStrings)}` : url;
+        const finalUrl = withQuery && Object.keys(filteredOpts).length ? `${url}?${this._buildCanonicalQueryString(filteredOpts)}` : url;
         const signedHeadersString = Object.fromEntries(Object.entries(signedHeaders).map(([k, v]) => [k, String(v)]));
         return this._sendRequest(finalUrl, method, signedHeadersString, body, tolerated);
     }
@@ -995,7 +1109,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.
@@ -1009,11 +1123,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,
@@ -1021,6 +1136,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.
@@ -1033,13 +1272,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,
@@ -1064,7 +1303,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.
@@ -1079,15 +1318,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') || '') };
@@ -1535,5 +1776,5 @@ class S3mini {
     }
 }
 
-export { S3mini, runInBatches, sanitizeETag };
+export { S3mini, S3mini as default, runInBatches, sanitizeETag };
 //# sourceMappingURL=s3mini.js.map