@backblaze-labs/b2-sdk 0.1.0 → 0.2.0

package/dist/util/best-effort.cjs

@@ -1,10 +1,44 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-async function bestEffort(fn) {
-  try {
-    await fn();
-  } catch {
-  }
+//#region src/util/best-effort.ts
+/**
+* Runs an async cleanup operation and swallows any rejection.
+*
+* Used at error-handling boundaries (e.g. after a multipart upload fails,
+* when trying to `cancelLargeFile` on the orphaned upload). The primary
+* error is what the caller wants to see; a secondary failure during
+* cleanup must not shadow it.
+*
+* Naming the pattern instead of inlining a try/catch with an empty catch
+* makes the intent explicit at the call site: this is best-effort cleanup,
+* not a silent error swallow.
+*
+* @param fn - Cleanup async function. Its return value is ignored; any
+*   thrown error or rejected promise is caught and discarded.
+* @param onError - Optional observer called with the swallowed cleanup error.
+*
+* @returns A promise that always resolves, regardless of `fn`'s outcome.
+*
+* @example
+* ```ts
+* try {
+*   await uploadParts(...)
+* } catch (err) {
+*   await bestEffort(() =>
+*     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),
+*   )
+*   throw err
+* }
+* ```
+*/
+async function bestEffort(fn, onError) {
+	try {
+		await fn();
+	} catch (error) {
+		try {
+			onError?.(error);
+		} catch {}
+	}
 }
+//#endregion
 exports.bestEffort = bestEffort;
-//# sourceMappingURL=best-effort.cjs.map
+
+//# sourceMappingURL=best-effort.cjs.map

package/dist/util/best-effort.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"best-effort.cjs","sources":["../../src/util/best-effort.ts"],"sourcesContent":["/**\n * Runs an async cleanup operation and swallows any rejection.\n *\n * Used at error-handling boundaries (e.g. after a multipart upload fails,\n * when trying to `cancelLargeFile` on the orphaned upload). The primary\n * error is what the caller wants to see; a secondary failure during\n * cleanup must not shadow it.\n *\n * Naming the pattern instead of inlining a try/catch with an empty catch\n * makes the intent explicit at the call site: this is best-effort cleanup,\n * not a silent error swallow.\n *\n * @param fn - Cleanup async function. Its return value is ignored; any\n *   thrown error or rejected promise is caught and discarded.\n *\n * @returns A promise that always resolves, regardless of `fn`'s outcome.\n *\n * @example\n * ```ts\n * try {\n *   await uploadParts(...)\n * } catch (err) {\n *   await bestEffort(() =>\n *     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),\n *   )\n *   throw err\n * }\n * ```\n */\nexport async function bestEffort(fn: () => Promise<unknown>): Promise<void> {\n  try {\n    await fn()\n  } catch {\n    // Intentional swallow: this helper exists for cleanup paths where a\n    // secondary failure must not shadow the primary error.\n  }\n}\n"],"names":[],"mappings":";;AA6BA,eAAsB,WAAW,IAA2C;AAC1E,MAAI;AACF,UAAM,GAAA;AAAA,EACR,QAAQ;AAAA,EAGR;AACF;;"}
+{"version":3,"file":"best-effort.cjs","names":[],"sources":["../../src/util/best-effort.ts"],"sourcesContent":["/**\n * Runs an async cleanup operation and swallows any rejection.\n *\n * Used at error-handling boundaries (e.g. after a multipart upload fails,\n * when trying to `cancelLargeFile` on the orphaned upload). The primary\n * error is what the caller wants to see; a secondary failure during\n * cleanup must not shadow it.\n *\n * Naming the pattern instead of inlining a try/catch with an empty catch\n * makes the intent explicit at the call site: this is best-effort cleanup,\n * not a silent error swallow.\n *\n * @param fn - Cleanup async function. Its return value is ignored; any\n *   thrown error or rejected promise is caught and discarded.\n * @param onError - Optional observer called with the swallowed cleanup error.\n *\n * @returns A promise that always resolves, regardless of `fn`'s outcome.\n *\n * @example\n * ```ts\n * try {\n *   await uploadParts(...)\n * } catch (err) {\n *   await bestEffort(() =>\n *     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),\n *   )\n *   throw err\n * }\n * ```\n */\nexport async function bestEffort(\n  fn: () => Promise<unknown>,\n  onError?: (error: unknown) => void,\n): Promise<void> {\n  try {\n    await fn()\n  } catch (error) {\n    try {\n      onError?.(error)\n    } catch {\n      // Observer failures are also secondary cleanup failures.\n    }\n    // Intentional swallow: this helper exists for cleanup paths where a\n    // secondary failure must not shadow the primary error.\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,eAAsB,WACpB,IACA,SACe;CACf,IAAI;EACF,MAAM,GAAG;CACX,SAAS,OAAO;EACd,IAAI;GACF,UAAU,KAAK;EACjB,QAAQ,CAER;CAGF;AACF"}

package/dist/util/best-effort.d.cts

@@ -12,6 +12,7 @@
  *
  * @param fn - Cleanup async function. Its return value is ignored; any
  *   thrown error or rejected promise is caught and discarded.
+ * @param onError - Optional observer called with the swallowed cleanup error.
  *
  * @returns A promise that always resolves, regardless of `fn`'s outcome.
  *
@@ -27,5 +28,5 @@
  * }
  * ```
  */
-export declare function bestEffort(fn: () => Promise<unknown>): Promise<void>;
+export declare function bestEffort(fn: () => Promise<unknown>, onError?: (error: unknown) => void): Promise<void>;
 //# sourceMappingURL=best-effort.d.ts.map

package/dist/util/best-effort.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"best-effort.d.ts","sourceRoot":"","sources":["../../src/util/best-effort.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAO1E"}
+{"version":3,"file":"best-effort.d.ts","sourceRoot":"","sources":["../../src/util/best-effort.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/util/best-effort.d.ts

@@ -12,6 +12,7 @@
  *
  * @param fn - Cleanup async function. Its return value is ignored; any
  *   thrown error or rejected promise is caught and discarded.
+ * @param onError - Optional observer called with the swallowed cleanup error.
  *
  * @returns A promise that always resolves, regardless of `fn`'s outcome.
  *
@@ -27,5 +28,5 @@
  * }
  * ```
  */
-export declare function bestEffort(fn: () => Promise<unknown>): Promise<void>;
+export declare function bestEffort(fn: () => Promise<unknown>, onError?: (error: unknown) => void): Promise<void>;
 //# sourceMappingURL=best-effort.d.ts.map

package/dist/util/best-effort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"best-effort.d.ts","sourceRoot":"","sources":["../../src/util/best-effort.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAO1E"}
+{"version":3,"file":"best-effort.d.ts","sourceRoot":"","sources":["../../src/util/best-effort.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/util/best-effort.js

@@ -1,10 +1,44 @@
-async function bestEffort(fn) {
-  try {
-    await fn();
-  } catch {
-  }
+//#region src/util/best-effort.ts
+/**
+* Runs an async cleanup operation and swallows any rejection.
+*
+* Used at error-handling boundaries (e.g. after a multipart upload fails,
+* when trying to `cancelLargeFile` on the orphaned upload). The primary
+* error is what the caller wants to see; a secondary failure during
+* cleanup must not shadow it.
+*
+* Naming the pattern instead of inlining a try/catch with an empty catch
+* makes the intent explicit at the call site: this is best-effort cleanup,
+* not a silent error swallow.
+*
+* @param fn - Cleanup async function. Its return value is ignored; any
+*   thrown error or rejected promise is caught and discarded.
+* @param onError - Optional observer called with the swallowed cleanup error.
+*
+* @returns A promise that always resolves, regardless of `fn`'s outcome.
+*
+* @example
+* ```ts
+* try {
+*   await uploadParts(...)
+* } catch (err) {
+*   await bestEffort(() =>
+*     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),
+*   )
+*   throw err
+* }
+* ```
+*/
+async function bestEffort(fn, onError) {
+	try {
+		await fn();
+	} catch (error) {
+		try {
+			onError?.(error);
+		} catch {}
+	}
 }
-export {
-  bestEffort
-};
-//# sourceMappingURL=best-effort.js.map
+//#endregion
+export { bestEffort };
+
+//# sourceMappingURL=best-effort.js.map

package/dist/util/best-effort.js.map

@@ -1 +1 @@
-{"version":3,"file":"best-effort.js","sources":["../../src/util/best-effort.ts"],"sourcesContent":["/**\n * Runs an async cleanup operation and swallows any rejection.\n *\n * Used at error-handling boundaries (e.g. after a multipart upload fails,\n * when trying to `cancelLargeFile` on the orphaned upload). The primary\n * error is what the caller wants to see; a secondary failure during\n * cleanup must not shadow it.\n *\n * Naming the pattern instead of inlining a try/catch with an empty catch\n * makes the intent explicit at the call site: this is best-effort cleanup,\n * not a silent error swallow.\n *\n * @param fn - Cleanup async function. Its return value is ignored; any\n *   thrown error or rejected promise is caught and discarded.\n *\n * @returns A promise that always resolves, regardless of `fn`'s outcome.\n *\n * @example\n * ```ts\n * try {\n *   await uploadParts(...)\n * } catch (err) {\n *   await bestEffort(() =>\n *     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),\n *   )\n *   throw err\n * }\n * ```\n */\nexport async function bestEffort(fn: () => Promise<unknown>): Promise<void> {\n  try {\n    await fn()\n  } catch {\n    // Intentional swallow: this helper exists for cleanup paths where a\n    // secondary failure must not shadow the primary error.\n  }\n}\n"],"names":[],"mappings":"AA6BA,eAAsB,WAAW,IAA2C;AAC1E,MAAI;AACF,UAAM,GAAA;AAAA,EACR,QAAQ;AAAA,EAGR;AACF;"}
+{"version":3,"file":"best-effort.js","names":[],"sources":["../../src/util/best-effort.ts"],"sourcesContent":["/**\n * Runs an async cleanup operation and swallows any rejection.\n *\n * Used at error-handling boundaries (e.g. after a multipart upload fails,\n * when trying to `cancelLargeFile` on the orphaned upload). The primary\n * error is what the caller wants to see; a secondary failure during\n * cleanup must not shadow it.\n *\n * Naming the pattern instead of inlining a try/catch with an empty catch\n * makes the intent explicit at the call site: this is best-effort cleanup,\n * not a silent error swallow.\n *\n * @param fn - Cleanup async function. Its return value is ignored; any\n *   thrown error or rejected promise is caught and discarded.\n * @param onError - Optional observer called with the swallowed cleanup error.\n *\n * @returns A promise that always resolves, regardless of `fn`'s outcome.\n *\n * @example\n * ```ts\n * try {\n *   await uploadParts(...)\n * } catch (err) {\n *   await bestEffort(() =>\n *     raw.cancelLargeFile(apiUrl, authToken, { fileId: largeFileId }),\n *   )\n *   throw err\n * }\n * ```\n */\nexport async function bestEffort(\n  fn: () => Promise<unknown>,\n  onError?: (error: unknown) => void,\n): Promise<void> {\n  try {\n    await fn()\n  } catch (error) {\n    try {\n      onError?.(error)\n    } catch {\n      // Observer failures are also secondary cleanup failures.\n    }\n    // Intentional swallow: this helper exists for cleanup paths where a\n    // secondary failure must not shadow the primary error.\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,eAAsB,WACpB,IACA,SACe;CACf,IAAI;EACF,MAAM,GAAG;CACX,SAAS,OAAO;EACd,IAAI;GACF,UAAU,KAAK;EACjB,QAAQ,CAER;CAGF;AACF"}

package/dist/util/bytes.cjs

@@ -0,0 +1,23 @@
+//#region src/util/bytes.ts
+/**
+* Return an ArrayBuffer containing exactly the bytes visible through a
+* Uint8Array view.
+*
+* Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views
+* are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do
+* not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a
+* fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.
+*
+* @param bytes - The byte view to copy.
+*
+* @returns An ArrayBuffer containing exactly `bytes`.
+*/
+function arrayBufferFor(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
+	if (bytes.buffer instanceof ArrayBuffer) return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+	return new Uint8Array(bytes).buffer;
+}
+//#endregion
+exports.arrayBufferFor = arrayBufferFor;
+
+//# sourceMappingURL=bytes.cjs.map

package/dist/util/bytes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.cjs","names":[],"sources":["../../src/util/bytes.ts"],"sourcesContent":["/**\n * Return an ArrayBuffer containing exactly the bytes visible through a\n * Uint8Array view.\n *\n * Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views\n * are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do\n * not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a\n * fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.\n *\n * @param bytes - The byte view to copy.\n *\n * @returns An ArrayBuffer containing exactly `bytes`.\n */\nexport function arrayBufferFor(bytes: Uint8Array): ArrayBuffer {\n  if (\n    bytes.buffer instanceof ArrayBuffer &&\n    bytes.byteOffset === 0 &&\n    bytes.byteLength === bytes.buffer.byteLength\n  ) {\n    return bytes.buffer\n  }\n  if (bytes.buffer instanceof ArrayBuffer) {\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)\n  }\n\n  return new Uint8Array(bytes).buffer\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,eAAe,OAAgC;CAC7D,IACE,MAAM,kBAAkB,eACxB,MAAM,eAAe,KACrB,MAAM,eAAe,MAAM,OAAO,YAElC,OAAO,MAAM;CAEf,IAAI,MAAM,kBAAkB,aAC1B,OAAO,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;CAGjF,OAAO,IAAI,WAAW,KAAK,CAAC,CAAC;AAC/B"}

package/dist/util/bytes.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Return an ArrayBuffer containing exactly the bytes visible through a
+ * Uint8Array view.
+ *
+ * Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views
+ * are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do
+ * not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a
+ * fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.
+ *
+ * @param bytes - The byte view to copy.
+ *
+ * @returns An ArrayBuffer containing exactly `bytes`.
+ */
+export declare function arrayBufferFor(bytes: Uint8Array): ArrayBuffer;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/util/bytes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/util/bytes.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAa7D"}

package/dist/util/bytes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Return an ArrayBuffer containing exactly the bytes visible through a
+ * Uint8Array view.
+ *
+ * Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views
+ * are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do
+ * not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a
+ * fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.
+ *
+ * @param bytes - The byte view to copy.
+ *
+ * @returns An ArrayBuffer containing exactly `bytes`.
+ */
+export declare function arrayBufferFor(bytes: Uint8Array): ArrayBuffer;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/util/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/util/bytes.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAa7D"}

package/dist/util/bytes.js

@@ -0,0 +1,23 @@
+//#region src/util/bytes.ts
+/**
+* Return an ArrayBuffer containing exactly the bytes visible through a
+* Uint8Array view.
+*
+* Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views
+* are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do
+* not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a
+* fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.
+*
+* @param bytes - The byte view to copy.
+*
+* @returns An ArrayBuffer containing exactly `bytes`.
+*/
+function arrayBufferFor(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
+	if (bytes.buffer instanceof ArrayBuffer) return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+	return new Uint8Array(bytes).buffer;
+}
+//#endregion
+export { arrayBufferFor };
+
+//# sourceMappingURL=bytes.js.map

package/dist/util/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","names":[],"sources":["../../src/util/bytes.ts"],"sourcesContent":["/**\n * Return an ArrayBuffer containing exactly the bytes visible through a\n * Uint8Array view.\n *\n * Exact `ArrayBuffer` views are returned directly. Other `ArrayBuffer` views\n * are copied with `ArrayBuffer.prototype.slice()` so Node `Buffer` instances do\n * not expose slab bytes. `SharedArrayBuffer`-backed views are copied through a\n * fresh `Uint8Array` so Web Crypto receives a plain `ArrayBuffer`.\n *\n * @param bytes - The byte view to copy.\n *\n * @returns An ArrayBuffer containing exactly `bytes`.\n */\nexport function arrayBufferFor(bytes: Uint8Array): ArrayBuffer {\n  if (\n    bytes.buffer instanceof ArrayBuffer &&\n    bytes.byteOffset === 0 &&\n    bytes.byteLength === bytes.buffer.byteLength\n  ) {\n    return bytes.buffer\n  }\n  if (bytes.buffer instanceof ArrayBuffer) {\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)\n  }\n\n  return new Uint8Array(bytes).buffer\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,eAAe,OAAgC;CAC7D,IACE,MAAM,kBAAkB,eACxB,MAAM,eAAe,KACrB,MAAM,eAAe,MAAM,OAAO,YAElC,OAAO,MAAM;CAEf,IAAI,MAAM,kBAAkB,aAC1B,OAAO,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;CAGjF,OAAO,IAAI,WAAW,KAAK,CAAC,CAAC;AAC/B"}

package/dist/util/crypto.cjs

@@ -0,0 +1,68 @@
+const require_text_codec = require("./text-codec.cjs");
+const require_bytes = require("./bytes.cjs");
+//#region src/util/crypto.ts
+var CRYPTO_UNAVAILABLE_MESSAGE = "SHA-256 and HMAC-SHA256 require globalThis.crypto.subtle or Node.js node:crypto.";
+/**
+* Convert bytes to a lowercase hex string.
+*
+* @param bytes - The raw bytes to encode as hexadecimal characters.
+*
+* @returns The lowercase hex-encoded string representation of the input bytes.
+*/
+function hexEncode(bytes) {
+	return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Compute a SHA-256 digest and return it as lowercase hex.
+*
+* @param data - UTF-8 string or raw bytes to digest.
+*
+* @returns The lowercase hex-encoded SHA-256 digest.
+*/
+async function sha256Hex(data) {
+	const bytes = bytesFor(data);
+	if (globalThis.crypto?.subtle) {
+		const digest = await globalThis.crypto.subtle.digest("SHA-256", require_bytes.arrayBufferFor(bytes));
+		return hexEncode(new Uint8Array(digest));
+	}
+	const { createHash } = await importNodeCrypto();
+	return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+* Compute an HMAC-SHA256 digest.
+*
+* @param key - UTF-8 string or raw bytes for the HMAC key.
+* @param data - UTF-8 string or raw bytes to sign.
+*
+* @returns The raw HMAC-SHA256 digest bytes.
+*/
+async function hmacSha256(key, data) {
+	const keyBytes = bytesFor(key);
+	const dataBytes = bytesFor(data);
+	if (globalThis.crypto?.subtle) {
+		const cryptoKey = await globalThis.crypto.subtle.importKey("raw", require_bytes.arrayBufferFor(keyBytes), {
+			name: "HMAC",
+			hash: "SHA-256"
+		}, false, ["sign"]);
+		const signature = await globalThis.crypto.subtle.sign("HMAC", cryptoKey, require_bytes.arrayBufferFor(dataBytes));
+		return new Uint8Array(signature);
+	}
+	const { createHmac } = await importNodeCrypto();
+	return new Uint8Array(createHmac("sha256", keyBytes).update(dataBytes).digest());
+}
+function bytesFor(data) {
+	return typeof data === "string" ? require_text_codec.utf8Encoder.encode(data) : data;
+}
+async function importNodeCrypto() {
+	try {
+		return await import("node:crypto");
+	} catch (err) {
+		throw new Error(CRYPTO_UNAVAILABLE_MESSAGE, { cause: err });
+	}
+}
+//#endregion
+exports.hexEncode = hexEncode;
+exports.hmacSha256 = hmacSha256;
+exports.sha256Hex = sha256Hex;
+
+//# sourceMappingURL=crypto.cjs.map

package/dist/util/crypto.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.cjs","names":[],"sources":["../../src/util/crypto.ts"],"sourcesContent":["import { arrayBufferFor } from './bytes.ts'\nimport { utf8Encoder } from './text-codec.ts'\n\nconst CRYPTO_UNAVAILABLE_MESSAGE =\n  'SHA-256 and HMAC-SHA256 require globalThis.crypto.subtle or Node.js node:crypto.'\n\ntype NodeHash = {\n  update(data: Uint8Array): NodeHash\n  digest(encoding: 'hex'): string\n}\n\ntype NodeHmac = {\n  update(data: Uint8Array): NodeHmac\n  digest(): Uint8Array\n}\n\ntype NodeCrypto = {\n  createHash(algorithm: string): NodeHash\n  createHmac(algorithm: string, key: Uint8Array): NodeHmac\n}\n\n/**\n * Convert bytes to a lowercase hex string.\n *\n * @param bytes - The raw bytes to encode as hexadecimal characters.\n *\n * @returns The lowercase hex-encoded string representation of the input bytes.\n */\nexport function hexEncode(bytes: Uint8Array): string {\n  return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\n/**\n * Compute a SHA-256 digest and return it as lowercase hex.\n *\n * @param data - UTF-8 string or raw bytes to digest.\n *\n * @returns The lowercase hex-encoded SHA-256 digest.\n */\nexport async function sha256Hex(data: string | Uint8Array): Promise<string> {\n  const bytes = bytesFor(data)\n  if (globalThis.crypto?.subtle) {\n    const digest = await globalThis.crypto.subtle.digest('SHA-256', arrayBufferFor(bytes))\n    return hexEncode(new Uint8Array(digest))\n  }\n\n  const { createHash } = await importNodeCrypto()\n  return createHash('sha256').update(bytes).digest('hex')\n}\n\n/**\n * Compute an HMAC-SHA256 digest.\n *\n * @param key - UTF-8 string or raw bytes for the HMAC key.\n * @param data - UTF-8 string or raw bytes to sign.\n *\n * @returns The raw HMAC-SHA256 digest bytes.\n */\nexport async function hmacSha256(\n  key: string | Uint8Array,\n  data: string | Uint8Array,\n): Promise<Uint8Array> {\n  const keyBytes = bytesFor(key)\n  const dataBytes = bytesFor(data)\n\n  if (globalThis.crypto?.subtle) {\n    const cryptoKey = await globalThis.crypto.subtle.importKey(\n      'raw',\n      arrayBufferFor(keyBytes),\n      { name: 'HMAC', hash: 'SHA-256' },\n      false,\n      ['sign'],\n    )\n    const signature = await globalThis.crypto.subtle.sign(\n      'HMAC',\n      cryptoKey,\n      arrayBufferFor(dataBytes),\n    )\n    return new Uint8Array(signature)\n  }\n\n  const { createHmac } = await importNodeCrypto()\n  return new Uint8Array(createHmac('sha256', keyBytes).update(dataBytes).digest())\n}\n\nfunction bytesFor(data: string | Uint8Array): Uint8Array {\n  return typeof data === 'string' ? utf8Encoder.encode(data) : data\n}\n\nasync function importNodeCrypto(): Promise<NodeCrypto> {\n  try {\n    // biome-ignore lint/suspicious/noTsIgnore: isomorphic import -- @ts-ignore is silent when node:crypto resolves and suppresses the error when it does not\n    // @ts-ignore -- node:crypto may not exist in browser/edge runtimes\n    return (await import('node:crypto')) as NodeCrypto\n  } catch (err) {\n    throw new Error(CRYPTO_UNAVAILABLE_MESSAGE, { cause: err })\n  }\n}\n"],"mappings":";;;AAGA,IAAM,6BACJ;;;;;;;;AAwBF,SAAgB,UAAU,OAA2B;CACnD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;AAC7E;;;;;;;;AASA,eAAsB,UAAU,MAA4C;CAC1E,MAAM,QAAQ,SAAS,IAAI;CAC3B,IAAI,WAAW,QAAQ,QAAQ;EAC7B,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,WAAW,cAAA,eAAe,KAAK,CAAC;EACrF,OAAO,UAAU,IAAI,WAAW,MAAM,CAAC;CACzC;CAEA,MAAM,EAAE,eAAe,MAAM,iBAAiB;CAC9C,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACxD;;;;;;;;;AAUA,eAAsB,WACpB,KACA,MACqB;CACrB,MAAM,WAAW,SAAS,GAAG;CAC7B,MAAM,YAAY,SAAS,IAAI;CAE/B,IAAI,WAAW,QAAQ,QAAQ;EAC7B,MAAM,YAAY,MAAM,WAAW,OAAO,OAAO,UAC/C,OACA,cAAA,eAAe,QAAQ,GACvB;GAAE,MAAM;GAAQ,MAAM;EAAU,GAChC,OACA,CAAC,MAAM,CACT;EACA,MAAM,YAAY,MAAM,WAAW,OAAO,OAAO,KAC/C,QACA,WACA,cAAA,eAAe,SAAS,CAC1B;EACA,OAAO,IAAI,WAAW,SAAS;CACjC;CAEA,MAAM,EAAE,eAAe,MAAM,iBAAiB;CAC9C,OAAO,IAAI,WAAW,WAAW,UAAU,QAAQ,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,CAAC;AACjF;AAEA,SAAS,SAAS,MAAuC;CACvD,OAAO,OAAO,SAAS,WAAW,mBAAA,YAAY,OAAO,IAAI,IAAI;AAC/D;AAEA,eAAe,mBAAwC;CACrD,IAAI;EAGF,OAAQ,MAAM,OAAO;CACvB,SAAS,KAAK;EACZ,MAAM,IAAI,MAAM,4BAA4B,EAAE,OAAO,IAAI,CAAC;CAC5D;AACF"}

package/dist/util/crypto.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Convert bytes to a lowercase hex string.
+ *
+ * @param bytes - The raw bytes to encode as hexadecimal characters.
+ *
+ * @returns The lowercase hex-encoded string representation of the input bytes.
+ */
+export declare function hexEncode(bytes: Uint8Array): string;
+/**
+ * Compute a SHA-256 digest and return it as lowercase hex.
+ *
+ * @param data - UTF-8 string or raw bytes to digest.
+ *
+ * @returns The lowercase hex-encoded SHA-256 digest.
+ */
+export declare function sha256Hex(data: string | Uint8Array): Promise<string>;
+/**
+ * Compute an HMAC-SHA256 digest.
+ *
+ * @param key - UTF-8 string or raw bytes for the HMAC key.
+ * @param data - UTF-8 string or raw bytes to sign.
+ *
+ * @returns The raw HMAC-SHA256 digest bytes.
+ */
+export declare function hmacSha256(key: string | Uint8Array, data: string | Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/util/crypto.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/util/crypto.js"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnD;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1E;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,IAAI,EAAE,MAAM,GAAG,UAAU,GACxB,OAAO,CAAC,UAAU,CAAC,CAsBrB"}

package/dist/util/crypto.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Convert bytes to a lowercase hex string.
+ *
+ * @param bytes - The raw bytes to encode as hexadecimal characters.
+ *
+ * @returns The lowercase hex-encoded string representation of the input bytes.
+ */
+export declare function hexEncode(bytes: Uint8Array): string;
+/**
+ * Compute a SHA-256 digest and return it as lowercase hex.
+ *
+ * @param data - UTF-8 string or raw bytes to digest.
+ *
+ * @returns The lowercase hex-encoded SHA-256 digest.
+ */
+export declare function sha256Hex(data: string | Uint8Array): Promise<string>;
+/**
+ * Compute an HMAC-SHA256 digest.
+ *
+ * @param key - UTF-8 string or raw bytes for the HMAC key.
+ * @param data - UTF-8 string or raw bytes to sign.
+ *
+ * @returns The raw HMAC-SHA256 digest bytes.
+ */
+export declare function hmacSha256(key: string | Uint8Array, data: string | Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/util/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/util/crypto.js"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnD;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1E;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,IAAI,EAAE,MAAM,GAAG,UAAU,GACxB,OAAO,CAAC,UAAU,CAAC,CAsBrB"}

package/dist/util/crypto.js

@@ -0,0 +1,66 @@
+import { utf8Encoder } from "./text-codec.js";
+import { arrayBufferFor } from "./bytes.js";
+//#region src/util/crypto.ts
+var CRYPTO_UNAVAILABLE_MESSAGE = "SHA-256 and HMAC-SHA256 require globalThis.crypto.subtle or Node.js node:crypto.";
+/**
+* Convert bytes to a lowercase hex string.
+*
+* @param bytes - The raw bytes to encode as hexadecimal characters.
+*
+* @returns The lowercase hex-encoded string representation of the input bytes.
+*/
+function hexEncode(bytes) {
+	return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Compute a SHA-256 digest and return it as lowercase hex.
+*
+* @param data - UTF-8 string or raw bytes to digest.
+*
+* @returns The lowercase hex-encoded SHA-256 digest.
+*/
+async function sha256Hex(data) {
+	const bytes = bytesFor(data);
+	if (globalThis.crypto?.subtle) {
+		const digest = await globalThis.crypto.subtle.digest("SHA-256", arrayBufferFor(bytes));
+		return hexEncode(new Uint8Array(digest));
+	}
+	const { createHash } = await importNodeCrypto();
+	return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+* Compute an HMAC-SHA256 digest.
+*
+* @param key - UTF-8 string or raw bytes for the HMAC key.
+* @param data - UTF-8 string or raw bytes to sign.
+*
+* @returns The raw HMAC-SHA256 digest bytes.
+*/
+async function hmacSha256(key, data) {
+	const keyBytes = bytesFor(key);
+	const dataBytes = bytesFor(data);
+	if (globalThis.crypto?.subtle) {
+		const cryptoKey = await globalThis.crypto.subtle.importKey("raw", arrayBufferFor(keyBytes), {
+			name: "HMAC",
+			hash: "SHA-256"
+		}, false, ["sign"]);
+		const signature = await globalThis.crypto.subtle.sign("HMAC", cryptoKey, arrayBufferFor(dataBytes));
+		return new Uint8Array(signature);
+	}
+	const { createHmac } = await importNodeCrypto();
+	return new Uint8Array(createHmac("sha256", keyBytes).update(dataBytes).digest());
+}
+function bytesFor(data) {
+	return typeof data === "string" ? utf8Encoder.encode(data) : data;
+}
+async function importNodeCrypto() {
+	try {
+		return await import("node:crypto");
+	} catch (err) {
+		throw new Error(CRYPTO_UNAVAILABLE_MESSAGE, { cause: err });
+	}
+}
+//#endregion
+export { hexEncode, hmacSha256, sha256Hex };
+
+//# sourceMappingURL=crypto.js.map

package/dist/util/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","names":[],"sources":["../../src/util/crypto.ts"],"sourcesContent":["import { arrayBufferFor } from './bytes.ts'\nimport { utf8Encoder } from './text-codec.ts'\n\nconst CRYPTO_UNAVAILABLE_MESSAGE =\n  'SHA-256 and HMAC-SHA256 require globalThis.crypto.subtle or Node.js node:crypto.'\n\ntype NodeHash = {\n  update(data: Uint8Array): NodeHash\n  digest(encoding: 'hex'): string\n}\n\ntype NodeHmac = {\n  update(data: Uint8Array): NodeHmac\n  digest(): Uint8Array\n}\n\ntype NodeCrypto = {\n  createHash(algorithm: string): NodeHash\n  createHmac(algorithm: string, key: Uint8Array): NodeHmac\n}\n\n/**\n * Convert bytes to a lowercase hex string.\n *\n * @param bytes - The raw bytes to encode as hexadecimal characters.\n *\n * @returns The lowercase hex-encoded string representation of the input bytes.\n */\nexport function hexEncode(bytes: Uint8Array): string {\n  return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\n/**\n * Compute a SHA-256 digest and return it as lowercase hex.\n *\n * @param data - UTF-8 string or raw bytes to digest.\n *\n * @returns The lowercase hex-encoded SHA-256 digest.\n */\nexport async function sha256Hex(data: string | Uint8Array): Promise<string> {\n  const bytes = bytesFor(data)\n  if (globalThis.crypto?.subtle) {\n    const digest = await globalThis.crypto.subtle.digest('SHA-256', arrayBufferFor(bytes))\n    return hexEncode(new Uint8Array(digest))\n  }\n\n  const { createHash } = await importNodeCrypto()\n  return createHash('sha256').update(bytes).digest('hex')\n}\n\n/**\n * Compute an HMAC-SHA256 digest.\n *\n * @param key - UTF-8 string or raw bytes for the HMAC key.\n * @param data - UTF-8 string or raw bytes to sign.\n *\n * @returns The raw HMAC-SHA256 digest bytes.\n */\nexport async function hmacSha256(\n  key: string | Uint8Array,\n  data: string | Uint8Array,\n): Promise<Uint8Array> {\n  const keyBytes = bytesFor(key)\n  const dataBytes = bytesFor(data)\n\n  if (globalThis.crypto?.subtle) {\n    const cryptoKey = await globalThis.crypto.subtle.importKey(\n      'raw',\n      arrayBufferFor(keyBytes),\n      { name: 'HMAC', hash: 'SHA-256' },\n      false,\n      ['sign'],\n    )\n    const signature = await globalThis.crypto.subtle.sign(\n      'HMAC',\n      cryptoKey,\n      arrayBufferFor(dataBytes),\n    )\n    return new Uint8Array(signature)\n  }\n\n  const { createHmac } = await importNodeCrypto()\n  return new Uint8Array(createHmac('sha256', keyBytes).update(dataBytes).digest())\n}\n\nfunction bytesFor(data: string | Uint8Array): Uint8Array {\n  return typeof data === 'string' ? utf8Encoder.encode(data) : data\n}\n\nasync function importNodeCrypto(): Promise<NodeCrypto> {\n  try {\n    // biome-ignore lint/suspicious/noTsIgnore: isomorphic import -- @ts-ignore is silent when node:crypto resolves and suppresses the error when it does not\n    // @ts-ignore -- node:crypto may not exist in browser/edge runtimes\n    return (await import('node:crypto')) as NodeCrypto\n  } catch (err) {\n    throw new Error(CRYPTO_UNAVAILABLE_MESSAGE, { cause: err })\n  }\n}\n"],"mappings":";;;AAGA,IAAM,6BACJ;;;;;;;;AAwBF,SAAgB,UAAU,OAA2B;CACnD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;AAC7E;;;;;;;;AASA,eAAsB,UAAU,MAA4C;CAC1E,MAAM,QAAQ,SAAS,IAAI;CAC3B,IAAI,WAAW,QAAQ,QAAQ;EAC7B,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,WAAW,eAAe,KAAK,CAAC;EACrF,OAAO,UAAU,IAAI,WAAW,MAAM,CAAC;CACzC;CAEA,MAAM,EAAE,eAAe,MAAM,iBAAiB;CAC9C,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACxD;;;;;;;;;AAUA,eAAsB,WACpB,KACA,MACqB;CACrB,MAAM,WAAW,SAAS,GAAG;CAC7B,MAAM,YAAY,SAAS,IAAI;CAE/B,IAAI,WAAW,QAAQ,QAAQ;EAC7B,MAAM,YAAY,MAAM,WAAW,OAAO,OAAO,UAC/C,OACA,eAAe,QAAQ,GACvB;GAAE,MAAM;GAAQ,MAAM;EAAU,GAChC,OACA,CAAC,MAAM,CACT;EACA,MAAM,YAAY,MAAM,WAAW,OAAO,OAAO,KAC/C,QACA,WACA,eAAe,SAAS,CAC1B;EACA,OAAO,IAAI,WAAW,SAAS;CACjC;CAEA,MAAM,EAAE,eAAe,MAAM,iBAAiB;CAC9C,OAAO,IAAI,WAAW,WAAW,UAAU,QAAQ,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,CAAC;AACjF;AAEA,SAAS,SAAS,MAAuC;CACvD,OAAO,OAAO,SAAS,WAAW,YAAY,OAAO,IAAI,IAAI;AAC/D;AAEA,eAAe,mBAAwC;CACrD,IAAI;EAGF,OAAQ,MAAM,OAAO;CACvB,SAAS,KAAK;EACZ,MAAM,IAAI,MAAM,4BAA4B,EAAE,OAAO,IAAI,CAAC;CAC5D;AACF"}

package/dist/util/defaults.cjs

@@ -1,11 +1,27 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const DEFAULT_TRANSFER_CONCURRENCY = 4;
-const DEFAULT_BULK_CONCURRENCY = 10;
-const DEFAULT_PAGE_SIZE = 1e3;
-const DEFAULT_CONTENT_TYPE = "b2/x-auto";
-exports.DEFAULT_BULK_CONCURRENCY = DEFAULT_BULK_CONCURRENCY;
+//#region src/util/defaults.ts
+/**
+* Default `maxFileCount` for list-style endpoints
+* (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2
+* caps `maxFileCount` at `10000` for these endpoints; the SDK requests
+* `1000` per page so a single network blip doesn't lose 10× the work and
+* so callers see results sooner.
+*
+* `b2_list_unfinished_large_files` is capped at `100` server-side and is
+* not affected by this constant.
+*/
+var DEFAULT_PAGE_SIZE = 1e3;
+/**
+* Default MIME type for uploads when the caller omits `contentType`.
+* B2 documents `b2/x-auto` as the magic value that asks the service to
+* sniff the file's content and pick a sensible `Content-Type` itself.
+* Centralising the literal here keeps the upload, copy, and create-write
+* paths in sync.
+*
+* @see https://www.backblaze.com/apidocs/b2-upload-file
+*/
+var DEFAULT_CONTENT_TYPE = "b2/x-auto";
+//#endregion
 exports.DEFAULT_CONTENT_TYPE = DEFAULT_CONTENT_TYPE;
 exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
-exports.DEFAULT_TRANSFER_CONCURRENCY = DEFAULT_TRANSFER_CONCURRENCY;
-//# sourceMappingURL=defaults.cjs.map
+
+//# sourceMappingURL=defaults.cjs.map

package/dist/util/defaults.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.cjs","sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"names":[],"mappings":";;AAqBO,MAAM,+BAA+B;AAYrC,MAAM,2BAA2B;AAYjC,MAAM,oBAAoB;AAW1B,MAAM,uBAAuB;;;;;"}
+{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;;;;;;;;;;AA6CA,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}

package/dist/util/defaults.js

@@ -1,11 +1,26 @@
-const DEFAULT_TRANSFER_CONCURRENCY = 4;
-const DEFAULT_BULK_CONCURRENCY = 10;
-const DEFAULT_PAGE_SIZE = 1e3;
-const DEFAULT_CONTENT_TYPE = "b2/x-auto";
-export {
-  DEFAULT_BULK_CONCURRENCY,
-  DEFAULT_CONTENT_TYPE,
-  DEFAULT_PAGE_SIZE,
-  DEFAULT_TRANSFER_CONCURRENCY
-};
-//# sourceMappingURL=defaults.js.map
+//#region src/util/defaults.ts
+/**
+* Default `maxFileCount` for list-style endpoints
+* (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2
+* caps `maxFileCount` at `10000` for these endpoints; the SDK requests
+* `1000` per page so a single network blip doesn't lose 10× the work and
+* so callers see results sooner.
+*
+* `b2_list_unfinished_large_files` is capped at `100` server-side and is
+* not affected by this constant.
+*/
+var DEFAULT_PAGE_SIZE = 1e3;
+/**
+* Default MIME type for uploads when the caller omits `contentType`.
+* B2 documents `b2/x-auto` as the magic value that asks the service to
+* sniff the file's content and pick a sensible `Content-Type` itself.
+* Centralising the literal here keeps the upload, copy, and create-write
+* paths in sync.
+*
+* @see https://www.backblaze.com/apidocs/b2-upload-file
+*/
+var DEFAULT_CONTENT_TYPE = "b2/x-auto";
+//#endregion
+export { DEFAULT_CONTENT_TYPE, DEFAULT_PAGE_SIZE };
+
+//# sourceMappingURL=defaults.js.map

package/dist/util/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"names":[],"mappings":"AAqBO,MAAM,+BAA+B;AAYrC,MAAM,2BAA2B;AAYjC,MAAM,oBAAoB;AAW1B,MAAM,uBAAuB;"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;;;;;;;;;;AA6CA,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}