@atproto/lex-client 0.0.10 → 0.0.12

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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","sourcesContent":["import { LexError, LexErrorCode, LexErrorData } from '@atproto/lex-data'\nimport { l } from '@atproto/lex-schema'\nimport { XrpcPayload } from './util.js'\n\nexport { LexError }\nexport type { LexErrorCode, LexErrorData }\n\nexport type XrpcErrorPayload<N extends LexErrorCode = LexErrorCode> =\n  XrpcPayload<LexErrorData<N>, 'application/json'>\n\nexport class XrpcError<\n  N extends LexErrorCode = LexErrorCode,\n> extends LexError<N> {\n  name = 'XrpcError'\n\n  constructor(\n    error: N,\n    message: string = `${error} Lexicon RPC error`,\n    options?: ErrorOptions,\n  ) {\n    super(error, message, options)\n  }\n}\n\n/**\n * All unsuccessful responses should follow a standard error response\n * schema. The Content-Type should be application/json, and the payload\n * should be a JSON object with the following fields:\n *\n * - `error` (string, required): type name of the error (generic ASCII\n *   constant, no whitespace)\n * - `message` (string, optional): description of the error, appropriate for\n *   display to humans\n *\n * This function checks whether a given payload matches this schema.\n */\nexport function isXrpcErrorPayload(\n  payload: XrpcPayload | null,\n): payload is XrpcErrorPayload {\n  return (\n    payload !== null &&\n    payload.encoding === 'application/json' &&\n    l.lexErrorData.matches(payload.body)\n  )\n}\n\n/**\n * Interface representing a failed XRPC request result.\n */\ntype LexRpcFailureResult<N extends LexErrorCode, E> = l.ResultFailure<E> & {\n  readonly error: N\n  shouldRetry(): boolean\n  matchesSchema(): boolean\n}\n\n/**\n * Class used to represent an HTTP request that resulted in an XRPC method error\n * That is, a non-2xx response with a valid XRPC error payload.\n */\nexport class XrpcResponseError<\n    M extends l.Procedure | l.Query = l.Procedure | l.Query,\n    N extends LexErrorCode = LexErrorCode,\n  >\n  extends XrpcError<N>\n  implements LexRpcFailureResult<N, XrpcResponseError<M, N>>\n{\n  name = 'XrpcResponseError'\n\n  constructor(\n    readonly method: M,\n    readonly status: number,\n    readonly headers: Headers,\n    readonly payload: XrpcErrorPayload<N>,\n    options?: ErrorOptions,\n  ) {\n    const { error, message } = payload.body\n    super(error, message, options)\n  }\n\n  readonly success = false\n\n  get reason(): this {\n    return this as this\n  }\n\n  get body(): LexErrorData {\n    return this.payload.body\n  }\n\n  matchesSchema(): this is M extends {\n    errors: readonly (infer E extends string)[]\n  }\n    ? XrpcResponseError<M, E>\n    : never {\n    return this.method.errors?.includes(this.error) ?? false\n  }\n\n  shouldRetry(): boolean {\n    // Do not retry client errors\n    if (this.status < 500) return false\n\n    return true\n  }\n\n  toJSON() {\n    return this.payload.body\n  }\n\n  toResponse(): Response {\n    const { status, headers } = this\n    return Response.json(this.toJSON(), { status, headers })\n  }\n}\n\n/**\n * This class represents an invalid XRPC response from the server.\n */\nexport class XrpcUpstreamError<\n    N extends 'InvalidResponse' | 'UpstreamFailure' =\n      | 'InvalidResponse'\n      | 'UpstreamFailure',\n  >\n  extends XrpcError<N>\n  implements LexRpcFailureResult<N, XrpcUpstreamError<N>>\n{\n  name = 'XrpcUpstreamError' as const\n\n  // For debugging purposes, we keep the response details here\n  readonly response: {\n    status: number\n    headers: Headers\n    payload: XrpcPayload | null\n  }\n\n  constructor(\n    error: N,\n    message: string,\n    response: { status: number; headers: Headers },\n    payload: XrpcPayload | null,\n    options?: ErrorOptions,\n  ) {\n    super(error, message, { cause: options?.cause })\n    this.response = {\n      status: response.status,\n      headers: response.headers,\n      payload,\n    }\n  }\n\n  readonly success = false as const\n\n  get reason(): this {\n    return this\n  }\n\n  matchesSchema(): false {\n    return false\n  }\n\n  shouldRetry(): boolean {\n    // Do not retry client errors\n    return this.response.status >= 500\n  }\n\n  toResponse(): Response {\n    return Response.json(this.toJSON(), { status: 502 })\n  }\n}\n\nexport class XrpcUnexpectedError\n  extends XrpcError<'InternalServerError'>\n  implements LexRpcFailureResult<'InternalServerError', unknown>\n{\n  name = 'XrpcUnexpectedError' as const\n\n  protected constructor(message: string, options: Required<ErrorOptions>) {\n    super('InternalServerError', message, options)\n  }\n\n  readonly success = false\n\n  get reason() {\n    return this.cause\n  }\n\n  matchesSchema(): false {\n    return false\n  }\n\n  shouldRetry(): boolean {\n    return true\n  }\n\n  toResponse(): Response {\n    return Response.json(this.toJSON(), { status: 500 })\n  }\n\n  static from(\n    cause: unknown,\n    message: string = cause instanceof LexError\n      ? cause.message\n      : 'XRPC request failed',\n  ): XrpcUnexpectedError {\n    if (cause instanceof XrpcUnexpectedError) return cause\n    return new XrpcUnexpectedError(message, { cause })\n  }\n}\n"]}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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","sourcesContent":["import { LexError, LexErrorCode, LexErrorData } from '@atproto/lex-data'\nimport {\n  InferMethodError,\n  Procedure,\n  Query,\n  ResultFailure,\n  lexErrorDataSchema,\n} from '@atproto/lex-schema'\nimport { XrpcResponsePayload } from './util.js'\nimport {\n  WWWAuthenticate,\n  parseWWWAuthenticateHeader,\n} from './www-authenticate.js'\n\n/**\n * HTTP status codes that indicate a transient error that may succeed on retry.\n *\n * Includes:\n * - 408 Request Timeout\n * - 425 Too Early\n * - 429 Too Many Requests (rate limited)\n * - 500 Internal Server Error\n * - 502 Bad Gateway\n * - 503 Service Unavailable\n * - 504 Gateway Timeout\n * - 522 Connection Timed Out (Cloudflare)\n * - 524 A Timeout Occurred (Cloudflare)\n */\nexport const RETRYABLE_HTTP_STATUS_CODES: ReadonlySet<number> = new Set([\n  408, 425, 429, 500, 502, 503, 504, 522, 524,\n])\n\nexport { LexError }\nexport type { LexErrorCode, LexErrorData }\n\n/**\n * The payload structure for XRPC error responses.\n *\n * All XRPC errors return JSON with an `error` code and optional `message`.\n *\n * @typeParam N - The specific error code type\n */\nexport type XrpcErrorPayload<N extends LexErrorCode = LexErrorCode> = {\n  body: LexErrorData<N>\n  encoding: 'application/json'\n}\n\n/**\n * All unsuccessful responses should follow a standard error response\n * schema. The Content-Type should be application/json, and the payload\n * should be a JSON object with the following fields:\n *\n * - `error` (string, required): type name of the error (generic ASCII\n *   constant, no whitespace)\n * - `message` (string, optional): description of the error, appropriate for\n *   display to humans\n *\n * This function checks whether a given payload matches this schema.\n */\nexport function isXrpcErrorPayload(\n  payload: XrpcResponsePayload | null | undefined,\n): payload is XrpcErrorPayload {\n  return (\n    payload != null &&\n    payload.encoding === 'application/json' &&\n    lexErrorDataSchema.matches(payload.body)\n  )\n}\n\n/**\n * Abstract base class for all XRPC errors.\n *\n * Extends {@link LexError} and implements {@link ResultFailure} for use with\n * safe/result-based error handling patterns.\n *\n * @typeParam M - The XRPC method type (Procedure or Query)\n * @typeParam N - The error code type\n * @typeParam TReason - The reason type for ResultFailure\n *\n * @see {@link XrpcResponseError} - For valid XRPC error responses\n * @see {@link XrpcUpstreamError} - For invalid/unexpected responses\n * @see {@link XrpcInternalError} - For network/internal errors\n */\nexport abstract class XrpcError<\n    M extends Procedure | Query = Procedure | Query,\n    N extends LexErrorCode = LexErrorCode,\n    TReason = unknown,\n  >\n  extends LexError<N>\n  implements ResultFailure<TReason>\n{\n  name = 'XrpcError'\n\n  constructor(\n    readonly method: M,\n    error: N,\n    message: string = `${error} Lexicon RPC error`,\n    options?: ErrorOptions,\n  ) {\n    super(error, message, options)\n  }\n\n  /**\n   * @see {@link ResultFailure.success}\n   */\n  readonly success = false as const\n\n  /**\n   * @see {@link ResultFailure.reason}\n   */\n  abstract readonly reason: TReason\n\n  /**\n   * Indicates whether the error is transient and can be retried.\n   */\n  abstract shouldRetry(): boolean\n\n  matchesSchema(): this is XrpcError<M, InferMethodError<M>> {\n    return this.method.errors?.includes(this.error) ?? false\n  }\n}\n\n/**\n * Error class for valid XRPC error responses from the server.\n *\n * This represents a properly formatted XRPC error where the server returned\n * a non-2xx status with a valid JSON error payload containing `error` and\n * optional `message` fields.\n *\n * Use {@link matchesSchema} to check if the error matches the method's declared\n * error types for type-safe error handling.\n *\n * @typeParam M - The XRPC method type\n * @typeParam N - The error code type (inferred from method or generic)\n *\n * @example Handling specific errors\n * ```typescript\n * try {\n *   await client.xrpc(someMethod, options)\n * } catch (err) {\n *   if (err instanceof XrpcResponseError && err.error === 'RecordNotFound') {\n *     // Handle not found case\n *   }\n * }\n * ```\n */\nexport class XrpcResponseError<\n  M extends Procedure | Query = Procedure | Query,\n  N extends LexErrorCode = InferMethodError<M> | LexErrorCode,\n> extends XrpcError<M, N, XrpcResponseError<M, N>> {\n  name = 'XrpcResponseError'\n\n  constructor(\n    method: M,\n    readonly response: Response,\n    readonly payload: XrpcErrorPayload<N>,\n    options?: ErrorOptions,\n  ) {\n    const { error, message } = payload.body\n    super(method, error, message, options)\n  }\n\n  override get reason(): this {\n    return this\n  }\n\n  override shouldRetry(): boolean {\n    return RETRYABLE_HTTP_STATUS_CODES.has(this.response.status)\n  }\n\n  override toJSON() {\n    return this.payload.body\n  }\n\n  override toResponse(): Response {\n    // Re-expose schema-valid errors as-is to downstream clients\n    if (this.matchesSchema()) {\n      const status = this.response.status >= 500 ? 502 : this.response.status\n      return Response.json(this.toJSON(), { status })\n    }\n\n    return this.response.status >= 500\n      ? // The upstream server had an error, return a generic upstream failure\n        Response.json({ error: 'UpstreamFailure' }, { status: 502 })\n      : // If the error is on our side, return a generic internal server error\n        Response.json({ error: 'InternalServerError' }, { status: 500 })\n  }\n\n  get body(): LexErrorData {\n    return this.payload.body\n  }\n}\n\nexport type { WWWAuthenticate }\n\n/**\n * Error class for 401 Unauthorized XRPC responses.\n *\n * Extends {@link XrpcResponseError} with access to parsed WWW-Authenticate header\n * information, useful for implementing authentication flows.\n *\n * Authentication errors are never retryable as they require user intervention\n * (e.g., re-authentication, token refresh).\n *\n * @typeParam M - The XRPC method type\n * @typeParam N - The error code type\n *\n * @example Handling authentication errors\n * ```typescript\n * try {\n *   await client.xrpc(someMethod, options)\n * } catch (err) {\n *   if (err instanceof XrpcAuthenticationError) {\n *     const { DPoP } = err.wwwAuthenticate\n *     if (DPoP?.error === 'use_dpop_nonce') {\n *       // Handle DPoP nonce requirement\n *     }\n *   }\n * }\n * ```\n */\nexport class XrpcAuthenticationError<\n  M extends Procedure | Query = Procedure | Query,\n  N extends LexErrorCode = LexErrorCode,\n> extends XrpcResponseError<M, N> {\n  name = 'XrpcAuthenticationError'\n\n  override shouldRetry(): boolean {\n    return false\n  }\n\n  #wwwAuthenticateCached?: WWWAuthenticate\n  /**\n   * Parsed WWW-Authenticate header from the response.\n   * Contains authentication scheme parameters (e.g., Bearer realm, DPoP nonce).\n   */\n  get wwwAuthenticate(): WWWAuthenticate {\n    return (this.#wwwAuthenticateCached ??=\n      parseWWWAuthenticateHeader(\n        this.response.headers.get('www-authenticate'),\n      ) ?? {})\n  }\n}\n\n/**\n * Error class for invalid or unprocessable XRPC responses from upstream servers.\n *\n * This occurs when the server returns a response that doesn't conform to the\n * XRPC protocol, such as:\n * - Missing or invalid Content-Type header\n * - Response body that doesn't match the method's output schema\n * - Non-JSON error responses\n * - Responses from non-XRPC endpoints\n *\n * The error code is always 'UpstreamFailure' and maps to HTTP 502 Bad Gateway\n * when converted to a response.\n *\n * @typeParam M - The XRPC method type\n */\nexport class XrpcUpstreamError<\n  M extends Procedure | Query = Procedure | Query,\n> extends XrpcError<M, 'UpstreamFailure', XrpcUpstreamError<M>> {\n  name = 'XrpcUpstreamError'\n\n  constructor(\n    method: M,\n    readonly response: Response,\n    readonly payload: XrpcResponsePayload | null = null,\n    message: string = `Unexpected upstream XRPC response`,\n    options?: ErrorOptions,\n  ) {\n    super(method, 'UpstreamFailure', message, options)\n  }\n\n  override get reason(): this {\n    return this\n  }\n\n  override shouldRetry(): boolean {\n    return RETRYABLE_HTTP_STATUS_CODES.has(this.response.status)\n  }\n\n  override toResponse(): Response {\n    return Response.json(this.toJSON(), { status: 502 })\n  }\n}\n\n/**\n * Error class for internal/client-side errors during XRPC requests.\n *\n * This represents errors that occur before or during the request that are not\n * server responses, such as:\n * - Network errors (connection refused, DNS failure)\n * - Request timeouts\n * - Request aborted via AbortSignal\n * - Invalid request construction\n *\n * The error code is always 'InternalServerError' and these errors are\n * optimistically considered retryable.\n *\n * @typeParam M - The XRPC method type\n */\nexport class XrpcInternalError<\n  M extends Procedure | Query = Procedure | Query,\n> extends XrpcError<M, 'InternalServerError', XrpcInternalError<M>> {\n  name = 'XrpcInternalError'\n\n  constructor(method: M, message?: string, options?: ErrorOptions) {\n    super(\n      method,\n      'InternalServerError',\n      message ?? 'Unable to fulfill XRPC request',\n      options,\n    )\n  }\n\n  override get reason(): this {\n    return this\n  }\n\n  override shouldRetry(): true {\n    // Ideally, we would inspect the reason to determine if it's retryable\n    // (by detecting network errors, timeouts, etc.). Since these cases are\n    // highly platform-dependent, we optimistically assume all internal\n    // errors are retryable.\n    return true\n  }\n\n  override toResponse(): Response {\n    // Do not expose internal error details to downstream clients\n    return Response.json({ error: this.error }, { status: 500 })\n  }\n}\n\n/**\n * Union type of all possible XRPC failure types.\n *\n * Used as the return type for safe/non-throwing XRPC methods. Check the\n * `success` property to distinguish between success and failure:\n *\n * @typeParam M - The XRPC method type\n *\n * @example\n * ```typescript\n * const result = await client.xrpcSafe(someMethod, options)\n * if (result.success) {\n *   console.log(result.body) // XrpcResponse\n * } else {\n *   // result is XrpcFailure (XrpcResponseError | XrpcUpstreamError | XrpcInternalError)\n *   console.error(result.error, result.message)\n * }\n * ```\n */\nexport type XrpcFailure<M extends Procedure | Query = Procedure | Query> =\n  // The server returned a valid XRPC error response\n  | XrpcResponseError<M>\n  // The response was not a valid XRPC response, or it does not match the schema\n  | XrpcUpstreamError<M>\n  // Something went wrong (network error, etc.)\n  | XrpcInternalError<M>\n\n/**\n * Converts an unknown error into an appropriate {@link XrpcFailure} type.\n *\n * If the error is already an XrpcFailure for the given method, returns it as-is.\n * Otherwise, wraps it in an {@link XrpcInternalError}.\n *\n * @param method - The XRPC method that was called\n * @param cause - The error to convert\n * @returns An XrpcFailure instance\n *\n * @example\n * ```typescript\n * try {\n *   const response = await fetch(...)\n *   // ... process response\n * } catch (err) {\n *   return asXrpcFailure(method, err)\n * }\n * ```\n */\nexport function asXrpcFailure<M extends Procedure | Query>(\n  method: M,\n  cause: unknown,\n): XrpcFailure<M> {\n  if (\n    cause instanceof XrpcResponseError ||\n    cause instanceof XrpcUpstreamError ||\n    cause instanceof XrpcInternalError\n  ) {\n    if (cause.method === method) return cause\n  }\n\n  return new XrpcInternalError(method, undefined, { cause })\n}\n"]}

package/dist/lexicons/com/atproto/repo/createRecord.defs.d.ts

@@ -4,30 +4,30 @@ declare const $nsid = "com.atproto.repo.createRecord";
 export { $nsid };
 /** Create a single new repository record. Requires auth, implemented by PDS. */
 declare const main: l.Procedure<"com.atproto.repo.createRecord", l.ParamsSchema<{}>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.OptionalSchema<l.StringSchema<{
+    rkey: l.OptionalSchema<l.StringSchema<{
         readonly format: "record-key";
         readonly maxLength: 512;
     }>>;
-    readonly validate: l.OptionalSchema<l.BooleanSchema>;
-    readonly record: l.UnknownObjectSchema;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    validate: l.OptionalSchema<l.BooleanSchema>;
+    record: l.UnknownObjectSchema;
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.StringSchema<{
+    cid: l.StringSchema<{
         readonly format: "cid";
     }>;
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
-    readonly validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
 }>>, readonly ["InvalidSwap"]>;
 export { main };
 export type Params = l.InferMethodParams<typeof main>;
@@ -36,29 +36,29 @@ export type InputBody = l.InferMethodInputBody<typeof main>;
 export type Output = l.InferMethodOutput<typeof main>;
 export type OutputBody = l.InferMethodOutputBody<typeof main>;
 export declare const $lxm: "com.atproto.repo.createRecord", $params: l.ParamsSchema<{}>, $input: l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.OptionalSchema<l.StringSchema<{
+    rkey: l.OptionalSchema<l.StringSchema<{
         readonly format: "record-key";
         readonly maxLength: 512;
     }>>;
-    readonly validate: l.OptionalSchema<l.BooleanSchema>;
-    readonly record: l.UnknownObjectSchema;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    validate: l.OptionalSchema<l.BooleanSchema>;
+    record: l.UnknownObjectSchema;
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.StringSchema<{
+    cid: l.StringSchema<{
         readonly format: "cid";
     }>;
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
-    readonly validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
 }>>;
 //# sourceMappingURL=createRecord.defs.d.ts.map

package/dist/lexicons/com/atproto/repo/deleteRecord.defs.d.ts

@@ -4,23 +4,23 @@ declare const $nsid = "com.atproto.repo.deleteRecord";
 export { $nsid };
 /** Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS. */
 declare const main: l.Procedure<"com.atproto.repo.deleteRecord", l.ParamsSchema<{}>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.StringSchema<{
+    rkey: l.StringSchema<{
         readonly format: "record-key";
     }>;
-    readonly swapRecord: l.OptionalSchema<l.StringSchema<{
+    swapRecord: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
 }>>, readonly ["InvalidSwap"]>;
 export { main };
 export type Params = l.InferMethodParams<typeof main>;
@@ -29,22 +29,22 @@ export type InputBody = l.InferMethodInputBody<typeof main>;
 export type Output = l.InferMethodOutput<typeof main>;
 export type OutputBody = l.InferMethodOutputBody<typeof main>;
 export declare const $lxm: "com.atproto.repo.deleteRecord", $params: l.ParamsSchema<{}>, $input: l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.StringSchema<{
+    rkey: l.StringSchema<{
         readonly format: "record-key";
     }>;
-    readonly swapRecord: l.OptionalSchema<l.StringSchema<{
+    swapRecord: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
 }>>;
 //# sourceMappingURL=deleteRecord.defs.d.ts.map

package/dist/lexicons/com/atproto/repo/getRecord.defs.d.ts

@@ -16,13 +16,13 @@ declare const main: l.Query<"com.atproto.repo.getRecord", l.ParamsSchema<{
         readonly format: "cid";
     }>>;
 }>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.OptionalSchema<l.StringSchema<{
+    cid: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
-    readonly value: l.UnknownObjectSchema;
+    value: l.UnknownObjectSchema;
 }>>, readonly ["RecordNotFound"]>;
 export { main };
 export type Params = l.InferMethodParams<typeof main>;
@@ -42,12 +42,12 @@ export declare const $lxm: "com.atproto.repo.getRecord", $params: l.ParamsSchema
         readonly format: "cid";
     }>>;
 }>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.OptionalSchema<l.StringSchema<{
+    cid: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
-    readonly value: l.UnknownObjectSchema;
+    value: l.UnknownObjectSchema;
 }>>;
 //# sourceMappingURL=getRecord.defs.d.ts.map

package/dist/lexicons/com/atproto/repo/listRecords.defs.d.ts

@@ -10,11 +10,11 @@ declare const main: l.Query<"com.atproto.repo.listRecords", l.ParamsSchema<{
         readonly format: "nsid";
     }>;
     readonly limit: l.OptionalSchema<l.WithDefaultSchema<l.IntegerSchema>>;
-    readonly cursor: l.OptionalSchema<l.StringSchema<{}>>;
+    readonly cursor: l.OptionalSchema<l.StringSchema<l.StringSchemaOptions>>;
     readonly reverse: l.OptionalSchema<l.BooleanSchema>;
 }>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly cursor: l.OptionalSchema<l.StringSchema<{}>>;
-    readonly records: l.ArraySchema<l.RefSchema<l.Validator<Record$0, Record$0>>>;
+    cursor: l.OptionalSchema<l.StringSchema<{}>>;
+    records: l.ArraySchema<l.RefSchema<l.Validator<Record$0, Record$0>>>;
 }>>, undefined>;
 export { main };
 export type Params = l.InferMethodParams<typeof main>;
@@ -28,11 +28,11 @@ export declare const $lxm: "com.atproto.repo.listRecords", $params: l.ParamsSche
         readonly format: "nsid";
     }>;
     readonly limit: l.OptionalSchema<l.WithDefaultSchema<l.IntegerSchema>>;
-    readonly cursor: l.OptionalSchema<l.StringSchema<{}>>;
+    readonly cursor: l.OptionalSchema<l.StringSchema<l.StringSchemaOptions>>;
     readonly reverse: l.OptionalSchema<l.BooleanSchema>;
 }>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly cursor: l.OptionalSchema<l.StringSchema<{}>>;
-    readonly records: l.ArraySchema<l.RefSchema<l.Validator<Record$0, Record$0>>>;
+    cursor: l.OptionalSchema<l.StringSchema<{}>>;
+    records: l.ArraySchema<l.RefSchema<l.Validator<Record$0, Record$0>>>;
 }>>;
 type Record$0 = {
     $type?: 'com.atproto.repo.listRecords#record';

package/dist/lexicons/com/atproto/repo/putRecord.defs.d.ts

@@ -4,33 +4,33 @@ declare const $nsid = "com.atproto.repo.putRecord";
 export { $nsid };
 /** Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS. */
 declare const main: l.Procedure<"com.atproto.repo.putRecord", l.ParamsSchema<{}>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.StringSchema<{
+    rkey: l.StringSchema<{
         readonly format: "record-key";
         readonly maxLength: 512;
     }>;
-    readonly validate: l.OptionalSchema<l.BooleanSchema>;
-    readonly record: l.UnknownObjectSchema;
-    readonly swapRecord: l.OptionalSchema<l.NullableSchema<l.StringSchema<{
+    validate: l.OptionalSchema<l.BooleanSchema>;
+    record: l.UnknownObjectSchema;
+    swapRecord: l.OptionalSchema<l.NullableSchema<l.StringSchema<{
         readonly format: "cid";
     }>>>;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.StringSchema<{
+    cid: l.StringSchema<{
         readonly format: "cid";
     }>;
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
-    readonly validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
 }>>, readonly ["InvalidSwap"]>;
 export { main };
 export type Params = l.InferMethodParams<typeof main>;
@@ -39,32 +39,32 @@ export type InputBody = l.InferMethodInputBody<typeof main>;
 export type Output = l.InferMethodOutput<typeof main>;
 export type OutputBody = l.InferMethodOutputBody<typeof main>;
 export declare const $lxm: "com.atproto.repo.putRecord", $params: l.ParamsSchema<{}>, $input: l.Payload<"application/json", l.ObjectSchema<{
-    readonly repo: l.StringSchema<{
+    repo: l.StringSchema<{
         readonly format: "at-identifier";
     }>;
-    readonly collection: l.StringSchema<{
+    collection: l.StringSchema<{
         readonly format: "nsid";
     }>;
-    readonly rkey: l.StringSchema<{
+    rkey: l.StringSchema<{
         readonly format: "record-key";
         readonly maxLength: 512;
     }>;
-    readonly validate: l.OptionalSchema<l.BooleanSchema>;
-    readonly record: l.UnknownObjectSchema;
-    readonly swapRecord: l.OptionalSchema<l.NullableSchema<l.StringSchema<{
+    validate: l.OptionalSchema<l.BooleanSchema>;
+    record: l.UnknownObjectSchema;
+    swapRecord: l.OptionalSchema<l.NullableSchema<l.StringSchema<{
         readonly format: "cid";
     }>>>;
-    readonly swapCommit: l.OptionalSchema<l.StringSchema<{
+    swapCommit: l.OptionalSchema<l.StringSchema<{
         readonly format: "cid";
     }>>;
 }>>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly uri: l.StringSchema<{
+    uri: l.StringSchema<{
         readonly format: "at-uri";
     }>;
-    readonly cid: l.StringSchema<{
+    cid: l.StringSchema<{
         readonly format: "cid";
     }>;
-    readonly commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
-    readonly validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
+    commit: l.OptionalSchema<l.RefSchema<l.Validator<RepoDefs.CommitMeta, RepoDefs.CommitMeta>>>;
+    validationStatus: l.OptionalSchema<l.StringSchema<{}>>;
 }>>;
 //# sourceMappingURL=putRecord.defs.d.ts.map

package/dist/lexicons/com/atproto/repo/uploadBlob.defs.d.ts

@@ -3,7 +3,7 @@ declare const $nsid = "com.atproto.repo.uploadBlob";
 export { $nsid };
 /** Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS. */
 declare const main: l.Procedure<"com.atproto.repo.uploadBlob", l.ParamsSchema<{}>, l.Payload<"*/*", undefined>, l.Payload<"application/json", l.ObjectSchema<{
-    readonly blob: l.BlobSchema<{
+    blob: l.BlobSchema<{
         allowLegacy: false;
     }>;
 }>>, undefined>;
@@ -14,7 +14,7 @@ export type InputBody = l.InferMethodInputBody<typeof main>;
 export type Output = l.InferMethodOutput<typeof main>;
 export type OutputBody = l.InferMethodOutputBody<typeof main>;
 export declare const $lxm: "com.atproto.repo.uploadBlob", $params: l.ParamsSchema<{}>, $input: l.Payload<"*/*", undefined>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    readonly blob: l.BlobSchema<{
+    blob: l.BlobSchema<{
         allowLegacy: false;
     }>;
 }>>;

package/dist/response.d.ts

@@ -1,13 +1,12 @@
-import { InferMethodOutputBody, InferMethodOutputEncoding, Procedure, Query, ResultSuccess } from '@atproto/lex-schema';
-import { XrpcPayload } from './util.js';
-export type XrpcResponseBody<M extends Procedure | Query> = InferMethodOutputBody<M, Uint8Array>;
-export type XrpcResponsePayload<M extends Procedure | Query> = InferMethodOutputEncoding<M> extends infer E extends string ? XrpcPayload<XrpcResponseBody<M>, E> : null;
+import { InferMethodOutputEncoding, Procedure, Query, ResultSuccess } from '@atproto/lex-schema';
+import { XrpcResponseBody, XrpcResponsePayload } from './util.js';
+export type { XrpcResponseBody, XrpcResponsePayload };
 /**
  * Small container for XRPC response data.
  *
  * @implements {ResultSuccess<XrpcResponse<M>>} for convenience in result handling contexts.
  */
-export declare class XrpcResponse<const M extends Procedure | Query> implements ResultSuccess<XrpcResponse<M>> {
+export declare class XrpcResponse<M extends Procedure | Query> implements ResultSuccess<XrpcResponse<M>> {
     readonly method: M;
     readonly status: number;
     readonly headers: Headers;
@@ -22,12 +21,24 @@ export declare class XrpcResponse<const M extends Procedure | Query> implements
      * in binary form {@link Uint8Array} (`false`).
      */
     get isParsed(): boolean;
+    /**
+     * The Content-Type encoding of the response (e.g., 'application/json').
+     * Returns `undefined` if the response has no body.
+     */
     get encoding(): InferMethodOutputEncoding<M>;
+    /**
+     * The parsed response body.
+     *
+     * For 'application/json' responses, this is the parsed and validated LexValue.
+     * For binary responses, this is a Uint8Array.
+     * Returns `undefined` if the response has no body.
+     */
     get body(): XrpcResponseBody<M>;
     /**
      * @throws {XrpcResponseError} in case of (valid) XRPC error responses. Use
      * {@link XrpcResponseError.matchesSchema} to narrow the error type based on
-     * the method's declared error schema.
+     * the method's declared error schema. This can be narrowed further as a
+     * {@link XrpcAuthenticationError} if the error is an authentication error.
      * @throws {XrpcUpstreamError} when the response is not a valid XRPC
      * response, or if the response does not conform to the method's schema.
      */

package/dist/response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,SAAS,EACT,KAAK,EACL,aAAa,EACd,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,IACtD,qBAAqB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;AAEtC,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,IACzD,yBAAyB,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,MAAM,GACvD,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GACnC,IAAI,CAAA;AAEV;;;;GAIG;AACH,qBAAa,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,CACzD,YAAW,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAWvC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO;IACzB,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAZ1C,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAG,IAAI,CAAS;IAEhC,uCAAuC;IACvC,IAAI,KAAK,IAAI,IAAI,CAEhB;gBAGU,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAG1C;;;OAGG;IACH,IAAI,QAAQ,YAEX;IAED,IAAI,QAAQ,IACuB,yBAAyB,CAAC,CAAC,CAAC,CAC9D;IAED,IAAI,IAAI,IACuB,gBAAgB,CAAC,CAAC,CAAC,CACjD;IAED;;;;;;OAMG;WACU,iBAAiB,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,EAC9D,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CA0F5B"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"AACA,OAAO,EACL,yBAAyB,EACzB,SAAS,EACT,KAAK,EACL,aAAa,EACd,MAAM,qBAAqB,CAAA;AAO5B,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAKjE,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,CAAA;AAErD;;;;GAIG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,CACnD,YAAW,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAWvC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO;IACzB,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAZ1C,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAG,IAAI,CAAS;IAEhC,uCAAuC;IACvC,IAAI,KAAK,IAAI,IAAI,CAEhB;gBAGU,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAG1C;;;OAGG;IACH,IAAI,QAAQ,YAEX;IAED;;;OAGG;IACH,IAAI,QAAQ,IACuB,yBAAyB,CAAC,CAAC,CAAC,CAC9D;IAED;;;;;;OAMG;IACH,IAAI,IAAI,IACuB,gBAAgB,CAAC,CAAC,CAAC,CACjD;IAED;;;;;;;OAOG;WACU,iBAAiB,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,EAC9D,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAoG5B"}

package/dist/response.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XrpcResponse = void 0;
 const lex_json_1 = require("@atproto/lex-json");
 const errors_js_1 = require("./errors.js");
+const CONTENT_TYPE_BINARY = 'application/octet-stream';
+const CONTENT_TYPE_JSON = 'application/json';
 /**
  * Small container for XRPC response data.
  *
@@ -30,18 +32,30 @@ class XrpcResponse {
      * in binary form {@link Uint8Array} (`false`).
      */
     get isParsed() {
-        return this.encoding === 'application/json' && shouldParse(this.method);
+        return this.method.output.encoding === CONTENT_TYPE_JSON;
     }
+    /**
+     * The Content-Type encoding of the response (e.g., 'application/json').
+     * Returns `undefined` if the response has no body.
+     */
     get encoding() {
         return this.payload?.encoding;
     }
+    /**
+     * The parsed response body.
+     *
+     * For 'application/json' responses, this is the parsed and validated LexValue.
+     * For binary responses, this is a Uint8Array.
+     * Returns `undefined` if the response has no body.
+     */
     get body() {
         return this.payload?.body;
     }
     /**
      * @throws {XrpcResponseError} in case of (valid) XRPC error responses. Use
      * {@link XrpcResponseError.matchesSchema} to narrow the error type based on
-     * the method's declared error schema.
+     * the method's declared error schema. This can be narrowed further as a
+     * {@link XrpcAuthenticationError} if the error is an authentication error.
      * @throws {XrpcUpstreamError} when the response is not a valid XRPC
      * response, or if the response does not conform to the method's schema.
      */
@@ -52,40 +66,47 @@ class XrpcResponse {
         // @NOTE redirect is set to 'follow', so we shouldn't get 3xx responses here
         if (response.status < 200 || response.status >= 300) {
             // Always parse json for error responses
-            const payload = await readPayload(response, { parse: true });
+            const payload = await readPayload(response, { parse: true }).catch((cause) => {
+                throw new errors_js_1.XrpcUpstreamError(method, response, null, 'Unable to parse response payload', { cause });
+            });
+            // Properly formatted XRPC error response ?
             if (response.status >= 400 && (0, errors_js_1.isXrpcErrorPayload)(payload)) {
-                throw new errors_js_1.XrpcResponseError(method, response.status, response.headers, payload);
+                throw response.status === 401
+                    ? new errors_js_1.XrpcAuthenticationError(method, response, payload)
+                    : new errors_js_1.XrpcResponseError(method, response, payload);
             }
-            if (response.status >= 500) {
-                throw new errors_js_1.XrpcUpstreamError('UpstreamFailure', `Upstream server encountered an error`, response, payload);
-            }
-            throw new errors_js_1.XrpcUpstreamError('InvalidResponse', response.status >= 400
-                ? `Upstream server returned an invalid response payload`
-                : `Upstream server returned an invalid status code`, response, payload);
+            // Invalid XRPC response (we probably did not hit an XRPC implementation)
+            throw new errors_js_1.XrpcUpstreamError(method, response, payload, response.status >= 500
+                ? 'Upstream server encountered an error'
+                : response.status >= 400
+                    ? 'Invalid response payload'
+                    : 'Invalid response status code');
         }
         // Only parse json if the schema expects it
         const payload = await readPayload(response, {
-            parse: shouldParse(method),
+            parse: method.output.encoding === CONTENT_TYPE_JSON,
+        }).catch((cause) => {
+            throw new errors_js_1.XrpcUpstreamError(method, response, null, 'Unable to parse response payload', { cause });
         });
         // Response is successful (2xx). Validate payload (data and encoding) against schema.
         if (method.output.encoding == null) {
             // Schema expects no payload
             if (payload) {
-                throw new errors_js_1.XrpcUpstreamError('InvalidResponse', `Expected response with no body, got ${payload.encoding}`, response, payload);
+                throw new errors_js_1.XrpcUpstreamError(method, response, payload, `Expected response with no body, got ${payload.encoding}`);
             }
         }
         else {
             // Schema expects a payload
             if (!payload || !method.output.matchesEncoding(payload.encoding)) {
-                throw new errors_js_1.XrpcUpstreamError('InvalidResponse', payload
+                throw new errors_js_1.XrpcUpstreamError(method, response, payload, payload
                     ? `Expected ${method.output.encoding} response, got ${payload.encoding}`
-                    : `Expected non-empty response with content-type ${method.output.encoding}`, response, payload);
+                    : `Expected non-empty response with content-type ${method.output.encoding}`);
             }
             // Assert valid response body.
             if (method.output.schema && options?.validateResponse !== false) {
                 const result = method.output.schema.safeParse(payload.body);
                 if (!result.success) {
-                    throw new errors_js_1.XrpcUpstreamError('InvalidResponse', `Response validation failed: ${result.reason.message}`, response, payload, { cause: result.reason });
+                    throw new errors_js_1.XrpcUpstreamError(method, response, payload, `Response validation failed: ${result.reason.message}`, { cause: result.reason });
                 }
             }
         }
@@ -93,9 +114,6 @@ class XrpcResponse {
     }
 }
 exports.XrpcResponse = XrpcResponse;
-function shouldParse(method) {
-    return method.output.encoding === 'application/json';
-}
 /**
  * @note this function always consumes the response body
  */
@@ -109,33 +127,28 @@ async function readPayload(response, options) {
         .toLowerCase();
     // Response content-type is undefined
     if (!encoding) {
-        // If the body is empty, return null (= no payload)
+        // If the body is empty, return undefined (= no payload)
         const body = await response.arrayBuffer();
         if (body.byteLength === 0)
-            return null;
+            return undefined;
         // If we got data despite no content-type, treat it as binary
         return {
-            encoding: 'application/octet-stream',
+            encoding: CONTENT_TYPE_BINARY,
             body: new Uint8Array(body),
         };
     }
-    if (options?.parse && encoding === 'application/json') {
+    if (options?.parse && encoding === CONTENT_TYPE_JSON) {
         // @NOTE It might be worth returning the raw bytes here (Uint8Array) and
         // perform the lex parsing using cborg/json, allowing to do
         // bytes->LexValue in one step instead of bytes->text->JSON->LexValue.
         // This would require adding encode/decode utilities to lex-json (similar
         // to @ipld/dag-json)
         const text = await response.text();
-        try {
-            // @NOTE Using `lexParse(text)` (instead of `jsonToLex(json)`) here as
-            // using a reviver function during JSON.parse should be faster than
-            // parsing to JSON then converting to Lex (?)
-            // @TODO verify statement above
-            return { encoding, body: (0, lex_json_1.lexParse)(text) };
-        }
-        catch (cause) {
-            throw new errors_js_1.XrpcUpstreamError('InvalidResponse', 'Invalid JSON response body', response, null, { cause });
-        }
+        // @NOTE Using `lexParse(text)` (instead of `jsonToLex(json)`) here as
+        // using a reviver function during JSON.parse should be faster than
+        // parsing to JSON then converting to Lex (?)
+        // @TODO verify statement above
+        return { encoding, body: (0, lex_json_1.lexParse)(text) };
     }
     return { encoding, body: new Uint8Array(await response.arrayBuffer()) };
 }