remix 3.0.0-beta.5 → 3.0.0-beta.6

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'), {
@@ -77,7 +77,7 @@ Then run:
 
 ```sh
 REMIX_DATA_TABLE_POSTGRES_TEST_URL=postgres://postgres:postgres@127.0.0.1:5432/remix \
-pnpm test src/lib/adapter.integration.test.ts
+pnpm test src/lib/driver.integration.test.ts
 ```
 
 Remove the container when you are done:
@@ -90,8 +90,8 @@ podman rm -f postgres
 
 - [`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/node-fetch-server/README.md

@@ -334,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`
 
@@ -346,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
 
@@ -356,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
 
@@ -366,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 -->
 

package/src/node-hmr/README.md

@@ -0,0 +1,307 @@
+# node-hmr
+
+Run Node.js applications with Hot Module Reloading.
+
+## Features
+
+- **HMR Runtime**: Provides an `import.meta.hot` API for modules that can handle hot updates
+- **Module Hook Friendly**: Use Node's module customization hooks API to automatically insert `import.meta.hot` usage
+- **Restart Fallback**: Restarts the child Node process when updates aren't accepted
+- **Fetch Proxy Support**: Wrap fetch handlers so requests are delayed/retried during server updates/restarts
+- **Browser HMR Integration**: Optionally hosts browser HMR coordination that survives child restarts
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Create a development script that starts your app server with HMR enabled, along with any additional Node args, such as the `--import` flag to provide [Node module customization hooks](https://nodejs.org/api/module.html#customization-hooks) for [JSX syntax support](https://github.com/remix-run/remix/tree/main/packages/node-tsx) and [Remix component HMR](https://github.com/remix-run/remix/tree/main/packages/ui-hmr):
+
+```ts
+// hmr.ts
+import { run } from 'remix/node-hmr'
+
+run('./server.ts', {
+  nodeArgs: ['--import', 'remix/node-tsx', '--import', 'remix/ui-hmr/node'],
+  watch: {
+    ignore: ['**/node_modules/**'],
+  },
+})
+```
+
+Then run the script with Node:
+
+```json
+{
+  "scripts": {
+    "hmr": "NODE_ENV=development node hmr.ts"
+  }
+}
+```
+
+## Fetch Proxy Support
+
+During development, server updates can briefly leave your app unable to handle requests. In a server-only context, requests may be rejected while the child server is restarting. In a browser context, the browser may refresh or revalidate at the same time as a server restart, which can result in failed requests or a broken page.
+
+A stable proxy server can avoid this by continuing to listen on the public port while `node-hmr` updates the child server behind it. `createHmrReadyFetch()` works with any fetch handler, so you can compose it with `createFetchProxy()` from [`remix/fetch-proxy`](https://github.com/remix-run/remix/tree/main/packages/fetch-proxy) to forward requests to the child server while delaying or retrying requests during updates.
+
+```ts
+// hmr.ts
+import * as http from 'node:http'
+
+import { createFetchProxy } from 'remix/fetch-proxy'
+import { run, createHmrReadyFetch } from 'remix/node-hmr'
+import { createRequestListener } from 'remix/node-fetch-server'
+
+const hmrProxyPort = 44100
+const appPort = 44101
+
+const hmrRunner = run('./server.ts', {
+  env: {
+    ...process.env,
+    PORT: String(appPort),
+  },
+  nodeArgs: ['--import', 'remix/node-tsx'],
+})
+
+const proxyFetch = createFetchProxy(`http://127.0.0.1:${appPort}`, {
+  xForwardedHeaders: true,
+})
+
+const server = http.createServer(createRequestListener(createHmrReadyFetch(hmrRunner, proxyFetch)))
+
+server.listen(hmrProxyPort)
+```
+
+By default, `createHmrReadyFetch()` retries `GET` and `HEAD` requests when the wrapped fetch handler throws or returns a `502`, `503`, or `504` response, but only if the server updated or restarted while the request was in flight. You can customize this policy with `shouldRetry`:
+
+```ts
+let fetchWhenReady = createHmrReadyFetch(hmrRunner, proxyFetch, {
+  shouldRetry({ request, response }) {
+    if (request.method !== 'GET' && request.method !== 'HEAD') return false
+
+    return response === undefined || [502, 503, 504].includes(response.status)
+  },
+})
+```
+
+## Browser HMR Integration
+
+`node-hmr` can coordinate browser-facing HMR alongside server HMR. The parent process hosts the browser event stream, tracks files reported by asset servers in the child process, sends matching file events back to the child runtime, and emits the resulting browser updates to connected clients.
+
+This is co-ordinated through the use of a browser HMR channel which can be created within the app server when running in `node-hmr` via the `remix/node-hmr/runtime` import:
+
+```ts
+import { createBrowserHmrChannel } from 'remix/node-hmr/runtime'
+
+let browserHmrChannel = await createBrowserHmrChannel()
+```
+
+The `remix/node-hmr/runtime` API is only available inside a child process supervised by `node-hmr`. Importing it outside `node-hmr` throws. Supervised child processes automatically receive the `REMIX_NODE_HMR` environment variable which you can check before dynamically importing the runtime API:
+
+```ts
+if (process.env.REMIX_NODE_HMR) {
+  let { createBrowserHmrChannel } = await import('remix/node-hmr/runtime')
+  let browserHmrChannel = await createBrowserHmrChannel()
+}
+```
+
+A browser HMR channel is scoped to the current child process. It gives browser HMR tooling an EventSource URL, a way to report the files it wants watched, and a way to respond to file changes with browser HMR events.
+
+Browser asset servers can use this API to co-ordinate browser HMR with the server, for example, [`remix/assets`](https://github.com/remix-run/remix/tree/main/packages/assets) via its `hmr` option to `createAssetServer`:
+
+```ts
+import { createAssetServer } from 'remix/assets'
+
+let isDevelopment = process.env.NODE_ENV === 'development'
+
+let assetServer = createAssetServer({
+  basePath: '/assets',
+  fileMap: { '/app/*path': 'app/*path' },
+  allowFiles: ['app/routes.ts', 'app/**/public/**'],
+  denyFiles: ['app/**/*.test.*'],
+  hmr:
+    isDevelopment && process.env.REMIX_NODE_HMR
+      ? async () => (await import('remix/node-hmr/runtime')).createBrowserHmrChannel()
+      : undefined,
+  watch: isDevelopment,
+})
+```
+
+When `node-hmr` hot updates or restarts server code in a way that should refresh server-rendered UI, it sends a `server:update` event to connected clients.
+
+Call `emitServerReady()` when your app server is ready to receive requests. This lets the parent process delay browser `server:update` events until a restarted app server has finished listening:
+
+```ts
+server.listen(port, () => {
+  if (process.env.REMIX_NODE_HMR) {
+    import('remix/node-hmr/runtime').then((nodeHmr) => nodeHmr.emitServerReady())
+  }
+})
+```
+
+## File Watching
+
+The file system is watched automatically so server source changes can hot update or restart the child process.
+
+You can optionally provide an array of glob patterns to the `watch.ignore` option.
+
+```ts
+import { run } from 'remix/node-hmr'
+
+run('./server.ts', {
+  nodeArgs: ['--import', 'remix/node-tsx', '--import', 'remix/ui-hmr/node'],
+  watch: {
+    ignore: ['**/node_modules/**'],
+  },
+})
+```
+
+You can also configure polling behavior. Polling defaults to `true` on Windows and `false` elsewhere:
+
+```ts
+import { run } from 'remix/node-hmr'
+
+run('./server.ts', {
+  nodeArgs: ['--import', 'remix/node-tsx', '--import', 'remix/ui-hmr/node'],
+  watch: {
+    poll: true,
+    pollInterval: 100,
+  },
+})
+```
+
+## `import.meta.hot`
+
+The `import.meta.hot` API provided by `node-hmr` is a small runtime contract for modules that can handle updates without restarting the process. It is primarily intended for transforms like [remix/ui-hmr](https://github.com/remix-run/remix/tree/main/packages/ui-hmr), but it can also be used directly.
+
+To type `import.meta.hot`, add the HMR types to your TypeScript config:
+
+```json
+{
+  "compilerOptions": {
+    "types": ["remix/node-hmr/types"]
+  }
+}
+```
+
+HMR accept calls are statically analyzed. Write them directly as `import.meta.hot.accept(...)`. Dependency accepts must use string literals or arrays of string literals; do not alias `import.meta.hot` or pass dynamically constructed dependency lists.
+
+```ts
+if (import.meta.hot) {
+  import.meta.hot.accept()
+}
+```
+
+For consistency with browser HMR environments, `node-hmr` also implements `import.meta.hot.on(...)`, but no events are fired in server modules.
+
+### Accepting updates
+
+Calling `accept()` makes the current module an HMR boundary. When the module changes, `node-hmr` evaluates the updated module and calls your callback with its exports.
+
+```ts
+export let value = 1
+
+if (import.meta.hot) {
+  import.meta.hot.accept((module) => {
+    if (typeof module.value !== 'number') {
+      import.meta.hot?.invalidate('Updated module no longer exports value')
+      return
+    }
+
+    value = module.value
+  })
+}
+```
+
+You can also accept updates from direct dependencies.
+
+```ts
+import { value } from './value.ts'
+
+let currentValue = value
+
+export function readValue() {
+  return currentValue
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept('./value.ts', (module) => {
+    if (typeof module.value !== 'number') {
+      import.meta.hot?.invalidate('Updated dependency no longer exports value')
+      return
+    }
+
+    currentValue = module.value
+  })
+}
+```
+
+Multiple dependencies can be accepted at once. The callback receives an array where only the changed dependency is defined.
+
+```ts
+if (import.meta.hot) {
+  import.meta.hot.accept(['./one.ts', './two.ts'], ([oneModule, twoModule]) => {
+    // oneModule is defined when ./one.ts changed.
+    // twoModule is defined when ./two.ts changed.
+  })
+}
+```
+
+### Cleaning up
+
+Register cleanup that should run before the module is replaced or disposed.
+
+```ts
+let interval = setInterval(refreshCache, 30_000)
+
+if (import.meta.hot) {
+  import.meta.hot.dispose(() => {
+    clearInterval(interval)
+  })
+}
+```
+
+The `data` object is preserved across updates for the same module. Use it for small pieces of state.
+
+```ts
+let count = Number(import.meta.hot?.data.count ?? 0)
+
+export function increment() {
+  count++
+}
+
+if (import.meta.hot) {
+  import.meta.hot.dispose((data) => {
+    data.count = count
+  })
+}
+```
+
+### Invalidating updates
+
+Call `invalidate()` inside an accept callback when the update cannot be applied safely. `node-hmr` falls back to a process restart.
+
+```ts
+if (import.meta.hot) {
+  import.meta.hot.accept((module) => {
+    if (typeof module.value !== 'number') {
+      import.meta.hot?.invalidate('Updated module no longer exports value')
+      return
+    }
+  })
+}
+```
+
+## Related Packages
+
+- [`assets`](https://github.com/remix-run/remix/tree/main/packages/assets) - Consumes browser HMR channels for coordinating server and browser HMR updates
+- [`fetch-proxy`](https://github.com/remix-run/remix/tree/main/packages/fetch-proxy) - Creates fetch handlers for forwarding requests to another server
+- [`ui-hmr`](https://github.com/remix-run/remix/tree/main/packages/ui-hmr) - Provides code transforms and runtime for HMR for Remix UI components
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/node-hmr/runtime.ts

@@ -0,0 +1,2 @@
+// IMPORTANT: This file is auto-generated, please do not edit manually.
+export * from '@remix-run/node-hmr/runtime'

package/src/node-hmr/types.d.ts

@@ -0,0 +1,2 @@
+// IMPORTANT: This file is auto-generated, please do not edit manually.
+export type * from '@remix-run/node-hmr/types'

package/src/node-hmr.ts

@@ -0,0 +1,2 @@
+// IMPORTANT: This file is auto-generated, please do not edit manually.
+export * from '@remix-run/node-hmr'