remix 3.0.0-beta.0 → 3.0.0-beta.2

package/src/multipart-parser/README.md

@@ -0,0 +1,241 @@
+# multipart-parser
+
+Fast streaming multipart parsing for JavaScript. `multipart-parser` processes multipart bodies incrementally so large uploads can be handled without buffering the entire multipart payload in memory.
+
+## Features
+
+- **File Upload Parsing** - Parse file uploads (`multipart/form-data`) with automatic field and file detection
+- **Full Multipart Support** - Support for all `multipart/*` content types (mixed, alternative, related, etc.)
+- **Convenient API** - `MultipartPart` API with `arrayBuffer`, `bytes`, `text`, `size`, and metadata access
+- **Built-in Limits** - Header, per-part, part-count, and aggregate-size limits to prevent abuse
+- **Node.js Support** - First-class Node.js support with native `http.IncomingMessage` compatibility
+- **Runtime Demos** - [Demos for every major runtime](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos)
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+The most common use case for `multipart-parser` is handling file uploads when you're building a web server. For this case, the `parseMultipartRequest` function is your friend. It automatically validates the request is `multipart/form-data`, extracts the multipart boundary from the `Content-Type` header, parses all fields and files in the `request.body` stream, and gives each one to you as a `MultipartPart` object with a rich API for accessing its metadata and content.
+
+```ts
+import { MultipartParseError, parseMultipartRequest } from 'remix/multipart-parser'
+
+async function handleRequest(request: Request): void {
+  try {
+    for await (let part of parseMultipartRequest(request)) {
+      if (part.isFile) {
+        // Access file data in multiple formats
+        let buffer = part.arrayBuffer // ArrayBuffer
+        console.log(`File received: ${part.filename} (${buffer.byteLength} bytes)`)
+        console.log(`Content type: ${part.mediaType}`)
+        console.log(`Field name: ${part.name}`)
+        console.log(`Content-Type header: ${part.headers['content-type']}`)
+
+        // Save to disk, upload to cloud storage, etc.
+        await saveFile(part.filename, part.bytes)
+      } else {
+        let text = part.text // string
+        console.log(`Field received: ${part.name} = ${JSON.stringify(text)}`)
+      }
+    }
+  } catch (error) {
+    if (error instanceof MultipartParseError) {
+      console.error('Failed to parse multipart request:', error.message)
+    } else {
+      console.error('An unexpected error occurred:', error)
+    }
+  }
+}
+```
+
+## Part Headers
+
+Each `MultipartPart` exposes decoded part headers as a plain object keyed by lower-case header name. Values are strings, and repeated headers are joined with `, `. Multipart part headers are parsed metadata from the request body, not native `Headers` objects, so access them with bracket notation:
+
+```ts
+for await (let part of parseMultipartRequest(request)) {
+  let contentDisposition = part.headers['content-disposition']
+  let contentType = part.headers['content-type']
+
+  console.log(contentDisposition, contentType)
+}
+```
+
+## Size Limits
+
+A common use case when handling file uploads is limiting the overall shape of incoming multipart bodies so malicious clients cannot force unbounded growth in memory. Use `maxFileSize` to limit each part, `maxParts` to limit how many parts are accepted, and `maxTotalSize` to limit aggregate part content across the entire request. `multipart-parser` applies finite defaults for each of these limits.
+
+```ts
+import {
+  MultipartParseError,
+  MaxFileSizeExceededError,
+  MaxPartsExceededError,
+  MaxTotalSizeExceededError,
+  parseMultipartRequest,
+} from 'remix/multipart-parser/node'
+
+const oneMb = Math.pow(2, 20)
+const limits = {
+  maxFileSize: 10 * oneMb,
+  maxParts: 100,
+  maxTotalSize: 25 * oneMb,
+}
+
+async function handleRequest(request: Request): Promise<Response> {
+  try {
+    for await (let part of parseMultipartRequest(request, limits)) {
+      // ...
+    }
+  } catch (error) {
+    if (error instanceof MaxFileSizeExceededError) {
+      return new Response('File size limit exceeded', { status: 413 })
+    } else if (error instanceof MaxPartsExceededError) {
+      return new Response('Too many multipart parts', { status: 413 })
+    } else if (error instanceof MaxTotalSizeExceededError) {
+      return new Response('Multipart request is too large', { status: 413 })
+    } else if (error instanceof MultipartParseError) {
+      return new Response('Failed to parse multipart request', { status: 400 })
+    } else {
+      console.error(error)
+      return new Response('Internal Server Error', { status: 500 })
+    }
+  }
+}
+```
+
+## Node.js Bindings
+
+The main module (`import {} from 'remix/multipart-parser'`) assumes you're working with [the fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) (`Request`, `ReadableStream`, etc). Support for these interfaces was added to Node.js by the [undici](https://github.com/nodejs/undici) project in [version 16.5.0](https://nodejs.org/en/blog/release/v16.5.0).
+
+If however you're building a server for Node.js that relies on node-specific APIs like `http.IncomingMessage`, `stream.Readable`, and `buffer.Buffer` (ala Express or `http.createServer`), `multipart-parser` ships with an additional module that works directly with these APIs.
+
+```ts
+import * as http from 'node:http'
+import { MultipartParseError, parseMultipartRequest } from 'remix/multipart-parser/node'
+
+let server = http.createServer(async (req, res) => {
+  try {
+    for await (let part of parseMultipartRequest(req)) {
+      // ...
+    }
+  } catch (error) {
+    if (error instanceof MultipartParseError) {
+      console.error('Failed to parse multipart request:', error.message)
+    } else {
+      console.error('An unexpected error occurred:', error)
+    }
+  }
+})
+
+server.listen(8080)
+```
+
+## Low-level API
+
+If you're working directly with multipart boundaries and buffers/streams of multipart data that are not necessarily part of a request, `multipart-parser` provides a low-level `parseMultipart()` API that you can use directly:
+
+```ts
+import { parseMultipart } from 'remix/multipart-parser'
+
+let message = new Uint8Array(/* ... */)
+let boundary = '----WebKitFormBoundary56eac3x'
+
+for (let part of parseMultipart(message, { boundary })) {
+  // ...
+}
+```
+
+In addition, the `parseMultipartStream` function provides an `async` generator interface for multipart data in a `ReadableStream`:
+
+```ts
+import { parseMultipartStream } from 'remix/multipart-parser'
+
+let message = new ReadableStream(/* ... */)
+let boundary = '----WebKitFormBoundary56eac3x'
+
+for await (let part of parseMultipartStream(message, { boundary })) {
+  // ...
+}
+```
+
+## Demos
+
+The [`demos` directory](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos) contains a few working demos of how you can use this library:
+
+- [`demos/bun`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/bun) - using multipart-parser in Bun
+- [`demos/cf-workers`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/cf-workers) - using multipart-parser in a Cloudflare Worker and storing file uploads in R2
+- [`demos/deno`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/deno) - using multipart-parser in Deno
+- [`demos/node`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/node) - using multipart-parser in Node.js
+
+## Benchmark
+
+`multipart-parser` is designed to be as efficient as possible, operating on streams of data and rarely buffering in common usage. This design yields exceptional performance when handling multipart payloads of any size. In benchmarks, `multipart-parser` is as fast or faster than `busboy`.
+
+The results of running the benchmarks on my laptop:
+
+```
+> @remix-run/multipart-parser@0.10.1 bench:node /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> node ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:27:09 PM
+Node.js v24.0.2
+┌──────────────────┬──────────────────┬──────────────────┬──────────────────┬───────────────────┐
+│ (index)          │ 1 small file     │ 1 large file     │ 100 small files  │ 5 large files     │
+├──────────────────┼──────────────────┼──────────────────┼──────────────────┼───────────────────┤
+│ multipart-parser │ '0.01 ms ± 0.03' │ '1.08 ms ± 0.08' │ '0.04 ms ± 0.01' │ '10.50 ms ± 0.38' │
+│ multipasta       │ '0.02 ms ± 0.06' │ '1.07 ms ± 0.02' │ '0.15 ms ± 0.02' │ '10.46 ms ± 0.11' │
+│ busboy           │ '0.06 ms ± 0.17' │ '3.07 ms ± 0.24' │ '0.24 ms ± 0.05' │ '29.85 ms ± 0.18' │
+│ @fastify/busboy  │ '0.05 ms ± 0.13' │ '1.23 ms ± 0.09' │ '0.45 ms ± 0.22' │ '11.81 ms ± 0.11' │
+└──────────────────┴──────────────────┴──────────────────┴──────────────────┴───────────────────┘
+
+> @remix-run/multipart-parser@0.10.1 bench:bun /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> bun run ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:27:31 PM
+Bun 1.2.13
+┌──────────────────┬────────────────┬────────────────┬─────────────────┬─────────────────┐
+│                  │ 1 small file   │ 1 large file   │ 100 small files │ 5 large files   │
+├──────────────────┼────────────────┼────────────────┼─────────────────┼─────────────────┤
+│ multipart-parser │ 0.01 ms ± 0.04 │ 0.86 ms ± 0.09 │ 0.04 ms ± 0.01  │ 8.32 ms ± 0.26  │
+│       multipasta │ 0.02 ms ± 0.07 │ 0.87 ms ± 0.03 │ 0.25 ms ± 0.21  │ 8.27 ms ± 0.09  │
+│           busboy │ 0.05 ms ± 0.17 │ 3.54 ms ± 0.10 │ 0.30 ms ± 0.03  │ 34.79 ms ± 0.38 │
+│  @fastify/busboy │ 0.06 ms ± 0.18 │ 4.04 ms ± 0.08 │ 0.48 ms ± 0.06  │ 39.91 ms ± 0.37 │
+└──────────────────┴────────────────┴────────────────┴─────────────────┴─────────────────┘
+
+> @remix-run/multipart-parser@0.10.1 bench:deno /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> deno run --allow-sys ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:28:12 PM
+Deno 2.3.6
+┌──────────────────┬──────────────────┬────────────────────┬──────────────────┬─────────────────────┐
+│ (idx)            │ 1 small file     │ 1 large file       │ 100 small files  │ 5 large files       │
+├──────────────────┼──────────────────┼────────────────────┼──────────────────┼─────────────────────┤
+│ multipart-parser │ "0.01 ms ± 0.03" │ "1.03 ms ± 0.04"   │ "0.05 ms ± 0.01" │ "10.05 ms ± 0.20"   │
+│ multipasta       │ "0.02 ms ± 0.07" │ "1.04 ms ± 0.03"   │ "0.16 ms ± 0.02" │ "10.10 ms ± 0.08"   │
+│ busboy           │ "0.05 ms ± 0.19" │ "3.06 ms ± 0.15"   │ "0.32 ms ± 0.05" │ "29.92 ms ± 0.24"   │
+│ @fastify/busboy  │ "0.06 ms ± 0.14" │ "14.72 ms ± 11.42" │ "0.81 ms ± 0.20" │ "127.63 ms ± 35.77" │
+└──────────────────┴──────────────────┴────────────────────┴──────────────────┴─────────────────────┘
+```
+
+## Related Packages
+
+- [`form-data-parser`](https://github.com/remix-run/remix/tree/main/packages/form-data-parser) - Uses `multipart-parser` internally to parse multipart requests and generate `FileUpload`s for storage
+- [`headers`](https://github.com/remix-run/remix/tree/main/packages/headers) - Used internally to parse `Content-Disposition` and `Content-Type` metadata for each `MultipartPart`
+
+## Credits
+
+Thanks to Jacob Ebey who gave me several code reviews on this project prior to publishing.
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

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

@@ -0,0 +1,352 @@
+# node-fetch-server
+
+Build Node.js servers with web-standard Fetch API primitives. `node-fetch-server` converts Node's HTTP server interfaces into [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)/[`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) flows that match modern runtimes.
+
+## Features
+
+- **Web Standards** - Standard [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) and [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) APIs
+- **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)
+- **TypeScript** - Full TypeScript support with type definitions
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Use `createRequestListener()` when you want to plug a fetch handler into a standard Node.js server:
+
+```ts
+import * as http from 'node:http'
+import { createRequestListener } from 'remix/node-fetch-server'
+
+async function handler(request: Request) {
+  let url = new URL(request.url)
+
+  if (url.pathname === '/' && request.method === 'GET') {
+    return new Response('Welcome to the User API! Try GET /api/users')
+  }
+
+  if (url.pathname === '/api/users' && request.method === 'GET') {
+    return Response.json([
+      { id: '1', name: 'Alice', email: 'alice@example.com' },
+      { id: '2', name: 'Bob', email: 'bob@example.com' },
+    ])
+  }
+
+  return new Response('Not Found', { status: 404 })
+}
+
+let server = http.createServer(createRequestListener(handler))
+
+server.listen(3000, () => {
+  console.log('Server running at http://localhost:3000')
+})
+```
+
+### Working with Request Data
+
+Handle different types of request data using standard web APIs:
+
+```ts
+async function handler(request: Request) {
+  let url = new URL(request.url)
+
+  // Handle JSON data
+  if (request.method === 'POST' && url.pathname === '/api/users') {
+    try {
+      let userData = await request.json()
+
+      // Validate required fields
+      if (!userData.name || !userData.email) {
+        return Response.json({ error: 'Name and email are required' }, { status: 400 })
+      }
+
+      // Create user (your implementation)
+      let newUser = {
+        id: Date.now().toString(),
+        ...userData,
+      }
+
+      return Response.json(newUser, { status: 201 })
+    } catch (error) {
+      return Response.json({ error: 'Invalid JSON' }, { status: 400 })
+    }
+  }
+
+  // Handle URL search params
+  if (url.pathname === '/api/search') {
+    let query = url.searchParams.get('q')
+    let limit = parseInt(url.searchParams.get('limit') || '10')
+
+    return Response.json({
+      query,
+      limit,
+      results: [], // Your search results here
+    })
+  }
+
+  return new Response('Not Found', { status: 404 })
+}
+```
+
+### Streaming Responses
+
+Take advantage of web-standard streaming with `ReadableStream`:
+
+```ts
+async function handler(request: Request) {
+  if (request.url.endsWith('/stream')) {
+    // Create a streaming response
+    let stream = new ReadableStream({
+      async start(controller) {
+        for (let i = 0; i < 5; i++) {
+          controller.enqueue(new TextEncoder().encode(`Chunk ${i}\n`))
+          await new Promise((resolve) => setTimeout(resolve, 1000))
+        }
+        controller.close()
+      },
+    })
+
+    return new Response(stream, {
+      headers: { 'Content-Type': 'text/plain' },
+    })
+  }
+
+  return new Response('Not Found', { status: 404 })
+}
+```
+
+### Custom Hostname Configuration
+
+Configure custom hostnames for deployment on VPS or custom environments. `node-fetch-server` uses
+the `host` option when constructing `request.url`.
+
+```ts
+import * as http from 'node:http'
+import { createRequestListener } from 'remix/node-fetch-server'
+
+let hostname = process.env.HOST || 'api.example.com'
+
+async function handler(request: Request) {
+  console.log(request.url) // http://api.example.com/path
+
+  return Response.json({
+    message: 'Hello from custom domain!',
+    url: request.url,
+  })
+}
+
+let server = http.createServer(createRequestListener(handler, { host: hostname }))
+
+server.listen(3000)
+```
+
+### Accessing Client Information
+
+Get client connection details (IP address, port) for logging or security:
+
+```ts
+import { type FetchHandler } from 'remix/node-fetch-server'
+
+let handler: FetchHandler = async (request, client) => {
+  // Log client information
+  console.log(`Request from ${client.address}:${client.port}`)
+
+  // Use for rate limiting, geolocation, etc.
+  if (isRateLimited(client.address)) {
+    return new Response('Too Many Requests', { status: 429 })
+  }
+
+  return Response.json({
+    message: 'Hello!',
+    yourIp: client.address,
+  })
+}
+```
+
+### HTTPS Support
+
+Use with Node.js HTTPS module for secure connections:
+
+```ts
+import * as https from 'node:https'
+import * as fs from 'node:fs'
+import { createRequestListener } from 'remix/node-fetch-server'
+
+let options = {
+  key: fs.readFileSync('private-key.pem'),
+  cert: fs.readFileSync('certificate.pem'),
+}
+
+let server = https.createServer(options, createRequestListener(handler))
+
+server.listen(443, () => {
+  console.log('HTTPS Server running on port 443')
+})
+```
+
+## Advanced Usage
+
+### Low-level API
+
+For more control over request/response handling, use the low-level API:
+
+```ts
+import * as http from 'node:http'
+import { createRequest, sendResponse } from 'remix/node-fetch-server'
+
+let server = http.createServer(async (req, res) => {
+  // Convert Node.js request to Fetch API Request
+  let request = createRequest(req, res, { host: process.env.HOST })
+
+  try {
+    // Add custom headers or middleware logic
+    let startTime = Date.now()
+
+    // Process the request with your handler
+    let response = await handler(request)
+    // Make sure the response is mutable
+    response = new Response(response.body, response)
+
+    // Add response timing header
+    let duration = Date.now() - startTime
+    response.headers.set('X-Response-Time', `${duration}ms`)
+
+    // Send the response
+    await sendResponse(res, response)
+  } catch (error) {
+    console.error('Server error:', error)
+    res.writeHead(500, { 'Content-Type': 'text/plain' })
+    res.end('Internal Server Error')
+  }
+})
+
+server.listen(3000)
+```
+
+The low-level API provides:
+
+- `createRequest(req, res, options)` - Converts Node.js IncomingMessage to web Request
+- `sendResponse(res, response)` - Sends web Response using Node.js ServerResponse
+
+This is useful for:
+
+- Building custom middleware systems
+- Integrating with existing Node.js code
+- Implementing custom error handling
+- Performance-critical applications
+
+## Migration from Express
+
+Transitioning from Express? Here's a comparison of common patterns:
+
+### Basic Routing
+
+```ts
+// Express
+let app = express()
+
+app.get('/users/:id', async (req, res) => {
+  let user = await db.getUser(req.params.id)
+  if (!user) {
+    return res.status(404).json({ error: 'User not found' })
+  }
+  res.json(user)
+})
+
+app.listen(3000)
+
+// node-fetch-server
+import { createRequestListener } from 'remix/node-fetch-server'
+
+async function handler(request: Request) {
+  let url = new URL(request.url)
+  let match = url.pathname.match(/^\/users\/(\w+)$/)
+
+  if (match && request.method === 'GET') {
+    let user = await db.getUser(match[1])
+    if (!user) {
+      return Response.json({ error: 'User not found' }, { status: 404 })
+    }
+    return Response.json(user)
+  }
+
+  return new Response('Not Found', { status: 404 })
+}
+
+http.createServer(createRequestListener(handler)).listen(3000)
+```
+
+## Demos
+
+The [`demos` directory](https://github.com/remix-run/remix/tree/main/packages/node-fetch-server/demos) contains working demos:
+
+- [`demos/http2`](https://github.com/remix-run/remix/tree/main/packages/node-fetch-server/demos/http2) - HTTP/2 server with TLS certificates
+
+## Related Packages
+
+- [`fetch-proxy`](https://github.com/remix-run/remix/tree/main/packages/fetch-proxy) - Build HTTP proxy servers using the web fetch API
+
+## Benchmarks
+
+Run the full benchmark suite:
+
+```sh
+pnpm run bench
+```
+
+Update the benchmark results below:
+
+```sh
+pnpm run bench:update-readme
+```
+
+<!-- benchmarks:start -->
+
+Last updated: 2026-04-29T17:19:30.407Z
+
+Environment: Darwin 25.3.0, Apple M1 Pro, Node.js v24.15.0
+
+Command: `wrk -t12 -c400 -d30s`
+
+### Raw Throughput
+
+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` |
+
+### Small Body
+
+POST benchmarks that read and print the request method, headers, and a small body.
+
+| 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` |
+
+### Large Body
+
+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` |
+
+<!-- benchmarks:end -->
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/node-tsx/README.md

@@ -0,0 +1,79 @@
+# node-tsx
+
+Run Node.js with TypeScript and JSX syntax support in `.ts`, `.tsx`, and `.jsx` files.
+
+`node-tsx` transforms supported source files before Node.js executes them, including
+TypeScript syntax that requires JavaScript code generation such as enums, runtime
+namespaces, and parameter properties. JSX compiler options are read from the nearest
+`tsconfig.json` for each loaded file.
+
+The loader does not type check, change Node.js module resolution, apply TypeScript
+path aliases, or downlevel JavaScript syntax for older runtimes.
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Pass the `--import` flag to register the `remix/node-tsx` loader when executing `node`:
+
+```sh
+node --import remix/node-tsx ./server.ts
+```
+
+### TypeScript configuration
+
+Since import resolution still follows Node.js, configure type checking to match native Node loading:
+
+```json
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "rewriteRelativeImportExtensions": true
+  }
+}
+```
+
+- [`module`](https://www.typescriptlang.org/tsconfig/#module) and [`moduleResolution`](https://www.typescriptlang.org/tsconfig/#moduleResolution) use `NodeNext` so TypeScript resolves modules the way Node does.
+- [`allowImportingTsExtensions`](https://www.typescriptlang.org/tsconfig/#allowImportingTsExtensions) allows source files to import `.ts` and `.tsx` modules directly.
+- [`isolatedModules`](https://www.typescriptlang.org/tsconfig/#isolatedModules) avoids patterns that require whole-program compilation, such as re-exporting a type without `export type`.
+- [`verbatimModuleSyntax`](https://www.typescriptlang.org/tsconfig/#verbatimModuleSyntax) requires type-only imports and exports to be marked so runtime imports are unambiguous.
+- [`rewriteRelativeImportExtensions`](https://www.typescriptlang.org/tsconfig/#rewriteRelativeImportExtensions) preserves a `tsc` emit path by rewriting relative `.ts` and `.tsx` imports to JavaScript extensions.
+
+Do not enable `erasableSyntaxOnly` if you want TypeScript to accept the same
+transform-only syntax that `node-tsx` can execute.
+
+### Programmatic usage
+
+#### Registering the loader
+
+Import `remix/node-tsx` as a side effect to register the loader.
+
+```ts
+import 'remix/node-tsx'
+```
+
+#### Loading a module with scoped JSX support
+
+Load a module with TypeScript and JSX syntax support scoped to its import graph:
+
+```ts
+import { loadModule } from 'remix/node-tsx/load-module'
+
+let mod = await loadModule('./app/server.tsx', import.meta.url)
+```
+
+## Related Work
+
+- [Node.js Modules: Customization hooks](https://nodejs.org/api/module.html#customization-hooks)
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/node-tsx/load-module.ts

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

package/{dist/node-serve.js → src/node-tsx.ts}

@@ -1,2 +1,3 @@
 // IMPORTANT: This file is auto-generated, please do not edit manually.
-export * from '@remix-run/node-serve';
+import '@remix-run/node-tsx'
+export {}