@helia/verified-fetch 4.0.0 → 4.0.1

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

@@ -3,7 +3,6 @@ import { code as rawCode } from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 import { getContentType } from '../utils/get-content-type.js'
 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'
@@ -49,10 +48,10 @@ export class RawPlugin extends BasePlugin {
   codes: number[] = [rawCode, identity.code]
 
   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?.mimeType === 'application/vnd.ipld.raw' || query.format === 'raw'
   }
 
@@ -66,21 +65,20 @@ export class RawPlugin extends BasePlugin {
       context.reqFormat = 'raw'
       context.query.download = true
       context.query.filename = context.query.filename ?? `${cid.toString()}.bin`
-      log.trace('Set content disposition...')
+      log.trace('set content disposition to force download')
     } else {
-      log.trace('Did NOT set content disposition...')
+      log.trace('did not set content disposition, raw block will display inline')
     }
 
     if (path !== '' && cid.code === rawCode) {
       log.trace('404-ing raw codec request for %c/%s', cid, path)
-      // throw new PluginError('ERR_RAW_PATHS_NOT_SUPPORTED', 'Raw codec does not support paths')
-      // return notFoundResponse(resource, 'Raw codec does not support paths')
-      throw new PluginFatalError('ERR_RAW_PATHS_NOT_SUPPORTED', 'Raw codec does not support paths', { response: notFoundResponse(resource, 'Raw codec does not support paths') })
+      return notFoundResponse(resource)
     }
 
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, 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
@@ -94,6 +92,7 @@ export class RawPlugin extends BasePlugin {
       contentTypeParser,
       log
     })
+
     const response = okRangeResponse(resource, context.byteRangeContext.getBody(contentType), { byteRangeContext: context.byteRangeContext, log }, {
       redirected: false
     })

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

@@ -14,11 +14,12 @@ import type { PluginContext } from './types.js'
 export class TarPlugin extends BasePlugin {
   readonly id = 'tar-plugin'
   readonly codes = []
+
   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?.mimeType === 'application/x-tar' || query.format === 'tar'
   }
 

package/src/plugins/types.ts

@@ -1,11 +1,10 @@
-import type { PluginError } from './errors.js'
 import type { ResolveURLResult, UrlQuery, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
 import type { ByteRangeContext } from '../utils/byte-range-context.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 { AbortOptions, Logger } from '@libp2p/interface'
 import type { Helia } from 'helia'
 import type { Blockstore } from 'interface-blockstore'
 import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
@@ -18,7 +17,7 @@ import type { CustomProgressEvent } from 'progress-events'
  * - Persistent: Relevant even after the request completes (e.g., logging or metrics).
  */
 export interface PluginOptions {
-  logger: ComponentLogger
+  logger: Logger
   getBlockstore(cid: CID, resource: string | CID, useSession?: boolean, options?: AbortOptions): Blockstore
   contentTypeParser?: ContentTypeParser
   helia: Helia
@@ -51,7 +50,6 @@ export interface PluginContext extends ResolveURLResult {
   options?: Omit<VerifiedFetchInit, 'signal'> & AbortOptions
   isDirectory?: boolean
   directoryEntries?: UnixFSEntry[]
-  errors?: PluginError[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
   query: UrlQuery
@@ -65,6 +63,10 @@ export interface PluginContext extends ResolveURLResult {
   byteRangeContext?: ByteRangeContext
   serverTiming: ServerTiming
   ipfsPath: string
+
+  /**
+   * Allow arbitrary keys/values
+   */
   [key: string]: unknown
 }
 
@@ -85,7 +87,3 @@ export interface PluginErrorOptions {
   details?: Record<string, any>
   response?: Response
 }
-
-export interface FatalPluginErrorOptions extends PluginErrorOptions {
-  response: Response
-}

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

@@ -3,7 +3,7 @@ import { InvalidRangeError } from '../errors.js'
 import { calculateByteRangeIndexes, getHeader } from './request-headers.js'
 import { getContentRangeHeader } from './response-headers.js'
 import type { SupportedBodyTypes } from '../index.js'
-import type { ComponentLogger, Logger } from '@libp2p/interface'
+import type { Logger } from '@libp2p/interface'
 
 type SliceableBody = Exclude<SupportedBodyTypes, ReadableStream<Uint8Array> | null>
 
@@ -90,8 +90,8 @@ export class ByteRangeContext {
   // to be set by isValidRangeRequest so that we don't need to re-check the byteRanges
   private _isValidRangeRequest: boolean = false
 
-  constructor (logger: ComponentLogger, private readonly headers?: HeadersInit) {
-    this.log = logger.forComponent('helia:verified-fetch:byte-range-context')
+  constructor (logger: Logger, private readonly headers?: HeadersInit) {
+    this.log = logger.newScope('byte-range-context')
     this.rangeRequestHeader = getHeader(this.headers, 'Range')
 
     if (this.rangeRequestHeader != null) {

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

@@ -1,28 +1,22 @@
-import { logger } from '@libp2p/logger'
 import { fileTypeFromBuffer } from 'file-type'
 
-const log = logger('helia:verified-fetch:content-type-parser')
-
 export const defaultMimeType = 'application/octet-stream'
 function checkForSvg (text: string): boolean {
-  log('checking for svg')
   return /^(<\?xml[^>]+>)?[^<^\w]+<svg/ig.test(text)
 }
 
 async function checkForJson (text: string): Promise<boolean> {
-  log('checking for json')
   try {
     JSON.parse(text)
     return true
   } catch (err) {
-    log('failed to parse as json', err)
     return false
   }
 }
 
 function getText (bytes: Uint8Array): string | null {
-  log('checking for text')
   const decoder = new TextDecoder('utf-8', { fatal: true })
+
   try {
     return decoder.decode(bytes)
   } catch (err) {
@@ -31,25 +25,24 @@ function getText (bytes: Uint8Array): string | null {
 }
 
 async function checkForHtml (text: string): Promise<boolean> {
-  log('checking for html')
   return /^\s*<(?:!doctype\s+html|html|head|body)\b/i.test(text)
 }
 
 export async function contentTypeParser (bytes: Uint8Array, fileName?: string): Promise<string> {
-  log('contentTypeParser called for fileName: %s, byte size=%s', fileName, bytes.length)
   const detectedType = (await fileTypeFromBuffer(bytes))?.mime
+
   if (detectedType != null) {
-    log('detectedType: %s', detectedType)
     if (detectedType === 'application/xml' && fileName?.toLowerCase().endsWith('.svg')) {
       return 'image/svg+xml'
     }
+
     return detectedType
   }
-  log('no detectedType')
 
   if (fileName == null) {
     // it's likely text... no other way to determine file-type.
     const text = getText(bytes)
+
     if (text != null) {
       // check for svg, json, html, or it's plain text.
       if (checkForSvg(text)) {
@@ -62,6 +55,7 @@ export async function contentTypeParser (bytes: Uint8Array, fileName?: string):
         return 'text/plain; charset=utf-8'
       }
     }
+
     return defaultMimeType
   }
 

package/src/utils/error-to-object.ts

@@ -0,0 +1,22 @@
+function isAggregateError (err?: any): err is AggregateError {
+  return err instanceof AggregateError || (err?.name === 'AggregateError' && Array.isArray(err?.errors))
+}
+
+/**
+ * Error instance properties are not enumerable so we must transform the error
+ * into a plain object if we want to pass it to `JSON.stringify` or similar.
+ */
+export function errorToObject (err: Error): any {
+  let errors
+
+  if (isAggregateError(err)) {
+    errors = err.errors.map(err => errorToObject(err))
+  }
+
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+    errors
+  }
+}

package/src/utils/get-stream-from-async-iterable.ts

@@ -2,18 +2,18 @@ import { AbortError } from '@libp2p/interface'
 import { CustomProgressEvent } from 'progress-events'
 import { NoContentError } from '../errors.js'
 import type { VerifiedFetchInit } from '../index.js'
-import type { ComponentLogger } from '@libp2p/interface'
+import type { Logger } from '@libp2p/interface'
 
 /**
  * Converts an async iterator of Uint8Array bytes to a stream and returns the first chunk of bytes
  */
-export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
-  const log = logger.forComponent('helia:verified-fetch:get-stream-from-async-iterable')
+export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: Logger, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
+  const log = logger.newScope('get-stream-from-async-iterable')
   const reader = iterator[Symbol.asyncIterator]()
   const { value: firstChunk, done } = await reader.next()
 
   if (done === true) {
-    log.error('no content found for path', path)
+    log.error('no content found for path "%s"', path)
     throw new NoContentError()
   }
 

package/src/utils/responses.ts

@@ -44,6 +44,20 @@ export function okResponse (url: string, body?: SupportedBodyTypes, init?: Respo
   return response
 }
 
+export function internalServerErrorResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
+  const response = new Response(body, {
+    ...(init ?? {}),
+    status: 500,
+    statusText: 'Internal Server Error'
+  })
+  response.headers.set('X-Content-Type-Options', 'nosniff') // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
+
+  setType(response, 'basic')
+  setUrl(response, url)
+
+  return response
+}
+
 export function badGatewayResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
   const response = new Response(body, {
     ...(init ?? {}),
@@ -57,7 +71,7 @@ export function badGatewayResponse (url: string, body?: SupportedBodyTypes, init
   return response
 }
 
-export function notSupportedResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
+export function notImplementedResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
   const response = new Response(body, {
     ...(init ?? {}),
     status: 501,

package/src/utils/walk-path.ts

@@ -52,7 +52,7 @@ export function isObjectNode (node: UnixFSEntry): node is ObjectNode {
  */
 export async function handlePathWalking ({ cid, path, resource, options, blockstore, log }: PluginContext & { blockstore: Blockstore, log: Logger }): Promise<PathWalkerResponse | Response> {
   try {
-    return await walkPath(blockstore, `${cid.toString()}/${path}`, options)
+    return await walkPath(blockstore, `${cid}/${path}`, options)
   } catch (err: any) {
     if (options?.signal?.aborted) {
       throw new AbortError(options?.signal?.reason)

package/src/verified-fetch.ts

@@ -1,7 +1,6 @@
 import { dnsLink } from '@helia/dnslink'
 import { ipnsResolver } from '@helia/ipns'
 import { AbortError } from '@libp2p/interface'
-import { prefixLogger } from '@libp2p/logger'
 import { CustomProgressEvent } from 'progress-events'
 import QuickLRU from 'quick-lru'
 import { ByteRangeContextPlugin } from './plugins/plugin-handle-byte-range-context.js'
@@ -15,6 +14,7 @@ import { RawPlugin } from './plugins/plugin-handle-raw.js'
 import { TarPlugin } from './plugins/plugin-handle-tar.js'
 import { URLResolver } from './url-resolver.ts'
 import { contentTypeParser } from './utils/content-type-parser.js'
+import { errorToObject } from './utils/error-to-object.ts'
 import { getContentDispositionFilename } from './utils/get-content-disposition-filename.js'
 import { getETag } from './utils/get-e-tag.js'
 import { getResolvedAcceptHeader } from './utils/get-resolved-accept-header.js'
@@ -22,7 +22,7 @@ import { getRedirectResponse } from './utils/handle-redirects.js'
 import { uriEncodeIPFSPath } from './utils/ipfs-path-to-string.ts'
 import { resourceToSessionCacheKey } from './utils/resource-to-cache-key.js'
 import { setCacheControlHeader } from './utils/response-headers.js'
-import { badRequestResponse, notAcceptableResponse, notSupportedResponse, badGatewayResponse } from './utils/responses.js'
+import { badRequestResponse, notAcceptableResponse, internalServerErrorResponse, notImplementedResponse } from './utils/responses.js'
 import { selectOutputType } from './utils/select-output-type.js'
 import { ServerTiming } from './utils/server-timing.js'
 import type { CIDDetail, ContentTypeParser, CreateVerifiedFetchOptions, ResolveURLResult, Resource, ResourceDetail, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
@@ -83,7 +83,7 @@ export class VerifiedFetch {
 
     const pluginOptions: PluginOptions = {
       ...init,
-      logger: prefixLogger('helia:verified-fetch'),
+      logger: helia.logger.forComponent('verified-fetch'),
       getBlockstore: (cid, resource, useSession, options) => this.getBlockstore(cid, resource, useSession, options),
       helia,
       contentTypeParser: this.contentTypeParser,
@@ -116,8 +116,6 @@ export class VerifiedFetch {
     } else {
       this.plugins = defaultPlugins
     }
-
-    this.log.trace('created VerifiedFetch instance')
   }
 
   private getBlockstore (root: CID, resource: string | CID, useSession: boolean = true, options: AbortOptions = {}): Blockstore {
@@ -160,30 +158,26 @@ export class VerifiedFetch {
     // set Content-Disposition header
     let contentDisposition: string | undefined
 
-    this.log.trace('checking for content disposition')
-
     // force download if requested
     if (context?.query?.download === true) {
+      this.log.trace('download requested')
       contentDisposition = 'attachment'
-    } else {
-      this.log.trace('download not requested')
     }
 
     // override filename if requested
     if (context?.query?.filename != null) {
+      this.log.trace('specific filename requested')
+
       if (contentDisposition == null) {
         contentDisposition = 'inline'
       }
 
       contentDisposition = `${contentDisposition}; ${getContentDispositionFilename(context.query.filename)}`
-    } else {
-      this.log.trace('no filename specified in query')
     }
 
     if (contentDisposition != null) {
+      this.log.trace('content disposition %s', contentDisposition)
       response.headers.set('Content-Disposition', contentDisposition)
-    } else {
-      this.log.trace('no content disposition specified')
     }
 
     if (context?.cid != null && response.headers.get('etag') == null) {
@@ -240,7 +234,7 @@ export class VerifiedFetch {
    * Runs plugins in a loop. After each plugin that returns `null` (partial/no final),
    * we re-check `canHandle()` for all plugins in the next iteration if the context changed.
    */
-  private async runPluginPipeline (context: PluginContext, maxPasses: number = 3): Promise<Response | undefined> {
+  private async runPluginPipeline (context: PluginContext, maxPasses: number = 3): Promise<Response> {
     let finalResponse: Response | undefined
     let passCount = 0
     const pluginsUsed = new Set<string>()
@@ -251,20 +245,24 @@ export class VerifiedFetch {
       this.log(`starting pipeline pass #${passCount + 1}`)
       passCount++
 
+      this.log.trace('checking which plugins can handle %c%s with accept %o', context.cid, context.path != null ? `/${context.path}` : '', context.accept)
+
       // gather plugins that say they can handle the *current* context, but haven't been used yet
       const readyPlugins = this.plugins.filter(p => !pluginsUsed.has(p.id)).filter(p => p.canHandle(context))
+
       if (readyPlugins.length === 0) {
-        this.log.trace('no plugins can handle the current context.. checking by CID code')
+        this.log.trace('no plugins can handle the current context, checking by CID code')
         const plugins = this.plugins.filter(p => p.codes.includes(context.cid.code))
+
         if (plugins.length > 0) {
           readyPlugins.push(...plugins)
         } else {
-          this.log.trace('no plugins found that can handle request by CID code; exiting pipeline.')
+          this.log.trace('no plugins found that can handle request by CID code; exiting pipeline')
           break
         }
       }
 
-      this.log.trace('plugins ready to handle request: ', readyPlugins.map(p => p.id).join(', '))
+      this.log.trace('plugins ready to handle request: %s', readyPlugins.map(p => p.id).join(', '))
 
       // track if any plugin changed the context or returned a response
       let contextChanged = false
@@ -272,10 +270,13 @@ export class VerifiedFetch {
 
       for (const plugin of readyPlugins) {
         try {
-          this.log.trace('invoking plugin:', plugin.id)
+          this.log('invoking plugin: %s', plugin.id)
           pluginsUsed.add(plugin.id)
 
           const maybeResponse = await plugin.handle(context)
+
+          this.log('plugin response %s %o', plugin.id, maybeResponse)
+
           if (maybeResponse != null) {
             // if a plugin returns a final Response, short-circuit
             finalResponse = maybeResponse
@@ -286,12 +287,16 @@ export class VerifiedFetch {
           if (context.options?.signal?.aborted) {
             throw new AbortError(context.options?.signal?.reason)
           }
-          this.log.error('error in plugin %s - %e', plugin.constructor.name, err)
-          // if fatal, short-circuit the pipeline
-          if (err.name === 'PluginFatalError') {
-            // if plugin provides a custom error response, return it
-            return err.response ?? badGatewayResponse(context.resource, 'Failed to fetch')
-          }
+
+          this.log.error('error in plugin %s - %e', plugin.id, err)
+
+          return internalServerErrorResponse(context.resource, JSON.stringify({
+            error: errorToObject(err)
+          }), {
+            headers: {
+              'content-type': 'application/json'
+            }
+          })
         } finally {
           // on each plugin call, check for changes in the context
           const newModificationId = context.modified
@@ -317,7 +322,13 @@ export class VerifiedFetch {
       }
     }
 
-    return finalResponse
+    return finalResponse ?? notImplementedResponse(context.resource, JSON.stringify({
+      error: errorToObject(new Error('No verified fetch plugin could handle the request'))
+    }), {
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
   }
 
   /**
@@ -363,7 +374,7 @@ export class VerifiedFetch {
     const acceptHeader = getResolvedAcceptHeader({ query: parsedResult.query, headers: options?.headers, logger: this.helia.logger })
 
     const accept: AcceptHeader | undefined = selectOutputType(parsedResult.cid, acceptHeader)
-    this.log('output type %s', accept)
+    this.log('accept %o', accept)
 
     if (acceptHeader != null && accept == null) {
       this.log.error('could not fulfil request based on accept header')
@@ -394,9 +405,16 @@ export class VerifiedFetch {
 
     const response = await this.runPluginPipeline(context)
 
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: parsedResult.cid, path: parsedResult.path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', {
+      cid: parsedResult.cid,
+      path: parsedResult.path
+    }))
+
+    if (response == null) {
+      this.log.error('no plugin could handle request for %s', resource)
+    }
 
-    return this.handleFinalResponse(response ?? notSupportedResponse(resource.toString()), context)
+    return this.handleFinalResponse(response, context)
   }
 
   /**

package/dist/src/plugins/errors.d.ts

@@ -1,25 +0,0 @@
-import type { FatalPluginErrorOptions, PluginErrorOptions } from './types.js';
-/**
- * If a plugin encounters an error, it should throw an instance of this class.
- */
-export declare class PluginError extends Error {
-    name: string;
-    code: string;
-    fatal: boolean;
-    details?: Record<string, any>;
-    response?: any;
-    constructor(code: string, message: string, options?: PluginErrorOptions);
-}
-/**
- * If a plugin encounters a fatal error and verified-fetch should not continue processing the request, it should throw
- * an instance of this class.
- *
- * Note that you should be very careful when throwing a `PluginFatalError`, as it will stop the request from being
- * processed further. If you do not have a response to return to the client, you should consider throwing a
- * `PluginError` instead.
- */
-export declare class PluginFatalError extends PluginError {
-    name: string;
-    constructor(code: string, message: string, options: FatalPluginErrorOptions);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/src/plugins/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAE7E;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAC7B,IAAI,SAAgB;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC7B,QAAQ,CAAC,EAAE,GAAG,CAAA;gBAER,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB;CAOzE;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;IACxC,IAAI,SAAqB;gBAEnB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB;CAI7E"}

package/dist/src/plugins/errors.js

@@ -1,33 +0,0 @@
-/**
- * If a plugin encounters an error, it should throw an instance of this class.
- */
-export class PluginError extends Error {
-    name = 'PluginError';
-    code;
-    fatal;
-    details;
-    response;
-    constructor(code, message, options) {
-        super(message);
-        this.code = code;
-        this.fatal = options?.fatal ?? false;
-        this.details = options?.details;
-        this.response = options?.response;
-    }
-}
-/**
- * If a plugin encounters a fatal error and verified-fetch should not continue processing the request, it should throw
- * an instance of this class.
- *
- * Note that you should be very careful when throwing a `PluginFatalError`, as it will stop the request from being
- * processed further. If you do not have a response to return to the client, you should consider throwing a
- * `PluginError` instead.
- */
-export class PluginFatalError extends PluginError {
-    name = 'PluginFatalError';
-    constructor(code, message, options) {
-        super(code, message, { ...options, fatal: true });
-        this.name = 'PluginFatalError';
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/src/plugins/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/plugins/errors.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAC7B,IAAI,GAAG,aAAa,CAAA;IACpB,IAAI,CAAQ;IACZ,KAAK,CAAS;IACd,OAAO,CAAsB;IAC7B,QAAQ,CAAM;IAErB,YAAa,IAAY,EAAE,OAAe,EAAE,OAA4B;QACtE,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,KAAK,CAAA;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,CAAA;QAC/B,IAAI,CAAC,QAAQ,GAAG,OAAO,EAAE,QAAQ,CAAA;IACnC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAiB,SAAQ,WAAW;IACxC,IAAI,GAAG,kBAAkB,CAAA;IAEhC,YAAa,IAAY,EAAE,OAAe,EAAE,OAAgC;QAC1E,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;QACjD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAA;IAChC,CAAC;CACF"}

package/src/plugins/errors.ts

@@ -1,37 +0,0 @@
-import type { FatalPluginErrorOptions, PluginErrorOptions } from './types.js'
-
-/**
- * If a plugin encounters an error, it should throw an instance of this class.
- */
-export class PluginError extends Error {
-  public name = 'PluginError'
-  public code: string
-  public fatal: boolean
-  public details?: Record<string, any>
-  public response?: any
-
-  constructor (code: string, message: string, options?: PluginErrorOptions) {
-    super(message)
-    this.code = code
-    this.fatal = options?.fatal ?? false
-    this.details = options?.details
-    this.response = options?.response
-  }
-}
-
-/**
- * If a plugin encounters a fatal error and verified-fetch should not continue processing the request, it should throw
- * an instance of this class.
- *
- * Note that you should be very careful when throwing a `PluginFatalError`, as it will stop the request from being
- * processed further. If you do not have a response to return to the client, you should consider throwing a
- * `PluginError` instead.
- */
-export class PluginFatalError extends PluginError {
-  public name = 'PluginFatalError'
-
-  constructor (code: string, message: string, options: FatalPluginErrorOptions) {
-    super(code, message, { ...options, fatal: true })
-    this.name = 'PluginFatalError'
-  }
-}