diff --git a/apps/svelte.dev/content/docs/kit/30-advanced/20-hooks.md b/apps/svelte.dev/content/docs/kit/30-advanced/20-hooks.md
index 8b2f95cee..053067274 100644
--- a/apps/svelte.dev/content/docs/kit/30-advanced/20-hooks.md
+++ b/apps/svelte.dev/content/docs/kit/30-advanced/20-hooks.md
@@ -144,6 +144,37 @@ export async function handleFetch({ event, request, fetch }) {
 }
 ```
 
+### handleValidationError
+
+This hook is called when a remote function is called with an argument that does not match its schema. It must return an object matching the shape of [`App.Error`](types#Error).
+
+Say you have a remote function that expects a string as its argument ...
+
+```js
+/// file: todos.remote.js
+import z from 'zod';
+import { query } from '$app/server';
+
+export getTodo = query(z.string(), (id) => {
+	// implementation...
+});
+```
+
+...but it is called with something that doesn't match the schema — such as a number (e.g `await getTodos(1)`) — then validation will fail, the server will respond with a [400 status code](https://http.dog/400), and the function will throw with the message 'Bad Request'.
+
+To customise this message and add additional properties to the error object, implement `handleValidationError`:
+
+```js
+/// file: src/hooks.server.js
+import z from 'zod';
+
+/** @type {import('@sveltejs/kit').HandleValidationError} */
+export const handleValidationError = ({ issues }) => {
+  // @ts-expect-error The types are too strict and disallow this but it's perfectly valid
+  return { message: 'Schema Error', validationErrors: z.treeifyError({ issues })};
+}
+```
+
 ## Shared hooks
 
 The following can be added to `src/hooks.server.js` _and_ `src/hooks.client.js`:
diff --git a/apps/svelte.dev/content/docs/kit/98-reference/10-@sveltejs-kit.md b/apps/svelte.dev/content/docs/kit/98-reference/10-@sveltejs-kit.md
index 943cc0e40..534e482d5 100644
--- a/apps/svelte.dev/content/docs/kit/98-reference/10-@sveltejs-kit.md
+++ b/apps/svelte.dev/content/docs/kit/98-reference/10-@sveltejs-kit.md
@@ -118,9 +118,10 @@ function fail(status: number): ActionFailure<undefined>;
 <div class="ts-block">
 
 ```dts
-function fail<
-	T extends Record<string, unknown> | undefined = undefined
->(status: number, data: T): ActionFailure<T>;
+function fail<T = undefined>(
+	status: number,
+	data: T
+): ActionFailure<T>;
 ```
 
 </div>
@@ -306,9 +307,7 @@ type Action<
 <div class="ts-block">
 
 ```dts
-interface ActionFailure<
-	T extends Record<string, unknown> | undefined = undefined
-> {/*…*/}
+interface ActionFailure<T = undefined> {/*…*/}
 ```
 
 <div class="ts-block-property">
@@ -1144,6 +1143,27 @@ type HandleServerError = (input: {
 
 </div>
 
+## HandleValidationError
+
+The server-side [`handleValidationError`](/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when schema validation fails in a remote function.
+
+If schema validation fails in a remote function, this function will be called with the validation issues and the event.
+This function is expected return an object shape that matches `App.Error`.
+
+<div class="ts-block">
+
+```dts
+type HandleValidationError<
+	Issue extends
+		StandardSchemaV1.Issue = StandardSchemaV1.Issue
+> = (input: {
+	issues: Issue[];
+	event: RequestEvent;
+}) => MaybePromise<App.Error>;
+```
+
+</div>
+
 ## HttpError
 
 The object returned by the [`error`](/docs/kit/@sveltejs-kit#error) function.
@@ -1915,6 +1935,311 @@ The location to redirect to.
 </div>
 </div></div>
 
+## RemoteCommand
+
+The return value of a remote `command` function.
+Call it with the input arguments to execute the command.
+
+Note: Prefer remote `form` functions when possible, as they
+work without JavaScript enabled.
+
+```svelte
+<script>
+	import { createTodo } from './todos.remote.js';
+
+	let text = $state('');
+</script>
+
+<input bind:value={text} />
+<button onclick={async () => {
+	await createTodo({ text });
+}}>
+	Create Todo
+</button>
+```
+Use the `updates` method to specify which queries to update in response to the command.
+```svelte
+<script>
+	import { getTodos, createTodo } from './todos.remote.js';
+
+	let text = $state('');
+</script>
+
+<input bind:value={text} />
+<button onclick={async () => {
+	await createTodo({ text }).updates(
+		getTodos.withOverride((todos) => [...todos, { text, done: false }])
+	);
+}}>
+	Create Todo
+</button>
+
+<ul>
+	{#each await getTodos() as todo}
+		<li>{todo.text}</li>
+	{/each}
+</ul>
+```
+
+<div class="ts-block">
+
+```dts
+type RemoteCommand<Input, Output> = (arg: Input) => Promise<
+	Awaited<Output>
+> & {
+	updates: (
+		...queries: Array<
+			| ReturnType<RemoteQuery<any, any>>
+			| ReturnType<
+					ReturnType<RemoteQuery<any, any>>['withOverride']
+			  >
+		>
+	) => Promise<Awaited<Output>>;
+};
+```
+
+</div>
+
+## RemoteFormAction
+
+The return value of a remote `form` function.
+Spread it onto a `<form>` element to connect the form with the remote form action.
+```svelte
+<script>
+	import { createTodo } from './todos.remote.js';
+</script>
+
+<form {...createTodo}>
+	<input type="text" name="name" />
+	<!-- ... -->
+</form>
+```
+Use the `enhance` method to influence what happens when the form is submitted.
+```svelte
+<script>
+	import { getTodos, createTodo } from './todos.remote.js';
+</script>
+
+<form {...myFormAction.enhance(async ({ data, submit }) => {
+	// `data` is an instance of FormData (https://developer.mozilla.org/en-US/docs/Web/API/FormData)
+	const text = data.get('text');
+	const todo = { text, done: false };
+
+	// `updates` and `withOverride` enable optimistic UI updates
+	await submit().updates(getTodos.withOverride((todos) => [...todos, todo]));
+})}>
+	<input name="text" />
+	<!-- ... -->
+</form>
+
+<ul>
+	{#each await getTodos() as todo}
+		<li>{todo.text}</li>
+	{/each}
+</ul>
+```
+
+<div class="ts-block">
+
+```dts
+type RemoteFormAction<Success, Failure> = ((
+	data: FormData
+) => Promise<void>) & {
+	method: 'POST';
+	/** The URL to send the form to. */
+	action: string;
+	/** Event handler that intercepts the form submission on the client to prevent a full page reload */
+	onsubmit: (event: SubmitEvent) => void;
+	/** Use the `enhance` method to influence what happens when the form is submitted. */
+	enhance: (
+		callback: (opts: {
+			form: HTMLFormElement;
+			data: FormData;
+			submit: () => Promise<void> & {
+				updates: (
+					...queries: Array<
+						| ReturnType<RemoteQuery<any, any>>
+						| ReturnType<
+								ReturnType<
+									RemoteQuery<any, any>
+								>['withOverride']
+						  >
+					>
+				) => Promise<void>;
+			};
+		}) => void
+	) => {
+		method: 'POST';
+		action: string;
+		onsubmit: (event: SubmitEvent) => void;
+	};
+	/**
+	 * Create an instance of the form for the given key.
+	 * The key 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: (
+		key: string | number | boolean
+	) => Omit<RemoteFormAction<Success, Failure>, 'for'>;
+	/** The result of the form submission */
+	get result(): Success | Failure | undefined;
+	/** When there's an error during form submission, it appears on this property */
+	get error(): App.Error | undefined;
+	/** Spread this onto a button or input of type submit */
+	formAction: {
+		type: 'submit';
+		formaction: string;
+		onclick: (event: Event) => void;
+		/** Use the `enhance` method to influence what happens when the form is submitted. */
+		enhance: (
+			callback: (opts: {
+				form: HTMLFormElement;
+				data: FormData;
+				submit: () => Promise<void> & {
+					updates: (
+						...queries: Array<
+							| ReturnType<RemoteQuery<any, any>>
+							| ReturnType<
+									ReturnType<
+										RemoteQuery<any, any>
+									>['withOverride']
+							  >
+						>
+					) => Promise<void>;
+				};
+			}) => void
+		) => {
+			type: 'submit';
+			formaction: string;
+			onclick: (event: Event) => void;
+		};
+	};
+};
+```
+
+</div>
+
+## RemoteQuery
+
+The return value of a remote `query` or `prerender` function.
+Call it with the input arguments to retrieve the value.
+On the server, this will directly call through to the underlying function.
+On the client, this will do a fetch to the server to retrieve the value.
+When the query is called in a reactive context on the client, it will update its dependencies with a new value whenever `refresh()` or `override()` are called.
+
+<div class="ts-block">
+
+```dts
+type RemoteQuery<Input, Output> = (arg: Input) => Promise<
+	Awaited<Output>
+> & {
+	/** The error in case the query fails. Most often this is a [`HttpError`](https://svelte.dev/docs/kit/@sveltejs-kit#HttpError) but it isn't guaranteed to be. */
+	get error(): any;
+	/** `true` before the first result is available and during refreshes */
+	get loading(): boolean;
+	/**
+	 * On the client, this function will re-fetch the query from the server.
+	 *
+	 * On the server, this can be called in the context of a `command` or `form` remote function. It will then
+	 * transport the updated data to the client along with the response, if the action was successful.
+	 */
+	refresh: () => Promise<void>;
+	/**
+	 * Temporarily override the value of a query. Useful for optimistic UI updates outside of a `command` or `form` remote function (for those, use `withOverride`).
+	 * `override` expects a function that takes the current value and returns the new value. It returns a function that will release the override.
+	 * Overrides are applied on new values, too, until they are released.
+	 *
+	 * ```svelte
+	 * <script>
+	 *   import { getList, commit } from './todos.remote.js';
+	 *   const list = getList();
+	 *   let release = [];
+	 * </script>
+	 *
+	 * <h2>Select items to remove</h2>
+	 *
+	 * <ul>
+	 *   {#each list as item}
+	 *     <li>{item.text}</li>
+	 *     <button onclick={() => {
+	 *       release.push(list.override((current) => current.filter((i) => i.id !== item.id)));
+	 *     }}>Remove</button>
+	 *   {/each}
+	 * </ul>
+	 *
+	 * <button onclick={() => {
+	 *   release.forEach((r) => r());
+	 *   release = [];
+	 * }}>Revert</button>
+	 *
+	 * <button onclick={async () => {
+	 *   await commit();
+	 *   release.forEach((r) => r());
+	 *   release = [];
+	 * }}>Confirm</button>
+	 * ```
+	 *
+	 * Can only be called on the client.
+	 */
+	override: (
+		update: (current: Awaited<Output>) => Awaited<Output>
+	) => () => void;
+	/**
+	 * Temporarily override the value of a query. Useful for optimistic UI updates.
+	 * `withOverride` expects a function that takes the current value and returns the new value.
+	 * In other words this works like `override`, but is specifically for use as part of the `updates` method of a remote `command` or `form` submit
+	 * in order to coordinate query refreshes and override releases at once, without causing e.g. flickering in the UI.
+	 *
+	 * ```svelte
+	 * <script>
+	 *   import { getTodos, addTodo } from './todos.remote.js';
+	 *   const todos = getTodos();
+	 * </script>
+	 *
+	 * <form {...addTodo.enhance(async ({ data, submit }) => {
+	 *   await submit().updates(todos.withOverride((todos) => [...todos, { text: data.get('text') }]));
+	 * }}>
+	 *   <input type="text" name="text" />
+	 *   <button type="submit">Add Todo</button>
+	 * </form>
+	 * ```
+	 */
+	withOverride: (
+		update: (current: Awaited<Output>) => Awaited<Output>
+	) => {
+		_key: string;
+		release: () => void;
+	};
+} & (
+		| {
+				/** The current value of the query. Undefined as long as there's no value yet */
+				get current(): undefined;
+				status: 'loading';
+		  }
+		| {
+				/** The current value of the query. Undefined as long as there's no value yet */
+				get current(): Awaited<Output>;
+				status: 'success' | 'reloading';
+		  }
+		| {
+				/** The current value of the query. Undefined as long as there's no value yet */
+				get current(): Awaited<Output> | undefined;
+				status: 'error';
+		  }
+	);
+```
+
+</div>
+
 ## RequestEvent
 
 <div class="ts-block">
@@ -2123,6 +2448,20 @@ isSubRequest: boolean;
 
 `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 
+</div>
+</div>
+
+<div class="ts-block-property">
+
+```dts
+isRemoteRequest: boolean;
+```
+
+<div class="ts-block-property-details">
+
+`true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
+related to the data request in this case. Use this property instead if the distinction is important to you.
+
 </div>
 </div></div>
 
@@ -2398,6 +2737,18 @@ nodes: SSRNodeLoader[];
 </div>
 <div class="ts-block-property">
 
+```dts
+remotes: Record<string, () => Promise<any>>;
+```
+
+<div class="ts-block-property-details">
+
+hashed filename -> import to that file
+
+</div>
+</div>
+<div class="ts-block-property">
+
 ```dts
 routes: SSRRoute[];
 ```
diff --git a/apps/svelte.dev/content/docs/kit/98-reference/20-$app-navigation.md b/apps/svelte.dev/content/docs/kit/98-reference/20-$app-navigation.md
index ac29666d0..57163c4dc 100644
--- a/apps/svelte.dev/content/docs/kit/98-reference/20-$app-navigation.md
+++ b/apps/svelte.dev/content/docs/kit/98-reference/20-$app-navigation.md
@@ -18,6 +18,7 @@ import {
 	preloadCode,
 	preloadData,
 	pushState,
+	refreshAll,
 	replaceState
 } from '$app/navigation';
 ```
@@ -248,6 +249,27 @@ function pushState(
 
 
 
+## refreshAll
+
+Causes all currently active remote functions to refresh, and all `load` functions belonging to the currently active page to re-run (unless disabled via the option argument).
+Returns a `Promise` that resolves when the page is subsequently updated.
+
+<div class="ts-block">
+
+```dts
+function refreshAll({
+	includeLoadFunctions
+}?:
+	| {
+			includeLoadFunctions?: boolean;
+	  }
+	| undefined): Promise<void>;
+```
+
+</div>
+
+
+
 ## replaceState
 
 Programmatically replace the current history entry with the given `page.state`. To use the current URL, you can pass `''` as the first argument. Used for [shallow routing](/docs/kit/shallow-routing).
diff --git a/apps/svelte.dev/content/docs/kit/98-reference/20-$app-server.md b/apps/svelte.dev/content/docs/kit/98-reference/20-$app-server.md
index 13c45a05d..ec129c1d0 100644
--- a/apps/svelte.dev/content/docs/kit/98-reference/20-$app-server.md
+++ b/apps/svelte.dev/content/docs/kit/98-reference/20-$app-server.md
@@ -7,9 +7,120 @@ title: $app/server
 
 ```js
 // @noErrors
-import { getRequestEvent, read } from '$app/server';
+import {
+	command,
+	form,
+	getRequestEvent,
+	prerender,
+	query,
+	read
+} from '$app/server';
 ```
 
+## command
+
+Creates a remote command. The given function is invoked directly on the server and via a fetch call on the client.
+
+```ts
+import { blogPosts } from '$lib/server/db';
+
+export interface BlogPost {
+	id: string;
+	title: string;
+	content: string;
+}
+
+export const like = command((postId: string) => {
+	blogPosts.get(postId).like();
+});
+```
+
+```svelte
+<script lang="ts">
+	import { like } from './blog.remote.js';
+
+	let post: BlogPost = $props();
+</script>
+
+<h1>{post.title}</h1>
+<p>{post.content}</p>
+<button onclick={() => like(post.id)}>♡</button>
+```
+
+<div class="ts-block">
+
+```dts
+function command<Output>(
+	fn: () => Output
+): RemoteCommand<void, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function command<Input, Output>(
+	validate: 'unchecked',
+	fn: (arg: Input) => Output
+): RemoteCommand<Input, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function command<Schema extends StandardSchemaV1, Output>(
+	validate: Schema,
+	fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Output
+): RemoteCommand<
+	StandardSchemaV1.InferOutput<Schema>,
+	Output
+>;
+```
+
+</div>
+
+
+
+## form
+
+Creates a form action. The passed function will be called when the form is submitted.
+Returns an object that can be spread onto a form element to connect it to the function.
+```ts
+import * as db from '$lib/server/db';
+
+export const createPost = form((formData) => {
+	const title = formData.get('title');
+	const content = formData.get('content');
+	return db.createPost({ title, content });
+});
+```
+```svelte
+<script>
+	import { createPost } from './blog.remote.js';
+</script>
+
+<form {...createPost}>
+	<input type="text" name="title" />
+	<textarea name="content" />
+	<button type="submit">Create</button>
+</form>
+```
+
+<div class="ts-block">
+
+```dts
+function form<T, U = never>(
+	fn: (formData: FormData) => T | IActionFailure<U>
+): RemoteFormAction<T, U>;
+```
+
+</div>
+
+
+
 ## getRequestEvent
 
 <blockquote class="since note">
@@ -35,6 +146,140 @@ function getRequestEvent(): RequestEvent<
 
 
 
+## prerender
+
+Creates a prerendered remote function. The given function is invoked at build time and the result is stored to disk.
+```ts
+import { blogPosts } from '$lib/server/db';
+
+export const blogPosts = prerender(() => blogPosts.getAll());
+```
+
+In case your function has an argument, you need to provide an `entries` function that returns a list representing the arguments to be used for prerendering.
+```ts
+import z from 'zod';
+import { blogPosts } from '$lib/server/db';
+
+export const blogPost = prerender(
+ z.string(),
+	(id) => blogPosts.get(id),
+	{ entries: () => blogPosts.getAll().map((post) => post.id) }
+);
+```
+
+<div class="ts-block">
+
+```dts
+function prerender<Output>(
+	fn: () => Output,
+	options?:
+		| {
+				entries?: RemotePrerenderEntryGenerator<void>;
+				dynamic?: boolean;
+		  }
+		| undefined
+): RemoteQuery<void, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function prerender<Input, Output>(
+	validate: 'unchecked',
+	fn: (arg: Input) => Output,
+	options?:
+		| {
+				entries?: RemotePrerenderEntryGenerator<Input>;
+				dynamic?: boolean;
+		  }
+		| undefined
+): RemoteQuery<Input, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function prerender<Schema extends StandardSchemaV1, Output>(
+	schema: Schema,
+	fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Output,
+	options?:
+		| {
+				entries?: RemotePrerenderEntryGenerator<
+					StandardSchemaV1.InferOutput<Schema>
+				>;
+				dynamic?: boolean;
+		  }
+		| undefined
+): RemoteQuery<
+	StandardSchemaV1.InferOutput<Schema>,
+	Output
+>;
+```
+
+</div>
+
+
+
+## query
+
+Creates a remote function that can be invoked like a regular function within components.
+The given function is invoked directly on the backend and via a fetch call on the client.
+```ts
+import { blogPosts } from '$lib/server/db';
+
+export const blogPosts = query(() => blogPosts.getAll());
+```
+```svelte
+<script>
+	import { blogPosts } from './blog.remote.js';
+</script>
+
+{#await blogPosts() then posts}
+	<!-- ... -->
+{/await}
+```
+
+<div class="ts-block">
+
+```dts
+function query<Output>(
+	fn: () => Output
+): RemoteQuery<void, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function query<Input, Output>(
+	validate: 'unchecked',
+	fn: (arg: Input) => Output
+): RemoteQuery<Input, Output>;
+```
+
+</div>
+
+<div class="ts-block">
+
+```dts
+function query<Schema extends StandardSchemaV1, Output>(
+	schema: Schema,
+	fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Output
+): RemoteQuery<
+	StandardSchemaV1.InferOutput<Schema>,
+	Output
+>;
+```
+
+</div>
+
+
+
 ## read
 
 <blockquote class="since note">
diff --git a/apps/svelte.dev/content/docs/kit/98-reference/50-configuration.md b/apps/svelte.dev/content/docs/kit/98-reference/50-configuration.md
index f84f417d4..9ed7566dc 100644
--- a/apps/svelte.dev/content/docs/kit/98-reference/50-configuration.md
+++ b/apps/svelte.dev/content/docs/kit/98-reference/50-configuration.md
@@ -359,6 +359,40 @@ A prefix that signals that an environment variable is unsafe to expose to client
 
 </div>
 
+## experimental
+
+<div class="ts-block-property-bullets">
+
+
+
+</div>
+
+Experimental features which are exempt from semantic versioning. These features may change or be removed at any time.
+
+<div class="ts-block-property-children">
+
+<div class="ts-block-property">
+
+```ts
+// @noErrors
+remoteFunctions?: boolean;
+```
+
+<div class="ts-block-property-details">
+
+<div class="ts-block-property-bullets">
+
+- <span class="tag">default</span> `false`
+
+</div>
+
+Whether to enable the experimental remote functions feature. This feature is not yet stable and may change or be removed at any time.
+
+</div>
+</div>
+
+</div>
+
 ## files
 
 <div class="ts-block-property-bullets">

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/sveltejs/svelte.dev/compare/sveltejs:0b335d6...sveltejs:13c4564.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/sveltejs/svelte.dev/compare/sveltejs:0b335d6...sveltejs:13c4564.diff" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/sveltejs/svelte.dev/compare/sveltejs:0b335d6...sveltejs:13c4564.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/sveltejs/svelte.dev/compare/sveltejs:0b335d6...sveltejs:13c4564.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>