diff --git a/.changeset/khaki-forks-learn.md b/.changeset/khaki-forks-learn.md
new file mode 100644
index 000000000000..d7725c8bd66b
--- /dev/null
+++ b/.changeset/khaki-forks-learn.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': minor
+---
+
+feat: enhance remote form functions with schema support, `input` and `issues` properties
diff --git a/.changeset/olive-dodos-flash.md b/.changeset/olive-dodos-flash.md
new file mode 100644
index 000000000000..bbc41830987d
--- /dev/null
+++ b/.changeset/olive-dodos-flash.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': minor
+---
+
+breaking: remote form functions get passed a parsed POJO instead of a `FormData` object now
diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index 4af669e42ed1..479e789089fc 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -227,7 +227,7 @@ export const getWeather = query.batch(v.string(), async (cities) => {
 
 ## form
 
-The `form` function makes it easy to write data to the server. It takes a callback that receives the current [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)...
+The `form` function makes it easy to write data to the server. It takes a callback that receives `data` constructed from the submitted [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)...
 
 
 ```ts
@@ -259,30 +259,28 @@ export const getPosts = query(async () => { /* ... */ });
 
 export const getPost = query(v.string(), async (slug) => { /* ... */ });
 
-export const createPost = form(async (data) => {
-	// Check the user is logged in
-	const user = await auth.getUser();
-	if (!user) error(401, 'Unauthorized');
-
-	const title = data.get('title');
-	const content = data.get('content');
-
-	// Check the data is valid
-	if (typeof title !== 'string' || typeof content !== 'string') {
-		error(400, 'Title and content are required');
+export const createPost = form(
+	v.object({
+		title: v.pipe(v.string(), v.nonEmpty()),
+		content:v.pipe(v.string(), v.nonEmpty())
+	}),
+	async ({ title, content }) => {
+		// Check the user is logged in
+		const user = await auth.getUser();
+		if (!user) error(401, 'Unauthorized');
+
+		const slug = title.toLowerCase().replace(/ /g, '-');
+
+		// Insert into the database
+		await db.sql`
+			INSERT INTO post (slug, title, content)
+			VALUES (${slug}, ${title}, ${content})
+		`;
+
+		// Redirect to the newly created page
+		redirect(303, `/blog/${slug}`);
 	}
-
-	const slug = title.toLowerCase().replace(/ /g, '-');
-
-	// Insert into the database
-	await db.sql`
-		INSERT INTO post (slug, title, content)
-		VALUES (${slug}, ${title}, ${content})
-	`;
-
-	// Redirect to the newly created page
-	redirect(303, `/blog/${slug}`);
-});
+);
 ```
 
 ...and returns an object that can be spread onto a `<form>` element. The callback is called whenever the form is submitted.
@@ -310,7 +308,184 @@ export const createPost = form(async (data) => {
 </form>
 ```
 
-The form object contains `method` and `action` properties that allow it to work without JavaScript (i.e. it submits data and reloads the page). It also has an `onsubmit` handler that progressively enhances the form when JavaScript is available, submitting data *without* reloading the entire page.
+As with `query`, if the callback uses the submitted `data`, it should be [validated](#query-Query-arguments) by passing a [Standard Schema](https://standardschema.dev) as the first argument to `form`. The one difference is to `query` is that the schema inputs must all be of type `string` or `File`, since that's all the original `FormData` provides. You can however coerce the value into a different type — how to do that depends on the validation library you use.
+
+```ts
+/// file: src/routes/count.remote.js
+import * as v from 'valibot';
+import { form } from '$app/server';
+
+export const setCount = form(
+	v.object({
+		// Valibot:
+		count: v.pipe(v.string(), v.transform((s) => Number(s)), v.number()),
+		// Zod:
+		// count: v.coerce.number()
+	}),
+	async ({ count }) => {
+		// ...
+	}
+);
+```
+
+The `name` attributes on the form controls must correspond to the properties of the schema — `title` and `content` in this case. If you schema contains objects, use object notation:
+
+```svelte
+<!--
+    results in a
+    {
+	   name: { first: string, last: string },
+	   jobs: Array<{ title: string, company: string }>
+	}
+    object
+-->
+<input name="name.first" />
+<input name="name.last" />
+{#each jobs as job, idx}
+	<input name="jobs[{idx}].title">
+	<input name="jobs[{idx}].company">
+{/each}
+```
+
+To indicate a repeated field, use a `[]` suffix:
+
+```svelte
+<label><input type="checkbox" name="language[]" value="html" /> HTML</label>
+<label><input type="checkbox" name="language[]" value="css" /> CSS</label>
+<label><input type="checkbox" name="language[]" value="js" /> JS</label>
+```
+
+If you'd like type safety and autocomplete when setting `name` attributes, use the form object's `field` method:
+
+```svelte
+<label>
+	<h2>Title</h2>
+	<input name={+++createPost.field('title')+++} />
+</label>
+```
+
+This will error during typechecking if `title` does not exist on your schema.
+
+The form object contains `method` and `action` properties that allow it to work without JavaScript (i.e. it submits data and reloads the page). It also has an [attachment](/docs/svelte/@attach) that progressively enhances the form when JavaScript is available, submitting data *without* reloading the entire page.
+
+### Validation
+
+If the submitted data doesn't pass the schema, the callback will not run. Instead, the form object's `issues` object will be populated:
+
+```svelte
+<form {...createPost}>
+	<label>
+		<h2>Title</h2>
+
++++		{#if createPost.issues.title}
+			{#each createPost.issues.title as issue}
+				<p class="issue">{issue.message}</p>
+			{/each}
+		{/if}+++
+
+		<input
+			name="title"
+			+++aria-invalid={!!createPost.issues.title}+++
+		/>
+	</label>
+
+	<label>
+		<h2>Write your post</h2>
+
++++		{#if createPost.issues.content}
+			{#each createPost.issues.content as issue}
+				<p class="issue">{issue.message}</p>
+			{/each}
+		{/if}+++
+
+		<textarea
+			name="content"
+			+++aria-invalid={!!createPost.issues.content}+++
+		></textarea>
+	</label>
+
+	<button>Publish!</button>
+</form>
+```
+
+You don't need to wait until the form is submitted to validate the data — you can call `validate()` programmatically, for example in an `oninput` callback (which will validate the data on every keystroke) or an `onchange` callback:
+
+```svelte
+<form {...createPost} oninput={() => createPost.validate()}>
+	<!-- -->
+</form>
+```
+
+By default, issues will be ignored if they belong to form controls that haven't yet been interacted with. To validate _all_ inputs, call `validate({ includeUntouched: true })`.
+
+For client-side validation, you can specify a _preflight_ schema which will populate `issues` and prevent data being sent to the server if the data doesn't validate:
+
+```svelte
+<script>
+	import * as v from 'valibot';
+	import { createPost } from '../data.remote';
+
+	const schema = v.object({
+		title: v.pipe(v.string(), v.nonEmpty()),
+		content:v.pipe(v.string(), v.nonEmpty())
+	});
+</script>
+
+<h1>Create a new post</h1>
+
+<form {...+++createPost.preflight(schema)+++}>
+	<!-- -->
+</form>
+```
+
+> [!NOTE] The preflight schema can be the same object as your server-side schema, if appropriate, though it won't be able to do server-side checks like 'this value already exists in the database'. Note that you cannot export a schema from a `.remote.ts` or `.remote.js` file, so the schema must either be exported from a shared module, or from a `<script module>` block in the component containing the `<form>`.
+
+### Live inputs
+
+The form object contains a `input` property which reflects its current value. As the user interacts with the form, `input` is automatically updated:
+
+```svelte
+<form {...createPost}>
+	<!-- -->
+</form>
+
+<div class="preview">
+	<h2>{createPost.input.title}</h2>
+	<div>{@html render(createPost.input.content)}</div>
+</div>
+```
+
+### Handling sensitive data
+
+In the case of a non-progressively-enhanced form submission (i.e. where JavaScript is unavailable, for whatever reason) `input` is also populated if the submitted data is invalid, so that the user does not need to fill the entire form out from scratch.
+
+You can prevent sensitive data (such as passwords and credit card numbers) from being sent back to the user by using a name with a leading underscore:
+
+```svelte
+<form {...register}>
+	<label>
+		Username
+		<input
+			name="username"
+			value={register.input.username}
+			aria-invalid={!!register.issues.username}
+		/>
+	</label>
+
+	<label>
+		Password
+		<input
+			type="password"
+			+++name="_password"+++
+			+++aria-invalid={!!register.issues._password}+++
+		/>
+	</label>
+
+	<button>Sign up!</button>
+</form>
+```
+
+In this example, if the data does not validate, only the first `<input>` will be populated when the page reloads.
 
 ### Single-flight mutations
 
@@ -331,25 +506,31 @@ export const getPosts = query(async () => { /* ... */ });
 
 export const getPost = query(v.string(), async (slug) => { /* ... */ });
 
-export const createPost = form(async (data) => {
-	// form logic goes here...
+export const createPost = form(
+	v.object({/* ... */}),
+	async (data) => {
+		// form logic goes here...
 
-	// Refresh `getPosts()` on the server, and send
-	// the data back with the result of `createPost`
-	+++await getPosts().refresh();+++
+		// Refresh `getPosts()` on the server, and send
+		// the data back with the result of `createPost`
+		+++await getPosts().refresh();+++
 
-	// Redirect to the newly created page
-	redirect(303, `/blog/${slug}`);
-});
+		// Redirect to the newly created page
+		redirect(303, `/blog/${slug}`);
+	}
+);
 
-export const updatePost = form(async (data) => {
-	// form logic goes here...
-	const result = externalApi.update(post);
+export const updatePost = form(
+	v.object({/* ... */}),
+	async (data) => {
+		// form logic goes here...
+		const result = externalApi.update(post);
 
-	// The API already gives us the updated post,
-	// no need to refresh it, we can set it directly
-	+++await getPost(post.id).set(result);+++
-});
+		// The API already gives us the updated post,
+		// no need to refresh it, we can set it directly
+		+++await getPost(post.id).set(result);+++
+	}
+);
 ```
 
 The second is to drive the single-flight mutation from the client, which we'll see in the section on [`enhance`](#form-enhance).
@@ -387,11 +568,14 @@ export const getPosts = query(async () => { /* ... */ });
 export const getPost = query(v.string(), async (slug) => { /* ... */ });
 
 // ---cut---
-export const createPost = form(async (data) => {
-	// ...
+export const createPost = form(
+	v.object({/* ... */}),
+	async (data) => {
+		// ...
 
-	return { success: true };
-});
+		return { success: true };
+	}
+);
 ```
 
 ```svelte
@@ -402,7 +586,9 @@ export const createPost = form(async (data) => {
 
 <h1>Create a new post</h1>
 
-<form {...createPost}><!-- ... --></form>
+<form {...createPost}>
+	<!-- -->
+</form>
 
 {#if createPost.result?.success}
 	<p>Successfully published!</p>
@@ -438,9 +624,7 @@ We can customize what happens when the form is submitted with the `enhance` meth
 		showToast('Oh no! Something went wrong');
 	}
 })}>
-	<input name="title" />
-	<textarea name="content"></textarea>
-	<button>publish</button>
+	<!-- -->
 </form>
 ```
 
@@ -517,7 +701,7 @@ The `command` function, like `form`, allows you to write data to the server. Unl
 
 > [!NOTE] Prefer `form` where possible, since it gracefully degrades if JavaScript is disabled or fails to load.
 
-As with `query`, if the function accepts an argument, it should be [validated](#query-Query-arguments) by passing a [Standard Schema](https://standardschema.dev) as the first argument to `command`.
+As with `query` and `form`, if the function accepts an argument, it should be [validated](#query-Query-arguments) by passing a [Standard Schema](https://standardschema.dev) as the first argument to `command`.
 
 ```ts
 /// file: likes.remote.js
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 9334ee453db6..c993ae897d38 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -1706,28 +1706,105 @@ export interface Snapshot<T = any> {
 	restore: (snapshot: T) => void;
 }
 
+// If T is unknown or RemoteFormInput, the types below will recurse indefinitely and create giant unions that TS can't handle
+type WillRecurseIndefinitely<T> = unknown extends T
+	? true
+	: RemoteFormInput extends T
+		? true
+		: false;
+
+// Helper type to convert union to intersection
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+	? I
+	: never;
+
+type FlattenInput<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: string }
+		: T extends Array<infer U>
+			? U extends string | File
+				? { [P in Prefix]: string[] }
+				: FlattenInput<U, `${Prefix}[${number}]`>
+			: T extends File
+				? { [P in Prefix]: string }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenInput<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: string };
+
+type FlattenIssues<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: RemoteFormIssue[] }
+		: T extends Array<infer U>
+			? { [P in Prefix | `${Prefix}[${number}]`]: RemoteFormIssue[] } & FlattenIssues<
+					U,
+					`${Prefix}[${number}]`
+				>
+			: T extends File
+				? { [P in Prefix]: RemoteFormIssue[] }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenIssues<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: RemoteFormIssue[] };
+
+type FlattenKeys<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: string }
+		: T extends Array<infer U>
+			? U extends string | File
+				? { [P in `${Prefix}[]`]: string[] }
+				: FlattenKeys<U, `${Prefix}[${number}]`>
+			: T extends File
+				? { [P in Prefix]: string }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenKeys<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: string };
+
+export interface RemoteFormInput {
+	[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+}
+
+export interface RemoteFormIssue {
+	name: string;
+	path: Array<string | number>;
+	message: string;
+}
+
 /**
  * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  */
-export type RemoteForm<Result> = {
+export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+	/** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */
+	[attachment: symbol]: (node: HTMLFormElement) => void;
 	method: 'POST';
 	/** The URL to send the form to. */
 	action: string;
-	/** Event handler that intercepts the form submission on the client to prevent a full page reload */
-	onsubmit: (event: SubmitEvent) => void;
 	/** Use the `enhance` method to influence what happens when the form is submitted. */
 	enhance(
 		callback: (opts: {
 			form: HTMLFormElement;
-			data: FormData;
+			data: Input;
 			submit: () => Promise<void> & {
 				updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 			};
-		}) => void
+		}) => void | Promise<void>
 	): {
 		method: 'POST';
 		action: string;
-		onsubmit: (event: SubmitEvent) => void;
+		[attachment: symbol]: (node: HTMLFormElement) => void;
 	};
 	/**
 	 * Create an instance of the form for the given key.
@@ -1743,11 +1820,27 @@ export type RemoteForm<Result> = {
 	 *	{/each}
 	 * ```
 	 */
-	for(key: string | number | boolean): Omit<RemoteForm<Result>, 'for'>;
+	for(key: string | number | boolean): Omit<RemoteForm<Input, Output>, 'for'>;
+	/**
+	 * This method exists to allow you to typecheck `name` attributes. It returns its argument
+	 * @example
+	 * ```svelte
+	 * <input name={login.field('username')} />
+	 * ```
+	 **/
+	field<Name extends keyof UnionToIntersection<FlattenKeys<Input, ''>>>(string: Name): Name;
+	/** Preflight checks */
+	preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
+	/** Validate the form contents programmatically */
+	validate(options?: { includeUntouched?: boolean }): Promise<void>;
 	/** The result of the form submission */
-	get result(): Result | undefined;
+	get result(): Output | undefined;
 	/** The number of pending submissions */
 	get pending(): number;
+	/** The submitted values */
+	input: null | UnionToIntersection<FlattenInput<Input, ''>>;
+	/** Validation issues */
+	issues: null | UnionToIntersection<FlattenIssues<Input, ''>>;
 	/** Spread this onto a `<button>` or `<input type="submit">` */
 	buttonProps: {
 		type: 'submit';
@@ -1758,11 +1851,11 @@ export type RemoteForm<Result> = {
 		enhance(
 			callback: (opts: {
 				form: HTMLFormElement;
-				data: FormData;
+				data: Input;
 				submit: () => Promise<void> & {
 					updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 				};
-			}) => void
+			}) => void | Promise<void>
 		): {
 			type: 'submit';
 			formmethod: 'POST';
diff --git a/packages/kit/src/runtime/app/server/remote/form.js b/packages/kit/src/runtime/app/server/remote/form.js
index e4e157eb68e1..01e2c893df76 100644
--- a/packages/kit/src/runtime/app/server/remote/form.js
+++ b/packages/kit/src/runtime/app/server/remote/form.js
@@ -1,34 +1,77 @@
-/** @import { RemoteForm } from '@sveltejs/kit' */
-/** @import { RemoteInfo, MaybePromise } from 'types' */
+/** @import { RemoteFormInput, RemoteForm } from '@sveltejs/kit' */
+/** @import { MaybePromise, RemoteInfo } from 'types' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
+import { DEV } from 'esm-env';
 import { run_remote_function } from './shared.js';
+import { convert_formdata, flatten_issues } from '../../../utils.js';
 
 /**
  * Creates a form object that can be spread onto a `<form>` element.
  *
  * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  *
- * @template T
- * @param {(data: FormData) => MaybePromise<T>} fn
- * @returns {RemoteForm<T>}
+ * @template Output
+ * @overload
+ * @param {() => Output} fn
+ * @returns {RemoteForm<void, Output>}
+ * @since 2.27
+ */
+/**
+ * Creates a form object that can be spread onto a `<form>` element.
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+ *
+ * @template {RemoteFormInput} Input
+ * @template Output
+ * @overload
+ * @param {'unchecked'} validate
+ * @param {(data: Input) => MaybePromise<Output>} fn
+ * @returns {RemoteForm<Input, Output>}
+ * @since 2.27
+ */
+/**
+ * Creates a form object that can be spread onto a `<form>` element.
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+ *
+ * @template {StandardSchemaV1<RemoteFormInput, Record<string, any>>} Schema
+ * @template Output
+ * @overload
+ * @param {Schema} validate
+ * @param {(data: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
+ * @returns {RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>}
+ * @since 2.27
+ */
+/**
+ * @template {RemoteFormInput} Input
+ * @template Output
+ * @param {any} validate_or_fn
+ * @param {(data?: Input) => MaybePromise<Output>} [maybe_fn]
+ * @returns {RemoteForm<Input, Output>}
  * @since 2.27
  */
 /*@__NO_SIDE_EFFECTS__*/
 // @ts-ignore we don't want to prefix `fn` with an underscore, as that will be user-visible
-export function form(fn) {
+export function form(validate_or_fn, maybe_fn) {
+	/** @type {(data?: Input) => Output} */
+	const fn = maybe_fn ?? validate_or_fn;
+
+	/** @type {StandardSchemaV1 | null} */
+	const schema = !maybe_fn || validate_or_fn === 'unchecked' ? null : validate_or_fn;
+
 	/**
 	 * @param {string | number | boolean} [key]
 	 */
 	function create_instance(key) {
-		/** @type {RemoteForm<T>} */
+		/** @type {RemoteForm<Input, Output>} */
 		const instance = {};
 
 		instance.method = 'POST';
-		instance.onsubmit = () => {};
 
 		Object.defineProperty(instance, 'enhance', {
 			value: () => {
-				return { action: instance.action, method: instance.method, onsubmit: instance.onsubmit };
+				return { action: instance.action, method: instance.method };
 			}
 		});
 
@@ -54,19 +97,79 @@ export function form(fn) {
 			id: '',
 			/** @param {FormData} form_data */
 			fn: async (form_data) => {
+				const validate_only = form_data.get('sveltekit:validate_only') === 'true';
+				form_data.delete('sveltekit:validate_only');
+
+				let data = maybe_fn ? convert_formdata(form_data) : undefined;
+
+				// TODO 3.0 remove this warning
+				if (DEV && !data) {
+					const error = () => {
+						throw new Error(
+							'Remote form functions no longer get passed a FormData object. ' +
+								"`form` now has the same signature as `query` or `command`, i.e. it expects to be invoked like `form(schema, callback)` or `form('unchecked', callback)`. " +
+								'The payload of the callback function is now a POJO instead of a FormData object. See https://kit.svelte.dev/docs/remote-functions#form for details.'
+						);
+					};
+					data = {};
+					for (const key of [
+						'append',
+						'delete',
+						'entries',
+						'forEach',
+						'get',
+						'getAll',
+						'has',
+						'keys',
+						'set',
+						'values'
+					]) {
+						Object.defineProperty(data, key, { get: error });
+					}
+				}
+
+				/** @type {{ input?: Record<string, string | string[]>, issues?: Record<string, StandardSchemaV1.Issue[]>, result: Output }} */
+				const output = {};
+
 				const { event, state } = get_request_store();
+				const validated = await schema?.['~standard'].validate(data);
+
+				if (validate_only) {
+					return validated?.issues ?? [];
+				}
+
+				if (validated?.issues !== undefined) {
+					output.issues = flatten_issues(validated.issues);
+					output.input = {};
+
+					for (let key of form_data.keys()) {
+						// redact sensitive fields
+						if (/^[.\]]?_/.test(key)) continue;
+
+						const is_array = key.endsWith('[]');
+						const values = form_data.getAll(key).filter((value) => typeof value === 'string');
 
-				state.refreshes ??= {};
+						if (is_array) key = key.slice(0, -2);
 
-				const result = await run_remote_function(event, state, true, form_data, (d) => d, fn);
+						output.input[key] = is_array ? values : values[0];
+					}
+				} else {
+					if (validated !== undefined) {
+						data = validated.value;
+					}
+
+					state.refreshes ??= {};
+
+					output.result = await run_remote_function(event, state, true, data, (d) => d, fn);
+				}
 
 				// We don't need to care about args or deduplicating calls, because uneval results are only relevant in full page reloads
 				// where only one form submission is active at the same time
 				if (!event.isRemoteRequest) {
-					(state.remote_data ??= {})[__.id] = result;
+					(state.remote_data ??= {})[__.id] = output;
 				}
 
-				return result;
+				return output;
 			}
 		};
 
@@ -82,11 +185,24 @@ export function form(fn) {
 			enumerable: true
 		});
 
+		for (const property of ['input', 'issues']) {
+			Object.defineProperty(instance, property, {
+				get() {
+					try {
+						const { remote_data } = get_request_store().state;
+						return remote_data?.[__.id]?.[property] ?? {};
+					} catch {
+						return undefined;
+					}
+				}
+			});
+		}
+
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
 					const { remote_data } = get_request_store().state;
-					return remote_data?.[__.id];
+					return remote_data?.[__.id]?.result;
 				} catch {
 					return undefined;
 				}
@@ -103,9 +219,24 @@ export function form(fn) {
 			get: () => 0
 		});
 
+		Object.defineProperty(instance, 'field', {
+			value: (/** @type {string} */ name) => name
+		});
+
+		Object.defineProperty(instance, 'preflight', {
+			// preflight is a noop on the server
+			value: () => instance
+		});
+
+		Object.defineProperty(instance, 'validate', {
+			value: () => {
+				throw new Error('Cannot call validate() on the server');
+			}
+		});
+
 		if (key == undefined) {
 			Object.defineProperty(instance, 'for', {
-				/** @type {RemoteForm<any>['for']} */
+				/** @type {RemoteForm<any, any>['for']} */
 				value: (key) => {
 					const { state } = get_request_store();
 					const cache_key = __.id + '|' + JSON.stringify(key);
diff --git a/packages/kit/src/runtime/client/remote-functions/form.svelte.js b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
index 3921ebc8efd3..6b4b8433469d 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -1,4 +1,5 @@
-/** @import { RemoteForm, RemoteQueryOverride } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { RemoteFormInput, RemoteForm, RemoteQueryOverride } from '@sveltejs/kit' */
 /** @import { RemoteFunctionResponse } from 'types' */
 /** @import { Query } from './query.svelte.js' */
 import { app_dir, base } from '__sveltekit/paths';
@@ -15,15 +16,18 @@ import {
 } from '../client.js';
 import { tick } from 'svelte';
 import { refresh_queries, release_overrides } from './shared.svelte.js';
+import { createAttachmentKey } from 'svelte/attachments';
+import { convert_formdata, file_transport, flatten_issues } from '../../utils.js';
 
 /**
  * Client-version of the `form` function from `$app/server`.
- * @template T
+ * @template {RemoteFormInput} T
+ * @template U
  * @param {string} id
- * @returns {RemoteForm<T>}
+ * @returns {RemoteForm<T, U>}
  */
 export function form(id) {
-	/** @type {Map<any, { count: number, instance: RemoteForm<T> }>} */
+	/** @type {Map<any, { count: number, instance: RemoteForm<T, U> }>} */
 	const instances = new Map();
 
 	/** @param {string | number | boolean} [key] */
@@ -31,12 +35,80 @@ export function form(id) {
 		const action_id = id + (key != undefined ? `/${JSON.stringify(key)}` : '');
 		const action = '?/remote=' + encodeURIComponent(action_id);
 
+		/** @type {Record<string, string | string[] | File | File[]>} */
+		let input = $state({});
+
+		/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+		let issues = $state.raw({});
+
 		/** @type {any} */
 		let result = $state.raw(started ? undefined : remote_responses[action_id]);
 
 		/** @type {number} */
 		let pending_count = $state(0);
 
+		/** @type {StandardSchemaV1 | undefined} */
+		let preflight_schema = undefined;
+
+		/** @type {HTMLFormElement | null} */
+		let element = null;
+
+		/** @type {Record<string, boolean>} */
+		let touched = {};
+
+		/**
+		 * @param {HTMLFormElement} form
+		 * @param {FormData} form_data
+		 * @param {Parameters<RemoteForm<any, any>['enhance']>[0]} callback
+		 */
+		async function handle_submit(form, form_data, callback) {
+			const data = convert_formdata(form_data);
+
+			const validated = await preflight_schema?.['~standard'].validate(data);
+
+			if (validated?.issues) {
+				issues = flatten_issues(validated.issues);
+				return;
+			}
+
+			// TODO 3.0 remove this warning
+			if (DEV) {
+				const error = () => {
+					throw new Error(
+						'Remote form functions no longer get passed a FormData object. The payload is now a POJO. See https://kit.svelte.dev/docs/remote-functions#form for details.'
+					);
+				};
+				for (const key of [
+					'append',
+					'delete',
+					'entries',
+					'forEach',
+					'get',
+					'getAll',
+					'has',
+					'keys',
+					'set',
+					'values'
+				]) {
+					if (!(key in data)) {
+						Object.defineProperty(data, key, { get: error });
+					}
+				}
+			}
+
+			try {
+				await callback({
+					form,
+					data,
+					submit: () => submit(form_data)
+				});
+			} catch (e) {
+				const error = e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
+				const status = e instanceof HttpError ? e.status : 500;
+				void set_nearest_error_page(error, status);
+			}
+		}
+
 		/**
 		 * @param {FormData} data
 		 * @returns {Promise<any> & { updates: (...args: any[]) => any }}
@@ -64,13 +136,6 @@ export function form(id) {
 					await Promise.resolve();
 
 					if (updates.length > 0) {
-						if (DEV) {
-							if (data.get('sveltekit:remote_refreshes')) {
-								throw new Error(
-									'The FormData key `sveltekit:remote_refreshes` is reserved for internal use and should not be set manually'
-								);
-							}
-						}
 						data.set('sveltekit:remote_refreshes', JSON.stringify(updates.map((u) => u._key)));
 					}
 
@@ -88,9 +153,18 @@ export function form(id) {
 					const form_result = /** @type { RemoteFunctionResponse} */ (await response.json());
 
 					if (form_result.type === 'result') {
-						result = devalue.parse(form_result.result, app.decoders);
-
-						if (form_result.refreshes) {
+						({
+							input = {},
+							issues = {},
+							result
+						} = devalue.parse(form_result.result, {
+							...app.decoders,
+							File: file_transport.decode
+						}));
+
+						if (issues.$) {
+							release_overrides(updates);
+						} else if (form_result.refreshes) {
 							refresh_queries(form_result.refreshes, updates);
 						} else {
 							void invalidateAll();
@@ -104,7 +178,6 @@ export function form(id) {
 						// Use internal version to allow redirects to external URLs
 						void _goto(form_result.location, { invalidateAll }, 0);
 					} else {
-						result = undefined;
 						throw new HttpError(form_result.status ?? 500, form_result.error);
 					}
 				} catch (e) {
@@ -134,43 +207,13 @@ export function form(id) {
 			return promise;
 		}
 
-		/** @type {RemoteForm<T>} */
+		/** @type {RemoteForm<T, U>} */
 		const instance = {};
 
 		instance.method = 'POST';
 		instance.action = action;
 
-		/**
-		 * @param {HTMLFormElement} form_element
-		 * @param {HTMLElement | null} submitter
-		 */
-		function create_form_data(form_element, submitter) {
-			const form_data = new FormData(form_element);
-
-			if (DEV) {
-				const enctype = submitter?.hasAttribute('formenctype')
-					? /** @type {HTMLButtonElement | HTMLInputElement} */ (submitter).formEnctype
-					: clone(form_element).enctype;
-				if (enctype !== 'multipart/form-data') {
-					for (const value of form_data.values()) {
-						if (value instanceof File) {
-							throw new Error(
-								'Your form contains <input type="file"> fields, but is missing the necessary `enctype="multipart/form-data"` attribute. This will lead to inconsistent behavior between enhanced and native forms. For more details, see https://github.com/sveltejs/kit/issues/9819.'
-							);
-						}
-					}
-				}
-			}
-
-			const submitter_name = submitter?.getAttribute('name');
-			if (submitter_name) {
-				form_data.append(submitter_name, submitter?.getAttribute('value') ?? '');
-			}
-
-			return form_data;
-		}
-
-		/** @param {Parameters<RemoteForm<any>['enhance']>[0]} callback */
+		/** @param {Parameters<RemoteForm<any, any>['enhance']>[0]} callback */
 		const form_onsubmit = (callback) => {
 			/** @param {SubmitEvent} event */
 			return async (event) => {
@@ -194,26 +237,105 @@ export function form(id) {
 
 				event.preventDefault();
 
-				const data = create_form_data(form, event.submitter);
+				const form_data = new FormData(form);
 
-				try {
-					await callback({
-						form,
-						data,
-						submit: () => submit(data)
-					});
-				} catch (e) {
-					const error =
-						e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+				if (DEV) {
+					validate_form_data(form_data, clone(form).enctype);
 				}
+
+				await handle_submit(form, form_data, callback);
 			};
 		};
 
-		instance.onsubmit = form_onsubmit(({ submit, form }) => submit().then(() => form.reset()));
+		/** @param {(event: SubmitEvent) => void} onsubmit */
+		function create_attachment(onsubmit) {
+			return (/** @type {HTMLFormElement} */ form) => {
+				if (element) {
+					let message = `A form object can only be attached to a single \`<form>\` element`;
+					if (DEV && !key) {
+						const name = id.split('/').pop();
+						message += `. To create multiple instances, use \`${name}.for(key)\``;
+					}
+
+					throw new Error(message);
+				}
+
+				element = form;
+
+				touched = {};
+
+				form.addEventListener('submit', onsubmit);
+
+				form.addEventListener('input', (e) => {
+					// strictly speaking it can be an HTMLTextAreaElement or HTMLSelectElement
+					// but that makes the types unnecessarily awkward
+					const element = /** @type {HTMLInputElement} */ (e.target);
+
+					let name = element.name;
+					if (!name) return;
+
+					const is_array = name.endsWith('[]');
+					if (is_array) name = name.slice(0, -2);
+
+					const is_file = element.type === 'file';
+
+					touched[name] = true;
+
+					if (is_array) {
+						const elements = /** @type {HTMLInputElement[]} */ (
+							Array.from(form.querySelectorAll(`[name="${name}[]"]`))
+						);
+
+						if (DEV) {
+							for (const e of elements) {
+								if ((e.type === 'file') !== is_file) {
+									throw new Error(
+										`Cannot mix and match file and non-file inputs under the same name ("${element.name}")`
+									);
+								}
+							}
+						}
+
+						input[name] = is_file
+							? elements.map((input) => Array.from(input.files ?? [])).flat()
+							: elements.map((element) => element.value);
+					} else if (is_file) {
+						if (DEV && element.multiple) {
+							throw new Error(
+								`Can only use the \`multiple\` attribute when \`name\` includes a \`[]\` suffix — consider changing "${name}" to "${name}[]"`
+							);
+						}
+
+						const file = /** @type {HTMLInputElement & { files: FileList }} */ (element).files[0];
 
-		/** @param {Parameters<RemoteForm<any>['buttonProps']['enhance']>[0]} callback */
+						if (file) {
+							input[name] = file;
+						} else {
+							delete input[name];
+						}
+					} else {
+						input[name] = element.value;
+					}
+				});
+
+				return () => {
+					element = null;
+					preflight_schema = undefined;
+				};
+			};
+		}
+
+		instance[createAttachmentKey()] = create_attachment(
+			form_onsubmit(({ submit, form }) =>
+				submit().then(() => {
+					if (!issues.$) {
+						form.reset();
+					}
+				})
+			)
+		);
+
+		/** @param {Parameters<RemoteForm<any, any>['buttonProps']['enhance']>[0]} callback */
 		const form_action_onclick = (callback) => {
 			/** @param {Event} event */
 			return async (event) => {
@@ -225,34 +347,41 @@ export function form(id) {
 				event.stopPropagation();
 				event.preventDefault();
 
-				const data = create_form_data(form, target);
+				const form_data = new FormData(form);
 
-				try {
-					await callback({
-						form,
-						data,
-						submit: () => submit(data)
-					});
-				} catch (e) {
-					const error =
-						e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+				if (DEV) {
+					const enctype = target.hasAttribute('formenctype')
+						? target.formEnctype
+						: clone(form).enctype;
+
+					validate_form_data(form_data, enctype);
 				}
+
+				if (target.name) {
+					form_data.append(target.name, target?.getAttribute('value') ?? '');
+				}
+
+				await handle_submit(form, form_data, callback);
 			};
 		};
 
-		/** @type {RemoteForm<any>['buttonProps']} */
+		/** @type {RemoteForm<any, any>['buttonProps']} */
 		// @ts-expect-error we gotta set enhance as a non-enumerable property
 		const button_props = {
 			type: 'submit',
 			formmethod: 'POST',
 			formaction: action,
-			onclick: form_action_onclick(({ submit, form }) => submit().then(() => form.reset()))
+			onclick: form_action_onclick(({ submit, form }) =>
+				submit().then(() => {
+					if (!issues.$) {
+						form.reset();
+					}
+				})
+			)
 		};
 
 		Object.defineProperty(button_props, 'enhance', {
-			/** @type {RemoteForm<any>['buttonProps']['enhance']} */
+			/** @type {RemoteForm<any, any>['buttonProps']['enhance']} */
 			value: (callback) => {
 				return {
 					type: 'submit',
@@ -267,23 +396,106 @@ export function form(id) {
 			get: () => pending_count
 		});
 
+		let validate_id = 0;
+
 		Object.defineProperties(instance, {
 			buttonProps: {
 				value: button_props
 			},
+			input: {
+				get: () => input,
+				set: (v) => {
+					input = v;
+				}
+			},
+			issues: {
+				get: () => issues
+			},
 			result: {
 				get: () => result
 			},
 			pending: {
 				get: () => pending_count
 			},
+			field: {
+				value: (/** @type {string} */ name) => name
+			},
+			preflight: {
+				/** @type {RemoteForm<any, any>['preflight']} */
+				value: (schema) => {
+					preflight_schema = schema;
+					return instance;
+				}
+			},
+			validate: {
+				/** @type {RemoteForm<any, any>['validate']} */
+				value: async ({ includeUntouched = false } = {}) => {
+					if (!element) return;
+
+					const id = ++validate_id;
+
+					const form_data = new FormData(element);
+
+					/** @type {readonly StandardSchemaV1.Issue[]} */
+					let array = [];
+
+					const validated = await preflight_schema?.['~standard'].validate(
+						convert_formdata(form_data)
+					);
+
+					if (validated?.issues) {
+						array = validated.issues;
+					} else {
+						form_data.set('sveltekit:validate_only', 'true');
+
+						const response = await fetch(`${base}/${app_dir}/remote/${action_id}`, {
+							method: 'POST',
+							body: form_data
+						});
+
+						const result = await response.json();
+
+						if (validate_id !== id) {
+							return;
+						}
+
+						if (result.type === 'result') {
+							array = /** @type {StandardSchemaV1.Issue[]} */ (
+								devalue.parse(result.result, app.decoders)
+							);
+						}
+					}
+
+					if (!includeUntouched) {
+						array = array.filter((issue) => {
+							if (issue.path !== undefined) {
+								let path = '';
+
+								for (const segment of issue.path) {
+									const key = typeof segment === 'object' ? segment.key : segment;
+
+									if (typeof key === 'number') {
+										path += `[${key}]`;
+									} else if (typeof key === 'string') {
+										path += path === '' ? key : '.' + key;
+									}
+								}
+
+								return touched[path];
+							}
+						});
+					}
+
+					issues = flatten_issues(array);
+				}
+			},
 			enhance: {
-				/** @type {RemoteForm<any>['enhance']} */
+				/** @type {RemoteForm<any, any>['enhance']} */
 				value: (callback) => {
 					return {
 						method: 'POST',
 						action,
-						onsubmit: form_onsubmit(callback)
+						[createAttachmentKey()]: create_attachment(form_onsubmit(callback))
 					};
 				}
 			}
@@ -295,7 +507,7 @@ export function form(id) {
 	const instance = create_instance();
 
 	Object.defineProperty(instance, 'for', {
-		/** @type {RemoteForm<any>['for']} */
+		/** @type {RemoteForm<T, U>['for']} */
 		value: (key) => {
 			const entry = instances.get(key) ?? { count: 0, instance: create_instance(key) };
 
@@ -335,3 +547,33 @@ export function form(id) {
 function clone(element) {
 	return /** @type {T} */ (HTMLElement.prototype.cloneNode.call(element));
 }
+
+/**
+ * @param {FormData} form_data
+ * @param {string} enctype
+ */
+function validate_form_data(form_data, enctype) {
+	for (const key of form_data.keys()) {
+		if (key.startsWith('sveltekit:')) {
+			throw new Error(
+				'FormData keys starting with `sveltekit:` are reserved for internal use and should not be set manually'
+			);
+		}
+
+		if (/^\$[.[]?/.test(key)) {
+			throw new Error(
+				'`$` is used to collect all FormData validation issues and cannot be used as the `name` of a form control'
+			);
+		}
+	}
+
+	if (enctype !== 'multipart/form-data') {
+		for (const value of form_data.values()) {
+			if (value instanceof File) {
+				throw new Error(
+					'Your form contains <input type="file"> fields, but is missing the necessary `enctype="multipart/form-data"` attribute. This will lead to inconsistent behavior between enhanced and native forms. For more details, see https://github.com/sveltejs/kit/issues/9819.'
+				);
+			}
+		}
+	}
+}
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 9f3afd08a134..8894c7304eeb 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -12,6 +12,7 @@ import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
+import { file_transport } from '../utils.js';
 
 /** @type {typeof handle_remote_call_internal} */
 export async function handle_remote_call(event, state, options, manifest, id) {
@@ -128,8 +129,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
-					result: stringify(data, transport),
-					refreshes: await serialize_refreshes(form_client_refreshes)
+					result: stringify(data, { ...transport, File: file_transport }),
+					refreshes: data.issues ? {} : await serialize_refreshes(form_client_refreshes)
 				})
 			);
 		}
@@ -260,7 +261,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 	const remotes = manifest._.remotes;
 	const module = await remotes[hash]?.();
 
-	let form = /** @type {RemoteForm<any>} */ (module?.default[name]);
+	let form = /** @type {RemoteForm<any, any>} */ (module?.default[name]);
 
 	if (!form) {
 		event.setHeaders({
diff --git a/packages/kit/src/runtime/utils.js b/packages/kit/src/runtime/utils.js
index b6e3103ff1ee..b300270bf172 100644
--- a/packages/kit/src/runtime/utils.js
+++ b/packages/kit/src/runtime/utils.js
@@ -1,3 +1,5 @@
+/** @import { RemoteFormIssue } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
@@ -63,3 +65,123 @@ export function base64_decode(encoded) {
 
 	return bytes;
 }
+
+/**
+ * Convert `FormData` into a POJO
+ * @param {FormData} data
+ */
+export function convert_formdata(data) {
+	/** @type {Record<string, any>} */
+	const result = Object.create(null); // guard against prototype pollution
+
+	for (let key of data.keys()) {
+		const is_array = key.endsWith('[]');
+		let values = data.getAll(key);
+
+		if (is_array) key = key.slice(0, -2);
+
+		if (values.length > 1 && !is_array) {
+			throw new Error(`Form cannot contain duplicated keys — "${key}" has ${values.length} values`);
+		}
+
+		// an empty `<input type="file">` will submit a non-existent file, bizarrely
+		values = values.filter(
+			(entry) => typeof entry === 'string' || entry.name !== '' || entry.size > 0
+		);
+
+		deep_set(result, split_path(key), is_array ? values : values[0]);
+	}
+
+	return result;
+}
+
+const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
+
+/**
+ * @param {string} path
+ */
+export function split_path(path) {
+	if (!path_regex.test(path)) {
+		throw new Error(`Invalid path ${path}`);
+	}
+
+	return path.split(/\.|\[|\]/).filter(Boolean);
+}
+
+/**
+ * @param {Record<string, any>} object
+ * @param {string[]} keys
+ * @param {any} value
+ */
+export function deep_set(object, keys, value) {
+	for (let i = 0; i < keys.length - 1; i += 1) {
+		const key = keys[i];
+		const is_array = /^\d+$/.test(keys[i + 1]);
+
+		if (object[key]) {
+			if (is_array !== Array.isArray(object[key])) {
+				throw new Error(`Invalid array key ${keys[i + 1]}`);
+			}
+		} else {
+			object = object[key] ??= is_array ? [] : Object.create(null); // guard against prototype pollution
+		}
+	}
+
+	object[keys[keys.length - 1]] = value;
+}
+
+/**
+ * @param {readonly StandardSchemaV1.Issue[]} issues
+ */
+export function flatten_issues(issues) {
+	/** @type {Record<string, RemoteFormIssue[]>} */
+	const result = {};
+
+	for (const issue of issues) {
+		/** @type {RemoteFormIssue} */
+		const normalized = { name: '', path: [], message: issue.message };
+
+		(result.$ ??= []).push(normalized);
+
+		let name = '';
+
+		if (issue.path !== undefined) {
+			for (const segment of issue.path) {
+				const key = /** @type {string | number} */ (
+					typeof segment === 'object' ? segment.key : segment
+				);
+
+				normalized.path.push(key);
+
+				if (typeof key === 'number') {
+					name += `[${key}]`;
+				} else if (typeof key === 'string') {
+					name += name === '' ? key : '.' + key;
+				}
+
+				(result[name] ??= []).push(normalized);
+			}
+
+			normalized.name = name;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * We need to encode `File` objects when returning `issues` from a `form` submission,
+ * because some validators include the original value in the issue. It doesn't
+ * need to deserialize to a `File` object
+ * @type {import('@sveltejs/kit').Transporter}
+ */
+export const file_transport = {
+	encode: (file) =>
+		file instanceof File && {
+			size: file.size,
+			type: file.type,
+			name: file.name,
+			lastModified: file.lastModified
+		},
+	decode: (data) => data
+};
diff --git a/packages/kit/src/runtime/utils.spec.js b/packages/kit/src/runtime/utils.spec.js
index 673ba0b0bb33..7d52180f1efd 100644
--- a/packages/kit/src/runtime/utils.spec.js
+++ b/packages/kit/src/runtime/utils.spec.js
@@ -1,5 +1,11 @@
 import { afterEach, assert, beforeEach, describe, expect, test } from 'vitest';
-import { base64_decode, base64_encode, text_encoder } from './utils.js';
+import {
+	base64_decode,
+	base64_encode,
+	convert_formdata,
+	split_path,
+	text_encoder
+} from './utils.js';
 
 const inputs = [
 	'hello world',
@@ -10,15 +16,17 @@ const inputs = [
 ];
 
 const buffer = globalThis.Buffer;
-beforeEach(() => {
-	// @ts-expect-error
-	delete globalThis.Buffer;
-});
-afterEach(() => {
-	globalThis.Buffer = buffer;
-});
 
 describe('base64_encode', () => {
+	beforeEach(() => {
+		// @ts-expect-error
+		delete globalThis.Buffer;
+	});
+
+	afterEach(() => {
+		globalThis.Buffer = buffer;
+	});
+
 	test.each(inputs)('%s', (input) => {
 		const expected = buffer.from(input).toString('base64');
 
@@ -28,6 +36,15 @@ describe('base64_encode', () => {
 });
 
 describe('base64_decode', () => {
+	beforeEach(() => {
+		// @ts-expect-error
+		delete globalThis.Buffer;
+	});
+
+	afterEach(() => {
+		globalThis.Buffer = buffer;
+	});
+
 	test.each(inputs)('%s', (input) => {
 		const encoded = buffer.from(input).toString('base64');
 
@@ -35,3 +52,59 @@ describe('base64_decode', () => {
 		expect(actual).toEqual(text_encoder.encode(input));
 	});
 });
+
+describe('split_path', () => {
+	const good = [
+		{
+			input: 'foo',
+			output: ['foo']
+		},
+		{
+			input: 'foo.bar.baz',
+			output: ['foo', 'bar', 'baz']
+		},
+		{
+			input: 'foo[0][1][2]',
+			output: ['foo', '0', '1', '2']
+		}
+	];
+
+	const bad = ['[0]', 'foo.0', 'foo[bar]'];
+
+	for (const { input, output } of good) {
+		test(input, () => {
+			expect(split_path(input)).toEqual(output);
+		});
+	}
+
+	for (const input of bad) {
+		test(input, () => {
+			expect(() => split_path(input)).toThrowError(`Invalid path ${input}`);
+		});
+	}
+});
+
+describe('convert_formdata', () => {
+	test('converts a FormData object', () => {
+		const data = new FormData();
+
+		data.append('foo', 'foo');
+
+		data.append('object.nested.property', 'property');
+		data.append('array[]', 'a');
+		data.append('array[]', 'b');
+		data.append('array[]', 'c');
+
+		const converted = convert_formdata(data);
+
+		expect(converted).toEqual({
+			foo: 'foo',
+			object: {
+				nested: {
+					property: 'property'
+				}
+			},
+			array: ['a', 'b', 'c']
+		});
+	});
+});
diff --git a/packages/kit/test/apps/basics/package.json b/packages/kit/test/apps/basics/package.json
index 7fa8ed647acb..45ad006f0224 100644
--- a/packages/kit/test/apps/basics/package.json
+++ b/packages/kit/test/apps/basics/package.json
@@ -28,6 +28,7 @@
 		"svelte-check": "^4.1.1",
 		"test-redirect-importer": "workspace:*",
 		"typescript": "^5.5.4",
+		"valibot": "^1.1.0",
 		"vite": "catalog:",
 		"vitest": "catalog:"
 	},
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/+page.svelte
index 2dc7bfb6fe7d..c285274438ab 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/+page.svelte
@@ -1,93 +1,78 @@
 <script>
-	import { get_task, task_one, task_two, resolve_deferreds } from './form.remote.js';
-	const current_task = get_task();
+	import {
+		get_message,
+		set_message,
+		resolve_deferreds,
+		set_reverse_message
+	} from './form.remote.js';
+
+	const message = get_message();
+
+	const scoped = set_message.for('scoped');
+	const enhanced = set_message.for('enhanced');
 </script>
 
+<p>message.current: {message.current}</p>
+
 <!-- TODO use await here once async lands -->
-<p id="get-task">{#await current_task then task}{task}{/await}</p>
+{#await message then m}
+	<p>await get_message(): {m}</p>
+{/await}
 
-<!-- Test pending state for forms -->
-<p id="form-pending">Form pending: {task_one.pending}</p>
-<p id="form-button-pending">Button pending: {task_two.buttonProps.pending}</p>
+<hr />
 
-<form {...task_one}>
-	<input id="input-task" name="task" />
-	<button id="submit-btn-one">Task One</button>
-	<button id="submit-btn-two" {...task_two.buttonProps}>Task Two</button>
-</form>
+<form data-unscoped {...set_message}>
+	{#if set_message.issues.message}
+		<p>{set_message.issues.message[0].message}</p>
+	{/if}
 
-<form
-	{...task_one.enhance(async ({ data, submit }) => {
-		const task = data.get('task');
-		if (task === 'abort') return;
-		await submit();
-	})}
->
-	<input id="input-task-enhance" name="task" />
-	<button id="submit-btn-enhance-one">Task One (enhanced)</button>
-	<button
-		id="submit-btn-enhance-two"
-		{...task_two.buttonProps.enhance(async ({ data, submit }) => {
-			const task = data.get('task');
-			if (task === 'abort') return;
-			await submit();
-		})}>Task Two (enhanced)</button
-	>
+	<input name={set_message.field('message')} value={set_message.input.message} />
+	<button>set message</button>
+	<button {...set_reverse_message.buttonProps}>set reverse message</button>
 </form>
 
-<form
-	{...task_one.enhance(async ({ data, submit }) => {
-		const task = data.get('task');
-		await submit().updates(current_task.withOverride(() => task + ' (overridden)'));
-	})}
->
-	<input id="input-task-override" name="task" />
-	<button id="submit-btn-override-one">Task One (with override)</button>
-	<button
-		id="submit-btn-override-two"
-		{...task_two.buttonProps.enhance(async ({ data, submit }) => {
-			const task = data.get('task');
-			await submit().updates(current_task.withOverride(() => task + ' (overridden)'));
-		})}>Task Two (with override)</button
-	>
+<p>set_message.input.message: {set_message.input.message}</p>
+<p>set_message.pending: {set_message.pending}</p>
+<p>set_message.result: {set_message.result}</p>
+<p>set_reverse_message.result: {set_reverse_message.result}</p>
+
+<hr />
+
+<form data-scoped {...scoped}>
+	{#if scoped.issues.message}
+		<p>{scoped.issues.message[0].message}</p>
+	{/if}
+
+	<input name={scoped.field('message')} value={scoped.input.message} />
+	<button>set scoped message</button>
 </form>
 
-<!-- Test case for button with nested elements (issue #14159) -->
+<p>scoped.input.message: {scoped.input.message}</p>
+<p>scoped.pending: {scoped.pending}</p>
+<p>scoped.result: {scoped.result}</p>
+
+<hr />
+
 <form
-	{...task_one.enhance(async ({ data, submit }) => {
-		const task = data.get('task');
-		await submit();
+	data-enhanced
+	{...enhanced.enhance(async ({ data, submit }) => {
+		await submit().updates(get_message().withOverride(() => data.message + ' (override)'));
 	})}
 >
-	<input id="input-task-nested" name="task" />
-	<button
-		id="submit-btn-nested-span"
-		{...task_two.buttonProps.enhance(async ({ data, submit }) => {
-			const task = data.get('task');
-			await submit();
-		})}
-	>
-		<span>Task Two (nested span)</span>
-	</button>
+	{#if enhanced.issues.message}
+		<p>{enhanced.issues.message[0].message}</p>
+	{/if}
+
+	<input name={enhanced.field('message')} value={enhanced.input.message} />
+	<button><span>set enhanced message</span></button>
 </form>
 
-<p id="form-result-1">{task_one.result}</p>
-<p id="form-result-2">{task_two.result}</p>
+<p>enhanced.input.message: {enhanced.input.message}</p>
+<p>enhanced.pending: {enhanced.pending}</p>
+<p>enhanced.result: {enhanced.result}</p>
 
-<form {...resolve_deferreds}>
-	<button id="resolve-deferreds" type="submit">Resolve Deferreds</button>
-</form>
+<hr />
 
-{#each ['foo', 'bar'] as item}
-	<form {...task_one.for(item)}>
-		<span id="form-result-{item}">{task_one.for(item).result}</span>
-		<input name="task" value={item} />
-		<button id="submit-btn-item-{item}">Task One for {item}</button>
-	</form>
-{/each}
-
-<form {...task_two.for('foo')}>
-	<span id="form-result-2-foo">{task_two.for('foo').result}</span>
-	<input name="task" value="foo2" />
-	<button id="submit-btn-item-2-foo">Task Two for foo</button>
+<form {...resolve_deferreds}>
+	<button>resolve deferreds</button>
 </form>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.js b/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.js
deleted file mode 100644
index 6136de792054..000000000000
--- a/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.js
+++ /dev/null
@@ -1,54 +0,0 @@
-import { form, query } from '$app/server';
-import { error, redirect } from '@sveltejs/kit';
-
-let task;
-const deferreds = [];
-
-export const get_task = query(() => {
-	return task;
-});
-
-export const resolve_deferreds = form(async () => {
-	for (const deferred of deferreds) {
-		deferred.resolve();
-	}
-	deferreds.length = 0;
-	return 'resolved';
-});
-
-export const task_one = form(async (form_data) => {
-	task = /** @type {string} */ (form_data.get('task'));
-
-	if (task === 'error') {
-		error(400, { message: 'Expected error' });
-	}
-	if (task === 'redirect') {
-		redirect(303, '/remote');
-	}
-	if (task === 'deferred') {
-		const deferred = Promise.withResolvers();
-		deferreds.push(deferred);
-		await deferred.promise;
-	} else if (task === 'override') {
-		await new Promise((resolve) => setTimeout(resolve, 500));
-	}
-
-	return task;
-});
-
-export const task_two = form(async (form_data) => {
-	task = /** @type {string} */ (form_data.get('task'));
-
-	if (task === 'error') {
-		throw new Error('Unexpected error');
-	}
-	if (task === 'deferred') {
-		const deferred = Promise.withResolvers();
-		deferreds.push(deferred);
-		await deferred.promise;
-	} else if (task === 'override') {
-		await new Promise((resolve) => setTimeout(resolve, 500));
-	}
-
-	return task;
-});
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.ts
new file mode 100644
index 000000000000..fa1a82e1e76b
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/form.remote.ts
@@ -0,0 +1,54 @@
+import { form, getRequestEvent, query } from '$app/server';
+import { error, redirect } from '@sveltejs/kit';
+import * as v from 'valibot';
+
+let message = 'initial';
+const deferreds = [];
+
+export const get_message = query(() => {
+	return message;
+});
+
+export const set_message = form(
+	v.object({
+		message: v.picklist(
+			['hello', 'goodbye', 'unexpected error', 'expected error', 'redirect'],
+			'message is invalid'
+		)
+	}),
+	async (data) => {
+		if (data.message === 'unexpected error') {
+			throw new Error('oops');
+		}
+
+		if (data.message === 'expected error') {
+			error(500, 'oops');
+		}
+
+		if (data.message === 'redirect') {
+			redirect(303, '/remote');
+		}
+
+		message = data.message;
+
+		if (getRequestEvent().isRemoteRequest) {
+			const deferred = Promise.withResolvers();
+			deferreds.push(deferred);
+			await deferred.promise;
+		}
+
+		return message;
+	}
+);
+
+export const set_reverse_message = form(v.object({ message: v.string() }), (data) => {
+	message = data.message.split('').reverse().join('');
+	return message;
+});
+
+export const resolve_deferreds = form(async () => {
+	for (const deferred of deferreds) {
+		deferred.resolve();
+	}
+	deferreds.length = 0;
+});
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/preflight/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/preflight/+page.svelte
new file mode 100644
index 000000000000..d799742bd29c
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/preflight/+page.svelte
@@ -0,0 +1,59 @@
+<script>
+	import { get_number, set_number } from './form.remote.js';
+	import * as v from 'valibot';
+
+	const number = get_number();
+
+	const enhanced = set_number.for('enhanced');
+
+	const schema = v.object({
+		number: v.pipe(
+			v.string(),
+			v.regex(/^\d+$/),
+			v.transform((n) => +n),
+			v.maxValue(20, 'too big')
+		)
+	});
+</script>
+
+<p>number.current: {number.current}</p>
+
+<!-- TODO use await here once async lands -->
+{#await number then n}
+	<p>await get_number(): {n}</p>
+{/await}
+
+<hr />
+
+<form data-default {...set_number.preflight(schema)}>
+	{#if set_number.issues.number}
+		<p>{set_number.issues.number[0].message}</p>
+	{/if}
+
+	<input type="number" name={set_number.field('number')} value={set_number.input.number} />
+	<button>set number</button>
+</form>
+
+<p>set_number.input.number: {set_number.input.number}</p>
+<p>set_number.pending: {set_number.pending}</p>
+<p>set_number.result: {set_number.result}</p>
+
+<hr />
+
+<form
+	data-enhanced
+	{...enhanced.preflight(schema).enhance(async ({ submit }) => {
+		await submit();
+	})}
+>
+	{#if enhanced.issues.number}
+		<p>{enhanced.issues.number[0].message}</p>
+	{/if}
+
+	<input type="number" name={enhanced.field('number')} value={enhanced.input.number} />
+	<button><span>set enhanced number</span></button>
+</form>
+
+<p>enhanced.input.number: {enhanced.input.number}</p>
+<p>enhanced.pending: {enhanced.pending}</p>
+<p>enhanced.result: {enhanced.result}</p>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/preflight/form.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/preflight/form.remote.ts
new file mode 100644
index 000000000000..e4a1f2378587
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/preflight/form.remote.ts
@@ -0,0 +1,23 @@
+import { form, query } from '$app/server';
+import * as v from 'valibot';
+
+let number = 0;
+
+export const get_number = query(() => {
+	return number;
+});
+
+export const set_number = form(
+	v.object({
+		number: v.pipe(
+			v.string(),
+			v.regex(/^\d+$/),
+			v.transform((n) => +n),
+			v.minValue(10, 'too small')
+		)
+	}),
+	async (data) => {
+		number = data.number;
+		get_number().refresh();
+	}
+);
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/underscore/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/underscore/+page.svelte
new file mode 100644
index 000000000000..620a7d63baef
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/underscore/+page.svelte
@@ -0,0 +1,28 @@
+<script>
+	import { register } from './form.remote.js';
+</script>
+
+<form {...register}>
+	<input
+		name={register.field('username')}
+		value={register.input.username}
+		aria-invalid={!!register.issues.username}
+	/>
+
+	<input
+		type="password"
+		name={register.field('_password')}
+		value={register.input._password}
+		aria-invalid={!!register.issues._password}
+	/>
+
+	<button>submit</button>
+</form>
+
+<pre>{JSON.stringify(register.issues, null, '  ')}</pre>
+
+<style>
+	[aria-invalid='true'] {
+		outline: 2px solid red;
+	}
+</style>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/underscore/form.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/underscore/form.remote.ts
new file mode 100644
index 000000000000..ed6f2bff3e8a
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/underscore/form.remote.ts
@@ -0,0 +1,10 @@
+import { form } from '$app/server';
+import * as v from 'valibot';
+
+export const register = form(
+	v.object({
+		username: v.pipe(v.string(), v.minLength(8)),
+		_password: v.pipe(v.string(), v.minLength(8))
+	}),
+	async (data) => {}
+);
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/validate/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/validate/+page.svelte
new file mode 100644
index 000000000000..0876bdea0f22
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/validate/+page.svelte
@@ -0,0 +1,25 @@
+<script>
+	import { my_form } from './form.remote.js';
+	import * as v from 'valibot';
+
+	const schema = v.object({
+		foo: v.picklist(['a', 'b']),
+		bar: v.picklist(['d', 'e'])
+	});
+</script>
+
+<form {...my_form.preflight(schema)} oninput={() => my_form.validate()}>
+	{#if my_form.issues.foo}
+		<p>{my_form.issues.foo[0].message}</p>
+	{/if}
+
+	<input name={my_form.field('foo')} />
+
+	{#if my_form.issues.bar}
+		<p>{my_form.issues.bar[0].message}</p>
+	{/if}
+
+	<input name={my_form.field('bar')} />
+
+	<button>submit</button>
+</form>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/validate/form.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/validate/form.remote.ts
new file mode 100644
index 000000000000..c24ed501afc9
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/validate/form.remote.ts
@@ -0,0 +1,12 @@
+import { form } from '$app/server';
+import * as v from 'valibot';
+
+export const my_form = form(
+	v.object({
+		foo: v.picklist(['a', 'b', 'c']),
+		bar: v.picklist(['d', 'e', 'f'])
+	}),
+	async (data) => {
+		console.log(data);
+	}
+);
diff --git a/packages/kit/test/apps/basics/test/client.test.js b/packages/kit/test/apps/basics/test/client.test.js
index b62dd253b5ed..9e69d0e25aef 100644
--- a/packages/kit/test/apps/basics/test/client.test.js
+++ b/packages/kit/test/apps/basics/test/client.test.js
@@ -1764,69 +1764,6 @@ test.describe('remote functions', () => {
 		await expect(page.locator('p')).toHaveText('post');
 	});
 
-	test('form.enhance works', async ({ page }) => {
-		await page.goto('/remote/form');
-		await page.fill('#input-task-enhance', 'abort');
-		await page.click('#submit-btn-enhance-one');
-		await page.waitForTimeout(100); // allow Svelte to update in case this does submit after (which it shouldn't)
-		await expect(page.locator('#form-result-1')).toHaveText('');
-
-		await page.fill('#input-task-enhance', 'hi');
-		await page.click('#submit-btn-enhance-one');
-		await expect(page.locator('#form-result-1')).toHaveText('hi');
-
-		await page.fill('#input-task-enhance', 'error');
-		await page.click('#submit-btn-enhance-one');
-		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "Expected error"'
-		);
-	});
-
-	test('form.buttonProps.enhance works', async ({ page }) => {
-		await page.goto('/remote/form');
-		await page.fill('#input-task-enhance', 'abort');
-		await page.click('#submit-btn-enhance-two');
-		await page.waitForTimeout(100); // allow Svelte to update in case this does submit after (which it shouldn't)
-		await expect(page.locator('#form-result-2')).toHaveText('');
-
-		await page.fill('#input-task-enhance', 'hi');
-		await page.click('#submit-btn-enhance-two');
-		await expect(page.locator('#form-result-2')).toHaveText('hi');
-
-		await page.fill('#input-task-enhance', 'error');
-		await page.click('#submit-btn-enhance-two');
-		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "Unexpected error (500 Internal Error)"'
-		);
-	});
-
-	test('form.enhance with override works', async ({ page }) => {
-		await page.goto('/remote/form');
-		await page.fill('#input-task-override', 'override');
-		page.click('#submit-btn-override-one');
-		await expect(page.locator('#get-task')).toHaveText('override (overridden)');
-		await expect(page.locator('#form-result-1')).toHaveText('override');
-		await expect(page.locator('#get-task')).toHaveText('override');
-	});
-
-	test('form.buttonProps.enhance with override works', async ({ page }) => {
-		await page.goto('/remote/form');
-		await page.fill('#input-task-override', 'override');
-		page.click('#submit-btn-override-one');
-		await expect(page.locator('#get-task')).toHaveText('override (overridden)');
-		await expect(page.locator('#form-result-1')).toHaveText('override');
-		await expect(page.locator('#get-task')).toHaveText('override');
-	});
-
-	test('form.buttonProps.enhance works with nested elements (issue #14159)', async ({ page }) => {
-		await page.goto('/remote/form');
-		await page.fill('#input-task-nested', 'nested-test');
-
-		// Click on the span inside the button to test the event.target vs event.currentTarget issue
-		await page.click('#submit-btn-nested-span span');
-		await expect(page.locator('#form-result-2')).toHaveText('nested-test');
-	});
-
 	test('prerendered entries not called in prod', async ({ page }) => {
 		let request_count = 0;
 		page.on('request', (r) => (request_count += r.url().includes('/_app/remote') ? 1 : 0));
@@ -1926,33 +1863,6 @@ test.describe('remote functions', () => {
 		await expect(page.locator('#command-pending')).toHaveText('Command pending: 0');
 	});
 
-	test('form pending state is tracked correctly', async ({ page }) => {
-		await page.goto('/remote/form');
-
-		// Initially no pending forms
-		await expect(page.locator('#form-pending')).toHaveText('Form pending: 0');
-		await expect(page.locator('#form-button-pending')).toHaveText('Button pending: 0');
-
-		// Fill form with slow operation
-		await page.fill('#input-task', 'deferred');
-
-		// Submit form - this will hang until we resolve it
-		await page.click('#submit-btn-one');
-
-		// Check that pending has incremented to 1
-		await expect(page.locator('#form-pending')).toHaveText('Form pending: 1');
-
-		// Resolve the deferred form submission
-		await page.click('#resolve-deferreds');
-
-		// Wait for form submission to complete and verify results
-		await expect(page.locator('#get-task')).toHaveText('deferred');
-
-		// Verify pending count returns to 0
-		await expect(page.locator('#form-pending')).toHaveText('Form pending: 0');
-		await expect(page.locator('#form-button-pending')).toHaveText('Button pending: 0');
-	});
-
 	// TODO once we have async SSR adjust the test and move this into test.js
 	test('query.batch works', async ({ page }) => {
 		await page.goto('/remote/batch');
diff --git a/packages/kit/test/apps/basics/test/test.js b/packages/kit/test/apps/basics/test/test.js
index 3703e45d9ace..da7aec216f71 100644
--- a/packages/kit/test/apps/basics/test/test.js
+++ b/packages/kit/test/apps/basics/test/test.js
@@ -1629,59 +1629,206 @@ test.describe('remote functions', () => {
 		await expect(page.locator('#redirected')).toHaveText('redirected');
 	});
 
-	test('form works', async ({ page }) => {
+	test('form works', async ({ page, javaScriptEnabled }) => {
 		await page.goto('/remote/form');
-		await page.fill('#input-task', 'hi');
-		await page.click('#submit-btn-one');
-		await expect(page.locator('#form-result-1')).toHaveText('hi');
-		await expect(page.locator('#input-task')).toHaveValue('');
+
+		if (javaScriptEnabled) {
+			// TODO remove the `if` — once async SSR lands these assertions should always succeed
+			await expect(page.getByText('message.current:')).toHaveText('message.current: initial');
+			await expect(page.getByText('await get_message():')).toHaveText(
+				'await get_message(): initial'
+			);
+		}
+
+		await page.fill('[data-unscoped] input', 'hello');
+		await page.getByText('set message').click();
+
+		if (javaScriptEnabled) {
+			await expect(page.getByText('set_message.pending:')).toHaveText('set_message.pending: 1');
+			await page.getByText('resolve deferreds').click();
+			await expect(page.getByText('set_message.pending:')).toHaveText('set_message.pending: 0');
+
+			await expect(page.getByText('message.current:')).toHaveText('message.current: hello');
+			await expect(page.getByText('await get_message():')).toHaveText('await get_message(): hello');
+		}
+
+		await expect(page.getByText('set_message.result')).toHaveText('set_message.result: hello');
+		await expect(page.locator('[data-unscoped] input')).toHaveValue('');
 	});
 
-	test('form error works', async ({ page }) => {
+	test('form updates inputs live', async ({ page, javaScriptEnabled }) => {
 		await page.goto('/remote/form');
-		await page.fill('#input-task', 'error');
-		await page.click('#submit-btn-one');
-		expect(await page.textContent('h1')).toBe('400');
-		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "Expected error"'
+
+		await page.fill('input', 'hello');
+
+		if (javaScriptEnabled) {
+			await expect(page.getByText('set_message.input.message:')).toHaveText(
+				'set_message.input.message: hello'
+			);
+		}
+
+		await page.getByText('set message').click();
+
+		if (javaScriptEnabled) {
+			await page.getByText('resolve deferreds').click();
+		}
+
+		await expect(page.getByText('set_message.input.message:')).toHaveText(
+			'set_message.input.message:'
 		);
 	});
 
-	test('form redirect works', async ({ page }) => {
+	test('form reports validation issues', async ({ page }) => {
 		await page.goto('/remote/form');
-		await page.fill('#input-task', 'redirect');
-		await page.click('#submit-btn-one');
-		expect(await page.textContent('#echo-result')).toBe('Hello world');
+
+		await page.fill('input', 'invalid');
+		await page.getByText('set message').click();
+
+		await page.getByText('message is invalid').waitFor();
 	});
 
-	test('form.buttonProps works', async ({ page }) => {
+	test('form handles unexpected error', async ({ page }) => {
 		await page.goto('/remote/form');
-		await page.fill('#input-task', 'hi');
-		await page.click('#submit-btn-two');
-		await expect(page.locator('#form-result-2')).toHaveText('hi');
+
+		await page.fill('input', 'unexpected error');
+		await page.getByText('set message').click();
+
+		await page
+			.getByText('This is your custom error page saying: "oops (500 Internal Error)"')
+			.waitFor();
 	});
 
-	test('form.buttonProps error works', async ({ page }) => {
+	test('form handles expected error', async ({ page }) => {
 		await page.goto('/remote/form');
-		await page.fill('#input-task', 'error');
-		await page.click('#submit-btn-two');
-		expect(await page.textContent('h1')).toBe('500');
-		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "Unexpected error (500 Internal Error)"'
+
+		await page.fill('input', 'expected error');
+		await page.getByText('set message').click();
+
+		await page.getByText('This is your custom error page saying: "oops"').waitFor();
+	});
+
+	test('form redirects', async ({ page }) => {
+		await page.goto('/remote/form');
+
+		await page.fill('input', 'redirect');
+		await page.getByText('set message').click();
+
+		await page.waitForURL('/remote');
+	});
+
+	test('form.buttonProps works', async ({ page, javaScriptEnabled }) => {
+		await page.goto('/remote/form');
+
+		await page.fill('[data-unscoped] input', 'backwards');
+		await page.getByText('set reverse message').click();
+
+		if (javaScriptEnabled) {
+			await page.getByText('message.current: sdrawkcab').waitFor();
+			await expect(page.getByText('await get_message():')).toHaveText(
+				'await get_message(): sdrawkcab'
+			);
+		}
+
+		await expect(page.getByText('set_reverse_message.result')).toHaveText(
+			'set_reverse_message.result: sdrawkcab'
 		);
 	});
 
-	test('form.for(...) scopes form submission', async ({ page, javaScriptEnabled }) => {
+	test('form scoping with for(...) works', async ({ page, javaScriptEnabled }) => {
 		await page.goto('/remote/form');
-		await page.click('#submit-btn-item-foo');
-		await expect(page.locator('#form-result-foo')).toHaveText('foo');
-		await expect(page.locator('#form-result-bar')).toHaveText('');
-		await expect(page.locator('#form-result-1')).toHaveText('');
-
-		await page.click('#submit-btn-item-2-foo');
-		await expect(page.locator('#form-result-2-foo')).toHaveText('foo2');
-		await expect(page.locator('#form-result-foo')).toHaveText(javaScriptEnabled ? 'foo' : '');
-		await expect(page.locator('#form-result-2')).toHaveText('');
+
+		await page.fill('[data-scoped] input', 'hello');
+		await page.getByText('set scoped message').click();
+
+		if (javaScriptEnabled) {
+			await expect(page.getByText('scoped.pending:')).toHaveText('scoped.pending: 1');
+			await page.getByText('resolve deferreds').click();
+			await expect(page.getByText('scoped.pending:')).toHaveText('scoped.pending: 0');
+
+			await page.getByText('message.current: hello').waitFor();
+			await expect(page.getByText('await get_message():')).toHaveText('await get_message(): hello');
+		}
+
+		await expect(page.getByText('scoped.result')).toHaveText('scoped.result: hello');
+		await expect(page.locator('[data-scoped] input')).toHaveValue('');
+	});
+
+	test('form enhance(...) works', async ({ page, javaScriptEnabled }) => {
+		await page.goto('/remote/form');
+
+		await page.fill('[data-enhanced] input', 'hello');
+
+		// Click on the span inside the button to test the event.target vs event.currentTarget issue (#14159)
+		await page.locator('[data-enhanced] span').click();
+
+		if (javaScriptEnabled) {
+			await expect(page.getByText('enhanced.pending:')).toHaveText('enhanced.pending: 1');
+
+			await page.getByText('message.current: hello (override)').waitFor();
+
+			await page.getByText('resolve deferreds').click();
+			await expect(page.getByText('enhanced.pending:')).toHaveText('enhanced.pending: 0');
+			await expect(page.getByText('await get_message():')).toHaveText('await get_message(): hello');
+		}
+
+		await expect(page.getByText('enhanced.result')).toHaveText('enhanced.result: hello');
+		await expect(page.locator('[data-enhanced] input')).toHaveValue('');
+	});
+
+	test('form preflight works', async ({ page, javaScriptEnabled }) => {
+		if (!javaScriptEnabled) return;
+
+		await page.goto('/remote/form/preflight');
+
+		for (const enhanced of [true, false]) {
+			const input = page.locator(enhanced ? '[data-enhanced] input' : '[data-default] input');
+			const button = page.getByText(enhanced ? 'set enhanced number' : 'set number');
+
+			await input.fill('21');
+			await button.click();
+			await page.getByText('too big').waitFor();
+
+			await input.fill('9');
+			await button.click();
+			await page.getByText('too small').waitFor();
+
+			await input.fill('15');
+			await button.click();
+			await expect(page.getByText('number.current')).toHaveText('number.current: 15');
+		}
+	});
+
+	test('form validate works', async ({ page, javaScriptEnabled }) => {
+		if (!javaScriptEnabled) return;
+
+		await page.goto('/remote/form/validate');
+
+		const foo = page.locator('input[name="foo"]');
+		const bar = page.locator('input[name="bar"]');
+
+		await foo.fill('a');
+		await expect(page.locator('form')).not.toContainText('Invalid type: Expected');
+
+		await bar.fill('g');
+		await expect(page.locator('form')).toContainText(
+			'Invalid type: Expected ("d" | "e") but received "g"'
+		);
+
+		await bar.fill('d');
+		await expect(page.locator('form')).not.toContainText('Invalid type: Expected');
+	});
+
+	test('form inputs excludes underscore-prefixed fields', async ({ page, javaScriptEnabled }) => {
+		if (javaScriptEnabled) return;
+
+		await page.goto('/remote/form/underscore');
+
+		await page.fill('input[name="username"]', 'abcdefg');
+		await page.fill('input[name="_password"]', 'pqrstuv');
+		await page.locator('button').click();
+
+		await expect(page.locator('input[name="username"]')).toHaveValue('abcdefg');
+		await expect(page.locator('input[name="_password"]')).toHaveValue('');
 	});
 
 	test('prerendered entries not called in prod', async ({ page, clicknav }) => {
diff --git a/packages/kit/test/apps/options-2/package.json b/packages/kit/test/apps/options-2/package.json
index 818c8a9dc163..83d0e4c62814 100644
--- a/packages/kit/test/apps/options-2/package.json
+++ b/packages/kit/test/apps/options-2/package.json
@@ -19,6 +19,7 @@
 		"svelte": "^5.38.5",
 		"svelte-check": "^4.1.1",
 		"typescript": "^5.5.4",
+		"valibot": "^1.1.0",
 		"vite": "catalog:"
 	},
 	"type": "module"
diff --git a/packages/kit/test/apps/options-2/src/routes/remote/count.remote.js b/packages/kit/test/apps/options-2/src/routes/remote/count.remote.js
index fc93f18dd9c2..52bd1f530250 100644
--- a/packages/kit/test/apps/options-2/src/routes/remote/count.remote.js
+++ b/packages/kit/test/apps/options-2/src/routes/remote/count.remote.js
@@ -1,5 +1,6 @@
 import { building, dev } from '$app/environment';
 import { command, form, prerender, query } from '$app/server';
+import * as v from 'valibot';
 
 let count = 0;
 
@@ -21,7 +22,6 @@ export const prerendered = prerender(() => {
 	return 'yes';
 });
 
-export const set_count_form = form(async (form_data) => {
-	const c = /** @type {string} */ (form_data.get('count'));
-	return (count = parseInt(c));
+export const set_count_form = form(v.object({ count: v.string() }), async (data) => {
+	return (count = parseInt(data.count));
 });
diff --git a/packages/kit/test/types/remote.test.ts b/packages/kit/test/types/remote.test.ts
index 567b75d29f3f..2dea52594198 100644
--- a/packages/kit/test/types/remote.test.ts
+++ b/packages/kit/test/types/remote.test.ts
@@ -159,8 +159,8 @@ command_tests();
 
 function form_tests() {
 	const q = query(() => '');
-	const f = form((f) => {
-		f.get('');
+	const f = form('unchecked', (data: { input: string }) => {
+		data.input;
 		return { success: true };
 	});
 
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 097c03cf9b38..960d072276a7 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -1682,28 +1682,105 @@ declare module '@sveltejs/kit' {
 		restore: (snapshot: T) => void;
 	}
 
+	// If T is unknown or RemoteFormInput, the types below will recurse indefinitely and create giant unions that TS can't handle
+	type WillRecurseIndefinitely<T> = unknown extends T
+		? true
+		: RemoteFormInput extends T
+			? true
+			: false;
+
+	// Helper type to convert union to intersection
+	type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+		? I
+		: never;
+
+	type FlattenInput<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: string }
+			: T extends Array<infer U>
+				? U extends string | File
+					? { [P in Prefix]: string[] }
+					: FlattenInput<U, `${Prefix}[${number}]`>
+				: T extends File
+					? { [P in Prefix]: string }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenInput<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: string };
+
+	type FlattenIssues<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: RemoteFormIssue[] }
+			: T extends Array<infer U>
+				? { [P in Prefix | `${Prefix}[${number}]`]: RemoteFormIssue[] } & FlattenIssues<
+						U,
+						`${Prefix}[${number}]`
+					>
+				: T extends File
+					? { [P in Prefix]: RemoteFormIssue[] }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenIssues<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: RemoteFormIssue[] };
+
+	type FlattenKeys<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: string }
+			: T extends Array<infer U>
+				? U extends string | File
+					? { [P in `${Prefix}[]`]: string[] }
+					: FlattenKeys<U, `${Prefix}[${number}]`>
+				: T extends File
+					? { [P in Prefix]: string }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenKeys<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: string };
+
+	export interface RemoteFormInput {
+		[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+	}
+
+	export interface RemoteFormIssue {
+		name: string;
+		path: Array<string | number>;
+		message: string;
+	}
+
 	/**
 	 * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
 	 */
-	export type RemoteForm<Result> = {
+	export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+		/** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */
+		[attachment: symbol]: (node: HTMLFormElement) => void;
 		method: 'POST';
 		/** The URL to send the form to. */
 		action: string;
-		/** Event handler that intercepts the form submission on the client to prevent a full page reload */
-		onsubmit: (event: SubmitEvent) => void;
 		/** Use the `enhance` method to influence what happens when the form is submitted. */
 		enhance(
 			callback: (opts: {
 				form: HTMLFormElement;
-				data: FormData;
+				data: Input;
 				submit: () => Promise<void> & {
 					updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 				};
-			}) => void
+			}) => void | Promise<void>
 		): {
 			method: 'POST';
 			action: string;
-			onsubmit: (event: SubmitEvent) => void;
+			[attachment: symbol]: (node: HTMLFormElement) => void;
 		};
 		/**
 		 * Create an instance of the form for the given key.
@@ -1719,11 +1796,27 @@ declare module '@sveltejs/kit' {
 		 *	{/each}
 		 * ```
 		 */
-		for(key: string | number | boolean): Omit<RemoteForm<Result>, 'for'>;
+		for(key: string | number | boolean): Omit<RemoteForm<Input, Output>, 'for'>;
+		/**
+		 * This method exists to allow you to typecheck `name` attributes. It returns its argument
+		 * @example
+		 * ```svelte
+		 * <input name={login.field('username')} />
+		 * ```
+		 **/
+		field<Name extends keyof UnionToIntersection<FlattenKeys<Input, ''>>>(string: Name): Name;
+		/** Preflight checks */
+		preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
+		/** Validate the form contents programmatically */
+		validate(options?: { includeUntouched?: boolean }): Promise<void>;
 		/** The result of the form submission */
-		get result(): Result | undefined;
+		get result(): Output | undefined;
 		/** The number of pending submissions */
 		get pending(): number;
+		/** The submitted values */
+		input: null | UnionToIntersection<FlattenInput<Input, ''>>;
+		/** Validation issues */
+		issues: null | UnionToIntersection<FlattenIssues<Input, ''>>;
 		/** Spread this onto a `<button>` or `<input type="submit">` */
 		buttonProps: {
 			type: 'submit';
@@ -1734,11 +1827,11 @@ declare module '@sveltejs/kit' {
 			enhance(
 				callback: (opts: {
 					form: HTMLFormElement;
-					data: FormData;
+					data: Input;
 					submit: () => Promise<void> & {
 						updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 					};
-				}) => void
+				}) => void | Promise<void>
 			): {
 				type: 'submit';
 				formmethod: 'POST';
@@ -2806,7 +2899,7 @@ declare module '$app/paths' {
 }
 
 declare module '$app/server' {
-	import type { RequestEvent, RemoteCommand, RemoteForm, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
+	import type { RequestEvent, RemoteCommand, RemoteForm, RemoteFormInput, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	/**
 	 * Read the contents of an imported asset from the filesystem
@@ -2860,7 +2953,23 @@ declare module '$app/server' {
 	 *
 	 * @since 2.27
 	 */
-	export function form<T>(fn: (data: FormData) => MaybePromise<T>): RemoteForm<T>;
+	export function form<Output>(fn: () => Output): RemoteForm<void, Output>;
+	/**
+	 * Creates a form object that can be spread onto a `<form>` element.
+	 *
+	 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+	 *
+	 * @since 2.27
+	 */
+	export function form<Input extends RemoteFormInput, Output>(validate: "unchecked", fn: (data: Input) => MaybePromise<Output>): RemoteForm<Input, Output>;
+	/**
+	 * Creates a form object that can be spread onto a `<form>` element.
+	 *
+	 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+	 *
+	 * @since 2.27
+	 */
+	export function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(validate: Schema, fn: (data: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;
 	/**
 	 * Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
 	 *
diff --git a/playgrounds/basic/package.json b/playgrounds/basic/package.json
index a9a81442be89..9b381ccfc533 100644
--- a/playgrounds/basic/package.json
+++ b/playgrounds/basic/package.json
@@ -32,6 +32,7 @@
 		"svelte": "^5.38.5",
 		"svelte-check": "^4.1.1",
 		"typescript": "^5.5.0",
+		"valibot": "^1.1.0",
 		"vite": "catalog:"
 	},
 	"type": "module",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7741f57fcb27..775f6c9859d5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -551,6 +551,9 @@ importers:
       typescript:
         specifier: ^5.5.4
         version: 5.8.3
+      valibot:
+        specifier: ^1.1.0
+        version: 1.1.0(typescript@5.8.3)
       vite:
         specifier: 'catalog:'
         version: 6.3.6(@types/node@18.19.119)(jiti@2.4.2)(lightningcss@1.30.1)(yaml@2.8.0)
@@ -716,6 +719,9 @@ importers:
       typescript:
         specifier: ^5.5.4
         version: 5.8.3
+      valibot:
+        specifier: ^1.1.0
+        version: 1.1.0(typescript@5.8.3)
       vite:
         specifier: 'catalog:'
         version: 6.3.6(@types/node@18.19.119)(jiti@2.4.2)(lightningcss@1.30.1)(yaml@2.8.0)
@@ -1293,6 +1299,9 @@ importers:
       typescript:
         specifier: ^5.5.0
         version: 5.8.3
+      valibot:
+        specifier: ^1.1.0
+        version: 1.1.0(typescript@5.8.3)
       vite:
         specifier: 'catalog:'
         version: 6.3.6(@types/node@18.19.119)(jiti@2.4.2)(lightningcss@1.30.1)(yaml@2.8.0)
@@ -6983,6 +6992,14 @@ packages:
   v8-compile-cache-lib@3.0.1:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
 
+  valibot@1.1.0:
+    resolution: {integrity: sha512-Nk8lX30Qhu+9txPYTwM0cFlWLdPFsFr6LblzqIySfbZph9+BFsAHsNvHOymEviUepeIW6KFHzpX8TKhbptBXXw==}
+    peerDependencies:
+      typescript: '>=5'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
   validate-npm-package-license@3.0.4:
     resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
 
@@ -13279,6 +13296,10 @@ snapshots:
 
   v8-compile-cache-lib@3.0.1: {}
 
+  valibot@1.1.0(typescript@5.8.3):
+    optionalDependencies:
+      typescript: 5.8.3
+
   validate-npm-package-license@3.0.4:
     dependencies:
       spdx-correct: 3.2.0