@atproto/xrpc 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atproto/xrpc
 
+## 0.8.3
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- Updated dependencies [[`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto/lexicon@0.7.4
+
 ## 0.8.2
 
 ### Patch Changes

package/package.json

@@ -1,9 +1,6 @@
 {
   "name": "@atproto/xrpc",
-  "version": "0.8.2",
-  "engines": {
-    "node": ">=22"
-  },
+  "version": "0.8.3",
   "license": "MIT",
   "description": "atproto HTTP API (XRPC) client library",
   "keywords": [
@@ -16,11 +13,11 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/xrpc"
   },
-  "dependencies": {
-    "zod": "^3.23.8",
-    "@atproto/lexicon": "^0.7.3"
-  },
-  "devDependencies": {},
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -28,6 +25,13 @@
       "default": "./dist/index.js"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "zod": "^3.23.8",
+    "@atproto/lexicon": "^0.7.4"
+  },
   "scripts": {
     "build": "tsgo --build tsconfig.build.json"
   }

package/src/client.ts

@@ -1,73 +0,0 @@
-import { LexiconDoc, Lexicons } from '@atproto/lexicon'
-import { CallOptions, QueryParams } from './types.js'
-import { combineHeaders } from './util.js'
-import { XrpcClient } from './xrpc-client.js'
-
-/** @deprecated Use {@link XrpcClient} instead */
-export class Client {
-  /** @deprecated */
-  get fetch(): never {
-    throw new Error(
-      'Client.fetch is no longer supported. Use an XrpcClient instead.',
-    )
-  }
-
-  /** @deprecated */
-  set fetch(_: never) {
-    throw new Error(
-      'Client.fetch is no longer supported. Use an XrpcClient instead.',
-    )
-  }
-
-  lex = new Lexicons()
-
-  // method calls
-  //
-
-  async call(
-    serviceUri: string | URL,
-    methodNsid: string,
-    params?: QueryParams,
-    data?: BodyInit | null,
-    opts?: CallOptions,
-  ) {
-    return this.service(serviceUri).call(methodNsid, params, data, opts)
-  }
-
-  service(serviceUri: string | URL) {
-    return new ServiceClient(this, serviceUri)
-  }
-
-  // schemas
-  // =
-
-  addLexicon(doc: LexiconDoc) {
-    this.lex.add(doc)
-  }
-
-  addLexicons(docs: LexiconDoc[]) {
-    for (const doc of docs) {
-      this.addLexicon(doc)
-    }
-  }
-
-  removeLexicon(uri: string) {
-    this.lex.remove(uri)
-  }
-}
-
-/** @deprecated Use {@link XrpcClient} instead */
-export class ServiceClient extends XrpcClient {
-  uri: URL
-
-  constructor(
-    public baseClient: Client,
-    serviceUri: string | URL,
-  ) {
-    super(async (input, init) => {
-      const headers = combineHeaders(init.headers, Object.entries(this.headers))
-      return fetch(new URL(input, this.uri), { ...init, headers })
-    }, baseClient.lex)
-    this.uri = typeof serviceUri === 'string' ? new URL(serviceUri) : serviceUri
-  }
-}

package/src/fetch-handler.ts

@@ -1,90 +0,0 @@
-import { Gettable } from './types.js'
-import { combineHeaders } from './util.js'
-
-export type FetchHandler = (
-  this: void,
-  /**
-   * The URL (pathname + query parameters) to make the request to, without the
-   * origin. The origin (protocol, hostname, and port) must be added by this
-   * {@link FetchHandler}, typically based on authentication or other factors.
-   */
-  url: string,
-  init: RequestInit,
-) => Promise<Response>
-
-export type FetchHandlerOptions = BuildFetchHandlerOptions | string | URL
-
-export type BuildFetchHandlerOptions = {
-  /**
-   * The service URL to make requests to. This can be a string, URL, or a
-   * function that returns a string or URL. This is useful for dynamic URLs,
-   * such as a service URL that changes based on authentication.
-   */
-  service: Gettable<string | URL>
-
-  /**
-   * Headers to be added to every request. If a function is provided, it will be
-   * called on each request to get the headers. This is useful for dynamic
-   * headers, such as authentication tokens that may expire.
-   */
-  headers?: {
-    [_ in string]?: Gettable<null | string>
-  }
-
-  /**
-   * Bring your own fetch implementation. Typically useful for testing, logging,
-   * mocking, or adding retries, session management, signatures, proof of
-   * possession (DPoP), SSRF protection, etc. Defaults to the global `fetch`
-   * function.
-   */
-  fetch?: typeof globalThis.fetch
-}
-
-export interface FetchHandlerObject {
-  fetchHandler: (
-    this: FetchHandlerObject,
-    /**
-     * The URL (pathname + query parameters) to make the request to, without the
-     * origin. The origin (protocol, hostname, and port) must be added by this
-     * {@link FetchHandler}, typically based on authentication or other factors.
-     */
-    url: string,
-    init: RequestInit,
-  ) => Promise<Response>
-}
-
-export function buildFetchHandler(
-  options: FetchHandler | FetchHandlerObject | FetchHandlerOptions,
-): FetchHandler {
-  // Already a fetch handler (allowed for convenience)
-  if (typeof options === 'function') return options
-  if (typeof options === 'object' && 'fetchHandler' in options) {
-    return options.fetchHandler.bind(options)
-  }
-
-  const {
-    service,
-    headers: defaultHeaders = undefined,
-    fetch = globalThis.fetch,
-  } = typeof options === 'string' || options instanceof URL
-    ? { service: options }
-    : options
-
-  if (typeof fetch !== 'function') {
-    throw new TypeError(
-      'XrpcDispatcher requires fetch() to be available in your environment.',
-    )
-  }
-
-  const defaultHeadersEntries =
-    defaultHeaders != null ? Object.entries(defaultHeaders) : undefined
-
-  return async function (url, init) {
-    const base = typeof service === 'function' ? service() : service
-    const fullUrl = new URL(url, base)
-
-    const headers = combineHeaders(init.headers, defaultHeadersEntries)
-
-    return fetch(fullUrl, { ...init, headers })
-  }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './client.js'
-export * from './fetch-handler.js'
-export * from './types.js'
-export * from './util.js'
-export * from './xrpc-client.js'
-
-import { Client } from './client.js'
-/** @deprecated create a local {@link XrpcClient} instance instead */
-const defaultInst = new Client()
-export default defaultInst

package/src/types.ts

@@ -1,181 +0,0 @@
-import { z } from 'zod'
-import { ValidationError } from '@atproto/lexicon'
-
-export type QueryParams = Record<string, any>
-export type HeadersMap = Record<string, string | undefined>
-
-export type {
-  /** @deprecated not to be confused with the WHATWG Headers constructor */
-  HeadersMap as Headers,
-}
-
-export type Gettable<T> = T | (() => T)
-
-export interface CallOptions {
-  encoding?: string
-  signal?: AbortSignal
-  headers?: HeadersMap
-}
-
-export const errorResponseBody = z.object({
-  error: z.string().optional(),
-  message: z.string().optional(),
-})
-export type ErrorResponseBody = z.infer<typeof errorResponseBody>
-
-export enum ResponseType {
-  /**
-   * Network issue, unable to get response from the server.
-   */
-  Unknown = 1,
-  /**
-   * Response failed lexicon validation.
-   */
-  InvalidResponse = 2,
-  Success = 200,
-  InvalidRequest = 400,
-  AuthenticationRequired = 401,
-  Forbidden = 403,
-  XRPCNotSupported = 404,
-  NotAcceptable = 406,
-  PayloadTooLarge = 413,
-  UnsupportedMediaType = 415,
-  RateLimitExceeded = 429,
-  InternalServerError = 500,
-  MethodNotImplemented = 501,
-  UpstreamFailure = 502,
-  NotEnoughResources = 503,
-  UpstreamTimeout = 504,
-}
-
-export function httpResponseCodeToEnum(status: number): ResponseType {
-  if (status in ResponseType) {
-    return status
-  } else if (status >= 100 && status < 200) {
-    return ResponseType.XRPCNotSupported
-  } else if (status >= 200 && status < 300) {
-    return ResponseType.Success
-  } else if (status >= 300 && status < 400) {
-    return ResponseType.XRPCNotSupported
-  } else if (status >= 400 && status < 500) {
-    return ResponseType.InvalidRequest
-  } else {
-    return ResponseType.InternalServerError
-  }
-}
-
-export function httpResponseCodeToName(status: number): string {
-  return ResponseType[httpResponseCodeToEnum(status)]
-}
-
-export const ResponseTypeStrings = {
-  [ResponseType.Unknown]: 'Unknown',
-  [ResponseType.InvalidResponse]: 'Invalid Response',
-  [ResponseType.Success]: 'Success',
-  [ResponseType.InvalidRequest]: 'Invalid Request',
-  [ResponseType.AuthenticationRequired]: 'Authentication Required',
-  [ResponseType.Forbidden]: 'Forbidden',
-  [ResponseType.XRPCNotSupported]: 'XRPC Not Supported',
-  [ResponseType.NotAcceptable]: 'Not Acceptable',
-  [ResponseType.PayloadTooLarge]: 'Payload Too Large',
-  [ResponseType.UnsupportedMediaType]: 'Unsupported Media Type',
-  [ResponseType.RateLimitExceeded]: 'Rate Limit Exceeded',
-  [ResponseType.InternalServerError]: 'Internal Server Error',
-  [ResponseType.MethodNotImplemented]: 'Method Not Implemented',
-  [ResponseType.UpstreamFailure]: 'Upstream Failure',
-  [ResponseType.NotEnoughResources]: 'Not Enough Resources',
-  [ResponseType.UpstreamTimeout]: 'Upstream Timeout',
-} as const satisfies Record<ResponseType, string>
-
-export function httpResponseCodeToString(status: number): string {
-  return ResponseTypeStrings[httpResponseCodeToEnum(status)]
-}
-
-export class XRPCResponse {
-  success = true
-
-  constructor(
-    public data: any,
-    public headers: HeadersMap,
-  ) {}
-}
-
-export class XRPCError extends Error {
-  success = false
-
-  public status: ResponseType
-
-  constructor(
-    statusCode: number,
-    public error: string = httpResponseCodeToName(statusCode),
-    message?: string,
-    public headers?: HeadersMap,
-    options?: ErrorOptions,
-  ) {
-    super(message || error || httpResponseCodeToString(statusCode), options)
-
-    this.status = httpResponseCodeToEnum(statusCode)
-
-    // Pre 2022 runtimes won't handle the "options" constructor argument
-    const cause = options?.cause
-    if (this.cause === undefined && cause !== undefined) {
-      this.cause = cause
-    }
-  }
-
-  static from(cause: unknown, fallbackStatus?: ResponseType): XRPCError {
-    if (cause instanceof XRPCError) {
-      return cause
-    }
-
-    // Type cast the cause to an Error if it is one
-    const causeErr = cause instanceof Error ? cause : undefined
-
-    // Try and find a Response object in the cause
-    const causeResponse: Response | undefined =
-      cause instanceof Response
-        ? cause
-        : cause?.['response'] instanceof Response
-          ? cause['response']
-          : undefined
-
-    const statusCode: unknown =
-      // Extract status code from "http-errors" like errors
-      causeErr?.['statusCode'] ??
-      causeErr?.['status'] ??
-      // Use the status code from the response object as fallback
-      causeResponse?.status
-
-    // Convert the status code to a ResponseType
-    const status: ResponseType =
-      typeof statusCode === 'number'
-        ? httpResponseCodeToEnum(statusCode)
-        : fallbackStatus ?? ResponseType.Unknown
-
-    const message = causeErr?.message ?? String(cause)
-
-    const headers = causeResponse
-      ? Object.fromEntries(causeResponse.headers.entries())
-      : undefined
-
-    return new XRPCError(status, undefined, message, headers, { cause })
-  }
-}
-
-export class XRPCInvalidResponseError extends XRPCError {
-  constructor(
-    public lexiconNsid: string,
-    public validationError: ValidationError,
-    public responseBody: unknown,
-  ) {
-    super(
-      ResponseType.InvalidResponse,
-      // @NOTE: This is probably wrong and should use ResponseTypeNames instead.
-      // But it would mean a breaking change.
-      ResponseTypeStrings[ResponseType.InvalidResponse],
-      `The server gave an invalid response and may be out of date.`,
-      undefined,
-      { cause: validationError },
-    )
-  }
-}

package/src/util.ts

@@ -1,384 +0,0 @@
-import {
-  LexXrpcProcedure,
-  LexXrpcQuery,
-  jsonStringToLex,
-  stringifyLex,
-} from '@atproto/lexicon'
-import {
-  CallOptions,
-  ErrorResponseBody,
-  Gettable,
-  QueryParams,
-  ResponseType,
-  XRPCError,
-  errorResponseBody,
-} from './types.js'
-
-const ReadableStream =
-  globalThis.ReadableStream ||
-  (class {
-    constructor() {
-      // This anonymous class will never pass any "instanceof" check and cannot
-      // be instantiated.
-      throw new Error('ReadableStream is not supported in this environment')
-    }
-  } as typeof globalThis.ReadableStream)
-
-export function isErrorResponseBody(v: unknown): v is ErrorResponseBody {
-  return errorResponseBody.safeParse(v).success
-}
-
-export function getMethodSchemaHTTPMethod(
-  schema: LexXrpcProcedure | LexXrpcQuery,
-) {
-  if (schema.type === 'procedure') {
-    return 'post'
-  }
-  return 'get'
-}
-
-export function constructMethodCallUri(
-  nsid: string,
-  schema: LexXrpcProcedure | LexXrpcQuery,
-  serviceUri: URL,
-  params?: QueryParams,
-): string {
-  const uri = new URL(constructMethodCallUrl(nsid, schema, params), serviceUri)
-  return uri.toString()
-}
-
-export function constructMethodCallUrl(
-  nsid: string,
-  schema: LexXrpcProcedure | LexXrpcQuery,
-  params?: QueryParams,
-): string {
-  const pathname = `/xrpc/${encodeURIComponent(nsid)}`
-  if (!params) return pathname
-
-  const searchParams: [string, string][] = []
-
-  for (const [key, value] of Object.entries(params)) {
-    const paramSchema = schema.parameters?.properties?.[key]
-    if (!paramSchema) {
-      throw new Error(`Invalid query parameter: ${key}`)
-    }
-    if (value !== undefined) {
-      if (paramSchema.type === 'array') {
-        const values = Array.isArray(value) ? value : [value]
-        for (const val of values) {
-          searchParams.push([
-            key,
-            encodeQueryParam(paramSchema.items.type, val),
-          ])
-        }
-      } else {
-        searchParams.push([key, encodeQueryParam(paramSchema.type, value)])
-      }
-    }
-  }
-
-  if (!searchParams.length) return pathname
-
-  return `${pathname}?${new URLSearchParams(searchParams).toString()}`
-}
-
-export function encodeQueryParam(
-  type:
-    | 'string'
-    | 'float'
-    | 'integer'
-    | 'boolean'
-    | 'datetime'
-    | 'array'
-    | 'unknown',
-  value: any,
-): string {
-  if (type === 'string' || type === 'unknown') {
-    return String(value)
-  }
-  if (type === 'float') {
-    return String(Number(value))
-  } else if (type === 'integer') {
-    return String(Number(value) | 0)
-  } else if (type === 'boolean') {
-    return value ? 'true' : 'false'
-  } else if (type === 'datetime') {
-    if (value instanceof Date) {
-      return value.toISOString()
-    }
-    return String(value)
-  }
-  throw new Error(`Unsupported query param type: ${type}`)
-}
-
-export function constructMethodCallHeaders(
-  schema: LexXrpcProcedure | LexXrpcQuery,
-  data?: unknown,
-  opts?: CallOptions,
-): Headers {
-  // Not using `new Headers(opts?.headers)` to avoid duplicating headers values
-  // due to inconsistent casing in headers name. In case of multiple headers
-  // with the same name (but using a different case), the last one will be used.
-
-  // new Headers({ 'content-type': 'foo', 'Content-Type': 'bar' }).get('content-type')
-  // => 'foo, bar'
-  const headers = new Headers()
-
-  if (opts?.headers) {
-    for (const name in opts.headers) {
-      if (headers.has(name)) {
-        throw new TypeError(`Duplicate header: ${name}`)
-      }
-
-      const value = opts.headers[name]
-      if (value != null) {
-        headers.set(name, value)
-      }
-    }
-  }
-
-  if (schema.type === 'procedure') {
-    if (opts?.encoding) {
-      headers.set('content-type', opts.encoding)
-    } else if (!headers.has('content-type') && typeof data !== 'undefined') {
-      // Special handling of BodyInit types before falling back to JSON encoding
-      if (
-        data instanceof ArrayBuffer ||
-        data instanceof ReadableStream ||
-        ArrayBuffer.isView(data)
-      ) {
-        headers.set('content-type', 'application/octet-stream')
-      } else if (data instanceof FormData) {
-        // Note: The multipart form data boundary is missing from the header
-        // we set here, making that header invalid. This special case will be
-        // handled in encodeMethodCallBody()
-        headers.set('content-type', 'multipart/form-data')
-      } else if (data instanceof URLSearchParams) {
-        headers.set(
-          'content-type',
-          'application/x-www-form-urlencoded;charset=UTF-8',
-        )
-      } else if (isBlobLike(data)) {
-        headers.set('content-type', data.type || 'application/octet-stream')
-      } else if (typeof data === 'string') {
-        headers.set('content-type', 'text/plain;charset=UTF-8')
-      }
-      // At this point, data is not a valid BodyInit type.
-      else if (isIterable(data)) {
-        headers.set('content-type', 'application/octet-stream')
-      } else if (
-        typeof data === 'boolean' ||
-        typeof data === 'number' ||
-        typeof data === 'string' ||
-        typeof data === 'object' // covers "null"
-      ) {
-        headers.set('content-type', 'application/json')
-      } else {
-        // symbol, function, bigint
-        throw new XRPCError(
-          ResponseType.InvalidRequest,
-          `Unsupported data type: ${typeof data}`,
-        )
-      }
-    }
-  }
-  return headers
-}
-
-export function combineHeaders(
-  headersInit: undefined | HeadersInit,
-  defaultHeaders?: Iterable<[string, undefined | Gettable<null | string>]>,
-): undefined | HeadersInit {
-  if (!defaultHeaders) return headersInit
-
-  let headers: Headers | undefined = undefined
-
-  for (const [name, definition] of defaultHeaders) {
-    // Ignore undefined values (allowed for convenience when using
-    // Object.entries).
-    if (definition === undefined) continue
-
-    // Lazy initialization of the headers object
-    headers ??= new Headers(headersInit)
-
-    if (headers.has(name)) continue
-
-    const value = typeof definition === 'function' ? definition() : definition
-
-    if (typeof value === 'string') headers.set(name, value)
-    else if (value === null) headers.delete(name)
-    else throw new TypeError(`Invalid "${name}" header value: ${typeof value}`)
-  }
-
-  return headers ?? headersInit
-}
-
-function isBlobLike(value: unknown): value is Blob {
-  if (value == null) return false
-  if (typeof value !== 'object') return false
-  if (typeof Blob === 'function' && value instanceof Blob) return true
-
-  // Support for Blobs provided by libraries that don't use the native Blob
-  // (e.g. fetch-blob from node-fetch).
-  // https://github.com/node-fetch/fetch-blob/blob/a1a182e5978811407bef4ea1632b517567dda01f/index.js#L233-L244
-
-  const tag = value[Symbol.toStringTag]
-  if (tag === 'Blob' || tag === 'File') {
-    return 'stream' in value && typeof value.stream === 'function'
-  }
-
-  return false
-}
-
-export function isBodyInit(value: unknown): value is BodyInit {
-  switch (typeof value) {
-    case 'string':
-      return true
-    case 'object':
-      return (
-        value instanceof ArrayBuffer ||
-        value instanceof FormData ||
-        value instanceof URLSearchParams ||
-        value instanceof ReadableStream ||
-        ArrayBuffer.isView(value) ||
-        isBlobLike(value)
-      )
-    default:
-      return false
-  }
-}
-
-export function isIterable(
-  value: unknown,
-): value is Iterable<unknown> | AsyncIterable<unknown> {
-  return (
-    value != null &&
-    typeof value === 'object' &&
-    (Symbol.iterator in value || Symbol.asyncIterator in value)
-  )
-}
-
-export function encodeMethodCallBody(
-  headers: Headers,
-  data?: unknown,
-): BodyInit | undefined {
-  // Silently ignore the body if there is no content-type header.
-  const contentType = headers.get('content-type')
-  if (!contentType) {
-    return undefined
-  }
-
-  if (typeof data === 'undefined') {
-    // This error would be returned by the server, but we can catch it earlier
-    // to avoid un-necessary requests. Note that a content-length of 0 does not
-    // necessary mean that the body is "empty" (e.g. an empty txt file).
-    throw new XRPCError(
-      ResponseType.InvalidRequest,
-      `A request body is expected but none was provided`,
-    )
-  }
-
-  if (isBodyInit(data)) {
-    if (data instanceof FormData && contentType === 'multipart/form-data') {
-      // fetch() will encode FormData payload itself, but it won't override the
-      // content-type header if already present. This would cause the boundary
-      // to be missing from the content-type header, resulting in a 400 error.
-      // Deleting the content-type header here to let fetch() re-create it.
-      headers.delete('content-type')
-    }
-
-    // Will be encoded by the fetch API.
-    return data
-  }
-
-  if (isIterable(data)) {
-    // Note that some environments support using Iterable & AsyncIterable as the
-    // body (e.g. Node's fetch), but not all of them do (browsers).
-    return iterableToReadableStream(data)
-  }
-
-  if (contentType.startsWith('text/')) {
-    return new TextEncoder().encode(String(data))
-  }
-  if (contentType.startsWith('application/json')) {
-    const json = stringifyLex(data)
-    // Server would return a 400 error if the JSON is invalid (e.g. trying to
-    // JSONify a function, or an object that implements toJSON() poorly).
-    if (json === undefined) {
-      throw new XRPCError(
-        ResponseType.InvalidRequest,
-        `Failed to encode request body as JSON`,
-      )
-    }
-    return new TextEncoder().encode(json)
-  }
-
-  // At this point, "data" is not a valid BodyInit value, and we don't know how
-  // to encode it into one. Passing it to fetch would result in an error. Let's
-  // throw our own error instead.
-
-  const type =
-    !data || typeof data !== 'object'
-      ? typeof data
-      : data.constructor !== Object &&
-          typeof data.constructor === 'function' &&
-          typeof data.constructor?.name === 'string'
-        ? data.constructor.name
-        : 'object'
-
-  throw new XRPCError(
-    ResponseType.InvalidRequest,
-    `Unable to encode ${type} as ${contentType} data`,
-  )
-}
-
-/**
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static}
- */
-function iterableToReadableStream(
-  iterable: Iterable<unknown> | AsyncIterable<unknown>,
-): ReadableStream<Uint8Array> {
-  // Use the native ReadableStream.from() if available.
-  if ('from' in ReadableStream && typeof ReadableStream.from === 'function') {
-    return ReadableStream.from(iterable)
-  }
-
-  // If you see this error, consider using a polyfill for ReadableStream. For
-  // example, the "web-streams-polyfill" package:
-  // https://github.com/MattiasBuelens/web-streams-polyfill
-
-  throw new TypeError(
-    'ReadableStream.from() is not supported in this environment. ' +
-      'It is required to support using iterables as the request body. ' +
-      'Consider using a polyfill or re-write your code to use a different body type.',
-  )
-}
-
-export function httpResponseBodyParse(
-  mimeType: string | null,
-  data: ArrayBuffer | undefined,
-): any {
-  try {
-    if (mimeType) {
-      if (mimeType.includes('application/json')) {
-        const str = new TextDecoder().decode(data)
-        return jsonStringToLex(str)
-      }
-      if (mimeType.startsWith('text/')) {
-        return new TextDecoder().decode(data)
-      }
-    }
-    if (data instanceof ArrayBuffer) {
-      return new Uint8Array(data)
-    }
-    return data
-  } catch (cause) {
-    throw new XRPCError(
-      ResponseType.InvalidResponse,
-      undefined,
-      `Failed to parse response body: ${String(cause)}`,
-      undefined,
-      { cause },
-    )
-  }
-}

package/src/xrpc-client.ts

@@ -1,124 +0,0 @@
-import { LexiconDoc, Lexicons, ValidationError } from '@atproto/lexicon'
-import {
-  FetchHandler,
-  FetchHandlerObject,
-  FetchHandlerOptions,
-  buildFetchHandler,
-} from './fetch-handler.js'
-import {
-  CallOptions,
-  Gettable,
-  QueryParams,
-  ResponseType,
-  XRPCError,
-  XRPCInvalidResponseError,
-  XRPCResponse,
-  httpResponseCodeToEnum,
-} from './types.js'
-import {
-  combineHeaders,
-  constructMethodCallHeaders,
-  constructMethodCallUrl,
-  encodeMethodCallBody,
-  getMethodSchemaHTTPMethod,
-  httpResponseBodyParse,
-  isErrorResponseBody,
-} from './util.js'
-
-export class XrpcClient {
-  readonly fetchHandler: FetchHandler
-  readonly headers = new Map<string, Gettable<null | string>>()
-  readonly lex: Lexicons
-
-  constructor(
-    fetchHandlerOpts: FetchHandler | FetchHandlerObject | FetchHandlerOptions,
-    // "Lexicons" is redundant here (because that class implements
-    // "Iterable<LexiconDoc>") but we keep it for explicitness:
-    lex: Lexicons | Iterable<LexiconDoc>,
-  ) {
-    this.fetchHandler = buildFetchHandler(fetchHandlerOpts)
-
-    this.lex = lex instanceof Lexicons ? lex : new Lexicons(lex)
-  }
-
-  setHeader(key: string, value: Gettable<null | string>): void {
-    this.headers.set(key.toLowerCase(), value)
-  }
-
-  unsetHeader(key: string): void {
-    this.headers.delete(key.toLowerCase())
-  }
-
-  clearHeaders(): void {
-    this.headers.clear()
-  }
-
-  async call(
-    methodNsid: string,
-    params?: QueryParams,
-    data?: unknown,
-    opts?: CallOptions,
-  ): Promise<XRPCResponse> {
-    const def = this.lex.getDefOrThrow(methodNsid)
-    if (!def || (def.type !== 'query' && def.type !== 'procedure')) {
-      throw new TypeError(
-        `Invalid lexicon: ${methodNsid}. Must be a query or procedure.`,
-      )
-    }
-
-    // @TODO: should we validate the params and data here?
-    // this.lex.assertValidXrpcParams(methodNsid, params)
-    // if (data !== undefined) {
-    //   this.lex.assertValidXrpcInput(methodNsid, data)
-    // }
-
-    const reqUrl = constructMethodCallUrl(methodNsid, def, params)
-    const reqMethod = getMethodSchemaHTTPMethod(def)
-    const reqHeaders = constructMethodCallHeaders(def, data, opts)
-    const reqBody = encodeMethodCallBody(reqHeaders, data)
-
-    // The duplex field is required for streaming bodies, but not yet reflected
-    // anywhere in docs or types. See whatwg/fetch#1438, nodejs/node#46221.
-    const init: RequestInit & { duplex: 'half' } = {
-      method: reqMethod,
-      headers: combineHeaders(reqHeaders, this.headers),
-      body: reqBody,
-      duplex: 'half',
-      redirect: 'follow',
-      signal: opts?.signal,
-    }
-
-    try {
-      const response = await this.fetchHandler.call(undefined, reqUrl, init)
-
-      const resStatus = response.status
-      const resHeaders = Object.fromEntries(response.headers.entries())
-      const resBodyBytes = await response.arrayBuffer()
-      const resBody = httpResponseBodyParse(
-        response.headers.get('content-type'),
-        resBodyBytes,
-      )
-
-      const resCode = httpResponseCodeToEnum(resStatus)
-      if (resCode !== ResponseType.Success) {
-        const { error = undefined, message = undefined } =
-          resBody && isErrorResponseBody(resBody) ? resBody : {}
-        throw new XRPCError(resCode, error, message, resHeaders)
-      }
-
-      try {
-        this.lex.assertValidXrpcOutput(methodNsid, resBody)
-      } catch (e: unknown) {
-        if (e instanceof ValidationError) {
-          throw new XRPCInvalidResponseError(methodNsid, e, resBody)
-        }
-
-        throw e
-      }
-
-      return new XRPCResponse(resBody, resHeaders)
-    } catch (err) {
-      throw XRPCError.from(err)
-    }
-  }
-}

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig/isomorphic.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-  },
-  "include": ["./src"],
-}

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/client.ts","./src/fetch-handler.ts","./src/index.ts","./src/types.ts","./src/util.ts","./src/xrpc-client.ts"]}

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "include": [],
-  "references": [{ "path": "./tsconfig.build.json" }],
-}