@helia/verified-fetch 2.6.4 → 2.6.6

package/src/plugins/plugin-handle-dag-cbor.ts

@@ -2,7 +2,7 @@ import * as ipldDagCbor from '@ipld/dag-cbor'
 import * as ipldDagJson from '@ipld/dag-json'
 import { dagCborToSafeJSON } from '../utils/dag-cbor-to-safe-json.js'
 import { setIpfsRoots } from '../utils/response-headers.js'
-import { notAcceptableResponse, okResponse } from '../utils/responses.js'
+import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { isObjectNode } from '../utils/walk-path.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
@@ -14,7 +14,7 @@ import type { ObjectNode } from 'ipfs-unixfs-exporter'
 export class DagCborPlugin extends BasePlugin {
   readonly codes = [ipldDagCbor.code]
 
-  canHandle ({ cid, accept, pathDetails }: PluginContext): boolean {
+  canHandle ({ cid, accept, pathDetails, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
     if (pathDetails == null) {
       return false
@@ -25,17 +25,18 @@ export class DagCborPlugin extends BasePlugin {
     if (cid.code !== ipldDagCbor.code) {
       return false
     }
+    if (byteRangeContext == null) {
+      return false
+    }
 
     return isObjectNode(pathDetails.terminalElement)
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext' | 'pathDetails'>>): Promise<Response> {
     const { cid, path, resource, accept, pathDetails } = context
 
     this.log.trace('fetching %c/%s', cid, path)
-    if (pathDetails == null) {
-      throw new Error('pathDetails is null')
-    }
+
     const ipfsRoots = pathDetails.ipfsRoots
     const terminalElement = pathDetails.terminalElement as ObjectNode // checked in canHandle fn.
 
@@ -72,7 +73,9 @@ export class DagCborPlugin extends BasePlugin {
       }
     }
 
-    const response = okResponse(resource, body)
+    context.byteRangeContext.setBody(body)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
 
     const responseContentType = accept ?? (body instanceof Uint8Array ? 'application/octet-stream' : 'application/json')
 

package/src/plugins/plugin-handle-dag-pb.ts

@@ -2,7 +2,6 @@ import { unixfs } from '@helia/unixfs'
 import { code as dagPbCode } from '@ipld/dag-pb'
 import { exporter } from 'ipfs-unixfs-exporter'
 import { CustomProgressEvent } from 'progress-events'
-import { ByteRangeContext } from '../utils/byte-range-context.js'
 import { getStreamFromAsyncIterable } from '../utils/get-stream-from-async-iterable.js'
 import { setIpfsRoots } from '../utils/response-headers.js'
 import { badGatewayResponse, badRangeResponse, movedPermanentlyResponse, notSupportedResponse, okRangeResponse } from '../utils/responses.js'
@@ -16,11 +15,14 @@ import type { CIDDetail } from '../index.js'
  */
 export class DagPbPlugin extends BasePlugin {
   readonly codes = [dagPbCode]
-  canHandle ({ cid, accept, pathDetails }: PluginContext): boolean {
+  canHandle ({ cid, accept, pathDetails, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
     if (pathDetails == null) {
       return false
     }
+    if (byteRangeContext == null) {
+      return false
+    }
 
     return cid.code === dagPbCode
   }
@@ -49,7 +51,7 @@ export class DagPbPlugin extends BasePlugin {
     return null
   }
 
-  async handle (context: PluginContext): Promise<Response | null> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext' | 'pathDetails'>>): Promise<Response | null> {
     const { cid, options, withServerTiming = false, pathDetails } = context
     const { handleServerTiming, contentTypeParser, helia, getBlockstore } = this.pluginOptions
     const log = this.log
@@ -57,11 +59,8 @@ export class DagPbPlugin extends BasePlugin {
     let path = context.path
 
     let redirected = false
-    const byteRangeContext = new ByteRangeContext(this.pluginOptions.logger, options?.headers)
 
-    if (pathDetails == null) {
-      throw new TypeError('Path details are required')
-    }
+    const byteRangeContext = context.byteRangeContext
     const ipfsRoots = pathDetails.ipfsRoots
     const terminalElement = pathDetails.terminalElement
     let resolvedCID = terminalElement.cid

package/src/plugins/plugin-handle-dir-index-html.ts

@@ -1,5 +1,6 @@
 import { code as dagPbCode } from '@ipld/dag-pb'
 import { dirIndexHtml } from '../utils/dir-index-html.js'
+import { okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext, VerifiedFetchPluginFactory } from './types.js'
 
@@ -21,29 +22,23 @@ export class DirIndexHtmlPlugin extends BasePlugin {
     return cid.code === dagPbCode
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext' | 'pathDetails' | 'directoryEntries'>>): Promise<Response> {
     const { resource, pathDetails, directoryEntries } = context
 
-    if (pathDetails?.terminalElement == null) {
-      throw new Error('Path details are required')
-    }
-    if (directoryEntries == null || directoryEntries?.length === 0) {
-      throw new Error('Directory entries are required')
-    }
     const terminalElement = pathDetails.terminalElement
 
     const gatewayURL = resource
     const htmlResponse = dirIndexHtml(terminalElement, directoryEntries, { gatewayURL, log: this.log })
 
-    return new Response(htmlResponse, {
-      status: 200,
-      statusText: 'OK',
-      headers: {
-        'Content-Type': 'text/html',
-        // see https://github.com/ipfs/gateway-conformance/pull/219
-        'Cache-Control': 'public, max-age=604800, stale-while-revalidate=2678400'
-      }
-    })
+    context.byteRangeContext.setBody(htmlResponse)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
+
+    response.headers.set('Content-Type', 'text/html')
+    // see https://github.com/ipfs/gateway-conformance/pull/219
+    response.headers.set('Cache-Control', 'public, max-age=604800, stale-while-revalidate=2678400')
+
+    return response
   }
 }
 

package/src/plugins/plugin-handle-ipns-record.ts

@@ -4,7 +4,7 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { getPeerIdFromString } from '../utils/get-peer-id-from-string.js'
-import { badRequestResponse, okResponse } from '../utils/responses.js'
+import { badRequestResponse, okRangeResponse } from '../utils/responses.js'
 import { PluginFatalError } from './errors.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
@@ -16,19 +16,22 @@ import type { PeerId } from '@libp2p/interface'
  */
 export class IpnsRecordPlugin extends BasePlugin {
   readonly codes = []
-  canHandle ({ cid, accept, query }: PluginContext): boolean {
+  canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
+    if (byteRangeContext == null) {
+      return false
+    }
 
     return accept === 'application/vnd.ipfs.ipns-record' || query.format === 'ipns-record'
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
     const { resource, path, options } = context
     const { helia } = this.pluginOptions
     context.reqFormat = 'ipns-record'
     if (path !== '' || !(resource.startsWith('ipns://') || resource.includes('.ipns.') || resource.includes('/ipns/'))) {
       this.log.error('invalid request for IPNS name "%s" and path "%s"', resource, path)
-      throw new PluginFatalError('ERR_INVALID_IPNS_NAME', 'Invalid IPNS name', { response: badRequestResponse(resource, 'Invalid IPNS name') })
+      throw new PluginFatalError('ERR_INVALID_IPNS_NAME', 'Invalid IPNS name', { response: badRequestResponse(resource, new Error('Invalid IPNS name')) })
     }
     let peerId: PeerId
 
@@ -61,7 +64,9 @@ export class IpnsRecordPlugin extends BasePlugin {
     const buf = await helia.datastore.get(datastoreKey, options)
     const record = DHTRecord.deserialize(buf)
 
-    const response = okResponse(resource, record.value)
+    context.byteRangeContext.setBody(record.value)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', 'application/vnd.ipfs.ipns-record')
 
     return response

package/src/plugins/plugin-handle-json.ts

@@ -1,7 +1,7 @@
 import * as ipldDagCbor from '@ipld/dag-cbor'
 import * as ipldDagJson from '@ipld/dag-json'
 import { code as jsonCode } from 'multiformats/codecs/json'
-import { notAcceptableResponse, okResponse } from '../utils/responses.js'
+import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 
@@ -10,8 +10,11 @@ import type { PluginContext } from './types.js'
  */
 export class JsonPlugin extends BasePlugin {
   readonly codes = [ipldDagJson.code, jsonCode]
-  canHandle ({ cid, accept }: PluginContext): boolean {
+  canHandle ({ cid, accept, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
+    if (byteRangeContext == null) {
+      return false
+    }
 
     if (accept === 'application/vnd.ipld.dag-json' && cid.code !== ipldDagCbor.code) {
       // we can handle application/vnd.ipld.dag-json, but if the CID codec is ipldDagCbor, DagCborPlugin should handle it
@@ -22,7 +25,7 @@ export class JsonPlugin extends BasePlugin {
     return ipldDagJson.code === cid.code || jsonCode === cid.code
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
     const { path, resource, cid, accept, options } = context
     const { getBlockstore } = this.pluginOptions
     const session = options?.session ?? true
@@ -50,7 +53,9 @@ export class JsonPlugin extends BasePlugin {
       body = block
     }
 
-    const response = okResponse(resource, body)
+    context.byteRangeContext.setBody(body)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', accept ?? 'application/json')
     return response
   }

package/src/plugins/plugin-handle-raw.ts

@@ -1,6 +1,5 @@
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
-import { ByteRangeContext } from '../utils/byte-range-context.js'
 import { notFoundResponse, okRangeResponse } from '../utils/responses.js'
 import { setContentType } from '../utils/set-content-type.js'
 import { PluginFatalError } from './errors.js'
@@ -46,12 +45,15 @@ function getOverridenRawContentType ({ headers, accept }: { headers?: HeadersIni
 export class RawPlugin extends BasePlugin {
   codes: number[] = [rawCode, identity.code]
 
-  canHandle ({ cid, accept, query }: PluginContext): boolean {
+  canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
+    if (byteRangeContext == null) {
+      return false
+    }
     return accept === 'application/vnd.ipld.raw' || query.format === 'raw'
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
     const { path, resource, cid, accept, query, options } = context
     const { getBlockstore, contentTypeParser } = this.pluginOptions
     const session = options?.session ?? true
@@ -73,12 +75,11 @@ export class RawPlugin extends BasePlugin {
       throw new PluginFatalError('ERR_RAW_PATHS_NOT_SUPPORTED', 'Raw codec does not support paths', { response: notFoundResponse(resource, 'Raw codec does not support paths') })
     }
 
-    const byteRangeContext = new ByteRangeContext(this.pluginOptions.logger, options?.headers)
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, options)
     const result = await blockstore.get(terminalCid, options)
-    byteRangeContext.setBody(result)
-    const response = okRangeResponse(resource, byteRangeContext.getBody(), { byteRangeContext, log }, {
+    context.byteRangeContext.setBody(result)
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log }, {
       redirected: false
     })
 

package/src/plugins/plugin-handle-tar.ts

@@ -3,7 +3,7 @@ import toBrowserReadableStream from 'it-to-browser-readablestream'
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { getETag } from '../utils/get-e-tag.js'
 import { tarStream } from '../utils/get-tar-stream.js'
-import { notAcceptableResponse, okResponse } from '../utils/responses.js'
+import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 
@@ -13,12 +13,15 @@ import type { PluginContext } from './types.js'
  */
 export class TarPlugin extends BasePlugin {
   readonly codes = []
-  canHandle ({ cid, accept, query }: PluginContext): boolean {
+  canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
+    if (byteRangeContext == null) {
+      return false
+    }
     return accept === 'application/x-tar' || query.format === 'tar'
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
     const { cid, path, resource, options, pathDetails } = context
     const { getBlockstore } = this.pluginOptions
 
@@ -34,7 +37,9 @@ export class TarPlugin extends BasePlugin {
     const blockstore = getBlockstore(terminusElement, resource, options?.session, options)
     const stream = toBrowserReadableStream<Uint8Array>(tarStream(`/ipfs/${cid}/${path}`, blockstore, options))
 
-    const response = okResponse(resource, stream)
+    context.byteRangeContext.setBody(stream)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', 'application/x-tar')
 
     response.headers.set('etag', getETag({ cid: terminusElement, reqFormat: context.reqFormat, weak: true }))

package/src/plugins/types.ts

@@ -1,6 +1,7 @@
 import type { PluginError } from './errors.js'
 import type { VerifiedFetchInit } from '../index.js'
 import type { ContentTypeParser, RequestFormatShorthand } from '../types.js'
+import type { ByteRangeContext } from '../utils/byte-range-context.js'
 import type { ParsedUrlStringResults } from '../utils/parse-url-string.js'
 import type { PathWalkerResponse } from '../utils/walk-path.js'
 import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
@@ -12,7 +13,7 @@ import type { CustomProgressEvent } from 'progress-events'
 
 /**
  * Contains common components and functions required by plugins to handle a request.
- * - Read-Only: Plugins can read but shouldn’t rewrite them.
+ * - Read-Only: Plugins can read but shouldn't rewrite them.
  * - Persistent: Relevant even after the request completes (e.g., logging or metrics).
  */
 export interface PluginOptions {
@@ -47,6 +48,14 @@ export interface PluginContext extends ParsedUrlStringResults {
   errors?: PluginError[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
+  query: ParsedUrlStringResults['query']
+  /**
+   * ByteRangeContext contains information about the size of the content and range requests.
+   * This can be used to set the Content-Length header without loading the entire body.
+   *
+   * This is set by the ByteRangeContextPlugin
+   */
+  byteRangeContext?: ByteRangeContext
   [key: string]: unknown
 }
 

package/src/utils/byte-range-context.ts

@@ -107,6 +107,7 @@ export class ByteRangeContext {
       this.log.trace('returning body with byteStart=%o, byteEnd=%o, byteSize=%o', byteStart, byteEnd, byteSize)
       if (body instanceof ReadableStream) {
         // stream should already be spliced by `unixfs.cat`
+        // TODO: if the content is not unixfs and unixfs.cat was not called, we need to slice the body here.
         return body
       }
       return this.getSlicedBody(body)

package/src/utils/parse-url-string.ts

@@ -144,10 +144,12 @@ function dnsLinkLabelDecoder (linkLabel: string): string {
  * A function that parses ipfs:// and ipns:// URLs, returning an object with easily recognizable properties.
  *
  * After determining the protocol successfully, we process the cidOrPeerIdOrDnsLink:
- * * If it's ipfs, it parses the CID or throws an Aggregate error
- * * If it's ipns, it attempts to resolve the PeerId and then the DNSLink. If both fail, an Aggregate error is thrown.
+ * * If it's ipfs, it parses the CID or throws Error[]
+ * * If it's ipns, it attempts to resolve the PeerId and then the DNSLink. If both fail, Error[] is thrown.
  *
  * @todo we need to break out each step of this function (cid parsing, ipns resolving, dnslink resolving) into separate functions and then remove the eslint-disable comment
+ *
+ * @throws {Error[]}
  */
 // eslint-disable-next-line complexity
 export async function parseUrlString ({ urlString, ipns, logger, withServerTiming = false }: ParseUrlStringInput, options?: ParseUrlStringOptions): Promise<ParsedUrlStringResults> {
@@ -185,12 +187,16 @@ export async function parseUrlString ({ urlString, ipns, logger, withServerTimin
         // try resolving as an IPNS name
 
         peerId = getPeerIdFromString(cidOrPeerIdOrDnsLink)
-        if (peerId.publicKey == null) {
+        const pubKey = peerId?.publicKey
+        if (pubKey == null) {
           throw new TypeError('cidOrPeerIdOrDnsLink contains no public key')
         }
 
         if (withServerTiming) {
-          const resolveResultWithServerTiming = await serverTiming('ipns.resolve', `Resolve IPNS name ${cidOrPeerIdOrDnsLink}`, ipns.resolve.bind(null, peerId.publicKey, options))
+          const resolveIpns = async (): Promise<IPNSResolveResult> => {
+            return ipns.resolve(pubKey, options)
+          }
+          const resolveResultWithServerTiming = await serverTiming('ipns.resolve', `Resolve IPNS name ${cidOrPeerIdOrDnsLink}`, resolveIpns)
           serverTimings.push(resolveResultWithServerTiming)
 
           // eslint-disable-next-line max-depth
@@ -199,7 +205,7 @@ export async function parseUrlString ({ urlString, ipns, logger, withServerTimin
           }
           resolveResult = resolveResultWithServerTiming.result
         } else {
-          resolveResult = await ipns.resolve(peerId.publicKey, options)
+          resolveResult = await ipns.resolve(pubKey, options)
         }
         cid = resolveResult?.cid
         resolvedPath = resolveResult?.path
@@ -211,7 +217,7 @@ export async function parseUrlString ({ urlString, ipns, logger, withServerTimin
           errors.push(new TypeError(`Could not parse PeerId in ipns url "${cidOrPeerIdOrDnsLink}", ${(err as Error).message}`))
         } else {
           log.error('could not resolve PeerId %c', peerId, err)
-          errors.push(new TypeError(`Could not resolve PeerId "${cidOrPeerIdOrDnsLink}", ${(err as Error).message}`))
+          errors.push(new TypeError(`Could not resolve PeerId "${cidOrPeerIdOrDnsLink}": ${(err as Error).message}`))
         }
       }
 
@@ -255,7 +261,10 @@ export async function parseUrlString ({ urlString, ipns, logger, withServerTimin
       throw errors[0]
     }
 
-    throw new AggregateError(errors, `Invalid resource. Cannot determine CID from URL "${urlString}"`)
+    errors.push(new Error(`Invalid resource. Cannot determine CID from URL "${urlString}".`))
+
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw errors
   }
 
   let ttl = calculateTtl(resolveResult)

package/src/utils/responses.ts

@@ -98,17 +98,35 @@ export function notFoundResponse (url: string, body?: SupportedBodyTypes, init?:
   return response
 }
 
-/**
- * if body is an Error, it will be converted to a string containing the error message.
- */
-export function badRequestResponse (url: string, body?: SupportedBodyTypes | Error, init?: ResponseInit): Response {
-  if (body instanceof Error) {
-    body = body.message
+function isArrayOfErrors (body: unknown | Error | Error[]): body is Error[] {
+  return Array.isArray(body) && body.every(e => e instanceof Error)
+}
+
+export function badRequestResponse (url: string, errors: Error | Error[], init?: ResponseInit): Response {
+  // stacktrace of the single error, or the stacktrace of the last error in the array
+  let stack: string | undefined
+  let convertedErrors: Array<{ message: string, stack: string }> | undefined
+  if (isArrayOfErrors(errors)) {
+    stack = errors[errors.length - 1].stack
+    convertedErrors = errors.map(e => ({ message: e.message, stack: e.stack ?? '' }))
+  } else if (errors instanceof Error) {
+    stack = errors.stack
+    convertedErrors = [{ message: errors.message, stack: errors.stack ?? '' }]
   }
-  const response = new Response(body, {
-    ...(init ?? {}),
+
+  const bodyJson = JSON.stringify({
+    stack,
+    errors: convertedErrors
+  })
+
+  const response = new Response(bodyJson, {
     status: 400,
-    statusText: 'Bad Request'
+    statusText: 'Bad Request',
+    ...(init ?? {}),
+    headers: {
+      ...(init?.headers ?? {}),
+      'Content-Type': 'application/json'
+    }
   })
 
   setType(response, 'basic')

package/src/verified-fetch.ts

@@ -4,6 +4,7 @@ import { prefixLogger } from '@libp2p/logger'
 import { LRUCache } from 'lru-cache'
 import { type CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
+import { ByteRangeContextPlugin } from './plugins/plugin-handle-byte-range-context.js'
 import { CarPlugin } from './plugins/plugin-handle-car.js'
 import { DagCborPlugin } from './plugins/plugin-handle-dag-cbor.js'
 import { DagPbPlugin } from './plugins/plugin-handle-dag-pb.js'
@@ -90,6 +91,7 @@ export class VerifiedFetch {
 
     const defaultPlugins = [
       new DagWalkPlugin(pluginOptions),
+      new ByteRangeContextPlugin(pluginOptions),
       new IpnsRecordPlugin(pluginOptions),
       new CarPlugin(pluginOptions),
       new RawPlugin(pluginOptions),
@@ -151,13 +153,24 @@ export class VerifiedFetch {
    * Server-Timing header to the response if it has been collected. It should be used for any final processing of the
    * response before it is returned to the user.
    */
-  private handleFinalResponse (response: Response, { query, cid, reqFormat, ttl, protocol, ipfsPath, pathDetails }: Partial<PluginContext> = {}): Response {
+  private handleFinalResponse (response: Response, { query, cid, reqFormat, ttl, protocol, ipfsPath, pathDetails, byteRangeContext }: Partial<PluginContext> = {}): Response {
     if (this.serverTimingHeaders.length > 0) {
       const headerString = this.serverTimingHeaders.join(', ')
       response.headers.set('Server-Timing', headerString)
       this.serverTimingHeaders = []
     }
 
+    // if there are multiple ranges, we should omit the content-length header. see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Transfer-Encoding
+    if (response.headers.get('Transfer-Encoding') !== 'chunked') {
+      if (byteRangeContext != null) {
+        const contentLength = byteRangeContext.length
+        if (contentLength != null) {
+          this.log.trace('Setting Content-Length from byteRangeContext: %d', contentLength)
+          response.headers.set('Content-Length', contentLength.toString())
+        }
+      }
+    }
+
     // set Content-Disposition header
     let contentDisposition: string | undefined