@sveltejs/kit 2.38.0 → 2.39.0

package/package.json

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

package/src/core/adapt/builder.js

@@ -1,7 +1,7 @@
 /** @import { Builder } from '@sveltejs/kit' */
 /** @import { ResolvedConfig } from 'vite' */
 /** @import { RouteDefinition } from '@sveltejs/kit' */
-/** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger } from 'types' */
+/** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger, RemoteChunk } from 'types' */
 import colors from 'kleur';
 import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
 import { extname, resolve, join, dirname, relative } from 'node:path';
@@ -32,6 +32,7 @@ const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.w
  *   prerender_map: PrerenderMap;
  *   log: Logger;
  *   vite_config: ResolvedConfig;
+ *   remotes: RemoteChunk[]
  * }} opts
  * @returns {Builder}
  */
@@ -43,7 +44,8 @@ export function create_builder({
 	prerendered,
 	prerender_map,
 	log,
-	vite_config
+	vite_config,
+	remotes
 }) {
 	/** @type {Map<RouteDefinition, RouteData>} */
 	const lookup = new Map();
@@ -145,7 +147,8 @@ export function create_builder({
 								build_data,
 								prerendered: [],
 								relative_path: relativePath,
-								routes: Array.from(filtered)
+								routes: Array.from(filtered),
+								remotes
 							})
 					});
 				}
@@ -195,7 +198,8 @@ export function create_builder({
 				relative_path: relativePath,
 				routes: subset
 					? subset.map((route) => /** @type {import('types').RouteData} */ (lookup.get(route)))
-					: route_data.filter((route) => prerender_map.get(route.id) !== true)
+					: route_data.filter((route) => prerender_map.get(route.id) !== true),
+				remotes
 			});
 		},
 

package/src/core/adapt/index.js

@@ -8,6 +8,7 @@ import { create_builder } from './builder.js';
  * @param {import('types').Prerendered} prerendered
  * @param {import('types').PrerenderMap} prerender_map
  * @param {import('types').Logger} log
+ * @param {import('types').RemoteChunk[]} remotes
  * @param {import('vite').ResolvedConfig} vite_config
  */
 export async function adapt(
@@ -17,6 +18,7 @@ export async function adapt(
 	prerendered,
 	prerender_map,
 	log,
+	remotes,
 	vite_config
 ) {
 	// This is only called when adapter is truthy, so the cast is safe
@@ -32,6 +34,7 @@ export async function adapt(
 		prerendered,
 		prerender_map,
 		log,
+		remotes,
 		vite_config
 	});
 

package/src/core/generate_manifest/index.js

@@ -1,3 +1,4 @@
+/** @import { RemoteChunk } from 'types' */
 import fs from 'node:fs';
 import path from 'node:path';
 import * as mime from 'mrmime';
@@ -18,9 +19,10 @@ import { uneval } from 'devalue';
  *   prerendered: string[];
  *   relative_path: string;
  *   routes: import('types').RouteData[];
+ *   remotes: RemoteChunk[];
  * }} opts
  */
-export function generate_manifest({ build_data, prerendered, relative_path, routes }) {
+export function generate_manifest({ build_data, prerendered, relative_path, routes, remotes }) {
 	/**
 	 * @type {Map<any, number>} The new index of each node in the filtered nodes array
 	 */
@@ -101,7 +103,7 @@ export function generate_manifest({ build_data, prerendered, relative_path, rout
 					${(node_paths).map(loader).join(',\n')}
 				],
 				remotes: {
-					${build_data.manifest_data.remotes.map((remote) => `'${remote.hash}': ${loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, remote.file).chunk.file))}`).join(',\n')}
+					${remotes.map((remote) => `'${remote.hash}': ${loader(join_relative(relative_path, `chunks/remote-${remote.hash}.js`))}`).join(',\n')}
 				},
 				routes: [
 					${routes.map(route => {

package/src/core/postbuild/analyse.js

@@ -1,3 +1,4 @@
+/** @import { RemoteChunk } from 'types' */
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { validate_server_exports } from '../../utils/exports.js';
@@ -11,7 +12,6 @@ import { check_feature } from '../../utils/features.js';
 import { createReadableStream } from '@sveltejs/kit/node';
 import { PageNodes } from '../../utils/page_nodes.js';
 import { build_server_nodes } from '../../exports/vite/build/build_server.js';
-import { validate_remote_functions } from '@sveltejs/kit/internal';
 
 export default forked(import.meta.url, analyse);
 
@@ -25,6 +25,7 @@ export default forked(import.meta.url, analyse);
  *   env: Record<string, string>;
  *   out: string;
  *   output_config: import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>;
+ *   remotes: RemoteChunk[];
  * }} opts
  */
 async function analyse({
@@ -35,7 +36,8 @@ async function analyse({
 	tracked_features,
 	env,
 	out,
-	output_config
+	output_config,
+	remotes
 }) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
@@ -166,16 +168,14 @@ async function analyse({
 	}
 
 	// analyse remotes
-	for (const remote of manifest_data.remotes) {
+	for (const remote of remotes) {
 		const loader = manifest._.remotes[remote.hash];
-		const module = await loader();
-
-		validate_remote_functions(module, remote.file);
+		const { default: functions } = await loader();
 
 		const exports = new Map();
 
-		for (const name in module) {
-			const info = /** @type {import('types').RemoteInfo} */ (module[name].__);
+		for (const name in functions) {
+			const info = /** @type {import('types').RemoteInfo} */ (functions[name].__);
 			const type = info.type;
 
 			exports.set(name, {

package/src/core/postbuild/prerender.js

@@ -495,7 +495,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	for (const loader of Object.values(manifest._.remotes)) {
 		const module = await loader();
 
-		for (const fn of Object.values(module)) {
+		for (const fn of Object.values(module.default)) {
 			if (fn?.__?.type === 'prerender') {
 				prerender_functions.push(fn.__);
 				should_prerender = true;

package/src/core/sync/create_manifest_data/index.js

@@ -4,11 +4,10 @@ import process from 'node:process';
 import colors from 'kleur';
 import { lookup } from 'mrmime';
 import { list_files, runtime_directory } from '../../utils.js';
-import { posixify, resolve_entry, walk } from '../../../utils/filesystem.js';
+import { posixify, resolve_entry } from '../../../utils/filesystem.js';
 import { parse_route_id } from '../../../utils/routing.js';
 import { sort_routes } from './sort.js';
 import { isSvelte5Plus } from '../utils.js';
-import { hash } from '../../../utils/hash.js';
 
 /**
  * Generates the manifest data used for the client-side manifest and types generation.
@@ -28,7 +27,6 @@ export default function create_manifest_data({
 	const hooks = create_hooks(config, cwd);
 	const matchers = create_matchers(config, cwd);
 	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
-	const remotes = create_remotes(config, cwd);
 
 	for (const route of routes) {
 		for (const param of route.params) {
@@ -43,7 +41,6 @@ export default function create_manifest_data({
 		hooks,
 		matchers,
 		nodes,
-		remotes,
 		routes
 	};
 }
@@ -468,33 +465,6 @@ function create_routes_and_nodes(cwd, config, fallback) {
 	};
 }
 
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {string} cwd
- */
-function create_remotes(config, cwd) {
-	if (!config.kit.experimental.remoteFunctions) return [];
-
-	const extensions = config.kit.moduleExtensions.map((ext) => `.remote${ext}`);
-
-	/** @type {import('types').ManifestData['remotes']} */
-	const remotes = [];
-
-	// TODO could files live in other directories, including node_modules?
-	for (const file of walk(config.kit.files.src)) {
-		if (extensions.some((ext) => file.endsWith(ext))) {
-			const posixified = posixify(path.relative(cwd, `${config.kit.files.src}/${file}`));
-
-			remotes.push({
-				hash: hash(posixified),
-				file: posixified
-			});
-		}
-	}
-
-	return remotes;
-}
-
 /**
  * @param {string} project_relative
  * @param {string} file

package/src/exports/internal/index.js

@@ -62,4 +62,4 @@ export class ActionFailure {
 	}
 }
 
-export { validate_remote_functions } from './remote-functions.js';
+export { init_remote_functions } from './remote-functions.js';

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

@@ -1,27 +1,28 @@
+/** @import { RemoteInfo } from 'types' */
+
+/** @type {RemoteInfo['type'][]} */
+const types = ['command', 'form', 'prerender', 'query', 'query_batch'];
+
 /**
  * @param {Record<string, any>} module
  * @param {string} file
+ * @param {string} hash
  */
-export function validate_remote_functions(module, file) {
+export function init_remote_functions(module, file, hash) {
 	if (module.default) {
 		throw new Error(
 			`Cannot export \`default\` from a remote module (${file}) — please use named exports instead`
 		);
 	}
 
-	for (const name in module) {
-		const type = /** @type {import('types').RemoteInfo['type']} */ (module[name]?.__?.type);
-
-		if (
-			type !== 'form' &&
-			type !== 'command' &&
-			type !== 'query' &&
-			type !== 'query_batch' &&
-			type !== 'prerender'
-		) {
+	for (const [name, fn] of Object.entries(module)) {
+		if (!types.includes(fn?.__?.type)) {
 			throw new Error(
 				`\`${name}\` exported from ${file} is invalid — all exports from this file must be remote functions`
 			);
 		}
+
+		fn.__.id = `${hash}/${name}`;
+		fn.__.name = name;
 	}
 }

package/src/exports/vite/dev/index.js

@@ -29,9 +29,10 @@ const vite_css_query_regex = /(?:\?|&)(?:raw|url|inline)(?:&|$)/;
  * @param {import('vite').ViteDevServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
+ * @param {() => Array<{ hash: string, file: string }>} get_remotes
  * @return {Promise<Promise<() => void>>}
  */
-export async function dev(vite, vite_config, svelte_config) {
+export async function dev(vite, vite_config, svelte_config, get_remotes) {
 	installPolyfills();
 
 	const async_local_storage = new AsyncLocalStorage();
@@ -266,12 +267,14 @@ export async function dev(vite, vite_config, svelte_config) {
 					};
 				}),
 				prerendered_routes: new Set(),
-				remotes: Object.fromEntries(
-					manifest_data.remotes.map((remote) => [
-						remote.hash,
-						() => vite.ssrLoadModule(remote.file)
-					])
-				),
+				get remotes() {
+					return Object.fromEntries(
+						get_remotes().map((remote) => [
+							remote.hash,
+							() => vite.ssrLoadModule(remote.file).then((module) => ({ default: module }))
+						])
+					);
+				},
 				routes: compact(
 					manifest_data.routes.map((route) => {
 						if (!route.page && !route.endpoint) return null;

package/src/exports/vite/index.js

@@ -41,7 +41,6 @@ import {
 } from './module_ids.js';
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
-import { build_remotes, treeshake_prerendered_remotes } from './build/build_remote.js';
 import { should_ignore } from './static_analysis/utils.js';
 
 const cwd = process.cwd();
@@ -654,10 +653,66 @@ async function kit({ svelte_config }) {
 	/** @type {import('vite').ViteDevServer} */
 	let dev_server;
 
+	/** @type {Array<{ hash: string, file: string }>} */
+	const remotes = [];
+
 	/** @type {import('vite').Plugin} */
 	const plugin_remote = {
 		name: 'vite-plugin-sveltekit-remote',
 
+		config(config) {
+			if (!config.build?.ssr) {
+				// only set manualChunks for the SSR build
+				return;
+			}
+
+			// Ensure build.rollupOptions.output exists
+			config.build ??= {};
+			config.build.rollupOptions ??= {};
+			config.build.rollupOptions.output ??= {};
+
+			if (Array.isArray(config.build.rollupOptions.output)) {
+				// TODO I have no idea how this could occur
+				throw new Error('rollupOptions.output cannot be an array');
+			}
+
+			// Set up manualChunks to isolate *.remote.ts files
+			const { manualChunks } = config.build.rollupOptions.output;
+
+			config.build.rollupOptions.output = {
+				...config.build.rollupOptions.output,
+				manualChunks(id, meta) {
+					if (id === `${runtime_directory}/app/server/index.js`) {
+						return 'app-server';
+					}
+
+					// Check if this is a *.remote.ts file
+					if (svelte_config.kit.moduleExtensions.some((ext) => id.endsWith(`.remote${ext}`))) {
+						const relative = posixify(path.relative(cwd, id));
+
+						return `remote-${hash(relative)}`;
+					}
+
+					// If there was an existing manualChunks function, call it
+					if (typeof manualChunks === 'function') {
+						return manualChunks(id, meta);
+					}
+
+					// If manualChunks is an object, check if this module matches any patterns
+					if (manualChunks) {
+						for (const name in manualChunks) {
+							const patterns = manualChunks[name];
+
+							// TODO is `id.includes(pattern)` correct?
+							if (patterns.some((pattern) => id.includes(pattern))) {
+								return name;
+							}
+						}
+					}
+				}
+			};
+		},
+
 		configureServer(_dev_server) {
 			dev_server = _dev_server;
 		},
@@ -668,36 +723,40 @@ async function kit({ svelte_config }) {
 			}
 
 			const file = posixify(path.relative(cwd, id));
-			const hashed = hash(file);
+
+			const remote = {
+				hash: hash(file),
+				file
+			};
+
+			remotes.push(remote);
 
 			if (opts?.ssr) {
-				// in dev, add metadata to remote functions by self-importing
-				if (dev_server) {
-					return (
-						code +
-						dedent`
-							import * as $$_self_$$ from './${path.basename(id)}';
-							import { validate_remote_functions as $$_validate_$$ } from '@sveltejs/kit/internal';
-
-							$$_validate_$$($$_self_$$, ${s(file)});
-
-							for (const [name, fn] of Object.entries($$_self_$$)) {
-								fn.__.id = ${s(hashed)} + '/' + name;
-								fn.__.name = name;
-							}
-						`
-					);
+				code += dedent`
+					import * as $$_self_$$ from './${path.basename(id)}';
+					import { init_remote_functions as $$_init_$$ } from '@sveltejs/kit/internal';
+
+					$$_init_$$($$_self_$$, ${s(file)}, ${s(remote.hash)});
+
+					for (const [name, fn] of Object.entries($$_self_$$)) {
+						fn.__.id = ${s(remote.hash)} + '/' + name;
+						fn.__.name = name;
+					}
+				`;
+
+				if (!dev_server) {
+					// in prod, prevent the functions from being treeshaken. This will
+					// be replaced with an `export default` in the `writeBundle` hook
+					code += `$$_export_$$($$_self_$$);`;
 				}
 
-				// in prod, return as-is, and augment the build result instead.
-				// this allows us to treeshake non-dynamic `prerender` functions
-				return;
+				return code;
 			}
 
 			// For the client, read the exports and create a new module that only contains fetch functions with the correct metadata
 
 			/** @type {Map<string, import('types').RemoteInfo['type']>} */
-			const remotes = new Map();
+			const map = new Map();
 
 			// in dev, load the server module here (which will result in this hook
 			// being called again with `opts.ssr === true` if the module isn't
@@ -708,7 +767,7 @@ async function kit({ svelte_config }) {
 				for (const [name, value] of Object.entries(module)) {
 					const type = value?.__?.type;
 					if (type) {
-						remotes.set(name, type);
+						map.set(name, type);
 					}
 				}
 			}
@@ -716,25 +775,37 @@ async function kit({ svelte_config }) {
 			// in prod, we already built and analysed the server code before
 			// building the client code, so `remote_exports` is populated
 			else if (remote_exports) {
-				const exports = remote_exports.get(hashed);
+				const exports = remote_exports.get(remote.hash);
 				if (!exports) throw new Error('Expected to find metadata for remote file ' + id);
 
 				for (const [name, value] of exports) {
-					remotes.set(name, value.type);
+					map.set(name, value.type);
 				}
 			}
 
 			let namespace = '__remote';
 			let uid = 1;
-			while (remotes.has(namespace)) namespace = `__remote${uid++}`;
+			while (map.has(namespace)) namespace = `__remote${uid++}`;
 
-			const exports = Array.from(remotes).map(([name, type]) => {
-				return `export const ${name} = ${namespace}.${type}('${hashed}/${name}');`;
+			const exports = Array.from(map).map(([name, type]) => {
+				return `export const ${name} = ${namespace}.${type}('${remote.hash}/${name}');`;
 			});
 
 			return {
 				code: `import * as ${namespace} from '__sveltekit/remote';\n\n${exports.join('\n')}\n`
 			};
+		},
+
+		writeBundle() {
+			for (const remote of remotes) {
+				const file = `${out}/server/chunks/remote-${remote.hash}.js`;
+				const code = fs.readFileSync(file, 'utf-8');
+
+				fs.writeFileSync(
+					file,
+					code.replace('$$_export_$$($$_self_$$)', () => `export default $$_self_$$;`)
+				);
+			}
 		}
 	};
 
@@ -811,11 +882,6 @@ async function kit({ svelte_config }) {
 						}
 						input['instrumentation.server'] = server_instrumentation;
 					}
-
-					// ...and every .remote file
-					for (const remote of manifest_data.remotes) {
-						input[`remote/${remote.hash}`] = path.resolve(remote.file);
-					}
 				} else if (svelte_config.kit.output.bundleStrategy !== 'split') {
 					input['bundle'] = `${runtime_directory}/client/bundle.js`;
 				} else {
@@ -917,7 +983,7 @@ async function kit({ svelte_config }) {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
 		 */
 		async configureServer(vite) {
-			return await dev(vite, vite_config, svelte_config);
+			return await dev(vite, vite_config, svelte_config, () => remotes);
 		},
 
 		/**
@@ -1000,7 +1066,8 @@ async function kit({ svelte_config }) {
 						build_data,
 						prerendered: [],
 						relative_path: '.',
-						routes: manifest_data.routes
+						routes: manifest_data.routes,
+						remotes
 					})};\n`
 				);
 
@@ -1014,7 +1081,8 @@ async function kit({ svelte_config }) {
 					tracked_features,
 					env: { ...env.private, ...env.public },
 					out,
-					output_config: svelte_config.output
+					output_config: svelte_config.output,
+					remotes
 				});
 
 				remote_exports = metadata.remotes;
@@ -1199,7 +1267,8 @@ async function kit({ svelte_config }) {
 						build_data,
 						prerendered: [],
 						relative_path: '.',
-						routes: manifest_data.routes
+						routes: manifest_data.routes,
+						remotes
 					})};\n`
 				);
 
@@ -1216,9 +1285,6 @@ async function kit({ svelte_config }) {
 					static_exports
 				);
 
-				// ...make sure remote exports have their IDs assigned...
-				build_remotes(out, manifest_data);
-
 				// ...and prerender
 				const { prerendered, prerender_map } = await prerender({
 					hash: kit.router.type === 'hash',
@@ -1236,13 +1302,11 @@ async function kit({ svelte_config }) {
 						build_data,
 						prerendered: prerendered.paths,
 						relative_path: '.',
-						routes: manifest_data.routes.filter((route) => prerender_map.get(route.id) !== true)
+						routes: manifest_data.routes.filter((route) => prerender_map.get(route.id) !== true),
+						remotes
 					})};\n`
 				);
 
-				// remove prerendered remote functions
-				await treeshake_prerendered_remotes(out, manifest_data, metadata);
-
 				if (service_worker_entry_file) {
 					if (kit.paths.assets) {
 						throw new Error('Cannot use service worker alongside config.kit.paths.assets');
@@ -1285,6 +1349,7 @@ async function kit({ svelte_config }) {
 							prerendered,
 							prerender_map,
 							log,
+							remotes,
 							vite_config
 						);
 					} else {

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

@@ -64,7 +64,13 @@ export function command(validate_or_fn, maybe_fn) {
 	const wrapper = (arg) => {
 		const { event, state } = get_request_store();
 
-		if (!event.isRemoteRequest) {
+		if (state.is_endpoint_request) {
+			if (!['POST', 'PUT', 'PATCH', 'DELETE'].includes(event.request.method)) {
+				throw new Error(
+					`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) from a ${event.request.method} handler`
+				);
+			}
+		} else if (!event.isRemoteRequest) {
 			throw new Error(
 				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) during server-side rendering`
 			);

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

@@ -83,9 +83,7 @@ export function query_batch(id) {
 						}
 
 						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);
 						}
 

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

@@ -21,13 +21,7 @@ export async function remote_request(url) {
 	const result = /** @type {RemoteFunctionResponse} */ (await response.json());
 
 	if (result.type === 'redirect') {
-		// resource_cache.delete(cache_key);
-		// version++;
-		// await goto(result.location);
-		// /** @type {Query<any>} */ (resource).refresh();
-		// TODO double-check this
 		await goto(result.location);
-		await new Promise((r) => setTimeout(r, 100));
 		throw new Redirect(307, result.location);
 	}
 

package/src/runtime/server/endpoint.js

@@ -41,6 +41,8 @@ export async function render_endpoint(event, event_state, mod, state) {
 		}
 	}
 
+	event_state.is_endpoint_request = true;
+
 	try {
 		const response = await with_request_store({ event, state: event_state }, () =>
 			handler(/** @type {import('@sveltejs/kit').RequestEvent<Record<string, any>>} */ (event))

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

@@ -1,4 +1,5 @@
 import * as devalue from 'devalue';
+import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
 import {
 	clarify_devalue_error,
@@ -17,61 +18,72 @@ import {
  */
 export function server_data_serializer(event, event_state, options) {
 	let promise_id = 1;
+	let max_nodes = -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);
+	/** @param {number} index */
+	function get_replacer(index) {
+		/** @param {any} thing */
+		return 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 {
+								index,
+								str: `${global}.resolve(${id}, ${str.includes('app.decode') ? `(app) => ${str}` : `() => ${str}`})`
+							};
 						}
+					);
 
-						return `${global}.resolve(${id}, ${str.includes('app.decode') ? `(app) => ${str}` : `() => ${str}`})`;
-					}
-				);
+				iterator.add(promise);
 
-			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)})`;
+				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 {
+		set_max_nodes(i) {
+			max_nodes = i;
+		},
+
 		add_node(i, node) {
 			try {
 				if (!node) {
@@ -83,7 +95,7 @@ export function server_data_serializer(event, event_state, options) {
 				const payload = { type: 'data', data: node.data, uses: serialize_uses(node) };
 				if (node.slash) payload.slash = node.slash;
 
-				strings[i] = devalue.uneval(payload, replacer);
+				strings[i] = devalue.uneval(payload, get_replacer(i));
 			} catch (e) {
 				// @ts-expect-error
 				e.path = e.path.slice(1);
@@ -96,8 +108,17 @@ export function server_data_serializer(event, event_state, options) {
 			const close = `</script>\n`;
 
 			return {
-				data: `[${strings.join(',')}]`,
-				chunks: promise_id > 1 ? iterator.iterate((str) => open + str + close) : null
+				data: `[${compact(max_nodes > -1 ? strings.slice(0, max_nodes) : strings).join(',')}]`,
+				chunks:
+					promise_id > 1
+						? iterator.iterate(({ index, str }) => {
+								if (max_nodes > -1 && index >= max_nodes) {
+									return '';
+								}
+
+								return open + str + close;
+							})
+						: null
 			};
 		}
 	};

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

@@ -195,7 +195,10 @@ export async function render_page(
 						}
 					});
 
-					data_serializer.add_node(i, server_data);
+					if (node) {
+						data_serializer.add_node(i, server_data);
+					}
+
 					data_serializer_json?.add_node(i, server_data);
 
 					return server_data;
@@ -278,6 +281,8 @@ export async function render_page(
 							let j = i;
 							while (!branch[j]) j -= 1;
 
+							data_serializer.set_max_nodes(j + 1);
+
 							const layouts = compact(branch.slice(0, j + 1));
 							const nodes = new PageNodes(layouts.map((layout) => layout.node));
 
@@ -300,7 +305,7 @@ export async function render_page(
 									server_data: null
 								}),
 								fetched,
-								data_serializer: server_data_serializer(event, event_state, options)
+								data_serializer
 							});
 						}
 					}
@@ -348,7 +353,8 @@ export async function render_page(
 			branch: ssr === false ? [] : compact(branch),
 			action_result,
 			fetched,
-			data_serializer
+			data_serializer:
+				ssr === false ? server_data_serializer(event, event_state, options) : data_serializer
 		});
 	} catch (e) {
 		// if we end up here, it means the data loaded successfully

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

@@ -45,6 +45,7 @@ export interface Cookie {
 export type ServerDataSerializer = {
 	add_node(i: number, node: ServerDataNode | null): void;
 	get_data(csp: Csp): { data: string; chunks: AsyncIterable<string> | null };
+	set_max_nodes(i: number): void;
 };
 
 export type ServerDataSerializerJson = {

package/src/runtime/server/remote.js

@@ -43,7 +43,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 	if (!remotes[hash]) error(404);
 
 	const module = await remotes[hash]();
-	const fn = module[name];
+	const fn = module.default[name];
 
 	if (!fn) error(404);
 
@@ -117,8 +117,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			}
 
 			const form_data = await event.request.formData();
-			form_client_refreshes = JSON.parse(
-				/** @type {string} */ (form_data.get('sveltekit:remote_refreshes')) ?? '[]'
+			form_client_refreshes = /** @type {string[]} */ (
+				JSON.parse(/** @type {string} */ (form_data.get('sveltekit:remote_refreshes')) ?? '[]')
 			);
 			form_data.delete('sveltekit:remote_refreshes');
 
@@ -129,7 +129,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
 					result: stringify(data, transport),
-					refreshes: await serialize_refreshes(/** @type {string[]} */ (form_client_refreshes))
+					refreshes: await serialize_refreshes(form_client_refreshes)
 				})
 			);
 		}
@@ -169,20 +169,28 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		);
 	} catch (error) {
 		if (error instanceof Redirect) {
-			return json({
-				type: 'redirect',
-				location: error.location,
-				refreshes: await serialize_refreshes(form_client_refreshes ?? [])
-			});
+			return json(
+				/** @type {RemoteFunctionResponse} */ ({
+					type: 'redirect',
+					location: error.location,
+					refreshes: await serialize_refreshes(form_client_refreshes ?? [])
+				})
+			);
 		}
 
+		const status =
+			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
 				error: await handle_error_and_jsonify(event, state, options, error),
-				status: error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
+				status
 			}),
 			{
+				// By setting a non-200 during prerendering we fail the prerender process (unless handleHttpError handles it).
+				// Errors at runtime will be passed to the client and are handled there
+				status: state.prerendering ? status : undefined,
 				headers: {
 					'cache-control': 'private, no-store'
 				}
@@ -194,7 +202,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 	 * @param {string[]} client_refreshes
 	 */
 	async function serialize_refreshes(client_refreshes) {
-		const refreshes = /** @type {Record<string, Promise<any>>} */ (state.refreshes);
+		const refreshes = state.refreshes ?? {};
 
 		for (const key of client_refreshes) {
 			if (refreshes[key] !== undefined) continue;
@@ -202,7 +210,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			const [hash, name, payload] = key.split('/');
 
 			const loader = manifest._.remotes[hash];
-			const fn = (await loader?.())?.[name];
+			const fn = (await loader?.())?.default?.[name];
 
 			if (!fn) error(400, 'Bad Request');
 
@@ -254,7 +262,7 @@ 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>} */ (module?.[name]);
+	let form = /** @type {RemoteForm<any>} */ (module?.default[name]);
 
 	if (!form) {
 		event.setHeaders({

package/src/runtime/server/respond.js

@@ -505,11 +505,12 @@ export async function internal_respond(request, options, manifest, state) {
 		return response;
 	} catch (e) {
 		if (e instanceof Redirect) {
-			const response = is_data_request
-				? redirect_json_response(e)
-				: route?.page && is_action_json_request(event)
-					? action_json_redirect(e)
-					: redirect_response(e.status, e.location);
+			const response =
+				is_data_request || remote_id
+					? redirect_json_response(e)
+					: route?.page && is_action_json_request(event)
+						? action_json_redirect(e)
+						: redirect_response(e.status, e.location);
 			add_cookies_to_headers(response.headers, new_cookies.values());
 			return response;
 		}

package/src/types/internal.d.ts

@@ -192,14 +192,15 @@ export interface ManifestData {
 		universal: string | null;
 	};
 	nodes: PageNode[];
-	remotes: Array<{
-		file: string;
-		hash: string;
-	}>;
 	routes: RouteData[];
 	matchers: Record<string, string>;
 }
 
+export interface RemoteChunk {
+	hash: string;
+	file: string;
+}
+
 export interface PageNode {
 	depth: number;
 	/** The `+page/layout.svelte`. */
@@ -598,6 +599,7 @@ export interface RequestState {
 	form_instances?: Map<any, any>;
 	remote_data?: Record<string, MaybePromise<any>>;
 	refreshes?: Record<string, Promise<any>>;
+	is_endpoint_request?: boolean;
 }
 
 export interface RequestStore {

package/src/version.js

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

package/types/index.d.ts

@@ -2123,10 +2123,6 @@ declare module '@sveltejs/kit' {
 			universal: string | null;
 		};
 		nodes: PageNode[];
-		remotes: Array<{
-			file: string;
-			hash: string;
-		}>;
 		routes: RouteData[];
 		matchers: Record<string, string>;
 	}

package/types/index.d.ts.map

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

package/src/exports/vite/build/build_remote.js

@@ -1,129 +0,0 @@
-/** @import { ManifestData, ServerMetadata } from 'types' */
-import fs from 'node:fs';
-import path from 'node:path';
-import { posixify } from '../../../utils/filesystem.js';
-import { dedent } from '../../../core/sync/utils.js';
-import { import_peer } from '../../../utils/import.js';
-
-/**
- * Moves the remote files to a sibling file and rewrites the original remote file to import from that sibling file,
- * enhancing the remote functions with their hashed ID.
- * This is not done through a self-import like during DEV because we want to treeshake prerendered remote functions
- * later, which wouldn't work if we do a self-import and iterate over all exports (since we're reading them then).
- * @param {string} out
- * @param {ManifestData} manifest_data
- */
-export function build_remotes(out, manifest_data) {
-	const dir = `${out}/server/remote`;
-
-	for (const remote of manifest_data.remotes) {
-		const entry = `${dir}/${remote.hash}.js`;
-		const tmp = `${remote.hash}.tmp.js`;
-
-		fs.renameSync(entry, `${dir}/${tmp}`);
-		fs.writeFileSync(
-			entry,
-			dedent`
-				import * as $$_self_$$ from './${tmp}';
-
-				for (const [name, fn] of Object.entries($$_self_$$)) {
-					fn.__.id = '${remote.hash}/' + name;
-					fn.__.name = name;
-				}
-
-				export * from './${tmp}';
-			`
-		);
-	}
-}
-
-
-/**
- * For each remote module, checks if there are treeshakeable prerendered remote functions,
- * then accomplishes the treeshaking by rewriting the remote files to only include the non-prerendered imports,
- * replacing the prerendered remote functions with a dummy function that should never be called,
- * and doing a Vite build. This will not treeshake perfectly yet as everything except the remote files are treated as external,
- * so it will not go into those files to check what can be treeshaken inside them.
- * @param {string} out
- * @param {ManifestData} manifest_data
- * @param {ServerMetadata} metadata
- */
-export async function treeshake_prerendered_remotes(out, manifest_data, metadata) {
-	if (manifest_data.remotes.length === 0) {
-		return;
-	}
-
-	const dir = posixify(`${out}/server/remote`);
-
-	const vite = /** @type {typeof import('vite')} */ (await import_peer('vite'));
-	const remote_entry = posixify(`${out}/server/remote-entry.js`);
-
-	const prefix = 'optimized/';
-
-	const input = {
-		// include this file in the bundle, so that Rollup understands
-		// that functions like `prerender` are side-effect free
-		[path.basename(remote_entry.slice(0, -3))]: remote_entry
-	};
-
-	for (const remote of manifest_data.remotes) {
-		const exports = metadata.remotes.get(remote.hash);
-		if (!exports) throw new Error('An impossible situation occurred');
-
-		/** @type {string[]} */
-		const dynamic = [];
-
-		/** @type {string[]} */
-		const prerendered = [];
-
-		for (const [name, value] of exports) {
-			(value.dynamic ? dynamic : prerendered).push(name);
-		}
-
-		const remote_file = posixify(`${dir}/${remote.hash}.js`);
-
-		fs.writeFileSync(
-			remote_file,
-			dedent`
-				import { ${dynamic.join(', ')} } from './${remote.hash}.tmp.js';
-				import { prerender } from '../${path.basename(remote_entry)}';
-
-				${prerendered.map((name) => `export const ${name} = prerender('unchecked', () => { throw new Error('Unexpectedly called prerender function. Did you forget to set { dynamic: true } ?') });`).join('\n')}
-
-				for (const [name, fn] of Object.entries({ ${Array.from(exports.keys()).join(', ')} })) {
-					fn.__.id = '${remote.hash}/' + name;
-					fn.__.name = name;
-				}
-
-				export { ${dynamic.join(', ')} };
-			`
-		);
-
-		input[prefix + remote.hash] = remote_file;
-	}
-
-	const bundle = /** @type {import('vite').Rollup.RollupOutput} */ (await vite.build({
-		configFile: false,
-		build: {
-			write: false,
-			ssr: true,
-			rollupOptions: {
-				external: (id) => {
-					if (id[0] === '.') return;
-					return !id.startsWith(dir);
-				},
-				input
-			}
-		}
-	}));
-
-	for (const chunk of bundle.output) {
-		if (chunk.type === 'chunk' && chunk.name.startsWith(prefix)) {
-			fs.writeFileSync(`${dir}/${chunk.fileName.slice(prefix.length)}`, chunk.code);
-		}
-	}
-
-	for (const remote of manifest_data.remotes) {
-		fs.unlinkSync(`${dir}/${remote.hash}.tmp.js`);
-	}
-}