@ardrive/turbo-sdk 1.30.0-alpha.1 → 1.31.0-alpha.1

package/lib/esm/common/chunked.js

@@ -0,0 +1,352 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CanceledError } from 'axios';
+import { pLimit } from 'plimit-lit';
+import { validChunkingModes, } from '../types.js';
+import { TurboEventEmitter, createStreamWithUploadEvents } from './events.js';
+import { TurboWinstonLogger } from './logger.js';
+const fiveMiB = 5 * 1024 * 1024; // 5 MiB
+const fiveHundredMiB = fiveMiB * 100; // 500 MiB
+export const defaultMaxChunkConcurrency = 5;
+export const maxChunkByteCount = fiveHundredMiB;
+export const minChunkByteCount = fiveMiB;
+export const defaultChunkByteCount = minChunkByteCount;
+const backlogQueueFactor = 2;
+const chunkingHeader = { 'x-chunking-version': '2' };
+/**
+ * Performs a chunked upload by splitting the stream into fixed-size buffers,
+ * uploading them in parallel, and emitting progress/error events.
+ */
+export class ChunkedUploader {
+    constructor({ http, token, maxChunkConcurrency = defaultMaxChunkConcurrency, chunkByteCount = defaultChunkByteCount, logger = TurboWinstonLogger.default, chunkingMode = 'auto', dataItemByteCount, }) {
+        this.chunkByteCount = chunkByteCount;
+        this.maxChunkConcurrency = maxChunkConcurrency;
+        this.http = http;
+        this.token = token;
+        this.logger = logger;
+        this.assertChunkParams({
+            chunkByteCount,
+            chunkingMode,
+            maxChunkConcurrency,
+        });
+        this.shouldUseChunkUploader = this.shouldChunkUpload({
+            chunkByteCount,
+            chunkingMode,
+            dataItemByteCount,
+        });
+        this.maxBacklogQueue = this.maxChunkConcurrency * backlogQueueFactor;
+    }
+    shouldChunkUpload({ chunkByteCount, chunkingMode, dataItemByteCount, }) {
+        if (chunkingMode === 'disabled') {
+            return false;
+        }
+        if (chunkingMode === 'force') {
+            return true;
+        }
+        const isMoreThanTwoChunksOfData = dataItemByteCount > chunkByteCount * 2;
+        return isMoreThanTwoChunksOfData;
+    }
+    assertChunkParams({ chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
+        if (Number.isNaN(maxChunkConcurrency) ||
+            !Number.isInteger(maxChunkConcurrency) ||
+            maxChunkConcurrency < 1) {
+            throw new Error('Invalid max chunk concurrency. Must be an integer of at least 1.');
+        }
+        if (Number.isNaN(chunkByteCount) ||
+            !Number.isInteger(chunkByteCount) ||
+            chunkByteCount < fiveMiB ||
+            chunkByteCount > fiveHundredMiB) {
+            throw new Error('Invalid chunk size. Must be an integer between 5 MiB and 500 MiB.');
+        }
+        if (typeof chunkingMode !== 'string' ||
+            !validChunkingModes.includes(chunkingMode)) {
+            throw new Error(`Invalid chunking mode. Must be one of: ${validChunkingModes.join(', ')}`);
+        }
+    }
+    /**
+     * Initialize or resume an upload session, returning the upload ID.
+     */
+    async initUpload() {
+        const res = await this.http.get({
+            endpoint: `/chunks/${this.token}/-1/-1?chunkSize=${this.chunkByteCount}`,
+            headers: chunkingHeader,
+        });
+        if (res.chunkSize !== this.chunkByteCount) {
+            this.logger.warn('Chunk size mismatch! Overriding with server value.', {
+                expected: this.chunkByteCount,
+                actual: res.chunkSize,
+            });
+            this.chunkByteCount = res.chunkSize;
+        }
+        return res.id;
+    }
+    async upload({ dataItemSizeFactory, dataItemStreamFactory, dataItemOpts, signal, events, }) {
+        const uploadId = await this.initUpload();
+        const dataItemByteCount = dataItemSizeFactory();
+        const emitter = new TurboEventEmitter(events);
+        const { stream, resume } = createStreamWithUploadEvents({
+            data: dataItemStreamFactory(),
+            dataSize: dataItemByteCount,
+            emitter,
+        });
+        this.logger.debug(`Starting chunked upload`, {
+            token: this.token,
+            uploadId,
+            totalSize: dataItemByteCount,
+            chunkByteCount: this.chunkByteCount,
+            maxChunkConcurrency: this.maxChunkConcurrency,
+            inputStreamType: isReadableStream(stream) ? 'ReadableStream' : 'Readable',
+        });
+        const inFlight = new Set();
+        const internalAbort = new AbortController();
+        const combinedSignal = combineAbortSignals([internalAbort.signal, signal]);
+        const limit = pLimit(this.maxChunkConcurrency);
+        let currentOffset = 0;
+        let currentChunkPartNumber = 0;
+        let firstError;
+        let uploadedBytes = 0;
+        const chunks = splitIntoChunks(stream, this.chunkByteCount);
+        resume();
+        for await (const chunk of chunks) {
+            if (combinedSignal?.aborted) {
+                internalAbort.abort();
+                await Promise.allSettled(inFlight);
+                firstError ??= new CanceledError();
+                break;
+            }
+            const chunkPartNumber = ++currentChunkPartNumber;
+            const chunkByteCount = chunk.length;
+            const chunkOffset = currentOffset;
+            currentOffset += chunkByteCount;
+            this.logger.debug('Queueing chunk', {
+                chunkPartNumber,
+                chunkOffset,
+                chunkByteCount,
+            });
+            const promise = limit(async () => {
+                if (firstError !== undefined) {
+                    return;
+                }
+                this.logger.debug('Uploading chunk', {
+                    chunkPartNumber,
+                    chunkOffset,
+                    chunkByteCount,
+                });
+                await this.http.post({
+                    endpoint: `/chunks/${this.token}/${uploadId}/${chunkOffset}`,
+                    data: chunk,
+                    headers: {
+                        'Content-Type': 'application/octet-stream',
+                        ...chunkingHeader,
+                    },
+                    signal: combinedSignal,
+                });
+                uploadedBytes += chunkByteCount;
+                this.logger.debug('Chunk uploaded', {
+                    chunkPartNumber,
+                    chunkOffset,
+                    chunkByteCount,
+                });
+                emitter.emit('upload-progress', {
+                    processedBytes: uploadedBytes,
+                    totalBytes: dataItemByteCount,
+                });
+            }).catch((err) => {
+                this.logger.error('Chunk upload failed', {
+                    id: chunkPartNumber,
+                    offset: chunkOffset,
+                    size: chunkByteCount,
+                    err,
+                });
+                emitter.emit('upload-error', err);
+                internalAbort.abort(err);
+                firstError = firstError ?? err;
+            });
+            inFlight.add(promise);
+            promise.finally(() => inFlight.delete(promise));
+            if (inFlight.size >= this.maxBacklogQueue) {
+                await Promise.race(inFlight);
+                if (combinedSignal?.aborted) {
+                    internalAbort.abort();
+                    await Promise.allSettled(inFlight);
+                    firstError ??= new CanceledError();
+                    break;
+                }
+            }
+        }
+        await Promise.all(inFlight);
+        if (firstError !== undefined) {
+            throw firstError;
+        }
+        const paidByHeader = {};
+        if (dataItemOpts?.paidBy !== undefined) {
+            paidByHeader['x-paid-by'] = Array.isArray(dataItemOpts.paidBy)
+                ? dataItemOpts.paidBy.join(',')
+                : dataItemOpts.paidBy;
+        }
+        // TODO: Async Finalize
+        // Finalize and reconstruct server-side
+        const finalizeResponse = await this.http.post({
+            endpoint: `/chunks/${this.token}/${uploadId}/-1`,
+            data: Buffer.alloc(0),
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                ...paidByHeader,
+                ...chunkingHeader,
+            },
+            signal: combinedSignal,
+        });
+        emitter.emit('upload-success');
+        return finalizeResponse;
+    }
+}
+/**
+ * Yield Buffers of up to `chunkByteCount`, coalescing whatever small pieces
+ * the source produces into proper slices.
+ */
+export async function* splitIntoChunks(source, chunkByteCount) {
+    if (isReadableStream(source)) {
+        yield* splitReadableStreamIntoChunks(source, chunkByteCount);
+    }
+    else {
+        yield* splitReadableIntoChunks(source, chunkByteCount);
+    }
+}
+export async function* splitReadableIntoChunks(source, chunkByteCount) {
+    const queue = [];
+    let total = 0;
+    let encoder;
+    for await (const piece of source) {
+        const u8 = piece instanceof Uint8Array
+            ? new Uint8Array(piece.buffer, piece.byteOffset, piece.byteLength)
+            : (encoder ??= new TextEncoder()).encode(String(piece));
+        queue.push(u8);
+        total += u8.length;
+        // Emit full chunks
+        while (total >= chunkByteCount) {
+            const out = new Uint8Array(chunkByteCount);
+            let remaining = out.length;
+            let off = 0;
+            while (remaining > 0) {
+                const head = queue[0];
+                const take = Math.min(remaining, head.length);
+                out.set(head.subarray(0, take), off);
+                off += take;
+                remaining -= take;
+                if (take === head.length) {
+                    queue.shift();
+                }
+                else {
+                    queue[0] = head.subarray(take);
+                }
+            }
+            total -= chunkByteCount;
+            // Yield a Buffer view (no copy)
+            yield Buffer.from(out.buffer, out.byteOffset, out.byteLength);
+        }
+    }
+    // Remainder
+    if (total > 0) {
+        const out = new Uint8Array(total);
+        let off = 0;
+        while (queue.length > 0) {
+            const head = queue.shift(); // safe due to loop condition
+            out.set(head, off);
+            off += head.length;
+        }
+        yield Buffer.from(out.buffer, out.byteOffset, out.byteLength);
+    }
+}
+export async function* splitReadableStreamIntoChunks(source, chunkByteCount) {
+    const reader = source.getReader();
+    const queue = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            // Ensure we keep a plain view (avoids surprises if the producer reuses buffers)
+            const u8 = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+            queue.push(u8);
+            total += u8.length;
+            while (total >= chunkByteCount) {
+                const out = new Uint8Array(chunkByteCount);
+                let remaining = out.length;
+                let off = 0;
+                while (remaining > 0) {
+                    const head = queue[0];
+                    const take = Math.min(remaining, head.length);
+                    out.set(head.subarray(0, take), off);
+                    off += take;
+                    remaining -= take;
+                    if (take === head.length) {
+                        queue.shift();
+                    }
+                    else {
+                        queue[0] = head.subarray(take);
+                    }
+                }
+                total -= chunkByteCount;
+                yield Buffer.from(out.buffer, out.byteOffset, out.byteLength);
+            }
+        }
+        if (total > 0) {
+            const out = new Uint8Array(total);
+            let off = 0;
+            while (queue.length > 0) {
+                const head = queue.shift(); // safe due to loop condition
+                out.set(head, off);
+                off += head.length;
+            }
+            yield Buffer.from(out.buffer, out.byteOffset, out.byteLength);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function isReadableStream(source) {
+    // Prefer instanceof if available, otherwise use a safe duck-typing check
+    if (typeof ReadableStream !== 'undefined' &&
+        source instanceof ReadableStream) {
+        return true;
+    }
+    return (source !== null &&
+        typeof source === 'object' &&
+        'getReader' in source &&
+        typeof source.getReader === 'function');
+}
+function combineAbortSignals(signals) {
+    const real = signals.filter(Boolean);
+    if (real.length === 0)
+        return undefined;
+    const anyFn = AbortSignal.any;
+    if (typeof anyFn === 'function') {
+        return anyFn(real);
+    }
+    const controller = new AbortController();
+    for (const s of real) {
+        const sig = s;
+        if (sig.aborted) {
+            controller.abort(sig.reason);
+            break;
+        }
+        const onAbort = () => controller.abort(sig.reason);
+        s.addEventListener('abort', onAbort, { once: true });
+    }
+    return controller.signal;
+}

package/lib/esm/common/http.js

@@ -42,6 +42,7 @@ export class TurboHTTPService {
         // See: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API#body
         const { body, duplex } = await toFetchBody(data);
         try {
+            this.logger.debug('Posting data via fetch', { endpoint, headers });
             const res = await fetch(this.axios.defaults.baseURL + endpoint, {
                 method: 'POST',
                 headers,

package/lib/esm/common/turbo.js

@@ -156,8 +156,16 @@ export class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, events, }) {
-        return this.uploadService.upload({ data, dataItemOpts, signal, events });
+    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
+        return this.uploadService.upload({
+            data,
+            dataItemOpts,
+            signal,
+            events,
+            chunkByteCount,
+            chunkingMode,
+            maxChunkConcurrency,
+        });
     }
     uploadFile(params) {
         return this.uploadService.uploadFile(params);

package/lib/esm/common/upload.js

@@ -18,6 +18,7 @@ import { pLimit } from 'plimit-lit';
 import { defaultRetryConfig } from '../utils/axiosClient.js';
 import { isBlob, sleep } from '../utils/common.js';
 import { FailedRequestError } from '../utils/errors.js';
+import { ChunkedUploader } from './chunked.js';
 import { TurboEventEmitter, createStreamWithUploadEvents } from './events.js';
 import { TurboHTTPService } from './http.js';
 import { TurboWinstonLogger } from './logger.js';
@@ -91,7 +92,7 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, events, }) {
+    upload({ data, dataItemOpts, signal, events, chunkByteCount, chunkingMode, maxChunkConcurrency, }) {
         // This function is intended to be usable in both Node and browser environments.
         if (isBlob(data)) {
             const streamFactory = () => data.stream();
@@ -119,6 +120,9 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
             signal,
             dataItemOpts,
             events,
+            chunkByteCount,
+            chunkingMode,
+            maxChunkConcurrency,
         });
     }
     resolveUploadFileConfig(params) {
@@ -159,22 +163,42 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
         let lastStatusCode = undefined; // Store the last status code for throwing
         const emitter = new TurboEventEmitter(events);
         // avoid duplicating signing on failures here - these errors will immediately be thrown
-        // TODO: create a SigningError class and throw that instead of the generic Error
-        const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
-            fileStreamFactory,
-            fileSizeFactory,
-            dataItemOpts,
-            emitter,
-        });
         // TODO: move the retry implementation to the http class, and avoid awaiting here. This will standardize the retry logic across all upload methods.
         while (retries < maxRetries) {
             if (signal?.aborted) {
                 throw new CanceledError();
             }
+            // TODO: create a SigningError class and throw that instead of the generic Error
+            const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
+                fileStreamFactory,
+                fileSizeFactory,
+                dataItemOpts,
+                emitter,
+            });
             // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
             // which will create a new emitter with upload events. We await
             // this result due to the wrapped retry logic of this method.
             try {
+                const { chunkByteCount, maxChunkConcurrency } = params;
+                const chunkedUploader = new ChunkedUploader({
+                    http: this.httpService,
+                    token: this.token,
+                    maxChunkConcurrency,
+                    chunkByteCount,
+                    logger: this.logger,
+                    dataItemByteCount: dataItemSizeFactory(),
+                    chunkingMode: params.chunkingMode,
+                });
+                if (chunkedUploader.shouldUseChunkUploader) {
+                    const response = await chunkedUploader.upload({
+                        dataItemStreamFactory,
+                        dataItemSizeFactory,
+                        dataItemOpts,
+                        signal,
+                        events,
+                    });
+                    return response;
+                }
                 const response = await this.uploadSignedDataItem({
                     dataItemStreamFactory,
                     dataItemSizeFactory,
@@ -263,7 +287,7 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
      */
     async uploadFolder(params) {
         this.logger.debug('Uploading folder...', { params });
-        const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, } = params;
+        const { dataItemOpts, signal, manifestOptions = {}, maxConcurrentUploads = 1, throwOnFailure = true, maxChunkConcurrency, chunkByteCount, chunkingMode, } = params;
         const { disableManifest, indexFile, fallbackFile } = manifestOptions;
         const paths = {};
         const response = {
@@ -287,6 +311,9 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
                     fileSizeFactory: () => this.getFileSize(file),
                     signal,
                     dataItemOpts: dataItemOptsWithContentType,
+                    chunkByteCount,
+                    maxChunkConcurrency,
+                    chunkingMode,
                 });
                 const relativePath = this.getRelativePath(file, params);
                 paths[relativePath] = { id: result.id };
@@ -332,6 +359,9 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
             fileSizeFactory: () => manifestBuffer.byteLength,
             signal,
             dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType },
+            chunkByteCount,
+            maxChunkConcurrency,
+            chunkingMode,
         });
         return {
             ...response,

package/lib/esm/types.js

@@ -43,3 +43,4 @@ export function isSolanaWalletAdapter(walletAdapter) {
 export function isEthereumWalletAdapter(walletAdapter) {
     return 'getSigner' in walletAdapter;
 }
+export const validChunkingModes = ['force', 'disabled', 'auto'];

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '1.30.0-alpha.1';
+export const version = '1.31.0-alpha.1';

package/lib/types/cli/commands/uploadFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadFile.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploadFile.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOhD,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB1E"}
+{"version":3,"file":"uploadFile.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploadFile.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQhD,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB1E"}

package/lib/types/cli/commands/uploadFolder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadFolder.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploadFolder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQlD,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA0Bf"}
+{"version":3,"file":"uploadFolder.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploadFolder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQlD,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/lib/types/cli/options.d.ts

@@ -131,7 +131,7 @@ export declare const optionMap: {
     };
     readonly maxConcurrency: {
         readonly alias: "--max-concurrency <maxConcurrency>";
-        readonly description: "Maximum number of concurrent uploads";
+        readonly description: "Maximum number of concurrent file uploads";
     };
     readonly paidBy: {
         readonly alias: "--paid-by <paidBy...>";
@@ -156,6 +156,19 @@ export declare const optionMap: {
         readonly alias: "--byte-count <byteCount>";
         readonly description: "Number of bytes to use for the action";
     };
+    readonly maxChunkConcurrency: {
+        readonly alias: "--max-chunk-concurrency <maxChunkConcurrency>";
+        readonly description: "Maximum number of concurrent chunks to upload per file";
+    };
+    readonly chunkByteCount: {
+        readonly alias: "--chunk-byte-count <chunkByteCount>";
+        readonly description: "Size of each chunk in bytes";
+    };
+    readonly chunkingMode: {
+        readonly alias: "--chunking-mode <chunkingMode>";
+        readonly description: "Chunking mode to use for the upload. Can be \"auto\", \"force\" or \"disabled\". Defaults to \"auto\".";
+        readonly default: "auto";
+    };
 };
 export declare const walletOptions: ({
     readonly alias: "-w, --wallet-file <filePath>";
@@ -229,6 +242,16 @@ export declare const uploadOptions: ({
     readonly alias: "--use-signer-balance-first";
     readonly description: "Use the signer balance first before using credit share approvals";
     readonly default: false;
+} | {
+    readonly alias: "--max-chunk-concurrency <maxChunkConcurrency>";
+    readonly description: "Maximum number of concurrent chunks to upload per file";
+} | {
+    readonly alias: "--chunk-byte-count <chunkByteCount>";
+    readonly description: "Size of each chunk in bytes";
+} | {
+    readonly alias: "--chunking-mode <chunkingMode>";
+    readonly description: "Chunking mode to use for the upload. Can be \"auto\", \"force\" or \"disabled\". Defaults to \"auto\".";
+    readonly default: "auto";
 })[];
 export declare const uploadFolderOptions: ({
     readonly description: "An array of additional tags for the write action, in \"--tags name1 value1 name2 value2\" format";
@@ -258,7 +281,7 @@ export declare const uploadFolderOptions: ({
     readonly default: true;
 } | {
     readonly alias: "--max-concurrency <maxConcurrency>";
-    readonly description: "Maximum number of concurrent uploads";
+    readonly description: "Maximum number of concurrent file uploads";
 } | {
     readonly alias: "--paid-by <paidBy...>";
     readonly description: "Address to pay for the upload";
@@ -271,6 +294,16 @@ export declare const uploadFolderOptions: ({
     readonly alias: "--use-signer-balance-first";
     readonly description: "Use the signer balance first before using credit share approvals";
     readonly default: false;
+} | {
+    readonly alias: "--max-chunk-concurrency <maxChunkConcurrency>";
+    readonly description: "Maximum number of concurrent chunks to upload per file";
+} | {
+    readonly alias: "--chunk-byte-count <chunkByteCount>";
+    readonly description: "Size of each chunk in bytes";
+} | {
+    readonly alias: "--chunking-mode <chunkingMode>";
+    readonly description: "Chunking mode to use for the upload. Can be \"auto\", \"force\" or \"disabled\". Defaults to \"auto\".";
+    readonly default: "auto";
 })[];
 export declare const uploadFileOptions: ({
     readonly description: "An array of additional tags for the write action, in \"--tags name1 value1 name2 value2\" format";
@@ -300,6 +333,16 @@ export declare const uploadFileOptions: ({
     readonly alias: "--use-signer-balance-first";
     readonly description: "Use the signer balance first before using credit share approvals";
     readonly default: false;
+} | {
+    readonly alias: "--max-chunk-concurrency <maxChunkConcurrency>";
+    readonly description: "Maximum number of concurrent chunks to upload per file";
+} | {
+    readonly alias: "--chunk-byte-count <chunkByteCount>";
+    readonly description: "Size of each chunk in bytes";
+} | {
+    readonly alias: "--chunking-mode <chunkingMode>";
+    readonly description: "Chunking mode to use for the upload. Can be \"auto\", \"force\" or \"disabled\". Defaults to \"auto\".";
+    readonly default: "auto";
 })[];
 export declare const shareCreditsOptions: ({
     readonly alias: "-a, --address <nativeAddress>";

package/lib/types/cli/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsJZ,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;IAIzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;IAMzB,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAO/B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAyC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;IAK/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;IAAwC,CAAC;AAE1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;IAAuB,CAAC"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoKZ,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;IAIzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASzB,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAO/B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAyC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;IAK/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;IAAwC,CAAC;AAE1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;IAAuB,CAAC"}

package/lib/types/cli/types.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { TurboChunkingMode } from '../types.js';
 export type GlobalOptions = {
     dev: boolean;
     local: boolean;
@@ -43,6 +44,9 @@ export type UploadOptions = WalletOptions & {
     ignoreApprovals: boolean;
     useSignerBalanceFirst: boolean;
     tags: string[] | undefined;
+    maxChunkConcurrency: string | undefined;
+    chunkByteCount: string | undefined;
+    chunkingMode: TurboChunkingMode | undefined;
 };
 export type UploadFolderOptions = UploadOptions & {
     folderPath: string | undefined;

package/lib/types/cli/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG;IAC1C,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG;IAC3C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG;IAC1C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG;IAC1C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,GAAG;IACpD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG;IAC7C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/types.ts"],"names":[],"mappings":"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"}

package/lib/types/cli/utils.d.ts

@@ -1,5 +1,5 @@
 import { Command, OptionValues } from 'commander';
-import { Currency, TokenType, TurboAuthenticatedClient, TurboUnauthenticatedConfiguration } from '../node/index.js';
+import { Currency, TokenType, TurboAuthenticatedClient, TurboChunkingMode, TurboUnauthenticatedConfiguration } from '../node/index.js';
 import { AddressOptions, GlobalOptions, TokenPriceOptions, UploadFolderOptions, UploadOptions, WalletOptions } from './types.js';
 export declare function exitWithErrorLog(error: unknown): void;
 export declare function runCommand<T extends OptionValues>(command: Command, action: (options: T) => Promise<void>): Promise<void>;
@@ -27,6 +27,9 @@ export declare function getUploadFolderOptions(options: UploadFolderOptions): {
     fallbackFile: string | undefined;
     disableManifest: boolean;
     maxConcurrentUploads: number;
+    maxChunkConcurrency?: number;
+    chunkByteCount?: number;
+    chunkingMode?: TurboChunkingMode;
 };
 /**
  * Parse tags array from CLI input into Tag array
@@ -46,5 +49,10 @@ export declare function currencyFromOptions<T extends GlobalOptions & {
     currency?: string;
 }>(options: T): Currency | undefined;
 export declare function requiredByteCountFromOptions({ byteCount, }: TokenPriceOptions): number;
+export declare function getChunkingOptions<O extends UploadOptions>(options: O): {
+    chunkingMode?: TurboChunkingMode;
+    chunkByteCount?: number;
+    maxChunkConcurrency?: number;
+};
 export {};
 //# sourceMappingURL=utils.d.ts.map