@backblaze-labs/b2-sdk 0.1.0

package/dist/simulator/validation.d.ts

@@ -0,0 +1,104 @@
+/**
+ * B2 spec-compliance validation helpers for the simulator.
+ *
+ * Each function mirrors a documented B2 input limit (file name length,
+ * bucket name regex, file-info byte budget, etc.). Validators return
+ * `null` for valid input or a `{ code, message }` pair that the handler
+ * converts into a synthetic `400`/`403` response with the right B2
+ * error code.
+ *
+ * Keeping validation in one module makes the simulator's "what does B2
+ * reject?" surface auditable in a single file. Doc references inline at
+ * each rule so the spec source is immediate.
+ *
+ * @packageDocumentation
+ */
+/** Shape returned by validation functions when input is rejected. */
+export interface ValidationError {
+    readonly code: string;
+    readonly message: string;
+}
+/** Minimum B2 bucket-name length per https://www.backblaze.com/apidocs/b2-create-bucket. */
+export declare const BUCKET_NAME_MIN = 6;
+/** Maximum B2 bucket-name length per https://www.backblaze.com/apidocs/b2-create-bucket. */
+export declare const BUCKET_NAME_MAX = 63;
+/**
+ * Validates a bucket name against B2's documented rules.
+ *
+ * @param name - Caller-supplied bucket name.
+ *
+ * @returns A `{ code, message }` pair on failure, or `null` when valid.
+ *
+ * @see https://www.backblaze.com/apidocs/b2-create-bucket
+ */
+export declare function validateBucketName(name: string): ValidationError | null;
+/** Max file-name length is 1024 BYTES (UTF-8 encoded), not chars. */
+export declare const FILE_NAME_MAX_BYTES = 1024;
+/**
+ * Validates a file name against B2's documented rules. Mirrors the
+ * server-side checks B2 runs on `b2_upload_file` / `b2_hide_file` /
+ * `b2_start_large_file` / `b2_copy_file` filename inputs.
+ *
+ * @param name - Caller-supplied file name (raw, unencoded).
+ *
+ * @returns A `{ code, message }` pair on failure, or `null` when valid.
+ *
+ * @see https://www.backblaze.com/apidocs/b2-upload-file
+ */
+export declare function validateFileName(name: string): ValidationError | null;
+/** Per-file fileInfo total size cap (sum of key+value bytes). */
+export declare const FILE_INFO_TOTAL_MAX = 2048;
+/** Per-key fileInfo value byte cap. */
+export declare const FILE_INFO_VALUE_MAX = 2048;
+/**
+ * Validates a `fileInfo` record against B2's byte-budget and
+ * key-shape rules.
+ *
+ * @param info - Caller-supplied fileInfo record.
+ *
+ * @returns A `{ code, message }` pair on failure, or `null` when valid.
+ *
+ * @see https://www.backblaze.com/apidocs/b2-upload-file
+ */
+export declare function validateFileInfo(info: Record<string, string>): ValidationError | null;
+/** Per-bucket bucketInfo total max keys. */
+export declare const BUCKET_INFO_MAX_KEYS = 10;
+/** Per-key bucketInfo value byte cap. */
+export declare const BUCKET_INFO_VALUE_MAX = 2048;
+/**
+ * Validates a `bucketInfo` record against B2's per-bucket metadata rules.
+ *
+ * @param info - Caller-supplied bucketInfo record.
+ *
+ * @returns A `{ code, message }` pair on failure, or `null` when valid.
+ *
+ * @see https://www.backblaze.com/apidocs/b2-create-bucket
+ */
+export declare function validateBucketInfo(info: Record<string, string>): ValidationError | null;
+/**
+ * Per-endpoint upper bound on the `maxFileCount` (or `maxKeyCount` /
+ * `maxPartCount`) request field. Sourced from the B2 endpoint docs.
+ */
+export declare const LIST_ENDPOINT_CAPS: {
+    /** `b2_list_file_names.maxFileCount` cap. */
+    readonly b2_list_file_names: 10000;
+    /** `b2_list_file_versions.maxFileCount` cap. */
+    readonly b2_list_file_versions: 10000;
+    /** `b2_list_unfinished_large_files.maxFileCount` cap. */
+    readonly b2_list_unfinished_large_files: 100;
+    /** `b2_list_keys.maxKeyCount` cap. */
+    readonly b2_list_keys: 10000;
+    /** `b2_list_parts.maxPartCount` cap. */
+    readonly b2_list_parts: 10000;
+};
+/**
+ * Validates a `maxFileCount` (or `maxKeyCount` / `maxPartCount`) value
+ * against the per-endpoint cap documented by B2.
+ *
+ * @param requested - Caller-supplied count.
+ * @param endpoint - Which list endpoint this applies to.
+ *
+ * @returns A `{ code, message }` pair on failure, or `null` when valid.
+ */
+export declare function validateMaxCount(requested: number | undefined, endpoint: keyof typeof LIST_ENDPOINT_CAPS): ValidationError | null;
+//# sourceMappingURL=validation.d.ts.map

package/dist/simulator/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/simulator/validation.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAMD,4FAA4F;AAC5F,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,4FAA4F;AAC5F,eAAO,MAAM,eAAe,KAAK,CAAA;AAMjC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAqBvE;AAMD,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAIvC;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAsCrE;AAMD,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,uCAAuC;AACvC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAIvC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,eAAe,GAAG,IAAI,CA6BrF;AAED,4CAA4C;AAC5C,eAAO,MAAM,oBAAoB,KAAK,CAAA;AACtC,yCAAyC;AACzC,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAIzC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,eAAe,GAAG,IAAI,CA8BvF;AAMD;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,6CAA6C;;IAE7C,gDAAgD;;IAEhD,yDAAyD;;IAEzD,sCAAsC;;IAEtC,wCAAwC;;CAEhC,CAAA;AAEV;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,OAAO,kBAAkB,GACxC,eAAe,GAAG,IAAI,CAgBxB"}

package/dist/simulator/validation.js

@@ -0,0 +1,174 @@
+import { utf8Encoder } from "../util/text-codec.js";
+const BUCKET_NAME_MIN = 6;
+const BUCKET_NAME_MAX = 63;
+const BUCKET_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]$/;
+const BUCKET_NAME_RESERVED_PREFIX = "b2-";
+function validateBucketName(name) {
+  if (typeof name !== "string" || name.length < BUCKET_NAME_MIN || name.length > BUCKET_NAME_MAX) {
+    return {
+      code: "invalid_bucket_name",
+      message: `bucketName must be ${BUCKET_NAME_MIN}-${BUCKET_NAME_MAX} characters`
+    };
+  }
+  if (!BUCKET_NAME_REGEX.test(name)) {
+    return {
+      code: "invalid_bucket_name",
+      message: "bucketName must contain only letters, digits, and hyphens; cannot start or end with a hyphen"
+    };
+  }
+  if (name.startsWith(BUCKET_NAME_RESERVED_PREFIX)) {
+    return {
+      code: "invalid_bucket_name",
+      message: `bucketName cannot start with the reserved prefix "${BUCKET_NAME_RESERVED_PREFIX}"`
+    };
+  }
+  return null;
+}
+const FILE_NAME_MAX_BYTES = 1024;
+const FILE_NAME_DEL = 127;
+function validateFileName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    return { code: "invalid_file_name", message: "fileName must be a non-empty string" };
+  }
+  const bytes = utf8Encoder.encode(name);
+  if (bytes.byteLength > FILE_NAME_MAX_BYTES) {
+    return {
+      code: "invalid_file_name",
+      message: `fileName exceeds the 1024-byte UTF-8 limit (got ${bytes.byteLength})`
+    };
+  }
+  for (let i = 0; i < name.length; i++) {
+    const code = name.charCodeAt(i);
+    if (code < 32 || code === FILE_NAME_DEL) {
+      return {
+        code: "invalid_file_name",
+        message: "fileName must not contain control characters (U+0000-U+001F or U+007F)"
+      };
+    }
+  }
+  if (name === "." || name === "..") {
+    return {
+      code: "invalid_file_name",
+      message: 'fileName cannot be exactly "." or ".."'
+    };
+  }
+  if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
+    return {
+      code: "invalid_file_name",
+      message: 'fileName cannot start with "/", end with "/", or contain "//"'
+    };
+  }
+  return null;
+}
+const FILE_INFO_TOTAL_MAX = 2048;
+const FILE_INFO_VALUE_MAX = 2048;
+const FILE_INFO_KEY_REGEX = /^[a-zA-Z0-9_-]+$/;
+function validateFileInfo(info) {
+  let total = 0;
+  for (const [key, value] of Object.entries(info)) {
+    if (!FILE_INFO_KEY_REGEX.test(key)) {
+      return {
+        code: "invalid_file_info",
+        message: `fileInfo key "${key}" must match ^[a-zA-Z0-9_-]+$`
+      };
+    }
+    if (typeof value !== "string") {
+      return { code: "invalid_file_info", message: `fileInfo value for "${key}" must be a string` };
+    }
+    const keyBytes = utf8Encoder.encode(key).byteLength;
+    const valueBytes = utf8Encoder.encode(value).byteLength;
+    if (valueBytes > FILE_INFO_VALUE_MAX) {
+      return {
+        code: "invalid_file_info",
+        message: `fileInfo value for "${key}" exceeds ${FILE_INFO_VALUE_MAX} bytes`
+      };
+    }
+    total += keyBytes + valueBytes;
+  }
+  if (total > FILE_INFO_TOTAL_MAX) {
+    return {
+      code: "invalid_file_info",
+      message: `fileInfo total size ${total} bytes exceeds the ${FILE_INFO_TOTAL_MAX}-byte limit`
+    };
+  }
+  return null;
+}
+const BUCKET_INFO_MAX_KEYS = 10;
+const BUCKET_INFO_VALUE_MAX = 2048;
+const BUCKET_INFO_KEY_REGEX = /^[a-zA-Z0-9_-]+$/;
+function validateBucketInfo(info) {
+  const entries = Object.entries(info);
+  if (entries.length > BUCKET_INFO_MAX_KEYS) {
+    return {
+      code: "invalid_bucket_info",
+      message: `bucketInfo cannot have more than ${BUCKET_INFO_MAX_KEYS} keys (got ${entries.length})`
+    };
+  }
+  for (const [key, value] of entries) {
+    if (!BUCKET_INFO_KEY_REGEX.test(key)) {
+      return {
+        code: "invalid_bucket_info",
+        message: `bucketInfo key "${key}" must match ^[a-zA-Z0-9_-]+$`
+      };
+    }
+    if (typeof value !== "string") {
+      return {
+        code: "invalid_bucket_info",
+        message: `bucketInfo value for "${key}" must be a string`
+      };
+    }
+    const valueBytes = utf8Encoder.encode(value).byteLength;
+    if (valueBytes > BUCKET_INFO_VALUE_MAX) {
+      return {
+        code: "invalid_bucket_info",
+        message: `bucketInfo value for "${key}" exceeds ${BUCKET_INFO_VALUE_MAX} bytes`
+      };
+    }
+  }
+  return null;
+}
+const LIST_ENDPOINT_CAPS = {
+  /** `b2_list_file_names.maxFileCount` cap. */
+  b2_list_file_names: 1e4,
+  /** `b2_list_file_versions.maxFileCount` cap. */
+  b2_list_file_versions: 1e4,
+  /** `b2_list_unfinished_large_files.maxFileCount` cap. */
+  b2_list_unfinished_large_files: 100,
+  /** `b2_list_keys.maxKeyCount` cap. */
+  b2_list_keys: 1e4,
+  /** `b2_list_parts.maxPartCount` cap. */
+  b2_list_parts: 1e4
+};
+function validateMaxCount(requested, endpoint) {
+  if (requested === void 0) return null;
+  if (!Number.isInteger(requested) || requested < 1) {
+    return {
+      code: "bad_request",
+      message: `maxFileCount must be a positive integer (got ${requested})`
+    };
+  }
+  const cap = LIST_ENDPOINT_CAPS[endpoint];
+  if (requested > cap) {
+    return {
+      code: "bad_request",
+      message: `maxFileCount ${requested} exceeds the ${endpoint} cap of ${cap}`
+    };
+  }
+  return null;
+}
+export {
+  BUCKET_INFO_MAX_KEYS,
+  BUCKET_INFO_VALUE_MAX,
+  BUCKET_NAME_MAX,
+  BUCKET_NAME_MIN,
+  FILE_INFO_TOTAL_MAX,
+  FILE_INFO_VALUE_MAX,
+  FILE_NAME_MAX_BYTES,
+  LIST_ENDPOINT_CAPS,
+  validateBucketInfo,
+  validateBucketName,
+  validateFileInfo,
+  validateFileName,
+  validateMaxCount
+};
+//# sourceMappingURL=validation.js.map

package/dist/simulator/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sources":["../../src/simulator/validation.ts"],"sourcesContent":["/**\n * B2 spec-compliance validation helpers for the simulator.\n *\n * Each function mirrors a documented B2 input limit (file name length,\n * bucket name regex, file-info byte budget, etc.). Validators return\n * `null` for valid input or a `{ code, message }` pair that the handler\n * converts into a synthetic `400`/`403` response with the right B2\n * error code.\n *\n * Keeping validation in one module makes the simulator's \"what does B2\n * reject?\" surface auditable in a single file. Doc references inline at\n * each rule so the spec source is immediate.\n *\n * @packageDocumentation\n */\n\nimport { utf8Encoder } from '../util/text-codec.ts'\n\n/** Shape returned by validation functions when input is rejected. */\nexport interface ValidationError {\n  readonly code: string\n  readonly message: string\n}\n\n// ---------------------------------------------------------------------------\n// Bucket name (`b2_create_bucket`, `b2_update_bucket`)\n// ---------------------------------------------------------------------------\n\n/** Minimum B2 bucket-name length per https://www.backblaze.com/apidocs/b2-create-bucket. */\nexport const BUCKET_NAME_MIN = 6\n/** Maximum B2 bucket-name length per https://www.backblaze.com/apidocs/b2-create-bucket. */\nexport const BUCKET_NAME_MAX = 63\n/** Bucket-name char set: letters, digits, hyphens. Anchored, leading/trailing hyphens are illegal. */\nconst BUCKET_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]$/\n/** Reserved prefix — B2 forbids consumer-created buckets starting with `b2-`. */\nconst BUCKET_NAME_RESERVED_PREFIX = 'b2-'\n\n/**\n * Validates a bucket name against B2's documented rules.\n *\n * @param name - Caller-supplied bucket name.\n *\n * @returns A `{ code, message }` pair on failure, or `null` when valid.\n *\n * @see https://www.backblaze.com/apidocs/b2-create-bucket\n */\nexport function validateBucketName(name: string): ValidationError | null {\n  if (typeof name !== 'string' || name.length < BUCKET_NAME_MIN || name.length > BUCKET_NAME_MAX) {\n    return {\n      code: 'invalid_bucket_name',\n      message: `bucketName must be ${BUCKET_NAME_MIN}-${BUCKET_NAME_MAX} characters`,\n    }\n  }\n  if (!BUCKET_NAME_REGEX.test(name)) {\n    return {\n      code: 'invalid_bucket_name',\n      message:\n        'bucketName must contain only letters, digits, and hyphens; cannot start or end with a hyphen',\n    }\n  }\n  if (name.startsWith(BUCKET_NAME_RESERVED_PREFIX)) {\n    return {\n      code: 'invalid_bucket_name',\n      message: `bucketName cannot start with the reserved prefix \"${BUCKET_NAME_RESERVED_PREFIX}\"`,\n    }\n  }\n  return null\n}\n\n// ---------------------------------------------------------------------------\n// File name (every upload / hide / copy entry point)\n// ---------------------------------------------------------------------------\n\n/** Max file-name length is 1024 BYTES (UTF-8 encoded), not chars. */\nexport const FILE_NAME_MAX_BYTES = 1024\n/** Control-character range B2 rejects: U+0000-U+001F (32 codepoints) plus DEL (U+007F). */\nconst FILE_NAME_DEL = 0x7f\n\n/**\n * Validates a file name against B2's documented rules. Mirrors the\n * server-side checks B2 runs on `b2_upload_file` / `b2_hide_file` /\n * `b2_start_large_file` / `b2_copy_file` filename inputs.\n *\n * @param name - Caller-supplied file name (raw, unencoded).\n *\n * @returns A `{ code, message }` pair on failure, or `null` when valid.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport function validateFileName(name: string): ValidationError | null {\n  if (typeof name !== 'string' || name.length === 0) {\n    return { code: 'invalid_file_name', message: 'fileName must be a non-empty string' }\n  }\n  const bytes = utf8Encoder.encode(name)\n  if (bytes.byteLength > FILE_NAME_MAX_BYTES) {\n    return {\n      code: 'invalid_file_name',\n      message: `fileName exceeds the 1024-byte UTF-8 limit (got ${bytes.byteLength})`,\n    }\n  }\n  for (let i = 0; i < name.length; i++) {\n    const code = name.charCodeAt(i)\n    if (code < 0x20 || code === FILE_NAME_DEL) {\n      return {\n        code: 'invalid_file_name',\n        message: 'fileName must not contain control characters (U+0000-U+001F or U+007F)',\n      }\n    }\n  }\n  // Path segments equal to `.` or `..` alone are illegal per B2 docs.\n  // Embedded `..` within a segment (e.g. `a..b`) is fine, and a path\n  // like `../foo` is fine because the SDK doesn't interpret it; only\n  // bare `.` or `..` as a complete name is rejected.\n  if (name === '.' || name === '..') {\n    return {\n      code: 'invalid_file_name',\n      message: 'fileName cannot be exactly \".\" or \"..\"',\n    }\n  }\n  // No leading or trailing slash, no `//`.\n  if (name.startsWith('/') || name.endsWith('/') || name.includes('//')) {\n    return {\n      code: 'invalid_file_name',\n      message: 'fileName cannot start with \"/\", end with \"/\", or contain \"//\"',\n    }\n  }\n  return null\n}\n\n// ---------------------------------------------------------------------------\n// File-info / Bucket-info byte budget\n// ---------------------------------------------------------------------------\n\n/** Per-file fileInfo total size cap (sum of key+value bytes). */\nexport const FILE_INFO_TOTAL_MAX = 2048\n/** Per-key fileInfo value byte cap. */\nexport const FILE_INFO_VALUE_MAX = 2048\n/** Allowed key character set (case-insensitive). */\nconst FILE_INFO_KEY_REGEX = /^[a-zA-Z0-9_-]+$/\n\n/**\n * Validates a `fileInfo` record against B2's byte-budget and\n * key-shape rules.\n *\n * @param info - Caller-supplied fileInfo record.\n *\n * @returns A `{ code, message }` pair on failure, or `null` when valid.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport function validateFileInfo(info: Record<string, string>): ValidationError | null {\n  let total = 0\n  for (const [key, value] of Object.entries(info)) {\n    if (!FILE_INFO_KEY_REGEX.test(key)) {\n      return {\n        code: 'invalid_file_info',\n        message: `fileInfo key \"${key}\" must match ^[a-zA-Z0-9_-]+$`,\n      }\n    }\n    if (typeof value !== 'string') {\n      return { code: 'invalid_file_info', message: `fileInfo value for \"${key}\" must be a string` }\n    }\n    const keyBytes = utf8Encoder.encode(key).byteLength\n    const valueBytes = utf8Encoder.encode(value).byteLength\n    if (valueBytes > FILE_INFO_VALUE_MAX) {\n      return {\n        code: 'invalid_file_info',\n        message: `fileInfo value for \"${key}\" exceeds ${FILE_INFO_VALUE_MAX} bytes`,\n      }\n    }\n    total += keyBytes + valueBytes\n  }\n  if (total > FILE_INFO_TOTAL_MAX) {\n    return {\n      code: 'invalid_file_info',\n      message: `fileInfo total size ${total} bytes exceeds the ${FILE_INFO_TOTAL_MAX}-byte limit`,\n    }\n  }\n  return null\n}\n\n/** Per-bucket bucketInfo total max keys. */\nexport const BUCKET_INFO_MAX_KEYS = 10\n/** Per-key bucketInfo value byte cap. */\nexport const BUCKET_INFO_VALUE_MAX = 2048\n/** Allowed key character set for bucketInfo. */\nconst BUCKET_INFO_KEY_REGEX = /^[a-zA-Z0-9_-]+$/\n\n/**\n * Validates a `bucketInfo` record against B2's per-bucket metadata rules.\n *\n * @param info - Caller-supplied bucketInfo record.\n *\n * @returns A `{ code, message }` pair on failure, or `null` when valid.\n *\n * @see https://www.backblaze.com/apidocs/b2-create-bucket\n */\nexport function validateBucketInfo(info: Record<string, string>): ValidationError | null {\n  const entries = Object.entries(info)\n  if (entries.length > BUCKET_INFO_MAX_KEYS) {\n    return {\n      code: 'invalid_bucket_info',\n      message: `bucketInfo cannot have more than ${BUCKET_INFO_MAX_KEYS} keys (got ${entries.length})`,\n    }\n  }\n  for (const [key, value] of entries) {\n    if (!BUCKET_INFO_KEY_REGEX.test(key)) {\n      return {\n        code: 'invalid_bucket_info',\n        message: `bucketInfo key \"${key}\" must match ^[a-zA-Z0-9_-]+$`,\n      }\n    }\n    if (typeof value !== 'string') {\n      return {\n        code: 'invalid_bucket_info',\n        message: `bucketInfo value for \"${key}\" must be a string`,\n      }\n    }\n    const valueBytes = utf8Encoder.encode(value).byteLength\n    if (valueBytes > BUCKET_INFO_VALUE_MAX) {\n      return {\n        code: 'invalid_bucket_info',\n        message: `bucketInfo value for \"${key}\" exceeds ${BUCKET_INFO_VALUE_MAX} bytes`,\n      }\n    }\n  }\n  return null\n}\n\n// ---------------------------------------------------------------------------\n// maxFileCount caps per endpoint\n// ---------------------------------------------------------------------------\n\n/**\n * Per-endpoint upper bound on the `maxFileCount` (or `maxKeyCount` /\n * `maxPartCount`) request field. Sourced from the B2 endpoint docs.\n */\nexport const LIST_ENDPOINT_CAPS = {\n  /** `b2_list_file_names.maxFileCount` cap. */\n  b2_list_file_names: 10_000,\n  /** `b2_list_file_versions.maxFileCount` cap. */\n  b2_list_file_versions: 10_000,\n  /** `b2_list_unfinished_large_files.maxFileCount` cap. */\n  b2_list_unfinished_large_files: 100,\n  /** `b2_list_keys.maxKeyCount` cap. */\n  b2_list_keys: 10_000,\n  /** `b2_list_parts.maxPartCount` cap. */\n  b2_list_parts: 10_000,\n} as const\n\n/**\n * Validates a `maxFileCount` (or `maxKeyCount` / `maxPartCount`) value\n * against the per-endpoint cap documented by B2.\n *\n * @param requested - Caller-supplied count.\n * @param endpoint - Which list endpoint this applies to.\n *\n * @returns A `{ code, message }` pair on failure, or `null` when valid.\n */\nexport function validateMaxCount(\n  requested: number | undefined,\n  endpoint: keyof typeof LIST_ENDPOINT_CAPS,\n): ValidationError | null {\n  if (requested === undefined) return null\n  if (!Number.isInteger(requested) || requested < 1) {\n    return {\n      code: 'bad_request',\n      message: `maxFileCount must be a positive integer (got ${requested})`,\n    }\n  }\n  const cap = LIST_ENDPOINT_CAPS[endpoint]\n  if (requested > cap) {\n    return {\n      code: 'bad_request',\n      message: `maxFileCount ${requested} exceeds the ${endpoint} cap of ${cap}`,\n    }\n  }\n  return null\n}\n"],"names":[],"mappings":"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"}

package/dist/streams/collect.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+async function collectStream(stream) {
+  const reader = stream.getReader();
+  try {
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+exports.collectStream = collectStream;
+//# sourceMappingURL=collect.cjs.map

package/dist/streams/collect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.cjs","sources":["../../src/streams/collect.ts"],"sourcesContent":["/**\n * Drain a `ReadableStream<Uint8Array>` into a single contiguous\n * `Uint8Array`. Releases the reader lock on both the happy and error\n * paths so the underlying stream can propagate close / error events to\n * the upstream producer.\n *\n * Used by both `createParallelDownloadStream` (per-range fetch) and\n * `StreamSource.toArrayBuffer` (whole-source materialisation). The two\n * code paths previously hand-rolled the same accumulate-then-concat\n * loop; consolidating here removes ~25 duplicated lines and a class of\n * lock-leak bugs.\n *\n * @param stream - Readable stream to consume. Will be fully drained.\n *\n * @returns A new `Uint8Array` containing every byte the stream produced.\n */\nexport async function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {\n  const reader = stream.getReader()\n  try {\n    const chunks: Uint8Array[] = []\n    let total = 0\n    while (true) {\n      const { done, value } = await reader.read()\n      if (done) break\n      chunks.push(value)\n      total += value.byteLength\n    }\n    const result = new Uint8Array(total)\n    let offset = 0\n    for (const chunk of chunks) {\n      result.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return result\n  } finally {\n    // Releasing here lets the underlying stream propagate close / error\n    // events to any upstream producer (e.g. a Node `Readable`) even on\n    // the error path where a mid-read throw left the reader locked.\n    reader.releaseLock()\n  }\n}\n"],"names":[],"mappings":";;AAgBA,eAAsB,cAAc,QAAyD;AAC3F,QAAM,SAAS,OAAO,UAAA;AACtB,MAAI;AACF,UAAM,SAAuB,CAAA;AAC7B,QAAI,QAAQ;AACZ,WAAO,MAAM;AACX,YAAM,EAAE,MAAM,MAAA,IAAU,MAAM,OAAO,KAAA;AACrC,UAAI,KAAM;AACV,aAAO,KAAK,KAAK;AACjB,eAAS,MAAM;AAAA,IACjB;AACA,UAAM,SAAS,IAAI,WAAW,KAAK;AACnC,QAAI,SAAS;AACb,eAAW,SAAS,QAAQ;AAC1B,aAAO,IAAI,OAAO,MAAM;AACxB,gBAAU,MAAM;AAAA,IAClB;AACA,WAAO;AAAA,EACT,UAAA;AAIE,WAAO,YAAA;AAAA,EACT;AACF;;"}

package/dist/streams/collect.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Drain a `ReadableStream<Uint8Array>` into a single contiguous
+ * `Uint8Array`. Releases the reader lock on both the happy and error
+ * paths so the underlying stream can propagate close / error events to
+ * the upstream producer.
+ *
+ * Used by both `createParallelDownloadStream` (per-range fetch) and
+ * `StreamSource.toArrayBuffer` (whole-source materialisation). The two
+ * code paths previously hand-rolled the same accumulate-then-concat
+ * loop; consolidating here removes ~25 duplicated lines and a class of
+ * lock-leak bugs.
+ *
+ * @param stream - Readable stream to consume. Will be fully drained.
+ *
+ * @returns A new `Uint8Array` containing every byte the stream produced.
+ */
+export declare function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+//# sourceMappingURL=collect.d.ts.map

package/dist/streams/collect.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../src/streams/collect.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAwB3F"}

package/dist/streams/collect.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Drain a `ReadableStream<Uint8Array>` into a single contiguous
+ * `Uint8Array`. Releases the reader lock on both the happy and error
+ * paths so the underlying stream can propagate close / error events to
+ * the upstream producer.
+ *
+ * Used by both `createParallelDownloadStream` (per-range fetch) and
+ * `StreamSource.toArrayBuffer` (whole-source materialisation). The two
+ * code paths previously hand-rolled the same accumulate-then-concat
+ * loop; consolidating here removes ~25 duplicated lines and a class of
+ * lock-leak bugs.
+ *
+ * @param stream - Readable stream to consume. Will be fully drained.
+ *
+ * @returns A new `Uint8Array` containing every byte the stream produced.
+ */
+export declare function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+//# sourceMappingURL=collect.d.ts.map

package/dist/streams/collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../src/streams/collect.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAwB3F"}

package/dist/streams/collect.js

@@ -0,0 +1,26 @@
+async function collectStream(stream) {
+  const reader = stream.getReader();
+  try {
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+export {
+  collectStream
+};
+//# sourceMappingURL=collect.js.map

package/dist/streams/collect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.js","sources":["../../src/streams/collect.ts"],"sourcesContent":["/**\n * Drain a `ReadableStream<Uint8Array>` into a single contiguous\n * `Uint8Array`. Releases the reader lock on both the happy and error\n * paths so the underlying stream can propagate close / error events to\n * the upstream producer.\n *\n * Used by both `createParallelDownloadStream` (per-range fetch) and\n * `StreamSource.toArrayBuffer` (whole-source materialisation). The two\n * code paths previously hand-rolled the same accumulate-then-concat\n * loop; consolidating here removes ~25 duplicated lines and a class of\n * lock-leak bugs.\n *\n * @param stream - Readable stream to consume. Will be fully drained.\n *\n * @returns A new `Uint8Array` containing every byte the stream produced.\n */\nexport async function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {\n  const reader = stream.getReader()\n  try {\n    const chunks: Uint8Array[] = []\n    let total = 0\n    while (true) {\n      const { done, value } = await reader.read()\n      if (done) break\n      chunks.push(value)\n      total += value.byteLength\n    }\n    const result = new Uint8Array(total)\n    let offset = 0\n    for (const chunk of chunks) {\n      result.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return result\n  } finally {\n    // Releasing here lets the underlying stream propagate close / error\n    // events to any upstream producer (e.g. a Node `Readable`) even on\n    // the error path where a mid-read throw left the reader locked.\n    reader.releaseLock()\n  }\n}\n"],"names":[],"mappings":"AAgBA,eAAsB,cAAc,QAAyD;AAC3F,QAAM,SAAS,OAAO,UAAA;AACtB,MAAI;AACF,UAAM,SAAuB,CAAA;AAC7B,QAAI,QAAQ;AACZ,WAAO,MAAM;AACX,YAAM,EAAE,MAAM,MAAA,IAAU,MAAM,OAAO,KAAA;AACrC,UAAI,KAAM;AACV,aAAO,KAAK,KAAK;AACjB,eAAS,MAAM;AAAA,IACjB;AACA,UAAM,SAAS,IAAI,WAAW,KAAK;AACnC,QAAI,SAAS;AACb,eAAW,SAAS,QAAQ;AAC1B,aAAO,IAAI,OAAO,MAAM;AACxB,gBAAU,MAAM;AAAA,IAClB;AACA,WAAO;AAAA,EACT,UAAA;AAIE,WAAO,YAAA;AAAA,EACT;AACF;"}

package/dist/streams/hash.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let nodeCreateHash;
+async function getNodeCreateHash() {
+  if (nodeCreateHash !== void 0) return nodeCreateHash;
+  try {
+    const crypto2 = await import("node:crypto");
+    if (typeof crypto2.createHash !== "function") throw new Error("createHash unavailable");
+    nodeCreateHash = (algo) => {
+      const h = crypto2.createHash(algo);
+      return {
+        update(data) {
+          h.update(data);
+        },
+        digest(encoding) {
+          return h.digest(encoding);
+        }
+      };
+    };
+  } catch {
+    nodeCreateHash = null;
+  }
+  return nodeCreateHash;
+}
+class IncrementalSha1 {
+  /** Buffered chunks for WebCrypto fallback path. */
+  chunks = [];
+  /** Total bytes fed into the hash so far. */
+  totalLength = 0;
+  /** Node.js hash instance, or null if using WebCrypto fallback. */
+  nodeHash = null;
+  /** Resolves once the crypto backend has been loaded. */
+  initPromise;
+  /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */
+  constructor() {
+    this.initPromise = getNodeCreateHash().then((factory) => {
+      if (factory) this.nodeHash = factory("sha1");
+    });
+  }
+  /**
+   * Feed data into the hash. Async because it lazily initializes the crypto backend.
+   * @param data - The bytes to include in the hash computation.
+   *
+   * @returns A promise that resolves once the data has been consumed.
+   */
+  async update(data) {
+    await this.initPromise;
+    if (this.nodeHash) {
+      this.nodeHash.update(data);
+    } else {
+      this.chunks.push(new Uint8Array(data));
+    }
+    this.totalLength += data.byteLength;
+  }
+  /**
+   * Finalize the hash and return the hex-encoded SHA-1 digest.
+   * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.
+   */
+  async digest() {
+    await this.initPromise;
+    if (this.nodeHash) {
+      return this.nodeHash.digest("hex");
+    }
+    const combined = new Uint8Array(this.totalLength);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const hashBuffer = await crypto.subtle.digest("SHA-1", combined.buffer);
+    return hexEncode(new Uint8Array(hashBuffer));
+  }
+  /**
+   * Total number of bytes fed into the hash so far.
+   *
+   * @returns The cumulative byte count across all update calls.
+   */
+  get bytesProcessed() {
+    return this.totalLength;
+  }
+}
+function hexEncode(bytes) {
+  const hex = [];
+  for (const b of bytes) {
+    hex.push(b.toString(16).padStart(2, "0"));
+  }
+  return hex.join("");
+}
+async function sha1Hex(data) {
+  const factory = await getNodeCreateHash();
+  if (factory) {
+    const h = factory("sha1");
+    h.update(data);
+    return h.digest("hex");
+  }
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data.buffer);
+  return hexEncode(new Uint8Array(hashBuffer));
+}
+exports.IncrementalSha1 = IncrementalSha1;
+exports.sha1Hex = sha1Hex;
+//# sourceMappingURL=hash.cjs.map

package/dist/streams/hash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.cjs","sources":["../../src/streams/hash.ts"],"sourcesContent":["/** Internal wrapper around a Node.js Hash instance. */\ntype NodeHasher = { update(data: Uint8Array): void; digest(encoding: string): string }\n\n/** Factory that creates a NodeHasher for a given algorithm name. */\ntype NodeHashFactory = (algorithm: string) => NodeHasher\n\nlet nodeCreateHash: NodeHashFactory | null | undefined\n\n/**\n * Lazily loads `node:crypto` and caches the factory. Returns null in non-Node runtimes.\n *\n * @returns The cached hash factory, or null if Node crypto is unavailable.\n */\nasync function getNodeCreateHash(): Promise<NodeHashFactory | null> {\n  if (nodeCreateHash !== undefined) return nodeCreateHash\n  try {\n    // @ts-ignore -- node:crypto may not exist in browser/edge runtimes\n    const crypto = await import('node:crypto')\n    // Vite's browser shim resolves the import but does not implement\n    // `createHash`. Probe explicitly so we fall through to the WebCrypto\n    // path instead of returning a broken factory.\n    if (typeof crypto.createHash !== 'function') throw new Error('createHash unavailable')\n    nodeCreateHash = (algo: string) => {\n      const h = crypto.createHash(algo)\n      return {\n        update(data: Uint8Array) {\n          h.update(data)\n        },\n        digest(encoding: string) {\n          return h.digest(encoding as 'hex') as string\n        },\n      }\n    }\n    /* v8 ignore next 3 -- non-Node runtime fallback, unreachable in Node tests */\n  } catch {\n    nodeCreateHash = null\n  }\n  return nodeCreateHash\n}\n\n/**\n * Incrementally computes SHA-1 hashes over streaming data.\n * Uses Node.js `crypto` when available, falling back to WebCrypto.\n */\nexport class IncrementalSha1 {\n  /** Buffered chunks for WebCrypto fallback path. */\n  private chunks: Uint8Array[] = []\n  /** Total bytes fed into the hash so far. */\n  private totalLength = 0\n  /** Node.js hash instance, or null if using WebCrypto fallback. */\n  private nodeHash: NodeHasher | null = null\n  /** Resolves once the crypto backend has been loaded. */\n  private initPromise: Promise<void>\n\n  /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */\n  constructor() {\n    this.initPromise = getNodeCreateHash().then((factory) => {\n      if (factory) this.nodeHash = factory('sha1')\n    })\n  }\n\n  /**\n   * Feed data into the hash. Async because it lazily initializes the crypto backend.\n   * @param data - The bytes to include in the hash computation.\n   *\n   * @returns A promise that resolves once the data has been consumed.\n   */\n  async update(data: Uint8Array): Promise<void> {\n    await this.initPromise\n    if (this.nodeHash) {\n      this.nodeHash.update(data)\n    } else {\n      this.chunks.push(new Uint8Array(data))\n    }\n    this.totalLength += data.byteLength\n  }\n\n  /**\n   * Finalize the hash and return the hex-encoded SHA-1 digest.\n   * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.\n   */\n  async digest(): Promise<string> {\n    await this.initPromise\n    if (this.nodeHash) {\n      return this.nodeHash.digest('hex')\n    }\n\n    /* v8 ignore start -- WebCrypto fallback path, only reachable when node:crypto is unavailable */\n    const combined = new Uint8Array(this.totalLength)\n    let offset = 0\n    for (const chunk of this.chunks) {\n      combined.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n\n    const hashBuffer = await crypto.subtle.digest('SHA-1', combined.buffer as ArrayBuffer)\n    return hexEncode(new Uint8Array(hashBuffer))\n    /* v8 ignore stop */\n  }\n\n  /**\n   * Total number of bytes fed into the hash so far.\n   *\n   * @returns The cumulative byte count across all update calls.\n   */\n  get bytesProcessed(): number {\n    return this.totalLength\n  }\n}\n\n/* v8 ignore start -- WebCrypto fallback path, only reachable when node:crypto is unavailable (browser/edge runtimes) */\n/**\n * Convert a byte array to a lowercase hex string.\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 */\nfunction hexEncode(bytes: Uint8Array): string {\n  const hex: string[] = []\n  for (const b of bytes) {\n    hex.push(b.toString(16).padStart(2, '0'))\n  }\n  return hex.join('')\n}\n/* v8 ignore stop */\n\n/**\n * Compute the SHA-1 hex digest of a complete byte array in one shot.\n * @param data - The byte array to hash.\n *\n * @returns The lowercase hex-encoded SHA-1 digest of the input.\n */\nexport async function sha1Hex(data: Uint8Array): Promise<string> {\n  const factory = await getNodeCreateHash()\n  if (factory) {\n    const h = factory('sha1')\n    h.update(data)\n    return h.digest('hex')\n  }\n  /* v8 ignore next 2 -- WebCrypto fallback, only reachable when node:crypto is unavailable */\n  const hashBuffer = await crypto.subtle.digest('SHA-1', data.buffer as ArrayBuffer)\n  return hexEncode(new Uint8Array(hashBuffer))\n}\n"],"names":["crypto"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAMA,IAAI;AAOJ,eAAe,oBAAqD;AAClE,MAAI,mBAAmB,OAAW,QAAO;AACzC,MAAI;AAEF,UAAMA,UAAS,MAAM,OAAO,aAAa;AAIzC,QAAI,OAAOA,QAAO,eAAe,WAAY,OAAM,IAAI,MAAM,wBAAwB;AACrF,qBAAiB,CAAC,SAAiB;AACjC,YAAM,IAAIA,QAAO,WAAW,IAAI;AAChC,aAAO;AAAA,QACL,OAAO,MAAkB;AACvB,YAAE,OAAO,IAAI;AAAA,QACf;AAAA,QACA,OAAO,UAAkB;AACvB,iBAAO,EAAE,OAAO,QAAiB;AAAA,QACnC;AAAA,MAAA;AAAA,IAEJ;AAAA,EAEF,QAAQ;AACN,qBAAiB;AAAA,EACnB;AACA,SAAO;AACT;AAMO,MAAM,gBAAgB;AAAA;AAAA,EAEnB,SAAuB,CAAA;AAAA;AAAA,EAEvB,cAAc;AAAA;AAAA,EAEd,WAA8B;AAAA;AAAA,EAE9B;AAAA;AAAA,EAGR,cAAc;AACZ,SAAK,cAAc,kBAAA,EAAoB,KAAK,CAAC,YAAY;AACvD,UAAI,QAAS,MAAK,WAAW,QAAQ,MAAM;AAAA,IAC7C,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,OAAO,MAAiC;AAC5C,UAAM,KAAK;AACX,QAAI,KAAK,UAAU;AACjB,WAAK,SAAS,OAAO,IAAI;AAAA,IAC3B,OAAO;AACL,WAAK,OAAO,KAAK,IAAI,WAAW,IAAI,CAAC;AAAA,IACvC;AACA,SAAK,eAAe,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAA0B;AAC9B,UAAM,KAAK;AACX,QAAI,KAAK,UAAU;AACjB,aAAO,KAAK,SAAS,OAAO,KAAK;AAAA,IACnC;AAGA,UAAM,WAAW,IAAI,WAAW,KAAK,WAAW;AAChD,QAAI,SAAS;AACb,eAAW,SAAS,KAAK,QAAQ;AAC/B,eAAS,IAAI,OAAO,MAAM;AAC1B,gBAAU,MAAM;AAAA,IAClB;AAEA,UAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,SAAS,MAAqB;AACrF,WAAO,UAAU,IAAI,WAAW,UAAU,CAAC;AAAA,EAE7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAI,iBAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AACF;AASA,SAAS,UAAU,OAA2B;AAC5C,QAAM,MAAgB,CAAA;AACtB,aAAW,KAAK,OAAO;AACrB,QAAI,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,EAC1C;AACA,SAAO,IAAI,KAAK,EAAE;AACpB;AASA,eAAsB,QAAQ,MAAmC;AAC/D,QAAM,UAAU,MAAM,kBAAA;AACtB,MAAI,SAAS;AACX,UAAM,IAAI,QAAQ,MAAM;AACxB,MAAE,OAAO,IAAI;AACb,WAAO,EAAE,OAAO,KAAK;AAAA,EACvB;AAEA,QAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,KAAK,MAAqB;AACjF,SAAO,UAAU,IAAI,WAAW,UAAU,CAAC;AAC7C;;;"}

package/dist/streams/hash.d.cts

@@ -0,0 +1,42 @@
+/**
+ * Incrementally computes SHA-1 hashes over streaming data.
+ * Uses Node.js `crypto` when available, falling back to WebCrypto.
+ */
+export declare class IncrementalSha1 {
+    /** Buffered chunks for WebCrypto fallback path. */
+    private chunks;
+    /** Total bytes fed into the hash so far. */
+    private totalLength;
+    /** Node.js hash instance, or null if using WebCrypto fallback. */
+    private nodeHash;
+    /** Resolves once the crypto backend has been loaded. */
+    private initPromise;
+    /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */
+    constructor();
+    /**
+     * Feed data into the hash. Async because it lazily initializes the crypto backend.
+     * @param data - The bytes to include in the hash computation.
+     *
+     * @returns A promise that resolves once the data has been consumed.
+     */
+    update(data: Uint8Array): Promise<void>;
+    /**
+     * Finalize the hash and return the hex-encoded SHA-1 digest.
+     * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.
+     */
+    digest(): Promise<string>;
+    /**
+     * Total number of bytes fed into the hash so far.
+     *
+     * @returns The cumulative byte count across all update calls.
+     */
+    get bytesProcessed(): number;
+}
+/**
+ * Compute the SHA-1 hex digest of a complete byte array in one shot.
+ * @param data - The byte array to hash.
+ *
+ * @returns The lowercase hex-encoded SHA-1 digest of the input.
+ */
+export declare function sha1Hex(data: Uint8Array): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/streams/hash.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/streams/hash.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,qBAAa,eAAe;IAC1B,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;IACjC,4CAA4C;IAC5C,OAAO,CAAC,WAAW,CAAI;IACvB,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAA0B;IAC1C,wDAAwD;IACxD,OAAO,CAAC,WAAW,CAAe;IAElC,+EAA+E;;IAO/E;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAU7C;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAmB/B;;;;OAIG;IACH,IAAI,cAAc,IAAI,MAAM,CAE3B;CACF;AAkBD;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAU/D"}

package/dist/streams/hash.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Incrementally computes SHA-1 hashes over streaming data.
+ * Uses Node.js `crypto` when available, falling back to WebCrypto.
+ */
+export declare class IncrementalSha1 {
+    /** Buffered chunks for WebCrypto fallback path. */
+    private chunks;
+    /** Total bytes fed into the hash so far. */
+    private totalLength;
+    /** Node.js hash instance, or null if using WebCrypto fallback. */
+    private nodeHash;
+    /** Resolves once the crypto backend has been loaded. */
+    private initPromise;
+    /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */
+    constructor();
+    /**
+     * Feed data into the hash. Async because it lazily initializes the crypto backend.
+     * @param data - The bytes to include in the hash computation.
+     *
+     * @returns A promise that resolves once the data has been consumed.
+     */
+    update(data: Uint8Array): Promise<void>;
+    /**
+     * Finalize the hash and return the hex-encoded SHA-1 digest.
+     * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.
+     */
+    digest(): Promise<string>;
+    /**
+     * Total number of bytes fed into the hash so far.
+     *
+     * @returns The cumulative byte count across all update calls.
+     */
+    get bytesProcessed(): number;
+}
+/**
+ * Compute the SHA-1 hex digest of a complete byte array in one shot.
+ * @param data - The byte array to hash.
+ *
+ * @returns The lowercase hex-encoded SHA-1 digest of the input.
+ */
+export declare function sha1Hex(data: Uint8Array): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/streams/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/streams/hash.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,qBAAa,eAAe;IAC1B,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;IACjC,4CAA4C;IAC5C,OAAO,CAAC,WAAW,CAAI;IACvB,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAA0B;IAC1C,wDAAwD;IACxD,OAAO,CAAC,WAAW,CAAe;IAElC,+EAA+E;;IAO/E;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAU7C;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAmB/B;;;;OAIG;IACH,IAAI,cAAc,IAAI,MAAM,CAE3B;CACF;AAkBD;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAU/D"}