@helia/verified-fetch 3.2.3 → 4.0.0

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

@@ -1,8 +1,4 @@
-import { Record as DHTRecord } from '@libp2p/kad-dht'
-import { Key } from 'interface-datastore'
-import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { marshalIPNSRecord } from 'ipns'
 import { getPeerIdFromString } from '../utils/get-peer-id-from-string.js'
 import { badRequestResponse, okRangeResponse } from '../utils/responses.js'
 import { PluginFatalError } from './errors.js'
@@ -23,17 +19,19 @@ export class IpnsRecordPlugin extends BasePlugin {
       return false
     }
 
-    return accept === 'application/vnd.ipfs.ipns-record' || query.format === 'ipns-record'
+    return accept?.mimeType === 'application/vnd.ipfs.ipns-record' || query.format === 'ipns-record'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
-    const { resource, path, options } = context
-    const { helia } = this.pluginOptions
+    const { resource, path, query, options } = context
+    const { ipnsResolver } = 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, new Error('Invalid IPNS name')) })
     }
+
     let peerId: PeerId
 
     try {
@@ -54,21 +52,20 @@ export class IpnsRecordPlugin extends BasePlugin {
       throw new PluginFatalError('ERR_NO_PEER_ID_FOUND', 'could not parse peer id from url', { response: badRequestResponse(resource, err) })
     }
 
-    // since this call happens after parseResource, we've already resolved the
-    // IPNS name so a local copy should be in the helia datastore, so we can
-    // just read it out..
-    const routingKey = uint8ArrayConcat([
-      uint8ArrayFromString('/ipns/'),
-      peerId.toMultihash().bytes
-    ])
-    const datastoreKey = new Key('/dht/record/' + uint8ArrayToString(routingKey, 'base32'), false)
-    const buf = await helia.datastore.get(datastoreKey, options)
-    const record = DHTRecord.deserialize(buf)
+    // force download in handleFinalResponse
+    query.filename = query.filename ?? `${peerId}.bin`
+    query.download = true
+
+    // @ts-expect-error progress handler types are incompatible
+    const result = await ipnsResolver.resolve(peerId, options)
+    const buf = marshalIPNSRecord(result.record)
 
-    context.byteRangeContext.setBody(record.value)
+    context.byteRangeContext.setBody(buf)
 
     const response = okRangeResponse(resource, context.byteRangeContext.getBody('application/vnd.ipfs.ipns-record'), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', context.byteRangeContext.getContentType() ?? 'application/vnd.ipfs.ipns-record')
+    response.headers.set('content-length', buf.byteLength.toString())
+    response.headers.set('x-ipfs-roots', result.cid.toV1().toString())
 
     return response
   }

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

@@ -1,5 +1,6 @@
 import * as ipldDagCbor from '@ipld/dag-cbor'
 import * as ipldDagJson from '@ipld/dag-json'
+import toBuffer from 'it-to-buffer'
 import { code as jsonCode } from 'multiformats/codecs/json'
 import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
@@ -17,7 +18,7 @@ export class JsonPlugin extends BasePlugin {
       return false
     }
 
-    if (accept === 'application/vnd.ipld.dag-json' && cid.code !== ipldDagCbor.code) {
+    if (accept?.mimeType === '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
       // TODO: remove the need for deny-listing cases in plugins
       return true
@@ -35,10 +36,10 @@ export class JsonPlugin extends BasePlugin {
 
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, options)
-    const block = await blockstore.get(terminalCid, options)
+    const block = await toBuffer(blockstore.get(terminalCid, options))
     let body: string | Uint8Array
 
-    if (accept === 'application/vnd.ipld.dag-cbor' || accept === 'application/cbor') {
+    if (accept?.mimeType === 'application/vnd.ipld.dag-cbor' || accept?.mimeType === 'application/cbor') {
       try {
         // if vnd.ipld.dag-cbor has been specified, convert to the format - note
         // that this supports more data types than regular JSON, the content-type
@@ -62,7 +63,7 @@ export class JsonPlugin extends BasePlugin {
         contentType = 'application/json'
       }
     } else {
-      contentType = accept.split(';')[0]
+      contentType = accept?.mimeType.split(';')[0]
     }
 
     context.byteRangeContext.setBody(body)

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

@@ -1,3 +1,4 @@
+import toBuffer from 'it-to-buffer'
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 import { getContentType } from '../utils/get-content-type.js'
@@ -5,6 +6,7 @@ import { notFoundResponse, okRangeResponse } from '../utils/responses.js'
 import { PluginFatalError } from './errors.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
+import type { AcceptHeader } from '../utils/select-output-type.ts'
 
 /**
  * These are Accept header values that will cause content type sniffing to be
@@ -22,9 +24,9 @@ const RAW_HEADERS = [
  * type. This avoids the user from receiving something different when they
  * signal that they want to `Accept` a specific mime type.
  */
-function getOverriddenRawContentType ({ headers, accept }: { headers?: HeadersInit, accept?: string }): string | undefined {
+function getOverriddenRawContentType ({ headers, accept }: { headers?: HeadersInit, accept?: AcceptHeader }): string | undefined {
   // accept has already been resolved by getResolvedAcceptHeader, if we have it, use it.
-  const acceptHeader = accept ?? new Headers(headers).get('accept') ?? ''
+  const acceptHeader = accept?.mimeType ?? new Headers(headers).get('accept') ?? ''
 
   // e.g. "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8"
   const acceptHeaders = acceptHeader.split(',')
@@ -51,7 +53,7 @@ export class RawPlugin extends BasePlugin {
     if (byteRangeContext == null) {
       return false
     }
-    return accept === 'application/vnd.ipld.raw' || query.format === 'raw'
+    return accept?.mimeType === 'application/vnd.ipld.raw' || query.format === 'raw'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
@@ -60,7 +62,7 @@ export class RawPlugin extends BasePlugin {
     const session = options?.session ?? true
     const log = this.log
 
-    if (accept === 'application/vnd.ipld.raw' || query.format === 'raw') {
+    if (accept?.mimeType === 'application/vnd.ipld.raw' || query.format === 'raw') {
       context.reqFormat = 'raw'
       context.query.download = true
       context.query.filename = context.query.filename ?? `${cid.toString()}.bin`
@@ -78,18 +80,31 @@ export class RawPlugin extends BasePlugin {
 
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, options)
-    const result = await blockstore.get(terminalCid, options)
+    const result = await toBuffer(blockstore.get(terminalCid, options))
     context.byteRangeContext.setBody(result)
 
     // if the user has specified an `Accept` header that corresponds to a raw
     // type, honour that header, so for example they don't request
     // `application/vnd.ipld.raw` but get `application/octet-stream`
-    const contentType = await getContentType({ filename: query.filename, bytes: result, path, defaultContentType: getOverriddenRawContentType({ headers: options?.headers, accept }), contentTypeParser, log })
+    const contentType = await getContentType({
+      filename: query.filename,
+      bytes: result,
+      path,
+      defaultContentType: getOverriddenRawContentType({ headers: options?.headers, accept }),
+      contentTypeParser,
+      log
+    })
     const response = okRangeResponse(resource, context.byteRangeContext.getBody(contentType), { byteRangeContext: context.byteRangeContext, log }, {
       redirected: false
     })
 
     response.headers.set('content-type', context.byteRangeContext.getContentType() ?? contentType)
+    response.headers.set('x-ipfs-roots', terminalCid.toV1().toString())
+
+    // only set content-length if it is not a range request
+    if (!context.byteRangeContext.isRangeRequest) {
+      response.headers.set('content-length', result.byteLength.toString())
+    }
 
     return response
   }

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

@@ -19,7 +19,7 @@ export class TarPlugin extends BasePlugin {
     if (byteRangeContext == null) {
       return false
     }
-    return accept === 'application/x-tar' || query.format === 'tar'
+    return accept?.mimeType === 'application/x-tar' || query.format === 'tar'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {

package/src/plugins/types.ts

@@ -1,9 +1,10 @@
 import type { PluginError } from './errors.js'
-import type { VerifiedFetchInit } from '../index.js'
-import type { ContentTypeParser, RequestFormatShorthand } from '../types.js'
+import type { ResolveURLResult, UrlQuery, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
 import type { ByteRangeContext } from '../utils/byte-range-context.js'
-import type { ParsedUrlStringResults } from '../utils/parse-url-string.js'
+import type { AcceptHeader } from '../utils/select-output-type.ts'
+import type { ServerTiming } from '../utils/server-timing.ts'
 import type { PathWalkerResponse } from '../utils/walk-path.js'
+import type { IPNSResolver } from '@helia/ipns'
 import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Helia } from 'helia'
 import type { Blockstore } from 'interface-blockstore'
@@ -19,9 +20,9 @@ import type { CustomProgressEvent } from 'progress-events'
 export interface PluginOptions {
   logger: ComponentLogger
   getBlockstore(cid: CID, resource: string | CID, useSession?: boolean, options?: AbortOptions): Blockstore
-  handleServerTiming<T>(name: string, description: string, fn: () => Promise<T>, withServerTiming: boolean): Promise<T>
   contentTypeParser?: ContentTypeParser
   helia: Helia
+  ipnsResolver: IPNSResolver
 }
 
 /**
@@ -30,22 +31,22 @@ export interface PluginOptions {
  * - Shared Data: Allows plugins to communicate partial results, discovered data, or interim errors.
  * - Ephemeral: Typically discarded once fetch(...) completes.
  */
-export interface PluginContext extends ParsedUrlStringResults {
+export interface PluginContext extends ResolveURLResult {
   readonly cid: CID
   readonly path: string
   readonly resource: string
-  readonly accept?: string
+  readonly accept?: AcceptHeader
 
   /**
    * An array of plugin IDs that are all enabled. You can use this to check if a plugin is enabled and respond accordingly.
    */
   plugins: string[]
+
   /**
    * The last time the context is modified, so we know whether a plugin has modified it.
    * A plugin should increment this value if it modifies the context.
    */
   modified: number
-  withServerTiming?: boolean
   onProgress?(evt: CustomProgressEvent<any>): void
   options?: Omit<VerifiedFetchInit, 'signal'> & AbortOptions
   isDirectory?: boolean
@@ -53,7 +54,8 @@ export interface PluginContext extends ParsedUrlStringResults {
   errors?: PluginError[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
-  query: ParsedUrlStringResults['query']
+  query: UrlQuery
+
   /**
    * 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.
@@ -61,6 +63,8 @@ export interface PluginContext extends ParsedUrlStringResults {
    * This is set by the ByteRangeContextPlugin
    */
   byteRangeContext?: ByteRangeContext
+  serverTiming: ServerTiming
+  ipfsPath: string
   [key: string]: unknown
 }
 

package/src/url-resolver.ts

@@ -0,0 +1,159 @@
+import { peerIdFromCID, peerIdFromString } from '@libp2p/peer-id'
+import { CID } from 'multiformats/cid'
+import { matchURLString } from './utils/parse-url-string.ts'
+import type { ResolveURLOptions, ResolveURLResult, Resource, URLResolver as URLResolverInterface } from './index.ts'
+import type { ServerTiming } from './utils/server-timing.ts'
+import type { DNSLink } from '@helia/dnslink'
+import type { IPNSResolver } from '@helia/ipns'
+import type { AbortOptions, PeerId } from '@libp2p/interface'
+
+const CODEC_LIBP2P_KEY = 0x72
+
+export interface URLResolverComponents {
+  ipnsResolver: IPNSResolver
+  dnsLink: DNSLink
+  timing: ServerTiming
+}
+
+function toQuery (query?: string): Record<string, any> {
+  if (query == null) {
+    return {}
+  }
+
+  const params = new URLSearchParams(query)
+  const output: Record<string, any> = {}
+
+  for (const [key, value] of params.entries()) {
+    output[key] = value
+
+    if (value === 'true') {
+      output[key] = true
+    }
+
+    if (value === 'false') {
+      output[key] = false
+    }
+  }
+
+  return output
+}
+
+export class URLResolver implements URLResolverInterface {
+  private readonly components: URLResolverComponents
+
+  constructor (components: URLResolverComponents) {
+    this.components = components
+  }
+
+  async resolve (resource: Resource, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    if (typeof resource === 'string') {
+      return this.parseUrlString(resource, options)
+    }
+
+    const cid = CID.asCID(resource)
+
+    if (cid != null) {
+      return this.resolveCIDResource(cid, '', {}, options)
+    }
+
+    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${resource}`)
+  }
+
+  async parseUrlString (urlString: string, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    const { protocol, cidOrPeerIdOrDnsLink, path, query } = matchURLString(urlString)
+
+    if (protocol === 'ipfs') {
+      const cid = CID.parse(cidOrPeerIdOrDnsLink)
+
+      return this.resolveCIDResource(cid, path ?? '', toQuery(query), options)
+    }
+
+    if (protocol === 'ipns') {
+      // try to parse target as peer id
+      let peerId: PeerId
+
+      try {
+        peerId = peerIdFromString(cidOrPeerIdOrDnsLink)
+      } catch {
+        // fall back to DNSLink (e.g. /ipns/example.com)
+        return this.resolveDNSLink(cidOrPeerIdOrDnsLink, path ?? '', toQuery(query), options)
+      }
+
+      // parse multihash from string (e.g. /ipns/QmFoo...)
+      return this.resolveIPNSName(cidOrPeerIdOrDnsLink, peerId, path ?? '', toQuery(query), options)
+    }
+
+    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${urlString}`)
+  }
+
+  async resolveCIDResource (cid: CID, path: string, query: Record<string, any>, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    if (cid.code === CODEC_LIBP2P_KEY) {
+      // special case - peer id encoded as a CID
+      return this.resolveIPNSName(cid.toString(), peerIdFromCID(cid), path, query, options)
+    }
+
+    return {
+      cid,
+      protocol: 'ipfs',
+      query,
+      path,
+      ttl: 29030400, // 1 year for ipfs content
+      ipfsPath: `/ipfs/${cid}${path === '' ? '' : `/${path}`}`
+    }
+  }
+
+  async resolveDNSLink (domain: string, path: string, query: Record<string, any>, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+    const results = await this.components.timing.time('dnsLink.resolve', `Resolve DNSLink ${domain}`, this.components.dnsLink.resolve(domain, options))
+    const result = results?.[0]
+
+    if (result == null) {
+      throw new TypeError(`Invalid resource. Cannot resolve DNSLink from domain: ${domain}`)
+    }
+
+    // dnslink resolved to IPNS name
+    if (result.namespace === 'ipns') {
+      return this.resolveIPNSName(domain, result.peerId, path, query, options)
+    }
+
+    // dnslink resolved to CID
+    if (result.namespace !== 'ipfs') {
+      // @ts-expect-error result namespace should only be ipns or ipfs
+      throw new TypeError(`Invalid resource. Unexpected DNSLink namespace ${result.namespace} from domain: ${domain}`)
+    }
+
+    return {
+      cid: result.cid,
+      path: concatPaths(result.path, path),
+      // dnslink is mutable so return 'ipns' protocol so we do not include immutable in cache-control header
+      protocol: 'ipns',
+      ttl: result.answer.TTL,
+      query,
+      ipfsPath: `/ipns/${domain}${path === '' ? '' : `/${path}`}`
+    }
+  }
+
+  async resolveIPNSName (resource: string, key: PeerId, path: string, query: Record<string, any>, options?: AbortOptions): Promise<ResolveURLResult> {
+    const result = await this.components.timing.time('ipns.resolve', `Resolve IPNS name ${key}`, this.components.ipnsResolver.resolve(key, options))
+
+    return {
+      cid: result.cid,
+      path: concatPaths(result.path, path),
+      query,
+      protocol: 'ipns',
+      // IPNS ttl is in nanoseconds, convert to seconds
+      ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9)),
+      ipfsPath: `/ipns/${resource}${path === '' ? '' : `/${path}`}`
+    }
+  }
+}
+
+function concatPaths (...paths: Array<string | undefined>): string {
+  return `${
+    paths
+      .filter(p => p != null && p !== '')
+      .join('/')
+      .replaceAll(/(\/+)/g, '/')
+      .replace(/^(\/)+/, '')
+      .replace(/(\/)+$/, '/')
+  }`
+}

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

@@ -2,7 +2,7 @@ import toBrowserReadableStream from 'it-to-browser-readablestream'
 import { InvalidRangeError } from '../errors.js'
 import { calculateByteRangeIndexes, getHeader } from './request-headers.js'
 import { getContentRangeHeader } from './response-headers.js'
-import type { SupportedBodyTypes } from '../types.js'
+import type { SupportedBodyTypes } from '../index.js'
 import type { ComponentLogger, Logger } from '@libp2p/interface'
 
 type SliceableBody = Exclude<SupportedBodyTypes, ReadableStream<Uint8Array> | null>

package/src/utils/get-content-type.ts

@@ -1,13 +1,13 @@
 import { defaultMimeType } from './content-type-parser.js'
 import { isPromise } from './type-guards.js'
-import type { ContentTypeParser } from '../types.js'
+import type { ContentTypeParser } from '../index.js'
 import type { Logger } from '@libp2p/interface'
 
 export interface GetContentTypeOptions {
   bytes: Uint8Array
-  path: string
+  path?: string
   defaultContentType?: string
-  contentTypeParser: ContentTypeParser | undefined
+  contentTypeParser?: ContentTypeParser
   log: Logger
 
   /**
@@ -25,7 +25,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
     try {
       let fileName
       if (filenameParam == null) {
-        fileName = path.split('/').pop()?.trim()
+        fileName = path?.split('/').pop()?.trim()
         fileName = (fileName === '' || fileName?.split('.').length === 1) ? undefined : fileName
       } else {
         fileName = filenameParam
@@ -46,6 +46,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
       log.error('error parsing content type', err)
     }
   }
+
   if (contentType === defaultMimeType) {
     // if the content type is the default in our content-type-parser, instead, set it to the default content type provided to this function.
     contentType = defaultContentType

package/src/utils/get-e-tag.ts

@@ -1,4 +1,4 @@
-import type { RequestFormatShorthand } from '../types.js'
+import type { RequestFormatShorthand } from '../index.js'
 import type { CID } from 'multiformats/cid'
 
 interface GetETagArg {

package/src/utils/get-offset-and-length.ts

@@ -0,0 +1,54 @@
+import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
+
+export function getOffsetAndLength (entry: UnixFSEntry, entityBytes?: string): { offset: number, length: number } {
+  if (entityBytes == null) {
+    return {
+      offset: 0,
+      length: Infinity
+    }
+  }
+
+  const parts = entityBytes.split(':')
+  const start = parseInt(parts[0], 10)
+  const end = parts[1] === '*' ? Infinity : parseInt(parts[1], 10)
+
+  if (isNaN(start) || isNaN(end)) {
+    throw new Error('Could not parse entity-bytes')
+  }
+
+  const entrySize = Number(entry.size)
+
+  if (start >= 0) {
+    if (end >= 0) {
+      return {
+        offset: start,
+        length: end - start
+      }
+    } else {
+      return {
+        offset: start,
+        length: (entrySize - start) + end
+      }
+    }
+  }
+
+  // start < 0
+  let offset = entrySize + start
+
+  if (Math.abs(start) > entrySize) {
+    offset = 0
+  }
+
+  if (end >= 0) {
+    return {
+      offset,
+      length: (entrySize - offset) + end
+    }
+  }
+
+  // end < 0
+  return {
+    offset,
+    length: (entrySize - offset) + end
+  }
+}

package/src/utils/get-resolved-accept-header.ts

@@ -1,10 +1,10 @@
 import { isExplicitAcceptHeader, isExplicitFormatQuery, isExplicitIpldAcceptRequest } from './is-accept-explicit.js'
 import { queryFormatToAcceptHeader } from './select-output-type.js'
-import type { ParsedUrlStringResults } from './parse-url-string.js'
+import type { UrlQuery } from '../index.ts'
 import type { ComponentLogger } from '@libp2p/interface'
 
 export interface ResolvedAcceptHeaderOptions {
-  query?: ParsedUrlStringResults['query']
+  query?: UrlQuery
   headers?: RequestInit['headers']
   logger: ComponentLogger
 }

package/src/utils/handle-redirects.ts

@@ -37,19 +37,21 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
   const forwardedHost = headers.get('x-forwarded-host')
   const headerHost = headers.get('host')
   const forwardedFor = headers.get('x-forwarded-for')
+
   if (forwardedFor == null && forwardedHost == null && headerHost == null) {
     log.trace('no redirect info found in headers')
     return null
   }
 
   log.trace('checking for redirect info')
-  // if x-forwarded-host is passed, we need to set the location header to the subdomain
-  // so that the browser can redirect to the correct subdomain
+  // if x-forwarded-host is passed, we need to set the location header to the
+  // subdomain so that the browser can redirect to the correct subdomain
   try {
     const urlParts = matchURLString(resource)
     const reqUrl = new URL(resource)
     const actualHost = forwardedHost ?? reqUrl.host
     const subdomainUrl = new URL(reqUrl)
+
     if (urlParts.protocol === 'ipfs' && cid.version === 0) {
       subdomainUrl.host = `${cid.toV1()}.ipfs.${actualHost}`
     } else {
@@ -65,6 +67,7 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
       log.trace('host header is not the same as the subdomain url host, not setting location header')
       return null
     }
+
     if (reqUrl.host === subdomainUrl.host) {
       log.trace('req url is the same as the subdomain url, not setting location header')
       return null
@@ -75,6 +78,7 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
     const pathUrl = new URL(reqUrl, `${reqUrl.protocol}//${actualHost}`)
     pathUrl.pathname = maybeAddTrailingSlash(reqUrl.pathname)
     log.trace('path url %s', pathUrl.href)
+
     // try to query subdomain with HEAD request to see if it's supported
     try {
       const subdomainTest = await fetch(subdomainUrl, { method: 'HEAD' })
@@ -86,11 +90,14 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
         throw new SubdomainNotSupportedError('subdomain not supported')
       }
     } catch (err: any) {
-      log('subdomain not supported', err)
+      log('subdomain not supported - %e', err)
+
       if (pathUrl.href === reqUrl.href) {
         log('path url is the same as the request url, not setting location header')
+
         return null
       }
+
       // pathUrl is different from request URL (maybe even with just a trailing slash)
       return movedPermanentlyResponse(resource.toString(), pathUrl.href)
     }

package/src/utils/ipfs-path-to-string.ts

@@ -0,0 +1,9 @@
+/**
+ * Joins an array of strings as an IPFS path and URI encodes individual
+ * components
+ */
+export function uriEncodeIPFSPath (str: string): string {
+  return str.split('/')
+    .map(p => encodeURIComponent(p))
+    .join('/')
+}

package/src/utils/is-accept-explicit.ts

@@ -1,29 +1,36 @@
 import { FORMAT_TO_MIME_TYPE } from './select-output-type.js'
-import type { ParsedUrlStringResults } from './parse-url-string.js'
+import type { UrlQuery } from '../index.ts'
 
 export interface IsAcceptExplicitOptions {
-  query?: ParsedUrlStringResults['query']
+  query?: UrlQuery
   headers: Headers
 }
 
 export function isExplicitAcceptHeader (headers: Headers): boolean {
   const incomingAcceptHeader = headers.get('accept')
-  if (incomingAcceptHeader != null && Object.values(FORMAT_TO_MIME_TYPE).includes(incomingAcceptHeader)) {
-    return true
+
+  if (incomingAcceptHeader == null) {
+    return false
   }
-  return false
+
+  return Object.values(FORMAT_TO_MIME_TYPE)
+    .some(mimeType => incomingAcceptHeader.includes(mimeType))
 }
 
-export function isExplicitFormatQuery (query?: ParsedUrlStringResults['query']): boolean {
+export function isExplicitFormatQuery (query?: UrlQuery): boolean {
   const formatQuery = query?.format
+
   if (formatQuery != null && Object.keys(FORMAT_TO_MIME_TYPE).includes(formatQuery)) {
     return true
   }
+
   return false
 }
 
 /**
- * The user can provide an explicit `accept` header in the request headers or a `format` query parameter in the URL.
+ * The user can provide an explicit `accept` header in the request headers or a
+ * `format` query parameter in the URL.
+ *
  * If either of these are provided, this function returns true.
  */
 export function isExplicitIpldAcceptRequest ({ query, headers }: IsAcceptExplicitOptions): boolean {