@backblaze-labs/b2-sdk 0.2.0 → 0.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/util/normalize.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACxF,EAAE,EAAE,CAAC,GACJ,CAAC,CAEH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACjD,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;CAAE,EAC1C,IAAI,EAAE,CAAC,GAAG,CAAC,CAEZ"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/util/normalize.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACzF,EAAE,EAAE,CAAC,GACJ,CAAC,CAEH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAClD,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;CAAE,EAC1C,IAAI,EAAE,CAAC,GAAG,CAAC,CAEZ"}

package/dist/util/normalize.js

@@ -36,7 +36,7 @@ function normalizeSha1(raw) {
 * substitution was needed, so callers paying for change detection
 * (e.g. React memo) see referential stability.
 *
-* @typeParam T - Any object with a `contentSha1: string | null` field.
+* @typeParam T - Any object with a `contentSha1?: string | null` field.
 *
 * @param fv - The wire-shape file-version object.
 *
@@ -50,11 +50,11 @@ function normalizeFileVersionSha1(fv) {
 }
 /**
 * Returns a new list-response object with `normalizeFileVersionSha1`
-* applied to every entry in `files`. Used at the `b2_list_file_names` /
-* `b2_list_file_versions` boundary so list output shares the same
-* SHA-1 semantics as the singular endpoints.
+* applied to every entry in `files`. Used at file-version and unfinished
+* large-file list boundaries so list output shares the same SHA-1 semantics
+* as the singular endpoints.
 *
-* @typeParam F - Any object with a `contentSha1: string | null` field.
+* @typeParam F - Any object with a `contentSha1?: string | null` field.
 * @typeParam R - The list-response shape (must have a `files` array of `F`).
 *
 * @param resp - The wire-shape list response.

package/dist/util/normalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.js","names":[],"sources":["../../src/util/normalize.ts"],"sourcesContent":["/**\n * Wire-shape → SDK-shape normalization helpers.\n *\n * B2 occasionally uses sentinel strings on the wire where a missing\n * value would be more idiomatic in TypeScript. The biggest offender is\n * `contentSha1: 'none'` on files completed via `b2_finish_large_file`\n * (multipart-finished files don't have a whole-file SHA-1; B2 sends the\n * literal three-letter string). The SDK's `FileVersion.contentSha1` is\n * typed `string | null` to signal that absence — this module collapses\n * the wire sentinel to `null` so callers can write\n * `if (fv.contentSha1) { ... }` without an extra `=== 'none'` guard.\n *\n * Normalization happens at the RawClient boundary so every SDK consumer\n * (RawClient direct users, the high-level facade, the simulator-driven\n * tests, generated docs) sees the same `null` value.\n *\n * @packageDocumentation\n */\n\n/**\n * Collapses the B2 wire sentinel `'none'` (and `undefined`) to `null` for\n * SHA-1-shaped fields. Any other string passes through unchanged.\n *\n * @param raw - SHA-1 string from the wire, or `null`/`undefined`.\n *\n * @returns A hex SHA-1 string, or `null` when the wire said \"no hash\".\n */\nexport function normalizeSha1(raw: string | null | undefined): string | null {\n  if (raw === null || raw === undefined || raw === 'none') return null\n  return raw\n}\n\n/**\n * Returns a new file-version-shaped object with the `contentSha1: 'none'`\n * sentinel collapsed to `null`. Pass-through when the value is already\n * `null` or a real hash. The object reference is preserved if no\n * substitution was needed, so callers paying for change detection\n * (e.g. React memo) see referential stability.\n *\n * @typeParam T - Any object with a `contentSha1: string | null` field.\n *\n * @param fv - The wire-shape file-version object.\n *\n * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.\n */\nexport function normalizeFileVersionSha1<T extends { readonly contentSha1: string | null }>(\n  fv: T,\n): T {\n  return fv.contentSha1 === 'none' ? { ...fv, contentSha1: null } : fv\n}\n\n/**\n * Returns a new list-response object with `normalizeFileVersionSha1`\n * applied to every entry in `files`. Used at the `b2_list_file_names` /\n * `b2_list_file_versions` boundary so list output shares the same\n * SHA-1 semantics as the singular endpoints.\n *\n * @typeParam F - Any object with a `contentSha1: string | null` field.\n * @typeParam R - The list-response shape (must have a `files` array of `F`).\n *\n * @param resp - The wire-shape list response.\n *\n * @returns A response with normalized `files`. `resp.files` is a new array.\n */\nexport function normalizeFileVersionListSha1<\n  F extends { readonly contentSha1: string | null },\n  R extends { readonly files: readonly F[] },\n>(resp: R): R {\n  return { ...resp, files: resp.files.map(normalizeFileVersionSha1) }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,cAAc,KAA+C;CAC3E,IAAI,QAAQ,QAAQ,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO;CAChE,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,yBACd,IACG;CACH,OAAO,GAAG,gBAAgB,SAAS;EAAE,GAAG;EAAI,aAAa;CAAK,IAAI;AACpE;;;;;;;;;;;;;;AAeA,SAAgB,6BAGd,MAAY;CACZ,OAAO;EAAE,GAAG;EAAM,OAAO,KAAK,MAAM,IAAI,wBAAwB;CAAE;AACpE"}
+{"version":3,"file":"normalize.js","names":[],"sources":["../../src/util/normalize.ts"],"sourcesContent":["/**\n * Wire-shape → SDK-shape normalization helpers.\n *\n * B2 occasionally uses sentinel strings on the wire where a missing\n * value would be more idiomatic in TypeScript. The biggest offender is\n * `contentSha1: 'none'` on files completed via `b2_finish_large_file`\n * (multipart-finished files don't have a whole-file SHA-1; B2 sends the\n * literal three-letter string). The SDK's `FileVersion.contentSha1` is\n * typed `string | null` to signal that absence — this module collapses\n * the wire sentinel to `null` so callers can write\n * `if (fv.contentSha1) { ... }` without an extra `=== 'none'` guard.\n *\n * Normalization happens at the RawClient boundary so every SDK consumer\n * (RawClient direct users, the high-level facade, the simulator-driven\n * tests, generated docs) sees the same `null` value.\n *\n * @packageDocumentation\n */\n\n/**\n * Collapses the B2 wire sentinel `'none'` (and `undefined`) to `null` for\n * SHA-1-shaped fields. Any other string passes through unchanged.\n *\n * @param raw - SHA-1 string from the wire, or `null`/`undefined`.\n *\n * @returns A hex SHA-1 string, or `null` when the wire said \"no hash\".\n */\nexport function normalizeSha1(raw: string | null | undefined): string | null {\n  if (raw === null || raw === undefined || raw === 'none') return null\n  return raw\n}\n\n/**\n * Returns a new file-version-shaped object with the `contentSha1: 'none'`\n * sentinel collapsed to `null`. Pass-through when the value is already\n * `null` or a real hash. The object reference is preserved if no\n * substitution was needed, so callers paying for change detection\n * (e.g. React memo) see referential stability.\n *\n * @typeParam T - Any object with a `contentSha1?: string | null` field.\n *\n * @param fv - The wire-shape file-version object.\n *\n * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.\n */\nexport function normalizeFileVersionSha1<T extends { readonly contentSha1?: string | null }>(\n  fv: T,\n): T {\n  return fv.contentSha1 === 'none' ? { ...fv, contentSha1: null } : fv\n}\n\n/**\n * Returns a new list-response object with `normalizeFileVersionSha1`\n * applied to every entry in `files`. Used at file-version and unfinished\n * large-file list boundaries so list output shares the same SHA-1 semantics\n * as the singular endpoints.\n *\n * @typeParam F - Any object with a `contentSha1?: string | null` field.\n * @typeParam R - The list-response shape (must have a `files` array of `F`).\n *\n * @param resp - The wire-shape list response.\n *\n * @returns A response with normalized `files`. `resp.files` is a new array.\n */\nexport function normalizeFileVersionListSha1<\n  F extends { readonly contentSha1?: string | null },\n  R extends { readonly files: readonly F[] },\n>(resp: R): R {\n  return { ...resp, files: resp.files.map(normalizeFileVersionSha1) }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,cAAc,KAA+C;CAC3E,IAAI,QAAQ,QAAQ,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO;CAChE,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,yBACd,IACG;CACH,OAAO,GAAG,gBAAgB,SAAS;EAAE,GAAG;EAAI,aAAa;CAAK,IAAI;AACpE;;;;;;;;;;;;;;AAeA,SAAgB,6BAGd,MAAY;CACZ,OAAO;EAAE,GAAG;EAAM,OAAO,KAAK,MAAM,IAAI,wBAAwB;CAAE;AACpE"}

package/dist/util/paginator.cjs

@@ -1,7 +1,12 @@
 //#region src/util/paginator.ts
+function isPrimitiveCursor(cursor) {
+	return cursor === null || typeof cursor !== "object" && typeof cursor !== "function";
+}
 /**
 * Async-iterates one page at a time. Stops when `fetcher` returns
-* `nextCursor: undefined`.
+* `nextCursor: undefined` or a primitive cursor that is identical to the
+* cursor just used, which prevents non-advancing server cursors from looping
+* forever.
 *
 * @typeParam Page - The per-page response shape.
 * @typeParam Cursor - The cursor type used to request the next page.
@@ -33,6 +38,7 @@ async function* paginatePages(fetcher, signal) {
 		const { page, nextCursor } = await fetcher(cursor);
 		yield page;
 		if (nextCursor === void 0) return;
+		if (cursor !== void 0 && isPrimitiveCursor(cursor) && isPrimitiveCursor(nextCursor) && Object.is(nextCursor, cursor)) return;
 		cursor = nextCursor;
 	}
 }

package/dist/util/paginator.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"paginator.cjs","names":[],"sources":["../../src/util/paginator.ts"],"sourcesContent":["/**\n * Generic pagination helpers for B2 list endpoints.\n *\n * B2 returns paginated results as `{ items, nextCursor }` shapes that differ\n * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,\n * `nextApplicationKeyId`, etc.). These helpers let callers iterate without\n * threading the cursor by hand.\n *\n * Two flavours:\n *   - {@link paginatePages} yields each page as the server returned it.\n *     Useful when the caller wants the per-page response object (e.g. for\n *     access to per-page metadata or to control item-iteration order).\n *   - {@link paginateItems} flattens pages and yields individual items.\n *     Useful for the common \"iterate everything\" case.\n *\n * Both helpers honour an optional {@link AbortSignal} that aborts the\n * iteration **between fetches**. They do NOT abort an in-flight network\n * request: the underlying list call has its own `signal` parameter and\n * each consumer must wire that through if mid-flight cancellation is\n * required.\n *\n * @packageDocumentation\n *\n * @example\n * ```ts\n * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {\n *   console.log(file.fileName, file.contentLength)\n * }\n * ```\n *\n */\n\n/**\n * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.\n */\nexport interface PaginatorOptions {\n  /**\n   * Maximum items per page. Forwarded to the underlying list call's\n   * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this\n   * at endpoint-specific limits (typically 10000 for files, 100 for parts).\n   */\n  pageSize?: number\n  /**\n   * Aborts the iteration between fetches. When already aborted at call time,\n   * the iterator throws immediately on its first `next()` call.\n   *\n   * Note: this does NOT abort an in-flight HTTP request mid-page. The\n   * iterator checks `signal.throwIfAborted()` only between fetches.\n   */\n  signal?: AbortSignal\n}\n\n/**\n * Function that fetches a single page given a cursor.\n *\n * The cursor is `undefined` for the first page, then takes the value of the\n * previous page's `nextCursor` on subsequent calls. Iteration stops when\n * `nextCursor` is `undefined` (or any other falsy value the caller maps to\n * `undefined`).\n *\n * @typeParam Page - The per-page response shape returned by the B2 endpoint.\n * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).\n */\nexport type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{\n  /** The page just fetched. */\n  page: Page\n  /** Cursor for the next page, or `undefined` if there are no more pages. */\n  nextCursor: Cursor | undefined\n}>\n\n/**\n * Async-iterates one page at a time. Stops when `fetcher` returns\n * `nextCursor: undefined`.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of pages.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n *\n * @example\n * ```ts\n * for await (const page of paginatePages(\n *   async (cursor) => {\n *     const resp = await bucket.listFileNames({ startFileName: cursor })\n *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }\n *   },\n *   abortSignal,\n * )) {\n *   for (const file of page.files) { ... }\n * }\n * ```\n */\nexport async function* paginatePages<Page, Cursor>(\n  fetcher: PageFetcher<Page, Cursor>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Page> {\n  let cursor: Cursor | undefined\n  while (true) {\n    signal?.throwIfAborted()\n    const { page, nextCursor } = await fetcher(cursor)\n    yield page\n    if (nextCursor === undefined) return\n    cursor = nextCursor\n  }\n}\n\n/**\n * Async-iterates items by flattening pages. The `extractItems` function\n * pulls the relevant array out of each page (e.g. `page.files`,\n * `page.keys`, `page.parts`). Each item is yielded individually so the\n * caller can `for await (const item of paginator)` rather than nest loops.\n *\n * Aborts between **pages**, not between items: if `signal` is aborted while\n * the caller is processing the items of page N, the iterator will still\n * yield all of page N's remaining items before checking the signal before\n * fetching page N+1.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n * @typeParam Item - The item type the caller wants to iterate.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param extractItems - Pulls the iterable items out of a page.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of individual items.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n */\nexport async function* paginateItems<Page, Cursor, Item>(\n  fetcher: PageFetcher<Page, Cursor>,\n  extractItems: (page: Page) => Iterable<Item>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Item> {\n  for await (const page of paginatePages(fetcher, signal)) {\n    yield* extractItems(page)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,gBAAuB,cACrB,SACA,QAC6B;CAC7B,IAAI;CACJ,OAAO,MAAM;EACX,QAAQ,eAAe;EACvB,MAAM,EAAE,MAAM,eAAe,MAAM,QAAQ,MAAM;EACjD,MAAM;EACN,IAAI,eAAe,KAAA,GAAW;EAC9B,SAAS;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,gBAAuB,cACrB,SACA,cACA,QAC6B;CAC7B,WAAW,MAAM,QAAQ,cAAc,SAAS,MAAM,GACpD,OAAO,aAAa,IAAI;AAE5B"}
+{"version":3,"file":"paginator.cjs","names":[],"sources":["../../src/util/paginator.ts"],"sourcesContent":["/**\n * Generic pagination helpers for B2 list endpoints.\n *\n * B2 returns paginated results as `{ items, nextCursor }` shapes that differ\n * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,\n * `nextApplicationKeyId`, etc.). These helpers let callers iterate without\n * threading the cursor by hand.\n *\n * Two flavours:\n *   - {@link paginatePages} yields each page as the server returned it.\n *     Useful when the caller wants the per-page response object (e.g. for\n *     access to per-page metadata or to control item-iteration order).\n *   - {@link paginateItems} flattens pages and yields individual items.\n *     Useful for the common \"iterate everything\" case.\n *\n * Both helpers honour an optional {@link AbortSignal} that aborts the\n * iteration **between fetches**. They do NOT abort an in-flight network\n * request: the underlying list call has its own `signal` parameter and\n * each consumer must wire that through if mid-flight cancellation is\n * required.\n *\n * @packageDocumentation\n *\n * @example\n * ```ts\n * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {\n *   console.log(file.fileName, file.contentLength)\n * }\n * ```\n *\n */\n\n/**\n * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.\n */\nexport interface PaginatorOptions {\n  /**\n   * Maximum items per page. Forwarded to the underlying list call's\n   * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this\n   * at endpoint-specific limits (typically 10000 for files, 100 for parts).\n   */\n  pageSize?: number\n  /**\n   * Aborts the iteration between fetches. When already aborted at call time,\n   * the iterator throws immediately on its first `next()` call.\n   *\n   * Note: this does NOT abort an in-flight HTTP request mid-page. The\n   * iterator checks `signal.throwIfAborted()` only between fetches.\n   */\n  signal?: AbortSignal\n}\n\n/**\n * Function that fetches a single page given a cursor.\n *\n * The cursor is `undefined` for the first page, then takes the value of the\n * previous page's `nextCursor` on subsequent calls. Iteration stops when\n * `nextCursor` is `undefined` (or any other falsy value the caller maps to\n * `undefined`).\n *\n * @typeParam Page - The per-page response shape returned by the B2 endpoint.\n * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).\n */\nexport type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{\n  /** The page just fetched. */\n  page: Page\n  /** Cursor for the next page, or `undefined` if there are no more pages. */\n  nextCursor: Cursor | undefined\n}>\n\nfunction isPrimitiveCursor(cursor: unknown): boolean {\n  return cursor === null || (typeof cursor !== 'object' && typeof cursor !== 'function')\n}\n\n/**\n * Async-iterates one page at a time. Stops when `fetcher` returns\n * `nextCursor: undefined` or a primitive cursor that is identical to the\n * cursor just used, which prevents non-advancing server cursors from looping\n * forever.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of pages.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n *\n * @example\n * ```ts\n * for await (const page of paginatePages(\n *   async (cursor) => {\n *     const resp = await bucket.listFileNames({ startFileName: cursor })\n *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }\n *   },\n *   abortSignal,\n * )) {\n *   for (const file of page.files) { ... }\n * }\n * ```\n */\nexport async function* paginatePages<Page, Cursor>(\n  fetcher: PageFetcher<Page, Cursor>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Page> {\n  let cursor: Cursor | undefined\n  while (true) {\n    signal?.throwIfAborted()\n    const { page, nextCursor } = await fetcher(cursor)\n    yield page\n    if (nextCursor === undefined) return\n    if (\n      cursor !== undefined &&\n      isPrimitiveCursor(cursor) &&\n      isPrimitiveCursor(nextCursor) &&\n      Object.is(nextCursor, cursor)\n    ) {\n      return\n    }\n    cursor = nextCursor\n  }\n}\n\n/**\n * Async-iterates items by flattening pages. The `extractItems` function\n * pulls the relevant array out of each page (e.g. `page.files`,\n * `page.keys`, `page.parts`). Each item is yielded individually so the\n * caller can `for await (const item of paginator)` rather than nest loops.\n *\n * Aborts between **pages**, not between items: if `signal` is aborted while\n * the caller is processing the items of page N, the iterator will still\n * yield all of page N's remaining items before checking the signal before\n * fetching page N+1.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n * @typeParam Item - The item type the caller wants to iterate.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param extractItems - Pulls the iterable items out of a page.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of individual items.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n */\nexport async function* paginateItems<Page, Cursor, Item>(\n  fetcher: PageFetcher<Page, Cursor>,\n  extractItems: (page: Page) => Iterable<Item>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Item> {\n  for await (const page of paginatePages(fetcher, signal)) {\n    yield* extractItems(page)\n  }\n}\n"],"mappings":";AAsEA,SAAS,kBAAkB,QAA0B;CACnD,OAAO,WAAW,QAAS,OAAO,WAAW,YAAY,OAAO,WAAW;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,gBAAuB,cACrB,SACA,QAC6B;CAC7B,IAAI;CACJ,OAAO,MAAM;EACX,QAAQ,eAAe;EACvB,MAAM,EAAE,MAAM,eAAe,MAAM,QAAQ,MAAM;EACjD,MAAM;EACN,IAAI,eAAe,KAAA,GAAW;EAC9B,IACE,WAAW,KAAA,KACX,kBAAkB,MAAM,KACxB,kBAAkB,UAAU,KAC5B,OAAO,GAAG,YAAY,MAAM,GAE5B;EAEF,SAAS;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,gBAAuB,cACrB,SACA,cACA,QAC6B;CAC7B,WAAW,MAAM,QAAQ,cAAc,SAAS,MAAM,GACpD,OAAO,aAAa,IAAI;AAE5B"}

package/dist/util/paginator.d.cts

@@ -67,7 +67,9 @@ export type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<
 }>;
 /**
  * Async-iterates one page at a time. Stops when `fetcher` returns
- * `nextCursor: undefined`.
+ * `nextCursor: undefined` or a primitive cursor that is identical to the
+ * cursor just used, which prevents non-advancing server cursors from looping
+ * forever.
  *
  * @typeParam Page - The per-page response shape.
  * @typeParam Cursor - The cursor type used to request the next page.

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

@@ -1 +1 @@
-{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAS7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAiB7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}

package/dist/util/paginator.d.ts

@@ -67,7 +67,9 @@ export type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<
 }>;
 /**
  * Async-iterates one page at a time. Stops when `fetcher` returns
- * `nextCursor: undefined`.
+ * `nextCursor: undefined` or a primitive cursor that is identical to the
+ * cursor just used, which prevents non-advancing server cursors from looping
+ * forever.
  *
  * @typeParam Page - The per-page response shape.
  * @typeParam Cursor - The cursor type used to request the next page.

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

@@ -1 +1 @@
-{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAS7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAiB7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}

package/dist/util/paginator.js

@@ -1,7 +1,12 @@
 //#region src/util/paginator.ts
+function isPrimitiveCursor(cursor) {
+	return cursor === null || typeof cursor !== "object" && typeof cursor !== "function";
+}
 /**
 * Async-iterates one page at a time. Stops when `fetcher` returns
-* `nextCursor: undefined`.
+* `nextCursor: undefined` or a primitive cursor that is identical to the
+* cursor just used, which prevents non-advancing server cursors from looping
+* forever.
 *
 * @typeParam Page - The per-page response shape.
 * @typeParam Cursor - The cursor type used to request the next page.
@@ -33,6 +38,7 @@ async function* paginatePages(fetcher, signal) {
 		const { page, nextCursor } = await fetcher(cursor);
 		yield page;
 		if (nextCursor === void 0) return;
+		if (cursor !== void 0 && isPrimitiveCursor(cursor) && isPrimitiveCursor(nextCursor) && Object.is(nextCursor, cursor)) return;
 		cursor = nextCursor;
 	}
 }

package/dist/util/paginator.js.map

@@ -1 +1 @@
-{"version":3,"file":"paginator.js","names":[],"sources":["../../src/util/paginator.ts"],"sourcesContent":["/**\n * Generic pagination helpers for B2 list endpoints.\n *\n * B2 returns paginated results as `{ items, nextCursor }` shapes that differ\n * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,\n * `nextApplicationKeyId`, etc.). These helpers let callers iterate without\n * threading the cursor by hand.\n *\n * Two flavours:\n *   - {@link paginatePages} yields each page as the server returned it.\n *     Useful when the caller wants the per-page response object (e.g. for\n *     access to per-page metadata or to control item-iteration order).\n *   - {@link paginateItems} flattens pages and yields individual items.\n *     Useful for the common \"iterate everything\" case.\n *\n * Both helpers honour an optional {@link AbortSignal} that aborts the\n * iteration **between fetches**. They do NOT abort an in-flight network\n * request: the underlying list call has its own `signal` parameter and\n * each consumer must wire that through if mid-flight cancellation is\n * required.\n *\n * @packageDocumentation\n *\n * @example\n * ```ts\n * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {\n *   console.log(file.fileName, file.contentLength)\n * }\n * ```\n *\n */\n\n/**\n * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.\n */\nexport interface PaginatorOptions {\n  /**\n   * Maximum items per page. Forwarded to the underlying list call's\n   * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this\n   * at endpoint-specific limits (typically 10000 for files, 100 for parts).\n   */\n  pageSize?: number\n  /**\n   * Aborts the iteration between fetches. When already aborted at call time,\n   * the iterator throws immediately on its first `next()` call.\n   *\n   * Note: this does NOT abort an in-flight HTTP request mid-page. The\n   * iterator checks `signal.throwIfAborted()` only between fetches.\n   */\n  signal?: AbortSignal\n}\n\n/**\n * Function that fetches a single page given a cursor.\n *\n * The cursor is `undefined` for the first page, then takes the value of the\n * previous page's `nextCursor` on subsequent calls. Iteration stops when\n * `nextCursor` is `undefined` (or any other falsy value the caller maps to\n * `undefined`).\n *\n * @typeParam Page - The per-page response shape returned by the B2 endpoint.\n * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).\n */\nexport type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{\n  /** The page just fetched. */\n  page: Page\n  /** Cursor for the next page, or `undefined` if there are no more pages. */\n  nextCursor: Cursor | undefined\n}>\n\n/**\n * Async-iterates one page at a time. Stops when `fetcher` returns\n * `nextCursor: undefined`.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of pages.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n *\n * @example\n * ```ts\n * for await (const page of paginatePages(\n *   async (cursor) => {\n *     const resp = await bucket.listFileNames({ startFileName: cursor })\n *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }\n *   },\n *   abortSignal,\n * )) {\n *   for (const file of page.files) { ... }\n * }\n * ```\n */\nexport async function* paginatePages<Page, Cursor>(\n  fetcher: PageFetcher<Page, Cursor>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Page> {\n  let cursor: Cursor | undefined\n  while (true) {\n    signal?.throwIfAborted()\n    const { page, nextCursor } = await fetcher(cursor)\n    yield page\n    if (nextCursor === undefined) return\n    cursor = nextCursor\n  }\n}\n\n/**\n * Async-iterates items by flattening pages. The `extractItems` function\n * pulls the relevant array out of each page (e.g. `page.files`,\n * `page.keys`, `page.parts`). Each item is yielded individually so the\n * caller can `for await (const item of paginator)` rather than nest loops.\n *\n * Aborts between **pages**, not between items: if `signal` is aborted while\n * the caller is processing the items of page N, the iterator will still\n * yield all of page N's remaining items before checking the signal before\n * fetching page N+1.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n * @typeParam Item - The item type the caller wants to iterate.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param extractItems - Pulls the iterable items out of a page.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of individual items.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n */\nexport async function* paginateItems<Page, Cursor, Item>(\n  fetcher: PageFetcher<Page, Cursor>,\n  extractItems: (page: Page) => Iterable<Item>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Item> {\n  for await (const page of paginatePages(fetcher, signal)) {\n    yield* extractItems(page)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,gBAAuB,cACrB,SACA,QAC6B;CAC7B,IAAI;CACJ,OAAO,MAAM;EACX,QAAQ,eAAe;EACvB,MAAM,EAAE,MAAM,eAAe,MAAM,QAAQ,MAAM;EACjD,MAAM;EACN,IAAI,eAAe,KAAA,GAAW;EAC9B,SAAS;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,gBAAuB,cACrB,SACA,cACA,QAC6B;CAC7B,WAAW,MAAM,QAAQ,cAAc,SAAS,MAAM,GACpD,OAAO,aAAa,IAAI;AAE5B"}
+{"version":3,"file":"paginator.js","names":[],"sources":["../../src/util/paginator.ts"],"sourcesContent":["/**\n * Generic pagination helpers for B2 list endpoints.\n *\n * B2 returns paginated results as `{ items, nextCursor }` shapes that differ\n * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,\n * `nextApplicationKeyId`, etc.). These helpers let callers iterate without\n * threading the cursor by hand.\n *\n * Two flavours:\n *   - {@link paginatePages} yields each page as the server returned it.\n *     Useful when the caller wants the per-page response object (e.g. for\n *     access to per-page metadata or to control item-iteration order).\n *   - {@link paginateItems} flattens pages and yields individual items.\n *     Useful for the common \"iterate everything\" case.\n *\n * Both helpers honour an optional {@link AbortSignal} that aborts the\n * iteration **between fetches**. They do NOT abort an in-flight network\n * request: the underlying list call has its own `signal` parameter and\n * each consumer must wire that through if mid-flight cancellation is\n * required.\n *\n * @packageDocumentation\n *\n * @example\n * ```ts\n * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {\n *   console.log(file.fileName, file.contentLength)\n * }\n * ```\n *\n */\n\n/**\n * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.\n */\nexport interface PaginatorOptions {\n  /**\n   * Maximum items per page. Forwarded to the underlying list call's\n   * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this\n   * at endpoint-specific limits (typically 10000 for files, 100 for parts).\n   */\n  pageSize?: number\n  /**\n   * Aborts the iteration between fetches. When already aborted at call time,\n   * the iterator throws immediately on its first `next()` call.\n   *\n   * Note: this does NOT abort an in-flight HTTP request mid-page. The\n   * iterator checks `signal.throwIfAborted()` only between fetches.\n   */\n  signal?: AbortSignal\n}\n\n/**\n * Function that fetches a single page given a cursor.\n *\n * The cursor is `undefined` for the first page, then takes the value of the\n * previous page's `nextCursor` on subsequent calls. Iteration stops when\n * `nextCursor` is `undefined` (or any other falsy value the caller maps to\n * `undefined`).\n *\n * @typeParam Page - The per-page response shape returned by the B2 endpoint.\n * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).\n */\nexport type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{\n  /** The page just fetched. */\n  page: Page\n  /** Cursor for the next page, or `undefined` if there are no more pages. */\n  nextCursor: Cursor | undefined\n}>\n\nfunction isPrimitiveCursor(cursor: unknown): boolean {\n  return cursor === null || (typeof cursor !== 'object' && typeof cursor !== 'function')\n}\n\n/**\n * Async-iterates one page at a time. Stops when `fetcher` returns\n * `nextCursor: undefined` or a primitive cursor that is identical to the\n * cursor just used, which prevents non-advancing server cursors from looping\n * forever.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of pages.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n *\n * @example\n * ```ts\n * for await (const page of paginatePages(\n *   async (cursor) => {\n *     const resp = await bucket.listFileNames({ startFileName: cursor })\n *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }\n *   },\n *   abortSignal,\n * )) {\n *   for (const file of page.files) { ... }\n * }\n * ```\n */\nexport async function* paginatePages<Page, Cursor>(\n  fetcher: PageFetcher<Page, Cursor>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Page> {\n  let cursor: Cursor | undefined\n  while (true) {\n    signal?.throwIfAborted()\n    const { page, nextCursor } = await fetcher(cursor)\n    yield page\n    if (nextCursor === undefined) return\n    if (\n      cursor !== undefined &&\n      isPrimitiveCursor(cursor) &&\n      isPrimitiveCursor(nextCursor) &&\n      Object.is(nextCursor, cursor)\n    ) {\n      return\n    }\n    cursor = nextCursor\n  }\n}\n\n/**\n * Async-iterates items by flattening pages. The `extractItems` function\n * pulls the relevant array out of each page (e.g. `page.files`,\n * `page.keys`, `page.parts`). Each item is yielded individually so the\n * caller can `for await (const item of paginator)` rather than nest loops.\n *\n * Aborts between **pages**, not between items: if `signal` is aborted while\n * the caller is processing the items of page N, the iterator will still\n * yield all of page N's remaining items before checking the signal before\n * fetching page N+1.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n * @typeParam Item - The item type the caller wants to iterate.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param extractItems - Pulls the iterable items out of a page.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of individual items.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n */\nexport async function* paginateItems<Page, Cursor, Item>(\n  fetcher: PageFetcher<Page, Cursor>,\n  extractItems: (page: Page) => Iterable<Item>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Item> {\n  for await (const page of paginatePages(fetcher, signal)) {\n    yield* extractItems(page)\n  }\n}\n"],"mappings":";AAsEA,SAAS,kBAAkB,QAA0B;CACnD,OAAO,WAAW,QAAS,OAAO,WAAW,YAAY,OAAO,WAAW;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,gBAAuB,cACrB,SACA,QAC6B;CAC7B,IAAI;CACJ,OAAO,MAAM;EACX,QAAQ,eAAe;EACvB,MAAM,EAAE,MAAM,eAAe,MAAM,QAAQ,MAAM;EACjD,MAAM;EACN,IAAI,eAAe,KAAA,GAAW;EAC9B,IACE,WAAW,KAAA,KACX,kBAAkB,MAAM,KACxB,kBAAkB,UAAU,KAC5B,OAAO,GAAG,YAAY,MAAM,GAE5B;EAEF,SAAS;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,gBAAuB,cACrB,SACA,cACA,QAC6B;CAC7B,WAAW,MAAM,QAAQ,cAAc,SAAS,MAAM,GACpD,OAAO,aAAa,IAAI;AAE5B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backblaze-labs/b2-sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The official Backblaze B2 Cloud Storage SDK for TypeScript and JavaScript",
   "license": "MIT",
   "type": "module",
@@ -59,6 +59,26 @@
         "default": "./dist/auth/file.cjs"
       }
     },
+    "./partner": {
+      "import": {
+        "types": "./dist/partner/index.d.ts",
+        "default": "./dist/partner/index.js"
+      },
+      "require": {
+        "types": "./dist/partner/index.d.cts",
+        "default": "./dist/partner/index.cjs"
+      }
+    },
+    "./backup": {
+      "import": {
+        "types": "./dist/backup/index.d.ts",
+        "default": "./dist/backup/index.js"
+      },
+      "require": {
+        "types": "./dist/backup/index.d.cts",
+        "default": "./dist/backup/index.cjs"
+      }
+    },
     "./streams": {
       "import": {
         "types": "./dist/streams/index.d.ts",
@@ -120,24 +140,24 @@
     "CHANGELOG.md"
   ],
   "devDependencies": {
-    "@biomejs/biome": "^2.5.1",
+    "@biomejs/biome": "^2.5.8",
     "@eslint/js": "^10.0.1",
     "@microsoft/tsdoc-config": "^0.18.1",
-    "@types/node": "^26.0.0",
-    "@vitest/browser": "^4.1.9",
-    "@vitest/browser-playwright": "^4.1.9",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@types/node": "^26.2.0",
+    "@vitest/browser": "^4.1.10",
+    "@vitest/browser-playwright": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.10",
     "cspell": "^10.0.1",
-    "eslint": "^10.6.0",
-    "eslint-plugin-jsdoc": "^63.0.10",
+    "eslint": "^10.8.1",
+    "eslint-plugin-jsdoc": "^64.2.0",
     "eslint-plugin-tsdoc": "^0.5.2",
-    "playwright": "^1.61.1",
-    "typedoc": "^0.28.19",
+    "playwright": "^1.62.1",
+    "typedoc": "^0.28.20",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.0",
-    "vite": "^8.1.0",
+    "typescript-eslint": "^8.67.0",
+    "vite": "^8.2.1",
     "vite-plugin-dts": "^5.0.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "@aws-sdk/client-s3": "^3.0.0"
@@ -161,7 +181,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/backblaze-labs/b2-sdk-typescript"
+    "url": "git+https://github.com/backblaze-labs/b2-sdk-typescript.git"
   },
   "author": "Backblaze, Inc.",
   "homepage": "https://github.com/backblaze-labs/b2-sdk-typescript#readme",
@@ -185,17 +205,19 @@
     "lint:fix": "biome check --write .",
     "lint:docs": "eslint src/ --no-warn-ignored",
     "lint:docs:fix": "eslint src/ --fix --no-warn-ignored",
-    "lint:spelling": "cspell --no-progress --gitignore \"src/**/*.ts\" \"examples/**/*.ts\" \"examples/**/*.md\" \"*.md\" \"CLAUDE.md\"",
+    "lint:spelling": "cspell --no-progress --gitignore \"src/**/*.ts\" \"examples/**/*.ts\" \"examples/**/*.md\" \"adr/**/*.md\" \"*.md\" \"CLAUDE.md\"",
     "typecheck": "tsc --noEmit",
     "typecheck:examples": "tsc --noEmit -p examples/tsconfig.json",
     "docs": "typedoc",
     "docs:watch": "typedoc --watch",
     "clean": "rm -rf dist docs",
     "version": "node scripts/cut-changelog.mjs && git add CHANGELOG.md",
-    "verify:metadata": "node scripts/verify-package-metadata.mjs",
+    "verify:metadata": "node --test scripts/verify-package-metadata.test.mjs && node scripts/verify-package-metadata.mjs",
     "verify:release": "node scripts/verify-release-workflow.mjs",
     "verify:exports": "node scripts/verify-package-exports.mjs",
     "verify:release-workflow": "node scripts/verify-release-workflow.mjs",
+    "smoke:published": "node scripts/smoke-published-package.mjs",
+    "test:smoke-published": "node --test scripts/smoke-published-package.test.mjs",
     "verify": "pnpm run lint && pnpm run lint:docs && pnpm run lint:spelling && pnpm run typecheck && pnpm run typecheck:examples && pnpm run test && pnpm run build && pnpm run docs && pnpm run verify:metadata && pnpm run verify:release && pnpm run verify:exports"
   }
 }