@human-synthesis/norns 0.0.16 → 0.2.0

package/src/live-client.js

@@ -0,0 +1,216 @@
+/**
+ * Browser side of the live-query bridge (R-11). Generated pages with
+ * `live: true` queries call `liveQueries` from an `$effect`; the server
+ * counterpart streams refresh signals from `/_norns/live` (see
+ * `src/server/live.js`).
+ *
+ * No SvelteKit import here — the caller passes `invalidate` from
+ * `$app/navigation` so this module stays framework-neutral and testable.
+ */
+
+/** SvelteKit `depends`/`invalidate` key for a query address. */
+export const dependsKey = (address) => `norns:${address}`;
+
+/**
+ * Subscribe to refresh signals and invalidate the given query addresses
+ * when they change. Returns a cleanup function (safe for `$effect`).
+ *
+ * @param {string[]} addresses query addresses this page depends on
+ * @param {(key: string) => *} invalidate `invalidate` from `$app/navigation`
+ * @param {{ path?: string, EventSource?: typeof EventSource }} [opts]
+ * @returns {() => void}
+ */
+export function liveQueries(addresses, invalidate, opts = {}) {
+	const ES = opts.EventSource ?? globalThis.EventSource;
+	if (typeof ES !== 'function') return () => {};
+
+	const wanted = new Set(addresses);
+	const source = new ES(opts.path ?? '/_norns/live');
+	source.onmessage = (e) => {
+		let payload;
+		try {
+			payload = JSON.parse(e.data);
+		} catch {
+			return;
+		}
+		for (const address of Array.isArray(payload?.queries) ? payload.queries : []) {
+			if (wanted.has(address)) invalidate(dependsKey(address));
+		}
+	};
+	return () => source.close();
+}
+
+/**
+ * Read a streaming Endpoint (K-23 typed SSE frames) as an async iterator
+ * (R-16). Backpressure-aware — the response body is only pulled when the
+ * consumer asks for the next frame — and abortable: breaking out of the
+ * loop (or firing `opts.signal`) aborts the underlying request.
+ *
+ *   for await (const frame of streamSource('/api/chat', { input: { prompt } }))
+ *     text += frame.delta
+ *
+ * @param {string} url the Endpoint's declared route
+ * @param {{ input?: *, method?: string, signal?: AbortSignal, fetch?: typeof fetch }} [opts]
+ *   `input` is sent as a JSON POST body (streaming endpoints take their
+ *   input up front); omit it for GET-style streams.
+ * @returns {AsyncGenerator<*>} parsed `data:` frames (JSON when possible)
+ */
+export async function* streamSource(url, opts = {}) {
+	const f = opts.fetch ?? globalThis.fetch;
+	const controller = new AbortController();
+	const abort = () => controller.abort();
+	opts.signal?.addEventListener('abort', abort, { once: true });
+
+	const hasInput = opts.input !== undefined;
+	const res = await f(url, {
+		method: opts.method ?? (hasInput ? 'POST' : 'GET'),
+		headers: {
+			accept: 'text/event-stream',
+			...(hasInput ? { 'content-type': 'application/json' } : {})
+		},
+		body: hasInput ? JSON.stringify(opts.input) : undefined,
+		signal: controller.signal
+	});
+	if (!res.ok || !res.body) {
+		throw new Error(`streamSource ${url}: ${res.status}${res.body ? '' : ' — no body'}`);
+	}
+
+	const reader = res.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = '';
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let cut;
+			while ((cut = buffer.indexOf('\n\n')) !== -1) {
+				const event = buffer.slice(0, cut);
+				buffer = buffer.slice(cut + 2);
+				const data = event
+					.split('\n')
+					.filter((line) => line.startsWith('data:'))
+					.map((line) => line.slice(5).replace(/^ /, ''))
+					.join('\n');
+				if (data === '') continue;
+				try {
+					yield JSON.parse(data);
+				} catch {
+					yield data;
+				}
+			}
+		}
+	} finally {
+		opts.signal?.removeEventListener('abort', abort);
+		controller.abort();
+	}
+}
+
+/**
+ * Connect to a Room over WebSocket with reconnect/backoff (R-16). Frames
+ * are the `{ type, ...payload }` envelope the Room contract declares in
+ * `messages`; `send(type, payload)` queues while disconnected and flushes
+ * on (re)connect. Reconnects use exponential backoff with jitter and stop
+ * after `close()`.
+ *
+ * @param {string} name room address (`module.Worker.name`), used to build
+ *   the default path `/_norns/room/<name>/ws`
+ * @param {{ path?: string, WebSocket?: typeof WebSocket, backoffMs?: number,
+ *   maxBackoffMs?: number }} [opts]
+ * @returns {{ send(type: string, payload?: object): void,
+ *   on(type: string, fn: (frame: *) => void): () => void, close(): void }}
+ *   `on('*', fn)` receives every frame; other types match `frame.type`.
+ */
+export function roomChannel(name, opts = {}) {
+	const WS = opts.WebSocket ?? globalThis.WebSocket;
+	const path = opts.path ?? `/_norns/room/${encodeURIComponent(name)}/ws`;
+	const handlers = new Map();
+	const queue = [];
+	let socket = null;
+	let timer = null;
+	let attempts = 0;
+	let closed = typeof WS !== 'function'; // SSR-safe: stay inert without a WebSocket
+
+	const backoff = () => {
+		const capped = Math.min(opts.maxBackoffMs ?? 15_000, (opts.backoffMs ?? 500) * 2 ** attempts);
+		return capped / 2 + Math.random() * (capped / 2);
+	};
+
+	const connect = () => {
+		if (closed) return;
+		socket = new WS(path);
+		socket.onopen = () => {
+			attempts = 0;
+			while (queue.length > 0) socket.send(queue.shift());
+		};
+		socket.onmessage = (e) => {
+			let frame;
+			try {
+				frame = JSON.parse(e.data);
+			} catch {
+				return;
+			}
+			for (const fn of handlers.get(frame?.type) ?? []) fn(frame);
+			for (const fn of handlers.get('*') ?? []) fn(frame);
+		};
+		socket.onclose = () => {
+			socket = null;
+			if (closed) return;
+			timer = setTimeout(connect, backoff());
+			attempts += 1;
+		};
+		socket.onerror = () => socket?.close?.();
+	};
+	connect();
+
+	return {
+		send(type, payload) {
+			const message = JSON.stringify({ type, ...(payload ?? {}) });
+			if (socket?.readyState === 1) socket.send(message);
+			else queue.push(message);
+		},
+		on(type, fn) {
+			const set = handlers.get(type) ?? new Set();
+			set.add(fn);
+			handlers.set(type, set);
+			return () => set.delete(fn);
+		},
+		close() {
+			closed = true;
+			clearTimeout(timer);
+			socket?.close?.();
+			socket = null;
+		}
+	};
+}
+
+/**
+ * Call a `transport: remote` action endpoint
+ * (`module.Action.name` → POST `/api/<module>/<name>`).
+ *
+ * @param {string} address action address
+ * @param {*} [input]
+ * @param {{ fetch?: typeof fetch }} [opts]
+ */
+export async function remoteCall(address, input, opts = {}) {
+	const parts = String(address).split('.');
+	if (parts.length !== 3 || parts[1] !== 'Action') {
+		throw new Error(`remoteCall: "${address}" is not an Action address`);
+	}
+	const f = opts.fetch ?? globalThis.fetch;
+	const res = await f(`/api/${parts[0]}/${parts[2]}`, {
+		method: 'POST',
+		headers: { 'content-type': 'application/json' },
+		body: JSON.stringify(input ?? {})
+	});
+	if (!res.ok) {
+		let detail = '';
+		try {
+			detail = (await res.json())?.message ?? '';
+		} catch {
+			/* body may not be JSON */
+		}
+		throw new Error(`remoteCall ${address}: ${res.status}${detail ? ` — ${detail}` : ''}`);
+	}
+	return res.json();
+}

package/src/server/boot.js

@@ -1,8 +1,13 @@
 import { sequence } from '@sveltejs/kit/hooks';
 import { Container } from './container.js';
 import { contextHandle } from './handle/context.js';
+import { authHandle } from './handle/auth.js';
 import { errorHandle } from './handle/error.js';
 import { setSerializer } from './route.js';
+import { createEvents, registerTriggers } from './events.js';
+import { createJobs, registerJobs } from './job.js';
+import { createLive } from './live.js';
+import { scheduledHandler, startCronShim } from './cron.js';
 
 /**
  * Create a fresh root container with no features registered. Useful for tests
@@ -34,16 +39,51 @@ export function createApp() {
  * Each `module.c` must default-export a function `(app) -> ...` that calls
  * `app.bind(...)` / `app.single(...)` / `app.migrations(...)`.
  *
+ * Spec-first extras:
+ * - `triggers` — generated trigger tables (`lib/<m>/triggers.c` exports),
+ *   nested arrays are flattened. Event triggers are wired into the bus;
+ *   cron ones are served by the returned `scheduled` handler.
+ * - `queue` — Cloudflare Queues producer binding; `emit` enqueues instead of
+ *   dispatching in-process.
+ * - `jobs` — generated job tables (`lib/<m>/jobs.c` `jobs` exports), nested
+ *   arrays flattened. Wired to `job:<address>` bus messages with
+ *   retry/backoff/DLQ semantics; a `jobs` facade singleton (enqueue) is
+ *   bound automatically unless a feature bound one.
+ * - `services` — generated service tables (`lib/<m>/services.c` `services`
+ *   exports), flattened; each client is container-registered under its unit
+ *   address so custom bodies can `container.resolve('crm.Service.mailer')`.
+ * - `cronShim: true` — local minute-timer for cron triggers (`norns dev`).
+ * - `auth` — a better-auth-shaped instance (`.handler(request)` +
+ *   `.api.getSession({ headers })`); requests under `authBasePath`
+ *   (default `/api/auth`) are handed to it, every other request gets
+ *   `event.locals.user` / `event.locals.session` and scope bindings.
+ * - `room` — the `ROOM` Durable Object namespace binding (Workers prod);
+ *   live-query publishes and the `/_norns/live` stream go through it. Omit
+ *   in dev: signals ride the in-process bus.
+ * - an `events` singleton is bound automatically unless a feature bound one,
+ *   and a `live` bridge singleton likewise (actions with `refresh` lists
+ *   publish through it).
+ *
  * @param {{
  *   features?: Record<string, FeatureModule>,
  *   extraHandle?: import('@sveltejs/kit').Handle | import('@sveltejs/kit').Handle[],
  *   handleError?: import('@sveltejs/kit').HandleServerError,
- *   serializer?: import('./route.js').Serializer | null
+ *   serializer?: import('./route.js').Serializer | null,
+ *   triggers?: *[],
+ *   jobs?: *[],
+ *   services?: *[],
+ *   queue?: { send(body: *): Promise<void> | void },
+ *   cronShim?: boolean,
+ *   room?: *,
+ *   auth?: { handler(request: Request): Promise<Response> | Response, api: { getSession(input: *): Promise<*> } },
+ *   authBasePath?: string
  * }} [opts]
  * @returns {Promise<{
  *   container: Container,
  *   handle: import('@sveltejs/kit').Handle,
- *   handleError: import('@sveltejs/kit').HandleServerError
+ *   handleError: import('@sveltejs/kit').HandleServerError,
+ *   scheduled: (event: *) => Promise<void>,
+ *   stopCronShim: () => void
  * }>}
  */
 export async function boot(opts = {}) {
@@ -73,8 +113,47 @@ export async function boot(opts = {}) {
 			: [opts.extraHandle]
 		: [];
 
-	const handle = sequence(contextHandle(container), ...extras);
+	if (!container.has('events')) {
+		container.single('events', () => createEvents(opts.queue ? { queue: opts.queue } : {}));
+	}
+	if (!container.has('live')) {
+		container.single('live', () =>
+			createLive({ events: container.resolve('events'), room: opts.room })
+		);
+	}
+
+	if (!container.has('jobs')) {
+		container.single('jobs', () => createJobs(container));
+	}
+	const jobTables = (opts.jobs ?? []).flat(Infinity);
+	if (jobTables.length > 0) registerJobs(container, jobTables);
+
+	for (const table of (opts.services ?? []).flat(Infinity)) {
+		for (const [address, client] of Object.entries(table ?? {})) {
+			if (!container.has(address)) container.single(address, () => client);
+		}
+	}
+
+	const triggers = (opts.triggers ?? []).flat(Infinity);
+	if (triggers.length > 0) {
+		registerTriggers(container, triggers.filter((t) => !t.schedule));
+	}
+	const stopCronShim = opts.cronShim ? startCronShim(container, triggers) : () => {};
+
+	// contextHandle must come first so authHandle can bind user/session into
+	// the per-request scope it creates.
+	const handle = sequence(
+		contextHandle(container),
+		...(opts.auth ? [authHandle(opts.auth, { basePath: opts.authBasePath })] : []),
+		...extras
+	);
 	const handleError = opts.handleError ?? errorHandle();
 
-	return { container, handle, handleError };
+	return {
+		container,
+		handle,
+		handleError,
+		scheduled: scheduledHandler(container, triggers),
+		stopCronShim
+	};
 }

package/src/server/cron.js

@@ -0,0 +1,105 @@
+/**
+ * Cron triggers: Workers `scheduled` adapter + local timer shim for
+ * `norns dev`. Triggers are the generated tables (`[{ on, action, schedule? }]`).
+ */
+
+/**
+ * Match a 5-field cron expression (min hour dom mon dow) against a Date.
+ * Supports `*`, `n`, `a-b`, `*​/n`, `a-b/n`, and comma lists; dow 0/7 = Sunday.
+ *
+ * @param {string} expr
+ * @param {Date} date
+ */
+export function cronMatches(expr, date) {
+	const fields = expr.trim().split(/\s+/);
+	if (fields.length !== 5) return false;
+	const values = [
+		date.getUTCMinutes(),
+		date.getUTCHours(),
+		date.getUTCDate(),
+		date.getUTCMonth() + 1,
+		date.getUTCDay()
+	];
+	return fields.every((field, i) => fieldMatches(field, values[i], i === 4));
+}
+
+function fieldMatches(field, value, isDow) {
+	return field.split(',').some((part) => {
+		const [range, stepStr] = part.split('/');
+		const step = stepStr === undefined ? 1 : Number(stepStr);
+		if (!Number.isInteger(step) || step < 1) return false;
+		let lo;
+		let hi;
+		if (range === '*') {
+			lo = 0;
+			hi = Infinity;
+		} else if (range.includes('-')) {
+			[lo, hi] = range.split('-').map(Number);
+		} else {
+			lo = hi = Number(range);
+			if (isDow && lo === 7) lo = hi = 0;
+		}
+		if (!Number.isInteger(lo) || (hi !== Infinity && !Number.isInteger(hi))) return false;
+		return value >= lo && value <= hi && (value - (lo === 0 || range === '*' ? 0 : lo)) % step === 0;
+	});
+}
+
+/** @param {{ schedule?: string }[]} triggers */
+export function cronTriggers(triggers) {
+	return triggers.filter((t) => typeof t.schedule === 'string');
+}
+
+async function runTrigger(container, trigger) {
+	await trigger.action.run({ input: {}, container });
+}
+
+/**
+ * Cloudflare Workers `scheduled` handler. Runs every cron trigger whose
+ * schedule equals `event.cron` (how Workers routes multi-cron Workers), or —
+ * when `event.cron` is absent — whose schedule matches the event time.
+ *
+ * @param {*} container
+ * @param {{ schedule?: string, action: { run(ctx: *): * } }[]} triggers
+ */
+export function scheduledHandler(container, triggers) {
+	const crons = cronTriggers(triggers);
+	return async (event) => {
+		const due = event?.cron
+			? crons.filter((t) => t.schedule === event.cron)
+			: crons.filter((t) => cronMatches(t.schedule, new Date(event?.scheduledTime ?? Date.now())));
+		for (const t of due) await runTrigger(container, t);
+	};
+}
+
+/**
+ * Local dev shim: checks once per minute (aligned to the minute) and runs
+ * matching cron triggers. Returns a stop function.
+ *
+ * @param {*} container
+ * @param {{ schedule?: string, action: { run(ctx: *): * } }[]} triggers
+ * @param {{ onError?: (err: *, trigger: *) => void }} [opts]
+ */
+export function startCronShim(container, triggers, { onError } = {}) {
+	const crons = cronTriggers(triggers);
+	if (crons.length === 0) return () => {};
+	let timer;
+	const tick = async () => {
+		const now = new Date();
+		for (const t of crons.filter((t) => cronMatches(t.schedule, now))) {
+			try {
+				await runTrigger(container, t);
+			} catch (err) {
+				onError?.(err, t);
+			}
+		}
+	};
+	const arm = () => {
+		const msToMinute = 60_000 - (Date.now() % 60_000);
+		timer = setTimeout(async () => {
+			await tick();
+			arm();
+		}, msToMinute);
+	};
+	arm();
+	return () => clearTimeout(timer);
+}

package/src/server/db.js

@@ -100,7 +100,11 @@ export async function betterSqlite(path, opts = {}) {
  * @returns {Promise<any>}
  */
 export async function d1(binding, opts = {}) {
-	const { drizzle } = await importDynamic('drizzle-orm/d1');
+	// Literal specifier on purpose: wrangler's esbuild must bundle the D1
+	// driver into the worker (a runtime importDynamic() can never resolve
+	// inside a workerd bundle). Safe to resolve statically — drizzle-orm is
+	// a hard dependency of every generated app, unlike the native drivers.
+	const { drizzle } = await import('drizzle-orm/d1');
 	return drizzle(binding, opts.drizzle);
 }
 
@@ -136,6 +140,67 @@ export async function postgres(url, opts = {}) {
 	return drizzle(pool, opts.drizzle);
 }
 
+/**
+ * Apply committed SQL migrations to a SQLite-backed Drizzle instance.
+ *
+ * Walks `dirs` (a root like `migrations/` whose subdirectories are module
+ * migration sets, or an explicit list of dirs), applies `*.sql` files in
+ * name order, and records each in `_norns_migrations` so re-runs are
+ * no-ops. Statements are split on drizzle-kit's `--> statement-breakpoint`
+ * marker. Local/dev helper — production D1 migrates via
+ * `wrangler d1 migrations apply`.
+ *
+ * @param {any} db Drizzle SQLite instance
+ * @param {string | string[]} dirs
+ * @returns {Promise<string[]>} ids of newly applied migration files
+ */
+export async function applyMigrations(db, dirs) {
+	const [{ sql }, fs, path] = await Promise.all([
+		importDynamic('drizzle-orm'),
+		importDynamic('node:fs'),
+		importDynamic('node:path')
+	]);
+	await db.run(sql.raw('CREATE TABLE IF NOT EXISTS "_norns_migrations" ("name" text PRIMARY KEY)'));
+	const rows = await db.all(sql.raw('SELECT "name" FROM "_norns_migrations"'));
+	const applied = new Set(rows.map((r) => r.name));
+
+	const byName = (a, b) => a.localeCompare(b);
+	const files = [];
+	for (const root of Array.isArray(dirs) ? dirs : [dirs]) {
+		if (!fs.existsSync(root)) continue;
+		const entries = fs.readdirSync(root, { withFileTypes: true });
+		for (const entry of entries.sort((a, b) => byName(a.name, b.name))) {
+			if (entry.isDirectory()) {
+				const sqls = fs
+					.readdirSync(path.join(root, entry.name))
+					.filter((f) => f.endsWith('.sql'))
+					.sort(byName);
+				for (const f of sqls) {
+					files.push({ id: `${entry.name}/${f}`, file: path.join(root, entry.name, f) });
+				}
+			} else if (entry.name.endsWith('.sql')) {
+				files.push({ id: entry.name, file: path.join(root, entry.name) });
+			}
+		}
+	}
+
+	const ran = [];
+	for (const { id, file } of files) {
+		if (applied.has(id)) continue;
+		const text = fs.readFileSync(file, 'utf-8');
+		const stmts = text
+			.split(/-->\s*statement-breakpoint/)
+			.map((s) => s.trim())
+			.filter(Boolean);
+		for (const stmt of stmts) await db.run(sql.raw(stmt));
+		await db.run(
+			sql.raw(`INSERT INTO "_norns_migrations" ("name") VALUES ('${id.replaceAll("'", "''")}')`)
+		);
+		ran.push(id);
+	}
+	return ran;
+}
+
 /**
  * Run `fn` inside a Drizzle transaction. Uniform across drivers.
  *

package/src/server/endpoint.js

@@ -0,0 +1,142 @@
+/**
+ * Endpoint shell runtime (D14/K-23).
+ *
+ * The generated `routes<route>/+server.c` calls `endpoint(def)` with the
+ * spec-derived contract plus the custom body: auth verifies *before*
+ * anything else runs, input validates before the body, output validates
+ * after it — or, with `def.stream`, the body's yielded frames are served
+ * as SSE, each checked against the declared frame shape.
+ *
+ * Credentials resolve at request time from the env binding named in spec
+ * (container `env` token or process.env) — never from spec values.
+ */
+
+import { json, error } from '@sveltejs/kit';
+
+import { envOf, hmacHex, shapeIssues } from './service.js';
+
+/** Verify the inbound request against `def.auth` (401 on mismatch). */
+async function verifyAuth(def, event, bodyText, container) {
+	const { mode, binding, header } = def.auth ?? { mode: 'none' };
+	if (mode === 'none') return;
+	const value = envOf(container)[binding];
+	if (!value) {
+		throw error(500, { message: `Endpoint ${def.name}: env binding "${binding}" is not set` });
+	}
+	const headers = event.request.headers;
+	const ok =
+		mode === 'bearer'
+			? headers.get('authorization') === `Bearer ${value}`
+			: mode === 'basic'
+				? headers.get('authorization') === `Basic ${btoa(value)}`
+				: mode === 'header'
+					? headers.get(header) === value
+					: mode === 'hmac'
+						? headers.get('x-signature') === (await hmacHex(value, bodyText))
+						: false;
+	if (!ok) throw error(401, { message: 'unauthorized' });
+}
+
+// Query-string values arrive as strings; nudge them toward the declared type.
+const COERCE = {
+	int: (s) => (/^-?\d+$/.test(s) ? Number(s) : s),
+	number: (s) => (s !== '' && !Number.isNaN(Number(s)) ? Number(s) : s),
+	money: (s) => (s !== '' && !Number.isNaN(Number(s)) ? Number(s) : s),
+	bool: (s) => (s === 'true' ? true : s === 'false' ? false : s)
+};
+
+function coerceQuery(shape, raw) {
+	for (const [key, t] of Object.entries(shape ?? {})) {
+		const spec = (typeof t === 'string' ? t : t?.type ?? '').replace(/\?$/, '');
+		if (COERCE[spec] && typeof raw[key] === 'string') raw[key] = COERCE[spec](raw[key]);
+	}
+	return raw;
+}
+
+function sseResponse(def, frames) {
+	const enc = new TextEncoder();
+	const stream = new ReadableStream({
+		async start(controller) {
+			try {
+				for await (const frame of frames) {
+					const issues = def.stream?.frame ? shapeIssues(def.stream.frame, frame, 'frame') : [];
+					if (issues.length > 0) throw new Error(`Endpoint ${def.name}: ${issues.join('; ')}`);
+					controller.enqueue(enc.encode(`data: ${JSON.stringify(frame)}\n\n`));
+				}
+				controller.enqueue(enc.encode('event: done\ndata: {}\n\n'));
+			} catch (e) {
+				const message = String(e?.message ?? e);
+				controller.enqueue(enc.encode(`event: error\ndata: ${JSON.stringify({ message })}\n\n`));
+			}
+			controller.close();
+		}
+	});
+	return new Response(stream, {
+		headers: {
+			'content-type': 'text/event-stream',
+			'cache-control': 'no-cache',
+			connection: 'keep-alive'
+		}
+	});
+}
+
+/**
+ * @param {{
+ *   name: string,
+ *   auth?: { mode: string, binding?: string, header?: string },
+ *   input?: Record<string, *>,
+ *   output?: Record<string, *>,
+ *   stream?: { frame: Record<string, *> },
+ *   body: (ctx: { input: *, container: *, event: *, user: * }) => *
+ * }} def
+ * @returns {(event: import('@sveltejs/kit').RequestEvent) => Promise<Response>}
+ */
+export function endpoint(def) {
+	if (typeof def?.body !== 'function') throw new Error('endpoint(): `body` is required');
+
+	return async (event) => {
+		const container = event.locals.container;
+		const method = event.request.method;
+		const usesBody = method !== 'GET' && method !== 'DELETE' && method !== 'HEAD';
+		const bodyText = usesBody ? await event.request.text() : '';
+		await verifyAuth(def, event, bodyText, container);
+
+		let input;
+		if (usesBody) {
+			try {
+				input = bodyText === '' ? {} : JSON.parse(bodyText);
+			} catch {
+				throw error(400, { message: `Endpoint ${def.name}: body is not valid JSON` });
+			}
+		} else {
+			input = coerceQuery(def.input, Object.fromEntries(event.url.searchParams));
+		}
+		if (def.input) {
+			const issues = shapeIssues(def.input, input, 'input');
+			if (issues.length > 0) {
+				throw error(400, { message: `Endpoint ${def.name}: ${issues.join('; ')}`, issues });
+			}
+		}
+
+		const ctx = { input, container, event, user: event.locals.user };
+
+		if (def.stream) {
+			let frames = def.body(ctx);
+			if (!frames?.[Symbol.asyncIterator]) frames = await frames;
+			if (!frames?.[Symbol.asyncIterator]) {
+				throw error(500, { message: `Endpoint ${def.name}: stream body must return an async iterable of frames` });
+			}
+			return sseResponse(def, frames);
+		}
+
+		const result = await def.body(ctx);
+		if (result instanceof Response) return result;
+		if (def.output) {
+			const issues = shapeIssues(def.output, result, 'output');
+			if (issues.length > 0) {
+				throw error(500, { message: `Endpoint ${def.name}: ${issues.join('; ')}`, issues });
+			}
+		}
+		return json(result ?? null);
+	};
+}