@sveltejs/kit 2.37.0 → 2.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.37.0",
+  "version": "2.38.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",

package/src/exports/internal/remote-functions.js

@@ -10,9 +10,15 @@ export function validate_remote_functions(module, file) {
 	}
 
 	for (const name in module) {
-		const type = module[name]?.__?.type;
+		const type = /** @type {import('types').RemoteInfo['type']} */ (module[name]?.__?.type);
 
-		if (type !== 'form' && type !== 'command' && type !== 'query' && type !== 'prerender') {
+		if (
+			type !== 'form' &&
+			type !== 'command' &&
+			type !== 'query' &&
+			type !== 'query_batch' &&
+			type !== 'prerender'
+		) {
 			throw new Error(
 				`\`${name}\` exported from ${file} is invalid — all exports from this file must be remote functions`
 			);

package/src/runtime/app/server/remote/query.js

@@ -72,21 +72,15 @@ export function query(validate_or_fn, maybe_fn) {
 
 		const { event, state } = get_request_store();
 
-		const abort_controller = new AbortController();
 		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
-		const promise = get_response(
-			__.id,
-			arg,
-			state,
-			() => run_remote_function(event, state, false, arg, validate, fn),
-			abort_controller.signal
+		const promise = get_response(__.id, arg, state, () =>
+			run_remote_function(event, state, false, arg, validate, fn)
 		);
 
 		promise.catch(() => {});
 
 		/** @param {Output} value */
 		promise.set = (value) => {
-			abort_controller.abort();
 			const { state } = get_request_store();
 			const refreshes = state.refreshes;
 
@@ -97,7 +91,7 @@ export function query(validate_or_fn, maybe_fn) {
 			}
 
 			const cache_key = create_remote_cache_key(__.id, stringify_remote_arg(arg, state.transport));
-			refreshes[cache_key] = Promise.resolve(value);
+			refreshes[cache_key] = (state.remote_data ??= {})[cache_key] = Promise.resolve(value);
 		};
 
 		promise.refresh = () => {
@@ -118,7 +112,6 @@ export function query(validate_or_fn, maybe_fn) {
 		};
 
 		promise.withOverride = () => {
-			abort_controller.abort();
 			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
 		};
 
@@ -129,3 +122,149 @@ export function query(validate_or_fn, maybe_fn) {
 
 	return wrapper;
 }
+
+/**
+ * Creates a batch query function that collects multiple calls and executes them in a single request
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+ *
+ * @template Input
+ * @template Output
+ * @overload
+ * @param {'unchecked'} validate
+ * @param {(args: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} fn
+ * @returns {RemoteQueryFunction<Input, Output>}
+ * @since 2.35
+ */
+/**
+ * Creates a batch query function that collects multiple calls and executes them in a single request
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+ *
+ * @template {StandardSchemaV1} Schema
+ * @template Output
+ * @overload
+ * @param {Schema} schema
+ * @param {(args: StandardSchemaV1.InferOutput<Schema>[]) => MaybePromise<(arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output>} fn
+ * @returns {RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>}
+ * @since 2.35
+ */
+/**
+ * @template Input
+ * @template Output
+ * @param {any} validate_or_fn
+ * @param {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} [maybe_fn]
+ * @returns {RemoteQueryFunction<Input, Output>}
+ * @since 2.35
+ */
+/*@__NO_SIDE_EFFECTS__*/
+function batch(validate_or_fn, maybe_fn) {
+	/** @type {(args?: Input[]) => (arg: Input, idx: number) => Output} */
+	const fn = maybe_fn ?? validate_or_fn;
+
+	/** @type {(arg?: any) => MaybePromise<Input>} */
+	const validate = create_validator(validate_or_fn, maybe_fn);
+
+	/** @type {RemoteInfo & { type: 'query_batch' }} */
+	const __ = {
+		type: 'query_batch',
+		id: '',
+		name: '',
+		run: (args) => {
+			const { event, state } = get_request_store();
+
+			return run_remote_function(
+				event,
+				state,
+				false,
+				args,
+				(array) => Promise.all(array.map(validate)),
+				fn
+			);
+		}
+	};
+
+	/** @type {{ args: any[], resolvers: Array<{resolve: (value: any) => void, reject: (error: any) => void}> }} */
+	let batching = { args: [], resolvers: [] };
+
+	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteInfo }} */
+	const wrapper = (arg) => {
+		if (prerendering) {
+			throw new Error(
+				`Cannot call query.batch '${__.name}' while prerendering, as prerendered pages need static data. Use 'prerender' from $app/server instead`
+			);
+		}
+
+		const { event, state } = get_request_store();
+
+		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
+		const promise = get_response(__.id, arg, state, () => {
+			// Collect all the calls to the same query in the same macrotask,
+			// then execute them as one backend request.
+			return new Promise((resolve, reject) => {
+				// We don't need to deduplicate args here, because get_response already caches/reuses identical calls
+				batching.args.push(arg);
+				batching.resolvers.push({ resolve, reject });
+
+				if (batching.args.length > 1) return;
+
+				setTimeout(async () => {
+					const batched = batching;
+					batching = { args: [], resolvers: [] };
+
+					try {
+						const get_result = await run_remote_function(
+							event,
+							state,
+							false,
+							batched.args,
+							(array) => Promise.all(array.map(validate)),
+							fn
+						);
+
+						for (let i = 0; i < batched.resolvers.length; i++) {
+							try {
+								batched.resolvers[i].resolve(get_result(batched.args[i], i));
+							} catch (error) {
+								batched.resolvers[i].reject(error);
+							}
+						}
+					} catch (error) {
+						for (const resolver of batched.resolvers) {
+							resolver.reject(error);
+						}
+					}
+				}, 0);
+			});
+		});
+
+		promise.catch(() => {});
+
+		promise.refresh = async () => {
+			const { state } = get_request_store();
+			const refreshes = state.refreshes;
+
+			if (!refreshes) {
+				throw new Error(
+					`Cannot call refresh on query.batch '${__.name}' because it is not executed in the context of a command/form remote function`
+				);
+			}
+
+			const cache_key = create_remote_cache_key(__.id, stringify_remote_arg(arg, state.transport));
+			refreshes[cache_key] = await /** @type {Promise<any>} */ (promise);
+		};
+
+		promise.withOverride = () => {
+			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+		};
+
+		return /** @type {RemoteQuery<Output>} */ (promise);
+	};
+
+	Object.defineProperty(wrapper, '__', { value: __ });
+
+	return wrapper;
+}
+
+// Add batch as a property to the query function
+Object.defineProperty(query, 'batch', { value: batch, enumerable: true });

package/src/runtime/app/server/remote/shared.js

@@ -66,16 +66,14 @@ export function create_validator(validate_or_fn, maybe_fn) {
  * @param {any} arg
  * @param {RequestState} state
  * @param {() => Promise<T>} get_result
- * @param {AbortSignal | undefined=} signal
  * @returns {Promise<T>}
  */
-export async function get_response(id, arg, state, get_result, signal) {
-	if (signal) {
-		await new Promise((r) => setTimeout(r, 0));
-		if (signal.aborted) throw new DOMException('The operation was aborted.', 'AbortError');
-	}
-	const cache_key = create_remote_cache_key(id, stringify_remote_arg(arg, state.transport));
+export async function get_response(id, arg, state, get_result) {
+	// wait a beat, in case `myQuery().set(...)` is immediately called
+	// eslint-disable-next-line @typescript-eslint/await-thenable
+	await 0;
 
+	const cache_key = create_remote_cache_key(id, stringify_remote_arg(arg, state.transport));
 	return ((state.remote_data ??= {})[cache_key] ??= get_result());
 }
 

package/src/runtime/client/remote-functions/form.svelte.js

@@ -32,7 +32,7 @@ export function form(id) {
 		const action = '?/remote=' + encodeURIComponent(action_id);
 
 		/** @type {any} */
-		let result = $state(started ? undefined : remote_responses[action_id]);
+		let result = $state.raw(started ? undefined : remote_responses[action_id]);
 
 		/** @type {number} */
 		let pending_count = $state(0);
@@ -105,7 +105,7 @@ export function form(id) {
 						void _goto(form_result.location, { invalidateAll }, 0);
 					} else {
 						result = undefined;
-						throw new HttpError(500, form_result.error);
+						throw new HttpError(form_result.status ?? 500, form_result.error);
 					}
 				} catch (e) {
 					result = undefined;

package/src/runtime/client/remote-functions/index.js

@@ -1,4 +1,4 @@
 export { command } from './command.svelte.js';
 export { form } from './form.svelte.js';
 export { prerender } from './prerender.svelte.js';
-export { query } from './query.svelte.js';
+export { query, query_batch } from './query.svelte.js';

package/src/runtime/client/remote-functions/query.svelte.js

@@ -1,8 +1,11 @@
 /** @import { RemoteQueryFunction } from '@sveltejs/kit' */
+/** @import { RemoteFunctionResponse } from 'types' */
 import { app_dir, base } from '__sveltekit/paths';
-import { remote_responses, started } from '../client.js';
+import { app, goto, remote_responses, started } from '../client.js';
 import { tick } from 'svelte';
 import { create_remote_function, remote_request } from './shared.svelte.js';
+import * as devalue from 'devalue';
+import { HttpError, Redirect } from '@sveltejs/kit/internal';
 
 /**
  * @param {string} id
@@ -25,6 +28,97 @@ export function query(id) {
 	});
 }
 
+/**
+ * @param {string} id
+ * @returns {(arg: any) => Query<any>}
+ */
+export function query_batch(id) {
+	/** @type {Map<string, Array<{resolve: (value: any) => void, reject: (error: any) => void}>>} */
+	let batching = new Map();
+
+	return create_remote_function(id, (cache_key, payload) => {
+		return new Query(cache_key, () => {
+			if (!started) {
+				const result = remote_responses[cache_key];
+				if (result) {
+					return result;
+				}
+			}
+
+			// Collect all the calls to the same query in the same macrotask,
+			// then execute them as one backend request.
+			return new Promise((resolve, reject) => {
+				// create_remote_function caches identical calls, but in case a refresh to the same query is called multiple times this function
+				// is invoked multiple times with the same payload, so we need to deduplicate here
+				const entry = batching.get(payload) ?? [];
+				entry.push({ resolve, reject });
+				batching.set(payload, entry);
+
+				if (batching.size > 1) return;
+
+				// Wait for the next macrotask - don't use microtask as Svelte runtime uses these to collect changes and flush them,
+				// and flushes could reveal more queries that should be batched.
+				setTimeout(async () => {
+					const batched = batching;
+					batching = new Map();
+
+					try {
+						const response = await fetch(`${base}/${app_dir}/remote/${id}`, {
+							method: 'POST',
+							body: JSON.stringify({
+								payloads: Array.from(batched.keys())
+							}),
+							headers: {
+								'Content-Type': 'application/json'
+							}
+						});
+
+						if (!response.ok) {
+							throw new Error('Failed to execute batch query');
+						}
+
+						const result = /** @type {RemoteFunctionResponse} */ (await response.json());
+						if (result.type === 'error') {
+							throw new HttpError(result.status ?? 500, result.error);
+						}
+
+						if (result.type === 'redirect') {
+							// TODO double-check this
+							await goto(result.location);
+							await new Promise((r) => setTimeout(r, 100));
+							throw new Redirect(307, result.location);
+						}
+
+						const results = devalue.parse(result.result, app.decoders);
+
+						// Resolve individual queries
+						// Maps guarantee insertion order so we can do it like this
+						let i = 0;
+
+						for (const resolvers of batched.values()) {
+							for (const { resolve, reject } of resolvers) {
+								if (results[i].type === 'error') {
+									reject(new HttpError(results[i].status, results[i].error));
+								} else {
+									resolve(results[i].data);
+								}
+							}
+							i++;
+						}
+					} catch (error) {
+						// Reject all queries in the batch
+						for (const resolver of batched.values()) {
+							for (const { reject } of resolver) {
+								reject(error);
+							}
+						}
+					}
+				}, 0);
+			});
+		});
+	});
+}
+
 /**
  * @template T
  * @implements {Partial<Promise<T>>}

package/src/runtime/server/data/index.js

@@ -2,11 +2,10 @@ import { text } from '@sveltejs/kit';
 import { HttpError, SvelteKitError, Redirect } from '@sveltejs/kit/internal';
 import { normalize_error } from '../../../utils/error.js';
 import { once } from '../../../utils/functions.js';
+import { server_data_serializer_json } from '../page/data_serializer.js';
 import { load_server_data } from '../page/load_data.js';
-import { clarify_devalue_error, handle_error_and_jsonify, serialize_uses } from '../utils.js';
+import { handle_error_and_jsonify } from '../utils.js';
 import { normalize_path } from '../../../utils/url.js';
-import * as devalue from 'devalue';
-import { create_async_iterator } from '../../../utils/streaming.js';
 import { text_encoder } from '../../utils.js';
 
 /**
@@ -120,7 +119,9 @@ export async function render_data(
 			)
 		);
 
-		const { data, chunks } = get_data_json(event, event_state, options, nodes);
+		const data_serializer = server_data_serializer_json(event, event_state, options);
+		for (let i = 0; i < nodes.length; i++) data_serializer.add_node(i, nodes[i]);
+		const { data, chunks } = data_serializer.get_data();
 
 		if (!chunks) {
 			// use a normal JSON response where possible, so we get `content-length`
@@ -185,92 +186,3 @@ export function redirect_json_response(redirect) {
 		})
 	);
 }
-
-/**
- * If the serialized data contains promises, `chunks` will be an
- * async iterable containing their resolutions
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
- * @param {import('types').SSROptions} options
- * @param {Array<import('types').ServerDataSkippedNode | import('types').ServerDataNode | import('types').ServerErrorNode | null | undefined>} nodes
- *  @returns {{ data: string, chunks: AsyncIterable<string> | null }}
- */
-export function get_data_json(event, event_state, options, nodes) {
-	let promise_id = 1;
-	let count = 0;
-
-	const { iterator, push, done } = create_async_iterator();
-
-	const reducers = {
-		...Object.fromEntries(
-			Object.entries(options.hooks.transport).map(([key, value]) => [key, value.encode])
-		),
-		/** @param {any} thing */
-		Promise: (thing) => {
-			if (typeof thing?.then === 'function') {
-				const id = promise_id++;
-				count += 1;
-
-				/** @type {'data' | 'error'} */
-				let key = 'data';
-
-				thing
-					.catch(
-						/** @param {any} e */ async (e) => {
-							key = 'error';
-							return handle_error_and_jsonify(event, event_state, options, /** @type {any} */ (e));
-						}
-					)
-					.then(
-						/** @param {any} value */
-						async (value) => {
-							let str;
-							try {
-								str = devalue.stringify(value, reducers);
-							} catch {
-								const error = await handle_error_and_jsonify(
-									event,
-									event_state,
-									options,
-									new Error(`Failed to serialize promise while rendering ${event.route.id}`)
-								);
-
-								key = 'error';
-								str = devalue.stringify(error, reducers);
-							}
-
-							count -= 1;
-
-							push(`{"type":"chunk","id":${id},"${key}":${str}}\n`);
-							if (count === 0) done();
-						}
-					);
-
-				return id;
-			}
-		}
-	};
-
-	try {
-		const strings = nodes.map((node) => {
-			if (!node) return 'null';
-
-			if (node.type === 'error' || node.type === 'skip') {
-				return JSON.stringify(node);
-			}
-
-			return `{"type":"data","data":${devalue.stringify(node.data, reducers)},"uses":${JSON.stringify(
-				serialize_uses(node)
-			)}${node.slash ? `,"slash":${JSON.stringify(node.slash)}` : ''}}`;
-		});
-
-		return {
-			data: `{"type":"data","nodes":[${strings.join(',')}]}\n`,
-			chunks: count > 0 ? iterator : null
-		};
-	} catch (e) {
-		// @ts-expect-error
-		e.path = 'data' + e.path;
-		throw new Error(clarify_devalue_error(event, /** @type {any} */ (e)));
-	}
-}

package/src/runtime/server/page/data_serializer.js

@@ -0,0 +1,202 @@
+import * as devalue from 'devalue';
+import { create_async_iterator } from '../../../utils/streaming.js';
+import {
+	clarify_devalue_error,
+	get_global_name,
+	handle_error_and_jsonify,
+	serialize_uses
+} from '../utils.js';
+
+/**
+ * If the serialized data contains promises, `chunks` will be an
+ * async iterable containing their resolutions
+ * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
+ * @param {import('types').SSROptions} options
+ * @returns {import('./types.js').ServerDataSerializer}
+ */
+export function server_data_serializer(event, event_state, options) {
+	let promise_id = 1;
+
+	const iterator = create_async_iterator();
+	const global = get_global_name(options);
+
+	/** @param {any} thing */
+	function replacer(thing) {
+		if (typeof thing?.then === 'function') {
+			const id = promise_id++;
+
+			const promise = thing
+				.then(/** @param {any} data */ (data) => ({ data }))
+				.catch(
+					/** @param {any} error */ async (error) => ({
+						error: await handle_error_and_jsonify(event, event_state, options, error)
+					})
+				)
+				.then(
+					/**
+					 * @param {{data: any; error: any}} result
+					 */
+					async ({ data, error }) => {
+						let str;
+						try {
+							str = devalue.uneval(error ? [, error] : [data], replacer);
+						} catch {
+							error = await handle_error_and_jsonify(
+								event,
+								event_state,
+								options,
+								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+							);
+							data = undefined;
+							str = devalue.uneval([, error], replacer);
+						}
+
+						return `${global}.resolve(${id}, ${str.includes('app.decode') ? `(app) => ${str}` : `() => ${str}`})`;
+					}
+				);
+
+			iterator.add(promise);
+
+			return `${global}.defer(${id})`;
+		} else {
+			for (const key in options.hooks.transport) {
+				const encoded = options.hooks.transport[key].encode(thing);
+				if (encoded) {
+					return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
+				}
+			}
+		}
+	}
+
+	const strings = /** @type {string[]} */ ([]);
+
+	return {
+		add_node(i, node) {
+			try {
+				if (!node) {
+					strings[i] = 'null';
+					return;
+				}
+
+				/** @type {any} */
+				const payload = { type: 'data', data: node.data, uses: serialize_uses(node) };
+				if (node.slash) payload.slash = node.slash;
+
+				strings[i] = devalue.uneval(payload, replacer);
+			} catch (e) {
+				// @ts-expect-error
+				e.path = e.path.slice(1);
+				throw new Error(clarify_devalue_error(event, /** @type {any} */ (e)));
+			}
+		},
+
+		get_data(csp) {
+			const open = `<script${csp.script_needs_nonce ? ` nonce="${csp.nonce}"` : ''}>`;
+			const close = `</script>\n`;
+
+			return {
+				data: `[${strings.join(',')}]`,
+				chunks: promise_id > 1 ? iterator.iterate((str) => open + str + close) : null
+			};
+		}
+	};
+}
+
+/**
+ * If the serialized data contains promises, `chunks` will be an
+ * async iterable containing their resolutions
+ * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
+ * @param {import('types').SSROptions} options
+ * @returns {import('./types.js').ServerDataSerializerJson}
+ */
+export function server_data_serializer_json(event, event_state, options) {
+	let promise_id = 1;
+
+	const iterator = create_async_iterator();
+
+	const reducers = {
+		...Object.fromEntries(
+			Object.entries(options.hooks.transport).map(([key, value]) => [key, value.encode])
+		),
+		/** @param {any} thing */
+		Promise: (thing) => {
+			if (typeof thing?.then !== 'function') {
+				return;
+			}
+
+			const id = promise_id++;
+
+			/** @type {'data' | 'error'} */
+			let key = 'data';
+
+			const promise = thing
+				.catch(
+					/** @param {any} e */ async (e) => {
+						key = 'error';
+						return handle_error_and_jsonify(event, event_state, options, /** @type {any} */ (e));
+					}
+				)
+				.then(
+					/** @param {any} value */
+					async (value) => {
+						let str;
+						try {
+							str = devalue.stringify(value, reducers);
+						} catch {
+							const error = await handle_error_and_jsonify(
+								event,
+								event_state,
+								options,
+								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+							);
+
+							key = 'error';
+							str = devalue.stringify(error, reducers);
+						}
+
+						return `{"type":"chunk","id":${id},"${key}":${str}}\n`;
+					}
+				);
+
+			iterator.add(promise);
+
+			return id;
+		}
+	};
+
+	const strings = /** @type {string[]} */ ([]);
+
+	return {
+		add_node(i, node) {
+			try {
+				if (!node) {
+					strings[i] = 'null';
+					return;
+				}
+
+				if (node.type === 'error' || node.type === 'skip') {
+					strings[i] = JSON.stringify(node);
+					return;
+				}
+
+				strings[i] =
+					`{"type":"data","data":${devalue.stringify(node.data, reducers)},"uses":${JSON.stringify(
+						serialize_uses(node)
+					)}${node.slash ? `,"slash":${JSON.stringify(node.slash)}` : ''}}`;
+			} catch (e) {
+				// @ts-expect-error
+				e.path = 'data' + e.path;
+				throw new Error(clarify_devalue_error(event, /** @type {any} */ (e)));
+			}
+		},
+
+		get_data() {
+			return {
+				data: `{"type":"data","nodes":[${strings.join(',')}]}\n`,
+				chunks: promise_id > 1 ? iterator.iterate() : null
+			};
+		}
+	};
+}

package/src/runtime/server/page/index.js

@@ -10,10 +10,10 @@ import {
 	is_action_json_request,
 	is_action_request
 } from './actions.js';
+import { server_data_serializer, server_data_serializer_json } from './data_serializer.js';
 import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
-import { get_data_json } from '../data/index.js';
 import { DEV } from 'esm-env';
 import { get_remote_action, handle_remote_form_post } from '../remote.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
@@ -147,7 +147,8 @@ export async function render_page(
 				options,
 				manifest,
 				state,
-				resolve_opts
+				resolve_opts,
+				data_serializer: server_data_serializer(event, event_state, options)
 			});
 		}
 
@@ -157,6 +158,12 @@ export async function render_page(
 		/** @type {Error | null} */
 		let load_error = null;
 
+		const data_serializer = server_data_serializer(event, event_state, options);
+		const data_serializer_json =
+			state.prerendering && should_prerender_data
+				? server_data_serializer_json(event, event_state, options)
+				: null;
+
 		/** @type {Array<Promise<import('types').ServerDataNode | null>>} */
 		const server_promises = nodes.data.map((node, i) => {
 			if (load_error) {
@@ -172,7 +179,7 @@ export async function render_page(
 						throw action_result.error;
 					}
 
-					return await load_server_data({
+					const server_data = await load_server_data({
 						event,
 						event_state,
 						state,
@@ -187,6 +194,11 @@ export async function render_page(
 							return data;
 						}
 					});
+
+					data_serializer.add_node(i, server_data);
+					data_serializer_json?.add_node(i, server_data);
+
+					return server_data;
 				} catch (e) {
 					load_error = /** @type {Error} */ (e);
 					throw load_error;
@@ -287,7 +299,8 @@ export async function render_page(
 									data: null,
 									server_data: null
 								}),
-								fetched
+								fetched,
+								data_serializer: server_data_serializer(event, event_state, options)
 							});
 						}
 					}
@@ -303,14 +316,9 @@ export async function render_page(
 			}
 		}
 
-		if (state.prerendering && should_prerender_data) {
+		if (state.prerendering && data_serializer_json) {
 			// ndjson format
-			let { data, chunks } = get_data_json(
-				event,
-				event_state,
-				options,
-				branch.map((node) => node?.server_data)
-			);
+			let { data, chunks } = data_serializer_json.get_data();
 
 			if (chunks) {
 				for await (const chunk of chunks) {
@@ -339,7 +347,8 @@ export async function render_page(
 			error: null,
 			branch: ssr === false ? [] : compact(branch),
 			action_result,
-			fetched
+			fetched,
+			data_serializer
 		});
 	} catch (e) {
 		// if we end up here, it means the data loaded successfully

package/src/runtime/server/page/load_data.js

@@ -1,12 +1,11 @@
 import { DEV } from 'esm-env';
-import * as devalue from 'devalue';
 import { disable_search, make_trackable } from '../../../utils/url.js';
 import { validate_depends, validate_load_response } from '../../shared.js';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { record_span } from '../../telemetry/record_span.js';
-import { clarify_devalue_error, get_node_type } from '../utils.js';
 import { base64_encode, text_decoder } from '../../utils.js';
 import { NULL_BODY_STATUS } from '../constants.js';
+import { get_node_type } from '../utils.js';
 
 /**
  * Calls the user's server `load` function.
@@ -234,38 +233,11 @@ export async function load_data({
 		},
 		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
-			return await with_request_store({ event: traced_event, state: event_state }, () => {
-				/** @type {Record<string, any> | null} */
-				let data = null;
-
-				return load.call(null, {
+			return await with_request_store({ event: traced_event, state: event_state }, () =>
+				load.call(null, {
 					url: event.url,
 					params: event.params,
-					get data() {
-						if (data === null && server_data_node?.data != null) {
-							/** @type {Record<string, (value: any) => any>} */
-							const reducers = {};
-
-							/** @type {Record<string, (value: any) => any>} */
-							const revivers = {};
-
-							for (const key in event_state.transport) {
-								reducers[key] = event_state.transport[key].encode;
-								revivers[key] = event_state.transport[key].decode;
-							}
-
-							// run it through devalue so that the developer can't accidentally mutate it
-							try {
-								data = devalue.parse(devalue.stringify(server_data_node.data, reducers), revivers);
-							} catch (e) {
-								// @ts-expect-error
-								e.path = e.path.slice(1);
-								throw new Error(clarify_devalue_error(event, /** @type {any} */ (e)));
-							}
-						}
-
-						return data;
-					},
+					data: server_data_node?.data ?? null,
 					route: event.route,
 					fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
 					setHeaders: event.setHeaders,
@@ -273,8 +245,8 @@ export async function load_data({
 					parent,
 					untrack: (fn) => fn(),
 					tracing: traced_event.tracing
-				});
-			});
+				})
+			);
 		}
 	});
 

package/src/runtime/server/page/render.js

@@ -8,15 +8,14 @@ import { serialize_data } from './serialize_data.js';
 import { s } from '../../../utils/misc.js';
 import { Csp } from './csp.js';
 import { uneval_action_response } from './actions.js';
-import { clarify_devalue_error, handle_error_and_jsonify, serialize_uses } from '../utils.js';
 import { public_env } from '../../shared-server.js';
-import { create_async_iterator } from '../../../utils/streaming.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { SCHEME } from '../../../utils/url.js';
 import { create_server_routing_response, generate_route_object } from './server_routing.js';
 import { add_resolution_suffix } from '../../pathname.js';
 import { with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
+import { get_global_name } from '../utils.js';
 
 // TODO rename this function/module
 
@@ -40,6 +39,7 @@ const updated = {
  *   event_state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   action_result?: import('@sveltejs/kit').ActionResult;
+ *   data_serializer: import('./types.js').ServerDataSerializer
  * }} opts
  */
 export async function render_response({
@@ -54,7 +54,8 @@ export async function render_response({
 	event,
 	event_state,
 	resolve_opts,
-	action_result
+	action_result,
+	data_serializer
 }) {
 	if (state.prerendering) {
 		if (options.csp.mode === 'nonce') {
@@ -295,16 +296,8 @@ export async function render_response({
 		}
 	}
 
-	const global = DEV ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
-
-	const { data, chunks } = get_data(
-		event,
-		event_state,
-		options,
-		branch.map((b) => b.server_data),
-		csp,
-		global
-	);
+	const global = get_global_name(options);
+	const { data, chunks } = data_serializer.get_data(csp);
 
 	if (page_config.ssr && page_config.csr) {
 		body += `\n\t\t\t${fetched
@@ -644,95 +637,3 @@ export async function render_response({
 				}
 			);
 }
-
-/**
- * If the serialized data contains promises, `chunks` will be an
- * async iterable containing their resolutions
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
- * @param {import('types').SSROptions} options
- * @param {Array<import('types').ServerDataNode | null>} nodes
- * @param {import('./csp.js').Csp} csp
- * @param {string} global
- * @returns {{ data: string, chunks: AsyncIterable<string> | null }}
- */
-function get_data(event, event_state, options, nodes, csp, global) {
-	let promise_id = 1;
-	let count = 0;
-
-	const { iterator, push, done } = create_async_iterator();
-
-	/** @param {any} thing */
-	function replacer(thing) {
-		if (typeof thing?.then === 'function') {
-			const id = promise_id++;
-			count += 1;
-
-			thing
-				.then(/** @param {any} data */ (data) => ({ data }))
-				.catch(
-					/** @param {any} error */ async (error) => ({
-						error: await handle_error_and_jsonify(event, event_state, options, error)
-					})
-				)
-				.then(
-					/**
-					 * @param {{data: any; error: any}} result
-					 */
-					async ({ data, error }) => {
-						count -= 1;
-
-						let str;
-						try {
-							str = devalue.uneval(error ? [, error] : [data], replacer);
-						} catch {
-							error = await handle_error_and_jsonify(
-								event,
-								event_state,
-								options,
-								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
-							);
-							data = undefined;
-							str = devalue.uneval([, error], replacer);
-						}
-
-						const nonce = csp.script_needs_nonce ? ` nonce="${csp.nonce}"` : '';
-						push(
-							`<script${nonce}>${global}.resolve(${id}, ${str.includes('app.decode') ? `(app) => ${str}` : `() => ${str}`})</script>\n`
-						);
-						if (count === 0) done();
-					}
-				);
-
-			return `${global}.defer(${id})`;
-		} else {
-			for (const key in options.hooks.transport) {
-				const encoded = options.hooks.transport[key].encode(thing);
-				if (encoded) {
-					return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
-				}
-			}
-		}
-	}
-
-	try {
-		const strings = nodes.map((node) => {
-			if (!node) return 'null';
-
-			/** @type {any} */
-			const payload = { type: 'data', data: node.data, uses: serialize_uses(node) };
-			if (node.slash) payload.slash = node.slash;
-
-			return devalue.uneval(payload, replacer);
-		});
-
-		return {
-			data: `[${strings.join(',')}]`,
-			chunks: count > 0 ? iterator : null
-		};
-	} catch (e) {
-		// @ts-expect-error
-		e.path = e.path.slice(1);
-		throw new Error(clarify_devalue_error(event, /** @type {any} */ (e)));
-	}
-}

package/src/runtime/server/page/respond_with_error.js

@@ -4,6 +4,7 @@ import { load_data, load_server_data } from './load_data.js';
 import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
 import { get_status } from '../../../utils/error.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
+import { server_data_serializer } from './data_serializer.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -45,6 +46,7 @@ export async function respond_with_error({
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
+		const data_serializer = server_data_serializer(event, event_state, options);
 
 		if (ssr) {
 			state.error = true;
@@ -59,6 +61,7 @@ export async function respond_with_error({
 			});
 
 			const server_data = await server_data_promise;
+			data_serializer.add_node(0, server_data);
 
 			const data = await load_data({
 				event,
@@ -101,7 +104,8 @@ export async function respond_with_error({
 			fetched,
 			event,
 			event_state,
-			resolve_opts
+			resolve_opts,
+			data_serializer
 		});
 	} catch (e) {
 		// Edge case: If route is a 404 and the user redirects to somewhere from the root layout,

package/src/runtime/server/page/types.d.ts

@@ -1,5 +1,12 @@
 import { CookieSerializeOptions } from 'cookie';
-import { SSRNode, CspDirectives, ServerDataNode } from 'types';
+import {
+	CspDirectives,
+	ServerDataNode,
+	SSRNode,
+	ServerDataSkippedNode,
+	ServerErrorNode
+} from 'types';
+import { Csp } from './csp.js';
 
 export interface Fetched {
 	url: string;
@@ -34,3 +41,16 @@ export interface Cookie {
 	value: string;
 	options: CookieSerializeOptions & { path: string };
 }
+
+export type ServerDataSerializer = {
+	add_node(i: number, node: ServerDataNode | null): void;
+	get_data(csp: Csp): { data: string; chunks: AsyncIterable<string> | null };
+};
+
+export type ServerDataSerializerJson = {
+	add_node(
+		i: number,
+		node: ServerDataSkippedNode | ServerDataNode | ServerErrorNode | null | undefined
+	): void;
+	get_data(): { data: string; chunks: AsyncIterable<string> | null };
+};

package/src/runtime/server/remote.js

@@ -60,12 +60,57 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 	let form_client_refreshes;
 
 	try {
+		if (info.type === 'query_batch') {
+			if (event.request.method !== 'POST') {
+				throw new SvelteKitError(
+					405,
+					'Method Not Allowed',
+					`\`query.batch\` functions must be invoked via POST request, not ${event.request.method}`
+				);
+			}
+
+			/** @type {{ payloads: string[] }} */
+			const { payloads } = await event.request.json();
+
+			const args = payloads.map((payload) => parse_remote_arg(payload, transport));
+			const get_result = await with_request_store({ event, state }, () => info.run(args));
+			const results = await Promise.all(
+				args.map(async (arg, i) => {
+					try {
+						return { type: 'result', data: get_result(arg, i) };
+					} catch (error) {
+						return {
+							type: 'error',
+							error: await handle_error_and_jsonify(event, state, options, error),
+							status:
+								error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
+						};
+					}
+				})
+			);
+
+			return json(
+				/** @type {RemoteFunctionResponse} */ ({
+					type: 'result',
+					result: stringify(results, transport)
+				})
+			);
+		}
+
 		if (info.type === 'form') {
+			if (event.request.method !== 'POST') {
+				throw new SvelteKitError(
+					405,
+					'Method Not Allowed',
+					`\`form\` functions must be invoked via POST request, not ${event.request.method}`
+				);
+			}
+
 			if (!is_form_content_type(event.request)) {
 				throw new SvelteKitError(
 					415,
 					'Unsupported Media Type',
-					`Form actions expect form-encoded data — received ${event.request.headers.get(
+					`\`form\` functions expect form-encoded data — received ${event.request.headers.get(
 						'content-type'
 					)}`
 				);

package/src/runtime/server/respond.js

@@ -35,6 +35,7 @@ import {
 	strip_data_suffix,
 	strip_resolution_suffix
 } from '../pathname.js';
+import { server_data_serializer } from './page/data_serializer.js';
 import { get_remote_id, handle_remote_call } from './remote.js';
 import { record_span } from '../telemetry/record_span.js';
 import { otel } from '../telemetry/otel.js';
@@ -542,7 +543,8 @@ export async function internal_respond(request, options, manifest, state) {
 					error: null,
 					branch: [],
 					fetched: [],
-					resolve_opts
+					resolve_opts,
+					data_serializer: server_data_serializer(event, event_state, options)
 				});
 			}
 

package/src/runtime/server/utils.js

@@ -44,6 +44,13 @@ export function allowed_methods(mod) {
 	return allowed;
 }
 
+/**
+ * @param {import('types').SSROptions} options
+ */
+export function get_global_name(options) {
+	return DEV ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
+}
+
 /**
  * Return as a response that renders the error.html
  *

package/src/types/internal.d.ts

@@ -553,6 +553,16 @@ export type RemoteInfo =
 			id: string;
 			name: string;
 	  }
+	| {
+			/**
+			 * Corresponds to the name of the client-side exports (that's why we use underscores and not dots)
+			 */
+			type: 'query_batch';
+			id: string;
+			name: string;
+			/** Direct access to the function without batching etc logic, for remote functions called from the client */
+			run: (args: any[]) => Promise<(arg: any, idx: number) => any>;
+	  }
 	| {
 			type: 'form';
 			id: string;

package/src/utils/routing.js

@@ -240,6 +240,8 @@ const basic_param_pattern = /\[(\[)?(\.\.\.)?(\w+?)(?:=(\w+))?\]\]?/g;
  */
 export function resolve_route(id, params) {
 	const segments = get_route_segments(id);
+	const has_id_trailing_slash = id != '/' && id.endsWith('/');
+
 	return (
 		'/' +
 		segments
@@ -262,7 +264,8 @@ export function resolve_route(id, params) {
 				})
 			)
 			.filter(Boolean)
-			.join('/')
+			.join('/') +
+		(has_id_trailing_slash ? '/' : '')
 	);
 }
 

package/src/utils/streaming.js

@@ -16,36 +16,50 @@ function defer() {
 
 /**
  * Create an async iterator and a function to push values into it
+ * @template T
  * @returns {{
- *   iterator: AsyncIterable<any>;
- *   push: (value: any) => void;
- *   done: () => void;
+ *   iterate: (transform?: (input: T) => T) => AsyncIterable<T>;
+ *   add: (promise: Promise<T>) => void;
  * }}
  */
 export function create_async_iterator() {
+	let count = 0;
+
 	const deferred = [defer()];
 
 	return {
-		iterator: {
-			[Symbol.asyncIterator]() {
-				return {
-					next: async () => {
-						const next = await deferred[0].promise;
-						if (!next.done) deferred.shift();
-						return next;
-					}
-				};
-			}
+		iterate: (transform = (x) => x) => {
+			return {
+				[Symbol.asyncIterator]() {
+					return {
+						next: async () => {
+							const next = await deferred[0].promise;
+
+							if (!next.done) {
+								deferred.shift();
+								return { value: transform(next.value), done: false };
+							}
+
+							return next;
+						}
+					};
+				}
+			};
 		},
-		push: (value) => {
-			deferred[deferred.length - 1].fulfil({
-				value,
-				done: false
+		add: (promise) => {
+			count += 1;
+
+			void promise.then((value) => {
+				deferred[deferred.length - 1].fulfil({
+					value,
+					done: false
+				});
+				deferred.push(defer());
+
+				if (--count === 0) {
+					deferred[deferred.length - 1].fulfil({ done: true });
+				}
 			});
-			deferred.push(defer());
-		},
-		done: () => {
-			deferred[deferred.length - 1].fulfil({ done: true });
 		}
 	};
 }

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.37.0';
+export const VERSION = '2.38.0';

package/types/index.d.ts

@@ -2922,6 +2922,24 @@ declare module '$app/server' {
 	 * @since 2.27
 	 */
 	export function query<Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+	export namespace query {
+		/**
+		 * Creates a batch query function that collects multiple calls and executes them in a single request
+		 *
+		 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+		 *
+		 * @since 2.35
+		 */
+		function batch<Input, Output>(validate: "unchecked", fn: (args: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>): RemoteQueryFunction<Input, Output>;
+		/**
+		 * Creates a batch query function that collects multiple calls and executes them in a single request
+		 *
+		 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+		 *
+		 * @since 2.35
+		 */
+		function batch<Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (args: StandardSchemaV1.InferOutput<Schema>[]) => MaybePromise<(arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+	}
 	type RemotePrerenderInputsGenerator<Input = any> = () => MaybePromise<Input[]>;
 	type MaybePromise<T> = T | Promise<T>;
 

package/types/index.d.ts.map

@@ -187,6 +187,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }