@avelonjs/next 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Yannelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# @avelonjs/next
+
+`@avelonjs/next` is the v1 adapter. It turns a `RouteManifest` into Next's file router, serves writes as generated server actions, wraps pages around the core kernel, and bridges `middleware.ts`. Reach for it when the application is a Next app and you want typed `routes/web.ts` without putting Next types in `@avelonjs/core`.
+
+The adapter is a translation layer at three seams: `mount`, `toRequest`, and `toResponse`. Middleware, binding, validation, and exception mapping stay in the kernel (D26).
+
+## Installation
+
+```sh
+bun add @avelonjs/next
+```
+
+Wire the adapter in `avelon.config.ts` and generate the router during `dev` and `build`.
+
+```ts
+import { NextAdapter } from '@avelonjs/next'
+import { createKernel, defineConfig } from '@avelonjs/core'
+
+const adapter = new NextAdapter({ root: process.cwd() })
+defineConfig({
+  name: 'app',
+  adapter,
+  drivers: {},
+})
+
+await adapter.mount(Route.manifest(), { kernel: createKernel() })
+```
+
+## Basic Usage
+
+```ts
+import { Route } from '@avelonjs/next'
+import { PostController } from '@/app/Http/Controllers/PostController'
+import { Post } from '@/app/Models/Post'
+
+Route.get('/', HomeController, 'index').name('home')
+
+Route.middleware('auth').group(() => {
+  Route.resource('posts', PostController).bind('post', Post)
+})
+```
+
+`reeve route:sync` (and `NextAdapter.mount`) wipe `app/(web)` and rewrite it. Generated pages are four lines and contain no logic:
+
+```ts
+// Generated by `reeve route:sync`. Do not edit.
+import { PostController } from '@/app/Http/Controllers/PostController'
+import { page } from '@avelonjs/next'
+
+export const dynamic = 'force-dynamic'
+
+export default page(PostController, 'show', '/posts/{post}')
+```
+
+Writes become server actions in `framework/routing/actions.generated.ts`. `.api()` additionally generates `app/(api)/api/.../route.ts` so JSON URLs do not collide with pages.
+
+## Capabilities
+
+| Capability          | Value   | Meaning                                                |
+| ------------------- | ------- | ------------------------------------------------------ |
+| `fileSystemRouting` | `true`  | `mount()` writes framework-owned files.                |
+| `serverActions`     | `true`  | `Route.post()` is served as a generated server action. |
+| `streaming`         | `true`  | The kernel may return `StreamResult`.                  |
+| `edgeMiddleware`    | `false` | Next 16 Proxy middleware defaults to Node (D27).       |
+
+`serverActions` selects the write transport. It does not gate whether a write route exists.
+
+## Request Lifecycle
+
+`page()` and `dispatch()` convert native Next inputs with `toRequest`, call `kernel.dispatch`, then `toResponse`. Redirects throw `NextRedirect` with a `NEXT_REDIRECT` digest so Next navigation keeps propagating. Validation failures return `{ kind: 'action', ok: false, errors }` for `useActionState`.
+
+`middleware.ts` calls `middleware(request)`. Routes that declare `auth` redirect to `/login` when no cookies or `Authorization` header are present; everything else returns `{ kind: 'next' }`.
+
+## Method Reference
+
+| Method / export             | Signature                                                                    | Description                                                                          |
+| --------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `NextAdapter`               | `class NextAdapter`                                                          | File-routing adapter implementing the frozen `Adapter` contract.                     |
+| `NextAdapter.mount`         | `(manifest, options) => Promise<MountResult>`                                | Writes the router and binds the kernel.                                              |
+| `NextAdapter.attach`        | `(manifest, options) => void`                                                | Binds kernel and manifest without rewriting generated files.                         |
+| `NextAdapter.registerViews` | `(views) => void`                                                            | Maps string view tokens to React components for `toResponse`.                        |
+| `NextAdapter.toRequest`     | `(native) => Promise<HttpRequest>`                                           | Converts page props, FormData, or `Request`. Unparseable bodies become `body: null`. |
+| `NextAdapter.toResponse`    | `(result) => Promise<NextNativeResponse>`                                    | Converts kernel results. Redirects throw `NextRedirect`.                             |
+| `nextCapabilities`          | `typeof nextCapabilities`                                                    | Literal capability object used by CLI and codegen.                                   |
+| `bindAdapter`               | `(adapter \| undefined) => void`                                             | Records the adapter generated helpers dispatch through.                              |
+| `getAdapter`                | `() => NextAdapter`                                                          | Returns the bound adapter or throws.                                                 |
+| `setRuntimeBoot`            | `(boot \| undefined) => void`                                                | Registers a boot function `page` and `dispatch` call when unbound.                   |
+| `ensureAdapter`             | `() => Promise<NextAdapter>`                                                 | Returns the bound adapter, booting first when needed.                                |
+| `page`                      | `(controller, action, uri) => PageComponent`                                 | Next page wrapper used by generated `page.tsx`.                                      |
+| `dispatch`                  | `(controller, action, uri, formData) => Promise<NextNativeResponse>`         | Server-action entry used by generated writes.                                        |
+| `handleRoute`               | `(controller, action, uri, request, params?) => Promise<NextNativeResponse>` | JSON route-handler entry used by `.api()` files.                                     |
+| `middleware`                | `(request, routes?) => Promise<NextNativeResponse>`                          | `proxy.ts` / `middleware.ts` bridge. Pass generated routes on the Node proxy.        |
+| `MiddlewareRoute`           | `interface`                                                                  | Method, path, and middleware aliases for Edge auth.                                  |
+| `setCookie`                 | `(name, value, options?) => void`                                            | Queues a cookie write for the current Next request.                                  |
+| `clearCookie`               | `(name, options?) => void`                                                   | Queues a cookie deletion for the current Next request.                               |
+| `PendingCookie`             | `interface`                                                                  | Queued cookie name, value, and options.                                              |
+| `ViewRegistry`              | `type`                                                                       | String view tokens mapped to render functions.                                       |
+| `formProps`                 | `(name, params?) => { action, method, fields }`                              | Hidden fields and action export for a named write route.                             |
+| `generateRouter`            | `(manifest, root, options) => Promise<readonly string[]>`                    | Destructive codegen used by `mount`.                                                 |
+| `findMountedRoute`          | `(controller, action, uri) => RouteDefinition`                               | Resolves a generated helper back to its manifest entry.                              |
+| `Route.get`                 | `(path, controller, action?) => RouteBuilder`                                | Registers a GET route.                                                               |
+| `Route.post`                | `(path, controller, action?) => RouteBuilder`                                | Registers a POST route.                                                              |
+| `Route.put`                 | `(path, controller, action?) => RouteBuilder`                                | Registers a PUT route.                                                               |
+| `Route.patch`               | `(path, controller, action?) => RouteBuilder`                                | Registers a PATCH route.                                                             |
+| `Route.delete`              | `(path, controller, action?) => RouteBuilder`                                | Registers a DELETE route.                                                            |
+| `Route.resource`            | `(name, controller) => ResourceBuilder`                                      | Expands the seven resource routes.                                                   |
+| `Route.middleware`          | `(...names) => { group }`                                                    | Applies middleware inside a group.                                                   |
+| `Route.prefix`              | `(prefix) => { group }`                                                      | Prefixes routes inside a group.                                                      |
+| `Route.all`                 | `() => readonly RouteDefinition[]`                                           | Returns registrations.                                                               |
+| `Route.manifest`            | `(version?) => RouteManifest`                                                | Builds a mountable manifest.                                                         |
+| `Route.find`                | `(name) => RouteDefinition`                                                  | Finds a named route or throws.                                                       |
+| `Route.reset`               | `() => void`                                                                 | Clears registrations.                                                                |
+| `RouteBuilder.name`         | `(name) => this`                                                             | Sets the stable route name.                                                          |
+| `RouteBuilder.middleware`   | `(...names) => this`                                                         | Appends middleware aliases.                                                          |
+| `RouteBuilder.bind`         | `(param, model) => this`                                                     | Marks a path parameter for binding.                                                  |
+| `RouteBuilder.api`          | `() => this`                                                                 | Additionally generates a JSON route handler.                                         |
+| `ResourceBuilder.bind`      | `(param, model) => this`                                                     | Binds member parameters.                                                             |
+| `ResourceBuilder.only`      | `(...actions) => this`                                                       | Keeps named resource actions.                                                        |
+| `ResourceBuilder.except`    | `(...actions) => this`                                                       | Drops named resource actions.                                                        |
+| `ResourceBuilder.api`       | `() => this`                                                                 | Marks remaining resource routes as `.api()`.                                         |
+| `route`                     | `(name, params?) => string`                                                  | Fills `{param}` placeholders.                                                        |
+| `exportName`                | `(definition) => string`                                                     | Stable generated export for a write route.                                           |
+| `uriToSegments`             | `(uri) => string`                                                            | Converts `/posts/{post}` to `posts/[post]`.                                          |
+| `nativeToRequest`           | `(native) => Promise<HttpRequest>`                                           | Low-level native conversion.                                                         |
+| `kernelToResponse`          | `(result) => Promise<NextNativeResponse>`                                    | Low-level result conversion.                                                         |
+| `NextRedirect`              | `class NextRedirect extends Error`                                           | Control-flow throw with a `NEXT_REDIRECT` digest.                                    |
+| `isNextControlFlow`         | `(error: unknown) => boolean`                                                | True for Next navigation throws.                                                     |
+| `PageProps`                 | `interface`                                                                  | Async Next page props.                                                               |
+| `NextNativeRequest`         | `type`                                                                       | `page`, `form`, or `http` native inputs.                                             |
+| `NextNativeResponse`        | `type`                                                                       | View, action, redirect, stream, or `next`.                                           |
+| `NextAdapterOptions`        | `interface`                                                                  | `root` plus optional capability overrides.                                           |
+
+## Testing
+
+Mount the adapter against a temp directory and call `page` / `dispatch` with the same controllers the generator would import. Point the kernel at `FakeDatabase` when a page loads models.
+
+```ts
+import { NextAdapter, Route, page } from '@avelonjs/next'
+import { createKernel } from '@avelonjs/core'
+
+const adapter = new NextAdapter({ root: tempDir })
+await adapter.mount(Route.manifest(), { kernel: createKernel() })
+const Page = page(PostController, 'index', '/posts')
+await Page({})
+```
+
+```sh
+bun test
+bun run typecheck
+```

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@avelonjs/next",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Next.js adapter for Avelon routing, server actions, and pages.",
+  "license": "MIT",
+  "author": "Ryan Yannelli <ryanyannelli@gmail.com>",
+  "homepage": "https://github.com/yannelli/avelon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yannelli/avelon.git",
+    "directory": "packages/next"
+  },
+  "bugs": {
+    "url": "https://github.com/yannelli/avelon/issues"
+  },
+  "keywords": [
+    "avelon",
+    "typescript",
+    "nextjs",
+    "adapter"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@avelonjs/core": "workspace:*"
+  },
+  "peerDependencies": {
+    "next": ">=16.0.0"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@avelonjs/assay": "workspace:*",
+    "@avelonjs/conformance": "workspace:*",
+    "@types/bun": "1.3.14",
+    "next": "16.2.12",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  }
+}

package/src/adapter.ts

@@ -0,0 +1,194 @@
+import type {
+  Adapter,
+  ControllerClass,
+  HttpMethod,
+  HttpRequest,
+  Kernel,
+  KernelResult,
+  MountOptions,
+  MountResult,
+  RouteDefinition,
+  RouteManifest,
+  ViewRef,
+} from '@avelonjs/core'
+import { Invalid } from '@avelonjs/core'
+
+import { generateRouter } from './codegen'
+import { flushOutgoingCookies, type ViewRegistry } from './cookies'
+import { nativeToRequest } from './request'
+import { kernelToResponse, type NextNativeResponse } from './response'
+import { exportName } from './routing'
+
+/** Capabilities the Next adapter reports. `serverActions` selects write transport (D26). */
+export const nextCapabilities = {
+  fileSystemRouting: true,
+  serverActions: true,
+  streaming: true,
+  edgeMiddleware: false,
+} as const
+
+/** Native request shapes the Next adapter accepts at `toRequest`. */
+export type NextNativeRequest =
+  | {
+      kind: 'page'
+      uri: string
+      params?: Record<string, string | string[] | undefined>
+      searchParams?: Record<string, string | string[] | undefined>
+      url?: string
+      cookies?: Record<string, string>
+    }
+  | {
+      kind: 'form'
+      uri: string
+      formData: FormData
+      url?: string
+      cookies?: Record<string, string>
+    }
+  | { kind: 'http'; request: Request; params?: Readonly<Record<string, string>> }
+
+/** Options for {@link NextAdapter}. */
+export interface NextAdapterOptions {
+  /** Application root where `app/(web)` and `framework/routing` are written. */
+  root: string
+  /** Override capabilities in tests. */
+  capabilities?: Partial<typeof nextCapabilities>
+}
+
+let boundAdapter: NextAdapter | undefined
+let runtimeBoot: (() => Promise<void>) | undefined
+
+/** Returns the adapter last passed to {@link bindAdapter}. */
+export function getAdapter(): NextAdapter {
+  if (boundAdapter === undefined) {
+    throw new Invalid('Next adapter has not been mounted.', {
+      metadata: { fields: { adapter: ['Call NextAdapter.mount() before page() or dispatch().'] } },
+    })
+  }
+  return boundAdapter
+}
+
+/** Records the adapter generated code and runtime helpers dispatch through. */
+export function bindAdapter(adapter: NextAdapter | undefined): void {
+  boundAdapter = adapter
+}
+
+/**
+ * Registers a one-time boot function `page` and `dispatch` call when the adapter
+ * is not yet attached. Next may render a page before the root layout finishes.
+ */
+export function setRuntimeBoot(boot: (() => Promise<void>) | undefined): void {
+  runtimeBoot = boot
+}
+
+/** Returns the bound adapter, booting the runtime first when necessary. */
+export async function ensureAdapter(): Promise<NextAdapter> {
+  if (boundAdapter !== undefined) return boundAdapter
+  if (runtimeBoot !== undefined) await runtimeBoot()
+  return getAdapter()
+}
+
+/** Next.js file-routing adapter. Translation only; the kernel owns the request pipeline. */
+export class NextAdapter<TController extends ControllerClass = ControllerClass> implements Adapter<
+  TController,
+  ViewRef,
+  NextNativeRequest,
+  NextNativeResponse
+> {
+  readonly name = 'next'
+  readonly capabilities: typeof nextCapabilities
+  readonly root: string
+  kernel: Kernel<TController> | undefined
+  manifest: RouteManifest<TController> | undefined
+  views: ViewRegistry | undefined
+
+  constructor(options: NextAdapterOptions) {
+    this.root = options.root
+    this.capabilities = { ...nextCapabilities, ...options.capabilities }
+  }
+
+  async mount(
+    manifest: RouteManifest<TController>,
+    options: MountOptions<TController>,
+  ): Promise<MountResult> {
+    this.kernel = options.kernel
+    this.manifest = manifest
+    bindAdapter(this as unknown as NextAdapter)
+    const generated = await generateRouter(manifest, this.root, {
+      basePath: options.basePath,
+      serverActions: this.capabilities.serverActions,
+    })
+    return {
+      mounted: manifest.routes.map((route) => route.name),
+      generated,
+    }
+  }
+
+  /**
+   * Binds the kernel and manifest without rewriting generated files.
+   *
+   * Use this from Next instrumentation or the root layout. `mount()` stays the codegen path
+   * for `reeve route:sync`.
+   */
+  attach(
+    manifest: RouteManifest<TController>,
+    options: MountOptions<TController> & { views?: ViewRegistry },
+  ): void {
+    this.kernel = options.kernel
+    this.manifest = manifest
+    if (options.views !== undefined) this.views = options.views
+    bindAdapter(this as unknown as NextAdapter)
+  }
+
+  /** Registers string view tokens so `toResponse` can render React components. */
+  registerViews(views: ViewRegistry): void {
+    this.views = views
+  }
+
+  async toRequest(native: NextNativeRequest): Promise<HttpRequest> {
+    return nativeToRequest(native)
+  }
+
+  async toResponse(result: KernelResult<ViewRef>): Promise<NextNativeResponse> {
+    await flushOutgoingCookies()
+    return kernelToResponse(result, this.views)
+  }
+}
+
+/** Looks up a route by controller, action, and path pattern. */
+export function findMountedRoute(
+  controller: ControllerClass,
+  action: string,
+  uri: string,
+): RouteDefinition<ControllerClass> {
+  const adapter = getAdapter()
+  const routes = adapter.manifest?.routes ?? []
+  const match = routes.find(
+    (route) => route.controller === controller && route.action === action && route.path === uri,
+  )
+  if (match !== undefined) return match as RouteDefinition<ControllerClass>
+  const byName = routes.find((route) => route.action === action && route.path === uri)
+  if (byName !== undefined) return byName as RouteDefinition<ControllerClass>
+  throw new Invalid(`No mounted route for ${controller.name}.${action} ${uri}.`, {
+    metadata: { fields: { route: [`${controller.name}.${action} is not mounted.`] } },
+  })
+}
+
+/** Hidden fields a generated form posts alongside `_method`. */
+export function formProps(
+  name: string,
+  params: Readonly<Record<string, string | number>> = {},
+): { action: string; method: HttpMethod; fields: Record<string, string> } {
+  const adapter = getAdapter()
+  const route = adapter.manifest?.routes.find((entry) => entry.name === name)
+  if (route === undefined) {
+    throw new Invalid(`Route ${name} was not found.`, {
+      metadata: { fields: { route: [`${name} is not mounted.`] } },
+    })
+  }
+  const fields: Record<string, string> = {}
+  for (const [key, value] of Object.entries(params)) fields[key] = String(value)
+  if (route.method !== 'POST' && route.method !== 'GET') fields._method = route.method
+  return { action: exportName(route), method: route.method, fields }
+}
+
+export type { HttpMethod }

package/src/codegen.ts

@@ -0,0 +1,159 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import {
+  Invalid,
+  type ControllerClass,
+  type RouteDefinition,
+  type RouteManifest,
+} from '@avelonjs/core'
+
+import { exportName, uriToSegments } from './routing'
+
+const BANNER = `// Generated by \`reeve route:sync\`. Do not edit.\n`
+
+function controllerImport(name: string): string {
+  return `@/app/Http/Controllers/${name}`
+}
+
+function webFile(root: string, uri: string): string {
+  const segments = uriToSegments(uri)
+  return join(root, 'app', '(web)', segments, 'page.tsx')
+}
+
+function apiFile(root: string, uri: string): string {
+  const path =
+    uri.startsWith('/api/') || uri === '/api' ? uri : `/api${uri.startsWith('/') ? uri : `/${uri}`}`
+  const segments = uriToSegments(path)
+  return join(root, 'app', '(api)', segments, 'route.ts')
+}
+
+function publicPath(root: string, file: string): string {
+  return file.slice(root.length).replaceAll('\\', '/').replace(/^\//, '')
+}
+
+async function writeGenerated(file: string, contents: string): Promise<void> {
+  await mkdir(dirname(file), { recursive: true })
+  await writeFile(file, contents)
+}
+
+/** Wipes and rewrites the Next router from a route manifest. Destructive by design. */
+export async function generateRouter<TController extends ControllerClass>(
+  manifest: RouteManifest<TController>,
+  root: string,
+  options: { basePath?: string; serverActions: boolean },
+): Promise<readonly string[]> {
+  const webRoot = join(root, 'app', '(web)')
+  const apiRoot = join(root, 'app', '(api)')
+  const routingRoot = join(root, 'framework', 'routing')
+  await rm(webRoot, { recursive: true, force: true })
+  await rm(apiRoot, { recursive: true, force: true })
+  await mkdir(routingRoot, { recursive: true })
+
+  const generated: string[] = []
+  const seenPages = new Set<string>()
+  const apiBundles = new Map<string, RouteDefinition<TController>[]>()
+
+  for (const definition of manifest.routes) {
+    const path = options.basePath
+      ? `${options.basePath.replace(/\/$/, '')}${definition.path}`
+      : definition.path
+
+    if (definition.method === 'GET') {
+      const file = webFile(root, path)
+      if (seenPages.has(file)) {
+        throw new Invalid(`Two GET routes resolve to the same page file: ${definition.path}.`, {
+          metadata: { fields: { route: [`${definition.path} collides with another GET route.`] } },
+        })
+      }
+      seenPages.add(file)
+      await writeGenerated(
+        file,
+        BANNER +
+          `import { ${definition.controller.name} } from '${controllerImport(definition.controller.name)}'\n` +
+          `import { page } from '@avelonjs/next'\n\n` +
+          `export const dynamic = 'force-dynamic'\n\n` +
+          `export default page(${definition.controller.name}, '${definition.action}', '${definition.path}')\n`,
+      )
+      generated.push(publicPath(root, file))
+    }
+
+    if (definition.api) {
+      const file = apiFile(root, path)
+      const bundle = apiBundles.get(file) ?? []
+      bundle.push(definition)
+      apiBundles.set(file, bundle)
+    }
+  }
+
+  for (const [file, bundle] of apiBundles) {
+    const controllers = [...new Set(bundle.map((definition) => definition.controller.name))]
+    const lines = [
+      BANNER.trim(),
+      ...controllers.map((name) => `import { ${name} } from '${controllerImport(name)}'`),
+      `import { handleRoute } from '@avelonjs/next'`,
+      '',
+      ...bundle.map((definition) => {
+        const method = definition.method === 'DELETE' ? 'DELETE' : definition.method
+        return (
+          `export async function ${method}(request: Request, context: { params: Promise<Record<string, string>> }) {\n` +
+          `  return handleRoute(${definition.controller.name}, '${definition.action}', '${definition.path}', request, await context.params)\n` +
+          `}\n`
+        )
+      }),
+    ]
+    await writeGenerated(file, `${lines.join('\n')}\n`)
+    generated.push(publicPath(root, file))
+  }
+
+  const writes = manifest.routes.filter((definition) => definition.method !== 'GET')
+  if (options.serverActions && writes.length > 0) {
+    const controllers = [...new Set(writes.map((definition) => definition.controller.name))]
+    const body = [
+      `'use server'`,
+      BANNER.trim(),
+      ...controllers.map((name) => `import { ${name} } from '${controllerImport(name)}'`),
+      `import { dispatch } from '@avelonjs/next'`,
+      '',
+      ...writes.map(
+        (definition) =>
+          `export async function ${exportName(definition)}(formData: FormData) {\n` +
+          `  return dispatch(${definition.controller.name}, '${definition.action}', '${definition.path}', formData)\n` +
+          `}`,
+      ),
+      '',
+    ].join('\n')
+    const file = join(routingRoot, 'actions.generated.ts')
+    await writeFile(file, body)
+    generated.push(publicPath(root, file))
+  }
+
+  const entries = manifest.routes.map((definition) => ({
+    method: definition.method,
+    path: definition.path,
+    name: definition.name,
+    controller: definition.controller.name,
+    action: definition.action,
+    middleware: definition.middleware,
+    api: definition.api,
+    export: definition.method === 'GET' ? null : exportName(definition),
+  }))
+  const manifestFile = join(routingRoot, 'manifest.generated.ts')
+  await writeFile(
+    manifestFile,
+    BANNER + `export const manifest = ${JSON.stringify(entries, null, 2)} as const\n`,
+  )
+  generated.push(publicPath(root, manifestFile))
+
+  const layout = join(webRoot, 'layout.tsx')
+  await mkdir(webRoot, { recursive: true })
+  await writeFile(
+    layout,
+    BANNER +
+      `export { default } from '@/resources/views/layouts/AppLayout'\n` +
+      `export { metadata } from '@/resources/views/layouts/AppLayout'\n` +
+      `export { viewport } from '@/resources/views/layouts/AppLayout'\n`,
+  )
+  generated.push(publicPath(root, layout))
+
+  return generated
+}