@sanity/client 7.26.2 → 8.0.0

package/src/data/eventsource.ts

@@ -14,8 +14,8 @@ export class ConnectionFailedError extends Error {
   readonly name = 'ConnectionFailedError'
   /**
    * HTTP status code of the rejected connection attempt, if known.
-   * Only set when the EventSource implementation exposes it — the polyfill used in
-   * Node.js and when custom headers (eg authorization) are required does, while
+   * Only set when the EventSource implementation exposes it — the `eventsource`
+   * package used by the client does (as `code` on its error events), while
    * native EventSource implementations (browser and Node.js) do not.
    */
   readonly status?: number
@@ -151,8 +151,10 @@ function connectWithESInstance<EventTypeName extends string>(
         const [parseError, event] = parseEvent(evt as MessageEvent)
         observer.error(
           parseError
-            ? new MessageParseError('Unable to parse EventSource error message', {cause: event})
-            : new MessageError((event?.data as {message: string}).message, event),
+            ? new MessageParseError('Unable to parse EventSource error message', {
+                cause: parseError,
+              })
+            : new MessageError((event.data as {message: string}).message, event),
         )
         return
       }
@@ -161,12 +163,13 @@ function connectWithESInstance<EventTypeName extends string>(
       // automatically, but in some cases (like when a laptop lid is closed), it will trigger onError
       // if it can't reconnect.
       // see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
-      // The polyfills expose the HTTP status of a rejected connection on the error event
-      // (native EventSource implementations do not). A status means the server rejected the
-      // connection attempt, so error out regardless of readyState — the polyfills disagree
-      // on whether the connection closes before or after the error event is dispatched —
-      // and let `reconnectOnConnectionFailure` classify it (4xx fatal, otherwise retried).
-      const rawStatus = (evt as {status?: unknown}).status
+      // The `eventsource` package exposes the HTTP status of a rejected connection as
+      // `code` on the error event (native EventSource implementations expose nothing).
+      // A status means the server rejected the connection attempt, so error out
+      // regardless of readyState — implementations disagree on whether the connection
+      // closes before or after the error event is dispatched — and let
+      // `reconnectOnConnectionFailure` classify it (4xx fatal, otherwise retried).
+      const rawStatus = (evt as {code?: unknown}).code
       const status = typeof rawStatus === 'number' ? rawStatus : undefined
       if (status !== undefined) {
         observer.error(new ConnectionFailedError('EventSource connection failed', {status}))

package/src/data/listen.ts

@@ -1,4 +1,5 @@
-import {Observable, of, throwError} from 'rxjs'
+import {EventSource} from 'eventsource'
+import {Observable, throwError} from 'rxjs'
 import {filter, map} from 'rxjs/operators'
 
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
@@ -22,8 +23,8 @@ import {pick} from '../util/pick'
 import {_getDataUrl} from './dataMethods'
 import {encodeQueryString} from './encodeQueryString'
 import {connectEventSource} from './eventsource'
-import {eventSourcePolyfill} from './eventsourcePolyfill'
 import {reconnectOnConnectionFailure} from './reconnectOnConnectionFailure'
+import {resolveEventSourceFetch} from './resolveEventSourceFetch'
 
 // Limit is 16K for a _request_, eg including headers. Have to account for an
 // unknown range of headers, but an average EventSource request from Chrome seems
@@ -57,7 +58,8 @@ const defaultOptions = {
 export type MapListenEventNamesToListenEvents<
   R extends Record<string, Any> = Record<string, Any>,
   Events extends (ResumableListenEventNames | ListenEventName)[] = (
-    ResumableListenEventNames | ListenEventName
+    | ResumableListenEventNames
+    | ListenEventName
   )[],
 > = Events extends (infer E)[]
   ? E extends 'welcome'
@@ -134,7 +136,8 @@ export function _listen<
   params?: ListenParams,
   opts: Opts = {} as Opts,
 ): Observable<ListenEventFromOptions<R, Opts>> {
-  const {url, token, withCredentials, requestTagPrefix, headers: configHeaders} = this.config()
+  const config = this.config()
+  const {url, token, withCredentials, requestTagPrefix, headers: configHeaders} = config
   const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join('.') : opts.tag
   const options = {...defaults(opts, defaultOptions), tag}
   const listenOpts = pick(options, possibleOptions)
@@ -147,29 +150,21 @@ export function _listen<
 
   const listenFor = (options.events ? options.events : ['mutation']) satisfies Opts['events']
 
-  const esOptions: EventSourceInit & {headers?: Record<string, string>} = {}
-  if (withCredentials) {
-    esOptions.withCredentials = true
+  const headers: Record<string, string> = {}
+  if (token) {
+    headers.Authorization = `Bearer ${token}`
   }
-
-  if (token || configHeaders) {
-    esOptions.headers = {}
-
-    if (token) {
-      esOptions.headers.Authorization = `Bearer ${token}`
-    }
-
-    if (configHeaders) {
-      Object.assign(esOptions.headers, configHeaders)
-    }
+  if (configHeaders) {
+    Object.assign(headers, configHeaders)
   }
 
   const initEventSource = () =>
-    // use polyfill if there is no global EventSource or if we need to set headers
-    (typeof EventSource === 'undefined' || esOptions.headers
-      ? eventSourcePolyfill
-      : of(EventSource)
-    ).pipe(map((EventSource) => new EventSource(uri, esOptions)))
+    new EventSource(uri, {
+      fetch: resolveEventSourceFetch(config, {
+        headers: Object.keys(headers).length ? headers : undefined,
+        withCredentials,
+      }),
+    })
 
   return connectEventSource(initEventSource, listenFor).pipe(
     reconnectOnConnectionFailure(),

package/src/data/live.ts

@@ -1,9 +1,11 @@
+import {EventSource} from 'eventsource'
 import {catchError, mergeMap, Observable, of, throwError} from 'rxjs'
 import {finalize, map} from 'rxjs/operators'
 
 import {CorsOriginError} from '../http/errors'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {
+  InitializedClientConfig,
   LiveEvent,
   LiveEventGoAway,
   LiveEventMessage,
@@ -15,8 +17,8 @@ import type {
 import {shareReplayLatest} from '../util/shareReplayLatest'
 import {_getDataUrl} from './dataMethods'
 import {connectEventSource} from './eventsource'
-import {eventSourcePolyfill} from './eventsourcePolyfill'
 import {reconnectOnConnectionFailure} from './reconnectOnConnectionFailure'
+import {resolveEventSourceFetch} from './resolveEventSourceFetch'
 
 const requiredApiVersion = '2021-03-25'
 
@@ -50,6 +52,7 @@ export class LiveClient {
      */
     waitFor?: 'function'
   } = {}): Observable<LiveEvent> {
+    const config = this.#client.config()
     const {
       projectId,
       apiVersion: _apiVersion,
@@ -57,7 +60,7 @@ export class LiveClient {
       withCredentials,
       requestTagPrefix,
       headers: configHeaders,
-    } = this.#client.config()
+    } = config
     const apiVersion = _apiVersion.replace(/^v/, '')
     if (apiVersion !== 'X' && apiVersion < requiredApiVersion) {
       throw new Error(
@@ -83,36 +86,39 @@ export class LiveClient {
     if (waitFor) {
       url.searchParams.set('waitFor', waitFor)
     }
-    const esOptions: EventSourceInit & {headers?: Record<string, string>} = {}
-    if (includeDrafts && withCredentials) {
-      esOptions.withCredentials = true
+    const eventSourceHeaders: Record<string, string> = {}
+    if (includeDrafts && token) {
+      eventSourceHeaders.Authorization = `Bearer ${token}`
     }
-
-    if ((includeDrafts && token) || configHeaders) {
-      esOptions.headers = {}
-
-      if (includeDrafts && token) {
-        esOptions.headers.Authorization = `Bearer ${token}`
-      }
-
-      if (configHeaders) {
-        Object.assign(esOptions.headers, configHeaders)
-      }
+    if (configHeaders) {
+      Object.assign(eventSourceHeaders, configHeaders)
     }
+    const eventSourceWithCredentials = Boolean(includeDrafts && withCredentials)
 
-    const key = `${url.href}::${JSON.stringify(esOptions)}`
-    const existing = eventsCache.get(key)
+    let transportCache = eventsCache.get(config.resolveFetch)
+    if (!transportCache) {
+      transportCache = new Map()
+      eventsCache.set(config.resolveFetch, transportCache)
+    }
+    const cacheKey = JSON.stringify([
+      url.href,
+      typeof config.proxy === 'string' ? config.proxy : null,
+      eventSourceHeaders,
+      eventSourceWithCredentials,
+    ])
+    const existing = transportCache.get(cacheKey)
 
     if (existing) {
       return existing
     }
 
     const initEventSource = () =>
-      // use polyfill if there is no global EventSource or if we need to set headers
-      (typeof EventSource === 'undefined' || esOptions.headers
-        ? eventSourcePolyfill
-        : of(EventSource)
-      ).pipe(map((EventSource) => new EventSource(url.href, esOptions)))
+      new EventSource(url.href, {
+        fetch: resolveEventSourceFetch(config, {
+          headers: Object.keys(eventSourceHeaders).length ? eventSourceHeaders : undefined,
+          withCredentials: eventSourceWithCredentials,
+        }),
+      })
 
     const events = connectEventSource(initEventSource, [
       'message',
@@ -125,7 +131,7 @@ export class LiveClient {
     const checkCors = checkCorsObservable(
       new URL(this.#client.getUrl('/check/cors', false)),
       projectId,
-      esOptions.withCredentials === true,
+      eventSourceWithCredentials,
     )
 
     const observable = events
@@ -162,12 +168,15 @@ export class LiveClient {
         }),
       )
       .pipe(
-        finalize(() => eventsCache.delete(key)),
+        finalize(() => {
+          transportCache.delete(cacheKey)
+          if (transportCache.size === 0) eventsCache.delete(config.resolveFetch)
+        }),
         shareReplayLatest({
           predicate: (event) => event.type === 'welcome',
         }),
       )
-    eventsCache.set(key, observable)
+    transportCache.set(cacheKey, observable)
     return observable
   }
 }
@@ -262,4 +271,12 @@ function checkCorsObservable(
   })
 }
 
-const eventsCache = new Map<string, Observable<LiveEvent>>()
+/**
+ * Cached observables capture their transport (`initEventSource` closes over
+ * `config.resolveFetch` and `config.proxy`), so the cache is scoped per
+ * resolver — `undefined` covers the `globalThis.fetch` fallback.
+ */
+const eventsCache = new Map<
+  InitializedClientConfig['resolveFetch'],
+  Map<string, Observable<LiveEvent>>
+>()

package/src/data/resolveEventSourceFetch.ts

@@ -0,0 +1,96 @@
+import type {EventSourceFetchInit, FetchLikeResponse} from 'eventsource'
+import type {FetchFunction, FetchInit} from 'get-it'
+
+import type {InitializedClientConfig} from '../types'
+
+/** @internal */
+export interface EventSourceFetchOptions {
+  /**
+   * Headers that must be merged into every EventSource request. Used for
+   * the `Authorization` token, custom `headers` from the client config,
+   * etc. — things the native EventSource API has no equivalent for.
+   */
+  headers?: Record<string, string>
+  /**
+   * If the client was configured with `withCredentials: true`, the
+   * resolved fetch forwards `credentials: 'include'` so the browser
+   * attaches cookies to the SSE request.
+   */
+  withCredentials?: boolean
+}
+
+/**
+ * Build a `fetch` implementation suitable for the `eventsource` package's
+ * `fetch` option. Routes the EventSource connection through the same
+ * transport layer the rest of the client uses, so things like the
+ * test-fetch override, the per-request `proxy` config, and `HTTPS_PROXY`
+ * env-var support apply to SSE too.
+ *
+ * Resolution order on each request:
+ *
+ *   1. `config.resolveFetch(config.proxy)` if set — the client's fetch
+ *      resolver, so SSE uses the same transport as regular requests:
+ *      custom fetch variants (incl. the test suite's injected mock),
+ *      undici configuration, an explicit `proxy` config, and env-proxy
+ *      support all apply to SSE too. The Node entry supplies get-it's
+ *      undici-backed fetch (threading the resolver through the env
+ *      instead of importing `get-it/node` directly keeps `undici` out of
+ *      the browser bundle); the browser entry leaves it unset.
+ *   2. `globalThis.fetch`. Note that Node's global fetch does NOT read
+ *      proxy env vars (that is opt-in via `NODE_USE_ENV_PROXY`), which
+ *      is one of the reasons step 1 exists.
+ *
+ * The returned fetch always merges `options.headers` into the outgoing
+ * request, regardless of which underlying fetch was picked.
+ *
+ * @internal
+ */
+export function resolveEventSourceFetch(
+  config: InitializedClientConfig,
+  options: EventSourceFetchOptions = {},
+): EventSourceFetch {
+  const extraHeaders = options.headers
+  const credentials: FetchInit['credentials'] = options.withCredentials ? 'include' : undefined
+
+  return function eventSourceFetch(url, init) {
+    const baseFetch = pickBaseFetch(config)
+
+    // Extra `EventSourceFetchInit` fields get-it's `FetchInit` doesn't
+    // declare (`mode`, `cache`) survive the spread and reach whichever
+    // fetch implementation is effective.
+    const mergedInit: FetchInit = {...init}
+    if (extraHeaders) {
+      const headers = new Headers(init?.headers)
+      for (const [key, value] of Object.entries(extraHeaders)) {
+        headers.set(key, value)
+      }
+      mergedInit.headers = headers
+    }
+    if (credentials !== undefined) {
+      mergedInit.credentials = credentials
+    }
+    // get-it's `FetchResponse` is a structural superset of the package's
+    // `FetchLikeResponse`, so it can be handed over as-is.
+    return baseFetch(typeof url === 'string' ? url : url.href, mergedInit)
+  }
+}
+
+/**
+ * The fetch shape handed to the `eventsource` package: accepts what its
+ * `FetchLike` passes in, requires only what get-it's `FetchFunction`
+ * guarantees back — the full `typeof fetch` contract is not needed anywhere
+ * in this chain.
+ *
+ * @internal
+ */
+export type EventSourceFetch = (
+  url: string | URL,
+  init?: EventSourceFetchInit,
+) => Promise<FetchLikeResponse>
+
+function pickBaseFetch(config: InitializedClientConfig): FetchFunction {
+  if (config.resolveFetch) {
+    return config.resolveFetch(typeof config.proxy === 'string' ? config.proxy : undefined)
+  }
+  return globalThis.fetch.bind(globalThis)
+}

package/src/datasets/DatasetsClient.ts

@@ -1,6 +1,6 @@
-import {lastValueFrom, type Observable} from 'rxjs'
+import {type Observable} from 'rxjs'
 
-import {_request} from '../data/dataMethods'
+import {_request, _requestObservable} from '../data/dataMethods'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {
   DatasetCreateOptions,
@@ -29,7 +29,7 @@ export class ObservableDatasetsClient {
    * @param options - Options for the dataset, including optional embeddings configuration
    */
   create(name: string, options?: DatasetCreateOptions): Observable<DatasetResponse> {
-    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
+    return _modifyObservable<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
   }
 
   /**
@@ -39,7 +39,13 @@ export class ObservableDatasetsClient {
    * @param options - New options for the dataset
    */
   edit(name: string, options?: DatasetEditOptions): Observable<DatasetResponse> {
-    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options)
+    return _modifyObservable<DatasetResponse>(
+      this.#client,
+      this.#httpRequest,
+      'PATCH',
+      name,
+      options,
+    )
   }
 
   /**
@@ -48,7 +54,7 @@ export class ObservableDatasetsClient {
    * @param name - Name of the dataset to delete
    */
   delete(name: string): Observable<{deleted: true}> {
-    return _modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
+    return _modifyObservable<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
   }
 
   /**
@@ -58,13 +64,13 @@ export class ObservableDatasetsClient {
     validate.resourceGuard('dataset', this.#client.config())
     const config = this.#client.config()
     const projectId = config.projectId
-    let uri = '/datasets'
+    let url = '/datasets'
     if (config.useProjectHostname === false) {
-      uri = `/projects/${projectId}/datasets`
+      url = `/projects/${projectId}/datasets`
     }
 
-    return _request<DatasetsResponse>(this.#client, this.#httpRequest, {
-      uri,
+    return _requestObservable<DatasetsResponse>(this.#client, this.#httpRequest, {
+      url,
       tag: null,
     })
   }
@@ -77,8 +83,8 @@ export class ObservableDatasetsClient {
   getEmbeddingsSettings(name: string): Observable<EmbeddingsSettings> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
-      uri: _embeddingsSettingsUri(this.#client, name),
+    return _requestObservable<EmbeddingsSettings>(this.#client, this.#httpRequest, {
+      url: _embeddingsSettingsUri(this.#client, name),
       tag: null,
     })
   }
@@ -92,9 +98,9 @@ export class ObservableDatasetsClient {
   editEmbeddingsSettings(name: string, settings: EmbeddingsSettingsBody): Observable<void> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return _request<void>(this.#client, this.#httpRequest, {
+    return _requestObservable<void>(this.#client, this.#httpRequest, {
       method: 'PUT',
-      uri: _embeddingsSettingsUri(this.#client, name),
+      url: _embeddingsSettingsUri(this.#client, name),
       body: settings,
       tag: null,
     })
@@ -118,9 +124,7 @@ export class DatasetsClient {
    */
   create(name: string, options?: DatasetCreateOptions): Promise<DatasetResponse> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(
-      _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options),
-    )
+    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
   }
 
   /**
@@ -131,9 +135,7 @@ export class DatasetsClient {
    */
   edit(name: string, options?: DatasetEditOptions): Promise<DatasetResponse> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(
-      _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options),
-    )
+    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options)
   }
 
   /**
@@ -143,7 +145,7 @@ export class DatasetsClient {
    */
   delete(name: string): Promise<{deleted: true}> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(_modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name))
+    return _modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
   }
 
   /**
@@ -153,14 +155,15 @@ export class DatasetsClient {
     validate.resourceGuard('dataset', this.#client.config())
     const config = this.#client.config()
     const projectId = config.projectId
-    let uri = '/datasets'
+    let url = '/datasets'
     if (config.useProjectHostname === false) {
-      uri = `/projects/${projectId}/datasets`
+      url = `/projects/${projectId}/datasets`
     }
 
-    return lastValueFrom(
-      _request<DatasetsResponse>(this.#client, this.#httpRequest, {uri, tag: null}),
-    )
+    return _request<DatasetsResponse>(this.#client, this.#httpRequest, {
+      url,
+      tag: null,
+    })
   }
 
   /**
@@ -171,12 +174,10 @@ export class DatasetsClient {
   getEmbeddingsSettings(name: string): Promise<EmbeddingsSettings> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return lastValueFrom(
-      _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
-        uri: _embeddingsSettingsUri(this.#client, name),
-        tag: null,
-      }),
-    )
+    return _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
+      url: _embeddingsSettingsUri(this.#client, name),
+      tag: null,
+    })
   }
 
   /**
@@ -188,14 +189,12 @@ export class DatasetsClient {
   editEmbeddingsSettings(name: string, settings: EmbeddingsSettingsBody): Promise<void> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return lastValueFrom(
-      _request<void>(this.#client, this.#httpRequest, {
-        method: 'PUT',
-        uri: _embeddingsSettingsUri(this.#client, name),
-        body: settings,
-        tag: null,
-      }),
-    )
+    return _request<void>(this.#client, this.#httpRequest, {
+      method: 'PUT',
+      url: _embeddingsSettingsUri(this.#client, name),
+      body: settings,
+      tag: null,
+    })
   }
 }
 
@@ -210,7 +209,7 @@ function _embeddingsSettingsUri(
   return `/datasets/${name}/settings/embeddings`
 }
 
-function _modify<R = unknown>(
+function _modifyObservable<R = unknown>(
   client: SanityClient | ObservableSanityClient,
   httpRequest: HttpRequest,
   method: 'DELETE' | 'PATCH' | 'PUT',
@@ -220,9 +219,27 @@ function _modify<R = unknown>(
   validate.resourceGuard('dataset', client.config())
   validate.dataset(name)
 
+  return _requestObservable<R>(client, httpRequest, {
+    method,
+    url: `/datasets/${name}`,
+    body: options,
+    tag: null,
+  })
+}
+
+function _modify<R = unknown>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  method: 'DELETE' | 'PATCH' | 'PUT',
+  name: string,
+  options?: DatasetCreateOptions | DatasetEditOptions,
+): Promise<R> {
+  validate.resourceGuard('dataset', client.config())
+  validate.dataset(name)
+
   return _request<R>(client, httpRequest, {
     method,
-    uri: `/datasets/${name}`,
+    url: `/datasets/${name}`,
     body: options,
     tag: null,
   })

package/src/defineCreateClient.ts

@@ -1,7 +1,5 @@
-import type {Middlewares} from 'get-it'
-
-import {defineHttpRequest} from './http/request'
-import type {Any, ClientConfig, HttpRequest} from './types'
+import {defineRequester, type EnvironmentOptions} from './http/request'
+import type {ClientConfig, HttpRequest} from './types'
 
 export {validateApiPerspective} from './config'
 export {
@@ -29,9 +27,6 @@ export {
 export * from './SanityClient'
 export * from './types'
 
-/** @alpha */
-export {adapter as unstable__adapter, environment as unstable__environment} from 'get-it'
-
 /**
  * Create the `requester` and `createClient` exports, that have environment specific middleware for node and browsers
  * @internal
@@ -40,27 +35,44 @@ export default function defineCreateClientExports<
   SanityClientType,
   ClientConfigType extends ClientConfig,
 >(
-  envMiddleware: Middlewares,
+  envOptions: EnvironmentOptions,
   ClassConstructor: new (httpRequest: HttpRequest, config: ClientConfigType) => SanityClientType,
 ) {
-  // Set the http client to use for requests, and its environment specific middleware
-  const defaultRequester = defineHttpRequest(envMiddleware)
+  // Set the http client to use for requests, and its environment specific options
+  const defaultRequester = defineRequester(envOptions).observable
 
   const createClient = (config: ClientConfigType) => {
-    const clientRequester = defineHttpRequest(envMiddleware, {
-      ignoreWarnings: config.ignoreWarnings,
-    })
-    return new ClassConstructor(
-      (options, requester) =>
-        (requester || clientRequester)({
-          maxRedirects: 0,
-          maxRetries: config.maxRetries,
-          retryDelay: config.retryDelay,
-          lineage: config.lineage,
-          ...options,
-        } as Any),
-      config,
+    const {observable: clientRequester, promise: clientRequesterPromise} = defineRequester(
+      envOptions,
+      {
+        ignoreWarnings: config.ignoreWarnings,
+        maxRetries: config.maxRetries,
+        retryDelay: config.retryDelay,
+      },
     )
+    // The single transport for the whole client. Resolves a request to its
+    // parsed response body as a Promise; the observable client surface wraps
+    // this in `new Observable(...)` (see `_observe` in dataMethods).
+    // Redirects are surfaced rather than followed unless a request opts in
+    // (via the public `maxRedirects` option, translated in `requestOptions`).
+    const httpRequest: HttpRequest = async (options) => {
+      const event = await clientRequesterPromise({redirect: 'manual', ...options})
+      return event.body
+    }
+    // Populate `requester` on the initialized config so internal paths
+    // (e.g. the asset upload event stream) can reach the underlying transport.
+    // `resolveFetch` is threaded onto the config so request building and
+    // EventSource fetches can reach the environment's fetch without importing
+    // `get-it/node` from a browser-shared module (would leak `undici` into
+    // the browser bundle). A caller-supplied `resolveFetch` wins over the
+    // environment's — that is the supported way to swap the transport (the
+    // test suite injects its mock fetch through it).
+    const resolvedConfig = {
+      ...config,
+      requester: clientRequester,
+      resolveFetch: config.resolveFetch ?? envOptions.resolveFetch,
+    }
+    return new ClassConstructor(httpRequest, resolvedConfig)
   }
 
   return {requester: defaultRequester, createClient}

package/src/http/browserMiddleware.ts

@@ -1 +1,7 @@
-export default []
+import type {EnvironmentOptions} from './request'
+
+const environment: EnvironmentOptions = {
+  middleware: [],
+}
+
+export default environment