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

package/README.md

@@ -625,6 +625,40 @@ const uploadResult = await turbo.uploadFile({
 });
 ```
 
+##### Customize Multi-Part Upload Behavior
+
+By default, the Turbo upload methods will split files into chunks that are larger than 10 MiB and send these chunks to the upload service multi-part endpoints. This behavior can be customized with the following inputs:
+
+- `chunkByteCount`: The maximum size in bytes for each chunk. Must be between 5 MiB and 500 MiB. Defaults to 5 MiB.
+- `maxChunkConcurrency`: The maximum number of chunks to upload concurrently. Defaults to 5. Reducing concurrency will slow down uploads, but reduce memory utilization and serialize network calls. Increasing it will upload faster, but can strain available resources.
+- `chunkingMode`: The chunking mode to use. Can be 'auto', 'force', or 'disabled'. Defaults to 'auto'. Auto behavior means chunking is enabled if the file would be split into at least three chunks.
+- `maxFinalizeMs`: The maximum time in milliseconds to wait for the finalization of all chunks after the last chunk is uploaded. Defaults to 1 minute per GiB of the total file size.
+
+```typescript
+// Customize chunking behavior
+await turbo.upload({
+  ...params,
+  chunkByteCount: 1024 * 1024 * 500, // Max chunk size
+  maxChunkConcurrency: 1, // Minimize concurrency
+});
+```
+
+```typescript
+// Disable chunking behavior
+await turbo.upload({
+  ...params,
+  chunkingMode: 'disabled',
+});
+```
+
+```typescript
+// Force chunking behavior
+await turbo.upload({
+  ...params,
+  chunkingMode: 'force',
+});
+```
+
 #### `uploadFolder({ folderPath, files, dataItemOpts, signal, maxConcurrentUploads, throwOnFailure, manifestOptions })`
 
 Signs and uploads a folder of files. For NodeJS, the `folderPath` of the folder to upload is required. For the browser, an array of `files` is required. The `dataItemOpts` is an optional object that can be used to configure tags, target, and anchor for the data item upload. The `signal` is an optional [AbortSignal] that can be used to cancel the upload or timeout the request. The `maxConcurrentUploads` is an optional number that can be used to limit the number of concurrent uploads. The `throwOnFailure` is an optional boolean that can be used to throw an error if any upload fails. The `manifestOptions` is an optional object that can be used to configure the manifest file, including a custom index file, fallback file, or whether to disable manifests altogether. Manifests are enabled by default.
@@ -765,8 +799,8 @@ Shares credits from the connected wallet to the provided native address and appr
 ```typescript
 const { approvalDataItemId, approvedWincAmount } = await turbo.shareCredits({
   approvedAddress: '2cor...VUa',
-  approvedWincAmount: 0.08315565032,
-  expiresBySeconds: 3600,
+  approvedWincAmount: 800_000_000_000, // 0.8 Credits
+  expiresBySeconds: 3600, // Credits will expire back to original wallet in 1 hour
 });
 ```
 

package/bundles/web.bundle.min.js

@@ -197377,7 +197377,7 @@ var require_axios = __commonJS({
       kind === "object" && isFunction4(thing.toString) && thing.toString() === "[object FormData]"));
     };
     var isURLSearchParams2 = kindOfTest2("URLSearchParams");
-    var [isReadableStream2, isRequest2, isResponse2, isHeaders2] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest2);
+    var [isReadableStream3, isRequest2, isResponse2, isHeaders2] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest2);
     var trim2 = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
     function forEach3(obj, fn2, { allOwnKeys = false } = {}) {
       if (obj === null || typeof obj === "undefined") {
@@ -197662,7 +197662,7 @@ var require_axios = __commonJS({
       isBoolean: isBoolean4,
       isObject: isObject5,
       isPlainObject: isPlainObject2,
-      isReadableStream: isReadableStream2,
+      isReadableStream: isReadableStream3,
       isRequest: isRequest2,
       isResponse: isResponse2,
       isHeaders: isHeaders2,
@@ -220929,6 +220929,18 @@ var tokenTypes = [
   "pol",
   "base-eth"
 ];
+var multipartPendingStatus = [
+  "ASSEMBLING",
+  "VALIDATING",
+  "FINALIZING"
+];
+var multipartFailedStatus = [
+  "UNDERFUNDED",
+  "INVALID",
+  "APPROVAL_FAILED",
+  "REVOKE_FAILED"
+];
+var multipartFinalizedStatus = ["FINALIZED"];
 var isNodeUploadFolderParams = (p9) => p9.folderPath !== void 0;
 var isWebUploadFolderParams = (p9) => p9.files !== void 0;
 function isKyvePrivateKey(wallet) {
@@ -220948,6 +220960,7 @@ function isSolanaWalletAdapter(walletAdapter) {
 function isEthereumWalletAdapter(walletAdapter) {
   return "getSigner" in walletAdapter;
 }
+var validChunkingModes = ["force", "disabled", "auto"];
 
 // src/common/logger.ts
 init_dirname();
@@ -220959,7 +220972,7 @@ var import_winston = __toESM(require_winston(), 1);
 init_dirname();
 init_buffer2();
 init_process2();
-var version21 = "1.30.0-alpha.1";
+var version21 = "1.31.0-alpha.1";
 
 // src/common/logger.ts
 var TurboWinstonLogger = class _TurboWinstonLogger {
@@ -225543,6 +225556,7 @@ var TurboHTTPService = class {
     }
     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,
@@ -274373,6 +274387,11 @@ function pLimit(concurrency) {
   return generator;
 }
 
+// src/common/chunked.ts
+init_dirname();
+init_buffer2();
+init_process2();
+
 // src/common/events.ts
 init_dirname();
 init_buffer2();
@@ -274595,6 +274614,407 @@ function createStreamWithSigningEvents({
   });
 }
 
+// src/common/chunked.ts
+var fiveMiB = 5 * 1024 * 1024;
+var fiveHundredMiB = fiveMiB * 100;
+var defaultMaxChunkConcurrency = 5;
+var minChunkByteCount = fiveMiB;
+var defaultChunkByteCount = minChunkByteCount;
+var backlogQueueFactor = 2;
+var chunkingHeader = { "x-chunking-version": "2" };
+var ChunkedUploader = class {
+  constructor({
+    http,
+    token,
+    maxChunkConcurrency = defaultMaxChunkConcurrency,
+    maxFinalizeMs,
+    chunkByteCount = defaultChunkByteCount,
+    logger: logger19 = TurboWinstonLogger.default,
+    chunkingMode = "auto",
+    dataItemByteCount
+  }) {
+    this.assertChunkParams({
+      chunkByteCount,
+      chunkingMode,
+      maxChunkConcurrency,
+      maxFinalizeMs
+    });
+    this.chunkByteCount = chunkByteCount;
+    this.maxChunkConcurrency = maxChunkConcurrency;
+    this.maxFinalizeMs = maxFinalizeMs;
+    this.http = http;
+    this.token = token;
+    this.logger = logger19;
+    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,
+    maxFinalizeMs
+  }) {
+    if (maxFinalizeMs !== void 0 && (Number.isNaN(maxFinalizeMs) || !Number.isInteger(maxFinalizeMs) || maxFinalizeMs < 0)) {
+      throw new Error(
+        "Invalid max finalization wait time. Must be a non-negative integer."
+      );
+    }
+    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.", {
+        clientExpected: this.chunkByteCount,
+        serverReturned: 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: stream2, 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: isReadableStream2(stream2) ? "ReadableStream" : "Readable"
+    });
+    const inFlight = /* @__PURE__ */ 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(stream2, this.chunkByteCount);
+    resume();
+    for await (const chunk of chunks) {
+      if (combinedSignal?.aborted) {
+        internalAbort.abort();
+        await Promise.allSettled(inFlight);
+        firstError ??= new CanceledError2();
+        break;
+      }
+      const chunkPartNumber = ++currentChunkPartNumber;
+      const chunkByteCount = chunk.length;
+      const chunkOffset = currentOffset;
+      currentOffset += chunkByteCount;
+      const promise = limit(async () => {
+        if (firstError !== void 0) {
+          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 CanceledError2();
+          break;
+        }
+      }
+    }
+    await Promise.all(inFlight);
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+    const finalizeResponse = await this.finalizeUpload(
+      uploadId,
+      dataItemByteCount,
+      dataItemOpts?.paidBy,
+      combinedSignal
+    );
+    emitter.emit("upload-success");
+    return finalizeResponse;
+  }
+  toGiB(bytes4) {
+    return bytes4 / 1024 ** 3;
+  }
+  async finalizeUpload(uploadId, dataItemByteCount, paidBy, signal) {
+    const fileSizeInGiB = Math.ceil(this.toGiB(dataItemByteCount));
+    const defaultMaxWaitTimeMins = fileSizeInGiB;
+    const maxWaitTimeMs = this.maxFinalizeMs ?? defaultMaxWaitTimeMins * 60 * 1e3;
+    const minimumWaitPerStepMs = (
+      // Per step, files smaller than 100MB will wait 2 second,
+      dataItemByteCount < 1024 * 1024 * 100 ? 2e3 : (
+        // files smaller than 3 GiB will wait 3 seconds,
+        dataItemByteCount < 1024 * 1024 * 1024 * 3 ? 3e3 : (
+          // and larger files will wait 1 second per GiB with max of 10 seconds
+          Math.max(1e3 * fileSizeInGiB, 1e4)
+        )
+      )
+    );
+    const paidByHeader = {};
+    if (paidBy !== void 0) {
+      paidByHeader["x-paid-by"] = Array.isArray(paidBy) ? paidBy.join(",") : paidBy;
+    }
+    await this.http.post({
+      endpoint: `/chunks/${this.token}/${uploadId}/finalize`,
+      data: Buffer2.alloc(0),
+      headers: {
+        "Content-Type": "application/octet-stream",
+        ...paidByHeader,
+        ...chunkingHeader
+      },
+      signal
+    });
+    this.logger.debug(
+      `Confirming upload to Turbo with uploadId ${uploadId} for up to ${defaultMaxWaitTimeMins} minutes.`
+    );
+    const startTime = Date.now();
+    const cutoffTime = startTime + maxWaitTimeMs;
+    let attempts = 0;
+    while (Date.now() < cutoffTime) {
+      const waitTimeMs = Math.min(
+        Math.floor((cutoffTime - Date.now()) * (3 / 4)),
+        minimumWaitPerStepMs
+      );
+      await sleep(waitTimeMs);
+      if (signal?.aborted) {
+        this.logger.warn(`Upload finalization aborted by signal.`);
+        throw new CanceledError2();
+      }
+      const response = await this.http.get({
+        endpoint: `/chunks/${this.token}/${uploadId}/status`,
+        signal
+      });
+      this.logger.debug(`Upload status found: ${response.status}`, {
+        status: response.status,
+        attempts: attempts++,
+        maxWaitTimeMs,
+        minimumWaitPerStepMs,
+        waitTimeMs,
+        elapsedMs: Date.now() - startTime
+      });
+      if (response.status === "FINALIZED") {
+        this.logger.debug(`Upload finalized successfully.`);
+        return response.receipt;
+      }
+      if (response.status === "UNDERFUNDED") {
+        throw new FailedRequestError(`Insufficient balance`, 402);
+      }
+    }
+    throw new Error(
+      `Upload multi-part finalization has timed out for Upload ID ${uploadId}`
+    );
+  }
+};
+async function* splitIntoChunks(source, chunkByteCount) {
+  if (isReadableStream2(source)) {
+    yield* splitReadableStreamIntoChunks(source, chunkByteCount);
+  } else {
+    yield* splitReadableIntoChunks(source, chunkByteCount);
+  }
+}
+async function* splitReadableIntoChunks(source, chunkByteCount) {
+  const queue2 = [];
+  let total = 0;
+  let encoder;
+  for await (const piece of source) {
+    const u82 = piece instanceof Uint8Array ? new Uint8Array(piece.buffer, piece.byteOffset, piece.byteLength) : (encoder ??= new TextEncoder()).encode(String(piece));
+    queue2.push(u82);
+    total += u82.length;
+    while (total >= chunkByteCount) {
+      const out = new Uint8Array(chunkByteCount);
+      let remaining = out.length;
+      let off2 = 0;
+      while (remaining > 0) {
+        const head = queue2[0];
+        const take = Math.min(remaining, head.length);
+        out.set(head.subarray(0, take), off2);
+        off2 += take;
+        remaining -= take;
+        if (take === head.length) {
+          queue2.shift();
+        } else {
+          queue2[0] = head.subarray(take);
+        }
+      }
+      total -= chunkByteCount;
+      yield Buffer2.from(out.buffer, out.byteOffset, out.byteLength);
+    }
+  }
+  if (total > 0) {
+    const out = new Uint8Array(total);
+    let off2 = 0;
+    while (queue2.length > 0) {
+      const head = queue2.shift();
+      out.set(head, off2);
+      off2 += head.length;
+    }
+    yield Buffer2.from(out.buffer, out.byteOffset, out.byteLength);
+  }
+}
+async function* splitReadableStreamIntoChunks(source, chunkByteCount) {
+  const reader = source.getReader();
+  const queue2 = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      const u82 = new Uint8Array(
+        value.buffer,
+        value.byteOffset,
+        value.byteLength
+      );
+      queue2.push(u82);
+      total += u82.length;
+      while (total >= chunkByteCount) {
+        const out = new Uint8Array(chunkByteCount);
+        let remaining = out.length;
+        let off2 = 0;
+        while (remaining > 0) {
+          const head = queue2[0];
+          const take = Math.min(remaining, head.length);
+          out.set(head.subarray(0, take), off2);
+          off2 += take;
+          remaining -= take;
+          if (take === head.length) {
+            queue2.shift();
+          } else {
+            queue2[0] = head.subarray(take);
+          }
+        }
+        total -= chunkByteCount;
+        yield Buffer2.from(out.buffer, out.byteOffset, out.byteLength);
+      }
+    }
+    if (total > 0) {
+      const out = new Uint8Array(total);
+      let off2 = 0;
+      while (queue2.length > 0) {
+        const head = queue2.shift();
+        out.set(head, off2);
+        off2 += head.length;
+      }
+      yield Buffer2.from(out.buffer, out.byteOffset, out.byteLength);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function isReadableStream2(source) {
+  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 void 0;
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function") {
+    return anyFn(real);
+  }
+  const controller = new AbortController();
+  for (const s7 of real) {
+    const sig = s7;
+    if (sig.aborted) {
+      controller.abort(sig.reason);
+      break;
+    }
+    const onAbort = () => controller.abort(sig.reason);
+    s7.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+
 // src/common/upload.ts
 function isTurboUploadFileWithStreamFactoryParams(params) {
   return "fileStreamFactory" in params;
@@ -274679,7 +275099,10 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
     data,
     dataItemOpts,
     signal,
-    events
+    events,
+    chunkByteCount,
+    chunkingMode,
+    maxChunkConcurrency
   }) {
     if (isBlob2(data)) {
       const streamFactory = () => data.stream();
@@ -274705,7 +275128,10 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
       fileSizeFactory: () => dataBuffer.byteLength,
       signal,
       dataItemOpts,
-      events
+      events,
+      chunkByteCount,
+      chunkingMode,
+      maxChunkConcurrency
     });
   }
   resolveUploadFileConfig(params) {
@@ -274737,17 +275163,38 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
     let lastError = void 0;
     let lastStatusCode = void 0;
     const emitter = new TurboEventEmitter(events);
-    const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
-      fileStreamFactory,
-      fileSizeFactory,
-      dataItemOpts,
-      emitter
-    });
     while (retries < maxRetries) {
       if (signal?.aborted) {
         throw new CanceledError2();
       }
+      const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
+        fileStreamFactory,
+        fileSizeFactory,
+        dataItemOpts,
+        emitter
+      });
       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,
+          maxFinalizeMs: params.maxFinalizeMs
+        });
+        if (chunkedUploader.shouldUseChunkUploader) {
+          const response2 = await chunkedUploader.upload({
+            dataItemStreamFactory,
+            dataItemSizeFactory,
+            dataItemOpts,
+            signal,
+            events
+          });
+          return response2;
+        }
         const response = await this.uploadSignedDataItem({
           dataItemStreamFactory,
           dataItemSizeFactory,
@@ -274783,7 +275230,7 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
         ]);
       }
     }
-    const msg = `Failed to upload file after ${maxRetries + 1} attempts
+    const msg = `Failed to upload file after ${retries + 1} attempts
 ${lastError instanceof Error ? lastError.message : lastError}`;
     if (lastError instanceof FailedRequestError) {
       lastError.message = msg;
@@ -274847,7 +275294,11 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
       signal,
       manifestOptions = {},
       maxConcurrentUploads = 1,
-      throwOnFailure = true
+      throwOnFailure = true,
+      maxChunkConcurrency,
+      chunkByteCount,
+      chunkingMode,
+      maxFinalizeMs
     } = params;
     const { disableManifest, indexFile, fallbackFile } = manifestOptions;
     const paths = {};
@@ -274873,7 +275324,10 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
           fileStreamFactory: () => this.getFileStreamForFile(file),
           fileSizeFactory: () => this.getFileSize(file),
           signal,
-          dataItemOpts: dataItemOptsWithContentType
+          dataItemOpts: dataItemOptsWithContentType,
+          chunkByteCount,
+          maxChunkConcurrency,
+          chunkingMode
         });
         const relativePath = this.getRelativePath(file, params);
         paths[relativePath] = { id: result2.id };
@@ -274916,7 +275370,11 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
       fileStreamFactory: () => this.createManifestStream(manifestBuffer),
       fileSizeFactory: () => manifestBuffer.byteLength,
       signal,
-      dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType }
+      dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType },
+      chunkByteCount,
+      maxChunkConcurrency,
+      maxFinalizeMs,
+      chunkingMode
     });
     return {
       ...response,
@@ -275164,9 +275622,20 @@ var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
     data,
     dataItemOpts,
     signal,
-    events
+    events,
+    chunkByteCount,
+    chunkingMode,
+    maxChunkConcurrency
   }) {
-    return this.uploadService.upload({ data, dataItemOpts, signal, events });
+    return this.uploadService.upload({
+      data,
+      dataItemOpts,
+      signal,
+      events,
+      chunkByteCount,
+      chunkingMode,
+      maxChunkConcurrency
+    });
   }
   uploadFile(params) {
     return this.uploadService.uploadFile(params);
@@ -275944,6 +276413,9 @@ export {
   isWebUploadFolderParams,
   lamportToTokenAmount,
   mARIOToTokenAmount,
+  multipartFailedStatus,
+  multipartFinalizedStatus,
+  multipartPendingStatus,
   privateKeyFromKyveMnemonic,
   readableStreamToAsyncIterable,
   signerFromKyveMnemonic,
@@ -275952,6 +276424,7 @@ export {
   tokenToBaseMap,
   tokenTypes,
   ukyveToTokenAmount,
+  validChunkingModes,
   weiToTokenAmount
 };
 /*! Bundled license information:

package/lib/cjs/cli/commands/uploadFile.js

@@ -32,6 +32,7 @@ async function uploadFile(options) {
         fileStreamFactory: () => (0, fs_1.createReadStream)(filePath),
         fileSizeFactory: () => fileSize,
         dataItemOpts: { tags: [...constants_js_1.turboCliTags, ...customTags], paidBy },
+        ...(0, utils_js_1.getChunkingOptions)(options),
     });
     console.log('Uploaded file:', JSON.stringify(result, null, 2));
 }