brustjs 0.1.11-alpha → 0.1.12-alpha

package/README.md

@@ -85,13 +85,18 @@ brustjs new   <name>              # scaffold a project (partial — see Status)
   `renderToString` runs once per key, then serves a frozen pair from Rust.
 - **`native: true` routes** — JSX compiled to a jinja template at build time and
   rendered Rust-side (`minijinja`), skipping React on the server entirely.
-- **Server actions** (`"use server"`) → per-action endpoints; client helper rewrites
-  form/`fetch` targets.
+- **Typed actions** — `defineActions().get/post/put/patch/delete/head(path, ctx => R, { body, query })`
+  on the server; `client<typeof actions>()` is an Eden-Treaty-style proxy that
+  infers the whole API from the server types (no codegen) and returns
+  `{ data, error, status, headers }` (never throws). Standard Schema (zod)
+  validation, JSON / urlencoded / multipart bodies.
 - **SSE & WebSockets** as first-class route shapes.
 - Nested routes + dynamic params, per-route typed loaders, request-scoped middleware,
-  forms/multipart, SPA-style navigation, in-process LRU response cache + island ISR cache, Tailwind v4 + CSS Modules.
-- **Agent-first** — server fns and routes expose MCP tool/resource schemas at
-  `/_brust/mcp` so agents drive the app without scraping.
+  SPA-style navigation, in-process LRU response cache + island ISR cache, Tailwind v4 + CSS Modules.
+- **Agent-first** — `defineActions` endpoints become MCP **tools** and route
+  loaders become **resources** at `/_brust/mcp`; `tools/call` runs through the
+  same validation + middleware as an HTTP request, so agents drive the app
+  without scraping.
 
 ## Performance
 
@@ -120,9 +125,9 @@ bench/ · docs/ · architecture.md
 ## Status
 
 Alpha, solo-developed. Linux is tier-1 (io_uring; glibc + musl, 6 prebuilt platform
-binaries). Known partials: `brustjs dev` TS reload is a full worker-respawn reload
-(not state-preserving HMR), islands + `.module.css`. Tailwind
-is opt-in — the scaffold adds it as a project dependency; `@import "tailwindcss"`
+binaries). Known partials: `brustjs dev` reload is a full worker-respawn (not
+state-preserving HMR) — TS, islands, and `.module.css` all reload that way.
+Tailwind is opt-in — the scaffold adds it as a project dependency; `@import "tailwindcss"`
 resolves from your own `node_modules`. Deployment note: the io_uring server needs `io_uring_*`
 syscalls permitted — a default-seccomp container (Docker/k8s) must allow them or run
 `--security-opt seccomp=unconfined`. Roadmap and limitations in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brustjs",
-  "version": "0.1.11-alpha",
+  "version": "0.1.12-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.11-alpha",
-    "brustjs-darwin-arm64": "0.1.11-alpha",
-    "brustjs-linux-x64-gnu": "0.1.11-alpha",
-    "brustjs-linux-arm64-gnu": "0.1.11-alpha",
-    "brustjs-linux-x64-musl": "0.1.11-alpha",
-    "brustjs-linux-arm64-musl": "0.1.11-alpha"
+    "brustjs-darwin-x64": "0.1.12-alpha",
+    "brustjs-darwin-arm64": "0.1.12-alpha",
+    "brustjs-linux-x64-gnu": "0.1.12-alpha",
+    "brustjs-linux-arm64-gnu": "0.1.12-alpha",
+    "brustjs-linux-x64-musl": "0.1.12-alpha",
+    "brustjs-linux-arm64-musl": "0.1.12-alpha"
   },
   "peerDependencies": {
     "react": "^19.2.6",
@@ -59,7 +59,8 @@
     "happy-dom": "^20.9.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "zod": "^4.4.3"
   },
   "type": "module",
   "types": "./runtime/index.d.ts",

package/runtime/actions.ts

@@ -1,65 +1,7 @@
-import type { BrustRequest, Middleware } from './routes.ts'
-
-/** Server-side action handler. First arg is ALWAYS BrustRequest; the client
- * stub strips it from the call site. Subsequent args are JSON-decoded from
- * the request body (which MUST be a JSON array). */
-export type ActionFn<Args extends unknown[] = unknown[], R = unknown> = (
-  req: BrustRequest,
-  ...args: Args
-) => Promise<R>
-
-/** Registration shape passed to brust.registerActions. */
-export interface ActionDef<F extends ActionFn = ActionFn> {
-  /** Stable id; must match the id used by `action<F>(id)` on the client.
-   * Charset: [A-Za-z0-9_-]+ (enforced both in TS and in Rust). */
-  id: string
-  /** Handler. Receives req + JSON-decoded args. */
-  fn: F
-  /** Per-action middleware chain. Same Middleware type used by routes. */
-  middleware?: Middleware[]
-}
-
-/** Mirrors is_safe_action_id in src/lib.rs and src/server.rs.
- * Allowed: [A-Za-z0-9_-]+ only, max 128 chars. */
-export function isValidActionId(id: string): boolean {
-  if (id.length === 0 || id.length > 128) return false
-  return /^[A-Za-z0-9_-]+$/.test(id)
-}
-
-const BRUST_MW_KEY = '__brustMiddleware'
-
-/** Attach a middleware chain to a server-action function. The function is
- * returned unchanged so the TypeScript signature is preserved verbatim —
- * callers can still write `typeof srv.deleteNote` on the client.
- *
- * Throws TypeError if `mws` isn't an array of functions.
- * Throws Error if called twice on the same fn (compose mws in one call).
- */
-export function withMiddleware<F extends (...args: never[]) => unknown>(
-  mws: readonly Middleware[],
-  fn: F,
-): F {
-  if (!Array.isArray(mws) || mws.some((m) => typeof m !== 'function')) {
-    throw new TypeError('withMiddleware expects an array of middleware functions')
-  }
-  if ((fn as { [BRUST_MW_KEY]?: unknown })[BRUST_MW_KEY] !== undefined) {
-    throw new Error(
-      'withMiddleware called twice on the same function — compose middleware in a single call instead',
-    )
-  }
-  Object.defineProperty(fn, BRUST_MW_KEY, {
-    value: Object.freeze([...mws]),
-    enumerable: false,
-    writable: false,
-    configurable: false,
-  })
-  return fn
-}
-
-/** Read the middleware metadata installed by withMiddleware. Used by the
- * scanner to populate ActionDef.middleware. Returns undefined for plain
- * (un-wrapped) functions. */
-export function getActionMiddleware(fn: unknown): Middleware[] | undefined {
-  if (typeof fn !== 'function') return undefined
-  return (fn as { [BRUST_MW_KEY]?: Middleware[] })[BRUST_MW_KEY]
-}
+export type {
+  EndpointDef,
+  ActionContext,
+  EndpointOptions,
+  ActionsBuilder,
+} from './define-actions.ts'
+export { defineActions, isValidEndpointPath } from './define-actions.ts'

package/runtime/cli/build.ts

@@ -2,10 +2,6 @@ import { existsSync } from 'node:fs'
 import { copyFile, cp, mkdir, readdir, rm } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import path, { isAbsolute, resolve } from 'node:path'
-import {
-  actionsPrebuiltPlugin,
-  writePrebuiltActionsFileWithMap,
-} from './actions-prebuilt-plugin.ts'
 import { emitNativeTemplates } from './native-routes-emit.ts'
 import { nativeShimPlugin } from './native-shim-plugin.ts'
 
@@ -217,18 +213,11 @@ export async function runBuild(args: string[]): Promise<void> {
   await rm(outDir, { recursive: true, force: true })
   await mkdir(outDir, { recursive: true })
 
-  // 2. Scan actions + rediscover id→source mapping for the prebuilt plugin.
-  const { scanActions, collectExports } = await import('../scan-actions.ts')
-  const scan = await scanActions({ roots: [entryDir] })
-  console.log(
-    `[brust build] actions: discovered ${scan.actions.length} (${scan.actions.map((a) => a.id).join(', ') || '(none)'})`,
-  )
-
-  const idToSource = new Map<string, string>()
-  for (const file of scan.sourceFiles) {
-    const defs = await collectExports(file)
-    for (const def of defs) idToSource.set(def.id, file)
-  }
+  // 2. Actions need no build-time codegen. With `defineActions(...)`, actions
+  // are an EXPLICIT module the app entry imports and passes to
+  // `brust.run({ actions })` — the dist boot registers them through the normal
+  // `import { actions } from './actions'` path, no scan and no `_actions-prebuilt`
+  // file. (The old `'use server'` filesystem scanner is gone.)
 
   // routes.tsx is the scan target for both islands (§3) and the MCP manifest
   // (§4). Computed once here and reused below.
@@ -243,6 +232,18 @@ export async function runBuild(args: string[]): Promise<void> {
     const islandsOutDir = path.join(outDir, 'islands')
     const result = await buildIslands(islandMap, { outDir: islandsOutDir })
     console.log(`[brust build] islands: ${result.islandCount} chunk(s) → ${islandsOutDir}`)
+
+    // Mirror into cwd/.brust/islands so the NON-prebuilt source runtime
+    // (`bun run <entry>` directly, and `bun run dev`) — which reads
+    // cwd/.brust/islands (see runtime/islands/build.ts default outDir) — finds
+    // the same chunks after a build. The prebuilt dist reads <distDir>/islands;
+    // this keeps the dev/source path working without a separate bundle step.
+    // Mirrors the jinja mirror below. `.brust/` is a gitignored cache dir.
+    const localIslandsDir = path.join(process.cwd(), '.brust', 'islands')
+    if (path.resolve(localIslandsDir) !== path.resolve(islandsOutDir)) {
+      await rm(localIslandsDir, { recursive: true, force: true })
+      await cp(islandsOutDir, localIslandsDir, { recursive: true })
+    }
   } else {
     console.log('[brust build] islands: skipped (no <Island> usage)')
   }
@@ -253,11 +254,11 @@ export async function runBuild(args: string[]): Promise<void> {
     const { extractMcpManifest } = await import('../mcp/extractor.ts')
     const { routes } = await import(routesFile)
     loadedRoutes = routes
+    const actionsFile = path.join(entryDir, 'actions.ts')
     const manifest = await extractMcpManifest({
-      serverFiles: scan.sourceFiles,
+      actionsFile: existsSync(actionsFile) ? actionsFile : undefined,
       routesFile,
       sourceRoots: [entryDir],
-      actions: scan.actions,
       routes,
     })
     const manifestPath = path.join(outDir, 'mcp-manifest.json')
@@ -350,11 +351,10 @@ export async function runBuild(args: string[]): Promise<void> {
     }
   }
 
-  // 5. Generate the prebuilt-actions file (always — empty list if no actions).
-  const prebuiltActionsPath = path.join(outDir, '_actions-prebuilt.ts')
-  await writePrebuiltActionsFileWithMap(prebuiltActionsPath, idToSource, REPO_ROOT)
-
-  // 6. Bun.build the server bundle with both plugins + banner.
+  // 5. Bun.build the server bundle with the native shim plugin + banner. No
+  // actions codegen: `defineActions(...)` actions register via the app entry's
+  // `import { actions } from './actions'` → `brust.run({ actions })` path, which
+  // the bundled entry already carries.
   const banner =
     `process.env.BRUST_PREBUILT = '1';\n` + `process.env.BRUST_DIST_DIR = import.meta.dir;\n`
 
@@ -380,7 +380,7 @@ export async function runBuild(args: string[]): Promise<void> {
     // point at non-existent files. Whitespace + syntax minification still apply.
     minify: { whitespace: true, syntax: true, identifiers: false },
     banner,
-    plugins: [nativeShimPlugin(REPO_ROOT), actionsPrebuiltPlugin(prebuiltActionsPath, REPO_ROOT)],
+    plugins: [nativeShimPlugin(REPO_ROOT)],
   })
 
   if (!result.success) {

package/runtime/client/index.ts

@@ -4,6 +4,9 @@
  * client doesn't need.
  */
 
+// BrustActionError is kept for backward compatibility with tests/fixtures/app
+// (AvatarUpload.tsx, NoteForm.tsx, WhoAmI.tsx) until Task M1 migrates those
+// usages to the new treaty client.
 export class BrustActionError extends Error {
   constructor(
     message: string,
@@ -15,107 +18,5 @@ export class BrustActionError extends Error {
   }
 }
 
-/** Untyped server-fn shape used as the generic constraint. The client never
- * sees BrustRequest, so we type the leading req as `any` here — the helper
- * strips it from the call site via DropReq<F>. */
-export type ServerFn = (req: any, ...args: any[]) => Promise<any>
-
-/** Drop the leading `req` arg from F's parameter list. */
-type DropReq<F> = F extends (req: any, ...args: infer A) => infer R ? (...args: A) => R : never
-
-/** Build a typed RPC stub for an action.
- *
- * Usage:
- *   import type * as srv from '../actions'
- *   const createNote = action<typeof srv.createNote>('createNote')
- *   const { id } = await createNote('hello')  // typed Promise<{ id: string }>
- *
- * @param id  The action id — matches the named export from a `'use server'`
- *            file discovered by `brust.scanActions()`. Use `withMiddleware`
- *            to attach per-action middleware on the server side.
- */
-export function action<F extends ServerFn>(id: string): DropReq<F> {
-  return (async (...args: unknown[]) => {
-    const res = await fetch(`/_brust/action/${encodeURIComponent(id)}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(args),
-    })
-    const text = await res.text()
-    if (!res.ok) {
-      const parsed = safeParse(text)
-      const message =
-        parsed &&
-        typeof parsed === 'object' &&
-        parsed !== null &&
-        'error' in parsed &&
-        parsed.error &&
-        typeof parsed.error === 'object' &&
-        'message' in parsed.error &&
-        typeof parsed.error.message === 'string'
-          ? parsed.error.message
-          : text || 'action failed'
-      throw new BrustActionError(message, res.status, parsed ?? text)
-    }
-    return text ? JSON.parse(text) : undefined
-  }) as DropReq<F>
-}
-
-function safeParse(s: string): unknown | null {
-  try {
-    return JSON.parse(s)
-  } catch {
-    return null
-  }
-}
-
-type FormActionFn<F> = F extends (req: any, fd: FormData) => infer R ? (fd: FormData) => R : never
-
-/** Build a typed RPC stub for a form-receiving action.
- *
- * The server handler MUST be declared with signature
- * `(req: BrustRequest, fd: FormData) => Promise<R>`. The framework parses
- * the request's multipart or form-urlencoded body server-side and passes
- * a FormData instance to the handler.
- *
- * Usage:
- *   import type * as srv from '../actions'
- *   const uploadAvatar = formAction<typeof srv.uploadAvatar>('uploadAvatar')
- *   const result = await uploadAvatar(new FormData(form))
- *
- * @param id  The action id — matches the named export from a `'use server'`
- *            file discovered by `brust.scanActions()`.
- */
-export function formAction<F extends (req: any, fd: FormData) => unknown>(
-  id: string,
-): FormActionFn<F> {
-  return (async (fd: FormData) => {
-    if (!(fd instanceof FormData)) {
-      throw new TypeError('formAction expects a FormData argument')
-    }
-    // DO NOT set Content-Type manually. fetch() auto-sets
-    // 'multipart/form-data; boundary=<random>' when body is a FormData;
-    // overriding loses the boundary and the server can't parse the body.
-    const res = await fetch(`/_brust/action/${encodeURIComponent(id)}`, {
-      method: 'POST',
-      body: fd,
-    })
-    const text = await res.text()
-    if (!res.ok) {
-      const parsed = safeParse(text)
-      const message =
-        parsed &&
-        typeof parsed === 'object' &&
-        parsed !== null &&
-        'error' in parsed &&
-        parsed.error &&
-        typeof parsed.error === 'object' &&
-        'message' in parsed.error &&
-        typeof parsed.error.message === 'string'
-          ? parsed.error.message
-          : text || 'action failed'
-      throw new BrustActionError(message, res.status, parsed ?? text)
-    }
-    return text ? JSON.parse(text) : undefined
-  }) as FormActionFn<F>
-}
+export { client } from '../treaty.ts'
+export type { TreatyResponse, ClientOptions } from '../treaty.ts'

package/runtime/define-actions.ts

@@ -0,0 +1,179 @@
+import type { BrustRequest, Middleware } from './routes.ts'
+import type { StandardSchemaV1, InferOutput } from './standard-schema.ts'
+
+const RESPOND = Symbol('brust.respond')
+export interface ActionResponseSentinel {
+  readonly [RESPOND]: true
+  status: number
+  body: unknown
+  headers?: Record<string, string>
+}
+export function isRespondSentinel(v: unknown): v is ActionResponseSentinel {
+  return typeof v === 'object' && v !== null && (v as Record<symbol, unknown>)[RESPOND] === true
+}
+export function makeRespond() {
+  return (
+    body: unknown,
+    init?: { status?: number; headers?: Record<string, string> },
+  ): ActionResponseSentinel => ({
+    [RESPOND]: true,
+    status: init?.status ?? 200,
+    body,
+    headers: init?.headers,
+  })
+}
+
+export interface ActionContext<
+  Body = unknown,
+  Params = Record<string, string>,
+  Query = Record<string, string>,
+> {
+  req: BrustRequest
+  body: Body
+  params: Params
+  query: Query
+  headers: Record<string, string>
+  respond: (
+    body: unknown,
+    init?: { status?: number; headers?: Record<string, string> },
+  ) => ActionResponseSentinel
+}
+type Handler<B, P, Q, R> = (ctx: ActionContext<B, P, Q>) => R | Promise<R>
+
+export interface EndpointOptions {
+  body?: StandardSchemaV1
+  query?: StandardSchemaV1
+  middleware?: Middleware[]
+  /** Build-time MCP tool description (read by the manifest extractor). */
+  description?: string
+}
+export interface EndpointDef {
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'
+  path: string
+  handler: (ctx: ActionContext) => unknown
+  body?: StandardSchemaV1
+  query?: StandardSchemaV1
+  middleware: Middleware[]
+}
+
+type ParamKeys<P extends string> = P extends `${string}{${infer K}}${infer Rest}`
+  ? (K extends `*${infer C}` ? C : K) | ParamKeys<Rest>
+  : never
+type Params<P extends string> = [ParamKeys<P>] extends [never]
+  ? Record<string, string>
+  : { [K in ParamKeys<P>]: string }
+type BodyOf<O> = O extends { body: infer S }
+  ? S extends StandardSchemaV1
+    ? InferOutput<S>
+    : unknown
+  : unknown
+type QueryOf<O> = O extends { query: infer S }
+  ? S extends StandardSchemaV1
+    ? InferOutput<S>
+    : unknown
+  : Record<string, string>
+
+export type EndpointEntry = { input: unknown; output: unknown }
+export type EndpointMap = Record<string, Partial<Record<EndpointDef['method'], EndpointEntry>>>
+
+export function isValidEndpointPath(p: string): boolean {
+  return typeof p === 'string' && p.length > 0 && p.startsWith('/') && !/[\s?#]/.test(p)
+}
+
+// biome-ignore lint/complexity/noBannedTypes: `{}` is the intersection identity for `Acc & {...}` endpoint-type accumulation; Record<string,never> would poison the intersection
+export interface ActionsBuilder<Acc extends EndpointMap = {}> {
+  endpoints: EndpointDef[]
+  use(mw: Middleware): ActionsBuilder<Acc>
+  get<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]: { GET: { input: QueryOf<O>; output: Awaited<R> } } }>
+  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> } } }>
+  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> } } }>
+  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> } } }>
+  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> } } }>
+  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> } } }>
+}
+
+export function defineActions(): ActionsBuilder {
+  const endpoints: EndpointDef[] = []
+  const globalMw: Middleware[] = []
+  const seen = new Set<string>()
+  function add(
+    method: EndpointDef['method'],
+    path: string,
+    handler: (c: ActionContext) => unknown,
+    opts?: EndpointOptions,
+  ) {
+    if (!isValidEndpointPath(path))
+      throw new Error(
+        `defineActions: invalid endpoint path ${JSON.stringify(path)} (must start with '/', no whitespace/?#)`,
+      )
+    const key = `${method} ${path}`
+    if (seen.has(key)) throw new Error(`defineActions: duplicate endpoint ${key}`)
+    seen.add(key)
+    endpoints.push({
+      method,
+      path,
+      handler,
+      body: opts?.body,
+      query: opts?.query,
+      middleware: [...globalMw, ...(opts?.middleware ?? [])],
+    })
+  }
+  const builder = {
+    endpoints,
+    use(mw: Middleware) {
+      globalMw.push(mw)
+      return builder
+    },
+    get(p: string, h: any, o?: EndpointOptions) {
+      add('GET', p, h, o)
+      return builder
+    },
+    post(p: string, h: any, o?: EndpointOptions) {
+      add('POST', p, h, o)
+      return builder
+    },
+    put(p: string, h: any, o?: EndpointOptions) {
+      add('PUT', p, h, o)
+      return builder
+    },
+    patch(p: string, h: any, o?: EndpointOptions) {
+      add('PATCH', p, h, o)
+      return builder
+    },
+    delete(p: string, h: any, o?: EndpointOptions) {
+      add('DELETE', p, h, o)
+      return builder
+    },
+    head(p: string, h: any, o?: EndpointOptions) {
+      add('HEAD', p, h, o)
+      return builder
+    },
+  }
+  return builder as unknown as ActionsBuilder
+}
+
+export { RESPOND }

package/runtime/index.d.ts

@@ -22,6 +22,12 @@ export declare function configureDevMode(enabled: boolean): void
 
 export declare function configureIslandsDir(path: string): NapiResult<undefined>
 
+/** Per-endpoint registration descriptor passed to `register_actions`. */
+export interface EndpointReg {
+  method: string
+  path: string
+}
+
 export declare function islandCacheClear(): void
 
 export declare function islandCacheGet(key: string): CachedIslandJs | null
@@ -213,12 +219,10 @@ export declare function napiWsSend(connId: bigint, data: Buffer, isBinary: boole
 export declare function napiWsSignalOpen(connId: bigint, status: number, body: Buffer, contentType: string, subprotocol: string): NapiResult<undefined>
 
 /**
- * Register the set of action ids that Rust will accept on
- * /_brust/action/<id>. Called once at boot from the main thread.
- * Validates charset and rejects duplicates. Replaces any previous set
- * (no incremental registration in MVP — register once at boot).
+ * Register action endpoints. Replaces any previous router state.
+ * Returns the number of endpoints registered.
  */
-export declare function registerActions(ids: Array<string>): NapiResult<number>
+export declare function registerActions(endpoints: Array<EndpointReg>): NapiResult<number>
 
 export declare function registerRenderer(buf: Uint8Array, f: (arg: number | string) => Promise<number>): NapiResult<number>
 
@@ -246,6 +250,8 @@ export interface ServeOptions {
   entry: string
   /** Optional performance tunables. Omit to keep framework defaults. */
   tuning?: ServeTuning
+  /** Optional action prefix override. Defaults to `/_brust/action`. */
+  actionPrefix?: string
 }
 
 /**