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 f2b76f591a13..131fca092871 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>
@@ -495,25 +495,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>
@@ -523,7 +523,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>
 ```
@@ -541,11 +541,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>
 ```
@@ -555,7 +559,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}
 ```
@@ -565,17 +569,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:
 
@@ -584,14 +588,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>
 ```
 
@@ -602,15 +606,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>
@@ -669,7 +673,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
@@ -718,11 +722,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}
 ```
@@ -746,7 +750,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();
@@ -799,7 +803,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 --->
@@ -810,14 +814,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.
@@ -832,19 +868,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 ce45549aa6b3..32fdf7cc3500 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';
@@ -1983,14 +1985,6 @@ export interface 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;
-
 /**
  * A function and proxy object used to imperatively create validation errors in form handlers.
  *
@@ -2021,9 +2015,27 @@ export interface ValidationError {
 	issues: StandardSchemaV1.Issue[];
 }
 
+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;
@@ -2044,23 +2056,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 bf69e0200bce..4c627939f8a4 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, InvalidField } from '@sveltejs/kit' */
-/** @import { InternalRemoteFormIssue, MaybePromise, RemoteInfo } from 'types' */
+/** @import { RemoteFormInput, RemoteForm, RemoteFormFactory, RemoteFormFactoryOptions, InvalidField } 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 { get_cache, run_remote_function } from './shared.js';
 import { ValidationError } from '@sveltejs/kit/internal';
 
 /**
- * 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 {() => 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 { ValidationError } from '@sveltejs/kit/internal';
  * @overload
  * @param {'unchecked'} validate
  * @param {(data: Input, issue: InvalidField<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 { ValidationError } from '@sveltejs/kit/internal';
  * @overload
  * @param {Schema} validate
  * @param {(data: StandardSchemaV1.InferOutput<Schema>, issue: InvalidField<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 { ValidationError } from '@sveltejs/kit/internal';
  * @template Output
  * @param {any} validate_or_fn
  * @param {(data_or_issue: any, issue?: any) => MaybePromise<Output>} [maybe_fn]
- * @returns {RemoteForm<Input, Output>}
+ * @returns {RemoteFormFactory<Input, Output>}
  * @since 2.27
  */
 /*@__NO_SIDE_EFFECTS__*/
@@ -70,9 +70,131 @@ export function form(validate_or_fn, maybe_fn) {
 		!maybe_fn || validate_or_fn === 'unchecked' ? null : /** @type {any} */ (validate_or_fn);
 
 	/**
-	 * @param {string | number | boolean} [key]
+	 * Creates the form handler function that processes form submissions
+	 * @param {RemoteInfo & { type: 'form' }} cache_info - The info object to use for caching results
+	 * @returns {(body: Record<string, any>, meta: any, form_data: FormData | null) => Promise<any>}
+	 */
+	function remote_handler(cache_info) {
+		return async (
+			/** @type {Record<string, any>} */ data,
+			/** @type {any} */ meta,
+			/** @type {FormData | null} */ form_data
+		) => {
+			// 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 (meta.validate_only) {
+				return validated?.issues?.map((issue) => normalize_issue(issue, true)) ?? [];
+			}
+
+			if (validated?.issues !== undefined) {
+				handle_issues(output, validated.issues, form_data);
+			} else {
+				if (validated !== undefined) {
+					data = validated.value;
+				}
+
+				state.refreshes ??= {};
+
+				const issue = create_issues();
+
+				try {
+					output.result = await run_remote_function(
+						event,
+						state,
+						true,
+						data,
+						(d) => d,
+						(data) => (!maybe_fn ? fn() : fn(data, issue))
+					);
+				} catch (e) {
+					if (e instanceof ValidationError) {
+						handle_issues(output, e.issues, 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
+			// Cache using the provided cache_info so keyed instances have separate caches
+			if (!event.isRemoteRequest) {
+				get_cache(cache_info, state)[''] ??= output;
+			}
+
+			return output;
+		};
+	}
+
+	/** @type {RemoteInfo & { type: 'form' }} */
+	const __ = {
+		type: 'form',
+		name: '',
+		id: '',
+		fn: /** @type {any} */ (null)
+	};
+	// Assign fn after __ is created to avoid circular reference
+	__.fn = remote_handler(__);
+
+	/**
+	 * @param {ExtractId<Input>} [key]
+	 * @returns {RemoteForm<Input, Output>}
 	 */
 	function create_instance(key) {
+		const { state } = get_request_store();
+		const instance_id = key !== undefined ? `${__.id}/${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: /** @type {any} */ (null)
+		};
+		// Assign fn after instance_info is created to avoid circular reference
+		instance_info.fn = remote_handler(instance_info);
+
+		// 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,105 +221,21 @@ export function form(validate_or_fn, maybe_fn) {
 			value: button_props
 		});
 
-		/** @type {RemoteInfo} */
-		const __ = {
-			type: 'form',
-			name: '',
-			id: '',
-			fn: async (data, meta, form_data) => {
-				// 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 (meta.validate_only) {
-					return validated?.issues?.map((issue) => normalize_issue(issue, true)) ?? [];
-				}
-
-				if (validated?.issues !== undefined) {
-					handle_issues(output, validated.issues, form_data);
-				} else {
-					if (validated !== undefined) {
-						data = validated.value;
-					}
-
-					state.refreshes ??= {};
-
-					const issue = create_issues();
-
-					try {
-						output.result = await run_remote_function(
-							event,
-							state,
-							true,
-							data,
-							(d) => d,
-							(data) => (!maybe_fn ? fn() : fn(data, issue))
-						);
-					} catch (e) {
-						if (e instanceof ValidationError) {
-							handle_issues(output, e.issues, 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(
@@ -212,7 +250,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
 				);
@@ -227,7 +265,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;
 				}
@@ -244,42 +282,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 ba47e7ff0099..d0a35c69a3d0 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';
@@ -49,22 +49,23 @@ 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) {
+	/** @param {RemoteFormFactoryOptions<T>} options */
+	function create_instance(options) {
+		const { key, preflight, initialData, resetAfterSuccess = true } = options;
 		const action_id_without_key = id;
-		const action_id = id + (key != undefined ? `/${JSON.stringify(key)}` : '');
+		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([]);
@@ -78,7 +79,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;
@@ -418,7 +419,7 @@ export function form(id) {
 		instance[createAttachmentKey()] = create_attachment(
 			form_onsubmit(({ submit, form }) =>
 				submit().then(() => {
-					if (!issues.$) {
+					if (!issues.$ && resetAfterSuccess) {
 						form.reset();
 					}
 				})
@@ -459,7 +460,7 @@ export function form(id) {
 			formaction: action,
 			onclick: form_action_onclick(({ submit, form }) =>
 				submit().then(() => {
-					if (!issues.$) {
+					if (!issues.$ && resetAfterSuccess) {
 						form.reset();
 					}
 				})
@@ -517,13 +518,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 } = {}) => {
@@ -605,37 +599,43 @@ 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) };
+	/** @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 cache_key = id + (key !== undefined ? `/${JSON.stringify(key)}` : '');
+		const entry = instances.get(cache_key) ?? {
+			count: 0,
+			instance: create_instance(options ?? { key })
+		};
 
-			try {
-				$effect.pre(() => {
-					return () => {
-						entry.count--;
+		try {
+			$effect.pre(() => {
+				if (options?.initialData)
+					entry.instance.fields.set(/** @type {any} */ (options?.initialData));
 
-						void tick().then(() => {
-							if (entry.count === 0) {
-								instances.delete(key);
-							}
-						});
-					};
-				});
+				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(cache_key);
+						}
+					});
+				};
+			});
 
-			return entry.instance;
+			entry.count += 1;
+			instances.set(cache_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 d52b4be8d87b..9afd347d6ad5 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';
@@ -267,9 +267,11 @@ 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_factory = /** @type {import("@sveltejs/kit").RemoteFormFactory<any, any>} */ (
+		module?.default[name]
+	);
 
-	if (!form) {
+	if (!form_factory) {
 		event.setHeaders({
 			// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
 			// "The server must generate an Allow header field in a 405 status code response"
@@ -285,9 +287,12 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 		};
 	}
 
+	let form;
 	if (action_id) {
-		// @ts-expect-error
-		form = with_request_store({ event, state }, () => form.for(JSON.parse(action_id)));
+		const key = JSON.parse(action_id);
+		form = with_request_store({ event, state }, () => form_factory(key));
+	} else {
+		form = with_request_store({ event, state }, () => form_factory());
 	}
 
 	try {
@@ -295,7 +300,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 
 		const { data, meta, form_data } = await deserialize_binary_form(event.request);
 		if (action_id && !('id' in data)) {
-			data.id = JSON.parse(decodeURIComponent(action_id));
+			data.id = JSON.parse(action_id);
 		}
 
 		await with_request_store({ event, state }, () => fn(data, meta, form_data));
diff --git a/packages/kit/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index 6384201af551..c842b9fa1712 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,
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/async/src/routes/remote/form/[test_name]/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/[test_name]/+page.svelte
index 485cfab34a11..90d2073da38b 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/[test_name]/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/form/[test_name]/+page.svelte
@@ -1,17 +1,24 @@
 <script>
 	import {
 		get_message,
-		set_message,
 		resolve_deferreds,
+		set_message,
 		set_reverse_message
 	} from './form.remote.js';
 
 	const { params } = $props();
 
 	const message = get_message(params.test_name);
-
-	const scoped = set_message.for(`scoped:${params.test_name}`);
-	const enhanced = set_message.for(`enhanced:${params.test_name}`);
+	const scoped = $derived(
+		set_message({
+			key: `scoped:${params.test_name}`,
+			initialData: {
+				message: 'hello'
+			},
+			resetAfterSuccess: false
+		})
+	);
+	const enhanced = $derived(set_message(`enhanced:${params.test_name}`));
 </script>
 
 <p>message.current: {message.current}</p>
@@ -20,32 +27,32 @@
 
 <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.test_name.as('hidden', params.test_name)} />
+	<input {...set_message().fields.message.as('text')} />
+	<input {...set_message().fields.test_name.as('hidden', params.test_name)} />
 	<!--
 	 NOTE: there really probably should be a `set_reverse_message' test_name hidden field here, but it collides with the one above.
 	 This kind of lines up with our discussions from earlier where we were talking about needing to include the RF hash in the field name.
 	 If we do that and this test starts failing, all we'll need to do is add the hidden field back in.
 	-->
 	<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 />
 
 <form data-scoped {...scoped}>
-	{#if scoped.fields.message.issues()}
-		<p>{scoped.fields.message.issues()[0].message}</p>
+	{#if scoped.fields.message.issues()?.[0]?.message}
+		<p>{scoped.fields.message.issues()?.[0]?.message}</p>
 	{/if}
 
 	<input {...scoped.fields.message.as('text')} />
@@ -68,7 +75,7 @@
 	})}
 >
 	{#if enhanced.fields.message.issues()}
-		<p>{enhanced.fields.message.issues()[0].message}</p>
+		<p>{enhanced.fields.message.issues()?.[0]?.message}</p>
 	{/if}
 
 	<input {...enhanced.fields.message.as('text')} />
@@ -82,7 +89,7 @@
 
 <hr />
 
-<form {...resolve_deferreds}>
+<form {...resolve_deferreds()}>
 	<button>resolve deferreds</button>
-	<input {...resolve_deferreds.fields.test_name.as('hidden', params.test_name)} />
+	<input {...resolve_deferreds().fields.test_name.as('hidden', params.test_name)} />
 </form>
diff --git a/packages/kit/test/apps/async/src/routes/remote/form/file-upload/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/file-upload/+page.svelte
index 850fa70a14db..88be3b30f188 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/file-upload/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/form/file-upload/+page.svelte
@@ -1,15 +1,16 @@
 <script lang="ts">
 	import { upload } from './form.remote';
+	const upload_form = upload();
 </script>
 
-<form {...upload} enctype="multipart/form-data">
-	<input {...upload.fields.text.as('hidden', 'Hello world')} />
+<form {...upload_form} enctype="multipart/form-data">
+	<input {...upload_form.fields.text.as('hidden', 'Hello world')} />
 	<p>File 1:</p>
-	<input {...upload.fields.file1.as('file')} />
+	<input {...upload_form.fields.file1.as('file')} />
 	<p>File 2:</p>
-	<input {...upload.fields.file2.as('file')} />
+	<input {...upload_form.fields.file2.as('file')} />
 	<label style:display="block">
-		<input {...upload.fields.read_files.as('checkbox')} />
+		<input {...upload_form.fields.read_files.as('checkbox')} />
 		Read files
 	</label>
 	<br />
@@ -17,4 +18,4 @@
 	<button>Submit</button>
 </form>
 
-<pre>{JSON.stringify(upload.result)}</pre>
+<pre>{JSON.stringify(upload_form.result)}</pre>
diff --git a/packages/kit/test/apps/async/src/routes/remote/form/imperative/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/imperative/+page.svelte
index 14e4a86ed75c..437fee7540d8 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/imperative/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/form/imperative/+page.svelte
@@ -9,26 +9,29 @@
 			'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 {...set_message.fields.test_name.as('hidden', 'imperative')} />
+		<input {...message_form.fields.message.as('text')} />
+		<input {...message_form.fields.test_name.as('hidden', 'imperative')} />
 	</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/async/src/routes/remote/form/preflight-only/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/preflight-only/+page.svelte
index 0b2cb866102e..4dcc2a507f1c 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/preflight-only/+page.svelte
+++ b/packages/kit/test/apps/async/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>
 
 <p>a: {(await data).a}</p>
@@ -18,19 +21,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/async/src/routes/remote/form/preflight/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/preflight/+page.svelte
index 85269d87cff4..ca1fa20a6695 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/preflight/+page.svelte
+++ b/packages/kit/test/apps/async/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>
@@ -17,24 +22,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/async/src/routes/remote/form/select-untouched/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/select-untouched/+page.svelte
index 5caecdde39f2..a546968d76c0 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/select-untouched/+page.svelte
+++ b/packages/kit/test/apps/async/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/async/src/routes/remote/form/submitter/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/submitter/+page.svelte
index d4648f9d462e..dff36b92ace8 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/submitter/+page.svelte
+++ b/packages/kit/test/apps/async/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/async/src/routes/remote/form/underscore/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/underscore/+page.svelte
index 6c8a0aff7e4f..abb644635ad0 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/underscore/+page.svelte
+++ b/packages/kit/test/apps/async/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/async/src/routes/remote/form/validate/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/validate/+page.svelte
index eefd62be84dc..5fdcd61074a6 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/validate/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/form/validate/+page.svelte
@@ -7,52 +7,58 @@
 		bar: v.picklist(['d', 'e']),
 		button: v.literal('submitter')
 	});
+	const my_form_form = my_form({
+		preflight: schema
+	});
+	const my_form_2_form = my_form_2();
+	let submitter;
 
+	$inspect(my_form_form.fields.allIssues());
 	let error = $state(false);
 </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 {...my_form.fields.button.as('submit', 'incorrect_value')}> submit </button>
+	<button {...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}
 
-	<button {...my_form.fields.button.as('submit', 'submitter')}>
+	<button {...my_form_form.fields.button.as('submit', 'submitter')}>
 		submit (imperative validation)
 	</button>
 </form>
-<button id="trigger-validate" onclick={() => my_form.validate({ includeUntouched: true })}>
+<button id="trigger-validate" onclick={() => my_form_form.validate({ includeUntouched: true })}>
 	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>
 
 <form
 	id="my-form-2"
-	{...my_form_2.enhance(async ({ submit }) => {
+	{...my_form_2_form.enhance(async ({ submit }) => {
 		error = false;
 		try {
 			await submit();
@@ -61,11 +67,11 @@
 		}
 	})}
 >
-	{#each my_form_2.fields.baz.issues() as issue}
+	{#each my_form_2_form.fields.baz.issues() as issue}
 		<p>{issue.message}</p>
 	{/each}
 
-	<input {...my_form_2.fields.baz.as('text')} />
+	<input {...my_form_2_form.fields.baz.as('text')} />
 
 	<p data-error>{error ? 'An error occurred' : 'No error'}</p>
 
diff --git a/packages/kit/test/apps/async/src/routes/remote/form/value/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/form/value/+page.svelte
index 2430477a2efe..f0fba82b607b 100644
--- a/packages/kit/test/apps/async/src/routes/remote/form/value/+page.svelte
+++ b/packages/kit/test/apps/async/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/async/test/test.js b/packages/kit/test/apps/async/test/test.js
index bf647f6e4e38..f9bf9eb31ba1 100644
--- a/packages/kit/test/apps/async/test/test.js
+++ b/packages/kit/test/apps/async/test/test.js
@@ -153,10 +153,9 @@ test.describe('remote functions', () => {
 		);
 	});
 
-	test('form scoping with for(...) works', async ({ page, javaScriptEnabled }) => {
+	test('form scoping with key works', async ({ page, javaScriptEnabled }) => {
 		await page.goto('/remote/form/form-scoped');
 
-		await page.fill('[data-scoped] input', 'hello');
 		await page.getByText('set scoped message').click();
 
 		if (javaScriptEnabled) {
@@ -171,7 +170,7 @@ test.describe('remote functions', () => {
 		await expect(page.getByText('scoped.result')).toHaveText(
 			'scoped.result: hello (from: scoped:form-scoped)'
 		);
-		await expect(page.locator('[data-scoped] input[name="message"]')).toHaveValue('');
+		await expect(page.locator('[data-scoped] input[name="message"]')).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 e30f43fc17d8..7caba2cfefe5 100644
--- a/packages/kit/test/types/remote.test.ts
+++ b/packages/kit/test/types/remote.test.ts
@@ -172,9 +172,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(
@@ -206,18 +208,19 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f2i = f2();
 	// @ts-expect-error
-	f2.fields.as('text');
-	f2.fields.a.issues();
-	f2.fields.nested.prop.issues();
+	f2i.fields.as('text');
+	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.as('text');
+	f2i.fields.array[0].array.as('text');
 
 	// all schema properties optional
 	const f3 = form(
@@ -244,14 +247,15 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f3i = f3();
 	// @ts-expect-error
-	f3.fields.as('text');
-	f3.fields.a.issues();
-	f3.fields.a.value();
-	f3.fields.nested.prop.issues();
-	f3.fields.nested.prop.value();
+	f3i.fields.as('text');
+	f3i.fields.a.issues();
+	f3i.fields.a.value();
+	f3i.fields.nested.prop.issues();
+	f3i.fields.nested.prop.value();
 	// @ts-expect-error
-	f3.fields.nonexistent.as('text');
+	f3i.fields.nonexistent.as('text');
 
 	// index signature schema
 	const f4 = form(null as any as StandardSchemaV1<Record<string, any>>, (data) => {
@@ -259,12 +263,13 @@ function form_tests() {
 		data.nested?.prop === '';
 		return { success: true };
 	});
+	const f4i = f4();
 	// @ts-expect-error
-	f4.fields.as('text');
-	f4.fields.a.issues();
-	f4.fields.a.value();
-	f4.fields.nested.prop.issues();
-	f4.fields.nested.prop.value();
+	f4i.fields.as('text');
+	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(
@@ -285,16 +290,17 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f5i = f5();
 	// @ts-expect-error
-	f5.fields.as('text');
-	f5.fields.foo.issues();
-	f5.fields.bar.issues();
-	f5.fields.foo.value();
-	f5.fields.bar.value() === 'c';
+	f5i.fields.as('text');
+	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.as('text');
+	f5i.fields.nonexistent.as('text');
 
 	// schema with arrays
 	const f6 = form(
@@ -315,19 +321,20 @@ function form_tests() {
 			return { success: true };
 		}
 	);
+	const f6i = f6();
 	// @ts-expect-error
-	f6.fields.as('text');
+	f6i.fields.as('text');
 	// @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.as('text');
+	f6i.fields.array[0].array.as('text');
 
 	// any
 	const f7 = form(null as any, (data, issue) => {
@@ -338,27 +345,30 @@ function form_tests() {
 		}
 		return { success: true };
 	});
+	const f7i = f7();
 	// @ts-expect-error
-	f7.fields.as('text');
-	f7.fields.a.issues();
-	f7.fields.a.value();
-	f7.fields.nested.prop.issues();
-	f7.fields.nested.prop.value();
+	f7i.fields.as('text');
+	f7i.fields.a.issues();
+	f7i.fields.a.value();
+	f7i.fields.nested.prop.issues();
+	f7i.fields.nested.prop.value();
 
 	// no schema
 	const f8 = form(() => {
 		invalid('foo');
 	});
-	f8.fields.issues();
-	f8.fields.allIssues();
+	const f8i = f8();
+	f8i.fields.issues();
+	f8i.fields.allIssues();
 	// @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 8ca87b95f7f5..3a4b72dca4f5 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -1959,14 +1959,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;
-
 	/**
 	 * A function and proxy object used to imperatively create validation errors in form handlers.
 	 *
@@ -1997,9 +1989,27 @@ declare module '@sveltejs/kit' {
 		issues: StandardSchemaV1.Issue[];
 	}
 
+	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;
@@ -2020,23 +2030,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. */
@@ -2391,6 +2384,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;
@@ -3164,7 +3173,7 @@ declare module '$app/paths' {
 }
 
 declare module '$app/server' {
-	import type { RequestEvent, RemoteCommand, RemoteForm, RemoteFormInput, InvalidField, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
+	import type { RequestEvent, RemoteCommand, RemoteFormFactory, RemoteFormInput, InvalidField, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	/**
 	 * Read the contents of an imported asset from the filesystem
@@ -3212,29 +3221,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: () => MaybePromise<Output>): RemoteForm<void, Output>;
+	export function form<Output>(fn: () => 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, issue: InvalidField<Input>) => MaybePromise<Output>): RemoteForm<Input, Output>;
+	export function form<Input extends RemoteFormInput, Output>(validate: "unchecked", fn: (data: Input, issue: InvalidField<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>, issue: InvalidField<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>, issue: InvalidField<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.
 	 *