@gentleduck/upload 0.2.5 → 0.3.0

package/src/core/contracts/contracts.types.ts

@@ -0,0 +1,373 @@
+/**
+ * Public contract types grouped under the `Contracts` namespace.
+ *
+ * Each sub-namespace owns one concern (Intent, Cursor, Result, Validation,
+ * Fingerprint, Errors, Strategy, BackendApi).
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+export namespace Contracts {
+  export namespace Intent {
+    /** Base shape for all upload intents. */
+    export type Base<K extends string = string> = {
+      /** Strategy name (discriminant). */
+      strategy: K
+      /** Unique backend file identifier. */
+      fileId: string
+    }
+
+    /** Registry of intent types mapped by strategy name. */
+    export type Map = Record<string, Base<string>>
+
+    /** Union of strategy keys for an intent map. */
+    export type StrategyKey<M extends Map> = keyof M & string
+
+    /** Union of all intent variants for an intent map. */
+    export type Any<M extends Map> = M[StrategyKey<M>]
+  }
+
+  export namespace Cursor {
+    /** Registry of cursor payload types mapped by strategy name. */
+    export type Map<M extends Intent.Map> = Partial<Record<Intent.StrategyKey<M>, unknown>>
+
+    /** Discriminated union of all cursor variants. */
+    export type Any<C extends Record<string, unknown>> = {
+      [K in keyof C & string]: {
+        /** Strategy name associated with this cursor. */
+        strategy: K
+        /** The custom strategy-defined state needed to resume the upload. */
+        value?: C[K] | undefined
+      }
+    }[keyof C & string]
+  }
+
+  export namespace Result {
+    /** Successful upload payload returned by your backend API's complete endpoint. */
+    export type Base = {
+      /** Unique backend file identifier. */
+      fileId: string
+      /** Storage key/path or public address of the uploaded file. */
+      key: string
+    }
+  }
+
+  export namespace Validation {
+    /** Why a file was rejected during client-side validation. */
+    export type Rejection =
+      | { code: 'empty_file' }
+      | { code: 'file_too_large'; maxBytes: number; size: number }
+      | { code: 'type_not_allowed'; allowed: string[]; got: string }
+      | { code: 'too_many_files'; max: number }
+      | { code: 'mime_mismatch'; claimed: string; sniffed: string }
+      | { code: 'filename_rejected'; reason: 'reserved' | 'too-long' | 'empty' | 'path-sep' }
+  }
+
+  /** Deterministic identity signature of a file on the client. */
+  export type FingerprintFile = {
+    /** Base name of the file (excluding directory path). */
+    name: string
+    /** Size of the file in bytes. */
+    size: number
+    /** MIME type of the file. */
+    type: string
+    /** Timestamp when the file was last modified on disk (milliseconds since epoch). */
+    lastModified: number
+    /** Optional pre-computed checksum of the file (e.g. SHA-256 hex). */
+    checksum?: string | undefined
+  }
+
+  export namespace Errors {
+    /** Base schema for upload-related runtime errors. */
+    export type Base = {
+      /** Stable machine-readable error classification. */
+      code: string
+      /** Human-friendly message suitable for presentation in standard warning elements. */
+      message: string
+      /** Original thrown error or reason context if available. */
+      cause?: unknown
+      /** Flag specifying whether the error recovery system should schedule retries. */
+      retryable?: boolean
+    }
+
+    /** Discriminant union of built-in engine failure structures. */
+    export type BuiltIn =
+      | { code: 'validation_failed'; message: string; reason: Validation.Rejection; retryable?: false }
+      | { code: 'strategy_missing'; message: string; strategy: string; retryable?: false }
+      | { code: 'aborted'; message: string; reason: 'pause' | 'cancel' | 'unknown'; cause?: unknown; retryable?: false }
+      | { code: 'network'; message: string; cause?: unknown; retryable?: boolean }
+      | { code: 'http'; message: string; status: number; statusText?: string; cause?: unknown; retryable?: boolean }
+      | { code: 'timeout'; message: string; cause?: unknown; retryable?: boolean }
+      | { code: 'auth'; message: string; cause?: unknown; retryable?: false }
+      | { code: 'rate_limit'; message: string; retryAfterMs?: number; cause?: unknown; retryable?: boolean }
+      | { code: 'server'; message: string; serverCode?: string; cause?: unknown; retryable?: boolean }
+      | { code: 'unknown'; message: string; cause?: unknown; retryable?: boolean }
+
+    /** The canonical error shape handled by the engine, plugins, and handlers. */
+    export type Error = BuiltIn | (Base & Record<string, unknown>)
+  }
+
+  /** Validation rules applied to files on registration before intents are initiated. */
+  export type ValidationRules = {
+    /** Maximum number of files permitted in a single upload batch. */
+    maxFiles?: number
+    /** Maximum size in bytes allowed for a single file. */
+    maxSizeBytes?: number
+    /** Minimum size in bytes allowed for a single file. */
+    minSizeBytes?: number
+    /** White-list of allowed MIME types (e.g. `["image/png", "application/pdf"]`). */
+    allowedTypes?: string[]
+    /** White-list of allowed file extension strings (e.g. `["png", "pdf"]`). */
+    allowedExtensions?: string[]
+  }
+
+  /**
+   * Safe, cause-stripped error summary stored in step history and forwarded in API context.
+   * The raw `cause` field is omitted because it may contain sensitive server response bodies.
+   */
+  export type StepError = {
+    code: string
+    message: string
+    retryable?: boolean
+  }
+
+  /** A single recorded phase transition on an upload item. */
+  export type UploadStep = {
+    /** Phase name when this step was entered. */
+    phase: string
+    /** Epoch ms when this phase was entered. */
+    enteredAt: number
+    /** Epoch ms when this phase was left. Undefined while still in this phase. */
+    leftAt?: number
+    /** Attempt number at the time of entering this phase. */
+    attempt: number
+    /** Safe error summary if this phase ended in failure. Cause is stripped. */
+    error?: StepError | undefined
+  }
+
+  export namespace Api {
+    /** Context passed to every backend API method alongside the call-specific args. */
+    export type Context<P extends string = string, M extends Intent.Map = Intent.Map> = {
+      /** Client-side identifier for this file item. */
+      localId: string
+      /** Upload purpose. */
+      purpose: P
+      /** File identity: name, size, MIME type, checksum. Always present. */
+      fingerprint: FingerprintFile
+      /** Which attempt this is, starting at 1. Increments on retry. */
+      attempt: number
+      /** Epoch ms when this item was registered. */
+      createdAt: number
+      /** Phase history up to this call. Errors have cause stripped. */
+      steps: readonly UploadStep[]
+      /** Caller-supplied metadata from the addFiles command. Never persisted. */
+      meta: Record<string, unknown>
+      /** Safe error from the most recent failed step, if any. */
+      lastError?: StepError | undefined
+      /** Browser File object. Present in most phases; absent when file is not loaded. */
+      file?: File | undefined
+      /** Upload intent from the backend. Present after createIntent succeeds. */
+      intent?: Intent.Any<M> | undefined
+      /** Cancellation signal. */
+      signal?: AbortSignal | undefined
+    }
+
+    /** Context for API calls where intent is not yet created but file is loaded (e.g. createIntent) */
+    export type CreateIntentContext<P extends string, M extends Intent.Map> = Context<P, M> &
+      Required<Pick<Context<P, M>, 'file' | 'signal'>>
+
+    /** Context for API calls verifying file checksum (e.g. findByChecksum) */
+    export type FindByChecksumContext<P extends string, M extends Intent.Map> = Context<P, M> &
+      Required<Pick<Context<P, M>, 'file'>>
+
+    /** Context for API calls executing during/after upload where intent is active (e.g. complete, signPart, completeMultipart) */
+    export type CompleteContext<P extends string, M extends Intent.Map> = Context<P, M> &
+      Required<Pick<Context<P, M>, 'file' | 'intent' | 'signal'>>
+
+    /** Context for API abort calls where intent is active but file/signal might be absent (e.g. abort) */
+    export type AbortContext<P extends string, M extends Intent.Map> = Context<P, M> &
+      Required<Pick<Context<P, M>, 'intent'>>
+
+    /** Contract definition for your backend API endpoints. */
+    export type Me<M extends Intent.Map, P extends string, R extends Result.Base = Result.Base> = {
+      /** Requests an upload intent from the server. */
+      createIntent(
+        args: {
+          purpose: P
+          contentType: string
+          size: number
+          filename: string
+          checksum?: string
+          attempt: number
+        },
+        ctx: CreateIntentContext<P, M>,
+        ...extra: any[]
+      ): Promise<M[keyof M]>
+
+      /** Finalizes the upload on the server after bytes have been transferred. */
+      complete(
+        args: {
+          fileId: string
+          /** Sanitized filename. Do not use the raw File.name from the browser. */
+          filename: string
+          contentType: string
+          size: number
+          checksum?: string
+          attempt: number
+        },
+        ctx: CompleteContext<P, M>,
+        ...extra: any[]
+      ): Promise<R>
+
+      /** Optional endpoint to fetch a signed preview/access URL for completed resources. */
+      getSignedPreviewUrl?(
+        args: { fileId: string; key: string; purpose: P },
+        ctx: Context<P, M>,
+        ...extra: any[]
+      ): Promise<string>
+
+      /** Optional endpoint to verify if the file has already been uploaded previously. */
+      findByChecksum?(
+        args: { checksum: string; purpose: P },
+        ctx: FindByChecksumContext<P, M>,
+        ...extra: any[]
+      ): Promise<R | null>
+
+      /** Multipart-specific backend commands. Required if using the multipart strategy. */
+      multipart?: {
+        signPart(
+          args: {
+            fileId: string
+            uploadId: string
+            partNumber: number
+            checksum?: string
+            attempt: number
+          },
+          ctx: CompleteContext<P, M>,
+          ...extra: any[]
+        ): Promise<{
+          url: string
+          headers?: Record<string, string>
+        }>
+
+        completeMultipart(
+          args: {
+            fileId: string
+            uploadId: string
+            parts: Array<{ partNumber: number; etag: string }>
+          },
+          ctx: CompleteContext<P, M>,
+          ...extra: any[]
+        ): Promise<unknown>
+
+        listParts?(
+          args: { fileId: string; uploadId: string },
+          ctx: CompleteContext<P, M>,
+          ...extra: any[]
+        ): Promise<Array<{ partNumber: number; etag?: string; size?: number }>>
+
+        abort?(args: { fileId: string; uploadId: string }, ctx: AbortContext<P, M>, ...extra: any[]): Promise<void>
+      }
+
+      /** TUS resumable protocol operations. */
+      tus?: {
+        create(
+          args: { fileId: string; size: number; filename: string; contentType: string; attempt: number },
+          ctx: CompleteContext<P, M>,
+          ...extra: any[]
+        ): Promise<{ uploadUrl: string }>
+
+        getOffset(args: { uploadUrl: string }, ctx: CompleteContext<P, M>, ...extra: any[]): Promise<{ offset: number }>
+      }
+    }
+  }
+
+  export namespace Strategy {
+    /** Per-call context handed to a strategy's `start()` method. */
+    export type Ctx<
+      M extends Intent.Map,
+      C extends Cursor.Map<M>,
+      P extends string,
+      R extends Result.Base,
+      K extends keyof M & string,
+    > = {
+      localId: string
+      purpose: P
+      file: File
+      fingerprint: FingerprintFile
+      intent: M[K]
+      signal: AbortSignal
+      attempt: number
+      createdAt: number
+      steps: readonly UploadStep[]
+      lastError?: StepError | undefined
+      meta: Record<string, unknown>
+      transport: {
+        put(args: {
+          url: string
+          body: Blob
+          headers?: Record<string, string>
+          signal: AbortSignal
+          onProgress?: (u: number, t: number) => void
+        }): Promise<{ etag?: string | undefined; headers?: Record<string, string> }>
+
+        postForm(args: {
+          url: string
+          fields: Record<string, string>
+          file: File | Blob
+          filename?: string
+          signal: AbortSignal
+          onProgress?: (uploadedBytes: number, totalBytes: number) => void
+        }): Promise<{ etag?: string; headers?: Record<string, string> }>
+
+        patch(args: {
+          url: string
+          body: Blob | ArrayBuffer
+          headers?: Record<string, string>
+          signal: AbortSignal
+          onProgress?: (u: number, t: number) => void
+        }): Promise<{ headers?: Record<string, string> }>
+
+        get?(args: {
+          url: string
+          headers?: Record<string, string>
+          signal: AbortSignal
+          onProgress?: (loaded: number, total: number) => void
+        }): Promise<{ blob: Blob; status: number; headers?: Record<string, string> }>
+
+        head?(args: {
+          url: string
+          headers?: Record<string, string>
+          signal: AbortSignal
+        }): Promise<{ status: number; headers: Record<string, string> }>
+      }
+      api: Api.Me<M, P, R>
+      reportProgress: (p: { uploadedBytes: number; totalBytes: number }) => void
+      readCursor: () => C[K] | undefined
+      persistCursor: (cursor: C[K] | undefined) => void
+    }
+
+    /** A single upload strategy implementation. */
+    export type Me<
+      M extends Intent.Map,
+      C extends Cursor.Map<M>,
+      P extends string,
+      R extends Result.Base,
+      K extends keyof M & string,
+    > = {
+      id: K
+      resumable: boolean
+      start(ctx: Ctx<M, C, P, R, K>): Promise<void>
+    }
+
+    /** Registry of available upload strategies, keyed by strategy id. */
+    export type Registry<
+      M extends Intent.Map,
+      C extends Cursor.Map<M>,
+      P extends string = string,
+      R extends Result.Base = Result.Base,
+    > = {
+      get<K extends keyof M & string>(id: K): Me<M, C, P, R, K> | undefined
+      has(id: string): id is keyof M & string
+      set<K extends keyof M & string>(strategy: Me<M, C, P, R, K>): void
+    }
+  }
+}

package/src/core/contracts/index.ts

@@ -1,8 +1,3 @@
-export * from './backendApi'
-export * from './cursor.types'
-export * from './errors.types'
-export * from './fingerprint.types'
-export * from './intent.types'
-export * from './result.types'
-export * from './strategy.types'
-export * from './transport'
+export type { Contracts } from './contracts.types'
+export type { Transport } from './transport'
+export { createFetchTransport, createXHRTransport } from './transport'

package/src/core/contracts/transport/index.ts

@@ -1,2 +1,3 @@
-export * from './transport'
-export * from './transport.types'
+export { createXHRTransport } from './transport'
+export { createFetchTransport } from './transport.fetch'
+export type { Transport } from './transport.types'

package/src/core/contracts/transport/transport.fetch.ts

@@ -0,0 +1,203 @@
+import { abortReason, makeAbortError } from './transport.libs'
+import type { Transport } from './transport.types'
+
+/**
+ * `fetch`-based transport for non-browser runtimes (Node, edge, workers, SSR)
+ * and any environment without `XMLHttpRequest`.
+ *
+ * Trade-off vs {@link createXHRTransport}: `fetch` has no portable upload
+ * progress API, so `put`/`postForm`/`patch` report a single terminal
+ * `onProgress(total, total)` on success rather than incremental bytes. Download
+ * (`get`) streams the response body, so its progress is real and incremental.
+ *
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+
+function isAbsoluteHttpUrl(url: string): boolean {
+  return /^https?:\/\//i.test(url)
+}
+
+/** Read a single-quotes-stripped ETag from response headers. */
+function readEtag(headers: Headers): string | undefined {
+  const raw = headers.get('etag') ?? headers.get('ETag')
+  if (!raw) return undefined
+  return raw.replace(/"/g, '')
+}
+
+/** Collect response headers into a lowercase-keyed record. */
+function headersToRecord(headers: Headers): Record<string, string> {
+  const out: Record<string, string> = {}
+  headers.forEach((value, key) => {
+    out[key.toLowerCase()] = value
+  })
+  return out
+}
+
+async function fetchRequest(args: {
+  method: 'POST' | 'PUT' | 'PATCH'
+  url: string
+  body: BodyInit
+  signal: AbortSignal
+  headers?: Record<string, string> | undefined
+  onProgress?: ((loaded: number, total: number) => void) | undefined
+  byteLength: number
+}): Promise<{ headers: Record<string, string>; etag?: string | undefined }> {
+  if (!args.url || !isAbsoluteHttpUrl(args.url)) {
+    throw new Error(`UploadTransport(fetch): expected absolute URL, got: ${String(args.url)}`)
+  }
+  if (args.signal.aborted) {
+    throw makeAbortError(abortReason(args.signal))
+  }
+
+  const init: RequestInit = { method: args.method, body: args.body, signal: args.signal }
+  if (args.headers) init.headers = args.headers
+
+  let res: Response
+  try {
+    res = await fetch(args.url, init)
+  } catch (err) {
+    if (args.signal.aborted || (err instanceof Error && err.name === 'AbortError')) {
+      throw makeAbortError(abortReason(args.signal))
+    }
+    throw err instanceof Error ? err : new Error(String(err))
+  }
+
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(`Upload failed with status ${res.status}`)
+  }
+
+  // fetch cannot report streamed upload progress portably; emit a single
+  // terminal tick so consumers can settle their progress bars.
+  args.onProgress?.(args.byteLength, args.byteLength)
+
+  return { headers: headersToRecord(res.headers), etag: readEtag(res.headers) }
+}
+
+/**
+ * Create a `fetch`-backed {@link Transport.Options} implementation.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+export function createFetchTransport(): Transport.Options {
+  return {
+    async postForm(args) {
+      const form = new FormData()
+      for (const [k, v] of Object.entries(args.fields)) form.append(k, v)
+      form.append('file', args.file, args.filename ?? 'file')
+
+      const out = await fetchRequest({
+        method: 'POST',
+        url: args.url,
+        body: form,
+        signal: args.signal,
+        byteLength: args.file.size,
+        onProgress: args.onProgress,
+      })
+      return out.etag !== undefined ? { headers: out.headers, etag: out.etag } : { headers: out.headers }
+    },
+
+    async put(args) {
+      const out = await fetchRequest({
+        method: 'PUT',
+        url: args.url,
+        body: args.body,
+        signal: args.signal,
+        headers: args.headers ?? {},
+        byteLength: args.body.size,
+        onProgress: args.onProgress,
+      })
+      return { headers: out.headers, etag: out.etag }
+    },
+
+    async patch(args) {
+      const body = args.body instanceof Blob ? args.body : new Blob([args.body])
+      const out = await fetchRequest({
+        method: 'PATCH',
+        url: args.url,
+        body,
+        signal: args.signal,
+        headers: args.headers ?? {},
+        byteLength: body.size,
+        onProgress: args.onProgress,
+      })
+      return { headers: out.headers }
+    },
+
+    async get(args) {
+      if (!args.url || !isAbsoluteHttpUrl(args.url)) {
+        throw new Error(`UploadTransport(fetch): expected absolute URL, got: ${String(args.url)}`)
+      }
+      if (args.signal.aborted) {
+        throw makeAbortError(abortReason(args.signal))
+      }
+
+      const init: RequestInit = { method: 'GET', signal: args.signal }
+      if (args.headers) init.headers = args.headers
+
+      let res: Response
+      try {
+        res = await fetch(args.url, init)
+      } catch (err) {
+        if (args.signal.aborted || (err instanceof Error && err.name === 'AbortError')) {
+          throw makeAbortError(abortReason(args.signal))
+        }
+        throw err instanceof Error ? err : new Error(String(err))
+      }
+
+      if (res.status < 200 || res.status >= 300) {
+        throw new Error(`Download failed with status ${res.status}`)
+      }
+
+      const headers = headersToRecord(res.headers)
+      const total = Number(res.headers.get('content-length')) || 0
+
+      // Stream when possible for incremental progress; otherwise fall back to a
+      // buffered read.
+      if (res.body && typeof res.body.getReader === 'function') {
+        const reader = res.body.getReader()
+        const chunks: Uint8Array[] = []
+        let loaded = 0
+        for (;;) {
+          const { done, value } = await reader.read()
+          if (done) break
+          if (value) {
+            chunks.push(value)
+            loaded += value.byteLength
+            args.onProgress?.(loaded, total || loaded)
+          }
+        }
+        const blob = new Blob(chunks as BlobPart[], {
+          type: res.headers.get('content-type') ?? 'application/octet-stream',
+        })
+        return { blob, status: res.status, headers }
+      }
+
+      const blob = await res.blob()
+      args.onProgress?.(blob.size, total || blob.size)
+      return { blob, status: res.status, headers }
+    },
+
+    async head(args) {
+      if (!args.url || !isAbsoluteHttpUrl(args.url)) {
+        throw new Error(`UploadTransport(fetch): expected absolute URL, got: ${String(args.url)}`)
+      }
+      if (args.signal.aborted) {
+        throw makeAbortError(abortReason(args.signal))
+      }
+
+      const init: RequestInit = { method: 'HEAD', signal: args.signal }
+      if (args.headers) init.headers = args.headers
+
+      let res: Response
+      try {
+        res = await fetch(args.url, init)
+      } catch (err) {
+        if (args.signal.aborted || (err instanceof Error && err.name === 'AbortError')) {
+          throw makeAbortError(abortReason(args.signal))
+        }
+        throw err instanceof Error ? err : new Error(String(err))
+      }
+
+      return { status: res.status, headers: headersToRecord(res.headers) }
+    },
+  }
+}

package/src/core/contracts/transport/transport.libs.ts

@@ -1,44 +1,40 @@
 import { isRecord } from '../../utils/guards'
 
-// ============================================================================
-// ABORT HANDLING UTILITIES
-// ============================================================================
-
 export function abortReason(signal?: AbortSignal): unknown {
   return signal?.reason
 }
 
+/**
+ * Map `controller.abort(reason)` payloads to `'pause' | 'cancel'`. Accepts a
+ * bare string, `{ reason }`, or `{ kind }` shape.
+ */
 export function normalizeAbortReason(r: unknown): 'pause' | 'cancel' | 'unknown' {
   if (!r) return 'unknown'
 
-  // Direct string match
   if (typeof r === 'string') {
     if (r === 'pause' || r === 'cancel') return r
     return 'unknown'
   }
 
-  // Object with 'reason' property (from controller.abort({ reason: 'pause' }))
   if (isRecord(r) && 'reason' in r) {
-    const v = r.reason
+    const v = r['reason']
     if (v === 'pause' || v === 'cancel') return v
   }
 
-  // Object with 'kind' property (alternative format)
   if (isRecord(r) && 'kind' in r) {
-    const v = r.kind
+    const v = r['kind']
     if (v === 'pause' || v === 'cancel') return v
   }
 
   return 'unknown'
 }
 
-export class UploadAbortError extends Error {
-  readonly code: 'aborted' = 'aborted'
-  reason: 'pause' | 'cancel' | 'unknown'
+import { UploadAbortError as CentralAbortError } from '../../errors'
 
+export class UploadAbortError extends CentralAbortError {
   constructor(reason: unknown) {
-    super('Upload aborted')
-    this.reason = normalizeAbortReason(reason)
+    const normalized = normalizeAbortReason(reason)
+    super(normalized)
   }
 }
 
@@ -46,20 +42,9 @@ export function makeAbortError(reason: unknown): UploadAbortError {
   return new UploadAbortError(reason)
 }
 
-// ============================================================================
-// ERROR HANDLING HELPERS
-// ============================================================================
-
-/**
- * Creates an error for network failures, including CORS detection.
- *
- * @param xhr - XMLHttpRequest instance to check status
- * @param defaultMessage - Default error message if status is non-zero
- *
- * @returns {Error} Appropriate error message based on XHR status
- */
+/** XHR network error with `status === 0` heuristic for CORS detection. */
 export function createNetworkError(xhr: XMLHttpRequest, defaultMessage: string): Error {
-  // Status 0 typically indicates CORS failure or network error
+  // status 0 -> CORS failure or transport-level network error.
   if (xhr.status === 0) {
     return new Error(
       'CORS error: The upload server does not allow requests from this origin. Please check CORS configuration.',
@@ -68,18 +53,7 @@ export function createNetworkError(xhr: XMLHttpRequest, defaultMessage: string):
   return new Error(`${defaultMessage} (status: ${xhr.status})`)
 }
 
-// ============================================================================
-// RESPONSE PARSING
-// ============================================================================
-
-/**
- * Parses XHR response headers into a key-value object.
- * Headers are normalized to lowercase keys.
- *
- * @param xhr - XMLHttpRequest instance
- *
- * @returns {Record<string, string>} Parsed headers object
- */
+/** Parse XHR headers into a lowercase-keyed record. */
 export function parseHeaders(xhr: XMLHttpRequest): Record<string, string> {
   const headers: Record<string, string> = {}
   const headerStr = xhr.getAllResponseHeaders()