brustjs 0.1.23-alpha → 0.1.25-alpha

package/example/pokedex/pages/ListPage.tsx

@@ -1,12 +1,12 @@
-// Route "/" — the Pokédex list. NATIVE route: this whole tree is compiled to a
-// minijinja template and rendered in Rust (no React on the server). The only
-// non-host tags are <BrustPage> (the document shell) and <Island> (the floating
-// team dock) — both intercepted by the compiler.
+// Route "/" — the Pokédex list. NATIVE leaf route: compiled to a minijinja
+// template and rendered into AppLayout's <Outlet/> slot (chrome lives in
+// AppLayout, nested as the parent in routes.tsx). The page therefore returns
+// JUST its inner aa-content fragment — no <BrustPage>, no <main>: AppLayout owns
+// the document shell and the single <main>.
 //
 // Native route components support `.map()` AND conditionals (S11): pagination
 // "disabled" state is a real `{hasPrev ? <a/> : <span/>}` branch, not a
 // precomputed hide-class. See ../FRAMEWORK-GAPS.md S11.
-import PageLayout from '../components/PageLayout'
 import type { ListData } from '../lib/types'
 
 export default function ListPage({
@@ -19,16 +19,9 @@ export default function ListPage({
   hasNext,
   prevHref,
   nextHref,
-  teamProps,
 }: ListData) {
   return (
-    <PageLayout
-      native
-      title="PokéDex · brust example"
-      active="list"
-      crumb="All Pokémon"
-      teamProps={teamProps}
-    >
+    <>
       <div className="aa-page-header">
         <div>
           <h1 className="aa-page-header__title">Pokédex</h1>
@@ -78,6 +71,6 @@ export default function ListPage({
           )}
         </div>
       </div>
-    </PageLayout>
+    </>
   )
 }

package/example/pokedex/pages/TypeChart.tsx

@@ -1,19 +1,14 @@
-// Route "/type-chart" — NATIVE route. A static 18×18 type-effectiveness matrix:
-// pure read-only data, the ideal native page (compiled to jinja, rendered in
-// Rust, zero React on the server). The 19×19 grid uses nested `.map()` on the
-// native path: rows.map(r => r.cells.map(c => …)) into a CSS grid.
-import PageLayout from '../components/PageLayout'
+// Route "/type-chart" — NATIVE leaf route, rendered into AppLayout's <Outlet/>
+// slot (chrome lives in AppLayout). Returns JUST its inner aa-content fragment.
+// A static 18×18 type-effectiveness matrix: pure read-only data, the ideal
+// native page (compiled to jinja, rendered in Rust, zero React on the server).
+// The 19×19 grid uses nested `.map()` on the native path: rows.map(r =>
+// r.cells.map(c => …)) into a CSS grid.
 import type { TypeChartData } from '../lib/types'
 
-export default function TypeChart({ rows, teamProps }: TypeChartData) {
+export default function TypeChart({ rows }: TypeChartData) {
   return (
-    <PageLayout
-      native
-      title="PokéDex · type chart"
-      active="typechart"
-      crumb="Type chart"
-      teamProps={teamProps}
-    >
+    <>
       <div className="aa-page-header">
         <div>
           <h1 className="aa-page-header__title">Type chart</h1>
@@ -49,6 +44,6 @@ export default function TypeChart({ rows, teamProps }: TypeChartData) {
           ))}
         </div>
       </div>
-    </PageLayout>
+    </>
   )
 }

package/example/pokedex/routes.tsx

@@ -1,4 +1,5 @@
 import { defineRoutes } from 'brustjs/routes'
+import AppLayout from './components/AppLayout'
 import { detailLoader, listLoader, typeChartLoader } from './lib/loaders'
 import DetailPage from './pages/DetailPage'
 import ListPage from './pages/ListPage'
@@ -9,13 +10,27 @@ import TypeChart from './pages/TypeChart'
 // runs in a Bun worker and its return value becomes the template scope. The only
 // React that ever boots in the browser is the islands (TeamBuilder /
 // AddToTeamButton). See ./FRAMEWORK-GAPS.md for what this costs.
+//
+// ROUTER-LEVEL LAYOUT (Approach a): the chrome (sidebar / topbar / team-dock) is
+// written ONCE in AppLayout, nested as the parent of the three leaf routes. Each
+// leaf renders into AppLayout's <Outlet/> slot. The compiler builds the synth
+// wrapper `<AppLayout native><Leaf native/></AppLayout>` per leaf and runs the
+// chain loaders top-down, shallow-merging into one flat jinja context. The leaf
+// loaders therefore also return the chrome fields (title/active/crumb/teamProps)
+// that AppLayout reads — see lib/loaders.ts and components/AppLayout.tsx.
 export const routes = defineRoutes([
-  // List + pagination (query string via req.search, validated by hand in the loader).
-  { path: '/', Component: ListPage, native: true, loader: listLoader },
+  {
+    Component: AppLayout,
+    native: true,
+    children: [
+      // List + pagination (query string via req.search, validated by hand in the loader).
+      { path: '/', Component: ListPage, native: true, loader: listLoader },
 
-  // Dynamic param {name} + a (non-streamed) evolution chain loaded in the loader.
-  { path: '/pokemon/{name}', Component: DetailPage, native: true, loader: detailLoader },
+      // Dynamic param {name} + a (non-streamed) evolution chain loaded in the loader.
+      { path: '/pokemon/{name}', Component: DetailPage, native: true, loader: detailLoader },
 
-  // Static 18×18 effectiveness matrix — the ideal native page.
-  { path: '/type-chart', Component: TypeChart, native: true, loader: typeChartLoader },
+      // Static 18×18 effectiveness matrix — the ideal native page.
+      { path: '/type-chart', Component: TypeChart, native: true, loader: typeChartLoader },
+    ],
+  },
 ])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brustjs",
-  "version": "0.1.23-alpha",
+  "version": "0.1.25-alpha",
   "description": "Bun + Rust SSR framework — React on the server, Rust everywhere else (napi cdylib + per-worker SharedArrayBuffer).",
   "license": "MIT",
   "repository": {
@@ -40,12 +40,12 @@
     "typescript": "^6.0.3"
   },
   "optionalDependencies": {
-    "brustjs-darwin-x64": "0.1.23-alpha",
-    "brustjs-darwin-arm64": "0.1.23-alpha",
-    "brustjs-linux-x64-gnu": "0.1.23-alpha",
-    "brustjs-linux-arm64-gnu": "0.1.23-alpha",
-    "brustjs-linux-x64-musl": "0.1.23-alpha",
-    "brustjs-linux-arm64-musl": "0.1.23-alpha"
+    "brustjs-darwin-x64": "0.1.25-alpha",
+    "brustjs-darwin-arm64": "0.1.25-alpha",
+    "brustjs-linux-x64-gnu": "0.1.25-alpha",
+    "brustjs-linux-arm64-gnu": "0.1.25-alpha",
+    "brustjs-linux-x64-musl": "0.1.25-alpha",
+    "brustjs-linux-arm64-musl": "0.1.25-alpha"
   },
   "peerDependencies": {
     "react": "^19.2.6",
@@ -98,6 +98,7 @@
     "lint": "biome lint .",
     "check": "biome check .",
     "check:fix": "biome check --write .",
-    "ci": "biome ci ."
+    "ci": "biome ci .",
+    "typecheck:treaty": "cd runtime && bunx tsc -p tsconfig.typecheck.json --noEmit"
   }
 }

package/runtime/action-error.ts

@@ -0,0 +1,31 @@
+// Typed domain error for treaty actions. `throw new ActionError(status, code, { data })`
+// from a handler (or nested business logic) → dispatchAction maps it to an HTTP
+// non-2xx with a flat body `{ code, message, data }`. Branded with Symbol.for so the
+// guard survives the class being duplicated across bundles (user code → framework).
+const ACTION_ERROR: unique symbol = Symbol.for('brust.actionError')
+
+export interface ActionErrorBody {
+  code: string
+  message: string
+  data?: unknown
+}
+
+export class ActionError extends Error {
+  readonly [ACTION_ERROR] = true as const
+  readonly status: number
+  readonly code: string
+  readonly data?: unknown
+  constructor(status: number, code: string, opts?: { message?: string; data?: unknown }) {
+    super(opts?.message ?? code)
+    this.name = 'ActionError'
+    this.status = status
+    this.code = code
+    this.data = opts?.data
+  }
+}
+
+export function isActionError(v: unknown): v is ActionError {
+  return (
+    typeof v === 'object' && v !== null && (v as Record<symbol, unknown>)[ACTION_ERROR] === true
+  )
+}

package/runtime/cli/build.ts

@@ -328,7 +328,10 @@ export async function runBuild(args: string[]): Promise<void> {
     // an empty importMap (no native routes to emit anyway).
     await emitNativeTemplates({
       entryFile: existsSync(routesFile) ? routesFile : entry,
-      flatRoutes: (loadedRoutes ?? []) as { nativeTemplate?: string }[],
+      flatRoutes: (loadedRoutes ?? []) as {
+        nativeTemplate?: string
+        chain?: Array<{ Component?: { name?: string } }>
+      }[],
       outDir: jinjaDir,
       repoRoot: REPO_ROOT,
     })

package/runtime/cli/dev.ts

@@ -82,7 +82,10 @@ export async function runDev(args: string[]): Promise<void> {
   const jinjaDir = path.join(process.cwd(), '.brust/jinja')
   const emitOpts = {
     entryFile: existsSync(routesFile) ? routesFile : entry,
-    flatRoutes: loadedRoutes as { nativeTemplate?: string }[],
+    flatRoutes: loadedRoutes as {
+      nativeTemplate?: string
+      chain?: Array<{ Component?: { name?: string } }>
+    }[],
     outDir: jinjaDir,
     repoRoot: REPO_ROOT,
   }

package/runtime/cli/native-routes-emit.ts

@@ -83,6 +83,125 @@ export function gatherComponentSources(pageSourcePath: string): {
   return { sources, mergedImports }
 }
 
+/** T2 / B1 fix — gather component sources for an ENTIRE native chain.
+ *
+ * The leaf of a composed chain is a bare fragment that no longer imports its
+ * ancestors, so seeding `gatherComponentSources` from the leaf alone would
+ * leave every ancestor's source ABSENT — `<AppLayout native>` would then
+ * silently soft-fall to an SsrComponent (React render) and break native. This
+ * unions `gatherComponentSources` over EVERY chain component's resolved source
+ * file (resolved name→file via the entry's `importMap`), then injects each
+ * chain component's OWN source keyed by its ident.
+ *
+ * Returns the merged `sources` map and `mergedImports` (ident→absolute path).
+ * Post-condition: `sources` has a key for every chain component name. Throws if
+ * a chain component name can't be resolved to a source file via `importMap`. */
+export function gatherChainSources(
+  chainNames: string[],
+  importMap: Map<string, string>,
+): { sources: Record<string, string>; mergedImports: Map<string, string> } {
+  const sources: Record<string, string> = {}
+  const mergedImports = new Map<string, string>()
+
+  for (const compName of chainNames) {
+    const compPath = importMap.get(compName)
+    if (!compPath) {
+      throw new Error(
+        `native chain component "${compName}" has no matching import in the routes entry ` +
+          `(expected \`import ${compName} from "..."\`)`,
+      )
+    }
+
+    // Union the transitive sources reachable from THIS chain component.
+    const { sources: subSources, mergedImports: subImports } = gatherComponentSources(compPath)
+    for (const [ident, src] of Object.entries(subSources)) {
+      if (ident in sources && sources[ident] !== src) {
+        throw new Error(
+          `native build: ambiguous component ident "${ident}" — two different sources in one chain`,
+        )
+      }
+      sources[ident] = src
+    }
+    for (const [ident, p] of subImports) {
+      const existing = mergedImports.get(ident)
+      if (existing !== undefined && existing !== p) {
+        throw new Error(
+          `native build: ambiguous component ident "${ident}" resolves to two paths: ${existing} and ${p}`,
+        )
+      }
+      mergedImports.set(ident, p)
+    }
+
+    // Inject the chain component's OWN source keyed by its ident — it is the
+    // route source for `gatherComponentSources(compPath)` (which seeds from the
+    // file's imports, not the file itself), so it would otherwise be missing.
+    const ownSrc = readFileSync(compPath, 'utf8')
+    if (compName in sources && sources[compName] !== ownSrc) {
+      throw new Error(
+        `native build: ambiguous component ident "${compName}" — two different sources in one chain`,
+      )
+    }
+    sources[compName] = ownSrc
+    mergedImports.set(compName, compPath)
+  }
+
+  return { sources, mergedImports }
+}
+
+/** T2 — build the synthetic wrapper SOURCE STRING for a native route chain.
+ *
+ * Given the component identifiers parent→leaf (e.g. `['AppLayout', 'Leaf']`),
+ * emit a default-exported function whose body nests every component, leaf
+ * innermost, with the `native` attribute on EVERY tag:
+ *
+ *   export default function Leaf__chain() { return <AppLayout native><Leaf native/></AppLayout>; }
+ *
+ * Load-bearing details:
+ * - `export default function` is required — the Rust compiler's
+ *   `find_default_export` only matches that exact form.
+ * - `native` on every tag — without it a nested component lowers to an
+ *   SsrComponent (React render) instead of being inlined into the chain.
+ * - The leaf tag is self-closing; each ancestor wraps the next via `<Outlet/>`
+ *   inside the ancestor's own source (the compiler substitutes the children
+ *   slot for `<Outlet/>`).
+ *
+ * The wrapper function name is `${leafName}__chain` — purely cosmetic (the
+ * compiler keys off the default export, not the name). */
+export function buildChainWrapperSource(chainNames: string[]): string {
+  if (chainNames.length < 2) {
+    throw new Error(
+      `buildChainWrapperSource requires a chain of length >= 2 (got ${chainNames.length})`,
+    )
+  }
+  // The names are interpolated raw into a JSX source string fed to the compiler.
+  // They come from `Component.name` (build-time idents) so injection isn't a real
+  // attack surface, but a pathological name would emit malformed JSX (a confusing
+  // compiler parse error) — reject anything that isn't a valid component identifier.
+  for (const name of chainNames) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
+      throw new Error(
+        `native chain component name is not a valid identifier: ${JSON.stringify(name)}`,
+      )
+    }
+  }
+  const leafName = chainNames[chainNames.length - 1]!
+  // Build nested JSX inner→outer: <Leaf native/> wrapped by each ancestor.
+  let jsx = `<${leafName} native/>`
+  for (let i = chainNames.length - 2; i >= 0; i--) {
+    const name = chainNames[i]!
+    jsx = `<${name} native>${jsx}</${name}>`
+  }
+  return `export default function ${leafName}__chain() { return ${jsx}; }`
+}
+
+/** Count opening `<main>` tags in a compiled template. SPA navigation extracts
+ * the FIRST `<main>…</main>` block (routes.ts), so a composed native template
+ * must contain exactly one `<main>` — the layout owns it and leaf fragments must
+ * not add their own. More than one silently truncates the SPA-nav payload. */
+export function countMainTags(template: string): number {
+  return (template.match(/<main[\s/>]/g) ?? []).length
+}
+
 /** Dev-only: splice the /_brust/dev WS client `<script>` into a compiled native
  * template so `native: true` (jinja) routes auto-reload like React-SSR routes.
  *
@@ -133,8 +252,13 @@ export interface NativeRouteEmitOpts {
   /** User's routes entry file (absolute path). Scanned for ImportDeclarations
    * to resolve each native: true route's Component to its source .tsx. */
   entryFile: string
-  /** Flat routes array; only entries with `nativeTemplate` are emitted. */
-  flatRoutes: { nativeTemplate?: string }[]
+  /** Flat routes array; only entries with `nativeTemplate` are emitted. The
+   * runtime objects are full FlatRoutes — `chain` (parent→leaf route nodes,
+   * each carrying its `Component`) drives T2 native-chain composition. */
+  flatRoutes: {
+    nativeTemplate?: string
+    chain?: Array<{ Component?: { name?: string } }>
+  }[]
   /** `.brust/jinja` absolute output dir. Created if missing. */
   outDir: string
   /** Repo root. Retained for call-site compatibility; native compilation now
@@ -364,21 +488,69 @@ export async function emitNativeTemplates(opts: NativeRouteEmitOpts): Promise<vo
     }
     const outPath = resolve(opts.outDir, `${name}.jinja`)
 
-    // Gather transitive component sources for native inlining and build the
-    // merged import map that covers nested components (e.g. islands inside an
-    // inlined native component that don't appear in the page's own imports).
-    const { sources, mergedImports } = gatherComponentSources(sourcePath)
+    // T2 — derive the route chain (parent→leaf component idents). A chain of
+    // length > 1 is a NESTED native route: synthesize a per-leaf wrapper that
+    // composes the whole chain into one native template, and gather sources for
+    // every chain component (B1 fix). Output stays under the LEAF's template
+    // name so the Rust route table is unchanged.
+    const chain = r.chain ?? []
+    const chainNames = chain
+      .map((node) => node.Component?.name)
+      .filter((n): n is string => typeof n === 'string' && n.length > 0)
+    // A nested route (chain.length > 1) whose names collapsed (anonymous/missing
+    // Component.name) must NOT silently fall through to the flat path — that would
+    // emit the leaf-only template and drop the layout. Fail loud instead.
+    if (chain.length > 1 && chainNames.length !== chain.length) {
+      throw new Error(
+        `native nested route "${name}" has ${chain.length} chain levels but only ${chainNames.length} named components — every level needs a named component`,
+      )
+    }
+
+    // Route source + sources map fed to the compiler. For a flat route
+    // (chain.length <= 1) this is the leaf source itself, seeded from its own
+    // imports — the EXISTING, untouched code path (no synth, no regression).
+    let routeSource: string
+    let routeSourcePath: string
+    let sources: Record<string, string>
+    let mergedImports: Map<string, string>
+    if (chainNames.length > 1) {
+      routeSource = buildChainWrapperSource(chainNames)
+      // Synthetic path: a placeholder under the leaf's dir. The compiler keys
+      // off the default export + componentSources, not a real file on disk.
+      routeSourcePath = resolve(dirname(sourcePath), `${name}__chain.tsx`)
+      ;({ sources, mergedImports } = gatherChainSources(chainNames, importMap))
+    } else {
+      // Gather transitive component sources for native inlining and build the
+      // merged import map that covers nested components (e.g. islands inside an
+      // inlined native component that don't appear in the page's own imports).
+      routeSource = readFileSync(sourcePath, 'utf8')
+      routeSourcePath = sourcePath
+      ;({ sources, mergedImports } = gatherComponentSources(sourcePath))
+    }
 
     let compiled: { template: string; islandsJson: string; warnings?: string[] }
     try {
-      compiled = compileJsx!(readFileSync(sourcePath, 'utf8'), sourcePath, sources)
+      compiled = compileJsx!(routeSource, routeSourcePath, sources)
     } catch (e) {
-      throw new Error(`native route "${name}" failed to compile (${sourcePath}):\n${String(e)}`)
+      throw new Error(
+        `native route "${name}" failed to compile (${routeSourcePath}):\n${String(e)}`,
+      )
     }
 
     // Print non-fatal compiler warnings to stderr.
     for (const w of compiled.warnings ?? []) process.stderr.write(`brust: ${w}\n`)
 
+    // SPA navigation extracts the FIRST <main>…</main> block, so a native route
+    // template must hold exactly one <main>. More than one (typically a leaf
+    // fragment adding its own under a layout that already owns one) silently
+    // truncates the nav payload — warn at build time (convention: layout owns <main>).
+    if (countMainTags(compiled.template) > 1) {
+      process.stderr.write(
+        `brust: native route "${name}" has more than one <main> — SPA navigation extracts only the first <main>…</main>. ` +
+          `Keep a single <main> (the layout owns it; leaf fragments must not add their own).\n`,
+      )
+    }
+
     // Dev-only: native routes don't pass through the React renderer's dev-client
     // injection, so splice the /_brust/dev WS script in here. reEmitJinja() runs
     // this on every hot reload, so the script is always present in dev.

package/runtime/cookies.ts

@@ -0,0 +1,61 @@
+import { __scope } from './request-context.ts'
+
+export interface CookieOptions {
+  maxAge?: number
+  expires?: Date
+  path?: string
+  domain?: string
+  secure?: boolean
+  httpOnly?: boolean
+  sameSite?: 'Strict' | 'Lax' | 'None'
+}
+
+// RFC 6265 cookie-name is a token: no control chars, whitespace, or separators.
+const COOKIE_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/
+
+/** Serialize a single Set-Cookie value. The value is URL-encoded; attributes
+ * are appended in a stable order. Mirrors the standard cookie attribute names.
+ *
+ * Hardening: the name is validated as an RFC 6265 token, and the final line is
+ * asserted CRLF-free — so a stray `\r\n` in a name/path/domain (which are NOT
+ * URL-encoded, unlike the value) can't smuggle an extra response header. */
+export function serializeCookie(name: string, value: string, opts: CookieOptions = {}): string {
+  if (!COOKIE_NAME.test(name)) {
+    throw new Error(`invalid cookie name ${JSON.stringify(name)} (must be an RFC 6265 token)`)
+  }
+  let out = `${name}=${encodeURIComponent(value)}`
+  if (opts.maxAge !== undefined) out += `; Max-Age=${opts.maxAge}`
+  if (opts.expires !== undefined) out += `; Expires=${opts.expires.toUTCString()}`
+  if (opts.path !== undefined) out += `; Path=${opts.path}`
+  if (opts.domain !== undefined) out += `; Domain=${opts.domain}`
+  if (opts.secure) out += '; Secure'
+  if (opts.httpOnly) out += '; HttpOnly'
+  if (opts.sameSite !== undefined) out += `; SameSite=${opts.sameSite}`
+  if (/[\r\n]/.test(out)) {
+    throw new Error('cookie contains CR/LF — refusing to emit (header-injection guard)')
+  }
+  return out
+}
+
+/** Per-request cookie helper. `get` reads the incoming request cookies; `set`
+ * and `delete` stage a Set-Cookie onto the active request scope, flushed onto
+ * the response by routes.ts. Outside a request scope, `set`/`delete` are no-ops
+ * (dev-warn under BRUST_DEV). */
+export const cookies = {
+  get(name: string): string | undefined {
+    return __scope()?.reqCookies[name]
+  },
+  set(name: string, value: string, opts?: CookieOptions): void {
+    const s = __scope()
+    if (!s) {
+      if (process.env.BRUST_DEV === '1') {
+        console.warn(`[brust] cookies.set('${name}') outside a request scope — no-op`)
+      }
+      return
+    }
+    s.setCookies.push(serializeCookie(name, value, opts))
+  },
+  delete(name: string, opts?: Pick<CookieOptions, 'path' | 'domain'>): void {
+    cookies.set(name, '', { ...opts, maxAge: 0 })
+  },
+}

package/runtime/define-actions.ts

@@ -46,6 +46,10 @@ export interface EndpointOptions {
   middleware?: Middleware[]
   /** Build-time MCP tool description (read by the manifest extractor). */
   description?: string
+  /** Declared domain errors, keyed by code. Each value is a StandardSchema for
+   * the error's `data` payload. TYPE-ONLY: flows into the treaty client's typed
+   * error union; the runtime ignores it (handlers throw `ActionError`). */
+  errors?: Record<string, StandardSchemaV1>
 }
 export interface EndpointDef {
   method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'
@@ -72,8 +76,19 @@ type QueryOf<O> = O extends { query: infer S }
     ? InferOutput<S>
     : unknown
   : Record<string, string>
+/** Discriminated error union derived from `opts.errors`. Each declared code maps
+ * to `{ code; message; data }` where `data` is the schema's inferred output. */
+type ErrorOf<O> = O extends { errors: infer E }
+  ? {
+      [K in keyof E & string]: {
+        code: K
+        message: string
+        data: E[K] extends StandardSchemaV1 ? InferOutput<E[K]> : unknown
+      }
+    }[keyof E & string]
+  : never
 
-export type EndpointEntry = { input: unknown; output: unknown }
+export type EndpointEntry = { input: unknown; output: unknown; error: unknown }
 export type EndpointMap = Record<string, Partial<Record<EndpointDef['method'], EndpointEntry>>>
 
 export function isValidEndpointPath(p: string): boolean {
@@ -88,32 +103,44 @@ export interface ActionsBuilder<Acc extends EndpointMap = {}> {
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { GET: { input: QueryOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { GET: { input: QueryOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
   post<P extends string, O extends EndpointOptions, R>(
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { POST: { input: BodyOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { POST: { input: BodyOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
   put<P extends string, O extends EndpointOptions, R>(
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { PUT: { input: BodyOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { PUT: { input: BodyOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
   patch<P extends string, O extends EndpointOptions, R>(
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { PATCH: { input: BodyOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { PATCH: { input: BodyOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
   delete<P extends string, O extends EndpointOptions, R>(
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { DELETE: { input: BodyOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { DELETE: { input: BodyOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
   head<P extends string, O extends EndpointOptions, R>(
     path: P,
     handler: Handler<BodyOf<O>, Params<P>, QueryOf<O>, R>,
     opts?: O,
-  ): ActionsBuilder<Acc & { [K in P]: { HEAD: { input: QueryOf<O>; output: Awaited<R> } } }>
+  ): ActionsBuilder<
+    Acc & { [K in P]: { HEAD: { input: QueryOf<O>; output: Awaited<R>; error: ErrorOf<O> } } }
+  >
 }
 
 export function defineActions(): ActionsBuilder {