diff --git a/.changeset/shaky-ties-look.md b/.changeset/shaky-ties-look.md
new file mode 100644
index 000000000000..16d5acb30264
--- /dev/null
+++ b/.changeset/shaky-ties-look.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': minor
+---
+
+breaking: update experimental `form` API
diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index 4d7e637b1d2b..01633b9b7edc 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -229,7 +229,6 @@ export const getWeather = query.batch(v.string(), async (cities) => {
 
 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
 /// file: src/routes/blog/data.remote.js
 // @filename: ambient.d.ts
@@ -293,115 +292,188 @@ export const createPost = form(
 
 <h1>Create a new post</h1>
 
+<form {...createPost}>
+	<!-- form content goes here -->
+
+	<button>Publish!</button>
+</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 [attachment](/docs/svelte/@attach) 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`.
+
+### Fields
+
+A form is composed of a set of _fields_, which are defined by the schema. In the case of `createPost`, we have two fields, `title` and `content`, which are both strings. To get the attributes for a field, call its `.as(...)` method, specifying which [input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#input_types) to use:
+
+```svelte
 <form {...createPost}>
 	<label>
 		<h2>Title</h2>
-		<input name="title" />
+		+++<input {...createPost.fields.title.as('text')} />+++
 	</label>
 
 	<label>
 		<h2>Write your post</h2>
-		<textarea name="content"></textarea>
+		+++<textarea {...createPost.fields.content.as('text')}></textarea>+++
 	</label>
 
 	<button>Publish!</button>
 </form>
 ```
 
-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.
+These attributes allow SvelteKit to set the correct input type, set a `name` that is used to construct the `data` passed to the handler, populate the `value` of the form (for example following a failed submission, to save the user having to re-enter everything), and set the [`aria-invalid`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-invalid) state.
 
-```ts
-/// file: src/routes/count.remote.js
+Fields can be nested in objects and arrays, and their values can be strings, numbers, booleans or `File` objects. For example, if your schema looked like this...
+
+```js
+/// file: data.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: z.coerce.number<string>()
+// ---cut---
+const datingProfile = v.object({
+	name: v.string(),
+	photo: v.file(),
+	info: v.object({
+		height: v.number(),
+		likesDogs: v.optional(v.boolean(), false)
 	}),
-	async ({ count }) => {
-		// ...
-	}
-);
+	attributes: v.array(v.string())
+});
+
+export const createProfile = form(datingProfile, (data) => { /* ... */ });
 ```
 
-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:
+...your form could look like this:
 
 ```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}
+<script>
+	import { createProfile } from './data.remote';
+
+	const { name, photo, info, attributes } = createProfile.fields;
+</script>
+
+<form {...createProfile} enctype="multipart/form-data">
+	<label>
+		<input {...name.as('text')} /> Name
+	</label>
+
+	<label>
+		<input {...photo.as('file')} /> Photo
+	</label>
+
+	<label>
+		<input {...info.height.as('number')} /> Height (cm)
+	</label>
+
+	<label>
+		<input {...info.likesDogs.as('checkbox')} /> I like dogs
+	</label>
+
+	<h2>My best attributes</h2>
+	<input {...attributes[0].as('text')} />
+	<input {...attributes[1].as('text')} />
+	<input {...attributes[2].as('text')} />
+
+	<button>submit</button>
+</form>
 ```
 
-To indicate a repeated field, use a `[]` suffix:
+Because our form contains a `file` input, we've added an `enctype="multipart/form-data"` attribute. The values for `info.height` and `info.likesDogs` are coerced to a number and a boolean respectively.
+
+> [!NOTE] If a `checkbox` input is unchecked, the value is not included in the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object that SvelteKit constructs the data from. As such, we have to make the value optional in our schema. In Valibot that means using `v.optional(v.boolean(), false)` instead of just `v.boolean()`, whereas in Zod it would mean using `z.coerce.boolean<boolean>()`.
+
+In the case of `radio` and `checkbox` inputs that all belong to the same field, the `value` must be specified as a second argument to `.as(...)`:
+
+```js
+/// file: data.remote.js
+import * as v from 'valibot';
+import { form } from '$app/server';
+// ---cut---
+export const survey = form(
+	v.object({
+		operatingSystem: v.picklist(['windows', 'mac', 'linux']),
+		languages: v.optional(v.array(v.picklist(['html', 'css', 'js'])), [])
+	}),
+	(data) => { /* ... */ }
+);
+```
 
 ```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>
+<form {...survey}>
+	<h2>Which operating system do you use?</h2>
+
+	{#each ['windows', 'mac', 'linux'] as os}
+		<label>
+			<input {...survey.fields.operatingSystem.as('radio', os)}>
+			{os}
+		</label>
+	{/each}
+
+	<h2>Which languages do you write code in?</h2>
+
+	{#each ['html', 'css', 'js'] as language}
+		<label>
+			<input {...survey.fields.languages.as('checkbox', language)}>
+			{language}
+		</label>
+	{/each}
+
+	<button>submit</button>
+</form>
 ```
 
-If you'd like type safety and autocomplete when setting `name` attributes, use the form object's `field` method:
+Alternatively, you could use `select` and `select multiple`:
 
 ```svelte
-<label>
-	<h2>Title</h2>
-	<input name={+++createPost.field('title')+++} />
-</label>
-```
+<form {...survey}>
+	<h2>Which operating system do you use?</h2>
 
-This will error during typechecking if `title` does not exist on your schema.
+	<select {...survey.fields.operatingSystem.as('select')}>
+		<option>windows</option>
+		<option>mac</option>
+		<option>linux</option>
+	</select>
 
-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.
+	<h2>Which languages do you write code in?</h2>
+
+	<select {...survey.fields.languages.as('select multiple')}>
+		<option>html</option>
+		<option>css</option>
+		<option>js</option>
+	</select>
+
+	<button>submit</button>
+</form>
+```
+
+> [!NOTE] As with unchecked `checkbox` inputs, if no selections are made then the data will be `undefined`. For this reason, the `languages` field uses `v.optional(v.array(...), [])` rather than just `v.array(...)`.
 
 ### 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:
+If the submitted data doesn't pass the schema, the callback will not run. Instead, each invalid field's `issues()` method will return an array of `{ message: string }` objects, and the `aria-invalid` attribute (returned from `as(...)`) will be set to `true`:
 
 ```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}+++
++++		{#each createPost.fields.title.issues() as issue}
+			<p class="issue">{issue.message}</p>
+		{/each}+++
 
-		<input
-			name="title"
-			+++aria-invalid={!!createPost.issues.title}+++
-		/>
+		<input {...createPost.fields.title.as('text')} />
 	</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}+++
++++		{#each createPost.fields.content.issues() as issue}
+			<p class="issue">{issue.message}</p>
+		{/each}+++
 
-		<textarea
-			name="content"
-			+++aria-invalid={!!createPost.issues.content}+++
-		></textarea>
+		<textarea {...createPost.fields.content.as('text')}></textarea>
 	</label>
 
 	<button>Publish!</button>
@@ -418,7 +490,7 @@ You don't need to wait until the form is submitted to validate the data — you
 
 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:
+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>
@@ -440,9 +512,17 @@ For client-side validation, you can specify a _preflight_ schema which will popu
 
 > [!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
+To get a list of _all_ issues, rather than just those belonging to a single field, you can use the `fields.allIssues()` method:
 
-The form object contains a `input` property which reflects its current value. As the user interacts with the form, `input` is automatically updated:
+```svelte
+{#each createPost.fields.allIssues() as issue}
+	<p>{issue.message}</p>
+{/each}
+```
+
+### Getting/setting inputs
+
+Each field has a `value()` method that reflects its current value. As the user interacts with the form, it is automatically updated:
 
 ```svelte
 <form {...createPost}>
@@ -450,14 +530,34 @@ The form object contains a `input` property which reflects its current value. As
 </form>
 
 <div class="preview">
-	<h2>{createPost.input.title}</h2>
-	<div>{@html render(createPost.input.content)}</div>
+	<h2>{createPost.fields.title.value()}</h2>
+	<div>{@html render(createPost.fields.content.value())}</div>
 </div>
 ```
 
+Alternatively, `createPost.fields.value()` would return a `{ title, content }` object.
+
+You can update a field (or a collection of fields) via the `set(...)` method:
+
+```svelte
+<script>
+	import { createPost } from '../data.remote';
+
+	// this...
+	createPost.fields.set({
+		title: 'My new blog post',
+		content: 'Lorem ipsum dolor sit amet...'
+	});
+
+	// ...is equivalent to this:
+	createPost.fields.title.set('My new blog post');
+	createPost.fields.content.set('Lorem ipsum dolor sit amet');
+</script>
+```
+
 ### 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.
+In the case of a non-progressively-enhanced form submission (i.e. where JavaScript is unavailable, for whatever reason) `value()` 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:
 
@@ -465,20 +565,12 @@ You can prevent sensitive data (such as passwords and credit card numbers) from
 <form {...register}>
 	<label>
 		Username
-		<input
-			name="username"
-			value={register.input.username}
-			aria-invalid={!!register.issues.username}
-		/>
+		<input {...register.fields.username.as('text')} />
 	</label>
 
 	<label>
 		Password
-		<input
-			type="password"
-			+++name="_password"+++
-			+++aria-invalid={!!register.issues._password}+++
-		/>
+		<input +++{...register.fields._password.as('password')}+++ />
 	</label>
 
 	<button>Sign up!</button>
@@ -680,12 +772,12 @@ This attribute exists on the `buttonProps` property of a form object:
 <form {...login}>
 	<label>
 		Your username
-		<input name="username" />
+		<input {...login.fields.username.as('text')} />
 	</label>
 
 	<label>
 		Your password
-		<input name="password" type="password" />
+		<input {...login.fields._password.as('password')} />
 	</label>
 
 	<button>login</button>
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index f06e771a400d..934d307d9066 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -1813,78 +1813,127 @@ export interface Snapshot<T = any> {
 // If T is unknown or has an index signature, the types below will recurse indefinitely and create giant unions that TS can't handle
 type WillRecurseIndefinitely<T> = unknown extends T ? true : string extends keyof 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> = T extends string | number | boolean | null | undefined
-	? { [P in Prefix]: 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 }
-				: {
-						// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-						[K in keyof Required<T>]: FlattenInput<
-							T[K],
-							Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-						>;
-					}[keyof T];
-
-type FlattenIssues<T, Prefix extends string> = T extends
-	| string
-	| number
-	| boolean
-	| null
-	| undefined
-	? { [P in Prefix]: RemoteFormIssue[] }
-	: 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[] }
-				: {
-						// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-						[K in keyof Required<T>]: FlattenIssues<
-							T[K],
-							Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-						>;
-					}[keyof T];
-
-type FlattenKeys<T, Prefix extends string> = T extends string | number | boolean | null | undefined
-	? { [P in Prefix]: 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 }
-				: {
-						// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-						[K in keyof Required<T>]: FlattenKeys<
-							T[K],
-							Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-						>;
-					}[keyof T];
+// Input type mappings for form fields
+type InputTypeMap = {
+	text: string;
+	email: string;
+	password: string;
+	url: string;
+	tel: string;
+	search: string;
+	number: number;
+	range: number;
+	date: string;
+	'datetime-local': string;
+	time: string;
+	month: string;
+	week: string;
+	color: string;
+	checkbox: boolean | string[];
+	radio: string;
+	file: File;
+	hidden: string;
+	submit: string;
+	button: string;
+	reset: string;
+	image: string;
+	select: string;
+	'select multiple': string[];
+	'file multiple': File[];
+};
+
+// Valid input types for a given value type
+export type RemoteFormFieldType<T> = {
+	[K in keyof InputTypeMap]: T extends InputTypeMap[K] ? K : never;
+}[keyof InputTypeMap];
+
+// Input element properties based on type
+type InputElementProps<T extends keyof InputTypeMap> = T extends 'checkbox' | 'radio'
+	? {
+			type: T;
+			'aria-invalid': boolean | 'false' | 'true' | undefined;
+			get checked(): boolean;
+			set checked(value: boolean);
+		}
+	: T extends 'file'
+		? {
+				type: 'file';
+				'aria-invalid': boolean | 'false' | 'true' | undefined;
+				get files(): FileList | null;
+				set files(v: FileList | null);
+			}
+		: {
+				type: T;
+				'aria-invalid': boolean | 'false' | 'true' | undefined;
+				get value(): string | number;
+				set value(v: string | number);
+			};
+
+type RemoteFormFieldMethods<T> = {
+	/** The values that will be submitted */
+	value(): T;
+	/** Set the values that will be submitted */
+	set(input: T): T;
+	/** Validation issues, if any */
+	issues(): RemoteFormIssue[] | undefined;
+};
+
+export type RemoteFormFieldValue = string | string[] | number | boolean | File | File[];
+
+type AsArgs<Type extends keyof InputTypeMap, Value> = Type extends 'checkbox'
+	? Value extends string[]
+		? [type: 'checkbox', value: Value[number] | (string & {})]
+		: [type: Type]
+	: Type extends 'radio'
+		? [type: 'radio', value: Value | (string & {})]
+		: [type: Type];
+
+/**
+ * Form field accessor type that provides name(), value(), and issues() methods
+ */
+export type RemoteFormField<Value extends RemoteFormFieldValue> = RemoteFormFieldMethods<Value> & {
+	/**
+	 * Returns an object that can be spread onto an input element with the correct type attribute,
+	 * aria-invalid attribute if the field is invalid, and appropriate value/checked property getters/setters.
+	 * @example
+	 * ```svelte
+	 * <input {...myForm.fields.myString.as('text')} />
+	 * <input {...myForm.fields.myNumber.as('number')} />
+	 * <input {...myForm.fields.myBoolean.as('checkbox')} />
+	 * ```
+	 */
+	as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+};
+
+type RemoteFormFieldContainer<Value> = RemoteFormFieldMethods<Value> & {
+	/** Validation issues belonging to this or any of the fields that belong to it, if any */
+	allIssues(): RemoteFormIssue[] | undefined;
+};
+
+/**
+ * Recursive type to build form fields structure with proxy access
+ */
+type RemoteFormFields<T> =
+	WillRecurseIndefinitely<T> extends true
+		? RecursiveFormFields
+		: NonNullable<T> extends string | number | boolean | File
+			? RemoteFormField<NonNullable<T>>
+			: T extends string[] | File[]
+				? RemoteFormField<T> & { [K in number]: RemoteFormField<T[number]> }
+				: T extends Array<infer U>
+					? RemoteFormFieldContainer<T> & { [K in number]: RemoteFormFields<U> }
+					: RemoteFormFieldContainer<T> & { [K in keyof T]-?: RemoteFormFields<T[K]> };
+
+// By breaking this out into its own type, we avoid the TS recursion depth limit
+type RecursiveFormFields = RemoteFormField<any> & { [key: string]: RecursiveFormFields };
+
+type MaybeArray<T> = T | T[];
 
 export interface RemoteFormInput {
-	[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+	[key: string]: MaybeArray<string | number | boolean | File | RemoteFormInput>;
 }
 
 export interface RemoteFormIssue {
-	name: string;
-	path: Array<string | number>;
 	message: string;
 }
 
@@ -1926,14 +1975,6 @@ export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
 	 * ```
 	 */
 	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 */
@@ -1946,10 +1987,8 @@ export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
 	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, ''>>;
+	/** Access form fields using object notation */
+	fields: Input extends void ? never : RemoteFormFields<Input>;
 	/** Spread this onto a `<button>` or `<input type="submit">` */
 	buttonProps: {
 		type: 'submit';
diff --git a/packages/kit/src/runtime/app/server/remote/form.js b/packages/kit/src/runtime/app/server/remote/form.js
index 1c24412c2545..ba6562bf3423 100644
--- a/packages/kit/src/runtime/app/server/remote/form.js
+++ b/packages/kit/src/runtime/app/server/remote/form.js
@@ -1,10 +1,17 @@
 /** @import { RemoteFormInput, RemoteForm } from '@sveltejs/kit' */
-/** @import { MaybePromise, RemoteInfo } from 'types' */
+/** @import { InternalRemoteFormIssue, 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 {
+	convert_formdata,
+	flatten_issues,
+	create_field_proxy,
+	set_nested_value,
+	throw_on_old_property_access,
+	deep_set
+} from '../../../form-utils.svelte.js';
 import { get_cache, 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.
@@ -128,7 +135,7 @@ export function form(validate_or_fn, maybe_fn) {
 					}
 				}
 
-				/** @type {{ input?: Record<string, string | string[]>, issues?: Record<string, StandardSchemaV1.Issue[]>, result: Output }} */
+				/** @type {{ input?: Record<string, any>, issues?: Record<string, InternalRemoteFormIssue[]>, result: Output }} */
 				const output = {};
 
 				const { event, state } = get_request_store();
@@ -140,18 +147,27 @@ export function form(validate_or_fn, maybe_fn) {
 
 				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;
+					// if it was a progressively-enhanced submission, we don't need
+					// to return the input — it's already there
+					if (!event.isRemoteRequest) {
+						output.input = {};
 
-						const is_array = key.endsWith('[]');
-						const values = form_data.getAll(key).filter((value) => typeof value === 'string');
+						for (let key of form_data.keys()) {
+							// redact sensitive fields
+							if (/^[.\]]?_/.test(key)) continue;
 
-						if (is_array) key = key.slice(0, -2);
+							const is_array = key.endsWith('[]');
+							const values = form_data.getAll(key).filter((value) => typeof value === 'string');
 
-						output.input[key] = is_array ? values : values[0];
+							if (is_array) key = key.slice(0, -2);
+
+							output.input = set_nested_value(
+								/** @type {Record<string, any>} */ (output.input),
+								key,
+								is_array ? values : values[0]
+							);
+						}
 					}
 				} else {
 					if (validated !== undefined) {
@@ -185,16 +201,30 @@ export function form(validate_or_fn, maybe_fn) {
 			enumerable: true
 		});
 
-		for (const property of ['input', 'issues']) {
-			Object.defineProperty(instance, property, {
-				get() {
-					try {
-						return get_cache(__)?.['']?.[property] ?? {};
-					} catch {
-						return undefined;
-					}
-				}
-			});
+		Object.defineProperty(instance, 'fields', {
+			get() {
+				const data = get_cache(__)?.[''];
+				return create_field_proxy(
+					{},
+					() => data?.input ?? {},
+					(path, value) => {
+						if (data) {
+							// don't override a submission
+							return;
+						}
+
+						const input = path.length === 0 ? value : deep_set({}, path.map(String), value);
+
+						get_cache(__)[''] ??= { input };
+					},
+					() => data?.issues ?? {}
+				);
+			}
+		});
+
+		// TODO 3.0 remove
+		if (DEV) {
+			throw_on_old_property_access(instance);
 		}
 
 		Object.defineProperty(instance, 'result', {
@@ -217,10 +247,6 @@ export function form(validate_or_fn, maybe_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
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 e2ee9af5cb45..8c938f6a7250 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -1,6 +1,6 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 /** @import { RemoteFormInput, RemoteForm, RemoteQueryOverride } from '@sveltejs/kit' */
-/** @import { RemoteFunctionResponse } from 'types' */
+/** @import { InternalRemoteFormIssue, RemoteFunctionResponse } from 'types' */
 /** @import { Query } from './query.svelte.js' */
 import { app_dir, base } from '$app/paths/internal/client';
 import * as devalue from 'devalue';
@@ -10,7 +10,34 @@ import { app, remote_responses, _goto, set_nearest_error_page, invalidateAll } f
 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';
+import {
+	convert_formdata,
+	flatten_issues,
+	create_field_proxy,
+	deep_set,
+	set_nested_value,
+	throw_on_old_property_access
+} from '../../form-utils.svelte.js';
+
+/**
+ * Merge client issues into server issues
+ * @param {Record<string, InternalRemoteFormIssue[]>} current_issues
+ * @param {Record<string, InternalRemoteFormIssue[]>} client_issues
+ * @returns {Record<string, InternalRemoteFormIssue[]>}
+ */
+function merge_with_server_issues(current_issues, client_issues) {
+	const merged_issues = Object.fromEntries(
+		Object.entries(current_issues)
+			.map(([key, issue_list]) => [key, issue_list.filter((issue) => issue.server)])
+			.filter(([, issue_list]) => issue_list.length > 0)
+	);
+
+	for (const [key, new_issue_list] of Object.entries(client_issues)) {
+		merged_issues[key] = [...(merged_issues[key] || []), ...new_issue_list];
+	}
+
+	return merged_issues;
+}
 
 /**
  * Client-version of the `form` function from `$app/server`.
@@ -28,10 +55,14 @@ 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({});
+		/**
+		 * By making this $state.raw() and creating a new object each time we update it,
+		 * all consumers along the update chain are properly invalidated.
+		 * @type {Record<string, string | string[] | File | File[]>}
+		 */
+		let input = $state.raw({});
 
-		/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+		/** @type {Record<string, InternalRemoteFormIssue[]>} */
 		let issues = $state.raw({});
 
 		/** @type {any} */
@@ -49,6 +80,8 @@ export function form(id) {
 		/** @type {Record<string, boolean>} */
 		let touched = {};
 
+		let submitted = false;
+
 		/**
 		 * @param {HTMLFormElement} form
 		 * @param {FormData} form_data
@@ -57,10 +90,13 @@ export function form(id) {
 		async function handle_submit(form, form_data, callback) {
 			const data = convert_formdata(form_data);
 
+			submitted = true;
+
 			const validated = await preflight_schema?.['~standard'].validate(data);
 
 			if (validated?.issues) {
-				issues = flatten_issues(validated.issues);
+				const client_issues = flatten_issues(validated.issues, false);
+				issues = merge_with_server_issues(issues, client_issues);
 				return;
 			}
 
@@ -146,21 +182,25 @@ export function form(id) {
 					const form_result = /** @type { RemoteFunctionResponse} */ (await response.json());
 
 					if (form_result.type === 'result') {
-						({
-							input = {},
-							issues = {},
-							result
-						} = devalue.parse(form_result.result, {
-							...app.decoders,
-							File: file_transport.decode
-						}));
+						({ issues = {}, result } = devalue.parse(form_result.result, app.decoders));
+
+						// Mark server issues with server: true
+						for (const issue_list of Object.values(issues)) {
+							for (const issue of issue_list) {
+								issue.server = true;
+							}
+						}
 
 						if (issues.$) {
 							release_overrides(updates);
-						} else if (form_result.refreshes) {
-							refresh_queries(form_result.refreshes, updates);
 						} else {
-							void invalidateAll();
+							input = {};
+
+							if (form_result.refreshes) {
+								refresh_queries(form_result.refreshes, updates);
+							} else {
+								void invalidateAll();
+							}
 						}
 					} else if (form_result.type === 'redirect') {
 						const refreshes = form_result.refreshes ?? '';
@@ -275,23 +315,37 @@ export function form(id) {
 					touched[name] = true;
 
 					if (is_array) {
-						const elements = /** @type {HTMLInputElement[]} */ (
-							Array.from(form.querySelectorAll(`[name="${name}[]"]`))
-						);
+						let value;
 
-						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}")`
-									);
+						if (element.tagName === 'SELECT') {
+							value = Array.from(
+								element.querySelectorAll('option:checked'),
+								(e) => /** @type {HTMLOptionElement} */ (e).value
+							);
+						} else {
+							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}")`
+										);
+									}
 								}
 							}
+
+							value = is_file
+								? elements.map((input) => Array.from(input.files ?? [])).flat()
+								: elements.map((element) => element.value);
+							if (element.type === 'checkbox') {
+								value = /** @type {string[]} */ (value.filter((_, i) => elements[i].checked));
+							}
 						}
 
-						input[name] = is_file
-							? elements.map((input) => Array.from(input.files ?? [])).flat()
-							: elements.map((element) => element.value);
+						input = set_nested_value(input, name, value);
 					} else if (is_file) {
 						if (DEV && element.multiple) {
 							throw new Error(
@@ -302,12 +356,23 @@ export function form(id) {
 						const file = /** @type {HTMLInputElement & { files: FileList }} */ (element).files[0];
 
 						if (file) {
-							input[name] = file;
+							input = set_nested_value(input, name, file);
 						} else {
-							delete input[name];
+							// Remove the property by setting to undefined and clean up
+							const path_parts = name.split(/\.|\[|\]/).filter(Boolean);
+							let current = /** @type {any} */ (input);
+							for (let i = 0; i < path_parts.length - 1; i++) {
+								if (current[path_parts[i]] == null) return;
+								current = current[path_parts[i]];
+							}
+							delete current[path_parts[path_parts.length - 1]];
 						}
 					} else {
-						input[name] = element.value;
+						input = set_nested_value(
+							input,
+							name,
+							element.type === 'checkbox' && !element.checked ? null : element.value
+						);
 					}
 				});
 
@@ -387,18 +452,29 @@ export function form(id) {
 
 		let validate_id = 0;
 
+		// TODO 3.0 remove
+		if (DEV) {
+			throw_on_old_property_access(instance);
+		}
+
 		Object.defineProperties(instance, {
 			buttonProps: {
 				value: button_props
 			},
-			input: {
-				get: () => input,
-				set: (v) => {
-					input = v;
-				}
-			},
-			issues: {
-				get: () => issues
+			fields: {
+				get: () =>
+					create_field_proxy(
+						{},
+						() => input,
+						(path, value) => {
+							if (path.length === 0) {
+								input = value;
+							} else {
+								input = deep_set(input, path.map(String), value);
+							}
+						},
+						() => issues
+					)
 			},
 			result: {
 				get: () => result
@@ -406,11 +482,8 @@ export function form(id) {
 			pending: {
 				get: () => pending_count
 			},
-			field: {
-				value: (/** @type {string} */ name) => name
-			},
 			preflight: {
-				/** @type {RemoteForm<any, any>['preflight']} */
+				/** @type {RemoteForm<T, U>['preflight']} */
 				value: (schema) => {
 					preflight_schema = schema;
 					return instance;
@@ -455,7 +528,7 @@ export function form(id) {
 						}
 					}
 
-					if (!includeUntouched) {
+					if (!includeUntouched && !submitted) {
 						array = array.filter((issue) => {
 							if (issue.path !== undefined) {
 								let path = '';
@@ -475,7 +548,10 @@ export function form(id) {
 						});
 					}
 
-					issues = flatten_issues(array);
+					const is_server_validation = !validated?.issues;
+					const new_issues = flatten_issues(array, is_server_validation);
+
+					issues = is_server_validation ? new_issues : merge_with_server_issues(issues, new_issues);
 				}
 			},
 			enhance: {
diff --git a/packages/kit/src/runtime/form-utils.spec.js b/packages/kit/src/runtime/form-utils.spec.js
new file mode 100644
index 000000000000..0e9c263c33b5
--- /dev/null
+++ b/packages/kit/src/runtime/form-utils.spec.js
@@ -0,0 +1,76 @@
+import { describe, expect, test } from 'vitest';
+import { convert_formdata, split_path } from './form-utils.svelte.js';
+
+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']
+		});
+	});
+
+	test('handles multiple fields at the same nested level', () => {
+		const data = new FormData();
+
+		data.append('user.name.first', 'first');
+		data.append('user.name.last', 'last');
+
+		const converted = convert_formdata(data);
+
+		expect(converted).toEqual({
+			user: {
+				name: {
+					first: 'first',
+					last: 'last'
+				}
+			}
+		});
+	});
+});
diff --git a/packages/kit/src/runtime/form-utils.svelte.js b/packages/kit/src/runtime/form-utils.svelte.js
new file mode 100644
index 000000000000..fef4689a0dd6
--- /dev/null
+++ b/packages/kit/src/runtime/form-utils.svelte.js
@@ -0,0 +1,435 @@
+/** @import { RemoteForm } from '@sveltejs/kit' */
+/** @import { InternalRemoteFormIssue } from 'types' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+import { DEV } from 'esm-env';
+
+/**
+ * Sets a value in a nested object using a path string, not mutating the original object but returning a new object
+ * @param {Record<string, any>} object
+ * @param {string} path_string
+ * @param {any} value
+ */
+export function set_nested_value(object, path_string, value) {
+	if (path_string.startsWith('n:')) {
+		path_string = path_string.slice(2);
+		value = value === '' ? undefined : parseFloat(value);
+	} else if (path_string.startsWith('b:')) {
+		path_string = path_string.slice(2);
+		value = value === 'on';
+	}
+
+	return deep_set(object, split_path(path_string), value);
+}
+
+/**
+ * Convert `FormData` into a POJO
+ * @param {FormData} data
+ */
+export function convert_formdata(data) {
+	/** @type {Record<string, any>} */
+	let result = Object.create(null); // guard against prototype pollution
+
+	for (let key of data.keys()) {
+		const is_array = key.endsWith('[]');
+		/** @type {any[]} */
+		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
+		);
+
+		if (key.startsWith('n:')) {
+			key = key.slice(2);
+			values = values.map((v) => (v === '' ? undefined : parseFloat(/** @type {string} */ (v))));
+		} else if (key.startsWith('b:')) {
+			key = key.slice(2);
+			values = values.map((v) => v === 'on');
+		}
+
+		result = set_nested_value(result, 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);
+}
+
+/**
+ * Sets a value in a nested object using an array of keys.
+ * Does not mutate the original object; returns a new object.
+ * @param {Record<string, any>} object
+ * @param {string[]} keys
+ * @param {any} value
+ */
+export function deep_set(object, keys, value) {
+	const result = Object.assign(Object.create(null), object); // guard against prototype pollution
+	let current = result;
+
+	for (let i = 0; i < keys.length - 1; i += 1) {
+		const key = keys[i];
+		const is_array = /^\d+$/.test(keys[i + 1]);
+		const exists = key in current;
+		const inner = current[key];
+
+		if (exists && is_array !== Array.isArray(inner)) {
+			throw new Error(`Invalid array key ${keys[i + 1]}`);
+		}
+
+		current[key] = is_array
+			? exists
+				? [...inner]
+				: []
+			: // guard against prototype pollution
+				Object.assign(Object.create(null), inner);
+
+		current = current[key];
+	}
+
+	current[keys[keys.length - 1]] = value;
+	return result;
+}
+
+/**
+ * @param {readonly StandardSchemaV1.Issue[]} issues
+ * @param {boolean} [server=false] - Whether these issues come from server validation
+ */
+export function flatten_issues(issues, server = false) {
+	/** @type {Record<string, InternalRemoteFormIssue[]>} */
+	const result = {};
+
+	for (const issue of issues) {
+		/** @type {InternalRemoteFormIssue} */
+		const normalized = { name: '', path: [], message: issue.message, server };
+
+		(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;
+}
+
+/**
+ * Gets a nested value from an object using a path array
+ * @param {Record<string, any>} object
+ * @param {(string | number)[]} path
+ * @returns {any}
+ */
+
+export function deep_get(object, path) {
+	let current = object;
+	for (const key of path) {
+		if (current == null || typeof current !== 'object') {
+			return current;
+		}
+		current = current[key];
+	}
+	return current;
+}
+
+/**
+ * Creates a proxy-based field accessor for form data
+ * @param {any} target - Function or empty POJO
+ * @param {() => Record<string, any>} get_input - Function to get current input data
+ * @param {(path: (string | number)[], value: any) => void} set_input - Function to set input data
+ * @param {() => Record<string, InternalRemoteFormIssue[]>} get_issues - Function to get current issues
+ * @param {(string | number)[]} path - Current access path
+ * @returns {any} Proxy object with name(), value(), and issues() methods
+ */
+export function create_field_proxy(target, get_input, set_input, get_issues, path = []) {
+	return new Proxy(target, {
+		get(target, prop) {
+			if (typeof prop === 'symbol') return target[prop];
+
+			// Handle array access like jobs[0]
+			if (/^\d+$/.test(prop)) {
+				return create_field_proxy({}, get_input, set_input, get_issues, [
+					...path,
+					parseInt(prop, 10)
+				]);
+			}
+
+			const key = build_path_string(path);
+
+			if (prop === 'set') {
+				const set_func = function (/** @type {any} */ newValue) {
+					set_input(path, newValue);
+					return newValue;
+				};
+				return create_field_proxy(set_func, get_input, set_input, get_issues, [...path, prop]);
+			}
+
+			if (prop === 'value') {
+				const value_func = function () {
+					// TODO Ideally we'd create a $derived just above and use it here but we can't because of push_reaction which prevents
+					// changes to deriveds created within an effect to rerun the effect - an argument for
+					// reverting that change in async mode?
+					// TODO we did that in Svelte now; bump Svelte version and use $derived here
+					return deep_get(get_input(), path);
+				};
+				return create_field_proxy(value_func, get_input, set_input, get_issues, [...path, prop]);
+			}
+
+			if (prop === 'issues' || prop === 'allIssues') {
+				const issues_func = () => {
+					const all_issues = get_issues()[key === '' ? '$' : key];
+
+					if (prop === 'allIssues') {
+						return all_issues?.map((issue) => ({
+							message: issue.message
+						}));
+					}
+
+					return all_issues
+						?.filter((issue) => issue.name === key)
+						?.map((issue) => ({
+							message: issue.message
+						}));
+				};
+
+				return create_field_proxy(issues_func, get_input, set_input, get_issues, [...path, prop]);
+			}
+
+			if (prop === 'as') {
+				/**
+				 * @param {string} type
+				 * @param {string} [input_value]
+				 */
+				const as_func = (type, input_value) => {
+					const is_array =
+						type === 'file multiple' ||
+						type === 'select multiple' ||
+						(type === 'checkbox' && typeof input_value === 'string');
+
+					const prefix =
+						type === 'number' || type === 'range'
+							? 'n:'
+							: type === 'checkbox' && !is_array
+								? 'b:'
+								: '';
+
+					// Base properties for all input types
+					/** @type {Record<string, any>} */
+					const base_props = {
+						name: prefix + key + (is_array ? '[]' : ''),
+						get 'aria-invalid'() {
+							const issues = get_issues();
+							return key in issues ? 'true' : undefined;
+						}
+					};
+
+					// Add type attribute only for non-text inputs and non-select elements
+					if (type !== 'text' && type !== 'select' && type !== 'select multiple') {
+						base_props.type = type === 'file multiple' ? 'file' : type;
+					}
+
+					// Handle select inputs
+					if (type === 'select' || type === 'select multiple') {
+						return Object.defineProperties(base_props, {
+							multiple: { value: is_array, enumerable: true },
+							value: {
+								enumerable: true,
+								get() {
+									const input = get_input();
+									return deep_get(input, path);
+								}
+							}
+						});
+					}
+
+					// Handle checkbox inputs
+					if (type === 'checkbox' || type === 'radio') {
+						if (DEV) {
+							if (type === 'radio' && !input_value) {
+								throw new Error('Radio inputs must have a value');
+							}
+
+							if (type === 'checkbox' && is_array && !input_value) {
+								throw new Error('Checkbox array inputs must have a value');
+							}
+						}
+
+						return Object.defineProperties(base_props, {
+							value: { value: input_value ?? 'on', enumerable: true },
+							checked: {
+								enumerable: true,
+								get() {
+									const input = get_input();
+									const value = deep_get(input, path);
+
+									if (type === 'radio') {
+										return value === input_value;
+									}
+
+									if (is_array) {
+										return (value ?? []).includes(input_value);
+									}
+
+									return value;
+								}
+							}
+						});
+					}
+
+					// Handle file inputs
+					if (type === 'file' || type === 'file multiple') {
+						return Object.defineProperties(base_props, {
+							multiple: { value: is_array, enumerable: true },
+							files: {
+								enumerable: true,
+								get() {
+									const input = get_input();
+									const value = deep_get(input, path);
+
+									// Convert File/File[] to FileList-like object
+									if (value instanceof File) {
+										// In browsers, we can create a proper FileList using DataTransfer
+										if (typeof DataTransfer !== 'undefined') {
+											const fileList = new DataTransfer();
+											fileList.items.add(value);
+											return fileList.files;
+										}
+										// Fallback for environments without DataTransfer
+										return { 0: value, length: 1 };
+									}
+
+									if (Array.isArray(value) && value.every((f) => f instanceof File)) {
+										if (typeof DataTransfer !== 'undefined') {
+											const fileList = new DataTransfer();
+											value.forEach((file) => fileList.items.add(file));
+											return fileList.files;
+										}
+										// Fallback for environments without DataTransfer
+										/** @type {any} */
+										const fileListLike = { length: value.length };
+										value.forEach((file, index) => {
+											fileListLike[index] = file;
+										});
+										return fileListLike;
+									}
+
+									return null;
+								}
+							}
+						});
+					}
+
+					// Handle all other input types (text, number, etc.)
+					return Object.defineProperties(base_props, {
+						value: {
+							enumerable: true,
+							get() {
+								const input = get_input();
+								const value = deep_get(input, path);
+
+								return value != null ? String(value) : '';
+							}
+						}
+					});
+				};
+
+				return create_field_proxy(as_func, get_input, set_input, get_issues, [...path, 'as']);
+			}
+
+			// Handle property access (nested fields)
+			return create_field_proxy({}, get_input, set_input, get_issues, [...path, prop]);
+		}
+	});
+}
+
+/**
+ * Builds a path string from an array of path segments
+ * @param {(string | number)[]} path
+ * @returns {string}
+ */
+function build_path_string(path) {
+	let result = '';
+
+	for (const segment of path) {
+		if (typeof segment === 'number') {
+			result += `[${segment}]`;
+		} else {
+			result += result === '' ? segment : '.' + segment;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * @param {RemoteForm<any, any>} instance
+ * @deprecated remove in 3.0
+ */
+export function throw_on_old_property_access(instance) {
+	Object.defineProperty(instance, 'field', {
+		value: (/** @type {string} */ name) => {
+			const new_name = name.endsWith('[]') ? name.slice(0, -2) : name;
+			throw new Error(
+				`\`form.field\` has been removed: Instead of \`<input name={form.field('${name}')} />\` do \`<input {...form.fields.${new_name}.as(type)} />\``
+			);
+		}
+	});
+
+	for (const property of ['input', 'issues']) {
+		Object.defineProperty(instance, property, {
+			get() {
+				const new_name = property === 'issues' ? 'issues' : 'value';
+				return new Proxy(
+					{},
+					{
+						get(_, prop) {
+							const prop_string = typeof prop === 'string' ? prop : String(prop);
+							const old =
+								prop_string.includes('[') || prop_string.includes('.')
+									? `['${prop_string}']`
+									: `.${prop_string}`;
+							const replacement = `.${prop_string}.${new_name}()`;
+							throw new Error(
+								`\`form.${property}\` has been removed: Instead of \`form.${property}${old}\` write \`form.fields${replacement}\``
+							);
+						}
+					}
+				);
+			}
+		});
+	}
+}
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 9e3dab46f16a..a7cc73f08494 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -12,7 +12,6 @@ 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) {
@@ -129,7 +128,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
-					result: stringify(data, { ...transport, File: file_transport }),
+					result: stringify(data, transport),
 					refreshes: data.issues ? {} : await serialize_refreshes(form_client_refreshes)
 				})
 			);
diff --git a/packages/kit/src/runtime/utils.js b/packages/kit/src/runtime/utils.js
index f53f6575d06e..b6e3103ff1ee 100644
--- a/packages/kit/src/runtime/utils.js
+++ b/packages/kit/src/runtime/utils.js
@@ -1,5 +1,3 @@
-/** @import { RemoteFormIssue } from '@sveltejs/kit' */
-/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
@@ -65,124 +63,3 @@ 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[key] ??= is_array ? [] : Object.create(null); // guard against prototype pollution
-		}
-		object = object[key];
-	}
-
-	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 3a7992a81b84..b77a1122bcd8 100644
--- a/packages/kit/src/runtime/utils.spec.js
+++ b/packages/kit/src/runtime/utils.spec.js
@@ -1,11 +1,5 @@
 import { afterEach, assert, beforeEach, describe, expect, test } from 'vitest';
-import {
-	base64_decode,
-	base64_encode,
-	convert_formdata,
-	split_path,
-	text_encoder
-} from './utils.js';
+import { base64_decode, base64_encode, text_encoder } from './utils.js';
 
 const inputs = [
 	'hello world',
@@ -52,77 +46,3 @@ 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']
-		});
-	});
-
-	test('handles multiple fields at the same nested level', () => {
-		const data = new FormData();
-
-		data.append('user.name.first', 'first');
-		data.append('user.name.last', 'last');
-
-		const converted = convert_formdata(data);
-
-		expect(converted).toEqual({
-			user: {
-				name: {
-					first: 'first',
-					last: 'last'
-				}
-			}
-		});
-	});
-});
diff --git a/packages/kit/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index ed0ceed4cf4b..367d9ceda6ff 100644
--- a/packages/kit/src/types/internal.d.ts
+++ b/packages/kit/src/types/internal.d.ts
@@ -21,7 +21,8 @@ import {
 	ServerInit,
 	ClientInit,
 	Transport,
-	HandleValidationError
+	HandleValidationError,
+	RemoteFormIssue
 } from '@sveltejs/kit';
 import {
 	HttpMethod,
@@ -580,6 +581,12 @@ export type RemoteInfo =
 			inputs?: RemotePrerenderInputsGenerator;
 	  };
 
+export interface InternalRemoteFormIssue extends RemoteFormIssue {
+	name: string;
+	path: Array<string | number>;
+	server?: boolean;
+}
+
 export type RecordSpan = <T>(options: {
 	name: string;
 	attributes: Record<string, any>;
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 c285274438ab..33f931628aa1 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
@@ -22,16 +22,16 @@
 <hr />
 
 <form data-unscoped {...set_message}>
-	{#if set_message.issues.message}
-		<p>{set_message.issues.message[0].message}</p>
+	{#if set_message.fields.message.issues()}
+		<p>{set_message.fields.message.issues()[0].message}</p>
 	{/if}
 
-	<input name={set_message.field('message')} value={set_message.input.message} />
+	<input {...set_message.fields.message.as('text')} />
 	<button>set message</button>
 	<button {...set_reverse_message.buttonProps}>set reverse message</button>
 </form>
 
-<p>set_message.input.message: {set_message.input.message}</p>
+<p>set_message.input.message: {set_message.fields.message.value()}</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>
@@ -39,15 +39,15 @@
 <hr />
 
 <form data-scoped {...scoped}>
-	{#if scoped.issues.message}
-		<p>{scoped.issues.message[0].message}</p>
+	{#if scoped.fields.message.issues()}
+		<p>{scoped.fields.message.issues()[0].message}</p>
 	{/if}
 
-	<input name={scoped.field('message')} value={scoped.input.message} />
+	<input {...scoped.fields.message.as('text')} />
 	<button>set scoped message</button>
 </form>
 
-<p>scoped.input.message: {scoped.input.message}</p>
+<p>scoped.input.message: {scoped.fields.message.value()}</p>
 <p>scoped.pending: {scoped.pending}</p>
 <p>scoped.result: {scoped.result}</p>
 
@@ -59,15 +59,15 @@
 		await submit().updates(get_message().withOverride(() => data.message + ' (override)'));
 	})}
 >
-	{#if enhanced.issues.message}
-		<p>{enhanced.issues.message[0].message}</p>
+	{#if enhanced.fields.message.issues()}
+		<p>{enhanced.fields.message.issues()[0].message}</p>
 	{/if}
 
-	<input name={enhanced.field('message')} value={enhanced.input.message} />
+	<input {...enhanced.fields.message.as('text')} />
 	<button><span>set enhanced message</span></button>
 </form>
 
-<p>enhanced.input.message: {enhanced.input.message}</p>
+<p>enhanced.input.message: {enhanced.fields.message.value()}</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/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/preflight/+page.svelte
index d799742bd29c..38d1248d4515 100644
--- 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
@@ -7,12 +7,7 @@
 	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')
-		)
+		number: v.pipe(v.number(), v.maxValue(20, 'too big'))
 	});
 </script>
 
@@ -26,15 +21,15 @@
 <hr />
 
 <form data-default {...set_number.preflight(schema)}>
-	{#if set_number.issues.number}
-		<p>{set_number.issues.number[0].message}</p>
-	{/if}
+	{#each set_number.fields.number.issues() as issue}
+		<p>{issue.message}</p>
+	{/each}
 
-	<input type="number" name={set_number.field('number')} value={set_number.input.number} />
+	<input {...set_number.fields.number.as('number')} />
 	<button>set number</button>
 </form>
 
-<p>set_number.input.number: {set_number.input.number}</p>
+<p>set_number.input.number: {set_number.fields.number.value()}</p>
 <p>set_number.pending: {set_number.pending}</p>
 <p>set_number.result: {set_number.result}</p>
 
@@ -46,14 +41,14 @@
 		await submit();
 	})}
 >
-	{#if enhanced.issues.number}
-		<p>{enhanced.issues.number[0].message}</p>
-	{/if}
+	{#each enhanced.fields.number.issues() as issue}
+		<p>{issue.message}</p>
+	{/each}
 
-	<input type="number" name={enhanced.field('number')} value={enhanced.input.number} />
+	<input {...enhanced.fields.number.as('number')} />
 	<button><span>set enhanced number</span></button>
 </form>
 
-<p>enhanced.input.number: {enhanced.input.number}</p>
+<p>enhanced.input.number: {enhanced.fields.number.value()}</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
index e4a1f2378587..79bf75d226bc 100644
--- 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
@@ -9,12 +9,7 @@ export const get_number = query(() => {
 
 export const set_number = form(
 	v.object({
-		number: v.pipe(
-			v.string(),
-			v.regex(/^\d+$/),
-			v.transform((n) => +n),
-			v.minValue(10, 'too small')
-		)
+		number: v.pipe(v.number(), v.minValue(10, 'too small'))
 	}),
 	async (data) => {
 		number = data.number;
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/submitter/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/submitter/+page.svelte
index f51a477890c6..5b76ef3a1f2e 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/submitter/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/submitter/+page.svelte
@@ -3,7 +3,7 @@
 </script>
 
 <form {...my_form}>
-	<button name={my_form.field('submitter')} value="hello">submit</button>
+	<button {...my_form.fields.submitter.as('submit')} value="hello">submit</button>
 </form>
 
 <p id="result">{my_form.result}</p>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/submitter/form.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/submitter/form.remote.ts
index b06d4eafeddb..08c7f22dcf00 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/submitter/form.remote.ts
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/submitter/form.remote.ts
@@ -6,6 +6,7 @@ export const my_form = form(
 		submitter: v.string()
 	}),
 	async (data) => {
+		console.log('!!!', data);
 		return data.submitter;
 	}
 );
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
index 620a7d63baef..6c8a0aff7e4f 100644
--- 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
@@ -3,23 +3,13 @@
 </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}
-	/>
+	<input {...register.fields.username.as('text')} />
+	<input {...register.fields._password.as('password')} />
 
 	<button>submit</button>
 </form>
 
-<pre>{JSON.stringify(register.issues, null, '  ')}</pre>
+<pre>{JSON.stringify(register.fields.issues(), null, '  ')}</pre>
 
 <style>
 	[aria-invalid='true'] {
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
index 0539e5f92dc1..25ccc5803c5b 100644
--- 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
@@ -8,28 +8,28 @@
 		button: v.literal('submitter')
 	});
 	let submitter;
-	$inspect(my_form.issues);
+	$inspect(my_form.fields.allIssues());
 </script>
 
 <form {...my_form.preflight(schema)} oninput={() => my_form.validate()}>
-	{#if my_form.issues.foo}
-		<p>{my_form.issues.foo[0].message}</p>
-	{/if}
+	{#each my_form.fields.foo.issues() as issue}
+		<p>{issue.message}</p>
+	{/each}
 
-	<input name={my_form.field('foo')} />
+	<input {...my_form.fields.foo.as('text')} />
 
-	{#if my_form.issues.bar}
-		<p>{my_form.issues.bar[0].message}</p>
-	{/if}
+	{#each my_form.fields.bar.issues() as issue}
+		<p>{issue.message}</p>
+	{/each}
 
-	<input name={my_form.field('bar')} />
+	<input {...my_form.fields.bar.as('text')} />
 
-	<button bind:this={submitter} name={my_form.field('button')} value="incorrect_value">
+	<button bind:this={submitter} {...my_form.fields.button.as('submit')} value="incorrect_value">
 		submit
 	</button>
-	{#if my_form.issues.button}
-		<p>{my_form.issues.button[0].message}</p>
-	{/if}
+	{#each my_form.fields.button.issues() as issue}
+		<p>{issue.message}</p>
+	{/each}
 </form>
 <button
 	id="trigger-validate"
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/value/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/value/+page.svelte
new file mode 100644
index 000000000000..2430477a2efe
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/value/+page.svelte
@@ -0,0 +1,46 @@
+<script>
+	import { values } from './value.remote.js';
+</script>
+
+<h1>Remote Form Value Test</h1>
+
+<form {...values}>
+	<label>
+		Leaf:
+		<input {...values.fields.leaf.as('text')} />
+	</label>
+
+	<label>
+		Object Leaf:
+		<input {...values.fields.object.leaf.as('text')} />
+	</label>
+
+	<label>
+		Object Array 0:
+		<input {...values.fields.object.array[0].as('text')} />
+	</label>
+	<label>
+		Object Array 1:
+		<input {...values.fields.object.array[1].as('text')} />
+	</label>
+
+	<label>
+		Array 0 Leaf:
+		<input {...values.fields.array[0].leaf.as('text')} />
+	</label>
+	<label>
+		Array 1 Leaf:
+		<input {...values.fields.array[1].leaf.as('text')} />
+	</label>
+
+	<button>Submit</button>
+</form>
+
+<h2>Full Form Value</h2>
+<pre id="full-value">{JSON.stringify(values.fields.value(), null, '  ')}</pre>
+
+<h2>Nested Object Value</h2>
+<pre id="object-value">{JSON.stringify(values.fields.object.value(), null, '  ')}</pre>
+
+<h2>Array Value</h2>
+<pre id="array-value">{JSON.stringify(values.fields.array.value(), null, '  ')}</pre>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/value/value.remote.ts b/packages/kit/test/apps/basics/src/routes/remote/form/value/value.remote.ts
new file mode 100644
index 000000000000..fbe2734f4be2
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/value/value.remote.ts
@@ -0,0 +1,20 @@
+import { form } from '$app/server';
+import * as v from 'valibot';
+
+export const values = form(
+	v.object({
+		leaf: v.string(),
+		object: v.object({
+			leaf: v.string(),
+			array: v.array(v.string())
+		}),
+		array: v.array(
+			v.object({
+				leaf: v.string()
+			})
+		)
+	}),
+	async (data) => {
+		return { success: true, data };
+	}
+);
diff --git a/packages/kit/test/apps/basics/test/test.js b/packages/kit/test/apps/basics/test/test.js
index 63af6264230a..c0d43a0d7bd3 100644
--- a/packages/kit/test/apps/basics/test/test.js
+++ b/packages/kit/test/apps/basics/test/test.js
@@ -1866,6 +1866,92 @@ test.describe('remote functions', () => {
 		await clicknav('[href="/remote/prerender/functions-only"]');
 		await expect(page.locator('#prerendered-data')).toHaveText('a c 中文 yes');
 	});
+
+	test('form.fields.value() returns correct nested object structure', async ({
+		page,
+		javaScriptEnabled
+	}) => {
+		if (!javaScriptEnabled) return;
+
+		await page.goto('/remote/form/value');
+
+		// Initially should be empty object or undefined values
+		const initialValue = await page.locator('#full-value').textContent();
+		expect(JSON.parse(initialValue)).toEqual({});
+
+		// Fill leaf field
+		await page.fill('input[name="leaf"]', 'leaf-value');
+		const afterLeaf = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterLeaf)).toEqual({
+			leaf: 'leaf-value'
+		});
+
+		// Fill object.leaf field
+		await page.fill('input[name="object.leaf"]', 'object-leaf-value');
+		const afterObjectLeaf = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterObjectLeaf)).toEqual({
+			leaf: 'leaf-value',
+			object: {
+				leaf: 'object-leaf-value'
+			}
+		});
+
+		// Fill object.array fields
+		await page.fill('input[name="object.array[0]"]', 'array-item-1');
+		const afterArrayItem1 = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterArrayItem1)).toEqual({
+			leaf: 'leaf-value',
+			object: {
+				leaf: 'object-leaf-value',
+				array: ['array-item-1']
+			}
+		});
+
+		await page.fill('input[name="object.array[1]"]', 'array-item-2');
+		const afterArrayItem2 = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterArrayItem2)).toEqual({
+			leaf: 'leaf-value',
+			object: {
+				leaf: 'object-leaf-value',
+				array: ['array-item-1', 'array-item-2']
+			}
+		});
+
+		// Fill array[0].leaf field
+		await page.fill('input[name="array[0].leaf"]', 'array-0-leaf');
+		const afterArray0 = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterArray0)).toEqual({
+			leaf: 'leaf-value',
+			object: {
+				leaf: 'object-leaf-value',
+				array: ['array-item-1', 'array-item-2']
+			},
+			array: [{ leaf: 'array-0-leaf' }]
+		});
+
+		// Fill array[1].leaf field
+		await page.fill('input[name="array[1].leaf"]', 'array-1-leaf');
+		const afterArray1 = await page.locator('#full-value').textContent();
+		expect(JSON.parse(afterArray1)).toEqual({
+			leaf: 'leaf-value',
+			object: {
+				leaf: 'object-leaf-value',
+				array: ['array-item-1', 'array-item-2']
+			},
+			array: [{ leaf: 'array-0-leaf' }, { leaf: 'array-1-leaf' }]
+		});
+
+		// Test nested object value access
+		const objectValue = await page.locator('#object-value').textContent();
+		expect(JSON.parse(objectValue)).toEqual({
+			leaf: 'object-leaf-value',
+			array: ['array-item-1', 'array-item-2']
+		});
+
+		// Test array value access
+		const arrayValue = await page.locator('#array-value').textContent();
+		expect(JSON.parse(arrayValue)).toEqual([{ leaf: 'array-0-leaf' }, { leaf: 'array-1-leaf' }]);
+	});
 });
 
 test.describe('params prop', () => {
diff --git a/packages/kit/test/types/remote.test.ts b/packages/kit/test/types/remote.test.ts
index be5b94ee103d..7519dc17a2ce 100644
--- a/packages/kit/test/types/remote.test.ts
+++ b/packages/kit/test/types/remote.test.ts
@@ -190,20 +190,18 @@ function form_tests() {
 			return { success: true };
 		}
 	);
-	f2.field('a');
-	f2.field('nested.prop');
 	// @ts-expect-error
-	f2.field('nonexistent');
-	f2.issues!.a;
-	f2.issues!['nested.prop'];
+	f2.fields.name();
+	f2.fields.a.issues();
+	f2.fields.nested.prop.issues();
 	// @ts-expect-error
-	f2.issues!.nonexistent;
-	f2.input!.a = '';
-	f2.input!['nested.prop'] = '';
+	f2.fields.nonexistent.issues();
+	f2.fields.a.value();
+	f2.fields.nested.prop.value();
 	// @ts-expect-error
-	f2.input!.nonexistent = '';
+	f2.fields.nonexistent.value();
 	// @ts-expect-error
-	f2.input!.a = 123;
+	f2.fields.array[0].array.name();
 
 	// all schema properties optional
 	const f3 = form(
@@ -222,20 +220,14 @@ function form_tests() {
 			return { success: true };
 		}
 	);
-	f3.field('a');
-	f3.field('nested.prop');
 	// @ts-expect-error
-	f3.field('nonexistent');
-	f3.issues!.a;
-	f3.issues!['nested.prop'];
+	f3.fields.name();
+	f3.fields.a.issues();
+	f3.fields.a.value();
+	f3.fields.nested.prop.issues();
+	f3.fields.nested.prop.value();
 	// @ts-expect-error
-	f3.issues!.nonexistent;
-	f3.input!.a = '';
-	f3.input!['nested.prop'] = '';
-	// @ts-expect-error
-	f3.input!.nonexistent = '';
-	// @ts-expect-error
-	f3.input!.a = 123;
+	f3.fields.nonexistent.name();
 
 	// index signature schema
 	const f4 = form(null as any as StandardSchemaV1<Record<string, any>>, (data) => {
@@ -243,14 +235,12 @@ function form_tests() {
 		data.nested?.prop === '';
 		return { success: true };
 	});
-	f4.field('a');
-	f4.field('nested.prop');
-	f4.issues!.a;
-	f4.issues!['nested.prop'];
-	f4.input!.a = '';
-	f4.input!['nested.prop'] = '';
 	// @ts-expect-error
-	f4.input!.a = 123;
+	f4.fields.name();
+	f4.fields.a.issues();
+	f4.fields.a.value();
+	f4.fields.nested.prop.issues();
+	f4.fields.nested.prop.value();
 
 	// schema with union types
 	const f5 = form(null as any as StandardSchemaV1<{ foo: 'a' | 'b'; bar: 'c' | 'd' }>, (data) => {
@@ -260,16 +250,16 @@ function form_tests() {
 		data.foo === 'e';
 		return { success: true };
 	});
-	f5.field('foo');
 	// @ts-expect-error
-	f5.field('nonexistent');
-	f5.issues!.foo;
-	f5.issues!.bar;
+	f5.fields.name();
+	f5.fields.foo.issues();
+	f5.fields.bar.issues();
+	f5.fields.foo.value();
+	f5.fields.bar.value() === 'c';
 	// @ts-expect-error
-	f5.issues!.nonexistent;
-	f5.input!.foo = 'a';
+	f5.fields.foo.value() === 'e';
 	// @ts-expect-error
-	f5.input!.foo = 123;
+	f5.fields.nonexistent.name();
 
 	// schema with arrays
 	const f6 = form(
@@ -282,30 +272,43 @@ function form_tests() {
 			return { success: true };
 		}
 	);
-	f6.field('array[0].prop');
-	f6.field('array[0].array[]');
+	// @ts-expect-error
+	f6.fields.name();
 	// @ts-expect-error
 	f6.field('array[0].array');
-	f6.issues!.array;
-	f6.issues!['array[0].prop'];
-	f6.issues!['array[0].array'];
+	f6.fields.array.issues();
+	f6.fields.array[0].prop.issues();
+	f6.fields.array[0].array.issues();
 	// @ts-expect-error
-	f6.issues!['array[0].array[]'];
+	f6.fields.nonexistent.issues();
+	f6.fields.array[0].prop.value();
+	f6.fields.array[0].array.value();
 	// @ts-expect-error
-	f6.issues!.nonexistent;
-	f6.input!['array[0].prop'] = '';
-	f6.input!['array[0].array'] = [''];
+	f6.fields.array[0].array.name();
+
+	// any
+	const f7 = form(null as any, (data) => {
+		data.a === '';
+		data.nested?.prop === '';
+		return { success: true };
+	});
 	// @ts-expect-error
-	f6.input!['array[0].array'] = '';
+	f7.fields.name();
+	f7.fields.a.issues();
+	f7.fields.a.value();
+	f7.fields.nested.prop.issues();
+	f7.fields.nested.prop.value();
+
+	// no schema
+	const f8 = form(() => {});
 	// @ts-expect-error
-	f6.input!['array[0].array[]'] = [''];
+	f8.fields.x;
 	// @ts-expect-error
 	f6.input!['array[0].prop'] = 123;
 
 	// doesn't use data
-	// eslint-disable-next-line @typescript-eslint/require-await --- we are testing that the async function does not cause `result` to be typed as a Promise
-	const f7 = form(async () => ({ success: true }));
-	f7.result?.success === true;
+	const f9 = form(() => Promise.resolve({ success: true }));
+	f9.result?.success === true;
 }
 form_tests();
 
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 7a5a4afc2449..a5f31c0cfb08 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -1789,78 +1789,127 @@ declare module '@sveltejs/kit' {
 	// If T is unknown or has an index signature, the types below will recurse indefinitely and create giant unions that TS can't handle
 	type WillRecurseIndefinitely<T> = unknown extends T ? true : string extends keyof 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> = T extends string | number | boolean | null | undefined
-		? { [P in Prefix]: 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 }
-					: {
-							// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-							[K in keyof Required<T>]: FlattenInput<
-								T[K],
-								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-							>;
-						}[keyof T];
-
-	type FlattenIssues<T, Prefix extends string> = T extends
-		| string
-		| number
-		| boolean
-		| null
-		| undefined
-		? { [P in Prefix]: RemoteFormIssue[] }
-		: 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[] }
-					: {
-							// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-							[K in keyof Required<T>]: FlattenIssues<
-								T[K],
-								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-							>;
-						}[keyof T];
-
-	type FlattenKeys<T, Prefix extends string> = T extends string | number | boolean | null | undefined
-		? { [P in Prefix]: 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 }
-					: {
-							// Required<T> is crucial here to avoid an undefined type to sneak into the union, which would turn the intersection into never
-							[K in keyof Required<T>]: FlattenKeys<
-								T[K],
-								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
-							>;
-						}[keyof T];
+	// Input type mappings for form fields
+	type InputTypeMap = {
+		text: string;
+		email: string;
+		password: string;
+		url: string;
+		tel: string;
+		search: string;
+		number: number;
+		range: number;
+		date: string;
+		'datetime-local': string;
+		time: string;
+		month: string;
+		week: string;
+		color: string;
+		checkbox: boolean | string[];
+		radio: string;
+		file: File;
+		hidden: string;
+		submit: string;
+		button: string;
+		reset: string;
+		image: string;
+		select: string;
+		'select multiple': string[];
+		'file multiple': File[];
+	};
+
+	// Valid input types for a given value type
+	export type RemoteFormFieldType<T> = {
+		[K in keyof InputTypeMap]: T extends InputTypeMap[K] ? K : never;
+	}[keyof InputTypeMap];
+
+	// Input element properties based on type
+	type InputElementProps<T extends keyof InputTypeMap> = T extends 'checkbox' | 'radio'
+		? {
+				type: T;
+				'aria-invalid': boolean | 'false' | 'true' | undefined;
+				get checked(): boolean;
+				set checked(value: boolean);
+			}
+		: T extends 'file'
+			? {
+					type: 'file';
+					'aria-invalid': boolean | 'false' | 'true' | undefined;
+					get files(): FileList | null;
+					set files(v: FileList | null);
+				}
+			: {
+					type: T;
+					'aria-invalid': boolean | 'false' | 'true' | undefined;
+					get value(): string | number;
+					set value(v: string | number);
+				};
+
+	type RemoteFormFieldMethods<T> = {
+		/** The values that will be submitted */
+		value(): T;
+		/** Set the values that will be submitted */
+		set(input: T): T;
+		/** Validation issues, if any */
+		issues(): RemoteFormIssue[] | undefined;
+	};
+
+	export type RemoteFormFieldValue = string | string[] | number | boolean | File | File[];
+
+	type AsArgs<Type extends keyof InputTypeMap, Value> = Type extends 'checkbox'
+		? Value extends string[]
+			? [type: 'checkbox', value: Value[number] | (string & {})]
+			: [type: Type]
+		: Type extends 'radio'
+			? [type: 'radio', value: Value | (string & {})]
+			: [type: Type];
+
+	/**
+	 * Form field accessor type that provides name(), value(), and issues() methods
+	 */
+	export type RemoteFormField<Value extends RemoteFormFieldValue> = RemoteFormFieldMethods<Value> & {
+		/**
+		 * Returns an object that can be spread onto an input element with the correct type attribute,
+		 * aria-invalid attribute if the field is invalid, and appropriate value/checked property getters/setters.
+		 * @example
+		 * ```svelte
+		 * <input {...myForm.fields.myString.as('text')} />
+		 * <input {...myForm.fields.myNumber.as('number')} />
+		 * <input {...myForm.fields.myBoolean.as('checkbox')} />
+		 * ```
+		 */
+		as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+	};
+
+	type RemoteFormFieldContainer<Value> = RemoteFormFieldMethods<Value> & {
+		/** Validation issues belonging to this or any of the fields that belong to it, if any */
+		allIssues(): RemoteFormIssue[] | undefined;
+	};
+
+	/**
+	 * Recursive type to build form fields structure with proxy access
+	 */
+	type RemoteFormFields<T> =
+		WillRecurseIndefinitely<T> extends true
+			? RecursiveFormFields
+			: NonNullable<T> extends string | number | boolean | File
+				? RemoteFormField<NonNullable<T>>
+				: T extends string[] | File[]
+					? RemoteFormField<T> & { [K in number]: RemoteFormField<T[number]> }
+					: T extends Array<infer U>
+						? RemoteFormFieldContainer<T> & { [K in number]: RemoteFormFields<U> }
+						: RemoteFormFieldContainer<T> & { [K in keyof T]-?: RemoteFormFields<T[K]> };
+
+	// By breaking this out into its own type, we avoid the TS recursion depth limit
+	type RecursiveFormFields = RemoteFormField<any> & { [key: string]: RecursiveFormFields };
+
+	type MaybeArray<T> = T | T[];
 
 	export interface RemoteFormInput {
-		[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+		[key: string]: MaybeArray<string | number | boolean | File | RemoteFormInput>;
 	}
 
 	export interface RemoteFormIssue {
-		name: string;
-		path: Array<string | number>;
 		message: string;
 	}
 
@@ -1902,14 +1951,6 @@ declare module '@sveltejs/kit' {
 		 * ```
 		 */
 		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 */
@@ -1922,10 +1963,8 @@ declare module '@sveltejs/kit' {
 		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, ''>>;
+		/** Access form fields using object notation */
+		fields: Input extends void ? never : RemoteFormFields<Input>;
 		/** Spread this onto a `<button>` or `<input type="submit">` */
 		buttonProps: {
 			type: 'submit';