webhoster 0.3.2 → 0.3.4

package/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish Package
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  id-token: write  # Required for OIDC
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      # Ensure npm 11.5.1 or later is installed
+      - name: Update npm
+        run: npm install -g npm@latest
+      - run: npm ci
+      - run: npm run build --if-present
+      - run: npm test
+      - run: npm publish

package/.test/index.js

@@ -26,7 +26,7 @@ import {
 import * as tls from './tls.js';
 import { ServerResponse } from 'node:http';
 
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
 
 /**
  * Redirect to HTTPS/2

package/README.md

@@ -39,7 +39,7 @@ For now, take a look at [/test/index.js](/test/index.js)
 * `.defaultInstance` - (`HttpHandler`) - Returns a instance of `HttpHandler` that can be accessed staticly.
 * `.middleware` - (`Middleware[]`) - An array of middleware operations to iterate through when handling a request. It is recommended to create isolated branches (eg: `/images/`; `/api/`; `/views/`; etc.).
 * `.errorHandlers` - (`MiddlewareErrorHandler[]`) - An array of `MiddlewareErrorHandler` that will handle errors and respond appropriately (eg: `res.status = 500`)
-* `.handleRequest` - (`function(MiddlewareFunctionParams):Promise<HttpResponse>`) - handles logic for calling middleware and error handlers. Unlikely to be used directly.
+* `.handleRequest` - (`function(HttpTransaction):Promise<HttpResponse>`) - handles logic for calling middleware and error handlers. Unlikely to be used directly.
 * `.handleHttp1Request` - (`function(IncomingMessage, ServerResponse):Promise<HttpResponse>`) - constructs a new `HttpRequest` and `HttpResponse` based on the HTTP1 parameters and passes it to `handleRequest`
 * `.handleHttp2Stream` - (`function(ServerHttp2Stream, IncomingHttpHeaders, HttpResponseOptions):Promise<HttpResponse>`) - constructs a new `HttpRequest` and `HttpResponse` based on the HTTP2 parameters and passes it to `handleRequest`
 
@@ -141,7 +141,7 @@ async function onGetIndexPage(transaction) {
 
 Middleware logic flows in a tree structure, allowing for `continue`, `break`, or `end`.
 
-A `MiddlewareFunction` is a function that accepts a `MiddlewareFunctionParams` object structured as `{ res: HttpRequest, res: HttpResponse }`. The function can return a instruction with the step in the tree-based logic, status code, or content body to be handled. It maybe return any of these instructions with any of the values as a literal, a `Promise`, or `PromiseLike`:
+A `MiddlewareFunction` is a function that accepts a `HttpTransaction` object structured as `{ res: HttpRequest, res: HttpResponse }`. The function can return a instruction with the step in the tree-based logic, status code, or content body to be handled. It maybe return any of these instructions with any of the values as a literal, a `Promise`, or `PromiseLike`:
 
 * `HttpHandler.CONTINUE`: Continues on the current branch to the next middleware, or moves to the next branch if there are no siblings left. `alias: true|void|null|undefined`
 * `HttpHandler.BREAK`: Breaks from the current middleware branch, and continues to the next branch. `alias: false`
@@ -151,7 +151,7 @@ A `MiddlewareFunction` is a function that accepts a `MiddlewareFunctionParams` o
 * `Array`: Explicitly passed to `HttpResponse.end()`. This is to support sending an `Array` object instead having it becoming an inline middleware branch.
 * `any`: Any other value returned would automatically be passed to `HttpResponse.end()` which, in turn, uses it's own content handlers (eg: `JSON`; `Readable`), and finally terminates the middleware tree.
 
-A `MiddlewareFilter` is a function that accepts a `MiddlewareFunctionParams` and returns a `boolean` or `Promise<boolean>` signaling whether to continue in the branch. `true` translates to `HttpHandler.CONTINUE`. `false` translates to `HttpHandler.BREAK`. There is no support for `HttpHandler.END` logic in a MiddlewareFilter by design.
+A `MiddlewareFilter` is a function that accepts a `HttpTransaction` and returns a `boolean` or `Promise<boolean>` signaling whether to continue in the branch. `true` translates to `HttpHandler.CONTINUE`. `false` translates to `HttpHandler.BREAK`. There is no support for `HttpHandler.END` logic in a MiddlewareFilter by design.
 
 A `MiddlewareErrorHandler` is an `Object` with a `onError` property. `onError` is like a MiddlewareFunction, but includes an `err` item in its parameter object. When the handler is in an error state, it will bubble upwards while searching for the next `MiddlewareErrorHandler`.
 
@@ -163,7 +163,7 @@ To support branching, `Middleware` can also be a `Iterable<Middleware>` (eg: `Se
 
 ### Response Middleware
 * [AuthHeaders](./middleware/AutoHeadersMiddleware.js) - Automatically sends response headers before writing or ending a response stream
-* [ContentLength](./middleware/contentLengthMiddleware.js) - Sets `Content-Length` based on response stream content writes
+* [ContentLength](./middleware/ContentLengthMiddleware.js) - Sets `Content-Length` based on response stream content writes
 * [Hash](./middleware/HashMiddleware.js) - Sets `ETag`, `Digest`, and `Content-MD5` response headers automatically
 * [ContentEncoder](./middleware/ContentEncoderMiddleware.js) - Applies `Content-Encoding` to response based on `Accept-Encoding` request header
 * [SendJson](./middleware/SendJsonMiddleware.js) - Adds response content processor that encodes objects and arrays to JSON string. Sets `application/json;charset=utf-8`, if content-type not set.

package/data/CookieObject.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../types').CookieDetails} CookieDetails */
+/** @typedef {import('./custom-types.js').CookieDetails} CookieDetails */
 
 /** @private */
 export default class CookieObject {

package/{types/index.js → data/custom-types.js}

@@ -16,7 +16,7 @@
 
 /** @typedef {import('node:stream').Duplex} Duplex */
 
-/** @typedef {import('./typings').Middleware} Middleware */
+/** @typedef {import('./middleware.js').Middleware} Middleware */
 
 /** @typedef {true|false|0} MiddlewareFlowInstruction */
 

package/{types/typings.d.ts → data/middleware.d.ts}

@@ -3,7 +3,7 @@ import {
   MiddlewareContent,
   MiddlewareFunction,
   MiddlewareFunctionResultType,
-} from './index.js';
+} from './custom-types.js';
 
 export type Middleware =
   | IMiddleware

package/helpers/HttpListener.js

@@ -148,6 +148,7 @@ export default class HttpListener {
 
         this.httpServer.keepAliveTimeout = 5000;
         this.httpServer.requestTimeout = 300_000;
+        // @ts-expect-error Missing types
         this.httpServer.setTimeout(120_000, (socket) => {
           if (!socket) {
             console.warn('HTTP socket (unknown) timed out.');
@@ -163,6 +164,7 @@ export default class HttpListener {
           // console.error('HTTP server error', err);
         });
         this.httpServer.addListener('clientError', this.#httpClientErrorListener = (error, socket) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP client connection reset.');
             return;
@@ -194,6 +196,7 @@ export default class HttpListener {
 
         this.httpsServer.keepAliveTimeout = 5000;
         this.httpsServer.requestTimeout = 300_000;
+        // @ts-expect-error Missing types
         this.httpsServer.setTimeout(120_000, (socket) => {
           if (!socket) {
             // console.warn('HTTPS socket (unknown) timed out.');
@@ -208,6 +211,7 @@ export default class HttpListener {
           // console.error('HTTPS server error', err);
         });
         this.httpsServer.addListener('clientError', this.#httpsClientErrorListener = (error, socket) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             console.warn('HTTPS client connection reset.');
             return;
@@ -237,77 +241,7 @@ export default class HttpListener {
         host: this.secureHost,
       }, () => {
         this.http2Server.removeListener('error', reject);
-
-        /** @type {Set<WeakRef<Http2Session>>} */
-        const sessions = new Set();
-        /** @type {WeakMap<Http2Session, {timestamp:number, identity:string}>} */
-        const sessionMetadata = new WeakMap();
-        /** @type {Set<WeakRef<Http2Stream>>} */
-        const streams = new Set();
-        /** @type {WeakMap<Http2Stream, {timestamp:number, identity:string, path:string}>} */
-        const streamMetadata = new WeakMap();
-        /** @return {void} */
-        function logUsage() {
-          if (global.gc) {
-            console.debug('Perfoming garbage collection.');
-            global.gc();
-          }
-          for (const reference of sessions) {
-            const session = reference.deref();
-            if (!session) {
-              sessions.delete(reference);
-              continue;
-            }
-            const metadata = sessionMetadata.get(session);
-            if (session.destroyed) {
-              console.warn('SESSION destroyed from', metadata.identity, 'since', metadata.timestamp);
-            } else {
-              console.debug('SESSION alive from', metadata.identity, 'since', metadata.timestamp);
-            }
-          }
-          for (const reference of streams) {
-            const stream = reference.deref();
-            if (!stream) {
-              streams.delete(reference);
-              continue;
-            }
-            const metadata = streamMetadata.get(stream);
-            if (stream.destroyed) {
-              console.warn('STREAM destroyed from', metadata.identity, 'since', metadata.timestamp, 'for', metadata.path);
-            } else {
-              console.debug('STREAM alive from', metadata.identity, 'since', metadata.timestamp, 'for', metadata.path);
-            }
-          }
-          if (sessions.size) {
-            console.debug('Active sessions:', sessions.size);
-          }
-          if (streams.size) {
-            console.debug('Active streams:', streams.size);
-          }
-          if ('process' in globalThis) {
-            if ('getActiveResourcesInfo' in globalThis.process) {
-              console.dir('Active Resources', globalThis.process.getActiveResourcesInfo());
-            }
-            if ('_getActiveRequests' in globalThis.process) {
-              console.dir('Active Requests', globalThis.process._getActiveRequests());
-            }
-            if ('_getActiveHandles' in globalThis.process) {
-              const handles = globalThis.process._getActiveHandles();
-              for (const handle of handles) {
-                if (handle instanceof Socket) {
-                  console.debug('Active Handle (Socket)', `${handle.localAddress}:${handle.localPort} <=> ${handle.remoteAddress}:${handle.remotePort}`);
-                } else if (handle instanceof Server) {
-                  console.debug('Active Handle (Server)', `${handle.address()?.port}`);
-                } else {
-                  console.debug('Active Handle (unknown)', handle);
-                }
-              }
-            }
-          }
-        }
-        // setInterval(logUsage, 300_000);
-        // logUsage();
-
+        // @ts-expect-error Missing types
         this.http2Server.setTimeout(120_000, (socket) => {
           if (!socket) {
             console.warn('HTTP2 socket (unknown) timed out.');
@@ -325,6 +259,7 @@ export default class HttpListener {
         this.http2Server.addListener('clientError', this.#http2ClientErrorListener = (error, socket) => {
           // No clear way to signal back to client why a socket has failed because
           // it's unsure if it's HTTP1 or HTTP2. Just destroy and log server-side.
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP/2 client connection reset.');
           } else {
@@ -333,6 +268,7 @@ export default class HttpListener {
           if (!socket.destroyed) socket.destroy(error);
         });
         this.http2Server.addListener('sessionError', this.#http2SessionErrorListener = (error, session) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP/2 client connection reset.');
           } else if (error?.message === 'SOCKET_TIMEOUT') {
@@ -344,12 +280,7 @@ export default class HttpListener {
         });
 
         this.http2Server.addListener('session', this.#http2SessionListener = (session) => {
-          sessions.add(new WeakRef(session));
           const identity = `${session.socket.remoteFamily}:${session.socket.remoteAddress}:${session.socket.remotePort}`;
-          sessionMetadata.set(session, {
-            timestamp: performance.now(),
-            identity,
-          });
           session.setTimeout(60_000, () => {
             // console.warn(`HTTP/2 session ${identity} timed out.`);
             session.destroy(new Error('SESSION_TIMEOUT'));
@@ -361,6 +292,7 @@ export default class HttpListener {
               session.ping((error) => {
                 if (!error) return;
                 if (session.destroyed) return;
+                // @ts-expect-error Missing types
                 if (error.code === 'ERR_HTTP2_PING_CANCEL') return;
                 console.error(`Ping to ${identity} failed.`, error);
               });
@@ -373,49 +305,42 @@ export default class HttpListener {
 
         // Logic handlers
         this.http2Server.addListener('stream', this.#http2StreamListener = (stream, headers) => {
-          streams.add(new WeakRef(stream));
-          streamMetadata.set(stream, {
-            timestamp: performance.now(),
-            identity: `${stream.session?.socket.remoteFamily}:${stream.session?.socket.remoteAddress}:${stream.session?.socket.remotePort}`,
-            path: headers[':path'],
-          });
-
           stream.setTimeout(300_000, () => {
             stream.destroy(new Error('SOCKET_TIMEOUT'));
           });
           stream.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('HTTP/2 stream connection reset.', headers[':path']);
             } else {
               console.error('HTTP/2 stream error', headers, error);
             }
           });
+          // @ts-expect-error Missing types
           this.httpHandler.handleHttp2Stream(stream, headers).catch((error) => {
             console.error('HTTP2 handler failed.', error);
           });
         });
-        this.http2Server.addListener('request', this.#http2RequestListener = (request, res) => {
+        this.http2Server.addListener('request', this.#http2RequestListener = (request, response) => {
           if (request.httpVersionMajor >= 2) return;
-          // @ts-ignore Ignore typings
+          // @ts-expect-error Missing types
           request.setTimeout(300_000, (socket) => {
             if (!socket) {
               // console.warn('HTTP1 in HTTP2 request (unknown) timed out.');
               return;
             }
-            // const identity = `${socket.remoteFamily}:${socket.remoteAddress}:${socket.remotePort}`;
-            // console.warn(`HTTP1 in HTTP2 request ${identity} timed out.`);
             socket.destroy(new Error('SOCKET_TIMEOUT'));
           });
-          res.setTimeout(300_000, (socket) => {
+          // @ts-expect-error Missing types
+          response.setTimeout(300_000, (socket) => {
             if (!socket) {
               // console.warn('HTTP1 in HTTP2 response (unknown) timed out.');
               return;
             }
-            const identity = `${socket.remoteFamily}:${socket.remoteAddress}:${socket.remotePort}`;
-            // console.warn(`HTTP1 in HTTP2 response ${identity} timed out.`);
             socket.destroy(new Error('SOCKET_TIMEOUT'));
           });
           request.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('Request stream connection reset.', req.url);
             } else {
@@ -425,17 +350,18 @@ export default class HttpListener {
               request.destroy(error);
             }
           });
-          res.addListener('error', (error) => {
+          response.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('Response stream connection reset.', req.url);
             } else {
               console.error('Response stream error', request.url, request.headers, error);
             }
-            if (!res.destroyed) {
-              res.destroy(error);
+            if (!response.destroyed) {
+              response.destroy(error);
             }
           });
-          this.httpHandler.handleHttp1Request(request, res).catch((error) => {
+          this.httpHandler.handleHttp1Request(request, response).catch((error) => {
             console.error('HTTP1 in HTTP2 handler failed.', error);
           });
         });

package/helpers/RequestReader.js

@@ -1,8 +1,7 @@
-/** @typedef {import('../types').HttpRequest} HttpRequest */
+/** @typedef {import('../data/custom-types.js').HttpRequest} HttpRequest */
 
 import { TextDecoder } from 'node:util';
 import AsyncObject from '../utils/AsyncObject.js';
-import { noop } from '../utils/function.js';
 import RequestHeaders from './RequestHeaders.js';
 
 /**
@@ -11,7 +10,6 @@ import RequestHeaders from './RequestHeaders.js';
  */
 
 const BUFFER_SIZE = 4096;
-const STREAM_WAIT_MS = 0;
 
 /** @type {WeakMap<HttpRequest, RequestReader>} */
 const cache = new WeakMap();
@@ -45,8 +43,6 @@ export default class RequestReader {
     const hp = new RequestHeaders(this.request);
     let data = Buffer.allocUnsafe(Math.min(BUFFER_SIZE, hp.contentLength || BUFFER_SIZE));
     let bytesWritten = 0;
-    /** @type {NodeJS.Timeout} */
-    let sendPingTimeout = null;
     this.request.stream.on('readable', () => {
       let chunk;
       // eslint-disable-next-line no-cond-assign
@@ -70,15 +66,8 @@ export default class RequestReader {
         }
         bytesWritten += buffer.copy(data, bytesWritten);
       }
-      clearTimeout(sendPingTimeout);
-      if (this.request.canPing) {
-        sendPingTimeout = setTimeout(() => {
-          this.request.ping().catch(noop);
-        }, STREAM_WAIT_MS);
-      }
     });
     this.request.stream.on('end', () => {
-      clearTimeout(sendPingTimeout);
       if (data.length > bytesWritten) {
         // Must partition to clear unsafe allocation
         data = data.subarray(0, bytesWritten);

package/helpers/ResponseHeaders.js

@@ -3,7 +3,7 @@ import CookieObject from '../data/CookieObject.js';
 import HeadersHandler from './HeadersParser.js';
 
 /** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
-/** @typedef {import('../types').CookieDetails} CookieDetails */
+/** @typedef {import('../data/custom-types.js').CookieDetails} CookieDetails */
 
 /** @type {(keyof CookieDetails)[]} */
 const COOKIE_DETAIL_KEYS = [
@@ -22,18 +22,17 @@ const COOKIE_DETAIL_KEYS = [
 const instanceCache = new WeakMap();
 
 export default class ResponseHeaders extends HeadersHandler {
-  /** @param {HttpResponse} res */
-  // @ts-ignore Cached constructor
-  constructor(res) {
-    const instance = instanceCache.get(res);
+  /** @param {HttpResponse} response */
+  constructor(response) {
+    const instance = instanceCache.get(response);
     if (instance) return instance;
-    super(res.headers);
-    instanceCache.set(res, this);
+    super(response.headers);
+    instanceCache.set(response, this);
   }
 
-  /** @param {HttpResponse} res */
-  static cookies(res) {
-    const instance = new ResponseHeaders(res);
+  /** @param {HttpResponse} response */
+  static cookies(response) {
+    const instance = new ResponseHeaders(response);
     return instance.cookies;
   }
 

package/lib/HttpHandler.js

@@ -7,10 +7,10 @@ import HttpRequest from './HttpRequest.js';
 import HttpResponse from './HttpResponse.js';
 import HttpTransaction from './HttpTransaction.js';
 
-/** @typedef {import('../types').Middleware} Middleware */
-/** @typedef {import('../types').MiddlewareErrorHandler} MiddlewareErrorHandler */
-/** @typedef {import('../types').MiddlewareFlowInstruction} MiddlewareFlowInstruction */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareErrorHandler} MiddlewareErrorHandler */
+/** @typedef {import('../data/custom-types.js').MiddlewareFlowInstruction} MiddlewareFlowInstruction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
 
 /** @type {HttpHandler} */
 let defaultInstance = null;
@@ -145,6 +145,7 @@ export default class HttpHandler {
 
     // Check if error handler
     const isErrorHandler = (typeof middleware === 'object'
+      && 'onError' in middleware
       && typeof middleware.onError === 'function');
 
     let value = middleware;
@@ -186,6 +187,7 @@ export default class HttpHandler {
           }
 
           // Sync operation returned Promise
+          // @ts-expect-error TS improperly thinks result can be null
           if (typeof result === 'object' && typeof result.then === 'function') {
             if (isErrorHandler) transaction.error = null;
             result = await result;
@@ -216,6 +218,7 @@ export default class HttpHandler {
           const { treeIndex } = transaction.state;
           treeIndex.push(-1);
           const { length } = value;
+          // eslint-disable-next-line no-plusplus
           for (let index = 0; index < length; index++) {
             const innerMiddleware = value[index];
             treeIndex[treeIndex.length - 1] += 1;
@@ -333,6 +336,7 @@ export default class HttpHandler {
 
     const request = new HttpRequest({
       headers,
+      // @ts-expect-error JSDoc syntax limitation
       method,
       stream: incomingMessage,
 
@@ -428,7 +432,7 @@ export default class HttpHandler {
       }
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    // eslint-disable-next-line @typescript-eslint/no-this-alias, unicorn/no-this-assignment
     const context = this;
 
     /** @type {Promise<any>[]} */
@@ -436,6 +440,7 @@ export default class HttpHandler {
 
     const request = new HttpRequest({
       headers,
+      // @ts-expect-error JSDoc syntax limitation
       method,
       stream,
 
@@ -492,7 +497,7 @@ export default class HttpHandler {
           'cache-control',
         ]) {
           if (passedHeader in headers) {
-            // @ts-ignore Coerce
+            // @ts-expect-error Coerce
             newHeaders[passedHeader] = headers[passedHeader];
           }
         }
@@ -500,10 +505,15 @@ export default class HttpHandler {
         // Build promise function
         const promiseFunction = async () => {
           try {
+            /** @type {import('node:http2').ServerHttp2Stream} */
             const pushStream = await new Promise((resolve, reject) => {
-              stream.pushStream(newHeaders, ((error, newStream) => (error ? reject(error) : resolve(newStream))));
+              stream.pushStream(
+                newHeaders,
+                ((error, newStream) => (error ? reject(error) : resolve(newStream))),
+              );
             });
             pushStream.addListener('error', (error) => {
+              // @ts-expect-error Missing types
               if (error?.code === 'ECONNRESET') {
                 console.warn('HTTP/2 stream connection reset.', headers[':path']);
               } else {

package/lib/HttpRequest.js

@@ -1,9 +1,9 @@
 import { Readable } from 'node:stream';
 import { URLSearchParams } from 'node:url';
 
-/** @typedef {import('../types').RequestMethod} RequestMethod */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
 /** @typedef {import('http').IncomingHttpHeaders} IncomingHttpHeaders */
-/** @typedef {import('../types/index.js').MediaType} MediaType */
+/** @typedef {import('../data/custom-types.js').MediaType} MediaType */
 
 /** @typedef {Partial<MediaType> & {parse:(this:HttpRequest)=>any|PromiseLike<any>, test?:(this:HttpRequest, mediaType: MediaType)=>boolean}} ContentReaderRegistration */
 
@@ -140,7 +140,9 @@ export default class HttpRequest {
     if (this.#readable === undefined) {
       if (this.method === 'GET' || this.method === 'HEAD') {
         this.#readable = null;
+      // @ts-expect-error Missing types
       } else if (Readable.toWeb) {
+        // @ts-expect-error Missing types
         this.#readable = Readable.toWeb(this.stream);
         this.#bodyUsed = true;
       } else {
@@ -226,7 +228,7 @@ export default class HttpRequest {
   }
 
   /**
-   * @return {Promise<ArrayBuffer>}
+   * @return {Promise<ArrayBufferLike>}
    */
   async arrayBuffer() {
     try {
@@ -264,7 +266,7 @@ export default class HttpRequest {
       try {
         const module = await import('node:buffer');
         if ('Blob' in module === false) throw new Error('NOT_SUPPORTED');
-        BlobClass = module.Blob;
+        BlobClass = /** @type {typeof Blob} */ (module.Blob);
       } catch {
         BlobClass = null;
       }
@@ -389,6 +391,7 @@ export default class HttpRequest {
     }
   }
 
+  // eslint-disable-next-line class-methods-use-this
   async formData() {
     throw new Error('UNSUPPORTED_MEDIA_TYPE');
   }

package/lib/HttpResponse.js

@@ -11,9 +11,9 @@ import { isWritable } from '../utils/stream.js';
 
 /** @typedef {import('http').OutgoingHttpHeaders} OutgoingHttpHeaders */
 /** @typedef {import('stream').Stream} Stream */
-/** @typedef {import('../types/index.js').Middleware} Middleware */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
 /** @typedef {import('./HttpRequest.js').default} HttpRequest */
-/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 /**
  * @typedef {Object} HttpResponseOptions
@@ -124,6 +124,7 @@ export default class HttpResponse {
   async sendRaw(body) {
     this.body = body;
     await new Promise((resolve, reject) => {
+      // @ts-expect-error Error is any
       this.stream.end(body, (error) => (error ? reject(error) : resolve()));
     });
     return 0;
@@ -135,7 +136,7 @@ export default class HttpResponse {
   }
 
   /**
-   * @param {Transform} stream
+   * @param {import('stream').Transform} stream
    * @return {this}
    */
   addUpstream(stream) {
@@ -162,6 +163,7 @@ export default class HttpResponse {
       // Called directly by user and needs finalizer calls
 
       this.isStreaming = true;
+      // eslint-disable-next-line no-plusplus
       for (let index = 0; index < this.finalizers.length; index++) {
         const process = this.finalizers[index];
         const result = process(this);
@@ -183,11 +185,13 @@ export default class HttpResponse {
       ];
     }
 
-    this.#pipeline = array[0];
-    // @ts-ignore Bad typings
+    // eslint-disable-next-line prefer-destructuring
+    this.#pipeline = /** @type {Writable} */ (array[0]);
+    // @ts-expect-error Bad typings
     pipeline(array, (error) => {
       this.#pipelineComplete = true;
       let nextCallback;
+      // eslint-disable-next-line no-cond-assign
       while ((nextCallback = this.#pipelineCallbacks.shift()) != null) {
         nextCallback(error);
       }
@@ -282,6 +286,7 @@ export default class HttpResponse {
     /** @type {void|Promise<boolean|void>} */
     let pendingPromise;
     let index;
+    // eslint-disable-next-line no-plusplus
     for (index = 0; index < this.finalizers.length; index++) {
       const process = this.finalizers[index];
       if (needsAsync) {
@@ -303,6 +308,7 @@ export default class HttpResponse {
     if (pendingPromise) {
       pendingPromise.then(async (initialResult) => {
         if (initialResult !== false) {
+          // eslint-disable-next-line no-plusplus
           for (index = 0; index < pendingProcessors.length; index++) {
             const process = pendingProcessors[index];
             const result = process(this);

package/lib/HttpTransaction.js

@@ -2,8 +2,8 @@
 /** @typedef {import('./HttpResponse.js').default} HttpResponse */
 /** @typedef {import('stream').Stream} Stream */
 
-/** @typedef {import('../types/index.js').MediaType} MediaType */
-/** @typedef {import('../types/index.js').Middleware} Middleware */
+/** @typedef {import('../data/custom-types.js').MediaType} MediaType */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
 /** @typedef {import('stream').Writable} Writable */
 
 /** @typedef {Partial<MediaType> & {parse:(this:HttpRequest)=>any|PromiseLike<any>, test?:(this:HttpRequest, mediaType: MediaType)=>boolean}} ContentReaderRegistration */

package/middleware/AutoHeadersMiddleware.js

@@ -1,6 +1,6 @@
 /** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
-/** @typedef {import('../types').ResponseFinalizer} ResponseFinalizer */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
 
 import { Transform } from 'node:stream';
 

package/middleware/CORSMiddleware.js

@@ -1,6 +1,6 @@
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
 
 /**
  * @typedef CORSMiddlewareOptions

package/middleware/CaseInsensitiveHeadersMiddleware.js

@@ -1,7 +1,7 @@
 import CaseInsensitiveObject from '../utils/CaseInsensitiveObject.js';
 
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
 
 /**
  * @typedef {Object} CaseInsensitiveHeadersMiddlewareOptions