remix 3.0.0-beta.4 → 3.0.0-beta.6

package/src/data-table-mysql/README.md

@@ -1,12 +1,12 @@
 # data-table-mysql
 
-MySQL adapter for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table). Use this package when you want `data-table` APIs backed by `mysql2`.
+MySQL database driver for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table), backed by `mysql2`.
 
 ## Features
 
-- **Native `mysql2` Integration**: Works with `mysql2/promise` `Pool` and `PoolConnection` instances
+- **Native `mysql2` Integration**: Creates a pool from `mysql2` configuration or uses an existing pool or connection
 - **Full `data-table` API Support**: Queries, relations, writes, and transactions
-- **Adapter-Owned Compiler**: SQL compilation lives in this adapter, with optional shared pure helpers from `data-table`
+- **MySQL Compiler**: SQL compilation is handled automatically for MySQL
 - **Multi-Statement Migrations**: `executeScript()` runs `up.sql` / `down.sql` files via `mysql2` (requires `multipleStatements: true`)
 - **MySQL Capabilities Enabled By Default**:
   - `returning: false`
@@ -24,17 +24,17 @@ npm i remix mysql2
 ## Usage
 
 ```ts
-import { createPool } from 'mysql2/promise'
-import { createDatabase } from 'remix/data-table'
-import { createMysqlDatabaseAdapter } from 'remix/data-table/mysql'
+import { createMysqlDatabase } from 'remix/data-table/mysql'
 
-let pool = createPool(process.env.DATABASE_URL as string)
-let db = createDatabase(createMysqlDatabaseAdapter(pool))
+let db = createMysqlDatabase({
+  uri: process.env.DATABASE_URL,
+  multipleStatements: true,
+})
 ```
 
 Use `db.query(...)`, relation loading, and transactions from `remix/data-table`. Import any driver-specific types you need directly from `mysql2/promise`.
 
-## Adapter Capabilities
+## Database Capabilities
 
 `data-table-mysql` reports this capability set by default:
 
@@ -48,22 +48,26 @@ Use `db.query(...)`, relation loading, and transactions from `remix/data-table`.
 
 ### Multi-Statement Migrations
 
-`remix/data-table/migrations` sends each migration to the adapter as a single multi-statement SQL script. mysql2 only accepts multi-statement scripts when the connection is created with `multipleStatements: true`:
+`remix/data-table/migrations` sends each migration as a single multi-statement SQL script. mysql2 only accepts multi-statement scripts when the connection is created with `multipleStatements: true`:
 
 ```ts
-import { createPool } from 'mysql2/promise'
+import { createMysqlDatabase } from 'remix/data-table/mysql'
 
-let pool = createPool({
+let db = createMysqlDatabase({
   uri: process.env.DATABASE_URL,
   multipleStatements: true,
 })
 ```
 
+Config-backed databases support `db.wipe()` and `db.reset()`. Call `await db.close()` during application shutdown to close the internally created pool. You may pass an existing `mysql2` pool or connection when your application owns the driver lifecycle; `db.close()` leaves supplied clients alone, and destructive lifecycle methods are unavailable in that mode. `db.wipe()` requires a database name in the connection config (`database`, or the path of a connection URI) and throws when none is present.
+
+Migration runs reserve one connection for the MySQL named lock, migration SQL, and journal updates. Lock acquisition waits up to 60 seconds and fails with an error instead of allowing the migration to proceed. After a successful run the connection is unlocked and returned to the pool; if the migration or unlock fails, the reserved connection is destroyed instead of being reused, so a dirty session can never leak back into the pool. Nested migration lock acquisition throws instead of deadlocking.
+
 ### `returning` On MySQL
 
-MySQL does not natively support SQL `RETURNING`. In this adapter, using `returning` on write operations throws `DataTableQueryError`.
+MySQL does not natively support SQL `RETURNING`. Using `returning` on write operations therefore throws `DataTableQueryError`.
 
-Use write metadata (`affectedRows`, `insertId`) on MySQL, or switch adapters when returned rows are required.
+Use write metadata (`affectedRows`, `insertId`) on MySQL, or switch databases when returned rows are required.
 
 ```ts
 import { DataTableQueryError } from 'remix/data-table'
@@ -74,17 +78,42 @@ try {
     .insert({ email: 'a@example.com', status: 'active' }, { returning: ['id'] })
 } catch (error) {
   if (error instanceof DataTableQueryError) {
-    // insert() returning is not supported by this adapter
+    // insert() returning is not supported by MySQL
   }
 }
 ```
 
+## Running integration tests locally
+
+To start a local MySQL container matching CI:
+
+```sh
+podman run --name mysql \
+  -e MYSQL_ROOT_PASSWORD=root \
+  -e MYSQL_DATABASE=remix \
+  -p 3306:3306 \
+  -d mysql:8
+```
+
+Then run:
+
+```sh
+REMIX_DATA_TABLE_MYSQL_TEST_URL=mysql://root:root@127.0.0.1:3306/remix \
+pnpm test src/lib/driver.integration.test.ts
+```
+
+Remove the container when you are done:
+
+```sh
+podman rm -f mysql
+```
+
 ## Related Packages
 
 - [`data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table) - Core query/relations API
 - [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Schema parsing and validation
-- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL adapter
-- [`data-table-sqlite`](https://github.com/remix-run/remix/tree/main/packages/data-table-sqlite) - SQLite adapter
+- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL database driver
+- [`data-table-sqlite`](https://github.com/remix-run/remix/tree/main/packages/data-table-sqlite) - SQLite database driver
 
 ## License
 

package/src/data-table-postgres/README.md

@@ -1,12 +1,12 @@
 # data-table-postgres
 
-PostgreSQL adapter for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table). Use this package when you want `data-table` APIs backed by `pg`.
+PostgreSQL database driver for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table), backed by `pg`.
 
 ## Features
 
-- **Native `pg` Integration**: Works with `pg` `Pool` and `PoolClient` instances
+- **Native `pg` Integration**: Creates a pool from `pg` configuration or uses an existing pool or client
 - **Full `data-table` API Support**: Queries, relations, writes, and transactions
-- **Adapter-Owned Compiler**: SQL compilation lives in this adapter, with optional shared pure helpers from `data-table`
+- **PostgreSQL Compiler**: SQL compilation is handled automatically for PostgreSQL
 - **Multi-Statement Migrations**: `executeScript()` runs `up.sql` / `down.sql` files natively via `pg`
 - **Postgres Capabilities Enabled By Default**:
   - `returning: true`
@@ -24,20 +24,20 @@ npm i remix pg
 ## Usage
 
 ```ts
-import { Pool } from 'pg'
-import { createDatabase } from 'remix/data-table'
-import { createPostgresDatabaseAdapter } from 'remix/data-table/postgres'
+import { createPostgresDatabase } from 'remix/data-table/postgres'
 
-let pool = new Pool({
+let db = createPostgresDatabase({
   connectionString: process.env.DATABASE_URL,
 })
-
-let db = createDatabase(createPostgresDatabaseAdapter(pool))
 ```
 
 Use `db.query(...)`, relation loading, and transactions from `remix/data-table`. Import any driver-specific types you need directly from `pg`.
 
-## Adapter Capabilities
+Config-backed databases support `db.wipe()` and `db.reset()`. Call `await db.close()` during application shutdown to close the internally created pool. You may pass an existing `pg` pool or client when your application owns the driver lifecycle; `db.close()` leaves supplied clients alone, and destructive lifecycle methods are unavailable in that mode. `db.wipe()` requires a database name resolvable from the connection config (`database`, the path of `connectionString`, or the `PGDATABASE` environment variable) and throws when none is present.
+
+Migration runs reserve one connection for the PostgreSQL advisory lock, migration SQL, and journal updates. Lock acquisition waits up to 60 seconds (via `lock_timeout`) and fails with an error instead of blocking forever. After a successful run the connection is unlocked and returned to the pool; if the migration or unlock fails, the reserved connection is destroyed instead of being reused, so a dirty session can never leak back into the pool. Nested migration lock acquisition throws instead of deadlocking.
+
+## Database Capabilities
 
 `data-table-postgres` reports this capability set by default:
 
@@ -51,7 +51,7 @@ Use `db.query(...)`, relation loading, and transactions from `remix/data-table`.
 
 ### Transaction Options
 
-Transaction options are passed through to the adapter as hints.
+Transaction options are passed through to PostgreSQL as hints.
 
 ```ts
 await db.transaction(async (txDb) => txDb.exec('select 1'), {
@@ -60,12 +60,38 @@ await db.transaction(async (txDb) => txDb.exec('select 1'), {
 })
 ```
 
+## Running integration tests locally
+
+To start a local Postgres container matching CI:
+
+```sh
+podman run --name postgres \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=remix \
+  -p 5432:5432 \
+  -d postgres:16
+```
+
+Then run:
+
+```sh
+REMIX_DATA_TABLE_POSTGRES_TEST_URL=postgres://postgres:postgres@127.0.0.1:5432/remix \
+pnpm test src/lib/driver.integration.test.ts
+```
+
+Remove the container when you are done:
+
+```sh
+podman rm -f postgres
+```
+
 ## Related Packages
 
 - [`data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table) - Core query/relations API
 - [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Schema parsing and validation
-- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL adapter
-- [`data-table-sqlite`](https://github.com/remix-run/remix/tree/main/packages/data-table-sqlite) - SQLite adapter
+- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL database driver
+- [`data-table-sqlite`](https://github.com/remix-run/remix/tree/main/packages/data-table-sqlite) - SQLite database driver
 
 ## License
 

package/src/data-table-sqlite/README.md

@@ -1,12 +1,12 @@
 # data-table-sqlite
 
-SQLite adapter for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table). Use this package when you want `data-table` APIs backed by a synchronous SQLite client.
+SQLite database driver for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table), backed by a synchronous SQLite client.
 
 ## Features
 
-- **Native Runtime SQLite Support**: Works with Node's `node:sqlite` `DatabaseSync`, Bun's `bun:sqlite` `Database`, and compatible synchronous SQLite clients
+- **Native Runtime SQLite Support**: Opens a configured filename with Node's `node:sqlite` or Bun's `bun:sqlite`, or uses a compatible synchronous SQLite client
 - **Full `data-table` API Support**: Queries, relations, writes, and transactions
-- **Adapter-Owned Compiler**: SQL compilation lives in this adapter, with optional shared pure helpers from `data-table`
+- **SQLite Compiler**: SQL compilation is handled automatically for SQLite
 - **Multi-Statement Migrations**: `executeScript()` runs `up.sql` / `down.sql` files via `Database.exec()`
 - **SQLite Capabilities Enabled By Default**:
   - `returning: true`
@@ -23,31 +23,42 @@ npm i remix
 
 ## Usage
 
-### Node
-
 ```ts
-import { DatabaseSync } from 'node:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
-let sqlite = new DatabaseSync('app.db')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase({
+  filename: 'app.db',
+  foreignKeys: true,
+})
 ```
 
-### Bun
+The config-backed database uses `node:sqlite` in Node.js and `bun:sqlite` in Bun. It supports `db.wipe()` and `db.reset()` because it can close and reopen the database file. Call `await db.close()` during application shutdown to release the connection and its file handle.
+
+Foreign key enforcement defaults to off on every runtime. When `foreignKeys` is enabled, the database restores foreign key enforcement each time it opens the connection, including after destructive lifecycle operations.
+
+The database also applies `pragma busy_timeout = 5000` whenever it opens the connection, so writes wait for a locked database instead of failing immediately with `SQLITE_BUSY`. Use `busyTimeout` to override the timeout in milliseconds (`0` disables the wait).
+
+You may also pass an existing synchronous client when your application owns its lifecycle:
 
 ```ts
 import { Database } from 'bun:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
 let sqlite = new Database('app.db')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase(sqlite)
+
+// Leaves the supplied client open.
+await db.close()
+
+// The application closes the client it owns.
+sqlite.close()
 ```
 
+Destructive lifecycle methods are unavailable when you pass an existing client.
+
 This is a good fit for local development, embedded deployments, and single-node services. Import any driver-specific types you need directly from your runtime's SQLite module.
 
-## Adapter Capabilities
+## Database Capabilities
 
 `data-table-sqlite` reports this capability set by default:
 
@@ -59,23 +70,30 @@ This is a good fit for local development, embedded deployments, and single-node
 
 ## Advanced Usage
 
+### Destructive Lifecycle And Locking
+
+`db.wipe()` and `db.reset()` assume a single process owns the database file. Stop other processes before wiping: on POSIX systems another process keeps writing to the deleted inode, and on Windows an open handle blocks deletion entirely. Wiping removes the `-wal`, `-shm`, and `-journal` sidecar files along with the main database file so a freshly created database never associates with stale sidecars.
+
+SQLite migrations run without a cross-process migration lock (`migrationLock: false`), so run migrations from one process at a time.
+
+`filename` resolves against the current working directory — for `remix db` commands, wherever you invoke the CLI. Prefer absolute paths or paths derived from `import.meta.dirname`.
+
 ### In-Memory Database For Tests
 
 ```ts
 import { DatabaseSync } from 'node:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
 let sqlite = new DatabaseSync(':memory:')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase(sqlite)
 ```
 
 ## Related Packages
 
 - [`data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table) - Core query/relations API
 - [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Schema parsing and validation
-- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL adapter
-- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL adapter
+- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL database driver
+- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL database driver
 
 ## License
 

package/src/fetch-proxy/README.md

@@ -7,6 +7,7 @@ HTTP proxy utilities built on the web [Fetch API](https://developer.mozilla.org/
 - **Web Standards** - Built on the standard [JavaScript Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
 - **Cookie Rewriting** - Supports rewriting `Set-Cookie` headers received from target server
 - **Forwarding Headers** - Supports `X-Forwarded-Proto`, `X-Forwarded-Host`, and `X-Forwarded-Port` headers
+- **Encoding Headers** - Strips stale encoding and framing headers from proxied responses
 - **Custom Fetch** - Supports custom `fetch` implementations
 
 ## Installation
@@ -36,9 +37,33 @@ let title = text.match(/<title>([^<]+)<\/title>/)[1]
 assert(title.includes('Remix'))
 ```
 
+## Encoding and Framing Headers
+
+Since proxying is done via `fetch` rather than raw HTTP messages, some encoding and framing headers need to be removed.
+
+The incoming `Accept-Encoding` request header describes the final client, so it is not forwarded to the target server.
+
+Since `fetch` can decompress upstream responses and does not expose raw HTTP transfer framing, `fetch-proxy` strips response headers that may no longer describe the returned body: `Content-Encoding`, related `Content-Length`, and `Transfer-Encoding`.
+
+To support serving compressed responses to the final client, you'll need to compress the response after the proxy returns it, e.g. with the [`compressResponse` helper from `remix/response`](https://github.com/remix-run/remix/tree/main/packages/response#compress-responses):
+
+```ts
+import { createFetchProxy } from 'remix/fetch-proxy'
+import { compressResponse } from 'remix/response/compress'
+
+let proxy = createFetchProxy('https://remix.run')
+
+async function handleFetch(request: Request): Promise<Response> {
+  let response = await proxy(request)
+
+  return compressResponse(response, request)
+}
+```
+
 ## Related Packages
 
 - [`node-fetch-server`](https://github.com/remix-run/remix/tree/main/packages/node-fetch-server) - Build HTTP servers for Node.js using the web fetch API
+- [`response`](https://github.com/remix-run/remix/tree/main/packages/response) - Create, transform, and compress Fetch API responses
 
 ## License
 

package/src/form-data-parser/README.md

@@ -7,7 +7,7 @@ A streaming `multipart/form-data` parser that solves memory issues with file upl
 - **Drop-in replacement** for `request.formData()` with streaming file upload support
 - **Minimal buffering** - processes file upload streams with minimal memory footprint
 - **Standards-based** - built on the [web Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) and [File API](https://developer.mozilla.org/en-US/docs/Web/API/File)
-- **Smart fallback** - automatically uses native `request.formData()` for non-`multipart/form-data` requests
+- **Smart fallback** - parses `application/x-www-form-urlencoded` requests with the same total size and field count limits, and uses native `request.formData()` for other form requests
 - **Storage agnostic** - works with any storage backend (local disk, S3, R2, etc.)
 
 ## Why You Need This
@@ -74,7 +74,7 @@ async function requestHandler(request: Request) {
 
 To validate the resulting `FormData` object with `remix/data-schema`, use the `remix/data-schema/form-data` helpers.
 
-To limit the overall shape of multipart requests, use the `maxHeaderSize`, `maxFileSize`, `maxFiles`, `maxParts`, and `maxTotalSize` options. By default, `parseFormData()` uses `maxFiles = 20`, `maxParts = 1000`, and `maxTotalSize = maxFiles * maxFileSize + 1 MiB`.
+To limit the overall shape of multipart requests, use the `maxHeaderSize`, `maxFileSize`, `maxFiles`, `maxParts`, and `maxTotalSize` options. For `application/x-www-form-urlencoded` requests, `maxParts` limits the number of form fields and `maxTotalSize` limits the raw request body size. By default, `parseFormData()` uses `maxFiles = 20`, `maxParts = 1000`, and `maxTotalSize = maxFiles * maxFileSize + 1 MiB`.
 
 Known limit errors are thrown directly so you can handle them with `instanceof` checks. Other failures while parsing the request body are wrapped in `FormDataParseError`, with the original error available as `error.cause`. Errors thrown or rejected by your `uploadHandler` are not wrapped.
 
@@ -106,9 +106,9 @@ try {
   } else if (error instanceof MaxFileSizeExceededError) {
     console.error(`Files may not be larger than 10 MiB`)
   } else if (error instanceof MaxPartsExceededError) {
-    console.error(`Request may not contain more than 25 multipart parts`)
+    console.error(`Request may not contain more than 25 form fields or multipart parts`)
   } else if (error instanceof MaxTotalSizeExceededError) {
-    console.error(`Multipart request may not exceed 12 MiB of total content`)
+    console.error(`Form data request may not exceed 12 MiB of total content`)
   } else if (error instanceof FormDataParseError) {
     console.error(`Could not parse form data:`, error.cause ?? error)
   } else {

package/src/mime/README.md

@@ -86,12 +86,19 @@ mimeTypeToContentType('image/png') // 'image/png'
 Registers or overrides a MIME type for one or more file extensions.
 
 ```ts
-import { defineMimeType } from 'remix/mime'
+import { defineMimeType, detectMimeType } from 'remix/mime'
 
 defineMimeType({
   extensions: ['myformat'],
   mimeType: 'application/x-myformat',
 })
+
+defineMimeType({
+  extensions: ['be.pit'],
+  mimeType: 'application/x-be-pit-document',
+})
+
+detectMimeType('filename.be.pit') // 'application/x-be-pit-document'
 ```
 
 You can also optionally configure the charset and whether the MIME type is compressible:

package/src/node-fetch-server/README.md

@@ -8,7 +8,8 @@ Build Node.js servers with web-standard Fetch API primitives. `node-fetch-server
 - **Node.js HTTP Integration** - Works directly with `node:http`, `node:https`, and `node:http2`
 - **Streaming Support** - Response support with `ReadableStream`
 - **Custom Hostname** - Configuration for deployment flexibility
-- **Client Info** - Access to client connection info (IP address, port)
+- **Proxy Header Support** - Opt in to trusted `Forwarded`, `X-Forwarded-Host`, `X-Forwarded-Proto`, and `X-Forwarded-For` headers
+- **Client Info** - Access to client connection info (IP address, port, and trusted proxy address)
 - **TypeScript** - Full TypeScript support with type definitions
 
 ## Installation
@@ -146,9 +147,34 @@ let server = http.createServer(createRequestListener(handler, { host: hostname }
 server.listen(3000)
 ```
 
+### Trusted Proxy Headers
+
+If your app runs behind a trusted reverse proxy, Node.js sees the proxy connection instead of the original client connection. Enable `trustProxy` to use trusted proxy headers when constructing `request.url` and client information:
+
+- `Forwarded: proto` and `X-Forwarded-Proto` can provide the original request protocol.
+- `Forwarded: host` and `X-Forwarded-Host` can provide the original request host.
+- `Forwarded: for` and `X-Forwarded-For` can provide the original client address.
+
+Only enable this option when your server is reachable exclusively through a trusted proxy that overwrites these headers. Otherwise, clients can spoof the host, protocol, and client address.
+
+```ts
+import * as http from 'node:http'
+import { createRequestListener } from 'remix/node-fetch-server'
+
+let server = http.createServer(
+  createRequestListener(handler, {
+    trustProxy: true,
+  }),
+)
+
+server.listen(3000)
+```
+
+When `host` or `protocol` are set, those fixed options take precedence over trusted proxy headers.
+
 ### Accessing Client Information
 
-Get client connection details (IP address, port) for logging or security:
+Get client connection details (IP address, port) for logging or security. When `trustProxy` is enabled, `client.address` uses trusted `Forwarded` or `X-Forwarded-For` values when present:
 
 ```ts
 import { type FetchHandler } from 'remix/node-fetch-server'
@@ -308,9 +334,9 @@ pnpm run bench:update-readme
 
 <!-- benchmarks:start -->
 
-Last updated: 2026-04-29T17:19:30.407Z
+Last updated: 2026-07-23T20:29:32.942Z
 
-Environment: Darwin 25.3.0, Apple M1 Pro, Node.js v24.15.0
+Environment: Darwin 25.4.0, Apple M5 Pro, Node.js v24.18.0
 
 Command: `wrk -t12 -c400 -d30s`
 
@@ -320,9 +346,9 @@ Simple HTML response benchmarks without inspecting the incoming request.
 
 | Server                    |   Version | Requests/sec | Avg latency | Transfer/sec |
 | ------------------------- | --------: | -----------: | ----------: | -----------: |
-| `node:http`               | `24.15.0` |     `47,110` |   `10.66ms` |     `9.66MB` |
-| `remix/node-fetch-server` |  `0.13.0` |     `43,317` |   `11.69ms` |     `8.80MB` |
-| `express`                 |   `5.2.1` |     `39,752` |   `13.69ms` |     `9.59MB` |
+| `node:http`               | `24.18.0` |     `66,594` |    `5.96ms` |    `13.65MB` |
+| `remix/node-fetch-server` |  `0.14.0` |     `61,587` |    `7.88ms` |    `12.51MB` |
+| `express`                 |   `5.2.1` |     `58,424` |    `8.42ms` |    `14.10MB` |
 
 ### Small Body
 
@@ -330,9 +356,9 @@ POST benchmarks that read and print the request method, headers, and a small bod
 
 | Server                    |   Version | Requests/sec | Avg latency | Transfer/sec |
 | ------------------------- | --------: | -----------: | ----------: | -----------: |
-| `remix/node-fetch-server` |  `0.13.0` |     `25,430` |   `24.25ms` |     `5.17MB` |
-| `node:http`               | `24.15.0` |     `25,088` |   `23.89ms` |     `5.14MB` |
-| `express`                 |   `5.2.1` |     `22,845` |   `27.16ms` |     `5.51MB` |
+| `node:http`               | `24.18.0` |     `35,303` |   `15.60ms` |     `7.24MB` |
+| `express`                 |   `5.2.1` |     `32,614` |   `16.93ms` |     `7.87MB` |
+| `remix/node-fetch-server` |  `0.14.0` |     `29,521` |   `18.98ms` |     `6.00MB` |
 
 ### Large Body
 
@@ -340,9 +366,9 @@ POST benchmarks that read and print the request method, headers, and a 1 MB body
 
 | Server                    |   Version | Requests/sec | Avg latency | Transfer/sec |
 | ------------------------- | --------: | -----------: | ----------: | -----------: |
-| `remix/node-fetch-server` |  `0.13.0` |      `1,086` |  `217.69ms` |   `225.87KB` |
-| `node:http`               | `24.15.0` |      `1,079` |  `198.67ms` |   `226.54KB` |
-| `express`                 |   `5.2.1` |      `1,022` |  `216.07ms` |   `252.51KB` |
+| `node:http`               | `24.18.0` |      `1,798` |  `206.65ms` |   `377.42KB` |
+| `remix/node-fetch-server` |  `0.14.0` |      `1,752` |  `167.69ms` |   `364.40KB` |
+| `express`                 |   `5.2.1` |      `1,731` |  `223.19ms` |   `427.67KB` |
 
 <!-- benchmarks:end -->