diff --git a/.changeset/all-symbols-hammer.md b/.changeset/all-symbols-hammer.md
new file mode 100644
index 000000000000..0e9d0d649e89
--- /dev/null
+++ b/.changeset/all-symbols-hammer.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': minor
+---
+
+feat: remote form factory
diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index bcbb3e9c1570..b0c6f89bf753 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -292,7 +292,7 @@ export const createPost = form(
 
 <h1>Create a new post</h1>
 
-<form {...createPost}>
+<form {...createPost()}>
 	<!-- form content goes here -->
 
 	<button>Publish!</button>
@@ -308,15 +308,15 @@ As with `query`, if the callback uses the submitted `data`, it should be [valida
 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}>
+<form {...createPost()}>
 	<label>
 		<h2>Title</h2>
-		+++<input {...createPost.fields.title.as('text')} />+++
+		+++<input {...createPost().fields.title.as('text')} />+++
 	</label>
 
 	<label>
 		<h2>Write your post</h2>
-		+++<textarea {...createPost.fields.content.as('text')}></textarea>+++
+		+++<textarea {...createPost().fields.content.as('text')}></textarea>+++
 	</label>
 
 	<button>Publish!</button>
@@ -353,10 +353,10 @@ export const createProfile = form(datingProfile, (data) => { /* ... */ });
 <script>
 	import { createProfile } from './data.remote';
 
-	const { name, photo, info, attributes } = createProfile.fields;
+	const { name, photo, info, attributes } = createProfile().fields;
 </script>
 
-<form {...createProfile} enctype="multipart/form-data">
+<form {...createProfile()} enctype="multipart/form-data">
 	<label>
 		<input {...name.as('text')} /> Name
 	</label>
@@ -403,12 +403,12 @@ export const survey = form(
 ```
 
 ```svelte
-<form {...survey}>
+<form {...survey()}>
 	<h2>Which operating system do you use?</h2>
 
 	{#each ['windows', 'mac', 'linux'] as os}
 		<label>
-			<input {...survey.fields.operatingSystem.as('radio', os)}>
+			<input {...survey().fields.operatingSystem.as('radio', os)}>
 			{os}
 		</label>
 	{/each}
@@ -417,7 +417,7 @@ export const survey = form(
 
 	{#each ['html', 'css', 'js'] as language}
 		<label>
-			<input {...survey.fields.languages.as('checkbox', language)}>
+			<input {...survey().fields.languages.as('checkbox', language)}>
 			{language}
 		</label>
 	{/each}
@@ -429,10 +429,10 @@ export const survey = form(
 Alternatively, you could use `select` and `select multiple`:
 
 ```svelte
-<form {...survey}>
+<form {...survey()}>
 	<h2>Which operating system do you use?</h2>
 
-	<select {...survey.fields.operatingSystem.as('select')}>
+	<select {...survey().fields.operatingSystem.as('select')}>
 		<option>windows</option>
 		<option>mac</option>
 		<option>linux</option>
@@ -440,7 +440,7 @@ Alternatively, you could use `select` and `select multiple`:
 
 	<h2>Which languages do you write code in?</h2>
 
-	<select {...survey.fields.languages.as('select multiple')}>
+	<select {...survey().fields.languages.as('select multiple')}>
 		<option>html</option>
 		<option>css</option>
 		<option>js</option>
@@ -494,25 +494,25 @@ The `invalid` function works as both a function and a proxy:
 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}>
+<form {...createPost()}>
 	<label>
 		<h2>Title</h2>
 
-+++		{#each createPost.fields.title.issues() as issue}
++++		{#each createPost().fields.title.issues() as issue}
 			<p class="issue">{issue.message}</p>
 		{/each}+++
 
-		<input {...createPost.fields.title.as('text')} />
+		<input {...createPost().fields.title.as('text')} />
 	</label>
 
 	<label>
 		<h2>Write your post</h2>
 
-+++		{#each createPost.fields.content.issues() as issue}
++++		{#each createPost().fields.content.issues() as issue}
 			<p class="issue">{issue.message}</p>
 		{/each}+++
 
-		<textarea {...createPost.fields.content.as('text')}></textarea>
+		<textarea {...createPost().fields.content.as('text')}></textarea>
 	</label>
 
 	<button>Publish!</button>
@@ -522,7 +522,7 @@ If the submitted data doesn't pass the schema, the callback will not run. Instea
 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 {...createPost()} oninput={() => form.validate()}>
 	<!-- -->
 </form>
 ```
@@ -540,11 +540,15 @@ For client-side validation, you can specify a _preflight_ schema which will popu
 		title: v.pipe(v.string(), v.nonEmpty()),
 		content: v.pipe(v.string(), v.nonEmpty())
 	});
+
+	const form = createPost(+++{
+		preflight: schema
+	}+++)
 </script>
 
 <h1>Create a new post</h1>
 
-<form {...+++createPost.preflight(schema)+++}>
+<form {...form}>
 	<!-- -->
 </form>
 ```
@@ -554,7 +558,7 @@ For client-side validation, you can specify a _preflight_ schema which will popu
 To get a list of _all_ issues, rather than just those belonging to a single field, you can use the `fields.allIssues()` method:
 
 ```svelte
-{#each createPost.fields.allIssues() as issue}
+{#each createPost().fields.allIssues() as issue}
 	<p>{issue.message}</p>
 {/each}
 ```
@@ -564,17 +568,17 @@ To get a list of _all_ issues, rather than just those belonging to a single fiel
 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}>
+<form {...createPost()}>
 	<!-- -->
 </form>
 
 <div class="preview">
-	<h2>{createPost.fields.title.value()}</h2>
-	<div>{@html render(createPost.fields.content.value())}</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.
+Alternatively, `createPost().fields.value()` would return a `{ title, content }` object.
 
 You can update a field (or a collection of fields) via the `set(...)` method:
 
@@ -583,14 +587,14 @@ You can update a field (or a collection of fields) via the `set(...)` method:
 	import { createPost } from '../data.remote';
 
 	// this...
-	createPost.fields.set({
+	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');
+	createPost().fields.title.set('My new blog post');
+	createPost().fields.content.set('Lorem ipsum dolor sit amet');
 </script>
 ```
 
@@ -601,15 +605,15 @@ In the case of a non-progressively-enhanced form submission (i.e. where JavaScri
 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}>
+<form {...register()}>
 	<label>
 		Username
-		<input {...register.fields.username.as('text')} />
+		<input {...register().fields.username.as('text')} />
 	</label>
 
 	<label>
 		Password
-		<input +++{...register.fields._password.as('password')}+++ />
+		<input +++{...register().fields._password.as('password')}+++ />
 	</label>
 
 	<button>Sign up!</button>
@@ -668,7 +672,7 @@ The second is to drive the single-flight mutation from the client, which we'll s
 
 ### Returns and redirects
 
-The example above uses [`redirect(...)`](@sveltejs-kit#redirect), which sends the user to the newly created page. Alternatively, the callback could return data, in which case it would be available as `createPost.result`:
+The example above uses [`redirect(...)`](@sveltejs-kit#redirect), which sends the user to the newly created page. Alternatively, the callback could return data, in which case it would be available as `createPost().result`:
 
 ```ts
 /// file: src/routes/blog/data.remote.js
@@ -717,11 +721,11 @@ export const createPost = form(
 
 <h1>Create a new post</h1>
 
-<form {...createPost}>
+<form {...createPost()}>
 	<!-- -->
 </form>
 
-{#if createPost.result?.success}
+{#if createPost().result?.success}
 	<p>Successfully published!</p>
 {/if}
 ```
@@ -745,7 +749,7 @@ We can customize what happens when the form is submitted with the `enhance` meth
 
 <h1>Create a new post</h1>
 
-<form {...createPost.enhance(async ({ form, data, submit }) => {
+<form {...createPost().enhance(async ({ form, data, submit }) => {
 	try {
 		await submit();
 		form.reset();
@@ -798,7 +802,7 @@ The override will be applied immediately, and released when the submission compl
 
 ### Multiple instances of a form
 
-Some forms may be repeated as part of a list. In this case you can create separate instances of a form function via `for(id)` to achieve isolation.
+Some forms may be repeated as part of a list. In this case you can create separate instances of a form function via `form(id)` to achieve isolation.
 
 ```svelte
 <!--- file: src/routes/todos/+page.svelte --->
@@ -809,14 +813,46 @@ Some forms may be repeated as part of a list. In this case you can create separa
 <h1>Todos</h1>
 
 {#each await getTodos() as todo}
-	{@const modify = modifyTodo.for(todo.id)}
+	{@const modify = modifyTodo(todo.id)}
 	<form {...modify}>
 		<!-- -->
-		<button disabled={!!modify.pending}>save changes</button>
+		<button disabled={!!modify.pending}>Save Changes</button>
 	</form>
 {/each}
 ```
 
+### Initial form data
+
+There are times when you want a form to be pre-filled with certain values when it first renders. For example, you might want to populate a form with values fetched from the server or set default values for a new data entry.
+
+You can do this by passing the `initialData` option when creating a form instance. This will set the initial state of the form fields, both for their values and for client-side validation.
+
+Here's an example of how to set initial form data using `initialData`:
+
+```svelte
+<!--- file: src/routes/edit-post/[postId]/+page.svelte --->
+<script>
+	import { getPost, editPost } from '../data.remote';
+
+	const { params } = $props();
+
+	// Fetch the data to pre-fill the form
+	const data = $derived(await getPost(params.postId));
+
+	// Pass initialData when creating the form instance
+	const form = $derived(editPost({
+		initialData: data
+	}));
+</script>
+
+<form {...form}>
+	<!-- Render your form fields here, which will use the initial values from `data` -->
+	<button disabled={!!form.pending}>Save Changes</button>
+</form>
+```
+
+You can also pass a partial object to `initialData` if you only want to set values for some fields. If `initialData` is omitted, the fields will be empty by default.
+
 ### buttonProps
 
 By default, submitting a form will send a request to the URL indicated by the `<form>` element's [`action`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/form#attributes_for_form_submission) attribute, which in the case of a remote function is a property on the form object generated by SvelteKit.
@@ -831,19 +867,19 @@ This attribute exists on the `buttonProps` property of a form object:
 	import { login, register } from '$lib/auth';
 </script>
 
-<form {...login}>
+<form {...login()}>
 	<label>
 		Your username
-		<input {...login.fields.username.as('text')} />
+		<input {...login().fields.username.as('text')} />
 	</label>
 
 	<label>
 		Your password
-		<input {...login.fields._password.as('password')} />
+		<input {...login().fields._password.as('password')} />
 	</label>
 
 	<button>login</button>
-	<button {...register.buttonProps}>register</button>
+	<button {...register().buttonProps}>register</button>
 </form>
 ```
 
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 1ef333310326..5edd130e0b80 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -15,7 +15,9 @@ import {
 	PrerenderUnseenRoutesHandlerValue,
 	PrerenderOption,
 	RequestOptions,
-	RouteSegment
+	RouteSegment,
+	DeepPartial,
+	ExtractId
 } from '../types/private.js';
 import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
 import { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
@@ -1969,14 +1971,6 @@ export interface RemoteFormAllIssue extends RemoteFormIssue {
 	path: Array<string | number>;
 }
 
-// If the schema specifies `id` as a string or number, ensure that `for(...)`
-// only accepts that type. Otherwise, accept `string | number`
-type ExtractId<Input> = Input extends { id: infer Id }
-	? Id extends string | number
-		? Id
-		: string | number
-	: string | number;
-
 /**
  * Recursively maps an input type to a structure where each field can create a validation issue.
  * This mirrors the runtime behavior of the `invalid` proxy passed to form handlers.
@@ -2007,9 +2001,27 @@ type InvalidField<T> =
 export type Invalid<Input = any> = ((...issues: Array<string | StandardSchemaV1.Issue>) => never) &
 	InvalidField<Input>;
 
+export type RemoteFormFactoryOptions<Input extends RemoteFormInput | void> = {
+	/** Optional key to create a scoped instance */
+	key?: ExtractId<Input>;
+	/** Client-side preflight schema for validation before submit */
+	preflight?: StandardSchemaV1<Input, any>;
+	/** Initial input values for the form fields */
+	initialData?: DeepPartial<Input>;
+	/** Reset the form values after successful submission, for non-enhanced forms (default: true) */
+	resetAfterSuccess?: boolean;
+};
+
 /**
  * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  */
+export type RemoteFormFactory<Input extends RemoteFormInput | void, Output> = (
+	keyOrOptions?: ExtractId<Input> | RemoteFormFactoryOptions<Input>
+) => RemoteForm<Input, Output>;
+
+/**
+ * The remote form instance created by the form factory function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+ */
 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;
@@ -2030,23 +2042,6 @@ export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
 		action: string;
 		[attachment: symbol]: (node: HTMLFormElement) => void;
 	};
-	/**
-	 * Create an instance of the form for the given `id`.
-	 * The `id` is stringified and used for deduplication to potentially reuse existing instances.
-	 * Useful when you have multiple forms that use the same remote form action, for example in a loop.
-	 * ```svelte
-	 * {#each todos as todo}
-	 *	{@const todoForm = updateTodo.for(todo.id)}
-	 *	<form {...todoForm}>
-	 *		{#if todoForm.result?.invalid}<p>Invalid data</p>{/if}
-	 *		...
-	 *	</form>
-	 *	{/each}
-	 * ```
-	 */
-	for(id: ExtractId<Input>): Omit<RemoteForm<Input, Output>, 'for'>;
-	/** Preflight checks */
-	preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
 	/** Validate the form contents programmatically */
 	validate(options?: {
 		/** Set this to `true` to also show validation issues of fields that haven't been touched yet. */
diff --git a/packages/kit/src/runtime/app/server/remote/form.js b/packages/kit/src/runtime/app/server/remote/form.js
index c1fe5a1d2c10..0681271ce858 100644
--- a/packages/kit/src/runtime/app/server/remote/form.js
+++ b/packages/kit/src/runtime/app/server/remote/form.js
@@ -1,5 +1,5 @@
-/** @import { RemoteFormInput, RemoteForm } from '@sveltejs/kit' */
-/** @import { InternalRemoteFormIssue, MaybePromise, RemoteInfo } from 'types' */
+/** @import { RemoteFormInput, RemoteForm, RemoteFormFactory, RemoteFormFactoryOptions } from '@sveltejs/kit' */
+/** @import { ExtractId, 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';
@@ -15,18 +15,18 @@ import {
 import { get_cache, run_remote_function } from './shared.js';
 
 /**
- * Creates a form object that can be spread onto a `<form>` element.
+ * Creates a factory function that returns form instances which can be spread onto a `<form>` element.
  *
  * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  *
  * @template Output
  * @overload
  * @param {(invalid: import('@sveltejs/kit').Invalid<void>) => MaybePromise<Output>} fn
- * @returns {RemoteForm<void, Output>}
+ * @returns {RemoteFormFactory<void, Output>}
  * @since 2.27
  */
 /**
- * Creates a form object that can be spread onto a `<form>` element.
+ * Creates a factory function that returns form instances which can be spread onto a `<form>` element.
  *
  * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  *
@@ -35,11 +35,11 @@ import { get_cache, run_remote_function } from './shared.js';
  * @overload
  * @param {'unchecked'} validate
  * @param {(data: Input, invalid: import('@sveltejs/kit').Invalid<Input>) => MaybePromise<Output>} fn
- * @returns {RemoteForm<Input, Output>}
+ * @returns {RemoteFormFactory<Input, Output>}
  * @since 2.27
  */
 /**
- * Creates a form object that can be spread onto a `<form>` element.
+ * Creates a factory function that returns form instances which can be spread onto a `<form>` element.
  *
  * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  *
@@ -48,7 +48,7 @@ import { get_cache, run_remote_function } from './shared.js';
  * @overload
  * @param {Schema} validate
  * @param {(data: StandardSchemaV1.InferOutput<Schema>, invalid: import('@sveltejs/kit').Invalid<StandardSchemaV1.InferInput<Schema>>) => MaybePromise<Output>} fn
- * @returns {RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>}
+ * @returns {RemoteFormFactory<StandardSchemaV1.InferInput<Schema>, Output>}
  * @since 2.27
  */
 /**
@@ -56,7 +56,7 @@ import { get_cache, run_remote_function } from './shared.js';
  * @template Output
  * @param {any} validate_or_fn
  * @param {(data_or_invalid: any, invalid?: any) => MaybePromise<Output>} [maybe_fn]
- * @returns {RemoteForm<Input, Output>}
+ * @returns {RemoteFormFactory<Input, Output>}
  * @since 2.27
  */
 /*@__NO_SIDE_EFFECTS__*/
@@ -69,10 +69,126 @@ export function form(validate_or_fn, maybe_fn) {
 	const schema =
 		!maybe_fn || validate_or_fn === 'unchecked' ? null : /** @type {any} */ (validate_or_fn);
 
+	/** @type {RemoteInfo & { type: 'form' }} */
+	const __ = {
+		type: 'form',
+		name: '',
+		id: '',
+		fn: async (form_data, instance) => {
+			const validate_only = form_data.get('sveltekit:validate_only') === 'true';
+
+			let data = maybe_fn ? convert_formdata(form_data) : undefined;
+
+			if (data && data.id === undefined) {
+				const id = form_data.get('sveltekit:id');
+				if (typeof id === 'string') {
+					data.id = JSON.parse(id);
+				}
+			}
+
+			// 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 {{ submission: true, input?: Record<string, any>, issues?: InternalRemoteFormIssue[], result: Output }} */
+			const output = {};
+
+			// make it possible to differentiate between user submission and programmatic `field.set(...)` updates
+			output.submission = true;
+
+			const { event, state } = get_request_store();
+			const validated = await schema?.['~standard'].validate(data);
+
+			if (validate_only) {
+				return validated?.issues?.map((issue) => normalize_issue(issue, true)) ?? [];
+			}
+
+			if (validated?.issues !== undefined) {
+				handle_issues(output, validated.issues, event.isRemoteRequest, form_data);
+			} else {
+				if (validated !== undefined) {
+					data = validated.value;
+				}
+
+				state.refreshes ??= {};
+
+				const invalid = create_invalid();
+
+				try {
+					output.result = await run_remote_function(
+						event,
+						state,
+						true,
+						data,
+						(d) => d,
+						(data) => (!maybe_fn ? fn(invalid) : fn(data, invalid))
+					);
+				} catch (e) {
+					if (e instanceof ValidationError) {
+						handle_issues(output, e.issues, event.isRemoteRequest, form_data);
+					} else {
+						throw e;
+					}
+				}
+			}
+
+			// 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) {
+				get_cache(/** @type any */ (instance).__, state)[''] ??= output;
+			}
+
+			return output;
+		}
+	};
+
 	/**
-	 * @param {string | number | boolean} [key]
+	 * @param {ExtractId<Input>} [key]
+	 * @returns {RemoteForm<Input, Output>}
 	 */
 	function create_instance(key) {
+		const { state } = get_request_store();
+		const instance_id =
+			key !== undefined ? `${__.id}/${encodeURIComponent(JSON.stringify(key))}` : __.id;
+
+		// Create instance-specific info object with the correct id
+		/** @type {RemoteInfo & { type: 'form' }} */
+		const instance_info = {
+			type: 'form',
+			name: __.name,
+			id: instance_id,
+			fn: __.fn
+		};
+
+		// Check cache for keyed instances
+		const cache_key = instance_info.id + '|' + JSON.stringify(key);
+		const cached = (state.form_instances ??= new Map()).get(cache_key);
+		if (cached) {
+			return cached;
+		}
+
 		/** @type {RemoteForm<Input, Output>} */
 		const instance = {};
 
@@ -99,117 +215,21 @@ export function form(validate_or_fn, maybe_fn) {
 			value: button_props
 		});
 
-		/** @type {RemoteInfo} */
-		const __ = {
-			type: 'form',
-			name: '',
-			id: '',
-			/** @param {FormData} form_data */
-			fn: async (form_data) => {
-				const validate_only = form_data.get('sveltekit:validate_only') === 'true';
-
-				let data = maybe_fn ? convert_formdata(form_data) : undefined;
-
-				if (data && data.id === undefined) {
-					const id = form_data.get('sveltekit:id');
-					if (typeof id === 'string') {
-						data.id = JSON.parse(id);
-					}
-				}
-
-				// 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 {{ submission: true, input?: Record<string, any>, issues?: InternalRemoteFormIssue[], result: Output }} */
-				const output = {};
-
-				// make it possible to differentiate between user submission and programmatic `field.set(...)` updates
-				output.submission = true;
-
-				const { event, state } = get_request_store();
-				const validated = await schema?.['~standard'].validate(data);
-
-				if (validate_only) {
-					return validated?.issues?.map((issue) => normalize_issue(issue, true)) ?? [];
-				}
-
-				if (validated?.issues !== undefined) {
-					handle_issues(output, validated.issues, event.isRemoteRequest, form_data);
-				} else {
-					if (validated !== undefined) {
-						data = validated.value;
-					}
-
-					state.refreshes ??= {};
-
-					const invalid = create_invalid();
-
-					try {
-						output.result = await run_remote_function(
-							event,
-							state,
-							true,
-							data,
-							(d) => d,
-							(data) => (!maybe_fn ? fn(invalid) : fn(data, invalid))
-						);
-					} catch (e) {
-						if (e instanceof ValidationError) {
-							handle_issues(output, e.issues, event.isRemoteRequest, form_data);
-						} else {
-							throw e;
-						}
-					}
-				}
-
-				// 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) {
-					get_cache(__, state)[''] ??= output;
-				}
-
-				return output;
-			}
-		};
-
-		Object.defineProperty(instance, '__', { value: __ });
+		Object.defineProperty(instance, '__', { value: instance_info });
 
 		Object.defineProperty(instance, 'action', {
-			get: () => `?/remote=${__.id}`,
+			get: () => `?/remote=${instance_info.id}`,
 			enumerable: true
 		});
 
 		Object.defineProperty(button_props, 'formaction', {
-			get: () => `?/remote=${__.id}`,
+			get: () => `?/remote=${instance_info.id}`,
 			enumerable: true
 		});
 
 		Object.defineProperty(instance, 'fields', {
 			get() {
-				const data = get_cache(__)?.[''];
+				const data = get_cache(instance_info)?.[''];
 				const issues = flatten_issues(data?.issues ?? []);
 
 				return create_field_proxy(
@@ -224,7 +244,7 @@ export function form(validate_or_fn, maybe_fn) {
 						const input =
 							path.length === 0 ? value : deep_set(data?.input ?? {}, path.map(String), value);
 
-						(get_cache(__)[''] ??= {}).input = input;
+						(get_cache(instance_info)[''] ??= {}).input = input;
 					},
 					() => issues
 				);
@@ -239,7 +259,7 @@ export function form(validate_or_fn, maybe_fn) {
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
-					return get_cache(__)?.['']?.result;
+					return get_cache(instance_info)?.['']?.result;
 				} catch {
 					return undefined;
 				}
@@ -256,42 +276,40 @@ export function form(validate_or_fn, maybe_fn) {
 			get: () => 0
 		});
 
-		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, any>['for']} */
-				value: (key) => {
-					const { state } = get_request_store();
-					const cache_key = __.id + '|' + JSON.stringify(key);
-					let instance = (state.form_instances ??= new Map()).get(cache_key);
+		// Cache keyed instances
+		const form_instances = state.form_instances ?? (state.form_instances = new Map());
+		form_instances.set(cache_key, instance);
 
-					if (!instance) {
-						instance = create_instance(key);
-						instance.__.id = `${__.id}/${encodeURIComponent(JSON.stringify(key))}`;
-						instance.__.name = __.name;
+		return instance;
+	}
 
-						state.form_instances.set(cache_key, instance);
-					}
+	/** @type {RemoteFormFactory<Input, Output>} */
+	const factory = (arg) => {
+		/** @type {RemoteFormFactoryOptions<Input> | undefined } */
+		const options = arg && typeof arg === 'object' ? arg : undefined;
+		const key = options ? options.key : /** @type {ExtractId<Input> | undefined} */ (arg);
 
-					return instance;
-				}
-			});
+		const instance = create_instance(key);
+
+		if (options?.initialData) {
+			// seed initial input into cache for SSR
+			const { state } = get_request_store();
+			const cache = get_cache(/** @type any */ (instance).__, state);
+			(cache[''] ??= {}).input = options.initialData;
 		}
 
 		return instance;
-	}
+	};
+
+	Object.defineProperty(factory, '__', { value: __ });
 
-	return create_instance();
+	return factory;
 }
 
 /**
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 02bbf9239720..1be39168c670 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 { InternalRemoteFormIssue, RemoteFunctionResponse } from 'types' */
+/** @import { RemoteFormInput, RemoteForm, RemoteQueryOverride, RemoteFormFactory, RemoteFormFactoryOptions } from '@sveltejs/kit' */
+/** @import { ExtractId, InternalRemoteFormIssue, RemoteFunctionResponse } from 'types' */
 /** @import { Query } from './query.svelte.js' */
 import { app_dir, base } from '$app/paths/internal/client';
 import * as devalue from 'devalue';
@@ -47,21 +47,22 @@ function merge_with_server_issues(form_data, current_issues, client_issues) {
  * @template {RemoteFormInput} T
  * @template U
  * @param {string} id
- * @returns {RemoteForm<T, U>}
+ * @returns {RemoteFormFactory<T, U>}
  */
 export function form(id) {
 	/** @type {Map<any, { count: number, instance: RemoteForm<T, U> }>} */
 	const instances = new Map();
 
-	/** @param {string | number | boolean} [key] */
-	function create_instance(key) {
-		const action_id = id + (key != undefined ? `/${JSON.stringify(key)}` : '');
+	/** @param {RemoteFormFactoryOptions<T>} options */
+	function create_instance(options) {
+		const { key, preflight, initialData, resetAfterSuccess = true } = options;
+		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({});
+		let input = $state(initialData ?? {});
 
 		/** @type {InternalRemoteFormIssue[]} */
 		let raw_issues = $state.raw([]);
@@ -75,7 +76,7 @@ export function form(id) {
 		let pending_count = $state(0);
 
 		/** @type {StandardSchemaV1 | undefined} */
-		let preflight_schema = undefined;
+		let preflight_schema = preflight;
 
 		/** @type {HTMLFormElement | null} */
 		let element = null;
@@ -411,7 +412,7 @@ export function form(id) {
 		instance[createAttachmentKey()] = create_attachment(
 			form_onsubmit(({ submit, form }) =>
 				submit().then(() => {
-					if (!issues.$) {
+					if (!issues.$ && resetAfterSuccess) {
 						form.reset();
 					}
 				})
@@ -452,7 +453,7 @@ export function form(id) {
 			formaction: action,
 			onclick: form_action_onclick(({ submit, form }) =>
 				submit().then(() => {
-					if (!issues.$) {
+					if (!issues.$ && resetAfterSuccess) {
 						form.reset();
 					}
 				})
@@ -510,13 +511,6 @@ export function form(id) {
 			pending: {
 				get: () => pending_count
 			},
-			preflight: {
-				/** @type {RemoteForm<T, U>['preflight']} */
-				value: (schema) => {
-					preflight_schema = schema;
-					return instance;
-				}
-			},
 			validate: {
 				/** @type {RemoteForm<any, any>['validate']} */
 				value: async ({ includeUntouched = false, preflightOnly = false, submitter } = {}) => {
@@ -587,37 +581,36 @@ export function form(id) {
 		return instance;
 	}
 
-	const instance = create_instance();
-
-	Object.defineProperty(instance, 'for', {
-		/** @type {RemoteForm<T, U>['for']} */
-		value: (key) => {
-			const entry = instances.get(key) ?? { count: 0, instance: create_instance(key) };
-
-			try {
-				$effect.pre(() => {
-					return () => {
-						entry.count--;
+	/** @type {RemoteFormFactory<T, U>} */
+	const factory = (arg) => {
+		/** @type {RemoteFormFactoryOptions<T> | undefined } */
+		const options = arg && typeof arg === 'object' ? arg : undefined;
+		const key = options ? options.key : /** @type {ExtractId<T> | undefined} */ (arg);
+		const entry = instances.get(key) ?? { count: 0, instance: create_instance(options ?? { key }) };
 
-						void tick().then(() => {
-							if (entry.count === 0) {
-								instances.delete(key);
-							}
-						});
-					};
-				});
+		try {
+			$effect.pre(() => {
+				return () => {
+					entry.count--;
 
-				entry.count += 1;
-				instances.set(key, entry);
-			} catch {
-				// not in an effect context
-			}
+					void tick().then(() => {
+						if (entry.count === 0) {
+							instances.delete(key);
+						}
+					});
+				};
+			});
 
-			return entry.instance;
+			entry.count += 1;
+			instances.set(key, entry);
+		} catch {
+			// not in an effect context
 		}
-	});
 
-	return instance;
+		return entry.instance;
+	};
+
+	return factory;
 }
 
 /**
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 88ae0d41387c..5df7dc2c33d0 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -1,4 +1,4 @@
-/** @import { ActionResult, RemoteForm, RequestEvent, SSRManifest } from '@sveltejs/kit' */
+/** @import { ActionResult, RequestEvent, SSRManifest } from '@sveltejs/kit' */
 /** @import { RemoteFunctionResponse, RemoteInfo, RequestState, SSROptions } from 'types' */
 
 import { json, error } from '@sveltejs/kit';
@@ -116,6 +116,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				);
 			}
 
+			const action_id = decodeURIComponent(additional_args ?? '');
+			const instance = fn(action_id ? JSON.parse(action_id) : undefined);
+
 			const form_data = await event.request.formData();
 			form_client_refreshes = /** @type {string[]} */ (
 				JSON.parse(/** @type {string} */ (form_data.get('sveltekit:remote_refreshes')) ?? '[]')
@@ -123,12 +126,14 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			form_data.delete('sveltekit:remote_refreshes');
 
 			// If this is a keyed form instance (created via form.for(key)), add the key to the form data (unless already set)
-			if (additional_args) {
-				form_data.set('sveltekit:id', decodeURIComponent(additional_args));
+			if (action_id) {
+				form_data.set('sveltekit:id', action_id);
 			}
 
-			const fn = info.fn;
-			const data = await with_request_store({ event, state }, () => fn(form_data));
+			const form_fn = /** @type {RemoteInfo & { type: 'form' }} */ (
+				/** @type {any} */ (instance).__
+			).fn;
+			const data = await with_request_store({ event, state }, () => form_fn(form_data, instance));
 
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
@@ -267,7 +272,9 @@ 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, any>} */ (module?.default[name]);
+	const form = /** @type {import("@sveltejs/kit").RemoteFormFactory<any, any>} */ (
+		module?.default[name]
+	);
 
 	if (!form) {
 		event.setHeaders({
@@ -285,14 +292,11 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 		};
 	}
 
-	if (action_id) {
-		// @ts-expect-error
-		form = with_request_store({ event, state }, () => form.for(JSON.parse(action_id)));
-	}
+	const instance = form(action_id ? JSON.parse(action_id) : undefined);
 
 	try {
 		const form_data = await event.request.formData();
-		const fn = /** @type {RemoteInfo & { type: 'form' }} */ (/** @type {any} */ (form).__).fn;
+		const fn = /** @type {RemoteInfo & { type: 'form' }} */ (/** @type {any} */ (instance).__).fn;
 
 		// If this is a keyed form instance (created via form.for(key)), add the key to the form data (unless already set)
 		if (action_id && !form_data.has('id')) {
@@ -300,7 +304,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 			form_data.set('sveltekit:id', decodeURIComponent(action_id));
 		}
 
-		await with_request_store({ event, state }, () => fn(form_data));
+		await with_request_store({ event, state }, () => fn(form_data, instance));
 
 		// We don't want the data to appear on `let { form } = $props()`, which is why we're not returning it.
 		// It is instead available on `myForm.result`, setting of which happens within the remote `form` function.
diff --git a/packages/kit/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index 84242df90417..2d359cca5498 100644
--- a/packages/kit/src/types/internal.d.ts
+++ b/packages/kit/src/types/internal.d.ts
@@ -22,7 +22,8 @@ import {
 	ClientInit,
 	Transport,
 	HandleValidationError,
-	RemoteFormIssue
+	RemoteFormIssue,
+	RemoteForm
 } from '@sveltejs/kit';
 import {
 	HttpMethod,
@@ -572,7 +573,7 @@ export type RemoteInfo =
 			type: 'form';
 			id: string;
 			name: string;
-			fn: (data: FormData) => Promise<any>;
+			fn: (data: FormData, instance: RemoteForm<any, any>) => Promise<any>;
 	  }
 	| {
 			type: 'prerender';
diff --git a/packages/kit/src/types/private.d.ts b/packages/kit/src/types/private.d.ts
index da512ed777c5..78f6e27addfd 100644
--- a/packages/kit/src/types/private.d.ts
+++ b/packages/kit/src/types/private.d.ts
@@ -241,3 +241,19 @@ export interface RouteSegment {
 }
 
 export type TrailingSlash = 'never' | 'always' | 'ignore';
+
+export type DeepPartial<T> = T extends Record<PropertyKey, unknown> | unknown[]
+	? {
+			[K in keyof T]?: T[K] extends Record<PropertyKey, unknown> | unknown[]
+				? DeepPartial<T[K]>
+				: T[K];
+		}
+	: T | undefined;
+
+// If the schema specifies `id` as a string or number, ensure that `for(...)`
+// only accepts that type. Otherwise, accept `string | number`
+export type ExtractId<Input> = Input extends { id: infer Id }
+	? Id extends string | number
+		? Id
+		: string | number
+	: string | number;
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 33f931628aa1..326239ff9fec 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
@@ -8,8 +8,14 @@
 
 	const message = get_message();
 
-	const scoped = set_message.for('scoped');
-	const enhanced = set_message.for('enhanced');
+	const scoped = set_message({
+		key: 'scoped',
+		initialData: {
+			message: 'hello'
+		},
+		resetAfterSuccess: false
+	});
+	const enhanced = set_message('enhanced');
 </script>
 
 <p>message.current: {message.current}</p>
@@ -21,20 +27,20 @@
 
 <hr />
 
-<form data-unscoped {...set_message}>
-	{#if set_message.fields.message.issues()}
-		<p>{set_message.fields.message.issues()[0].message}</p>
+<form data-unscoped {...set_message()}>
+	{#if set_message().fields.message.issues()}
+		<p>{set_message().fields.message.issues()[0].message}</p>
 	{/if}
 
-	<input {...set_message.fields.message.as('text')} />
+	<input {...set_message().fields.message.as('text')} />
 	<button>set message</button>
-	<button {...set_reverse_message.buttonProps}>set reverse message</button>
+	<button {...set_reverse_message().buttonProps}>set reverse message</button>
 </form>
 
-<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>
+<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>
 
 <hr />
 
@@ -73,6 +79,6 @@
 
 <hr />
 
-<form {...resolve_deferreds}>
+<form {...resolve_deferreds()}>
 	<button>resolve deferreds</button>
 </form>
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/imperative/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/imperative/+page.svelte
index c21e4d146af3..a5d051230428 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/imperative/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/imperative/+page.svelte
@@ -8,25 +8,28 @@
 			'message is invalid'
 		)
 	});
+	const message_form = set_message({
+		preflight: schema
+	});
 </script>
 
-<form {...set_message.preflight(schema)}>
+<form {...message_form}>
 	<label>
 		<span>Message</span>
-		<input {...set_message.fields.message.as('text')} />
+		<input {...message_form.fields.message.as('text')} />
 	</label>
 
 	<p id="issue">
-		{set_message.fields.message.issues()?.[0]?.message ?? 'ok'}
+		{message_form.fields.message.issues()?.[0]?.message ?? 'ok'}
 	</p>
-	<p id="value">{set_message.fields.message.value()}</p>
+	<p id="value">{message_form.fields.message.value()}</p>
 
 	<button
 		id="set-and-validate"
 		type="button"
 		on:click={async () => {
-			set_message.fields.message.set('hello');
-			await set_message.validate({ includeUntouched: true });
+			message_form.fields.message.set('hello');
+			await message_form.validate({ includeUntouched: true });
 		}}
 	>
 		Set & validate
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/preflight-only/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/preflight-only/+page.svelte
index 6de838b61e63..ab2795f477c5 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/preflight-only/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/preflight-only/+page.svelte
@@ -9,6 +9,9 @@
 		b: v.string(),
 		c: v.string()
 	});
+	const set_form = set({
+		preflight: schema
+	});
 </script>
 
 <!-- TODO use await here once async lands -->
@@ -21,19 +24,19 @@
 <hr />
 
 <form
-	{...set.preflight(schema)}
-	oninput={() => set.validate({ preflightOnly: true })}
-	onchange={() => set.validate()}
+	{...set_form}
+	oninput={() => set_form.validate({ preflightOnly: true })}
+	onchange={() => set_form.validate()}
 >
-	<input {...set.fields.a.as('text')} />
-	<input {...set.fields.b.as('text')} />
-	<input {...set.fields.c.as('text')} />
+	<input {...set_form.fields.a.as('text')} />
+	<input {...set_form.fields.b.as('text')} />
+	<input {...set_form.fields.c.as('text')} />
 
 	<button>submit</button>
 </form>
 
 <div class="issues">
-	{#each set.fields.allIssues() as issue}
+	{#each set_form.fields.allIssues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 </div>
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 38d1248d4515..1987a92827c0 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
@@ -4,11 +4,16 @@
 
 	const number = get_number();
 
-	const enhanced = set_number.for('enhanced');
-
 	const schema = v.object({
 		number: v.pipe(v.number(), v.maxValue(20, 'too big'))
 	});
+	const number_form = set_number({
+		preflight: schema
+	});
+	const enhanced = set_number({
+		key: 'enhanced',
+		preflight: schema
+	});
 </script>
 
 <p>number.current: {number.current}</p>
@@ -20,24 +25,24 @@
 
 <hr />
 
-<form data-default {...set_number.preflight(schema)}>
-	{#each set_number.fields.number.issues() as issue}
+<form data-default {...number_form}>
+	{#each number_form.fields.number.issues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 
-	<input {...set_number.fields.number.as('number')} />
+	<input {...number_form.fields.number.as('number')} />
 	<button>set number</button>
 </form>
 
-<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>
+<p>set_number.input.number: {number_form.fields.number.value()}</p>
+<p>set_number.pending: {number_form.pending}</p>
+<p>set_number.result: {number_form.result}</p>
 
 <hr />
 
 <form
 	data-enhanced
-	{...enhanced.preflight(schema).enhance(async ({ submit }) => {
+	{...enhanced.enhance(async ({ submit }) => {
 		await submit();
 	})}
 >
diff --git a/packages/kit/test/apps/basics/src/routes/remote/form/select-untouched/+page.svelte b/packages/kit/test/apps/basics/src/routes/remote/form/select-untouched/+page.svelte
index 5caecdde39f2..a546968d76c0 100644
--- a/packages/kit/test/apps/basics/src/routes/remote/form/select-untouched/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/remote/form/select-untouched/+page.svelte
@@ -1,11 +1,13 @@
 <script>
 	import { myform } from './form.remote.js';
+
+	const myform_form = myform();
 </script>
 
-<form {...myform}>
-	<input {...myform.fields.message.as('text')} />
+<form {...myform_form}>
+	<input {...myform_form.fields.message.as('text')} />
 
-	<select {...myform.fields.number.as('select')}>
+	<select {...myform_form.fields.number.as('select')}>
 		<option>one</option>
 		<option>two</option>
 		<option>three</option>
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 d4648f9d462e..dff36b92ace8 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
@@ -1,9 +1,11 @@
 <script>
 	import { my_form } from './form.remote.js';
+
+	const my_form_form = my_form();
 </script>
 
-<form {...my_form}>
-	<button {...my_form.fields.submitter.as('submit', 'hello')}>submit</button>
+<form {...my_form_form}>
+	<button {...my_form_form.fields.submitter.as('submit', 'hello')}>submit</button>
 </form>
 
-<p id="result">{my_form.result}</p>
+<p id="result">{my_form_form.result}</p>
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 6c8a0aff7e4f..abb644635ad0 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
@@ -1,15 +1,17 @@
 <script>
 	import { register } from './form.remote.js';
+
+	const register_form = register();
 </script>
 
-<form {...register}>
-	<input {...register.fields.username.as('text')} />
-	<input {...register.fields._password.as('password')} />
+<form {...register_form}>
+	<input {...register_form.fields.username.as('text')} />
+	<input {...register_form.fields._password.as('password')} />
 
 	<button>submit</button>
 </form>
 
-<pre>{JSON.stringify(register.fields.issues(), null, '  ')}</pre>
+<pre>{JSON.stringify(register_form.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 6d53630be4ac..e87cb8d9d90c 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
@@ -7,47 +7,50 @@
 		bar: v.picklist(['d', 'e']),
 		button: v.optional(v.literal('submitter'))
 	});
+	const my_form_form = my_form({
+		preflight: schema
+	});
 	let submitter;
-	$inspect(my_form.fields.allIssues());
+	$inspect(my_form_form.fields.allIssues());
 </script>
 
-<form id="my-form" {...my_form.preflight(schema)} oninput={() => my_form.validate()}>
-	{#each my_form.fields.foo.issues() as issue}
+<form id="my-form" {...my_form_form} oninput={() => my_form_form.validate()}>
+	{#each my_form_form.fields.foo.issues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 
-	<input {...my_form.fields.foo.as('text')} />
+	<input {...my_form_form.fields.foo.as('text')} />
 
-	{#each my_form.fields.bar.issues() as issue}
+	{#each my_form_form.fields.bar.issues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 
-	<input {...my_form.fields.bar.as('text')} />
+	<input {...my_form_form.fields.bar.as('text')} />
 
 	<button>submit (imperative validation)</button>
 
-	<button bind:this={submitter} {...my_form.fields.button.as('submit', 'incorrect_value')}>
+	<button bind:this={submitter} {...my_form_form.fields.button.as('submit', 'incorrect_value')}>
 		submit
 	</button>
-	{#each my_form.fields.button.issues() as issue}
+	{#each my_form_form.fields.button.issues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 </form>
 <button
 	id="trigger-validate"
-	onclick={() => my_form.validate({ includeUntouched: true, submitter })}
+	onclick={() => my_form_form.validate({ includeUntouched: true, submitter })}
 >
 	trigger validation
 </button>
 
-<form id="issue-path-form" {...issue_path_form}>
-	<input {...issue_path_form.fields.nested.value.as('text')} />
+<form id="issue-path-form" {...issue_path_form()}>
+	<input {...issue_path_form().fields.nested.value.as('text')} />
 	<button
 		type="button"
 		id="validate"
-		onclick={() => issue_path_form.validate({ includeUntouched: true })}
+		onclick={() => issue_path_form().validate({ includeUntouched: true })}
 	>
 		Validate
 	</button>
-	<pre id="allIssues">{JSON.stringify(issue_path_form.fields.allIssues())}</pre>
+	<pre id="allIssues">{JSON.stringify(issue_path_form().fields.allIssues())}</pre>
 </form>
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
index 2430477a2efe..f0fba82b607b 100644
--- 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
@@ -1,46 +1,47 @@
 <script>
 	import { values } from './value.remote.js';
+	const values_form = values();
 </script>
 
 <h1>Remote Form Value Test</h1>
 
-<form {...values}>
+<form {...values_form}>
 	<label>
 		Leaf:
-		<input {...values.fields.leaf.as('text')} />
+		<input {...values_form.fields.leaf.as('text')} />
 	</label>
 
 	<label>
 		Object Leaf:
-		<input {...values.fields.object.leaf.as('text')} />
+		<input {...values_form.fields.object.leaf.as('text')} />
 	</label>
 
 	<label>
 		Object Array 0:
-		<input {...values.fields.object.array[0].as('text')} />
+		<input {...values_form.fields.object.array[0].as('text')} />
 	</label>
 	<label>
 		Object Array 1:
-		<input {...values.fields.object.array[1].as('text')} />
+		<input {...values_form.fields.object.array[1].as('text')} />
 	</label>
 
 	<label>
 		Array 0 Leaf:
-		<input {...values.fields.array[0].leaf.as('text')} />
+		<input {...values_form.fields.array[0].leaf.as('text')} />
 	</label>
 	<label>
 		Array 1 Leaf:
-		<input {...values.fields.array[1].leaf.as('text')} />
+		<input {...values_form.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>
+<pre id="full-value">{JSON.stringify(values_form.fields.value(), null, '  ')}</pre>
 
 <h2>Nested Object Value</h2>
-<pre id="object-value">{JSON.stringify(values.fields.object.value(), null, '  ')}</pre>
+<pre id="object-value">{JSON.stringify(values_form.fields.object.value(), null, '  ')}</pre>
 
 <h2>Array Value</h2>
-<pre id="array-value">{JSON.stringify(values.fields.array.value(), null, '  ')}</pre>
+<pre id="array-value">{JSON.stringify(values_form.fields.array.value(), null, '  ')}</pre>
diff --git a/packages/kit/test/apps/basics/test/test.js b/packages/kit/test/apps/basics/test/test.js
index 2518529e27d5..2cf254231e33 100644
--- a/packages/kit/test/apps/basics/test/test.js
+++ b/packages/kit/test/apps/basics/test/test.js
@@ -1760,7 +1760,8 @@ test.describe('remote functions', () => {
 		await page.getByText('set reverse message').click();
 
 		if (javaScriptEnabled) {
-			await page.getByText('message.current: sdrawkcab').waitFor();
+			await page.getByText('message.current').waitFor();
+			await expect(page.getByText('message.current:')).toHaveText('message.current: sdrawkcab');
 			await expect(page.getByText('await get_message():')).toHaveText(
 				'await get_message(): sdrawkcab'
 			);
@@ -1771,10 +1772,9 @@ test.describe('remote functions', () => {
 		);
 	});
 
-	test('form scoping with for(...) works', async ({ page, javaScriptEnabled }) => {
+	test('form scoping works', async ({ page, javaScriptEnabled }) => {
 		await page.goto('/remote/form');
 
-		await page.fill('[data-scoped] input', 'hello');
 		await page.getByText('set scoped message').click();
 
 		if (javaScriptEnabled) {
@@ -1787,7 +1787,7 @@ test.describe('remote functions', () => {
 		}
 
 		await expect(page.getByText('scoped.result')).toHaveText('scoped.result: hello (from: scoped)');
-		await expect(page.locator('[data-scoped] input')).toHaveValue('');
+		await expect(page.locator('[data-scoped] input')).toHaveValue('hello');
 	});
 
 	test('form enhance(...) works', async ({ page, javaScriptEnabled }) => {
diff --git a/packages/kit/test/apps/options-2/src/routes/remote/+page.svelte b/packages/kit/test/apps/options-2/src/routes/remote/+page.svelte
index a7d595d09cde..28980225dfd1 100644
--- a/packages/kit/test/apps/options-2/src/routes/remote/+page.svelte
+++ b/packages/kit/test/apps/options-2/src/routes/remote/+page.svelte
@@ -3,6 +3,7 @@
 
 	let count = $state(null);
 	let prerendered_result = $state(null);
+	const form = set_count_form();
 </script>
 
 <p id="count">{count}</p>
@@ -12,7 +13,7 @@
 <button onclick={async () => (count = await set_count(0))} id="reset-btn">reset</button>
 
 <form
-	{...set_count_form.enhance(async ({ submit }) => {
+	{...form.enhance(async ({ submit }) => {
 		await submit().updates(get_count());
 		count = await get_count();
 	})}
diff --git a/packages/kit/test/types/remote.test.ts b/packages/kit/test/types/remote.test.ts
index 760663fa9291..5c681958db2a 100644
--- a/packages/kit/test/types/remote.test.ts
+++ b/packages/kit/test/types/remote.test.ts
@@ -170,9 +170,11 @@ function form_tests() {
 		return { success: true };
 	});
 
-	f.result?.success === true;
+	const fi = f();
 
-	f.enhance(async ({ submit }) => {
+	fi.result?.success === true;
+
+	fi.enhance(async ({ submit }) => {
 		const x: void = await submit();
 		x;
 		const y: void = await submit().updates(
@@ -202,18 +204,19 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f2i = f2();
 	// @ts-expect-error
-	f2.fields.name();
-	f2.fields.a.issues();
-	f2.fields.nested.prop.issues();
+	f2i.fields.name();
+	f2i.fields.a.issues();
+	f2i.fields.nested.prop.issues();
 	// @ts-expect-error
-	f2.fields.nonexistent.issues();
-	f2.fields.a.value();
-	f2.fields.nested.prop.value();
+	f2i.fields.nonexistent.issues();
+	f2i.fields.a.value();
+	f2i.fields.nested.prop.value();
 	// @ts-expect-error
-	f2.fields.nonexistent.value();
+	f2i.fields.nonexistent.value();
 	// @ts-expect-error
-	f2.fields.array[0].array.name();
+	f2i.fields.array[0].array.name();
 
 	// all schema properties optional
 	const f3 = form(
@@ -238,14 +241,15 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f3i = f3();
 	// @ts-expect-error
-	f3.fields.name();
-	f3.fields.a.issues();
-	f3.fields.a.value();
-	f3.fields.nested.prop.issues();
-	f3.fields.nested.prop.value();
+	f3i.fields.name();
+	f3i.fields.a.issues();
+	f3i.fields.a.value();
+	f3i.fields.nested.prop.issues();
+	f3i.fields.nested.prop.value();
 	// @ts-expect-error
-	f3.fields.nonexistent.name();
+	f3i.fields.nonexistent.name();
 
 	// index signature schema
 	const f4 = form(null as any as StandardSchemaV1<Record<string, any>>, (data) => {
@@ -253,12 +257,13 @@ function form_tests() {
 		data.nested?.prop === '';
 		return { success: true };
 	});
+	const f4i = f4();
 	// @ts-expect-error
-	f4.fields.name();
-	f4.fields.a.issues();
-	f4.fields.a.value();
-	f4.fields.nested.prop.issues();
-	f4.fields.nested.prop.value();
+	f4i.fields.name();
+	f4i.fields.a.issues();
+	f4i.fields.a.value();
+	f4i.fields.nested.prop.issues();
+	f4i.fields.nested.prop.value();
 
 	// schema with union types
 	const f5 = form(
@@ -277,16 +282,17 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f5i = f5();
 	// @ts-expect-error
-	f5.fields.name();
-	f5.fields.foo.issues();
-	f5.fields.bar.issues();
-	f5.fields.foo.value();
-	f5.fields.bar.value() === 'c';
+	f5i.fields.name();
+	f5i.fields.foo.issues();
+	f5i.fields.bar.issues();
+	f5i.fields.foo.value();
+	f5i.fields.bar.value() === 'c';
 	// @ts-expect-error
-	f5.fields.foo.value() === 'e';
+	f5i.fields.foo.value() === 'e';
 	// @ts-expect-error
-	f5.fields.nonexistent.name();
+	f5i.fields.nonexistent.name();
 
 	// schema with arrays
 	const f6 = form(
@@ -305,19 +311,20 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f6i = f6();
 	// @ts-expect-error
-	f6.fields.name();
+	f6i.fields.name();
 	// @ts-expect-error
-	f6.field('array[0].array');
-	f6.fields.array.issues();
-	f6.fields.array[0].prop.issues();
-	f6.fields.array[0].array.issues();
+	f6i.field('array[0].array');
+	f6i.fields.array.issues();
+	f6i.fields.array[0].prop.issues();
+	f6i.fields.array[0].array.issues();
 	// @ts-expect-error
-	f6.fields.nonexistent.issues();
-	f6.fields.array[0].prop.value();
-	f6.fields.array[0].array.value();
+	f6i.fields.nonexistent.issues();
+	f6i.fields.array[0].prop.value();
+	f6i.fields.array[0].array.value();
 	// @ts-expect-error
-	f6.fields.array[0].array.name();
+	f6i.fields.array[0].array.name();
 
 	// any
 	const f7 = form(null as any, (data, invalid) => {
@@ -326,12 +333,13 @@ function form_tests() {
 		invalid('foo', invalid.nested.prop('bar'));
 		return { success: true };
 	});
+	const f7i = f7();
 	// @ts-expect-error
-	f7.fields.name();
-	f7.fields.a.issues();
-	f7.fields.a.value();
-	f7.fields.nested.prop.issues();
-	f7.fields.nested.prop.value();
+	f7i.fields.name();
+	f7i.fields.a.issues();
+	f7i.fields.a.value();
+	f7i.fields.nested.prop.issues();
+	f7i.fields.nested.prop.value();
 
 	// no schema
 	const f8 = form((invalid) => {
@@ -341,14 +349,16 @@ function form_tests() {
 			invalid.x('bar')
 		);
 	});
+	const f8i = f8();
 	// @ts-expect-error
-	f8.fields.x;
+	f8i.fields.x;
 	// @ts-expect-error
-	f6.input!['array[0].prop'] = 123;
+	f8i.input!['array[0].prop'] = 123;
 
 	// doesn't use data
 	const f9 = form(() => Promise.resolve({ success: true }));
-	f9.result?.success === true;
+	const f9i = f9();
+	f9i.result?.success === true;
 }
 form_tests();
 
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 9705e4a0b9bd..7f92f61e9e11 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -1945,14 +1945,6 @@ declare module '@sveltejs/kit' {
 		path: Array<string | number>;
 	}
 
-	// If the schema specifies `id` as a string or number, ensure that `for(...)`
-	// only accepts that type. Otherwise, accept `string | number`
-	type ExtractId<Input> = Input extends { id: infer Id }
-		? Id extends string | number
-			? Id
-			: string | number
-		: string | number;
-
 	/**
 	 * Recursively maps an input type to a structure where each field can create a validation issue.
 	 * This mirrors the runtime behavior of the `invalid` proxy passed to form handlers.
@@ -1983,9 +1975,27 @@ declare module '@sveltejs/kit' {
 	export type Invalid<Input = any> = ((...issues: Array<string | StandardSchemaV1.Issue>) => never) &
 		InvalidField<Input>;
 
+	export type RemoteFormFactoryOptions<Input extends RemoteFormInput | void> = {
+		/** Optional key to create a scoped instance */
+		key?: ExtractId<Input>;
+		/** Client-side preflight schema for validation before submit */
+		preflight?: StandardSchemaV1<Input, any>;
+		/** Initial input values for the form fields */
+		initialData?: DeepPartial<Input>;
+		/** Reset the form values after successful submission, for non-enhanced forms (default: true) */
+		resetAfterSuccess?: boolean;
+	};
+
 	/**
 	 * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
 	 */
+	export type RemoteFormFactory<Input extends RemoteFormInput | void, Output> = (
+		keyOrOptions?: ExtractId<Input> | RemoteFormFactoryOptions<Input>
+	) => RemoteForm<Input, Output>;
+
+	/**
+	 * The remote form instance created by the form factory function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+	 */
 	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;
@@ -2006,23 +2016,6 @@ declare module '@sveltejs/kit' {
 			action: string;
 			[attachment: symbol]: (node: HTMLFormElement) => void;
 		};
-		/**
-		 * Create an instance of the form for the given `id`.
-		 * The `id` is stringified and used for deduplication to potentially reuse existing instances.
-		 * Useful when you have multiple forms that use the same remote form action, for example in a loop.
-		 * ```svelte
-		 * {#each todos as todo}
-		 *	{@const todoForm = updateTodo.for(todo.id)}
-		 *	<form {...todoForm}>
-		 *		{#if todoForm.result?.invalid}<p>Invalid data</p>{/if}
-		 *		...
-		 *	</form>
-		 *	{/each}
-		 * ```
-		 */
-		for(id: ExtractId<Input>): Omit<RemoteForm<Input, Output>, 'for'>;
-		/** Preflight checks */
-		preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
 		/** Validate the form contents programmatically */
 		validate(options?: {
 			/** Set this to `true` to also show validation issues of fields that haven't been touched yet. */
@@ -2379,6 +2372,22 @@ declare module '@sveltejs/kit' {
 	}
 
 	type TrailingSlash = 'never' | 'always' | 'ignore';
+
+	type DeepPartial<T> = T extends Record<PropertyKey, unknown> | unknown[]
+		? {
+				[K in keyof T]?: T[K] extends Record<PropertyKey, unknown> | unknown[]
+					? DeepPartial<T[K]>
+					: T[K];
+			}
+		: T | undefined;
+
+	// If the schema specifies `id` as a string or number, ensure that `for(...)`
+	// only accepts that type. Otherwise, accept `string | number`
+	type ExtractId<Input> = Input extends { id: infer Id }
+		? Id extends string | number
+			? Id
+			: string | number
+		: string | number;
 	interface Asset {
 		file: string;
 		size: number;
@@ -3120,7 +3129,7 @@ declare module '$app/paths' {
 }
 
 declare module '$app/server' {
-	import type { RequestEvent, RemoteCommand, RemoteForm, RemoteFormInput, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
+	import type { RequestEvent, RemoteCommand, RemoteFormFactory, RemoteFormInput, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	/**
 	 * Read the contents of an imported asset from the filesystem
@@ -3168,29 +3177,29 @@ declare module '$app/server' {
 	 */
 	export function command<Schema extends StandardSchemaV1, Output>(validate: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Output): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>;
 	/**
-	 * Creates a form object that can be spread onto a `<form>` element.
+	 * Creates a factory function that returns form instances which 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<Output>(fn: (invalid: import("@sveltejs/kit").Invalid<void>) => MaybePromise<Output>): RemoteForm<void, Output>;
+	export function form<Output>(fn: (invalid: import("@sveltejs/kit").Invalid<void>) => MaybePromise<Output>): RemoteFormFactory<void, Output>;
 	/**
-	 * Creates a form object that can be spread onto a `<form>` element.
+	 * Creates a factory function that returns form instances which 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, invalid: import("@sveltejs/kit").Invalid<Input>) => MaybePromise<Output>): RemoteForm<Input, Output>;
+	export function form<Input extends RemoteFormInput, Output>(validate: "unchecked", fn: (data: Input, invalid: import("@sveltejs/kit").Invalid<Input>) => MaybePromise<Output>): RemoteFormFactory<Input, Output>;
 	/**
-	 * Creates a form object that can be spread onto a `<form>` element.
+	 * Creates a factory function that returns form instances which 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>, invalid: import("@sveltejs/kit").Invalid<StandardSchemaV1.InferInput<Schema>>) => MaybePromise<Output>): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;
+	export function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(validate: Schema, fn: (data: StandardSchemaV1.InferOutput<Schema>, invalid: import("@sveltejs/kit").Invalid<StandardSchemaV1.InferInput<Schema>>) => MaybePromise<Output>): RemoteFormFactory<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.
 	 *