remix 3.0.0-beta.9 → 3.0.0-rc.2

package/src/cli/README.md

@@ -5,6 +5,7 @@ Command-line interface for creating and managing Remix projects.
 ## Features
 
 - Create new Remix projects with `npx remix@next new` or installed `remix new`
+- List browser-reachable files and inspect URL mappings with `remix assets`
 - Print shell completion scripts with `remix completion`
 - Check project environment and Remix app conventions with `remix doctor`
 - Apply available low-risk project fixes with `remix doctor --fix`
@@ -46,10 +47,13 @@ The rest of the CLI is available through the installed `remix` command:
 
 ```sh
 remix new my-remix-app
+remix assets
+remix assets inspect /assets/app/actions/public/entry.ts
 remix completion bash >> ~/.bashrc
 remix doctor
 remix doctor --fix
 remix db migrate
+remix db rollback
 remix db status
 remix db reset --force
 remix routes
@@ -66,10 +70,13 @@ You can also run the CLI programmatically:
 import { runRemix } from 'remix/cli'
 
 await runRemix(['new', 'my-remix-app'])
+await runRemix(['assets'])
+await runRemix(['assets', 'inspect', '/assets/app/actions/public/entry.ts'])
 await runRemix(['completion', 'bash'])
 await runRemix(['doctor'])
 await runRemix(['doctor', '--fix'])
 await runRemix(['db', 'migrate'])
+await runRemix(['db', 'rollback'])
 await runRemix(['db', 'status'])
 await runRemix(['db', 'reset', '--force'])
 await runRemix(['routes'])
@@ -81,8 +88,12 @@ await runRemix(['version'])
 
 Destructive database commands (`remix db wipe` and `remix db reset`) refuse to run without `--force`.
 
+`remix db rollback` reverts the most recent migration by default. Use `--step <count>` or `--to <migration>` to select a bound, and use `--dry-run` to report what would be reverted without changing the database.
+
 `runRemix()` returns the CLI exit code as a promise.
 
+`remix assets` lists each browser-reachable asset as `URL -> file`, one per line. Run `remix assets inspect <url-or-file>` to see one asset's resolved mapping and whether it is reachable, denied, unsupported, missing, or unmapped. Denied assets also show the matching deny rule.
+
 ## Configuration
 
 The CLI loads an optional `remix.json`. The file is parsed as JSONC, so it may contain comments and
@@ -90,7 +101,22 @@ trailing commas. Every top-level field is optional:
 
 ```jsonc
 {
-  "$schema": "https://remix.run/schemas/remix.json",
+  "$schema": "./node_modules/remix/schema/remix.json",
+
+  "assets": {
+    "rootDir": ".",
+    "basePath": "/assets",
+    "mounts": {
+      "app": "app",
+      "npm": "node_modules",
+    },
+    "allowFiles": ["app/routes.ts", "app/**/public/**"],
+    "allowPackages": ["remix"],
+    "denyFiles": ["app/**/*.test.*"],
+    "files": {
+      "extensions": [".svg", ".png", ".jpg", ".woff2"],
+    },
+  },
 
   "db": {
     "adapter": {
@@ -152,6 +178,8 @@ trailing commas. Every top-level field is optional:
 }
 ```
 
+The local `$schema` association uses the schema shipped with the directly installed `remix` package, so editor validation matches that version and remains available offline. It intentionally does not reference the transitive `@remix-run/cli` package, which may not be linked at the project root by package managers such as pnpm.
+
 Explicit command flags and positional arguments override configured values. Repeated flags replace
 configured arrays, while nested Playwright and coverage settings merge by field. Relative paths and
 globs are resolved from the directory containing the config file. Use `remix doctor --no-strict` to
@@ -162,8 +190,9 @@ disable configured strict mode for one run.
 a string or an object naming an environment variable with an optional default. `db.seed` names a
 SQL file that `remix db seed` and `remix db reset` run against the database. Database flags such as
 `--migrations`, `--seed`, `--journal-table`, and `--connection-env` override the corresponding
-config for one invocation. When no global `--config` is provided, database commands find the
-nearest `remix.json` by walking up from the working directory.
+config for one invocation. Rollbacks also accept `--step`, `--to`, and `--dry-run`. When no global
+`--config` is provided, database commands find the nearest `remix.json` by walking up from the
+working directory.
 
 Use the global `--config` option to select another JSONC file. The option itself is resolved from the
 CLI working directory and may appear before or after the command:
@@ -177,6 +206,26 @@ A missing default `remix.json` is ignored. A missing explicitly selected file, m
 unknown property, or invalid value is reported as a CLI error. The optional `$schema` field enables
 editor completion and validation; it has no runtime effect.
 
+Load the complete validated config from application code with `loadConfig()`:
+
+```ts
+import { createAssetServer } from 'remix/assets'
+import { loadConfig } from 'remix/cli'
+
+let config = await loadConfig(import.meta.dirname)
+if (config.assets === undefined) throw new Error('Missing assets configuration')
+
+let assetServer = createAssetServer({
+  ...config.assets,
+  sourceMaps: process.env.NODE_ENV === 'development' ? 'external' : undefined,
+})
+```
+
+Pass a config file to load it directly, or a directory to search upward for the nearest
+`remix.json`. Asset paths are resolved relative to the config file, so `config.assets` can be spread
+directly into `createAssetServer()`. Add runtime-only options such as transforms, caches, HMR, or
+error handlers in application code.
+
 ## License
 
 See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/data-table/README.md

@@ -11,7 +11,7 @@ Typed relational query toolkit for JavaScript runtimes.
 - **Relation-First Queries**: `hasMany`, `hasOne`, `belongsTo`, `hasManyThrough`, and nested eager loading
 - **Safe Scoped Writes**: `update`/`delete` with `orderBy`/`limit` run safely in a transaction
 - **First-Class Migrations**: Plain SQL `up.sql`/`down.sql` files with a journaling runner and dry-run planning
-- **Database Lifecycle Commands**: Wipe, migrate, inspect, seed, and reset through `remix db`
+- **Database Lifecycle Commands**: Wipe, migrate, rollback, inspect, seed, and reset through `remix db`
 - **Raw SQL Escape Hatch**: Execute SQL directly with `db.exec(sql\`...\`)`
 
 `data-table` gives you two complementary APIs:
@@ -409,7 +409,7 @@ environment variable at command runtime, and paths are resolved relative to `rem
 
 ```jsonc
 {
-  "$schema": "https://remix.run/schemas/remix.json",
+  "$schema": "./node_modules/remix/schema/remix.json",
   "db": {
     "adapter": {
       "type": "postgres",
@@ -433,12 +433,16 @@ Run lifecycle commands through the Remix CLI:
 remix db status
 remix db migrate
 remix db migrate --to 20260301113000_add_user_status
+remix db rollback
+remix db rollback --step 2
+remix db rollback --to 20260301113000_add_user_status
+remix db rollback --dry-run
 remix db seed
-remix db reset
-remix db wipe
+remix db reset --force
+remix db wipe --force
 ```
 
-`--to` accepts a bare migration id (`20260301113000`) or the full directory name (`20260301113000_add_user_status`).
+`rollback` reverts the most recently applied migration by default. Bound it with either `--step <count>` or `--to <migration>`, which reverts through the target migration inclusively. Migration targets accept a bare migration id (`20260301113000`) or the full directory name (`20260301113000_add_user_status`). Use `--dry-run` to report what would be reverted without changing the database.
 
 `remix db status` reports applied migrations whose files are no longer present as `missing`. If the journal table does not exist, it reports every migration as pending without creating the table. Forward migration runs stop before executing SQL when an applied journal entry is missing from the current migration set. Rollbacks skip those orphaned journal entries so migrations that are still present can be reverted.
 
@@ -473,6 +477,15 @@ for (let script of plan.sql) console.log(script)
 
 `to` and `step` are mutually exclusive. Omit `journalTable` to use `data_table_migrations`.
 
+Hosts that embed the database CLI can invoke the same rollback behavior through `runRemixDb()`:
+
+```ts
+import { runRemixDb } from 'remix/data-table/cli'
+
+await runRemixDb({ command: 'rollback', db, migrations })
+await runRemixDb({ command: 'rollback', db, migrations, step: 2, dryRun: true })
+```
+
 Database drivers with migration locking run the complete migration and journal lifecycle through the
 connection that owns the lock. This keeps advisory locks correctly paired when the driver uses a
 connection pool, including pools configured with a single connection.

package/src/fetch-router/README.md

@@ -237,6 +237,45 @@ router.map(routes.contact, {
 })
 ```
 
+#### Method Not Allowed Responses
+
+When a request URL matches one or more route patterns, but none of those routes are registered for the request method, the router first falls through to any less specific route that can handle the method (including `ANY` routes). If no route can handle the request, the router responds with `405 Method Not Allowed` and an [`Allow` header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Allow) listing the methods that are registered for that URL, instead of treating the request as a 404.
+
+```ts
+import { createRouter } from 'remix/router'
+
+let router = createRouter()
+
+router.get('/users/:id', ({ params }) => new Response(`User ${params.id}`))
+router.put('/users/:id', ({ params }) => new Response(`Updated ${params.id}`))
+
+let response = await router.fetch('https://remix.run/users/1', { method: 'DELETE' })
+// 405 Method Not Allowed
+// Allow: GET, HEAD, PUT
+```
+
+If you want a handler to receive every request method at a given URL instead, register an `ANY` route for it.
+
+#### HEAD Requests
+
+Routes registered for `GET` also serve `HEAD` requests. The `GET` handler runs as usual, and the router strips the body from its response, so a `HEAD` request observes the same status and headers as the equivalent `GET` request.
+
+```ts
+let router = createRouter()
+
+router.get(
+  '/report',
+  () => new Response('report data', { headers: { 'Content-Type': 'text/csv' } }),
+)
+
+let response = await router.fetch('https://remix.run/report', { method: 'HEAD' })
+// 200 OK
+// Content-Type: text/csv
+// (empty body)
+```
+
+If you register an explicit `HEAD` route for the same pattern, it takes precedence over the `GET` route for `HEAD` requests.
+
 ### Composing Route Groups
 
 As applications grow, it is useful to let one file own the routes for a specific area of the app while the top-level router decides where that area is mounted. Use `router.mount()` with a route installer to register a group of routes under a route pattern prefix.

package/src/multiple-import-maps-polyfill/README.md

@@ -0,0 +1,107 @@
+# multiple-import-maps-polyfill
+
+Polyfill for dynamic JavaScript imports that depend on import maps added after the document's initial import map. Browsers with native support for multiple import maps continue to use native dynamic imports.
+
+The module loading logic in this package was adapted from [ES Module Shims](https://github.com/guybedford/es-module-shims) by Guy Bedford.
+
+This package assumes the initial document contains one complete import map before any module scripts. It is designed to load dynamic imports that depend on additional import maps installed after the initial page load.
+
+## Features
+
+- Detects native support for multiple import maps
+- Loads dynamic imports through every import map in the document when a polyfill is required
+- Preloads dynamic modules through the same polyfill cache
+- Resolves native module types through import maps while leaving their loading semantics to the browser
+- Supports import-map integrity metadata
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Use `importModule` in place of `import()` when a dynamic import may depend on an import map added at runtime:
+
+```ts
+import { importModule } from 'remix/multiple-import-maps-polyfill'
+
+let moduleUrl = new URL('./features/search.ts', import.meta.url).href
+let feature = await importModule(moduleUrl)
+feature.openSearch()
+```
+
+`importModule` uses native `import()` when the browser supports multiple import maps. In other browsers, it loads the module through the polyfill using every import map currently installed in the document.
+
+Use `detectMultipleImportMapSupport` and `preloadShim` when an integration also manages module preloads. For example, configure Remix UI to load client entries discovered during navigation:
+
+```ts
+import {
+  detectMultipleImportMapSupport,
+  importModule,
+  preloadShim,
+} from 'remix/multiple-import-maps-polyfill'
+import { run } from 'remix/ui'
+
+run({
+  async loadModule(moduleUrl, exportName) {
+    let module = await importModule(moduleUrl)
+    let Component = module[exportName]
+    if (typeof Component !== 'function') {
+      throw new Error(`Unknown component: ${moduleUrl}#${exportName}`)
+    }
+    return Component
+  },
+  async processClientEntryPreloads(preloads) {
+    if (await detectMultipleImportMapSupport()) return preloads
+
+    preloadShim(preloads)
+    return []
+  },
+})
+```
+
+Browsers with multiple import map support retain native module loading and native `<link rel="modulepreload">` elements. Other browsers load late client entries and preloads through the polyfill.
+
+`detectMultipleImportMapSupport()` returns a cached promise. When it detects that the polyfill is required, it begins loading the polyfill runtime in the background so the work can overlap with a later `importShim()` or `preloadShim()` call. Browsers with multiple import map support do not load the polyfill runtime.
+
+`importShim()` always uses the polyfill to load a dynamic JavaScript import using every import map currently installed in the document. It does not detect native support. `preloadShim()` always uses the polyfill fetch cache rather than native module preload links. Like native module preloads, it fetches only the supplied module specifier or array of specifiers and caches their responses for later imports. Preload failures are ignored. `importShim()` reports the failure if the module is later required.
+
+## Content Security Policy
+
+Polyfilled module graphs are evaluated from blob URLs, and `es-module-lexer` compiles its parser from Wasm. Content Security Policies must allow `blob:` module scripts and Wasm compilation with `'wasm-unsafe-eval'`.
+
+The support detector creates a Trusted Types policy named `remix/multiple-import-maps-polyfill`. Allow this policy when Trusted Types are required for scripts, for example:
+
+```http
+Content-Security-Policy: script-src 'self' blob: 'wasm-unsafe-eval'; require-trusted-types-for 'script'; trusted-types remix/multiple-import-maps-polyfill;
+```
+
+## `remix/assets` HMR Support
+
+HMR appends mappings for updated modules to the document in additional `<script type="importmap">` elements. Configure the Remix asset server's `hmr.moduleImporter` option to use the polyfilled `importModule` function when these updates must work in browsers without native support for multiple import maps:
+
+```ts
+import { createAssetServer } from 'remix/assets'
+import { createBrowserHmrChannel } from 'remix/node-hmr/runtime'
+
+let assets = createAssetServer({
+  hmr: {
+    channel: createBrowserHmrChannel,
+    moduleImporter: 'remix/multiple-import-maps-polyfill',
+  },
+  watch: true,
+})
+```
+
+The module importer and its dependencies must be available through the document's initial import map. Importing `remix/multiple-import-maps-polyfill` from the application's main client entry satisfies this requirement.
+
+## Related Packages
+
+- [`assets`](https://github.com/remix-run/remix/tree/main/packages/assets) - Compiles and serves browser assets
+- [`ui`](https://github.com/remix-run/remix/tree/main/packages/ui) - Loads client entries discovered during navigation
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/packages/multiple-import-maps-polyfill/LICENSE)

package/src/multiple-import-maps-polyfill.ts

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

package/src/node-hmr/README.md

@@ -120,7 +120,6 @@ 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:

package/src/render-middleware/README.md

@@ -1,13 +1,14 @@
 # render-middleware
 
-Request-scoped renderer middleware for Remix. It stores a renderer in `fetch-router` request context so route actions can render responses without passing request-specific rendering details through every action.
+Request-scoped response rendering for Remix. It provides the conventional Remix UI renderer and a low-level escape hatch for custom renderers.
 
 ## Features
 
-- **Generic renderers** - Render any input type to a `Response`
-- **Request-scoped setup** - Create renderers from the current `RequestContext`
-- **Typed context** - Typed `context.render` (or `context.get(Renderer)`)
-- **Small runtime** - The package only stores a renderer in request context
+- **Remix UI rendering** - Stream nodes to HTML responses with `render()`
+- **Framework-owned frames** - Resolve nested and targeted `<Frame>` requests through the current router
+- **Client entry assets** - Resolve source-based `clientEntry()` modules, import maps, and preloads through an asset server
+- **Typed context** - Preserve renderer input and response option types on `context.render`
+- **Custom renderers** - Install JSON, email, or other response pipelines with `renderWith()`
 
 ## Installation
 
@@ -17,82 +18,96 @@ npm i remix
 
 ## Usage
 
-Use `renderWith()` to add a renderer to `context.render` and `context.get(Renderer)`.
+Install `render()` in the router middleware stack. Pass an asset server when components use source-based client entries such as `clientEntry(import.meta.url, Component)`.
 
-```ts
-import { createRouter, type MiddlewareContext } from 'remix/router'
-import { renderWith } from 'remix/middleware/render'
+```tsx
+import { createAssetServer } from 'remix/assets'
+import { render } from 'remix/middleware/render'
+import { staticFiles } from 'remix/middleware/static'
+import { createRouter } from 'remix/router'
+import { Frame } from 'remix/ui'
+
+let assets = createAssetServer({
+  basePath: '/assets',
+  rootDir: process.cwd(),
+  allowFiles: ['app/routes.ts', 'app/**/public/**'],
+  allowPackages: ['remix'],
+  denyFiles: ['app/**/*.test.*'],
+})
 
-const render = renderWith(
-  (context) =>
-    function render(value: string, init?: ResponseInit) {
-      return new Response(`${context.url.pathname}: ${value}`, init)
-    },
+let router = createRouter({
+  middleware: [staticFiles('./public'), render({ assets })],
+})
+
+router.get(
+  '/assets/*path',
+  async ({ request }) =>
+    (await assets.fetch(request)) ?? new Response('Not Found', { status: 404 }),
 )
 
-type AppContext = MiddlewareContext<[typeof render]>
+router.get('/', (context) =>
+  context.render(
+    <html>
+      <body>
+        <h1>Dashboard</h1>
+        <Frame src="/activity" fallback={<p>Loading activity…</p>} />
+      </body>
+    </html>,
+  ),
+)
+```
 
-const router = createRouter<AppContext>({
-  middleware: [render],
-})
+`context.render(node, init)` returns an HTML `Response` and preserves the supplied status and headers:
 
-router.get('/hello', (context) => {
-  return context.render('Hello')
-})
+```tsx
+router.get('/missing', (context) =>
+  context.render(<h1>Not found</h1>, {
+    status: 404,
+    headers: { 'Cache-Control': 'no-store' },
+  }),
+)
 ```
 
-Use `context.render(...)` (or `context.get(Renderer)(...)`).
+The middleware forwards request credentials and session headers to internal frame requests, converts them to safe `GET` requests, follows redirects, preserves application error bodies, propagates frame targets and top-frame URLs, and cancels frame rendering when the original request is aborted.
+
+### Options
 
-Renderers may render any value type, not just UI nodes.
+- **`assets`** - An asset server that resolves source-based client entry IDs to browser module URLs, import maps, and preload URLs. Omit it when client entries already use public URLs or the app has no client entries.
+- **`onError`** - A callback for server rendering errors. When omitted, the UI renderer uses its default error reporting.
+
+## Custom renderers
+
+Use `renderWith()` when the input is not a Remix UI node or the application owns a fully custom response pipeline. The factory runs once per request and may read the current request context.
 
 ```ts
 import { renderWith } from 'remix/middleware/render'
+import { createRouter } from 'remix/router'
 
-const json = renderWith(
+let json = renderWith(
   () =>
     function render(data: unknown, init?: ResponseInit) {
       return Response.json(data, init)
     },
 )
 
-router.get('/api', (context) => {
-  return context.render({ ok: true })
-})
-```
-
-For Remix UI, create a renderer that owns frame resolution and response creation.
-
-```tsx
-import { createHtmlResponse } from 'remix/response/html'
-import { renderWith } from 'remix/middleware/render'
-import type { RemixNode } from 'remix/ui'
-import { renderToStream } from 'remix/ui/server'
+let router = createRouter({ middleware: [json] })
 
-const render = renderWith(
-  ({ router, url }) =>
-    function render(node: RemixNode, init?: ResponseInit) {
-      let stream = renderToStream(node, {
-        async resolveFrame(src) {
-          let response = await router.fetch(new URL(src, url))
+router.get('/api/status', (context) => context.render({ ok: true }))
+```
 
-          if (!response.ok) {
-            return `<pre>Frame error: ${response.status}</pre>`
-          }
+Custom renderers are also available through `context.get(Renderer)` when direct-property access is not suitable.
 
-          return response.body ?? response.text()
-        },
-      })
+## Related Packages
 
-      return createHtmlResponse(stream, init)
-    },
-)
-```
+- [`assets`](https://github.com/remix-run/remix/tree/main/packages/assets) - Source asset compilation and browser module URLs
+- [`fetch-router`](https://github.com/remix-run/remix/tree/main/packages/fetch-router) - Request routing and typed context
+- [`ui`](https://github.com/remix-run/remix/tree/main/packages/ui) - Remix UI components, frames, and server rendering
+- [`response`](https://github.com/remix-run/remix/tree/main/packages/response) - Web `Response` helpers
 
-## Related Packages
+## Related Work
 
-- [`fetch-router`](https://github.com/remix-run/remix/tree/main/packages/fetch-router) - Request routing and context
-- [`ui`](https://github.com/remix-run/remix/tree/main/packages/ui) - Remix UI rendering primitives
-- [`response`](https://github.com/remix-run/remix/tree/main/packages/response) - Response helpers
+- [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+- [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
 
 ## License
 

package/src/spa/README.md

@@ -0,0 +1,96 @@
+# spa
+
+Client-rendered application routing for Remix. It connects a standard fetch router to the browser
+UI runtime without exposing the response carrier used to associate route responses with Remix
+nodes.
+
+## Features
+
+- **Standard fetch routing** - Preserve `Request` to `Response` dispatch, redirects, status codes,
+  headers, middleware, and cancellation
+- **Node rendering middleware** - Render `RemixNode` values through `context.render()`
+- **Browser runtime** - Resolve the current URL and future frame navigations through the router
+- **Initial fallback** - Display an interactive Remix node while the first route loads
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Install `render()` before middleware and route handlers that use `context.render()`, then pass the
+router to `run()`.
+
+```tsx
+import { createRouter } from 'remix/router'
+import { get, route } from 'remix/routes'
+import { render, run } from 'remix/spa'
+
+const routes = route({
+  home: get('/'),
+  about: get('/about'),
+})
+
+const router = createRouter({
+  middleware: [render()],
+  defaultHandler({ render }) {
+    return render(<h1>Not Found</h1>, { status: 404 })
+  },
+})
+
+router.map(routes, {
+  actions: {
+    home({ render }) {
+      return render(<h1>Home</h1>)
+    },
+    about({ render }) {
+      return render(<h1>About</h1>)
+    },
+  },
+})
+
+const app = run(router, { fallback: <p>Loading…</p> })
+await app.ready()
+```
+
+The router remains an ordinary fetch router, so its normal actions, controllers, middleware, and
+context typing continue to apply.
+
+## Wrapping Route Content
+
+Pass a request-aware transform to `render()` when every route should share an application shell.
+
+```tsx
+const router = createRouter({
+  middleware: [
+    render((content, { url }) => (
+      <main data-pathname={url.pathname}>
+        <nav>{/* ... */}</nav>
+        {content}
+      </main>
+    )),
+  ],
+})
+```
+
+## Related Packages
+
+- [`fetch-router`](https://github.com/remix-run/remix/tree/main/packages/fetch-router) - Request
+  routing, controllers, and middleware context
+- [`render-middleware`](https://github.com/remix-run/remix/tree/main/packages/render-middleware) -
+  Request-scoped renderer middleware
+- [`ui`](https://github.com/remix-run/remix/tree/main/packages/ui) - Remix components, frames, and
+  browser runtime
+
+## Related Work
+
+- [Fetch standard](https://fetch.spec.whatwg.org/) - The request and response model preserved by SPA
+  routers
+- [Navigation API](https://wicg.github.io/navigation-api/) - Browser navigation lifecycle used by
+  the Remix UI runtime
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/spa.ts

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

package/src/{static-files-middleware → static-middleware}/README.md

@@ -1,4 +1,4 @@
-# static-files-middleware
+# static-middleware
 
 Static file serving middleware for Remix. Serves static files from a directory with support for ETags, range requests, and conditional requests.
 

package/src/static-middleware.ts

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

package/src/test/README.md

@@ -58,7 +58,7 @@ trailing commas are allowed:
 
 ```jsonc
 {
-  "$schema": "https://remix.run/schemas/remix.json",
+  "$schema": "./node_modules/remix/schema/remix.json",
   "test": {
     "files": ["**/*.test{,.browser,.e2e}.{ts,tsx}"],
     "browserFiles": ["**/*.test.browser.{ts,tsx}"],