@vigla/kit 0.0.0-stage → 0.1.0

package/src/server/read.ts

@@ -0,0 +1,80 @@
+import type { Read, ServerManifest, ServerPaths } from '../types/internal/server.ts';
+import { findRequest } from './scope.ts';
+import * as errors from './errors.ts';
+
+interface Assets {
+	manifest: ServerManifest;
+	paths: ServerPaths;
+	read?: Read;
+}
+let configured: Assets | undefined;
+export function configureRead(manifest: ServerManifest, paths: ServerPaths, read?: Read): void {
+	configured = { manifest, paths, read };
+}
+
+export function read(file: string): Response {
+	(globalThis as { __VIGLA_TRACK__?: (label: string) => void }).__VIGLA_TRACK__?.(
+		'$app/server:read'
+	);
+	const store = findRequest();
+	const source = store
+		? { manifest: store.manifest, paths: store.options.paths, read: store.state.read }
+		: configured;
+	if (!source?.read) errors.read_implementation_missing();
+	const inline = /^data:([^;,]+)?(;base64)?,/.exec(file);
+	if (inline) {
+		const encoded = file.slice(inline[0].length);
+		const value = inline[2]
+			? Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0))
+			: new TextEncoder().encode(decodeURIComponent(encoded));
+		return new Response(value, {
+			headers: {
+				'content-type': inline[1] || 'application/octet-stream',
+				'content-length': String(value.byteLength)
+			}
+		});
+	}
+	let pathname: string;
+	try {
+		pathname = decodeURIComponent(new URL(file, store?.event.url ?? 'http://kit.invalid').pathname);
+	} catch {
+		return errors.read_asset_missing({ file });
+	}
+	const prefix = source.paths.assets || source.paths.base;
+	const name = pathname.startsWith(`${prefix}/@fs/`)
+		? pathname.slice(prefix.length)
+		: pathname.startsWith(`${prefix}/`)
+			? pathname.slice(prefix.length + 1)
+			: pathname.slice(1);
+	if (!(name in source.manifest.server_assets)) errors.read_asset_missing({ file });
+	const reader = source.read;
+	const pending = Promise.resolve(reader(name)).then((stream) => {
+		if (!stream) errors.read_asset_missing({ file });
+		return stream.getReader();
+	});
+	pending.catch(() => {});
+	const body = new ReadableStream<Uint8Array>(
+		{
+			async pull(controller) {
+				try {
+					const next = await (await pending).read();
+					if (next.done) controller.close();
+					else controller.enqueue(next.value);
+				} catch (error) {
+					controller.error(error);
+				}
+			},
+			async cancel(reason) {
+				await (await pending).cancel(reason);
+			}
+		},
+		{ highWaterMark: 0 }
+	);
+	const type = source.manifest.mime_types[name.slice(name.lastIndexOf('.'))];
+	return new Response(body, {
+		headers: {
+			'content-length': String(source.manifest.server_assets[name]),
+			...(type ? { 'content-type': type } : {})
+		}
+	});
+}

package/src/server/remote/collect.ts

@@ -0,0 +1,70 @@
+import type { RemoteData, RemoteInternals, RemoteNode } from '../../types/internal/remote.ts';
+import type { RequestStore } from '../../types/internal/server.ts';
+import { Redirect } from '../../shared/outcomes.ts';
+import { handleError } from '../failure.ts';
+import { snapshot } from './resource.ts';
+
+function bucket(data: RemoteData, internals: RemoteInternals): Record<string, RemoteNode> {
+	if (internals.type === 'query_live') return (data.l ??= {});
+	if (internals.type === 'prerender') return (data.p ??= {});
+	if (internals.type === 'form') return (data.f ??= {});
+	return (data.q ??= {});
+}
+
+export async function collect(store: RequestStore, data: RemoteData): Promise<RemoteData> {
+	const processed = new Set<string>();
+	const inflight: Promise<void>[] = [];
+	const drain = (): void => {
+		for (const [key, entry] of store.remote.explicit) {
+			store.remote.explicit.delete(key);
+			if (processed.has(key)) continue;
+			processed.add(key);
+			data.r = true;
+			inflight.push(
+				entry.read().then(
+					(v) => {
+						bucket(data, entry.internals)[key] = { v };
+						drain();
+					},
+					async (error) => {
+						if (error instanceof Redirect) {
+							if (store.event.isRemoteRequest) data.redirect ??= error.location;
+						} else bucket(data, entry.internals)[key] = { e: await handleError(store, error) };
+						drain();
+					}
+				)
+			);
+		}
+	};
+	drain();
+	for (let index = 0; index < inflight.length; index++) await inflight[index];
+	const errors: Promise<void>[] = [];
+	for (const [key, entry] of store.remote.implicit) {
+		if (!entry.internals.id || processed.has(key)) continue;
+		let ready = true;
+		await Promise.race([
+			entry.read().then(
+				(v) => {
+					if (ready) bucket(data, entry.internals)[key] = { v };
+				},
+				async (error) => {
+					if (ready && !(error instanceof Redirect))
+						errors.push(
+							handleError(store, error).then((e) => {
+								bucket(data, entry.internals)[key] = { e };
+							})
+						);
+				}
+			),
+			Promise.resolve().then(() => {
+				ready = false;
+			})
+		]);
+	}
+	await Promise.all(errors);
+	if (store.remote.ignored.size) data.i = [...store.remote.ignored];
+	if (!store.event.isRemoteRequest)
+		for (const nodes of [data.q, data.l, data.p, data.f])
+			for (const [key, node] of Object.entries(nodes ?? {})) snapshot(store, key, () => node);
+	return data;
+}

package/src/server/remote/command.ts

@@ -0,0 +1,30 @@
+import type { Command } from '../../types/remote-functions.ts';
+import type { RemoteCommandInternals, RemoteImplementation } from '../../types/internal/remote.ts';
+import { getRequestStore } from '../scope.ts';
+import { server_api_unavailable } from '../errors.ts';
+import { createValidator, execute } from './shared.ts';
+import * as errors from './errors.ts';
+
+export const command: Command = (validation: any, implementation?: RemoteImplementation): any => {
+	const fn = implementation ?? validation;
+	const internals: RemoteCommandInternals = {
+		type: 'command',
+		id: '',
+		name: '',
+		validate: createValidator(validation, implementation),
+		implementation: fn
+	};
+	const invoke = (arg: unknown) => {
+		const store = getRequestStore();
+		if (store.remote.query || store.remote.prerender) errors.commandReadonly(internals.name);
+		if (!['POST', 'PUT', 'PATCH', 'DELETE'].includes(store.event.request.method)) {
+			errors.commandMethod(internals.name, store.event.request.method);
+		}
+		if (store.state.isRendering) errors.commandRender(internals.name);
+		const result = execute(store, { mutation: true }, true, () => internals.validate(arg), fn);
+		return Object.assign(result, {
+			updates: () => server_api_unavailable({ name: `${internals.name}(...).updates(...)` })
+		});
+	};
+	return Object.defineProperties(invoke, { __: { value: internals }, pending: { get: () => 0 } });
+};

package/src/server/remote/errors.ts

@@ -0,0 +1,135 @@
+import { documentationLink, throwDiagnostic } from '../../shared/diagnostics.ts';
+
+export function invalidValidator(): never {
+	return throwDiagnostic(
+		'remote_invalid_validator',
+		"Invalid validator passed to remote function. Expected `'unchecked'` or a Standard Schema (https://standardschema.dev)",
+		invalidValidator
+	);
+}
+export function headersForbidden(): never {
+	return throwDiagnostic(
+		'remote_headers_forbidden',
+		'`setHeaders` is not allowed in remote functions',
+		headersForbidden
+	);
+}
+export function cookieForbidden(operation: string): never {
+	return throwDiagnostic(
+		'remote_cookie_forbidden',
+		`Cannot ${operation} cookies in \`query\` or \`prerender\` functions`,
+		cookieForbidden
+	);
+}
+export function cookiePath(operation: string): never {
+	return throwDiagnostic(
+		'remote_cookie_path_relative',
+		`Cookies ${operation} in remote functions must have an absolute path`,
+		cookiePath
+	);
+}
+export function requestProperty(property: string): never {
+	return throwDiagnostic(
+		'remote_request_property',
+		`Cannot access \`event.${property}\` in a query. Pass the value as an argument to the query instead`,
+		requestProperty
+	);
+}
+export function commandMethod(name: string, method: string): never {
+	return throwDiagnostic(
+		'remote_command_method',
+		`Cannot call a command (\`${name}\`) from a \`${method}\` handler`,
+		commandMethod
+	);
+}
+export function commandReadonly(name: string): never {
+	return throwDiagnostic(
+		'remote_command_readonly',
+		`Cannot call a command (\`${name}\`) inside a query or prerender function`,
+		commandReadonly
+	);
+}
+export function commandRender(name: string): never {
+	return throwDiagnostic(
+		'remote_command_render',
+		`Cannot call a command (\`${name}\`) during server-side rendering`,
+		commandRender
+	);
+}
+export function queryPrerender(type: string, name: string): never {
+	return throwDiagnostic(
+		'remote_query_prerender',
+		`Cannot call \`${type}\` \`${name}\` while prerendering, as prerendered pages need static data. Use \`prerender\` from \`$app/server\` instead`,
+		queryPrerender
+	);
+}
+export function liveEmpty(name: string): never {
+	return throwDiagnostic(
+		'remote_query_live_no_value',
+		`\`query.live\` \`${name}\` did not yield a value`,
+		liveEmpty
+	);
+}
+export function liveInvalid(name: string): never {
+	return throwDiagnostic(
+		'remote_query_live_not_iterable',
+		`\`query.live\` \`${name}\` must return an \`Iterator\`, \`Iterable\`, \`AsyncIterator\` or \`AsyncIterable\``,
+		liveInvalid
+	);
+}
+export function formFailure(): never {
+	return throwDiagnostic(
+		'remote_form_fail',
+		`\`fail(...)\` is for form actions. A remote \`form\` handler should call \`invalid(...)\` instead.${documentationLink('formValidation')}`,
+		formFailure
+	);
+}
+export function invalidExport(id: string): never {
+	return throwDiagnostic(
+		'remote_module_invalid_export',
+		`\`${id.slice(id.indexOf('/') + 1)}\` exported from \`${id.slice(0, id.indexOf('/'))}\` is invalid — all exports from this file must be remote functions`,
+		invalidExport
+	);
+}
+export function defaultExport(id: string): never {
+	return throwDiagnostic(
+		'remote_module_default_export',
+		`Cannot export \`default\` from a remote module (\`${id}\`) — please use named exports instead`,
+		defaultExport
+	);
+}
+export function requestedContext(): never {
+	return throwDiagnostic(
+		'remote_requested_context',
+		'`requested(...)` can only be called in the context of a command/form remote function',
+		requestedContext
+	);
+}
+export function requestedQuery(): never {
+	return throwDiagnostic(
+		'remote_requested_invalid_query',
+		'`requested(...)` expects a query function created with `query(...)`, `query.batch(...)`, or `query.live(...)`',
+		requestedQuery
+	);
+}
+export function requestedLimit(): never {
+	return throwDiagnostic(
+		'remote_requested_invalid_limit',
+		'Limit must be a non-negative integer or `Infinity`',
+		requestedLimit
+	);
+}
+export function requestedAsync(name: string, limit: number): never {
+	return throwDiagnostic(
+		'remote_requested_async_validator',
+		`\`requested(${name}, ${limit})\` cannot be used with synchronous iteration because the query validator is async. Use \`for await ... of\` instead`,
+		requestedAsync
+	);
+}
+export function requestedMethod(method: string, live: boolean): never {
+	return throwDiagnostic(
+		'remote_requested_wrong_method',
+		`\`${method}()\` is invalid for ${live ? 'live' : 'regular'} queries. Use \`${live ? 'reconnectAll' : 'refreshAll'}()\` instead.`,
+		requestedMethod
+	);
+}

package/src/server/remote/form.ts

@@ -0,0 +1,160 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Form } from '../../types/remote-functions.ts';
+import type { RemoteFormInvalidField } from '../../types/fields.ts';
+import type {
+	RemoteFormInstance,
+	RemoteFormInternals,
+	RemoteFormResult,
+	RemoteImplementation
+} from '../../types/internal/remote.ts';
+import {
+	createFields,
+	deepSet,
+	flattenIssues,
+	normalizeIssue,
+	parseFormKey,
+	splitPath
+} from '../../shared/form-fields.ts';
+import { ActionFailure, ValidationError } from '../../shared/outcomes.ts';
+import { getRequestStore } from '../scope.ts';
+import { server_api_unavailable } from '../errors.ts';
+import { createValidator, execute } from './shared.ts';
+import { snapshot } from './resource.ts';
+import * as errors from './errors.ts';
+
+function issueProxy(path: Array<string | number> = []): RemoteFormInvalidField<any> {
+	return new Proxy((message: string): StandardSchemaV1.Issue => ({ message, path }), {
+		get(target, key) {
+			if (typeof key === 'symbol') return Reflect.get(target, key);
+			return issueProxy([...path, /^\d+$/.test(key) ? Number(key) : key]);
+		}
+	}) as RemoteFormInvalidField<any>;
+}
+
+function issues(
+	output: RemoteFormResult,
+	failures: readonly StandardSchemaV1.Issue[],
+	data: FormData | null,
+	id: string
+): void {
+	output.issues = failures.map((issue) => normalizeIssue(issue, true));
+	if (!data) return;
+	output.input = {};
+	for (const key of new Set(data.keys())) {
+		const field = parseFormKey(id, key);
+		const path = splitPath(field.name);
+		if (path.some((part) => part.startsWith('_'))) continue;
+		const entries = data.getAll(key).filter((value) => typeof value === 'string');
+		deepSet(output.input, path, field.isArray ? entries : entries[0]);
+	}
+}
+
+export const form: Form = (validation: any, implementation?: RemoteImplementation): any => {
+	const fn = implementation ?? validation;
+	const validate = createValidator(validation, implementation);
+	const create = (key?: string): RemoteFormInstance => {
+		const internals: RemoteFormInternals = {
+			type: 'form',
+			id: '',
+			name: '',
+			key,
+			validate,
+			implementation: fn,
+			async fn(data, meta, formData) {
+				const store = getRequestStore();
+				const output: RemoteFormResult = { submission: true };
+				try {
+					const input = await (implementation ? validate(data) : undefined);
+					if (meta.validate_only) return [];
+					output.result = await execute(
+						store,
+						{ mutation: true },
+						true,
+						() => input,
+						(input) => (implementation ? fn(input, issueProxy()) : fn())
+					);
+					if (output.result instanceof ActionFailure) errors.formFailure();
+				} catch (error) {
+					if (error instanceof ActionFailure) errors.formFailure();
+					if (!(error instanceof ValidationError)) throw error;
+					if (meta.validate_only) return error.issues.map((issue) => normalizeIssue(issue, true));
+					issues(output, error.issues, formData, internals.id);
+				}
+				store.remote.formValues.set(internals, output);
+				if (!store.event.isRemoteRequest) {
+					const actionId = key ? `${internals.id}/${key}` : internals.id;
+					store.remote.implicit.set(actionId, { internals, read: () => Promise.resolve(output) });
+					snapshot(store, actionId, () => ({ v: output }));
+				}
+				return output;
+			}
+		};
+		const instance = { method: 'POST' } as RemoteFormInstance;
+		const unavailable = (method: string) => server_api_unavailable({ name: `form.${method}()` });
+		Object.defineProperties(instance, {
+			__: { value: internals },
+			action: {
+				enumerable: true,
+				get() {
+					const store = getRequestStore();
+					const search = new URLSearchParams(
+						store.state.prerendering ? '' : store.event.url.search
+					);
+					search.delete('/remote');
+					const query = search.toString();
+					return `?${query ? `${query}&` : ''}/remote=${internals.id}${key ? `/${encodeURIComponent(key)}` : ''}`;
+				}
+			},
+			fields: {
+				get() {
+					const store = getRequestStore();
+					const read = () => store.remote.formValues.get(internals);
+					if (store.state.isRendering && internals.id) {
+						const actionId = key ? `${internals.id}/${key}` : internals.id;
+						snapshot(store, actionId, () => ({ v: read() }));
+					}
+					return createFields({
+						id: internals.id,
+						get: () => read()?.input ?? {},
+						set(path, value) {
+							const output = read() ?? {};
+							if (output.submission) return;
+							if (!path.length) output.input = value;
+							else deepSet((output.input ??= {}), path, value);
+							store.remote.formValues.set(internals, output);
+						},
+						issues: () => flattenIssues(read()?.issues ?? []),
+						touched: () => ({}),
+						dirty: () => ({})
+					});
+				}
+			},
+			result: { get: () => getRequestStore().remote.formValues.get(internals)?.result },
+			pending: { get: () => 0 },
+			submitted: { get: () => false },
+			element: { get: () => null },
+			preflight: { value: () => instance },
+			enhance: { value: () => ({ method: instance.method, action: instance.action }) },
+			validate: { value: () => unavailable('validate') },
+			submit: { value: () => unavailable('submit') }
+		});
+		if (key === undefined)
+			Object.defineProperty(instance, 'for', {
+				value(value: string | number) {
+					const store = getRequestStore();
+					const key = JSON.stringify(value);
+					const identity = `${internals.id}|${key}`;
+					let keyed = store.remote.forms.get(identity);
+					if (!keyed) {
+						keyed = create(key);
+						keyed.__.id = internals.id;
+						keyed.__.name = internals.name;
+						store.remote.forms.set(identity, keyed);
+					}
+					return keyed;
+				}
+			});
+		return instance;
+	};
+	return create();
+};

package/src/server/remote/handler.ts

@@ -0,0 +1,208 @@
+import type { ActionResult } from '../actions.ts';
+import type { RemoteCall, RequestStore } from '../../types/internal/server.ts';
+import type {
+	RemoteData,
+	RemoteExport,
+	RemoteFormInstance,
+	RemoteFormResult,
+	RemoteFunction,
+	RemoteResponse
+} from '../../types/internal/remote.ts';
+import { deserializeBinaryForm } from '../../shared/form-data.ts';
+import { decodeArgument, splitRemoteKey } from '../../shared/remote.ts';
+import { isForm } from '../../shared/http.ts';
+import { HttpError, Redirect } from '../../shared/outcomes.ts';
+import { serialize } from '../../shared/serialization.ts';
+import { actionLocation } from '../actions.ts';
+import { FrameworkError, handleError } from '../failure.ts';
+import { runRequest } from '../scope.ts';
+import { versionHeader } from '../headers.ts';
+import { collect } from './collect.ts';
+import { liveResponse } from './stream.ts';
+import * as errors from './errors.ts';
+
+const kinds = new Set(['query', 'query_batch', 'query_live', 'command', 'form', 'prerender']);
+
+export function initRemote(value: unknown, id: string): void {
+	const name = id.slice(id.indexOf('/') + 1);
+	if (name === 'default') errors.defaultExport(id);
+	if ((!value || typeof value !== 'object') && typeof value !== 'function')
+		errors.invalidExport(id);
+	const internals = (value as RemoteExport).__;
+	if (!internals || !kinds.has(internals.type)) errors.invalidExport(id);
+	internals.id = id;
+	internals.name = name;
+}
+
+async function lookup(
+	store: RequestStore,
+	hash: string,
+	name: string
+): Promise<RemoteExport | undefined> {
+	if (!Object.hasOwn(store.manifest.remotes, hash)) return;
+	const module = await store.manifest.remotes[hash]!();
+	return Object.hasOwn(module.default, name) ? module.default[name] : undefined;
+}
+
+function requested(store: RequestStore, keys: unknown): void {
+	if (keys === undefined) return;
+	if (!Array.isArray(keys) || keys.some((key) => typeof key !== 'string'))
+		throw new HttpError({ status: 400, message: 'Bad Request' });
+	for (const key of keys) {
+		const { id, payload } = splitRemoteKey(key);
+		let payloads = store.remote.requested.get(id);
+		if (!payloads) store.remote.requested.set(id, (payloads = new Set()));
+		payloads.add(payload);
+	}
+}
+
+function method(store: RequestStore, type: string, expected: string): void {
+	if (store.event.request.method !== expected)
+		throw new FrameworkError(
+			405,
+			'Method Not Allowed',
+			`\`${type}\` functions must be invoked via ${expected} request, not ${store.event.request.method}`
+		);
+}
+
+function response(store: RequestStore, body: RemoteResponse, status = 200): Response {
+	return Response.json(body, {
+		status,
+		headers: {
+			...(!store.state.prerendering || body.type === 'error'
+				? { 'cache-control': 'private, no-store' }
+				: {}),
+			...versionHeader(store.options)
+		}
+	});
+}
+
+export async function handleRemote(call: RemoteCall): Promise<Response> {
+	const { store } = call;
+	const fn = await lookup(store, call.id, call.name);
+	if (!fn) throw new HttpError({ status: 404, message: 'Not Found' });
+	const internals = fn.__;
+	const invoke = (arg: unknown) => runRequest(store, () => (fn as RemoteFunction)(arg));
+	try {
+		const data: RemoteData = {};
+		switch (internals.type) {
+			case 'query_live': {
+				method(store, 'query.live', 'GET');
+				const payload = new URL(store.event.request.url).searchParams.get('payload');
+				const result = liveResponse(
+					store,
+					internals,
+					decodeArgument(payload, store.hooks.transport)
+				);
+				for (const [name, value] of Object.entries(versionHeader(store.options)))
+					result.headers.set(name, value);
+				return result;
+			}
+			case 'query_batch': {
+				method(store, 'query.batch', 'POST');
+				const input: unknown = await store.event.request.json();
+				if (
+					!input ||
+					typeof input !== 'object' ||
+					!('payloads' in input) ||
+					!Array.isArray(input.payloads) ||
+					input.payloads.some((value) => typeof value !== 'string')
+				) {
+					throw new HttpError({ status: 400, message: 'Bad Request' });
+				}
+				const payloads = input.payloads;
+				data._ = await runRequest(store, () =>
+					internals.run(payloads.map((value) => decodeArgument(value, store.hooks.transport)))
+				);
+				break;
+			}
+			case 'form': {
+				method(store, 'form', 'POST');
+				if (!isForm(store.event.request))
+					throw new FrameworkError(
+						415,
+						'Unsupported Media Type',
+						'`form` functions expect form-encoded data'
+					);
+				const form = await deserializeBinaryForm(store.event.request, internals.id);
+				requested(store, form.meta.remote_refreshes);
+				if (call.argument && !('id' in form.data))
+					form.data.id = JSON.parse(decodeURIComponent(call.argument));
+				const derived = { ...store, remote: { ...store.remote, mutation: true } };
+				data._ = await runRequest(derived, () => internals.fn(form.data, form.meta, form.formData));
+				if ((data._ as RemoteFormResult).issues)
+					return response(store, { type: 'result', data: serialize(data, store.hooks.transport) });
+				break;
+			}
+			case 'command': {
+				method(store, 'command', 'POST');
+				const input: unknown = await store.event.request.json();
+				if (
+					!input ||
+					typeof input !== 'object' ||
+					!('payload' in input) ||
+					typeof input.payload !== 'string'
+				)
+					throw new HttpError({ status: 400, message: 'Bad Request' });
+				requested(store, 'refreshes' in input ? input.refreshes : undefined);
+				data._ = await invoke(decodeArgument(input.payload, store.hooks.transport));
+				break;
+			}
+			case 'prerender':
+				method(store, 'prerender', 'GET');
+				data._ = await invoke(decodeArgument(call.argument ?? '', store.hooks.transport));
+				break;
+			case 'query':
+				method(store, 'query', 'GET');
+				data._ = await invoke(
+					decodeArgument(
+						new URL(store.event.request.url).searchParams.get('payload'),
+						store.hooks.transport
+					)
+				);
+		}
+		return response(store, {
+			type: 'result',
+			data: serialize(await collect(store, data), store.hooks.transport)
+		});
+	} catch (error) {
+		if (error instanceof Redirect) {
+			const data = await collect(store, { redirect: error.location });
+			return response(store, { type: 'result', data: serialize(data, store.hooks.transport) });
+		}
+		const transformed = await handleError(store, error);
+		return response(
+			store,
+			{ type: 'error', error: transformed },
+			store.state.prerendering ? transformed.status : 200
+		);
+	}
+}
+
+export async function handleFormPost(store: RequestStore, id: string): Promise<ActionResult> {
+	const location = actionLocation(store.event.url);
+	const [hash, name, ...rest] = id.split('/');
+	let form = await lookup(store, hash ?? '', name ?? '');
+	if (form?.__.type !== 'form') {
+		store.event.setHeaders({ allow: 'GET' });
+		return { type: 'error', location, error: new FrameworkError(405, 'Method Not Allowed') };
+	}
+	try {
+		const key = rest.join('/');
+		if (key)
+			form = runRequest(store, () =>
+				(form as RemoteFormInstance).for(JSON.parse(key))
+			) as RemoteFormInstance;
+		if (form.__.type !== 'form') throw new FrameworkError(400, 'Bad Request');
+		const internals = form.__;
+		const decoded = await deserializeBinaryForm(store.event.request, internals.id);
+		if (key && !('id' in decoded.data)) decoded.data.id = JSON.parse(key);
+		const derived = { ...store, remote: { ...store.remote, mutation: true } };
+		await runRequest(derived, () => internals.fn(decoded.data, decoded.meta, decoded.formData));
+		return { type: 'success', status: 200, location, data: undefined };
+	} catch (error) {
+		if (error instanceof Redirect)
+			return { type: 'redirect', status: error.status, location: error.location };
+		return { type: 'error', location, error };
+	}
+}