@backblaze-labs/b2-sdk 0.1.0

package/dist/upload/single.js

@@ -0,0 +1,47 @@
+import { IncrementalSha1 } from "../streams/hash.js";
+import { ProgressTracker } from "../streams/progress.js";
+import { DEFAULT_CONTENT_TYPE } from "../util/defaults.js";
+async function uploadSmallFile(raw, accountInfo, options) {
+  let uploadEntry = accountInfo.checkoutUploadUrl(options.bucketId);
+  if (!uploadEntry) {
+    const resp = await raw.getUploadUrl(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {
+      bucketId: options.bucketId
+    });
+    uploadEntry = { uploadUrl: resp.uploadUrl, authorizationToken: resp.authorizationToken };
+  }
+  const data = new Uint8Array(await options.source.toArrayBuffer());
+  const sha1 = new IncrementalSha1();
+  await sha1.update(data);
+  const sha1Hex = await sha1.digest();
+  const tracker = new ProgressTracker(options.onProgress, data.byteLength, 1);
+  try {
+    const result = await raw.uploadFile(
+      uploadEntry.uploadUrl,
+      {
+        authorization: uploadEntry.authorizationToken,
+        fileName: options.fileName,
+        contentType: options.contentType ?? DEFAULT_CONTENT_TYPE,
+        contentLength: data.byteLength,
+        contentSha1: sha1Hex,
+        ...options.fileInfo !== void 0 ? { fileInfo: options.fileInfo } : {},
+        ...options.serverSideEncryption !== void 0 ? { serverSideEncryption: options.serverSideEncryption } : {},
+        ...options.fileRetention !== void 0 ? { fileRetention: options.fileRetention } : {},
+        ...options.legalHold !== void 0 ? { legalHold: options.legalHold } : {},
+        ...options.lastModifiedMillis !== void 0 ? { lastModifiedMillis: options.lastModifiedMillis } : {}
+      },
+      data,
+      options.signal
+    );
+    tracker.addBytes(data.byteLength);
+    tracker.completePart();
+    accountInfo.returnUploadUrl(options.bucketId, uploadEntry);
+    return result;
+  } catch (err) {
+    accountInfo.evictUploadUrl(options.bucketId, uploadEntry);
+    throw err;
+  }
+}
+export {
+  uploadSmallFile
+};
+//# sourceMappingURL=single.js.map

package/dist/upload/single.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single.js","sources":["../../src/upload/single.ts"],"sourcesContent":["import type { AccountInfo } from '../auth/account-info.ts'\nimport type { RawClient } from '../raw/index.ts'\nimport { IncrementalSha1 } from '../streams/hash.ts'\nimport { type ProgressListener, ProgressTracker } from '../streams/progress.ts'\nimport type { ContentSource } from '../streams/source.ts'\nimport type { EncryptionSetting } from '../types/encryption.ts'\nimport type { FileVersion } from '../types/file.ts'\nimport type { BucketId } from '../types/ids.ts'\nimport type { FileRetentionValue, LegalHoldValue } from '../types/lock.ts'\nimport { DEFAULT_CONTENT_TYPE } from '../util/defaults.ts'\n\n/** Options for uploading a small file in a single HTTP request. */\nexport interface UploadFileOptions {\n  /** Target bucket for the upload. */\n  readonly bucketId: BucketId\n  /** Full B2 file name including any path prefix. */\n  readonly fileName: string\n  /** Content to upload. */\n  readonly source: ContentSource\n  /** MIME type. Defaults to `b2/x-auto` for server-side detection. */\n  readonly contentType?: string\n  /** Custom file info key/value pairs stored with the file. */\n  readonly fileInfo?: Record<string, string>\n  /** Server-side encryption settings. */\n  readonly serverSideEncryption?: EncryptionSetting\n  /** File retention policy applied at upload time. */\n  readonly fileRetention?: FileRetentionValue\n  /** Legal hold status applied at upload time. */\n  readonly legalHold?: LegalHoldValue\n  /** Override the last-modified timestamp (epoch millis). */\n  readonly lastModifiedMillis?: number\n  /** Callback invoked with upload progress updates. */\n  readonly onProgress?: ProgressListener\n  /** Signal to abort the upload. */\n  readonly signal?: AbortSignal\n}\n\n/**\n * Uploads a file in a single HTTP request (suitable for files up to ~100 MB).\n *\n * The entire file content is read into memory, SHA-1 hashed, and sent in one\n * `b2_upload_file` call. For files larger than the recommended part size, use\n * {@link uploadLargeFile} which splits the file into parts uploaded in parallel.\n *\n * Upload URLs are pooled via {@link AccountInfo} and recycled on success or\n * evicted on failure.\n *\n * @param raw - Low-level B2 API client.\n * @param accountInfo - Authorized account state (tokens, URLs, upload URL pool).\n * @param options - Upload parameters.\n *\n * @returns The resulting {@link FileVersion} metadata.\n */\nexport async function uploadSmallFile(\n  raw: RawClient,\n  accountInfo: AccountInfo,\n  options: UploadFileOptions,\n): Promise<FileVersion> {\n  let uploadEntry = accountInfo.checkoutUploadUrl(options.bucketId)\n\n  if (!uploadEntry) {\n    const resp = await raw.getUploadUrl(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {\n      bucketId: options.bucketId,\n    })\n    uploadEntry = { uploadUrl: resp.uploadUrl, authorizationToken: resp.authorizationToken }\n  }\n\n  const data = new Uint8Array(await options.source.toArrayBuffer())\n  const sha1 = new IncrementalSha1()\n  await sha1.update(data)\n  const sha1Hex = await sha1.digest()\n\n  // Single-request uploads send the whole payload in one shot, so the\n  // tracker reports a single \"part\" worth of progress: one byte burst at\n  // completion and a parts-completed transition from 0 → 1. The tracker\n  // is created (rather than calling the listener directly) so consumers\n  // see the same {bytesTransferred, totalBytes, partsCompleted,\n  // totalParts, elapsedMs} shape they get from `uploadLargeFile`.\n  const tracker = new ProgressTracker(options.onProgress, data.byteLength, 1)\n\n  try {\n    const result = await raw.uploadFile(\n      uploadEntry.uploadUrl,\n      {\n        authorization: uploadEntry.authorizationToken,\n        fileName: options.fileName,\n        contentType: options.contentType ?? DEFAULT_CONTENT_TYPE,\n        contentLength: data.byteLength,\n        contentSha1: sha1Hex,\n        ...(options.fileInfo !== undefined ? { fileInfo: options.fileInfo } : {}),\n        ...(options.serverSideEncryption !== undefined\n          ? { serverSideEncryption: options.serverSideEncryption }\n          : {}),\n        ...(options.fileRetention !== undefined ? { fileRetention: options.fileRetention } : {}),\n        ...(options.legalHold !== undefined ? { legalHold: options.legalHold } : {}),\n        ...(options.lastModifiedMillis !== undefined\n          ? { lastModifiedMillis: options.lastModifiedMillis }\n          : {}),\n      },\n      data,\n      options.signal,\n    )\n\n    tracker.addBytes(data.byteLength)\n    tracker.completePart()\n    accountInfo.returnUploadUrl(options.bucketId, uploadEntry)\n    return result\n  } catch (err) {\n    accountInfo.evictUploadUrl(options.bucketId, uploadEntry)\n    throw err\n  }\n}\n"],"names":[],"mappings":";;;AAqDA,eAAsB,gBACpB,KACA,aACA,SACsB;AACtB,MAAI,cAAc,YAAY,kBAAkB,QAAQ,QAAQ;AAEhE,MAAI,CAAC,aAAa;AAChB,UAAM,OAAO,MAAM,IAAI,aAAa,YAAY,UAAA,GAAa,YAAY,gBAAgB;AAAA,MACvF,UAAU,QAAQ;AAAA,IAAA,CACnB;AACD,kBAAc,EAAE,WAAW,KAAK,WAAW,oBAAoB,KAAK,mBAAA;AAAA,EACtE;AAEA,QAAM,OAAO,IAAI,WAAW,MAAM,QAAQ,OAAO,eAAe;AAChE,QAAM,OAAO,IAAI,gBAAA;AACjB,QAAM,KAAK,OAAO,IAAI;AACtB,QAAM,UAAU,MAAM,KAAK,OAAA;AAQ3B,QAAM,UAAU,IAAI,gBAAgB,QAAQ,YAAY,KAAK,YAAY,CAAC;AAE1E,MAAI;AACF,UAAM,SAAS,MAAM,IAAI;AAAA,MACvB,YAAY;AAAA,MACZ;AAAA,QACE,eAAe,YAAY;AAAA,QAC3B,UAAU,QAAQ;AAAA,QAClB,aAAa,QAAQ,eAAe;AAAA,QACpC,eAAe,KAAK;AAAA,QACpB,aAAa;AAAA,QACb,GAAI,QAAQ,aAAa,SAAY,EAAE,UAAU,QAAQ,SAAA,IAAa,CAAA;AAAA,QACtE,GAAI,QAAQ,yBAAyB,SACjC,EAAE,sBAAsB,QAAQ,qBAAA,IAChC,CAAA;AAAA,QACJ,GAAI,QAAQ,kBAAkB,SAAY,EAAE,eAAe,QAAQ,cAAA,IAAkB,CAAA;AAAA,QACrF,GAAI,QAAQ,cAAc,SAAY,EAAE,WAAW,QAAQ,UAAA,IAAc,CAAA;AAAA,QACzE,GAAI,QAAQ,uBAAuB,SAC/B,EAAE,oBAAoB,QAAQ,uBAC9B,CAAA;AAAA,MAAC;AAAA,MAEP;AAAA,MACA,QAAQ;AAAA,IAAA;AAGV,YAAQ,SAAS,KAAK,UAAU;AAChC,YAAQ,aAAA;AACR,gBAAY,gBAAgB,QAAQ,UAAU,WAAW;AACzD,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,gBAAY,eAAe,QAAQ,UAAU,WAAW;AACxD,UAAM;AAAA,EACR;AACF;"}

package/dist/upload/stream.cjs

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const hash = require("../streams/hash.cjs");
+const progress = require("../streams/progress.cjs");
+const defaults = require("../util/defaults.cjs");
+const toError = require("../util/to-error.cjs");
+const cancel = require("./cancel.cjs");
+const concurrency = require("./concurrency.cjs");
+function createWriteStream(raw, accountInfo, options) {
+  const minPartSize = accountInfo.getAbsoluteMinimumPartSize();
+  const recommendedPartSize = accountInfo.getRecommendedPartSize();
+  const partSize = Math.max(options.partSize ?? recommendedPartSize, minPartSize);
+  const concurrency$1 = options.concurrency ?? defaults.DEFAULT_TRANSFER_CONCURRENCY;
+  const tracker = new progress.ProgressTracker(options.onProgress, null, null);
+  const sem = new concurrency.Semaphore(concurrency$1);
+  let largeFileId = null;
+  let startPromise = null;
+  let nextPartNumber = 1;
+  let pendingBytes = 0;
+  const pending = [];
+  const partSha1s = [];
+  const inflight = [];
+  let errored = null;
+  const {
+    promise: done,
+    resolve: resolveDone,
+    reject: rejectDone
+  } = Promise.withResolvers();
+  done.catch(() => {
+  });
+  function ensureStarted() {
+    if (largeFileId !== null) return Promise.resolve(largeFileId);
+    if (startPromise !== null) return startPromise;
+    startPromise = (async () => {
+      const resp = await raw.startLargeFile(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {
+        bucketId: options.bucketId,
+        fileName: options.fileName,
+        contentType: options.contentType ?? defaults.DEFAULT_CONTENT_TYPE,
+        fileInfo: options.fileInfo ?? {},
+        ...options.serverSideEncryption !== void 0 ? { serverSideEncryption: options.serverSideEncryption } : {}
+      });
+      largeFileId = resp.fileId;
+      return largeFileId;
+    })();
+    return startPromise;
+  }
+  async function shipPart(data, partNumber) {
+    const fileId = await ensureStarted();
+    const sha1 = new hash.IncrementalSha1();
+    await sha1.update(data);
+    const sha1Hex = await sha1.digest();
+    let uploadEntry = accountInfo.checkoutPartUploadUrl(fileId);
+    if (!uploadEntry) {
+      const resp = await raw.getUploadPartUrl(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {
+        fileId
+      });
+      uploadEntry = { uploadUrl: resp.uploadUrl, authorizationToken: resp.authorizationToken };
+    }
+    try {
+      const result = await raw.uploadPart(
+        uploadEntry.uploadUrl,
+        {
+          authorization: uploadEntry.authorizationToken,
+          partNumber,
+          contentLength: data.byteLength,
+          contentSha1: sha1Hex,
+          ...options.serverSideEncryption !== void 0 ? { serverSideEncryption: options.serverSideEncryption } : {}
+        },
+        data,
+        options.signal
+      );
+      accountInfo.returnPartUploadUrl(fileId, uploadEntry);
+      partSha1s[partNumber - 1] = result.contentSha1;
+      tracker.addBytes(data.byteLength);
+      tracker.completePart();
+    } catch (err) {
+      accountInfo.evictPartUploadUrl(fileId, uploadEntry);
+      throw err;
+    }
+  }
+  function dispatchPart() {
+    if (pending.length === 0) return;
+    let data;
+    if (pending.length === 1) {
+      const head = pending[0];
+      if (!head) return;
+      data = head;
+    } else {
+      const total = pending.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+      data = new Uint8Array(total);
+      let offset = 0;
+      for (const chunk of pending) {
+        data.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+    }
+    pending.length = 0;
+    pendingBytes = 0;
+    const partNumber = nextPartNumber++;
+    const task = (async () => {
+      await sem.acquire();
+      try {
+        await shipPart(data, partNumber);
+      } catch (err) {
+        errored = toError.toError(err);
+        throw err;
+      } finally {
+        sem.release();
+      }
+    })();
+    inflight.push(task);
+    task.catch(() => {
+    });
+  }
+  const writable = new WritableStream({
+    async write(chunk) {
+      if (errored) throw errored;
+      options.signal?.throwIfAborted();
+      pending.push(chunk);
+      pendingBytes += chunk.byteLength;
+      while (pendingBytes >= partSize) {
+        const carved = carveExact(pending, partSize);
+        const partNumber = nextPartNumber++;
+        pendingBytes -= partSize;
+        const task = (async () => {
+          await sem.acquire();
+          try {
+            await shipPart(carved, partNumber);
+          } catch (err) {
+            errored = toError.toError(err);
+            throw err;
+          } finally {
+            sem.release();
+          }
+        })();
+        inflight.push(task);
+        task.catch(() => {
+        });
+      }
+    },
+    async close() {
+      try {
+        if (errored) throw errored;
+        options.signal?.throwIfAborted();
+        if (pendingBytes > 0) {
+          dispatchPart();
+        }
+        await Promise.all(inflight);
+        if (errored) throw errored;
+        if (largeFileId === null) {
+          throw new Error("createWriteStream closed without any data written.");
+        }
+        const result = await raw.finishLargeFile(
+          accountInfo.getApiUrl(),
+          accountInfo.getAuthToken(),
+          { fileId: largeFileId, partSha1Array: partSha1s }
+        );
+        resolveDone(result);
+      } catch (err) {
+        const fileIdToCancel = largeFileId;
+        if (fileIdToCancel !== null) {
+          await cancel.cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel);
+        }
+        rejectDone(err);
+        throw err;
+      }
+    },
+    async abort(reason) {
+      const fileIdToCancel = largeFileId;
+      if (fileIdToCancel !== null) {
+        await cancel.cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel);
+      }
+      rejectDone(toError.toError(reason));
+    }
+  });
+  return { writable, done };
+}
+function carveExact(chunks, size) {
+  const out = new Uint8Array(size);
+  let written = 0;
+  while (written < size && chunks.length > 0) {
+    const head = chunks[0];
+    if (!head) break;
+    const need = size - written;
+    if (head.byteLength <= need) {
+      out.set(head, written);
+      written += head.byteLength;
+      chunks.shift();
+    } else {
+      out.set(head.subarray(0, need), written);
+      chunks[0] = head.subarray(need);
+      written += need;
+    }
+  }
+  return out;
+}
+exports.createWriteStream = createWriteStream;
+//# sourceMappingURL=stream.cjs.map

package/dist/upload/stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.cjs","sources":["../../src/upload/stream.ts"],"sourcesContent":["import type { AccountInfo } from '../auth/account-info.ts'\nimport type { RawClient } from '../raw/index.ts'\nimport { IncrementalSha1 } from '../streams/hash.ts'\nimport type { ProgressListener } from '../streams/progress.ts'\nimport { ProgressTracker } from '../streams/progress.ts'\nimport type { EncryptionSetting } from '../types/encryption.ts'\nimport type { FileVersion } from '../types/file.ts'\nimport type { BucketId, LargeFileId } from '../types/ids.ts'\nimport { DEFAULT_CONTENT_TYPE, DEFAULT_TRANSFER_CONCURRENCY } from '../util/defaults.ts'\nimport { toError } from '../util/to-error.ts'\nimport { cancelLargeFileBestEffort } from './cancel.ts'\nimport { Semaphore } from './concurrency.ts'\n\n/** Options for creating a streaming multipart upload sink. */\nexport interface CreateWriteStreamOptions {\n  /** Target bucket for the upload. */\n  readonly bucketId: BucketId\n  /** Destination file name in the bucket. */\n  readonly fileName: string\n  /** MIME type. Defaults to `b2/x-auto`. */\n  readonly contentType?: string\n  /** Custom file info stored with the file. */\n  readonly fileInfo?: Record<string, string>\n  /** Server-side encryption applied to each part. */\n  readonly serverSideEncryption?: EncryptionSetting\n  /**\n   * Target part size in bytes. The stream buffers writes until this many bytes\n   * are accumulated, then ships a part. Must be at least the account's\n   * absolute minimum part size; the implementation will raise it if too small.\n   */\n  readonly partSize?: number\n  /** Maximum number of parts uploaded in parallel. Defaults to 4. */\n  readonly concurrency?: number\n  /** Callback invoked with upload progress events. `totalBytes` is `null` (size unknown). */\n  readonly onProgress?: ProgressListener\n  /** Aborts the upload and cancels the unfinished large file. */\n  readonly signal?: AbortSignal\n}\n\n/**\n * Handle returned by `B2Object.createWriteStream`: the Web `WritableStream` to\n * pipe data into, plus a promise that resolves with the finished\n * {@link FileVersion} once the stream is closed and all parts have been\n * uploaded.\n */\nexport interface UploadWriteHandle {\n  /** Web `WritableStream` sink to pipe data into. */\n  readonly writable: WritableStream<Uint8Array>\n  /** Resolves with the finalized file version when the stream closes successfully. */\n  readonly done: Promise<FileVersion>\n}\n\n/**\n * Creates a {@link WritableStream} that streams data into a B2 multipart upload.\n *\n * Buffers incoming chunks until `partSize` bytes are accumulated, ships each\n * complete part through the standard multipart engine, and finalizes the file\n * once the stream is closed. Honours backpressure via the queue's bounded\n * concurrency. Streaming uploads do not support resume because the total size\n * and per-part hashes aren't known in advance; use {@link uploadLargeFile} with\n * a buffered source when resume is required.\n *\n * @param raw - Low-level B2 API client.\n * @param accountInfo - Authorized account state (tokens, URLs, part URL pool).\n * @param options - Streaming upload parameters.\n *\n * @returns A {@link UploadWriteHandle} with the writable sink and a completion promise.\n */\nexport function createWriteStream(\n  raw: RawClient,\n  accountInfo: AccountInfo,\n  options: CreateWriteStreamOptions,\n): UploadWriteHandle {\n  const minPartSize = accountInfo.getAbsoluteMinimumPartSize()\n  const recommendedPartSize = accountInfo.getRecommendedPartSize()\n  const partSize = Math.max(options.partSize ?? recommendedPartSize, minPartSize)\n  const concurrency = options.concurrency ?? DEFAULT_TRANSFER_CONCURRENCY\n  const tracker = new ProgressTracker(options.onProgress, null, null)\n  const sem = new Semaphore(concurrency)\n\n  let largeFileId: LargeFileId | null = null\n  let startPromise: Promise<LargeFileId> | null = null\n  let nextPartNumber = 1\n  let pendingBytes = 0\n  const pending: Uint8Array[] = []\n  const partSha1s: string[] = []\n  const inflight: Promise<void>[] = []\n  let errored: Error | null = null\n\n  // ES2024 `Promise.withResolvers()` exposes the resolve/reject pair as\n  // properties of the returned object, avoiding the `let resolve!:` /\n  // `let reject!:` non-null-assertion pattern needed before this API\n  // existed. Available in Node 22 (our minimum), Bun, Deno, modern\n  // browsers, and Cloudflare Workers.\n  const {\n    promise: done,\n    resolve: resolveDone,\n    reject: rejectDone,\n  } = Promise.withResolvers<FileVersion>()\n  // Attach a no-op rejection handler so a `done` that rejects before the\n  // caller observes it never surfaces as a process-level unhandled rejection.\n  // The error is not swallowed: `close()`/`abort()` also reject the writable\n  // (so `pipeTo`/`getWriter().close()` throw), and any later `await done` /\n  // `done.then(onRejected)` the caller attaches still sees the rejection —\n  // extra handlers on the same promise all fire. Mirrors the\n  // `task.catch(() => {})` pattern used for inflight part uploads below, and\n  // keeps the engine well-behaved under Bun and Node's strict\n  // unhandled-rejection mode.\n  done.catch(() => {})\n\n  function ensureStarted(): Promise<LargeFileId> {\n    if (largeFileId !== null) return Promise.resolve(largeFileId)\n    if (startPromise !== null) return startPromise\n    startPromise = (async () => {\n      const resp = await raw.startLargeFile(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {\n        bucketId: options.bucketId,\n        fileName: options.fileName,\n        contentType: options.contentType ?? DEFAULT_CONTENT_TYPE,\n        fileInfo: options.fileInfo ?? {},\n        ...(options.serverSideEncryption !== undefined\n          ? { serverSideEncryption: options.serverSideEncryption }\n          : {}),\n      })\n      largeFileId = resp.fileId\n      return largeFileId\n    })()\n    return startPromise\n  }\n\n  async function shipPart(data: Uint8Array, partNumber: number): Promise<void> {\n    const fileId = await ensureStarted()\n\n    const sha1 = new IncrementalSha1()\n    await sha1.update(data)\n    const sha1Hex = await sha1.digest()\n\n    let uploadEntry = accountInfo.checkoutPartUploadUrl(fileId)\n    if (!uploadEntry) {\n      const resp = await raw.getUploadPartUrl(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {\n        fileId,\n      })\n      uploadEntry = { uploadUrl: resp.uploadUrl, authorizationToken: resp.authorizationToken }\n    }\n\n    try {\n      const result = await raw.uploadPart(\n        uploadEntry.uploadUrl,\n        {\n          authorization: uploadEntry.authorizationToken,\n          partNumber,\n          contentLength: data.byteLength,\n          contentSha1: sha1Hex,\n          ...(options.serverSideEncryption !== undefined\n            ? { serverSideEncryption: options.serverSideEncryption }\n            : {}),\n        },\n        data as BodyInit,\n        options.signal,\n      )\n      accountInfo.returnPartUploadUrl(fileId, uploadEntry)\n      partSha1s[partNumber - 1] = result.contentSha1\n      tracker.addBytes(data.byteLength)\n      tracker.completePart()\n    } catch (err) {\n      accountInfo.evictPartUploadUrl(fileId, uploadEntry)\n      throw err\n    }\n  }\n\n  function dispatchPart(): void {\n    if (pending.length === 0) return\n    let data: Uint8Array\n    if (pending.length === 1) {\n      const head = pending[0]\n      if (!head) return\n      data = head\n    } else {\n      const total = pending.reduce((sum, chunk) => sum + chunk.byteLength, 0)\n      data = new Uint8Array(total)\n      let offset = 0\n      for (const chunk of pending) {\n        data.set(chunk, offset)\n        offset += chunk.byteLength\n      }\n    }\n    pending.length = 0\n    pendingBytes = 0\n    const partNumber = nextPartNumber++\n    const task = (async () => {\n      await sem.acquire()\n      try {\n        await shipPart(data, partNumber)\n      } catch (err) {\n        errored = toError(err)\n        throw err\n      } finally {\n        sem.release()\n      }\n    })()\n    inflight.push(task)\n    // Swallow rejection here; we check `errored` later.\n    task.catch(() => {})\n  }\n\n  const writable = new WritableStream<Uint8Array>({\n    async write(chunk: Uint8Array): Promise<void> {\n      if (errored) throw errored\n      options.signal?.throwIfAborted()\n\n      pending.push(chunk)\n      pendingBytes += chunk.byteLength\n      while (pendingBytes >= partSize) {\n        // Pull exactly partSize bytes off the front\n        const carved = carveExact(pending, partSize)\n        const partNumber = nextPartNumber++\n        pendingBytes -= partSize\n        const task = (async () => {\n          await sem.acquire()\n          try {\n            await shipPart(carved, partNumber)\n          } catch (err) {\n            errored = toError(err)\n            throw err\n          } finally {\n            sem.release()\n          }\n        })()\n        inflight.push(task)\n        task.catch(() => {})\n      }\n    },\n\n    async close(): Promise<void> {\n      try {\n        if (errored) throw errored\n        options.signal?.throwIfAborted()\n\n        // Ship any remaining bytes as the last part. If the total fit in one\n        // single buffered batch (no parts shipped yet), we have to use the\n        // multipart path anyway since we already called startLargeFile lazily.\n        if (pendingBytes > 0) {\n          dispatchPart()\n        }\n\n        await Promise.all(inflight)\n        if (errored) throw errored\n\n        if (largeFileId === null) {\n          // Stream closed before any data was written. Start an empty large\n          // file? B2 requires at least 2 parts. Reject — callers shouldn't\n          // close an empty stream.\n          throw new Error('createWriteStream closed without any data written.')\n        }\n\n        const result = await raw.finishLargeFile(\n          accountInfo.getApiUrl(),\n          accountInfo.getAuthToken(),\n          { fileId: largeFileId, partSha1Array: partSha1s },\n        )\n        resolveDone(result)\n      } catch (err) {\n        // Capture into a const so the cancel closure sees a non-null\n        // `fileId`; closures don't observe the outer `!== null` narrowing\n        // because the variable is mutable across the lambda boundary.\n        const fileIdToCancel = largeFileId\n        if (fileIdToCancel !== null) {\n          await cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel)\n        }\n        rejectDone(err)\n        throw err\n      }\n    },\n\n    async abort(reason: unknown): Promise<void> {\n      const fileIdToCancel = largeFileId\n      if (fileIdToCancel !== null) {\n        await cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel)\n      }\n      rejectDone(toError(reason))\n    },\n  })\n\n  return { writable, done }\n}\n\n/**\n * Removes exactly `size` bytes from the front of `chunks` (mutates) and returns\n * them as a contiguous Uint8Array. Any trailing remainder of the last chunk\n * stays at the front of `chunks` for the next part.\n *\n * @param chunks - Queue of pending chunks. Modified in place.\n * @param size - Number of bytes to carve off the front.\n *\n * @returns A new Uint8Array containing exactly `size` bytes.\n */\nfunction carveExact(chunks: Uint8Array[], size: number): Uint8Array {\n  const out = new Uint8Array(size)\n  let written = 0\n  while (written < size && chunks.length > 0) {\n    const head = chunks[0]\n    if (!head) break\n    const need = size - written\n    if (head.byteLength <= need) {\n      out.set(head, written)\n      written += head.byteLength\n      chunks.shift()\n    } else {\n      out.set(head.subarray(0, need), written)\n      chunks[0] = head.subarray(need)\n      written += need\n    }\n  }\n  return out\n}\n"],"names":["concurrency","DEFAULT_TRANSFER_CONCURRENCY","ProgressTracker","Semaphore","DEFAULT_CONTENT_TYPE","IncrementalSha1","toError","cancelLargeFileBestEffort"],"mappings":"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"}

package/dist/upload/stream.d.cts

@@ -0,0 +1,61 @@
+import { AccountInfo } from '../auth/account-info.js';
+import { RawClient } from '../raw/index.js';
+import { ProgressListener } from '../streams/progress.js';
+import { EncryptionSetting } from '../types/encryption.js';
+import { FileVersion } from '../types/file.js';
+import { BucketId } from '../types/ids.js';
+/** Options for creating a streaming multipart upload sink. */
+export interface CreateWriteStreamOptions {
+    /** Target bucket for the upload. */
+    readonly bucketId: BucketId;
+    /** Destination file name in the bucket. */
+    readonly fileName: string;
+    /** MIME type. Defaults to `b2/x-auto`. */
+    readonly contentType?: string;
+    /** Custom file info stored with the file. */
+    readonly fileInfo?: Record<string, string>;
+    /** Server-side encryption applied to each part. */
+    readonly serverSideEncryption?: EncryptionSetting;
+    /**
+     * Target part size in bytes. The stream buffers writes until this many bytes
+     * are accumulated, then ships a part. Must be at least the account's
+     * absolute minimum part size; the implementation will raise it if too small.
+     */
+    readonly partSize?: number;
+    /** Maximum number of parts uploaded in parallel. Defaults to 4. */
+    readonly concurrency?: number;
+    /** Callback invoked with upload progress events. `totalBytes` is `null` (size unknown). */
+    readonly onProgress?: ProgressListener;
+    /** Aborts the upload and cancels the unfinished large file. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Handle returned by `B2Object.createWriteStream`: the Web `WritableStream` to
+ * pipe data into, plus a promise that resolves with the finished
+ * {@link FileVersion} once the stream is closed and all parts have been
+ * uploaded.
+ */
+export interface UploadWriteHandle {
+    /** Web `WritableStream` sink to pipe data into. */
+    readonly writable: WritableStream<Uint8Array>;
+    /** Resolves with the finalized file version when the stream closes successfully. */
+    readonly done: Promise<FileVersion>;
+}
+/**
+ * Creates a {@link WritableStream} that streams data into a B2 multipart upload.
+ *
+ * Buffers incoming chunks until `partSize` bytes are accumulated, ships each
+ * complete part through the standard multipart engine, and finalizes the file
+ * once the stream is closed. Honours backpressure via the queue's bounded
+ * concurrency. Streaming uploads do not support resume because the total size
+ * and per-part hashes aren't known in advance; use {@link uploadLargeFile} with
+ * a buffered source when resume is required.
+ *
+ * @param raw - Low-level B2 API client.
+ * @param accountInfo - Authorized account state (tokens, URLs, part URL pool).
+ * @param options - Streaming upload parameters.
+ *
+ * @returns A {@link UploadWriteHandle} with the writable sink and a completion promise.
+ */
+export declare function createWriteStream(raw: RawClient, accountInfo: AccountInfo, options: CreateWriteStreamOptions): UploadWriteHandle;
+//# sourceMappingURL=stream.d.ts.map

package/dist/upload/stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/upload/stream.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAE9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,iBAAiB,CAAA;AAM5D,8DAA8D;AAC9D,MAAM,WAAW,wBAAwB;IACvC,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,mDAAmD;IACnD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,iBAAiB,CAAA;IACjD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAA;IACtC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;IAC7C,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CACpC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,SAAS,EACd,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,wBAAwB,GAChC,iBAAiB,CAmNnB"}

package/dist/upload/stream.d.ts

@@ -0,0 +1,61 @@
+import { AccountInfo } from '../auth/account-info.js';
+import { RawClient } from '../raw/index.js';
+import { ProgressListener } from '../streams/progress.js';
+import { EncryptionSetting } from '../types/encryption.js';
+import { FileVersion } from '../types/file.js';
+import { BucketId } from '../types/ids.js';
+/** Options for creating a streaming multipart upload sink. */
+export interface CreateWriteStreamOptions {
+    /** Target bucket for the upload. */
+    readonly bucketId: BucketId;
+    /** Destination file name in the bucket. */
+    readonly fileName: string;
+    /** MIME type. Defaults to `b2/x-auto`. */
+    readonly contentType?: string;
+    /** Custom file info stored with the file. */
+    readonly fileInfo?: Record<string, string>;
+    /** Server-side encryption applied to each part. */
+    readonly serverSideEncryption?: EncryptionSetting;
+    /**
+     * Target part size in bytes. The stream buffers writes until this many bytes
+     * are accumulated, then ships a part. Must be at least the account's
+     * absolute minimum part size; the implementation will raise it if too small.
+     */
+    readonly partSize?: number;
+    /** Maximum number of parts uploaded in parallel. Defaults to 4. */
+    readonly concurrency?: number;
+    /** Callback invoked with upload progress events. `totalBytes` is `null` (size unknown). */
+    readonly onProgress?: ProgressListener;
+    /** Aborts the upload and cancels the unfinished large file. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Handle returned by `B2Object.createWriteStream`: the Web `WritableStream` to
+ * pipe data into, plus a promise that resolves with the finished
+ * {@link FileVersion} once the stream is closed and all parts have been
+ * uploaded.
+ */
+export interface UploadWriteHandle {
+    /** Web `WritableStream` sink to pipe data into. */
+    readonly writable: WritableStream<Uint8Array>;
+    /** Resolves with the finalized file version when the stream closes successfully. */
+    readonly done: Promise<FileVersion>;
+}
+/**
+ * Creates a {@link WritableStream} that streams data into a B2 multipart upload.
+ *
+ * Buffers incoming chunks until `partSize` bytes are accumulated, ships each
+ * complete part through the standard multipart engine, and finalizes the file
+ * once the stream is closed. Honours backpressure via the queue's bounded
+ * concurrency. Streaming uploads do not support resume because the total size
+ * and per-part hashes aren't known in advance; use {@link uploadLargeFile} with
+ * a buffered source when resume is required.
+ *
+ * @param raw - Low-level B2 API client.
+ * @param accountInfo - Authorized account state (tokens, URLs, part URL pool).
+ * @param options - Streaming upload parameters.
+ *
+ * @returns A {@link UploadWriteHandle} with the writable sink and a completion promise.
+ */
+export declare function createWriteStream(raw: RawClient, accountInfo: AccountInfo, options: CreateWriteStreamOptions): UploadWriteHandle;
+//# sourceMappingURL=stream.d.ts.map

package/dist/upload/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/upload/stream.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAE9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,iBAAiB,CAAA;AAM5D,8DAA8D;AAC9D,MAAM,WAAW,wBAAwB;IACvC,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,mDAAmD;IACnD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,iBAAiB,CAAA;IACjD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAA;IACtC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;IAC7C,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CACpC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,SAAS,EACd,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,wBAAwB,GAChC,iBAAiB,CAmNnB"}

package/dist/upload/stream.js

@@ -0,0 +1,198 @@
+import { IncrementalSha1 } from "../streams/hash.js";
+import { ProgressTracker } from "../streams/progress.js";
+import { DEFAULT_TRANSFER_CONCURRENCY, DEFAULT_CONTENT_TYPE } from "../util/defaults.js";
+import { toError } from "../util/to-error.js";
+import { cancelLargeFileBestEffort } from "./cancel.js";
+import { Semaphore } from "./concurrency.js";
+function createWriteStream(raw, accountInfo, options) {
+  const minPartSize = accountInfo.getAbsoluteMinimumPartSize();
+  const recommendedPartSize = accountInfo.getRecommendedPartSize();
+  const partSize = Math.max(options.partSize ?? recommendedPartSize, minPartSize);
+  const concurrency = options.concurrency ?? DEFAULT_TRANSFER_CONCURRENCY;
+  const tracker = new ProgressTracker(options.onProgress, null, null);
+  const sem = new Semaphore(concurrency);
+  let largeFileId = null;
+  let startPromise = null;
+  let nextPartNumber = 1;
+  let pendingBytes = 0;
+  const pending = [];
+  const partSha1s = [];
+  const inflight = [];
+  let errored = null;
+  const {
+    promise: done,
+    resolve: resolveDone,
+    reject: rejectDone
+  } = Promise.withResolvers();
+  done.catch(() => {
+  });
+  function ensureStarted() {
+    if (largeFileId !== null) return Promise.resolve(largeFileId);
+    if (startPromise !== null) return startPromise;
+    startPromise = (async () => {
+      const resp = await raw.startLargeFile(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {
+        bucketId: options.bucketId,
+        fileName: options.fileName,
+        contentType: options.contentType ?? DEFAULT_CONTENT_TYPE,
+        fileInfo: options.fileInfo ?? {},
+        ...options.serverSideEncryption !== void 0 ? { serverSideEncryption: options.serverSideEncryption } : {}
+      });
+      largeFileId = resp.fileId;
+      return largeFileId;
+    })();
+    return startPromise;
+  }
+  async function shipPart(data, partNumber) {
+    const fileId = await ensureStarted();
+    const sha1 = new IncrementalSha1();
+    await sha1.update(data);
+    const sha1Hex = await sha1.digest();
+    let uploadEntry = accountInfo.checkoutPartUploadUrl(fileId);
+    if (!uploadEntry) {
+      const resp = await raw.getUploadPartUrl(accountInfo.getApiUrl(), accountInfo.getAuthToken(), {
+        fileId
+      });
+      uploadEntry = { uploadUrl: resp.uploadUrl, authorizationToken: resp.authorizationToken };
+    }
+    try {
+      const result = await raw.uploadPart(
+        uploadEntry.uploadUrl,
+        {
+          authorization: uploadEntry.authorizationToken,
+          partNumber,
+          contentLength: data.byteLength,
+          contentSha1: sha1Hex,
+          ...options.serverSideEncryption !== void 0 ? { serverSideEncryption: options.serverSideEncryption } : {}
+        },
+        data,
+        options.signal
+      );
+      accountInfo.returnPartUploadUrl(fileId, uploadEntry);
+      partSha1s[partNumber - 1] = result.contentSha1;
+      tracker.addBytes(data.byteLength);
+      tracker.completePart();
+    } catch (err) {
+      accountInfo.evictPartUploadUrl(fileId, uploadEntry);
+      throw err;
+    }
+  }
+  function dispatchPart() {
+    if (pending.length === 0) return;
+    let data;
+    if (pending.length === 1) {
+      const head = pending[0];
+      if (!head) return;
+      data = head;
+    } else {
+      const total = pending.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+      data = new Uint8Array(total);
+      let offset = 0;
+      for (const chunk of pending) {
+        data.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+    }
+    pending.length = 0;
+    pendingBytes = 0;
+    const partNumber = nextPartNumber++;
+    const task = (async () => {
+      await sem.acquire();
+      try {
+        await shipPart(data, partNumber);
+      } catch (err) {
+        errored = toError(err);
+        throw err;
+      } finally {
+        sem.release();
+      }
+    })();
+    inflight.push(task);
+    task.catch(() => {
+    });
+  }
+  const writable = new WritableStream({
+    async write(chunk) {
+      if (errored) throw errored;
+      options.signal?.throwIfAborted();
+      pending.push(chunk);
+      pendingBytes += chunk.byteLength;
+      while (pendingBytes >= partSize) {
+        const carved = carveExact(pending, partSize);
+        const partNumber = nextPartNumber++;
+        pendingBytes -= partSize;
+        const task = (async () => {
+          await sem.acquire();
+          try {
+            await shipPart(carved, partNumber);
+          } catch (err) {
+            errored = toError(err);
+            throw err;
+          } finally {
+            sem.release();
+          }
+        })();
+        inflight.push(task);
+        task.catch(() => {
+        });
+      }
+    },
+    async close() {
+      try {
+        if (errored) throw errored;
+        options.signal?.throwIfAborted();
+        if (pendingBytes > 0) {
+          dispatchPart();
+        }
+        await Promise.all(inflight);
+        if (errored) throw errored;
+        if (largeFileId === null) {
+          throw new Error("createWriteStream closed without any data written.");
+        }
+        const result = await raw.finishLargeFile(
+          accountInfo.getApiUrl(),
+          accountInfo.getAuthToken(),
+          { fileId: largeFileId, partSha1Array: partSha1s }
+        );
+        resolveDone(result);
+      } catch (err) {
+        const fileIdToCancel = largeFileId;
+        if (fileIdToCancel !== null) {
+          await cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel);
+        }
+        rejectDone(err);
+        throw err;
+      }
+    },
+    async abort(reason) {
+      const fileIdToCancel = largeFileId;
+      if (fileIdToCancel !== null) {
+        await cancelLargeFileBestEffort(raw, accountInfo, fileIdToCancel);
+      }
+      rejectDone(toError(reason));
+    }
+  });
+  return { writable, done };
+}
+function carveExact(chunks, size) {
+  const out = new Uint8Array(size);
+  let written = 0;
+  while (written < size && chunks.length > 0) {
+    const head = chunks[0];
+    if (!head) break;
+    const need = size - written;
+    if (head.byteLength <= need) {
+      out.set(head, written);
+      written += head.byteLength;
+      chunks.shift();
+    } else {
+      out.set(head.subarray(0, need), written);
+      chunks[0] = head.subarray(need);
+      written += need;
+    }
+  }
+  return out;
+}
+export {
+  createWriteStream
+};
+//# sourceMappingURL=stream.js.map