@helia/verified-fetch 3.2.3 → 4.0.1

package/src/index.ts

@@ -641,13 +641,13 @@
  *   Inspects the current `PluginContext` (which includes the CID, path, query, accept header, etc.)
  *   and returns `true` if the plugin can operate on the current state of the request.
  *
- * - **`handle(context: PluginContext): Promise<Response | null>`**
- *   Performs the plugin’s work. It may:
- *     - **Return a final `Response`**: This stops the pipeline immediately.
- *     - **Return `null`**: This indicates that the plugin has only partially processed the request
- *       (for example, by performing path walking or decoding) and the pipeline should continue.
- *    - **Throw a `PluginError`**: This logs a non-fatal error and continues the pipeline.
- *    - **Throw a `PluginFatalError`**: This logs a fatal error and stops the pipeline immediately.
+ * - **`handle(context: PluginContext): Promise<Response | undefined>`**
+ *   Performs the plugin’s work. It will only be executed if `canHandle` previously returned `true`.
+ *   It may:
+ *   - **Return a `Response`**: This stops the pipeline immediately and returns the response.
+ *   - **Return `undefined`**: This indicates that the plugin has only partially processed the request
+ *     (for example, by performing path walking or decoding) and the pipeline should continue.
+ *   - **Throw an `Error`**: An Internal Server Error will be returned
  *
  * ### Plugin Pipeline
  *
@@ -745,12 +745,12 @@
  *      canHandle(context: PluginContext): boolean {
  *        // Only handle requests if the Accept header matches your custom type
  *        // Or check context for pathDetails, custom values, etc...
- *        return context.accept === 'application/vnd.my-custom-type'
+ *        return context.accept?.mimeType === 'application/vnd.my-custom-type'
  *      }
  *
  *      async handle(context: PluginContext): Promise<Response | null> {
  *        // Perform any partial processing here, e.g., modify the context:
- *        context.customProcessed = true;
+ *        context.customProcessed = true
  *
  *        // If you are ready to finalize the response:
  *        return new Response('Hello, world!', {
@@ -758,7 +758,7 @@
  *          headers: {
  *            'Content-Type': 'text/plain'
  *          }
- *        });
+ *        })
  *
  *        // Or, if further processing is needed by another plugin, simply return null.
  *      }
@@ -784,47 +784,6 @@
  *    const fetch = await createVerifiedFetch(helia, { plugins })
  *    ```
  *
- * ---
- *
- * ### Error Handling in the Plugin Pipeline
- *
- * Verified‑Fetch distinguishes between two types of errors thrown by plugins:
- *
- * - **PluginError (Non‑Fatal):**
- *   - Use this when your plugin encounters an issue that should be logged but does not prevent the pipeline
- *     from continuing.
- *   - When a plugin throws a `PluginError`, the error is logged and the pipeline continues with the next plugin.
- *
- * - **PluginFatalError (Fatal):**
- *   - Use this when a critical error occurs that should immediately abort the request.
- *   - When a plugin throws a `PluginFatalError`, the pipeline immediately terminates and the provided error
- *     response is returned.
- *
- * @example Plugin error Handling
- *
- * ```typescript
- * import { PluginError, PluginFatalError } from '@helia/verified-fetch'
- *
- * // async handle(context: PluginContext): Promise<Response | null> {
- * const recoverable = Math.random() > 0.5 // Use more sophisticated logic here ;)
- * if (recoverable === true) {
- *   throw new PluginError('MY_CUSTOM_WARNING', 'A non‑fatal issue occurred', {
- *     details: {
- *       someKey: 'Additional details here'
- *     }
- *   });
- * }
- *
- * if (recoverable === false) {
- *   throw new PluginFatalError('MY_CUSTOM_FATAL', 'A critical error occurred', {
- *     response: new Response('Something happened', { status: 500 })  // Required: supply your own error response
- *   });
- * }
- *
- *   // Otherwise, continue processing...
- * // }
- * ```
- *
  * ### How the Plugin Pipeline Works
  *
  * - **Shared Context:**
@@ -842,8 +801,7 @@
  *   This means you do not have to specify a rigid order, each plugin simply checks the context and acts if appropriate.
  *
  * - **Error Handling:**
- *   - A thrown `PluginError` is considered non‑fatal and is logged, allowing the pipeline to continue.
- *   - A thrown `PluginFatalError` immediately stops the pipeline and returns the error response.
+ *   - Any thrown error immediately stops the pipeline and returns the error response.
  *
  * For a detailed explanation of the pipeline, please refer to the discussion in [Issue #167](https://github.com/ipfs/helia-verified-fetch/issues/167).
  */
@@ -857,10 +815,10 @@ import { createLibp2p } from 'libp2p'
 import { getLibp2pConfig } from './utils/libp2p-defaults.js'
 import { VerifiedFetch as VerifiedFetchClass } from './verified-fetch.js'
 import type { VerifiedFetchPluginFactory } from './plugins/types.js'
-import type { ContentTypeParser } from './types.js'
+import type { DNSLink, ResolveProgressEvents as ResolveDNSLinkProgressEvents } from '@helia/dnslink'
 import type { GetBlockProgressEvents, Helia, Routing } from '@helia/interface'
-import type { ResolveDNSLinkProgressEvents } from '@helia/ipns'
-import type { Libp2p, ServiceMap } from '@libp2p/interface'
+import type { IPNSResolver } from '@helia/ipns'
+import type { AbortOptions, Libp2p, ServiceMap } from '@libp2p/interface'
 import type { DNSResolvers, DNS } from '@multiformats/dns'
 import type { DNSResolver } from '@multiformats/dns/resolvers'
 import type { HeliaInit } from 'helia'
@@ -868,6 +826,25 @@ import type { ExporterProgressEvents } from 'ipfs-unixfs-exporter'
 import type { Libp2pOptions } from 'libp2p'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
+
+export type RequestFormatShorthand = 'raw' | 'car' | 'tar' | 'ipns-record' | 'dag-json' | 'dag-cbor' | 'json' | 'cbor'
+
+export type SupportedBodyTypes = string | Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array> | null
+
+/**
+ * A ContentTypeParser attempts to return the mime type of a given file. It
+ * receives the first chunk of the file data and the file name, if it is
+ * available.  The function can be sync or async and if it returns/resolves to
+ * `undefined`, `application/octet-stream` will be used.
+ */
+export interface ContentTypeParser {
+  /**
+   * Attempt to determine a mime type, either via of the passed bytes or the
+   * filename if it is available.
+   */
+  (bytes: Uint8Array, fileName?: string): Promise<string | undefined> | string | undefined
+}
+
 /**
  * The types for the first argument of the `verifiedFetch` function.
  */
@@ -879,7 +856,7 @@ export interface ResourceDetail {
 
 export interface CIDDetail {
   cid: CID
-  path: string
+  path?: string
 }
 
 export interface CIDDetailError extends CIDDetail {
@@ -995,24 +972,32 @@ export interface CreateVerifiedFetchOptions {
    * If you want to replace one of the default plugins, you can do so by passing a plugin with the same name.
    */
   plugins?: VerifiedFetchPluginFactory[]
-}
 
-export type { ContentTypeParser } from './types.js'
+  /**
+   * Used to resolve IPNS names
+   */
+  ipnsResolver?: IPNSResolver
 
-export type BubbledProgressEvents =
-  // unixfs-exporter
-  ExporterProgressEvents |
-  // helia blockstore
-  GetBlockProgressEvents |
-  // ipns
-  ResolveDNSLinkProgressEvents
+  /**
+   * Used to resolve DNSLink entries to IPNS names or CIDs
+   */
+  dnsLink?: DNSLink
+
+  /**
+   * Used to turn URLs into CIDs/paths
+   */
+  urlResolver?: URLResolver
+}
 
 export type VerifiedFetchProgressEvents =
   ProgressEvent<'verified-fetch:request:start', CIDDetail> |
   ProgressEvent<'verified-fetch:request:info', string> |
-  ProgressEvent<'verified-fetch:request:progress:chunk', CIDDetail> |
+  ProgressEvent<'verified-fetch:request:progress:chunk'> |
   ProgressEvent<'verified-fetch:request:end', CIDDetail> |
-  ProgressEvent<'verified-fetch:request:error', CIDDetailError>
+  ProgressEvent<'verified-fetch:request:error', CIDDetailError> |
+  ExporterProgressEvents |
+  GetBlockProgressEvents |
+  ResolveDNSLinkProgressEvents
 
 /**
  * Options for the `fetch` function returned by `createVerifiedFetch`.
@@ -1021,7 +1006,7 @@ export type VerifiedFetchProgressEvents =
  * passed to `fetch` in browsers, plus an `onProgress` option to listen for
  * progress events.
  */
-export interface VerifiedFetchInit extends RequestInit, ProgressOptions<BubbledProgressEvents | VerifiedFetchProgressEvents> {
+export interface VerifiedFetchInit extends RequestInit, ProgressOptions<VerifiedFetchProgressEvents> {
   /**
    * If true, try to create a blockstore session - this can reduce overall
    * network traffic by first querying for a set of peers that have the data we
@@ -1072,6 +1057,30 @@ export interface VerifiedFetchInit extends RequestInit, ProgressOptions<BubbledP
   withServerTiming?: boolean
 }
 
+export interface ResolveURLOptions extends ProgressOptions<VerifiedFetchProgressEvents>, AbortOptions {
+
+}
+
+export interface UrlQuery extends Record<string, string | unknown> {
+  format?: RequestFormatShorthand
+  download?: boolean
+  filename?: string
+  'dag-scope'?: string
+}
+
+export interface ResolveURLResult {
+  cid: CID
+  protocol: string
+  ttl: number
+  path: string
+  query: UrlQuery
+  ipfsPath: string
+}
+
+export interface URLResolver {
+  resolve (resource: Resource, options?: ResolveURLOptions): Promise<ResolveURLResult>
+}
+
 /**
  * Create and return a Helia node
  */
@@ -1116,7 +1125,7 @@ export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchIni
     init.logger.forComponent('helia:verified-fetch').trace('created verified-fetch with libp2p config: %j', libp2pConfig)
   }
 
-  const verifiedFetchInstance = new VerifiedFetchClass({ helia: init }, options)
+  const verifiedFetchInstance = new VerifiedFetchClass(init, options)
   async function verifiedFetch (resource: Resource, options?: VerifiedFetchInit): Promise<Response> {
     return verifiedFetchInstance.fetch(resource, options)
   }

package/src/plugins/index.ts

@@ -2,7 +2,6 @@
  * This file is the entry into all things we export from the `src/plugins` directory.
  */
 
-export { PluginError, PluginFatalError } from './errors.js'
 export { BasePlugin } from './plugin-base.js'
 export type { PluginOptions, PluginContext, VerifiedFetchPluginFactory } from './types.js'
 export * from './plugins.js'

package/src/plugins/plugin-base.ts

@@ -17,9 +17,10 @@ export abstract class BasePlugin implements VerifiedFetchPlugin {
   protected _log?: Logger
 
   get log (): Logger {
-    // instantiate the logger lazily because it depends on the id, which is not set until after the constructor is called
+    // instantiate the logger lazily because it depends on the id, which is not
+    // set until after the constructor is called
     if (this._log == null) {
-      this._log = this.pluginOptions.logger.forComponent(this.id)
+      this._log = this.pluginOptions.logger.newScope(this.id)
     }
     return this._log
   }

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

@@ -1,11 +1,12 @@
 import { BlockExporter, car, CIDPath, SubgraphExporter, UnixFSExporter } from '@helia/car'
-import { CarWriter } from '@ipld/car'
 import { code as dagPbCode } from '@ipld/dag-pb'
+import { createScalableCuckooFilter } from '@libp2p/utils'
 import toBrowserReadableStream from 'it-to-browser-readablestream'
+import { getOffsetAndLength } from '../utils/get-offset-and-length.ts'
 import { okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
-import type { ExportCarOptions } from '@helia/car'
+import type { ExportCarOptions, UnixFSExporterOptions } from '@helia/car'
 
 function getFilename ({ cid, ipfsPath, query }: Pick<PluginContext, 'query' | 'cid' | 'ipfsPath'>): string {
   if (query.filename != null) {
@@ -13,7 +14,10 @@ function getFilename ({ cid, ipfsPath, query }: Pick<PluginContext, 'query' | 'c
   }
 
   // convert context.ipfsPath to a filename. replace all / with _, replace prefix protocol with empty string
-  const filename = ipfsPath.replace(/\/ipfs\//, '').replace(/\/ipns\//, '').replace(/\//g, '_')
+  const filename = ipfsPath
+    .replace(/\/ipfs\//, '')
+    .replace(/\/ipns\//, '')
+    .replace(/\//g, '_')
 
   return `${filename}.car`
 }
@@ -22,9 +26,16 @@ function getFilename ({ cid, ipfsPath, query }: Pick<PluginContext, 'query' | 'c
 type DagScope = 'all' | 'entity' | 'block'
 function getDagScope ({ query }: Pick<PluginContext, 'query'>): DagScope | null {
   const dagScope = query['dag-scope']
+
   if (dagScope === 'all' || dagScope === 'entity' || dagScope === 'block') {
     return dagScope
   }
+
+  // entity-bytes implies entity scope
+  if (query['entity-bytes']) {
+    return 'entity'
+  }
+
   return 'all'
 }
 
@@ -36,22 +47,27 @@ export class CarPlugin extends BasePlugin {
   readonly id = 'car-plugin'
 
   canHandle (context: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', context.cid, context.accept)
     if (context.byteRangeContext == null) {
       return false
     }
+
     if (context.pathDetails == null) {
       return false
     }
 
-    return context.accept?.startsWith('application/vnd.ipld.car') === true || context.query.format === 'car' // application/vnd.ipld.car
+    return context.accept?.mimeType.startsWith('application/vnd.ipld.car') === true || context.query.format === 'car' // application/vnd.ipld.car
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
-    const { options, pathDetails, cid } = context
+    const { options, pathDetails, cid, query, accept } = context
+
+    const order = accept?.options.order === 'dfs' ? 'dfs' : 'unk'
+    const duplicates = accept?.options.dups !== 'n'
+
     if (pathDetails == null) {
       throw new Error('attempted to handle request for car with no path details')
     }
+
     const { getBlockstore, helia } = this.pluginOptions
     context.reqFormat = 'car'
     context.query.download = true
@@ -63,46 +79,52 @@ export class CarPlugin extends BasePlugin {
       getCodec: helia.getCodec,
       logger: helia.logger
     })
-    const ipfsRootsWithoutDagRoot = pathDetails.ipfsRoots.filter(pathCid => !pathCid.equals(cid))
+
     const carExportOptions: ExportCarOptions = {
-      ...options
+      ...options,
+      includeTraversalBlocks: true
+    }
+
+    if (!duplicates) {
+      carExportOptions.blockFilter = createScalableCuckooFilter(1024)
     }
-    if (ipfsRootsWithoutDagRoot.length > 0) {
-      carExportOptions.traversal = new CIDPath(ipfsRootsWithoutDagRoot)
+
+    if (pathDetails.ipfsRoots.length > 1) {
+      carExportOptions.traversal = new CIDPath(pathDetails.ipfsRoots)
     }
+
     const dagScope = getDagScope(context)
-    // root should be the terminal element if it exists, otherwise the root cid.. because of this, we can't use the @helia/car stream() method.
-    const root = pathDetails.terminalElement.cid ?? cid
+    const target = pathDetails.terminalElement.cid ?? cid
+
     if (dagScope === 'block') {
       carExportOptions.exporter = new BlockExporter()
     } else if (dagScope === 'entity') {
-      // if its unixFS, we need to enumerate a directory, or get all blocks for the entity, otherwise, use blockExporter
-      if (root.code === dagPbCode) {
-        carExportOptions.exporter = new UnixFSExporter()
+      // if its unixFS, we need to enumerate a directory, or get all/some blocks
+      // for the entity, otherwise, use blockExporter
+      if (target.code === dagPbCode) {
+        const options: UnixFSExporterOptions = {
+          listingOnly: true
+        }
+
+        const slice = getOffsetAndLength(pathDetails.terminalElement, query['entity-bytes']?.toString())
+        options.offset = slice.offset
+        options.length = slice.length
+
+        carExportOptions.exporter = new UnixFSExporter(options)
       } else {
         carExportOptions.exporter = new BlockExporter()
       }
     } else {
       carExportOptions.exporter = new SubgraphExporter()
     }
-    const { writer, out } = CarWriter.create(root)
-    const iter = async function * (): AsyncIterable<Uint8Array> {
-      for await (const buf of out) {
-        yield buf
-      }
-    }
 
-    // the root passed to export should be the root CID of the DAG, not the terminal element.
-    c.export(cid, writer, carExportOptions)
-      .catch((err) => {
-        this.log.error('error exporting car - %e', err)
-      })
-    // export will close the writer when it's done, no finally needed.
+    context.byteRangeContext.setBody(toBrowserReadableStream(c.export(target, carExportOptions)))
 
-    context.byteRangeContext.setBody(toBrowserReadableStream(iter()))
-
-    const response = okRangeResponse(context.resource, context.byteRangeContext.getBody('application/vnd.ipld.car; version=1'), { byteRangeContext: context.byteRangeContext, log: this.log })
-    response.headers.set('content-type', context.byteRangeContext.getContentType() ?? 'application/vnd.ipld.car; version=1')
+    const response = okRangeResponse(context.resource, context.byteRangeContext.getBody('application/vnd.ipld.car; version=1'), {
+      byteRangeContext: context.byteRangeContext,
+      log: this.log
+    })
+    response.headers.set('content-type', context.byteRangeContext.getContentType() ?? `application/vnd.ipld.car; version=1; order=${order}; dups=${duplicates ? 'y' : 'n'}`)
 
     return response
   }

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

@@ -51,18 +51,19 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
   readonly codes = [ipldDagCbor.code]
 
   canHandle ({ cid, accept, pathDetails }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
     if (pathDetails == null) {
       return false
     }
+
     if (!isObjectNode(pathDetails.terminalElement)) {
       return false
     }
+
     if (cid.code !== ipldDagCbor.code) {
       return false
     }
 
-    if (accept == null || !accept.includes('text/html')) {
+    if (accept == null || !accept?.mimeType.includes('text/html')) {
       return false
     }
 
@@ -97,7 +98,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
     })
   }
 
-  getHtml ({ path, obj, cid }: { path: string, obj: Record<string, any>, cid: CID }): string {
+  getHtml ({ path, obj, cid }: { path?: string, obj: Record<string, any>, cid: CID }): string {
     const style = `
       :root {
         --sans-serif: "Plex", system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, sans-serif;

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

@@ -16,21 +16,23 @@ export class DagCborPlugin extends BasePlugin {
   readonly codes = [ipldDagCbor.code]
 
   canHandle ({ cid, accept, pathDetails, byteRangeContext, plugins }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
     if (pathDetails == null) {
       return false
     }
+
     if (!isObjectNode(pathDetails.terminalElement)) {
       return false
     }
+
     if (cid.code !== ipldDagCbor.code) {
       return false
     }
+
     if (byteRangeContext == null) {
       return false
     }
 
-    if (accept != null && accept.includes('text/html') && plugins.includes('dag-cbor-plugin-html-preview')) {
+    if (accept != null && accept.mimeType === 'text/html' && plugins.includes('dag-cbor-plugin-html-preview')) {
       // let the dag-cbor-html-preview plugin handle it
       return false
     }
@@ -47,10 +49,10 @@ export class DagCborPlugin extends BasePlugin {
 
     let body: string | Uint8Array
 
-    if (accept === 'application/octet-stream' || accept === 'application/vnd.ipld.dag-cbor' || accept === 'application/cbor') {
+    if (accept?.mimeType === 'application/octet-stream' || accept?.mimeType === 'application/vnd.ipld.dag-cbor' || accept?.mimeType === 'application/cbor') {
       // skip decoding
       body = block
-    } else if (accept === 'application/vnd.ipld.dag-json') {
+    } else if (accept?.mimeType === 'application/vnd.ipld.dag-json') {
       try {
         // if vnd.ipld.dag-json has been specified, convert to the format - note
         // that this supports more data types than regular JSON, the content-type
@@ -65,7 +67,7 @@ export class DagCborPlugin extends BasePlugin {
       try {
         body = dagCborToSafeJSON(block)
       } catch (err) {
-        if (accept === 'application/json') {
+        if (accept?.mimeType === 'application/json') {
           this.log('could not decode DAG-CBOR as JSON-safe, but the client sent "Accept: application/json"', err)
 
           return notAcceptableResponse(resource)
@@ -78,7 +80,7 @@ export class DagCborPlugin extends BasePlugin {
 
     context.byteRangeContext.setBody(body)
 
-    const responseContentType = accept ?? (body instanceof Uint8Array ? 'application/octet-stream' : 'application/json')
+    const responseContentType = accept?.mimeType ?? (body instanceof Uint8Array ? 'application/octet-stream' : 'application/json')
     const response = okRangeResponse(resource, context.byteRangeContext.getBody(responseContentType), { byteRangeContext: context.byteRangeContext, log: this.log })
 
     response.headers.set('content-type', context.byteRangeContext.getContentType() ?? responseContentType)

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

@@ -6,7 +6,7 @@ import { CustomProgressEvent } from 'progress-events'
 import { getContentType } from '../utils/get-content-type.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'
+import { badGatewayResponse, badRangeResponse, movedPermanentlyResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 import type { CIDDetail } from '../index.js'
@@ -18,15 +18,21 @@ import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
 export class DagPbPlugin extends BasePlugin {
   readonly id = 'dag-pb-plugin'
   readonly codes = [dagPbCode]
+
   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
     }
 
+    // TODO: this may be too restrictive?
+    if (accept != null && accept.mimeType !== 'application/octet-stream') {
+      return false
+    }
+
     return cid.code === dagPbCode
   }
 
@@ -55,8 +61,8 @@ export class DagPbPlugin extends BasePlugin {
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext' | 'pathDetails'>>): Promise<Response | null> {
-    const { cid, options, withServerTiming = false, pathDetails, query } = context
-    const { handleServerTiming, contentTypeParser, helia, getBlockstore } = this.pluginOptions
+    const { cid, options, pathDetails, query } = context
+    const { contentTypeParser, helia, getBlockstore } = this.pluginOptions
     const log = this.log
     let resource = context.resource
     let path = context.path
@@ -93,10 +99,10 @@ export class DagPbPlugin extends BasePlugin {
       try {
         log.trace('found directory at %c/%s, looking for index.html', cid, path)
 
-        const entry = await handleServerTiming('exporter-dir', '', async () => exporter(`/ipfs/${dirCid}/${rootFilePath}`, helia.blockstore, {
+        const entry = await context.serverTiming.time('exporter-dir', '', exporter(`/ipfs/${dirCid}/${rootFilePath}`, helia.blockstore, {
           signal: options?.signal,
           onProgress: options?.onProgress
-        }), withServerTiming)
+        }))
 
         log.trace('found root file at %c/%s with cid %c', dirCid, rootFilePath, entry.cid)
         path = rootFilePath
@@ -105,21 +111,20 @@ export class DagPbPlugin extends BasePlugin {
         if (options?.signal?.aborted) {
           throw new AbortError(options?.signal?.reason)
         }
-        this.log.error('error loading path %c/%s', dirCid, rootFilePath, err)
+
+        this.log.error('error loading path %c/%s - %e', dirCid, rootFilePath, err)
+
         context.isDirectory = true
         context.directoryEntries = []
         context.modified++
+
         this.log.trace('attempting to get directory entries because index.html was not found')
-        try {
-          for await (const dirItem of fs.ls(dirCid, { signal: options?.signal, onProgress: options?.onProgress, extended: false })) {
-            context.directoryEntries.push(dirItem)
-          }
-          // dir-index-html plugin or dir-index-json (future idea?) plugin should handle this
-          return null
-        } catch (e) {
-          log.error('error listing directory %c', dirCid, e)
-          return notSupportedResponse('Unable to get directory contents')
+        for await (const dirItem of fs.ls(dirCid, { signal: options?.signal, onProgress: options?.onProgress, extended: false })) {
+          context.directoryEntries.push(dirItem)
         }
+
+        // dir-index-html plugin or dir-index-json (future idea?) plugin should handle this
+        return null
       } finally {
         options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid, path: rootFilePath }))
       }
@@ -136,10 +141,10 @@ export class DagPbPlugin extends BasePlugin {
     }
 
     try {
-      const entry = await handleServerTiming('exporter-file', '', async () => exporter(resolvedCID, helia.blockstore, {
+      const entry = await context.serverTiming.time('exporter-file', '', exporter(resolvedCID, helia.blockstore, {
         signal: options?.signal,
         onProgress: options?.onProgress
-      }), withServerTiming)
+      }))
 
       let firstChunk: Uint8Array
       let contentType: string
@@ -152,13 +157,13 @@ export class DagPbPlugin extends BasePlugin {
         })
         log('got async iterator for %c/%s', cid, path)
 
-        const streamAndFirstChunk = await handleServerTiming('stream-and-chunk', '', async () => getStreamFromAsyncIterable(asyncIter, path ?? '', this.pluginOptions.logger, {
+        const streamAndFirstChunk = await context.serverTiming.time('stream-and-chunk', '', getStreamFromAsyncIterable(asyncIter, path, this.pluginOptions.logger, {
           onProgress: options?.onProgress,
           signal: options?.signal
-        }), withServerTiming)
+        }))
         const stream = streamAndFirstChunk.stream
         firstChunk = streamAndFirstChunk.firstChunk
-        contentType = await handleServerTiming('get-content-type', '', async () => getContentType({ filename: query.filename, bytes: firstChunk, path, contentTypeParser, log }), withServerTiming)
+        contentType = await context.serverTiming.time('get-content-type', '', getContentType({ filename: query.filename, bytes: firstChunk, path, contentTypeParser, log }))
 
         byteRangeContext.setBody(stream)
       }
@@ -177,17 +182,20 @@ export class DagPbPlugin extends BasePlugin {
       if (options?.signal?.aborted) {
         throw new AbortError(options?.signal?.reason)
       }
-      log.error('error streaming %c/%s', cid, path, err)
+
+      log.error('error streaming %c/%s - %e', cid, path, err)
+
       if (byteRangeContext.isRangeRequest && err.code === 'ERR_INVALID_PARAMS') {
         return badRangeResponse(resource)
       }
-      return badGatewayResponse(resource.toString(), 'Unable to stream content')
+
+      return badGatewayResponse(resource, 'Unable to stream content')
     }
   }
 
   private async handleRangeRequest (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext' | 'pathDetails'>>, entry: UnixFSEntry): Promise<string> {
-    const { path, byteRangeContext, options, withServerTiming = false } = context
-    const { handleServerTiming, contentTypeParser } = this.pluginOptions
+    const { path, byteRangeContext, options } = context
+    const { contentTypeParser } = this.pluginOptions
     const log = this.log
 
     // get the first chunk in order to determine the content type
@@ -203,7 +211,7 @@ export class DagPbPlugin extends BasePlugin {
       onProgress: options?.onProgress,
       signal: options?.signal
     })
-    const contentType = await handleServerTiming('get-content-type', '', async () => getContentType({ bytes: firstChunk, path, contentTypeParser, log }), withServerTiming)
+    const contentType = await context.serverTiming.time('get-content-type', '', getContentType({ bytes: firstChunk, path, contentTypeParser, log }))
 
     byteRangeContext?.setBody((range): AsyncGenerator<Uint8Array, void, unknown> => {
       if (options?.signal?.aborted) {