@fabrika/app 0.3.3 → 0.4.1

package/src/react/provider.tsx

@@ -0,0 +1,179 @@
+// `FabrikaProvider`: the page's clients, the cache of their answers, and the caller document of the SPA mount. The
+// hooks take a procedure of a client as the typed name of a call; the provider runs it on the client it holds for
+// that mount, so a test hands in a client over the test kit and the page's own module-level client stays as it is.
+
+import { createContext, type ReactNode, useContext, useState } from 'react'
+import { z } from 'zod/v4'
+import { type PageCaller, parsePageCaller } from '../client/caller'
+import { attachmentAt, type ClientNode, clientNodeOf, downloadFile } from '../client/contract'
+import { RpcError, type RpcFetch } from '../client/transport'
+import { joinPath, PAGE_CALLER_FILE } from '../contract/defaults'
+import { type FabrikaError, toFabrikaError } from './errors'
+import { QueryStore, type StoreTarget } from './store'
+
+export type CallerState =
+	| { readonly status: 'loading' }
+	| { readonly status: 'ready'; readonly caller: PageCaller }
+	| { readonly status: 'error'; readonly error: FabrikaError }
+
+/** The caller document, read once per provider when a view first asks for it. */
+export class CallerSource {
+	state: CallerState = { status: 'loading' }
+	#started = false
+	readonly #listeners = new Set<() => void>()
+
+	constructor(private readonly url: string, private readonly fetch: RpcFetch) {}
+
+	subscribe(listener: () => void): () => void {
+		this.#listeners.add(listener)
+		if (!this.#started) {
+			this.#started = true
+			void this.#load()
+		}
+		return () => this.#listeners.delete(listener)
+	}
+
+	async #load(): Promise<void> {
+		this.state = await this.#read()
+		for (const listener of [...this.#listeners]) listener()
+	}
+
+	async #read(): Promise<CallerState> {
+		try {
+			const response = await this.fetch(this.url, { credentials: 'same-origin' })
+			if (!response.ok) {
+				return {
+					status: 'error',
+					error: toFabrikaError(new RpcError({ type: 'caller', message: `HTTP ${response.status}`, httpStatus: response.status })),
+				}
+			}
+			return { status: 'ready', caller: parsePageCaller(await response.json()) }
+		} catch (error) {
+			return { status: 'error', error: toFabrikaError(error) }
+		}
+	}
+}
+
+export interface Fabrika {
+	readonly store: QueryStore
+	readonly caller: CallerSource
+	/** The call of `procedure` on the provider's client of its mount. */
+	target(procedure: unknown, hook: string): ResolvedProcedure
+	/** The download of attachment `procedure` on the provider's client of its mount. */
+	attachment(procedure: unknown, hook: string): (input: unknown) => Promise<File>
+}
+
+export interface ResolvedProcedure extends StoreTarget {
+	readonly node: ClientNode
+}
+
+const FabrikaContext = createContext<Fabrika | null>(null)
+
+/** The `{ path, code, message }` issues of a refused input, as the application answers them. */
+function issuesOf(error: z.core.$ZodError): readonly { readonly path: string; readonly code: string; readonly message: string }[] {
+	return error.issues.map((issue) => ({ path: issue.path.map(String).join('.'), code: issue.code, message: issue.message }))
+}
+
+/** Checks the input with the procedure's own schema first: a refused input is the application's 400, unsent. */
+function validated(node: ClientNode, input: unknown): unknown {
+	const schema = node.procedure?.input ?? null
+	if (schema === null) return input
+	const parsed = z.safeParse(schema, input ?? {})
+	if (parsed.success) return input
+	const issues = issuesOf(parsed.error)
+	const first = issues[0]
+	throw new RpcError({
+		type: 'validation',
+		message: first === undefined ? 'Invalid input' : `${first.path || 'input'}: ${first.message}`,
+		issues,
+		httpStatus: 400,
+	})
+}
+
+function idOf(node: ClientNode): string {
+	return node.path === '' ? node.mount : `${node.mount}.${node.path}`
+}
+
+function procedureAt(client: object, path: string): unknown {
+	let value: unknown = client
+	for (const segment of path.split('.')) {
+		value = typeof value === 'object' && value !== null ? Reflect.get(value, segment) : undefined
+	}
+	return value
+}
+
+function fabrika(clients: readonly object[], spa: string, fetch: RpcFetch): Fabrika {
+	const byMount = new Map<string, object>()
+	for (const client of clients) {
+		const node = clientNodeOf(client)
+		if (node === null || node.path !== '') throw new Error('FabrikaProvider takes the clients createClient made')
+		if (byMount.has(node.mount)) throw new Error(`FabrikaProvider holds two clients of mount '${node.mount}'`)
+		byMount.set(node.mount, client)
+	}
+	const clientOf = (mount: string, hook: string): object => {
+		const client = byMount.get(mount)
+		if (client === undefined) throw new Error(`${hook}: the FabrikaProvider holds no client of mount '${mount}'`)
+		return client
+	}
+	return {
+		store: new QueryStore(toFabrikaError),
+		caller: new CallerSource(joinPath(spa, PAGE_CALLER_FILE), fetch),
+		attachment(procedure, hook) {
+			const at = attachmentAt(procedure)
+			if (at === null) throw new Error(`${hook} takes an attachment procedure of a client createClient made`)
+			const own = procedureAt(clientOf(at.mount, hook), at.path)
+			if (attachmentAt(own) === null || typeof own !== 'object' || own === null) {
+				throw new Error(`${hook}: '${at.mount}.${at.path}' is not an attachment procedure of the provider's client`)
+			}
+			return (input) => downloadFile(own, input)
+		},
+		target(procedure, hook) {
+			const node = clientNodeOf(procedure)
+			if (node?.procedure == null) throw new Error(`${hook} takes a procedure of a client createClient made`)
+			const call = procedureAt(clientOf(node.mount, hook), node.path)
+			if (typeof call !== 'function') throw new Error(`${hook}: '${idOf(node)}' is not a procedure of the provider's client`)
+			return {
+				id: idOf(node),
+				node,
+				run: async (input) => {
+					const answer: unknown = await Reflect.apply(call, undefined, [validated(node, input)])
+					return answer
+				},
+			}
+		},
+	}
+}
+
+export interface FabrikaProviderProps {
+	/** The clients of the mounts the page calls, as `createClient` made them; read at the first render. */
+	readonly clients: readonly object[]
+	/** The prefix of the SPA mount the page is served from: the caller document is `<spa>/__fabrika-me.json`. */
+	readonly spa?: string
+	/** What the caller document is fetched with; the global `fetch` by default (a test passes the kit's). */
+	readonly fetch?: RpcFetch
+	readonly children?: ReactNode
+}
+
+export function FabrikaProvider({ clients, spa = '/', fetch: fetchCaller, children }: FabrikaProviderProps): ReactNode {
+	const [value] = useState(() => fabrika(clients, spa, fetchCaller ?? ((input, init) => fetch(input, init))))
+	return <FabrikaContext.Provider value={value}>{children}</FabrikaContext.Provider>
+}
+
+export function useFabrika(hook: string): Fabrika {
+	const value = useContext(FabrikaContext)
+	if (value === null) throw new Error(`${hook} is used outside a FabrikaProvider`)
+	return value
+}
+
+/** The prefix a mutation invalidates by default: the group it lies in (`api.deals` for `api.deals.create`). */
+export function parentOf(node: ClientNode): string {
+	const segments = node.path.split('.')
+	return segments.length <= 1 ? node.mount : `${node.mount}.${segments.slice(0, -1).join('.')}`
+}
+
+/** The prefix of a procedure or a group, for `invalidate`. */
+export function prefixOf(target: unknown): string {
+	const node = clientNodeOf(target)
+	if (node === null) throw new Error('invalidate takes a procedure or a group of a client createClient made')
+	return idOf(node)
+}

package/src/react/store.ts

@@ -0,0 +1,215 @@
+// The provider's cache, without React: one entry per procedure and input (and one per paged list), each with the
+// pages it holds, a snapshot the hooks subscribe to, and a sequence number so a slower, older answer never overwrites
+// a newer one. `invalidate` refetches the entries a view shows and drops the others.
+
+import type { FabrikaError } from './errors'
+
+/** A procedure as the store calls it: its id (`<mount>.<path>`) and the call of the provider's client. */
+export interface StoreTarget {
+	readonly id: string
+	readonly run: (input: unknown) => Promise<unknown>
+}
+
+export type QueryStatus = 'loading' | 'success' | 'error'
+
+export interface QuerySnapshot {
+	readonly status: QueryStatus
+	readonly data: unknown
+	readonly error: FabrikaError | null
+	/** A request of this entry is in flight: the first load, a refetch or the next page. */
+	readonly fetching: boolean
+}
+
+export interface PagesSnapshot {
+	readonly status: QueryStatus
+	readonly items: readonly unknown[]
+	readonly next: string | null
+	readonly error: FabrikaError | null
+	readonly fetching: boolean
+	readonly loadingMore: boolean
+}
+
+/** One page of a cursor list, as every list procedure of the paved road answers it. */
+export interface Page {
+	readonly items: readonly unknown[]
+	readonly next: string | null
+}
+
+type Listener = () => void
+
+/** JSON with sorted keys, so two inputs that are the same value are the same key. */
+export function stableKey(value: unknown): string {
+	return JSON.stringify(value, (_key, field: unknown) => {
+		if (typeof field !== 'object' || field === null || Array.isArray(field)) return field
+		return Object.fromEntries(Object.entries(field).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)))
+	}) ?? 'null'
+}
+
+/** `<mount>.<path>` lies under `prefix` when it is the prefix itself or one of its descendants. */
+export function under(id: string, prefix: string): boolean {
+	return id === prefix || id.startsWith(`${prefix}.`)
+}
+
+abstract class Entry<S> {
+	snapshot: S
+	protected sequence = 0
+	readonly #listeners = new Set<Listener>()
+
+	constructor(readonly target: StoreTarget, readonly input: unknown, initial: S) {
+		this.snapshot = initial
+	}
+
+	get watched(): boolean {
+		return this.#listeners.size > 0
+	}
+
+	subscribe(listener: Listener): () => void {
+		this.#listeners.add(listener)
+		return () => this.#listeners.delete(listener)
+	}
+
+	protected publish(snapshot: S): void {
+		this.snapshot = snapshot
+		for (const listener of [...this.#listeners]) listener()
+	}
+
+	abstract load(): Promise<void>
+}
+
+export class QueryEntry extends Entry<QuerySnapshot> {
+	constructor(target: StoreTarget, input: unknown, private readonly mapError: (error: unknown) => FabrikaError) {
+		super(target, input, { status: 'loading', data: undefined, error: null, fetching: false })
+	}
+
+	async load(): Promise<void> {
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true })
+		try {
+			const data = await this.target.run(this.input)
+			if (sequence !== this.sequence) return
+			this.publish({ status: 'success', data, error: null, fetching: false })
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			this.publish({ ...this.snapshot, status: 'error', error: this.mapError(error), fetching: false })
+		}
+	}
+}
+
+/** `null` when the answer is no page: a hook over a procedure that does not page reports it instead of looping. */
+function pageOf(value: unknown): Page | null {
+	if (typeof value !== 'object' || value === null) return null
+	const items: unknown = Reflect.get(value, 'items')
+	const next: unknown = Reflect.get(value, 'next')
+	return Array.isArray(items) && (typeof next === 'string' || next === null) ? { items, next } : null
+}
+
+const NOT_A_PAGE: FabrikaError = { kind: 'other', message: 'the procedure answered no { items, next } page', status: 0 }
+
+export class PagesEntry extends Entry<PagesSnapshot> {
+	/** How many pages the view has asked for; a refetch loads as many again. `Infinity` follows every cursor. */
+	#pages: number
+
+	constructor(target: StoreTarget, input: unknown, pages: number, private readonly mapError: (error: unknown) => FabrikaError) {
+		super(target, input, { status: 'loading', items: [], next: null, error: null, fetching: false, loadingMore: false })
+		this.#pages = pages
+	}
+
+	#request(after: string | null): Promise<unknown> {
+		const input = typeof this.input === 'object' && this.input !== null ? this.input : {}
+		return this.target.run(after === null ? input : { ...input, after })
+	}
+
+	/** Loads the first `#pages` pages again, from the first cursor. */
+	async load(): Promise<void> {
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true })
+		try {
+			const items: unknown[] = []
+			let next: string | null = null
+			let loaded = 0
+			do {
+				const page = pageOf(await this.#request(next))
+				if (sequence !== this.sequence) return
+				if (page === null) {
+					this.#refuse(NOT_A_PAGE)
+					return
+				}
+				items.push(...page.items)
+				next = page.next
+				loaded++
+			} while (next !== null && loaded < this.#pages)
+			this.publish({ status: 'success', items, next, error: null, fetching: false, loadingMore: false })
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			this.#refuse(this.mapError(error))
+		}
+	}
+
+	#refuse(error: FabrikaError): void {
+		this.publish({ ...this.snapshot, status: 'error', error, fetching: false, loadingMore: false })
+	}
+
+	/** Appends the next page; nothing while a request is in flight or when the list has no more. */
+	async loadMore(): Promise<void> {
+		const after = this.snapshot.next
+		if (after === null || this.snapshot.fetching) return
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true, loadingMore: true })
+		try {
+			const page = pageOf(await this.#request(after))
+			if (sequence !== this.sequence) return
+			if (page === null) {
+				this.#refuse(NOT_A_PAGE)
+				return
+			}
+			this.#pages++
+			this.publish({
+				status: 'success',
+				items: [...this.snapshot.items, ...page.items],
+				next: page.next,
+				error: null,
+				fetching: false,
+				loadingMore: false,
+			})
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			// The loaded rows stay; the next `loadMore` asks for the same cursor again.
+			this.publish({ ...this.snapshot, status: 'error', error: this.mapError(error), fetching: false, loadingMore: false })
+		}
+	}
+}
+
+export class QueryStore {
+	readonly #entries = new Map<string, QueryEntry | PagesEntry>()
+
+	constructor(private readonly mapError: (error: unknown) => FabrikaError) {}
+
+	query(target: StoreTarget, input: unknown): QueryEntry {
+		const key = `query\u0000${target.id}\u0000${stableKey(input)}`
+		const found = this.#entries.get(key)
+		if (found instanceof QueryEntry) return found
+		const entry = new QueryEntry(target, input, this.mapError)
+		this.#entries.set(key, entry)
+		return entry
+	}
+
+	pages(target: StoreTarget, input: unknown, pages: number): PagesEntry {
+		const key = `pages\u0000${target.id}\u0000${stableKey(input)}\u0000${pages}`
+		const found = this.#entries.get(key)
+		if (found instanceof PagesEntry) return found
+		const entry = new PagesEntry(target, input, pages, this.mapError)
+		this.#entries.set(key, entry)
+		return entry
+	}
+
+	/** Refetches every entry under one of `prefixes` that a view shows, and forgets the rest, so their next view loads. */
+	async invalidate(prefixes: readonly string[]): Promise<void> {
+		const loads: Promise<void>[] = []
+		for (const [key, entry] of this.#entries) {
+			if (!prefixes.some((prefix) => under(entry.target.id, prefix))) continue
+			if (entry.watched) loads.push(entry.load())
+			else this.#entries.delete(key)
+		}
+		await Promise.all(loads)
+	}
+}

package/src/react/testing.ts

@@ -0,0 +1,144 @@
+// @fabrika/app/react/testing — what a screen test of an SPA needs: happy-dom's document over Bun's own web platform,
+// and typing that React reads. No test-runner dependency; happy-dom's registrator is an optional peer dependency.
+
+import { GlobalRegistrator } from '@happy-dom/global-registrator'
+import { act } from 'react'
+
+/**
+ * The classes and functions of Bun's web platform a screen test keeps: the client, the test kit, a form's challenge and
+ * a download run on them, and happy-dom's own differ (a happy-dom `File` of a Bun `Blob` holds `[object Blob]`).
+ */
+const BUN_GLOBALS = [
+	'fetch',
+	'Request',
+	'Response',
+	'Headers',
+	'AbortController',
+	'AbortSignal',
+	'URL',
+	'URLSearchParams',
+	'Blob',
+	'File',
+	'FormData',
+	'TextEncoder',
+	'TextDecoder',
+	'ReadableStream',
+] as const
+
+export interface InstalledDom {
+	/** Closes the window and removes its globals; call it from the test file's `afterAll`. */
+	uninstall(): Promise<void>
+}
+
+export interface DomOptions {
+	/** The page's address; `http://app.test/` by default. A router needs a real origin. */
+	readonly url?: string
+}
+
+/**
+ * Installs happy-dom's window as the globals, keeping Bun's fetch, abort, URL, blob, file and form classes, with
+ * navigation off: a download's link click leaves the page where it is, so a later test of the file still has it. Call
+ * it in a module the test file imports first: React reads `window` when it loads.
+ */
+export function installDom(options: DomOptions = {}): InstalledDom {
+	const kept = BUN_GLOBALS.map((name) => [name, Reflect.get(globalThis, name)] as const)
+	GlobalRegistrator.register({
+		url: options.url ?? 'http://app.test/',
+		settings: {
+			navigation: {
+				disableMainFrameNavigation: true,
+				disableChildFrameNavigation: true,
+				disableChildPageNavigation: true,
+				disableFallbackToSetURL: true,
+			},
+		},
+	})
+	for (const [name, value] of kept) Reflect.set(globalThis, name, value)
+	Reflect.set(globalThis, 'IS_REACT_ACT_ENVIRONMENT', true)
+	return {
+		async uninstall() {
+			// A request a screen started may still settle: let it, before its window goes.
+			await new Promise((resolve) => setTimeout(resolve, 50))
+			await GlobalRegistrator.unregister()
+		},
+	}
+}
+
+type Control = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement
+
+/**
+ * The text a label gives its control: what is hidden from assistive technology (a required marker) left out, and so
+ * is a control the label wraps.
+ */
+function readText(element: Element): string {
+	const copy = element.cloneNode(true)
+	if (copy instanceof Element) {
+		for (const left of copy.querySelectorAll('[aria-hidden="true"], input, textarea, select')) left.remove()
+	}
+	return (copy.textContent ?? '').replace(/\s+/g, ' ').trim()
+}
+
+/** A control's accessible name: its `aria-label`, the elements `aria-labelledby` names, or its `<label>`. */
+function nameOf(control: Control): string {
+	const aria = control.getAttribute('aria-label')
+	if (aria !== null) return aria.trim()
+	const labelledBy = control.getAttribute('aria-labelledby')
+	if (labelledBy !== null) {
+		return labelledBy.split(/\s+/).map((id) => {
+			const label = control.ownerDocument.getElementById(id)
+			return label === null ? '' : readText(label)
+		}).join(' ').trim()
+	}
+	const labels = control.labels === null ? [] : [...control.labels]
+	return labels.map(readText).join(' ').trim()
+}
+
+const isControl = (element: Element): element is Control =>
+	element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement
+
+/** The one input, textarea or select whose accessible name is `label`; throws when there is none or more than one. */
+export function controlByLabel(label: string, within: ParentNode = document.body): Control {
+	const found = [...within.querySelectorAll('input, textarea, select')].filter(isControl).filter((control) => nameOf(control) === label)
+	const [control] = found
+	if (control === undefined || found.length > 1) {
+		throw new Error(`${found.length === 0 ? 'no' : found.length} control${found.length > 1 ? 's' : ''} labelled '${label}'`)
+	}
+	return control
+}
+
+/** The prototype whose `value` setter React's own value tracking does not see, so the next event reads as a change. */
+function valueSetter(control: Control): ((value: string) => void) | undefined {
+	const prototype = control instanceof HTMLTextAreaElement
+		? HTMLTextAreaElement.prototype
+		: control instanceof HTMLSelectElement
+		? HTMLSelectElement.prototype
+		: HTMLInputElement.prototype
+	return Object.getOwnPropertyDescriptor(prototype, 'value')?.set
+}
+
+/**
+ * Types `value` into the control labelled `label`, as React reads a person typing: it focuses the control, sets the
+ * value past React's tracking, and sends `input`, `change` and `keyup`. A select takes the option's value.
+ */
+export async function type(label: string, value: string, within?: ParentNode): Promise<void> {
+	const control = controlByLabel(label, within)
+	await act(async () => {
+		control.focus()
+		valueSetter(control)?.call(control, value)
+		control.dispatchEvent(new Event('input', { bubbles: true }))
+		control.dispatchEvent(new Event('change', { bubbles: true }))
+		control.dispatchEvent(new KeyboardEvent('keyup', { bubbles: true }))
+	})
+}
+
+/** Waits, letting React render, until the text of `within` holds `text`; throws after `timeoutMs` (2 s by default). */
+export async function waitForText(text: string, options: { readonly within?: Element; readonly timeoutMs?: number } = {}): Promise<void> {
+	const within = options.within ?? document.body
+	const deadline = Date.now() + (options.timeoutMs ?? 2000)
+	while (!(within.textContent ?? '').includes(text)) {
+		if (Date.now() > deadline) throw new Error(`the page did not show '${text}' in time`)
+		await act(async () => {
+			await new Promise((resolve) => setTimeout(resolve, 10))
+		})
+	}
+}

package/src/react/types.ts

@@ -0,0 +1,40 @@
+// The types the hooks read off a client procedure: its input as the caller writes it, and its answer as the output
+// schema parses it.
+
+import type { z } from 'zod/v4'
+import type { Schema } from '../contract/define'
+
+/** A query or mutation of a client that `createClient` built. */
+export type ClientProcedure = ((input: never) => Promise<unknown>) & { readonly output: Schema }
+
+/** A group of a client tree (`api.deals`), or the client itself: every procedure under it. */
+export interface ClientGroup {
+	readonly [name: string]: unknown
+}
+
+/** What `invalidate` takes: one procedure, or a group for every procedure under it. */
+export type InvalidateTarget = ClientProcedure | ClientGroup
+
+/** The input as the caller writes it; `undefined` admitted for a procedure that takes none. */
+export type ProcedureInput<F extends ClientProcedure> = F extends (input: infer I) => Promise<unknown> ? I : never
+
+/** A procedure by its input `I` and output schema `O`: what the hooks take, so both are inferred from the call. */
+export type TypedProcedure<I, O extends Schema> = ((input: I) => Promise<unknown>) & { readonly output: O }
+
+/** An input argument that may be left out when the procedure takes no input. */
+export type InputArgument<I> = undefined extends I ? I | void : I
+
+/** The answer, as the procedure's output schema parses it. */
+export type ProcedureResult<F extends ClientProcedure> = z.output<F['output']>
+
+/** The answer of a cursor list: `{ items, next }`. */
+export interface PageAnswer<Item> {
+	readonly items: readonly Item[]
+	readonly next: string | null
+}
+
+/** A procedure that pages: input `after`, answer `{ items, next }`. */
+export type PagedProcedure<I, Item> = ((input: I) => Promise<unknown>) & { readonly output: z.core.$ZodType<PageAnswer<Item>> }
+
+/** The input of a paged procedure without its cursor: the hook sends `after` itself. */
+export type PageInput<I> = undefined extends I ? Omit<NonNullable<I>, 'after'> | void : Omit<I, 'after'>

package/src/rpc/dispatcher.ts

@@ -114,9 +114,9 @@ async function dispatchOne(router: AnyRouter, ctx: unknown, call: SingleCall): P
 }
 
 /**
- * Dispatch an RPC POST. The `ctx` is already built (and decorated by middleware,
- * e.g. `ctx.auth`) by the server before this is called. Handles a single call
- * `{ method, input }` or a `{ batch: [...] }`.
+ * Dispatch an RPC POST. The `ctx` is already built (with its `ctx.auth`, for example)
+ * by the server before this is called. One request is one call,
+ * `{ method, input }`.
  */
 export async function dispatchRpcRequest(args: { router: AnyRouter; ctx: unknown; request: Request }): Promise<Response> {
 	let rawBody: unknown
@@ -126,25 +126,10 @@ export async function dispatchRpcRequest(args: { router: AnyRouter; ctx: unknown
 		return jsonResponse({ error: { type: 'validation', message: 'Invalid JSON body' } }, 400)
 	}
 
-	if (isRecord(rawBody) && Array.isArray(rawBody['batch'])) {
-		const results: SingleResult[] = []
-		for (const call of rawBody['batch']) {
-			results.push((await dispatchOne(args.router, args.ctx, normalizeCall(call))).body)
-		}
-		return jsonResponse({ batch: results }, 200)
-	}
-
 	if (!isRecord(rawBody) || typeof rawBody['method'] !== 'string') {
-		return jsonResponse({ error: { type: 'validation', message: 'Body must be { method, input } or { batch: [...] }' } }, 400)
+		return jsonResponse({ error: { type: 'validation', message: 'Body must be { method, input }' } }, 400)
 	}
 
 	const single = await dispatchOne(args.router, args.ctx, { method: rawBody['method'], input: rawBody['input'] })
 	return jsonResponse(single.body, single.status)
 }
-
-function normalizeCall(call: unknown): SingleCall {
-	if (isRecord(call) && typeof call['method'] === 'string') {
-		return { method: call['method'], input: call['input'] }
-	}
-	return { method: '', input: undefined }
-}