@sveltejs/kit 2.47.2 → 2.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.47.2",
+  "version": "2.48.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -41,7 +41,7 @@
     "@types/set-cookie-parser": "^2.4.7",
     "dts-buddy": "^0.6.2",
     "rollup": "^4.14.2",
-    "svelte": "^5.39.8",
+    "svelte": "^5.42.1",
     "svelte-preprocess": "^6.0.0",
     "typescript": "^5.3.3",
     "vite": "^6.3.5",

package/src/core/postbuild/analyse.js

@@ -105,7 +105,8 @@ async function analyse({
 		}
 
 		metadata.nodes[node.index] = {
-			has_server_load: has_server_load(node)
+			has_server_load: has_server_load(node),
+			has_universal_load: node.universal?.load !== undefined
 		};
 	}
 

package/src/exports/public.d.ts

@@ -1914,10 +1914,28 @@ type RemoteFormFieldContainer<Value> = RemoteFormFieldMethods<Value> & {
 	allIssues(): RemoteFormIssue[] | undefined;
 };
 
+type UnknownField<Value> = RemoteFormFieldMethods<Value> & {
+	/** Validation issues belonging to this or any of the fields that belong to it, if any */
+	allIssues(): RemoteFormIssue[] | undefined;
+	/**
+	 * Returns an object that can be spread onto an input element with the correct type attribute,
+	 * aria-invalid attribute if the field is invalid, and appropriate value/checked property getters/setters.
+	 * @example
+	 * ```svelte
+	 * <input {...myForm.fields.myString.as('text')} />
+	 * <input {...myForm.fields.myNumber.as('number')} />
+	 * <input {...myForm.fields.myBoolean.as('checkbox')} />
+	 * ```
+	 */
+	as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+} & {
+	[key: string | number]: UnknownField<any>;
+};
+
 /**
  * Recursive type to build form fields structure with proxy access
  */
-type RemoteFormFields<T> =
+export type RemoteFormFields<T> =
 	WillRecurseIndefinitely<T> extends true
 		? RecursiveFormFields
 		: NonNullable<T> extends string | number | boolean | File
@@ -1925,11 +1943,17 @@ type RemoteFormFields<T> =
 			: T extends string[] | File[]
 				? RemoteFormField<T> & { [K in number]: RemoteFormField<T[number]> }
 				: T extends Array<infer U>
-					? RemoteFormFieldContainer<T> & { [K in number]: RemoteFormFields<U> }
-					: RemoteFormFieldContainer<T> & { [K in keyof T]-?: RemoteFormFields<T[K]> };
+					? RemoteFormFieldContainer<T> & {
+							[K in number]: RemoteFormFields<U>;
+						}
+					: RemoteFormFieldContainer<T> & {
+							[K in keyof T]-?: RemoteFormFields<T[K]>;
+						};
 
 // By breaking this out into its own type, we avoid the TS recursion depth limit
-type RecursiveFormFields = RemoteFormField<any> & { [key: string | number]: RecursiveFormFields };
+type RecursiveFormFields = RemoteFormFieldContainer<any> & {
+	[key: string | number]: UnknownField<any>;
+};
 
 type MaybeArray<T> = T | T[];
 

package/src/exports/vite/index.js

@@ -172,8 +172,8 @@ let secondary_build_started = false;
 /** @type {import('types').ManifestData} */
 let manifest_data;
 
-/** @type {import('types').ServerMetadata['remotes'] | undefined} only set at build time */
-let remote_exports = undefined;
+/** @type {import('types').ServerMetadata | undefined} only set at build time once analysis is finished */
+let build_metadata = undefined;
 
 /**
  * Returns the SvelteKit Vite plugin. Vite executes Rollup hooks as well as some of its own.
@@ -369,12 +369,28 @@ async function kit({ svelte_config }) {
 
 				if (!secondary_build_started) {
 					manifest_data = sync.all(svelte_config, config_env.mode).manifest_data;
+					// During the initial server build we don't know yet
+					new_config.define.__SVELTEKIT_HAS_SERVER_LOAD__ = 'true';
+					new_config.define.__SVELTEKIT_HAS_UNIVERSAL_LOAD__ = 'true';
+				} else {
+					const nodes = Object.values(
+						/** @type {import('types').ServerMetadata} */ (build_metadata).nodes
+					);
+
+					// Through the finished analysis we can now check if any node has server or universal load functions
+					const has_server_load = nodes.some((node) => node.has_server_load);
+					const has_universal_load = nodes.some((node) => node.has_universal_load);
+
+					new_config.define.__SVELTEKIT_HAS_SERVER_LOAD__ = s(has_server_load);
+					new_config.define.__SVELTEKIT_HAS_UNIVERSAL_LOAD__ = s(has_universal_load);
 				}
 			} else {
 				new_config.define = {
 					...define,
 					__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: '0',
-					__SVELTEKIT_PAYLOAD__: 'globalThis.__sveltekit_dev'
+					__SVELTEKIT_PAYLOAD__: 'globalThis.__sveltekit_dev',
+					__SVELTEKIT_HAS_SERVER_LOAD__: 'true',
+					__SVELTEKIT_HAS_UNIVERSAL_LOAD__: 'true'
 				};
 
 				// @ts-ignore this prevents a reference error if `client.js` is imported on the server
@@ -733,8 +749,8 @@ 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(remote.hash);
+			else if (build_metadata?.remotes) {
+				const exports = build_metadata?.remotes.get(remote.hash);
 				if (!exports) throw new Error('Expected to find metadata for remote file ' + id);
 
 				for (const [name, value] of exports) {
@@ -1038,7 +1054,7 @@ async function kit({ svelte_config }) {
 					remotes
 				});
 
-				remote_exports = metadata.remotes;
+				build_metadata = metadata;
 
 				log.info('Building app');
 

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

@@ -4,7 +4,7 @@ import { read } from '../../../utils/filesystem.js';
 
 const inheritable_page_options = new Set(['ssr', 'prerender', 'csr', 'trailingSlash', 'config']);
 
-const valid_page_options = new Set([...inheritable_page_options, 'entries']);
+const valid_page_options = new Set([...inheritable_page_options, 'entries', 'load']);
 
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
@@ -14,7 +14,8 @@ const parser = Parser.extend(tsPlugin());
 
 /**
  * Collects page options from a +page.js/+layout.js file, ignoring reassignments
- * and using the declared value. Returns `null` if any export is too difficult to analyse.
+ * and using the declared value (except for load functions, for which the value is `true`).
+ * Returns `null` if any export is too difficult to analyse.
  * @param {string} filename The name of the file to report when an error occurs
  * @param {string} input
  * @returns {Record<string, any> | null}
@@ -116,6 +117,13 @@ export function statically_analyse_page_options(filename, input) {
 									continue;
 								}
 
+								// Special case: We only want to know that 'load' is exported (in a way that doesn't cause truthy checks in other places to trigger)
+								if (variable_declarator.id.name === 'load') {
+									page_options.set('load', null);
+									export_specifiers.delete('load');
+									continue;
+								}
+
 								// references a declaration we can't easily evaluate statically
 								return null;
 							}
@@ -138,7 +146,12 @@ export function statically_analyse_page_options(filename, input) {
 			// class and function declarations
 			if (statement.declaration.type !== 'VariableDeclaration') {
 				if (valid_page_options.has(statement.declaration.id.name)) {
-					return null;
+					// Special case: We only want to know that 'load' is exported (in a way that doesn't cause truthy checks in other places to trigger)
+					if (statement.declaration.id.name === 'load') {
+						page_options.set('load', null);
+					} else {
+						return null;
+					}
 				}
 				continue;
 			}
@@ -157,6 +170,12 @@ export function statically_analyse_page_options(filename, input) {
 					continue;
 				}
 
+				// Special case: We only want to know that 'load' is exported (in a way that doesn't cause truthy checks in other places to trigger)
+				if (declaration.id.name === 'load') {
+					page_options.set('load', null);
+					continue;
+				}
+
 				// references a declaration we can't easily evaluate statically
 				return null;
 			}
@@ -187,7 +206,7 @@ export function get_name(node) {
  */
 export function create_node_analyser({ resolve, static_exports = new Map() }) {
 	/**
-	 * Computes the final page options for a node (if possible). Otherwise, returns `null`.
+	 * Computes the final page options (may include load function as `load: null`; special case) for a node (if possible). Otherwise, returns `null`.
 	 * @param {import('types').PageNode} node
 	 * @returns {Promise<Record<string, any> | null>}
 	 */

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

@@ -11,7 +11,7 @@ import {
 	deep_set,
 	normalize_issue,
 	flatten_issues
-} from '../../../form-utils.svelte.js';
+} from '../../../form-utils.js';
 import { get_cache, run_remote_function } from './shared.js';
 
 /**
@@ -215,7 +215,6 @@ export function form(validate_or_fn, maybe_fn) {
 				return create_field_proxy(
 					{},
 					() => data?.input ?? {},
-					() => {},
 					(path, value) => {
 						if (data?.submission) {
 							// don't override a submission
@@ -318,7 +317,7 @@ function handle_issues(output, issues, is_remote_request, form_data) {
 
 			if (is_array) key = key.slice(0, -2);
 
-			output.input = set_nested_value(
+			set_nested_value(
 				/** @type {Record<string, any>} */ (output.input),
 				key,
 				is_array ? values : values[0]

package/src/runtime/client/client.js

@@ -206,9 +206,14 @@ const invalidated = [];
  */
 const components = [];
 
-/** @type {{id: string, token: {}, promise: Promise<import('./types.js').NavigationResult>} | null} */
+/** @type {{id: string, token: {}, promise: Promise<import('./types.js').NavigationResult>, fork: Promise<import('svelte').Fork | null> | null} | null} */
 let load_cache = null;
 
+function discard_load_cache() {
+	void load_cache?.fork?.then((f) => f?.discard());
+	load_cache = null;
+}
+
 /**
  * @type {Map<string, Promise<URL>>}
  * Cache for client-side rerouting, since it could contain async calls which we want to
@@ -382,7 +387,7 @@ async function _invalidate(include_load_functions = true, reset_page_state = tru
 	// Also solves an edge case where a preload is triggered, the navigation for it
 	// was then triggered and is still running while the invalidation kicks in,
 	// at which point the invalidation should take over and "win".
-	load_cache = null;
+	discard_load_cache();
 
 	// Rerun queries
 	if (force_invalidation) {
@@ -461,7 +466,7 @@ export async function _goto(url, options, redirect_count, nav_token) {
 	// Clear preload cache when invalidateAll is true to ensure fresh data
 	// after form submissions or explicit invalidations
 	if (options.invalidateAll) {
-		load_cache = null;
+		discard_load_cache();
 	}
 
 	await navigate({
@@ -518,11 +523,32 @@ async function _preload_data(intent) {
 				preload_tokens.delete(preload);
 				if (result.type === 'loaded' && result.state.error) {
 					// Don't cache errors, because they might be transient
-					load_cache = null;
+					discard_load_cache();
 				}
 				return result;
-			})
+			}),
+			fork: null
 		};
+
+		if (svelte.fork) {
+			const lc = load_cache;
+
+			lc.fork = lc.promise.then((result) => {
+				// if load_cache was discarded before load_cache.promise could
+				// resolve, bail rather than creating an orphan fork
+				if (lc === load_cache && result.type === 'loaded') {
+					try {
+						return svelte.fork(() => {
+							root.$set(result.props);
+						});
+					} catch {
+						// if it errors, it's because the experimental flag isn't enabled
+					}
+				}
+
+				return null;
+			});
+		}
 	}
 
 	return load_cache.promise;
@@ -732,7 +758,7 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 		}
 	}
 
-	if (node.universal?.load) {
+	if (__SVELTEKIT_HAS_UNIVERSAL_LOAD__ && node.universal?.load) {
 		/** @param {string[]} deps */
 		function depends(...deps) {
 			for (const dep of deps) {
@@ -1004,49 +1030,52 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 	const search_params_changed = diff_search_params(current.url, url);
 
 	let parent_invalid = false;
-	const invalid_server_nodes = loaders.map((loader, i) => {
-		const previous = current.branch[i];
 
-		const invalid =
-			!!loader?.[0] &&
-			(previous?.loader !== loader[1] ||
-				has_changed(
-					parent_invalid,
-					route_changed,
-					url_changed,
-					search_params_changed,
-					previous.server?.uses,
-					params
-				));
-
-		if (invalid) {
-			// For the next one
-			parent_invalid = true;
-		}
+	if (__SVELTEKIT_HAS_SERVER_LOAD__) {
+		const invalid_server_nodes = loaders.map((loader, i) => {
+			const previous = current.branch[i];
+
+			const invalid =
+				!!loader?.[0] &&
+				(previous?.loader !== loader[1] ||
+					has_changed(
+						parent_invalid,
+						route_changed,
+						url_changed,
+						search_params_changed,
+						previous.server?.uses,
+						params
+					));
+
+			if (invalid) {
+				// For the next one
+				parent_invalid = true;
+			}
 
-		return invalid;
-	});
+			return invalid;
+		});
 
-	if (invalid_server_nodes.some(Boolean)) {
-		try {
-			server_data = await load_data(url, invalid_server_nodes);
-		} catch (error) {
-			const handled_error = await handle_error(error, { url, params, route: { id } });
+		if (invalid_server_nodes.some(Boolean)) {
+			try {
+				server_data = await load_data(url, invalid_server_nodes);
+			} catch (error) {
+				const handled_error = await handle_error(error, { url, params, route: { id } });
 
-			if (preload_tokens.has(preload)) {
-				return preload_error({ error: handled_error, url, params, route });
-			}
+				if (preload_tokens.has(preload)) {
+					return preload_error({ error: handled_error, url, params, route });
+				}
 
-			return load_root_error_page({
-				status: get_status(error),
-				error: handled_error,
-				url,
-				route
-			});
-		}
+				return load_root_error_page({
+					status: get_status(error),
+					error: handled_error,
+					url,
+					route
+				});
+			}
 
-		if (server_data.type === 'redirect') {
-			return server_data;
+			if (server_data.type === 'redirect') {
+				return server_data;
+			}
 		}
 	}
 
@@ -1232,27 +1261,29 @@ async function load_root_error_page({ status, error, url, route }) {
 	/** @type {import('types').ServerDataNode | null} */
 	let server_data_node = null;
 
-	const default_layout_has_server_load = app.server_loads[0] === 0;
+	if (__SVELTEKIT_HAS_SERVER_LOAD__) {
+		const default_layout_has_server_load = app.server_loads[0] === 0;
 
-	if (default_layout_has_server_load) {
-		// TODO post-https://github.com/sveltejs/kit/discussions/6124 we can use
-		// existing root layout data
-		try {
-			const server_data = await load_data(url, [true]);
+		if (default_layout_has_server_load) {
+			// TODO post-https://github.com/sveltejs/kit/discussions/6124 we can use
+			// existing root layout data
+			try {
+				const server_data = await load_data(url, [true]);
 
-			if (
-				server_data.type !== 'data' ||
-				(server_data.nodes[0] && server_data.nodes[0].type !== 'data')
-			) {
-				throw 0;
-			}
+				if (
+					server_data.type !== 'data' ||
+					(server_data.nodes[0] && server_data.nodes[0].type !== 'data')
+				) {
+					throw 0;
+				}
 
-			server_data_node = server_data.nodes[0] ?? null;
-		} catch {
-			// at this point we have no choice but to fall back to the server, if it wouldn't
-			// bring us right back here, turning this into an endless loop
-			if (url.origin !== origin || url.pathname !== location.pathname || hydrated) {
-				await native_navigation(url);
+				server_data_node = server_data.nodes[0] ?? null;
+			} catch {
+				// at this point we have no choice but to fall back to the server, if it wouldn't
+				// bring us right back here, turning this into an endless loop
+				if (url.origin !== origin || url.pathname !== location.pathname || hydrated) {
+					await native_navigation(url);
+				}
 			}
 		}
 	}
@@ -1653,6 +1684,7 @@ async function navigate({
 	}
 
 	// reset preload synchronously after the history state has been set to avoid race conditions
+	const load_cache_fork = load_cache?.fork;
 	load_cache = null;
 
 	navigation_result.props.page.state = state;
@@ -1687,7 +1719,14 @@ async function navigate({
 			navigation_result.props.page.url = url;
 		}
 
-		root.$set(navigation_result.props);
+		const fork = load_cache_fork && (await load_cache_fork);
+
+		if (fork) {
+			void fork.commit();
+		} else {
+			root.$set(navigation_result.props);
+		}
+
 		update(navigation_result.props.page);
 		has_navigated = true;
 	} else {
@@ -1696,8 +1735,15 @@ async function navigate({
 
 	const { activeElement } = document;
 
+	const promises = [tick()];
+
 	// need to render the DOM before we can scroll to the rendered elements and do focus management
-	await tick();
+	// svelte.settled is only available in Svelte 5
+	if (/** @type {any} */ (svelte).settled) {
+		promises.push(/** @type {any} */ (svelte).settled());
+	}
+	// we still need to await tick everytime because if there's no async work settled resolves immediately
+	await Promise.all(promises);
 
 	// we reset scroll before dealing with focus, to avoid a flash of unscrolled content
 	let scroll = popped ? popped.scroll : noscroll ? scroll_state() : null;

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

@@ -17,10 +17,9 @@ import {
 	deep_set,
 	set_nested_value,
 	throw_on_old_property_access,
-	split_path,
 	build_path_string,
 	normalize_issue
-} from '../../form-utils.svelte.js';
+} from '../../form-utils.js';
 
 /**
  * Merge client issues into server issues. Server issues are persisted unless
@@ -60,24 +59,9 @@ export function form(id) {
 		const action = '?/remote=' + encodeURIComponent(action_id);
 
 		/**
-		 * By making this $state.raw() and creating a new object each time we update it,
-		 * all consumers along the update chain are properly invalidated.
 		 * @type {Record<string, string | string[] | File | File[]>}
 		 */
-		let input = $state.raw({});
-
-		// TODO 3.0: Remove versions state and related logic; it's a workaround for $derived not updating when created inside $effects
-		/**
-		 * This allows us to update individual fields granularly
-		 * @type {Record<string, number>}
-		 */
-		const versions = $state({});
-
-		/**
-		 * This ensures that `{field.value()}` is updated even if the version hasn't been initialized
-		 * @type {Set<string>}
-		 */
-		const version_reads = new Set();
+		let input = $state({});
 
 		/** @type {InternalRemoteFormIssue[]} */
 		let raw_issues = $state.raw([]);
@@ -101,16 +85,6 @@ export function form(id) {
 
 		let submitted = false;
 
-		function update_all_versions() {
-			for (const path of version_reads) {
-				versions[path] ??= 0;
-			}
-
-			for (const key of Object.keys(versions)) {
-				versions[key] += 1;
-			}
-		}
-
 		/**
 		 * @param {FormData} form_data
 		 * @returns {Record<string, any>}
@@ -235,8 +209,6 @@ export function form(id) {
 						if (issues.$) {
 							release_overrides(updates);
 						} else {
-							update_all_versions();
-
 							if (form_result.refreshes) {
 								refresh_queries(form_result.refreshes, updates);
 							} else {
@@ -386,7 +358,7 @@ export function form(id) {
 							}
 						}
 
-						input = set_nested_value(input, name, value);
+						set_nested_value(input, name, value);
 					} else if (is_file) {
 						if (DEV && element.multiple) {
 							throw new Error(
@@ -397,7 +369,7 @@ export function form(id) {
 						const file = /** @type {HTMLInputElement & { files: FileList }} */ (element).files[0];
 
 						if (file) {
-							input = set_nested_value(input, name, file);
+							set_nested_value(input, name, file);
 						} else {
 							// Remove the property by setting to undefined and clean up
 							const path_parts = name.split(/\.|\[|\]/).filter(Boolean);
@@ -409,7 +381,7 @@ export function form(id) {
 							delete current[path_parts[path_parts.length - 1]];
 						}
 					} else {
-						input = set_nested_value(
+						set_nested_value(
 							input,
 							name,
 							element.type === 'checkbox' && !element.checked ? null : element.value
@@ -418,17 +390,7 @@ export function form(id) {
 
 					name = name.replace(/^[nb]:/, '');
 
-					versions[name] ??= 0;
-					versions[name] += 1;
-
-					const path = split_path(name);
-
-					while (path.pop() !== undefined) {
-						const name = build_path_string(path);
-
-						versions[name] ??= 0;
-						versions[name] += 1;
-					}
+					touched[name] = true;
 				});
 
 				form.addEventListener('reset', async () => {
@@ -437,7 +399,6 @@ export function form(id) {
 					await tick();
 
 					input = convert_formdata(new FormData(form));
-					update_all_versions();
 				});
 
 				return () => {
@@ -530,28 +491,14 @@ export function form(id) {
 					create_field_proxy(
 						{},
 						() => input,
-						(path) => {
-							version_reads.add(path);
-							versions[path];
-						},
 						(path, value) => {
 							if (path.length === 0) {
 								input = value;
-								update_all_versions();
 							} else {
-								input = deep_set(input, path.map(String), value);
+								deep_set(input, path.map(String), value);
 
 								const key = build_path_string(path);
-								versions[key] ??= 0;
-								versions[key] += 1;
 								touched[key] = true;
-
-								const parent_path = path.slice();
-								while (parent_path.pop() !== undefined) {
-									const parent_key = build_path_string(parent_path);
-									versions[parent_key] ??= 0;
-									versions[parent_key] += 1;
-								}
 							}
 						},
 						() => issues

package/src/runtime/{form-utils.svelte.js → form-utils.js}

@@ -3,12 +3,9 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 
 import { DEV } from 'esm-env';
-import * as svelte from 'svelte';
-// Svelte 4 and under don't have `untrack` - you'll not be able to use remote functions with Svelte 4 but this will still be loaded
-const untrack = svelte.untrack ?? ((value) => value());
 
 /**
- * Sets a value in a nested object using a path string, not mutating the original object but returning a new object
+ * Sets a value in a nested object using a path string, mutating the original object
  * @param {Record<string, any>} object
  * @param {string} path_string
  * @param {any} value
@@ -22,7 +19,7 @@ export function set_nested_value(object, path_string, value) {
 		value = value === 'on';
 	}
 
-	return deep_set(object, split_path(path_string), value);
+	deep_set(object, split_path(path_string), value);
 }
 
 /**
@@ -31,7 +28,7 @@ export function set_nested_value(object, path_string, value) {
  */
 export function convert_formdata(data) {
 	/** @type {Record<string, any>} */
-	let result = Object.create(null); // guard against prototype pollution
+	const result = {};
 
 	for (let key of data.keys()) {
 		if (key.startsWith('sveltekit:')) {
@@ -61,7 +58,7 @@ export function convert_formdata(data) {
 			values = values.map((v) => v === 'on');
 		}
 
-		result = set_nested_value(result, key, is_array ? values : values[0]);
+		set_nested_value(result, key, is_array ? values : values[0]);
 	}
 
 	return result;
@@ -81,18 +78,32 @@ export function split_path(path) {
 }
 
 /**
- * Sets a value in a nested object using an array of keys.
- * Does not mutate the original object; returns a new object.
+ * Check if a property key is dangerous and could lead to prototype pollution
+ * @param {string} key
+ */
+function check_prototype_pollution(key) {
+	if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+		throw new Error(
+			`Invalid key "${key}"` +
+				(DEV ? ': This key is not allowed to prevent prototype pollution.' : '')
+		);
+	}
+}
+
+/**
+ * Sets a value in a nested object using an array of keys, mutating the original object.
  * @param {Record<string, any>} object
  * @param {string[]} keys
  * @param {any} value
  */
 export function deep_set(object, keys, value) {
-	const result = Object.assign(Object.create(null), object); // guard against prototype pollution
-	let current = result;
+	let current = object;
 
 	for (let i = 0; i < keys.length - 1; i += 1) {
 		const key = keys[i];
+
+		check_prototype_pollution(key);
+
 		const is_array = /^\d+$/.test(keys[i + 1]);
 		const exists = key in current;
 		const inner = current[key];
@@ -101,18 +112,16 @@ export function deep_set(object, keys, value) {
 			throw new Error(`Invalid array key ${keys[i + 1]}`);
 		}
 
-		current[key] = is_array
-			? exists
-				? [...inner]
-				: []
-			: // guard against prototype pollution
-				Object.assign(Object.create(null), inner);
+		if (!exists) {
+			current[key] = is_array ? [] : {};
+		}
 
 		current = current[key];
 	}
 
-	current[keys[keys.length - 1]] = value;
-	return result;
+	const final_key = keys[keys.length - 1];
+	check_prototype_pollution(final_key);
+	current[final_key] = value;
 }
 
 /**
@@ -196,18 +205,14 @@ export function deep_get(object, path) {
  * Creates a proxy-based field accessor for form data
  * @param {any} target - Function or empty POJO
  * @param {() => Record<string, any>} get_input - Function to get current input data
- * @param {(path: string) => void} depend - Function to make an effect depend on a specific field
  * @param {(path: (string | number)[], value: any) => void} set_input - Function to set input data
  * @param {() => Record<string, InternalRemoteFormIssue[]>} get_issues - Function to get current issues
  * @param {(string | number)[]} path - Current access path
  * @returns {any} Proxy object with name(), value(), and issues() methods
  */
-export function create_field_proxy(target, get_input, depend, set_input, get_issues, path = []) {
-	const path_string = build_path_string(path);
-
+export function create_field_proxy(target, get_input, set_input, get_issues, path = []) {
 	const get_value = () => {
-		depend(path_string);
-		return untrack(() => deep_get(get_input(), path));
+		return deep_get(get_input(), path);
 	};
 
 	return new Proxy(target, {
@@ -216,7 +221,7 @@ export function create_field_proxy(target, get_input, depend, set_input, get_iss
 
 			// Handle array access like jobs[0]
 			if (/^\d+$/.test(prop)) {
-				return create_field_proxy({}, get_input, depend, set_input, get_issues, [
+				return create_field_proxy({}, get_input, set_input, get_issues, [
 					...path,
 					parseInt(prop, 10)
 				]);
@@ -229,17 +234,11 @@ export function create_field_proxy(target, get_input, depend, set_input, get_iss
 					set_input(path, newValue);
 					return newValue;
 				};
-				return create_field_proxy(set_func, get_input, depend, set_input, get_issues, [
-					...path,
-					prop
-				]);
+				return create_field_proxy(set_func, get_input, set_input, get_issues, [...path, prop]);
 			}
 
 			if (prop === 'value') {
-				return create_field_proxy(get_value, get_input, depend, set_input, get_issues, [
-					...path,
-					prop
-				]);
+				return create_field_proxy(get_value, get_input, set_input, get_issues, [...path, prop]);
 			}
 
 			if (prop === 'issues' || prop === 'allIssues') {
@@ -259,10 +258,7 @@ export function create_field_proxy(target, get_input, depend, set_input, get_iss
 						}));
 				};
 
-				return create_field_proxy(issues_func, get_input, depend, set_input, get_issues, [
-					...path,
-					prop
-				]);
+				return create_field_proxy(issues_func, get_input, set_input, get_issues, [...path, prop]);
 			}
 
 			if (prop === 'as') {
@@ -411,14 +407,11 @@ export function create_field_proxy(target, get_input, depend, set_input, get_iss
 					});
 				};
 
-				return create_field_proxy(as_func, get_input, depend, set_input, get_issues, [
-					...path,
-					'as'
-				]);
+				return create_field_proxy(as_func, get_input, set_input, get_issues, [...path, 'as']);
 			}
 
 			// Handle property access (nested fields)
-			return create_field_proxy({}, get_input, depend, set_input, get_issues, [...path, prop]);
+			return create_field_proxy({}, get_input, set_input, get_issues, [...path, prop]);
 		}
 	});
 }

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

@@ -227,7 +227,6 @@ export async function render_response({
 					paths.reset();
 				}
 
-				// eslint-disable-next-line
 				const { head, html, css } = options.async ? await rendered : rendered;
 
 				return { head, html, css };
@@ -654,7 +653,7 @@ export async function render_response({
 					async start(controller) {
 						controller.enqueue(text_encoder.encode(transformed + '\n'));
 						for await (const chunk of chunks) {
-							controller.enqueue(text_encoder.encode(chunk));
+							if (chunk.length) controller.enqueue(text_encoder.encode(chunk));
 						}
 						controller.close();
 					},

package/src/types/global-private.d.ts

@@ -13,6 +13,16 @@ declare global {
 	const __SVELTEKIT_EXPERIMENTAL__REMOTE_FUNCTIONS__: boolean;
 	/** True if `config.kit.router.resolution === 'client'` */
 	const __SVELTEKIT_CLIENT_ROUTING__: boolean;
+	/**
+	 * True if any node in the manifest has a server load function.
+	 * Used for treeshaking server load code from client bundles when no server loads exist.
+	 */
+	const __SVELTEKIT_HAS_SERVER_LOAD__: boolean;
+	/**
+	 * True if any node in the manifest has a universal load function.
+	 * Used for treeshaking universal load code from client bundles when no universal loads exist.
+	 */
+	const __SVELTEKIT_HAS_UNIVERSAL_LOAD__: boolean;
 	/** The `__sveltekit_abc123` object in the init `<script>` */
 	const __SVELTEKIT_PAYLOAD__: {
 		/** The basepath, usually relative to the current page */

package/src/types/internal.d.ts

@@ -370,6 +370,7 @@ export interface ServerMetadata {
 	nodes: Array<{
 		/** Also `true` when using `trailingSlash`, because we need to do a server request in that case to get its value. */
 		has_server_load: boolean;
+		has_universal_load: boolean;
 	}>;
 	routes: Map<string, ServerMetadataRoute>;
 	/** For each hashed remote file, a map of export name -> { type, dynamic }, where `dynamic` is `false` for non-dynamic prerender functions */
@@ -395,6 +396,7 @@ export interface SSRComponent {
 export type SSRComponentLoader = () => Promise<SSRComponent>;
 
 export interface UniversalNode {
+	/** Is `null` in case static analysis succeeds but the node is ssr=false */
 	load?: Load;
 	prerender?: PrerenderOption;
 	ssr?: boolean;

package/src/version.js

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

package/types/index.d.ts

@@ -1890,10 +1890,28 @@ declare module '@sveltejs/kit' {
 		allIssues(): RemoteFormIssue[] | undefined;
 	};
 
+	type UnknownField<Value> = RemoteFormFieldMethods<Value> & {
+		/** Validation issues belonging to this or any of the fields that belong to it, if any */
+		allIssues(): RemoteFormIssue[] | undefined;
+		/**
+		 * Returns an object that can be spread onto an input element with the correct type attribute,
+		 * aria-invalid attribute if the field is invalid, and appropriate value/checked property getters/setters.
+		 * @example
+		 * ```svelte
+		 * <input {...myForm.fields.myString.as('text')} />
+		 * <input {...myForm.fields.myNumber.as('number')} />
+		 * <input {...myForm.fields.myBoolean.as('checkbox')} />
+		 * ```
+		 */
+		as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+	} & {
+		[key: string | number]: UnknownField<any>;
+	};
+
 	/**
 	 * Recursive type to build form fields structure with proxy access
 	 */
-	type RemoteFormFields<T> =
+	export type RemoteFormFields<T> =
 		WillRecurseIndefinitely<T> extends true
 			? RecursiveFormFields
 			: NonNullable<T> extends string | number | boolean | File
@@ -1901,11 +1919,17 @@ declare module '@sveltejs/kit' {
 				: T extends string[] | File[]
 					? RemoteFormField<T> & { [K in number]: RemoteFormField<T[number]> }
 					: T extends Array<infer U>
-						? RemoteFormFieldContainer<T> & { [K in number]: RemoteFormFields<U> }
-						: RemoteFormFieldContainer<T> & { [K in keyof T]-?: RemoteFormFields<T[K]> };
+						? RemoteFormFieldContainer<T> & {
+								[K in number]: RemoteFormFields<U>;
+							}
+						: RemoteFormFieldContainer<T> & {
+								[K in keyof T]-?: RemoteFormFields<T[K]>;
+							};
 
 	// By breaking this out into its own type, we avoid the TS recursion depth limit
-	type RecursiveFormFields = RemoteFormField<any> & { [key: string | number]: RecursiveFormFields };
+	type RecursiveFormFields = RemoteFormFieldContainer<any> & {
+		[key: string | number]: UnknownField<any>;
+	};
 
 	type MaybeArray<T> = T | T[];
 
@@ -2491,6 +2515,7 @@ declare module '@sveltejs/kit' {
 	type SSRComponentLoader = () => Promise<SSRComponent>;
 
 	interface UniversalNode {
+		/** Is `null` in case static analysis succeeds but the node is ssr=false */
 		load?: Load;
 		prerender?: PrerenderOption;
 		ssr?: boolean;

package/types/index.d.ts.map

@@ -66,6 +66,7 @@
 		"AsArgs",
 		"RemoteFormField",
 		"RemoteFormFieldContainer",
+		"UnknownField",
 		"RemoteFormFields",
 		"RecursiveFormFields",
 		"MaybeArray",
@@ -211,6 +212,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }