@sveltejs/kit 1.0.0-next.446 → 1.0.0-next.447

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.446",
+  "version": "1.0.0-next.447",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -12,7 +12,7 @@
   "dependencies": {
     "@sveltejs/vite-plugin-svelte": "^1.0.1",
     "cookie": "^0.5.0",
-    "devalue": "^2.0.1",
+    "devalue": "^3.1.2",
     "kleur": "^4.1.4",
     "magic-string": "^0.26.2",
     "mime": "^3.0.0",
@@ -36,7 +36,6 @@
     "rollup": "^2.75.7",
     "svelte": "^3.48.0",
     "svelte-preprocess": "^4.10.6",
-    "tiny-glob": "^0.2.9",
     "typescript": "^4.7.4",
     "uvu": "^0.5.3",
     "vite": "^3.0.9"

package/src/{core/constants.js → constants.js}

@@ -3,3 +3,5 @@
 export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
 
 export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';
+
+export const DATA_SUFFIX = '/__data.js';

package/src/core/env.js

@@ -1,4 +1,4 @@
-import { GENERATED_COMMENT } from './constants.js';
+import { GENERATED_COMMENT } from '../constants.js';
 import { runtime_base } from './utils.js';
 
 /**

package/src/core/sync/write_ambient.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { get_env } from '../../exports/vite/utils.js';
-import { GENERATED_COMMENT } from '../constants.js';
+import { GENERATED_COMMENT } from '../../constants.js';
 import { create_types } from '../env.js';
 import { write_if_changed } from './utils.js';
 

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

@@ -8,7 +8,7 @@ import { installPolyfills } from '../../../exports/node/polyfills.js';
 import { coalesce_to_error } from '../../../utils/error.js';
 import { posixify } from '../../../utils/filesystem.js';
 import { load_template } from '../../../core/config/index.js';
-import { SVELTE_KIT_ASSETS } from '../../../core/constants.js';
+import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import * as sync from '../../../core/sync/sync.js';
 import { get_mime_lookup, runtime_base, runtime_prefix } from '../../../core/utils.js';
 import { get_env, prevent_illegal_vite_imports, resolve_entry } from '../utils.js';

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

@@ -4,7 +4,7 @@ import sirv from 'sirv';
 import { pathToFileURL } from 'url';
 import { getRequest, setResponse } from '../../../exports/node/index.js';
 import { installPolyfills } from '../../../exports/node/polyfills.js';
-import { SVELTE_KIT_ASSETS } from '../../../core/constants.js';
+import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { loadEnv } from 'vite';
 
 /** @typedef {import('http').IncomingMessage} Req */

package/src/runtime/client/client.js

@@ -10,6 +10,7 @@ import Root from '__GENERATED__/root.svelte';
 import { nodes, server_loads, dictionary, matchers } from '__GENERATED__/client-manifest.js';
 import { HttpError, Redirect } from '../control.js';
 import { stores } from './singletons.js';
+import { DATA_SUFFIX } from '../../constants.js';
 
 const SCROLL_KEY = 'sveltekit:scroll';
 const INDEX_KEY = 'sveltekit:index';
@@ -393,7 +394,7 @@ export function create_client({ target, base, trailing_slash }) {
 	 *   status: number;
 	 *   error: HttpError | Error | null;
 	 *   routeId: string | null;
-	 *   validation_errors?: string | undefined;
+	 *   validation_errors?: Record<string, any> | null;
 	 * }} opts
 	 */
 	async function get_navigation_result_from_branch({
@@ -715,24 +716,14 @@ export function create_client({ target, base, trailing_slash }) {
 
 		if (invalid_server_nodes.some(Boolean)) {
 			try {
-				const res = await native_fetch(
-					`${url.pathname}${url.pathname.endsWith('/') ? '' : '/'}__data.json${url.search}`,
-					{
-						headers: {
-							'x-sveltekit-invalidated': invalid_server_nodes.map((x) => (x ? '1' : '')).join(',')
-						}
-					}
-				);
-
-				server_data = /** @type {import('types').ServerData} */ (await res.json());
-
-				if (!res.ok) {
-					throw server_data;
-				}
-			} catch (e) {
-				// something went catastrophically wrong — bail and defer to the server
-				native_navigation(url);
-				return;
+				server_data = await load_data(url, invalid_server_nodes);
+			} catch (error) {
+				return load_root_error_page({
+					status: 500,
+					error: /** @type {Error} */ (error),
+					url,
+					routeId: route.id
+				});
 			}
 
 			if (server_data.type === 'redirect') {
@@ -882,19 +873,18 @@ export function create_client({ target, base, trailing_slash }) {
 		if (node.server) {
 			// TODO post-https://github.com/sveltejs/kit/discussions/6124 we can use
 			// existing root layout data
-			const res = await native_fetch(
-				`${url.pathname}${url.pathname.endsWith('/') ? '' : '/'}__data.json${url.search}`,
-				{
-					headers: {
-						'x-sveltekit-invalidated': '1'
-					}
-				}
-			);
+			try {
+				const server_data = await load_data(url, [true]);
 
-			const server_data_nodes = await res.json();
-			server_data_node = server_data_nodes?.[0] ?? null;
+				if (
+					server_data.type !== 'data' ||
+					(server_data.nodes[0] && server_data.nodes[0].type !== 'data')
+				) {
+					throw 0;
+				}
 
-			if (!res.ok || server_data_nodes?.type !== 'data') {
+				server_data_node = server_data.nodes[0] ?? null;
+			} catch {
 				// at this point we have no choice but to fall back to the server
 				native_navigation(url);
 
@@ -1298,32 +1288,24 @@ export function create_client({ target, base, trailing_slash }) {
 			});
 		},
 
-		_hydrate: async ({ status, error, node_ids, params, routeId }) => {
+		_hydrate: async ({
+			status,
+			error: original_error, // TODO get rid of this
+			node_ids,
+			params,
+			routeId,
+			data: server_data_nodes,
+			errors: validation_errors
+		}) => {
 			const url = new URL(location.href);
 
 			/** @type {import('./types').NavigationFinished | undefined} */
 			let result;
 
 			try {
-				/**
-				 * @param {string} type
-				 * @param {any} fallback
-				 */
-				const parse = (type, fallback) => {
-					const script = document.querySelector(`script[sveltekit\\:data-type="${type}"]`);
-					return script?.textContent ? JSON.parse(script.textContent) : fallback;
-				};
-				/**
-				 * @type {Array<import('types').ServerDataNode | null>}
-				 * On initial navigation, this will only consist of data nodes or `null`.
-				 * A possible error is passed through the `error` property, in which case
-				 * the last entry of `node_ids` is an error page and the last entry of
-				 * `server_data_nodes` is `null`.
-				 */
-				const server_data_nodes = parse('server_data', []);
-				const validation_errors = parse('validation_errors', undefined);
-
 				const branch_promises = node_ids.map(async (n, i) => {
+					const server_data_node = server_data_nodes[i];
+
 					return load_node({
 						loader: nodes[n],
 						url,
@@ -1336,7 +1318,7 @@ export function create_client({ target, base, trailing_slash }) {
 							}
 							return data;
 						},
-						server_data_node: create_data_node(server_data_nodes[i])
+						server_data_node: create_data_node(server_data_node)
 					});
 				});
 
@@ -1345,13 +1327,15 @@ export function create_client({ target, base, trailing_slash }) {
 					params,
 					branch: await Promise.all(branch_promises),
 					status,
-					error: /** @type {import('../server/page/types').SerializedHttpError} */ (error)
+					error: /** @type {import('../server/page/types').SerializedHttpError} */ (original_error)
 						?.__is_http_error
 						? new HttpError(
-								/** @type {import('../server/page/types').SerializedHttpError} */ (error).status,
-								error.message
+								/** @type {import('../server/page/types').SerializedHttpError} */ (
+									original_error
+								).status,
+								original_error.message
 						  )
-						: error,
+						: original_error,
 					validation_errors,
 					routeId
 				});
@@ -1377,3 +1361,34 @@ export function create_client({ target, base, trailing_slash }) {
 		}
 	};
 }
+
+let data_id = 1;
+
+/**
+ * @param {URL} url
+ * @param {boolean[]} invalid
+ * @returns {Promise<import('types').ServerData>}
+ */
+async function load_data(url, invalid) {
+	const data_url = new URL(url);
+	data_url.pathname = url.pathname.replace(/\/$/, '') + DATA_SUFFIX;
+	data_url.searchParams.set('__invalid', invalid.map((x) => (x ? 'y' : 'n')).join(''));
+	data_url.searchParams.set('__id', String(data_id++));
+
+	// The __data.js file is generated by the server and looks like
+	// `window.__sveltekit_data = ${devalue(data)}`. We do this instead
+	// of `export const data` because modules are cached indefinitely,
+	// and that would cause memory leaks.
+	//
+	// The data is read and deleted in the same tick as the promise
+	// resolves, so it's not vulnerable to race conditions
+	await import(/* @vite-ignore */ data_url.href);
+
+	// @ts-expect-error
+	const server_data = window.__sveltekit_data;
+
+	// @ts-expect-error
+	delete window.__sveltekit_data;
+
+	return server_data;
+}

package/src/runtime/client/start.js

@@ -20,6 +20,8 @@ export { set_public_env } from '../env-public.js';
  *     node_ids: number[];
  *     params: Record<string, string>;
  *     routeId: string | null;
+ *     data: Array<import('types').ServerDataNode | null>;
+ *     errors: Record<string, any> | null;
  *   };
  * }} opts
  */

package/src/runtime/client/types.d.ts

@@ -27,6 +27,8 @@ export interface Client {
 		node_ids: number[];
 		params: Record<string, string>;
 		routeId: string | null;
+		data: Array<import('types').ServerDataNode | null>;
+		errors: Record<string, any> | null;
 	}) => Promise<void>;
 	_start_router: () => void;
 }

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

@@ -0,0 +1,146 @@
+import { HttpError, Redirect } from '../../control.js';
+import { normalize_error } from '../../../utils/error.js';
+import { once } from '../../../utils/functions.js';
+import { load_server_data } from '../page/load_data.js';
+import { data_response, error_to_pojo } from '../utils.js';
+import { normalize_path } from '../../../utils/url.js';
+import { DATA_SUFFIX } from '../../../constants.js';
+
+/**
+ * @param {import('types').RequestEvent} event
+ * @param {import('types').SSRRoute} route
+ * @param {import('types').SSROptions} options
+ * @param {import('types').SSRState} state
+ * @returns {Promise<Response>}
+ */
+export async function render_data(event, route, options, state) {
+	if (!route.page) {
+		// requesting /__data.js should fail for a +server.js
+		return new Response(undefined, {
+			status: 404
+		});
+	}
+
+	try {
+		const node_ids = [...route.page.layouts, route.page.leaf];
+
+		const invalidated =
+			event.url.searchParams
+				.get('__invalid')
+				?.split('')
+				.map((x) => x === 'y') ?? node_ids.map(() => true);
+
+		let aborted = false;
+
+		const url = new URL(event.url);
+		url.pathname = normalize_path(
+			url.pathname.slice(0, -DATA_SUFFIX.length),
+			options.trailing_slash
+		);
+
+		url.searchParams.delete('__invalid');
+		url.searchParams.delete('__id');
+
+		const new_event = { ...event, url };
+
+		const functions = node_ids.map((n, i) => {
+			return once(async () => {
+				try {
+					if (aborted) {
+						return /** @type {import('types').ServerDataSkippedNode} */ ({
+							type: 'skip'
+						});
+					}
+
+					// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
+					const node = n == undefined ? n : await options.manifest._.nodes[n]();
+					return load_server_data({
+						event: new_event,
+						state,
+						node,
+						parent: async () => {
+							/** @type {Record<string, any>} */
+							const data = {};
+							for (let j = 0; j < i; j += 1) {
+								const parent = /** @type {import('types').ServerDataNode | null} */ (
+									await functions[j]()
+								);
+
+								if (parent) {
+									Object.assign(data, parent.data);
+								}
+							}
+							return data;
+						}
+					});
+				} catch (e) {
+					aborted = true;
+					throw e;
+				}
+			});
+		});
+
+		const promises = functions.map(async (fn, i) => {
+			if (!invalidated[i]) {
+				return /** @type {import('types').ServerDataSkippedNode} */ ({
+					type: 'skip'
+				});
+			}
+
+			return fn();
+		});
+
+		let length = promises.length;
+		const nodes = await Promise.all(
+			promises.map((p, i) =>
+				p.catch((e) => {
+					const error = normalize_error(e);
+
+					if (error instanceof Redirect) {
+						throw error;
+					}
+
+					// Math.min because array isn't guaranteed to resolve in order
+					length = Math.min(length, i + 1);
+
+					if (error instanceof HttpError) {
+						return /** @type {import('types').ServerErrorNode} */ ({
+							type: 'error',
+							httperror: { ...error }
+						});
+					}
+
+					options.handle_error(error, event);
+
+					return /** @type {import('types').ServerErrorNode} */ ({
+						type: 'error',
+						error: error_to_pojo(error, options.get_stack)
+					});
+				})
+			)
+		);
+
+		/** @type {import('types').ServerData} */
+		const server_data = {
+			type: 'data',
+			nodes: nodes.slice(0, length)
+		};
+
+		return data_response(server_data);
+	} catch (e) {
+		const error = normalize_error(e);
+
+		if (error instanceof Redirect) {
+			/** @type {import('types').ServerData} */
+			const server_data = {
+				type: 'redirect',
+				location: error.location
+			};
+
+			return data_response(server_data);
+		} else {
+			// TODO make it clearer that this was an unexpected error
+			return data_response(error_to_pojo(error, options.get_stack));
+		}
+	}
+}

package/src/runtime/server/index.js

@@ -2,20 +2,16 @@ import { render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
-import { coalesce_to_error, normalize_error } from '../../utils/error.js';
-import { serialize_error, GENERIC_ERROR, error_to_pojo } from './utils.js';
+import { coalesce_to_error } from '../../utils/error.js';
+import { serialize_error, GENERIC_ERROR } from './utils.js';
 import { decode_params, disable_search, normalize_path } from '../../utils/url.js';
 import { exec } from '../../utils/routing.js';
 import { negotiate } from '../../utils/http.js';
-import { HttpError, Redirect } from '../control.js';
-import { load_server_data } from './page/load_data.js';
-import { json } from '../../exports/index.js';
-import { once } from '../../utils/functions.js';
+import { render_data } from './data/index.js';
+import { DATA_SUFFIX } from '../../constants.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
-const DATA_SUFFIX = '/__data.json';
-
 /** @param {{ html: string }} opts */
 const default_transform = ({ html }) => html;
 
@@ -69,12 +65,7 @@ export async function respond(request, options, state) {
 	}
 
 	const is_data_request = decoded.endsWith(DATA_SUFFIX);
-
-	if (is_data_request) {
-		const data_suffix_length = DATA_SUFFIX.length - (options.trailing_slash === 'always' ? 1 : 0);
-		decoded = decoded.slice(0, -data_suffix_length) || '/';
-		url = new URL(url.origin + url.pathname.slice(0, -data_suffix_length) + url.search);
-	}
+	if (is_data_request) decoded = decoded.slice(0, -DATA_SUFFIX.length);
 
 	if (!state.prerendering?.fallback) {
 		const matchers = await options.manifest._.matchers();
@@ -92,26 +83,19 @@ export async function respond(request, options, state) {
 		}
 	}
 
-	if (route) {
-		if (route.page) {
-			const normalized = normalize_path(url.pathname, options.trailing_slash);
-
-			if (normalized !== url.pathname && !state.prerendering?.fallback) {
-				return new Response(undefined, {
-					status: 301,
-					headers: {
-						'x-sveltekit-normalize': '1',
-						location:
-							// ensure paths starting with '//' are not treated as protocol-relative
-							(normalized.startsWith('//') ? url.origin + normalized : normalized) +
-							(url.search === '?' ? '' : url.search)
-					}
-				});
-			}
-		} else if (is_data_request) {
-			// requesting /__data.json should fail for a standalone endpoint
+	if (route?.page && !is_data_request) {
+		const normalized = normalize_path(url.pathname, options.trailing_slash);
+
+		if (normalized !== url.pathname && !state.prerendering?.fallback) {
 			return new Response(undefined, {
-				status: 404
+				status: 301,
+				headers: {
+					'x-sveltekit-normalize': '1',
+					location:
+						// ensure paths starting with '//' are not treated as protocol-relative
+						(normalized.startsWith('//') ? url.origin + normalized : normalized) +
+						(url.search === '?' ? '' : url.search)
+				}
 			});
 		}
 	}
@@ -250,116 +234,9 @@ export async function respond(request, options, state) {
 				if (route) {
 					/** @type {Response} */
 					let response;
-					if (is_data_request && route.page) {
-						try {
-							const node_ids = [...route.page.layouts, route.page.leaf];
-
-							const invalidated =
-								request.headers.get('x-sveltekit-invalidated')?.split(',').map(Boolean) ??
-								node_ids.map(() => true);
-
-							let aborted = false;
-
-							const functions = node_ids.map((n, i) => {
-								return once(async () => {
-									try {
-										if (aborted) {
-											return /** @type {import('types').ServerDataSkippedNode} */ ({
-												type: 'skip'
-											});
-										}
-
-										// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
-										const node = n == undefined ? n : await options.manifest._.nodes[n]();
-										return load_server_data({
-											dev: options.dev,
-											event,
-											state,
-											node,
-											parent: async () => {
-												/** @type {Record<string, any>} */
-												const data = {};
-												for (let j = 0; j < i; j += 1) {
-													const parent = /** @type {import('types').ServerDataNode | null} */ (
-														await functions[j]()
-													);
-
-													if (parent) {
-														Object.assign(data, parent.data);
-													}
-												}
-												return data;
-											}
-										});
-									} catch (e) {
-										aborted = true;
-										throw e;
-									}
-								});
-							});
 
-							const promises = functions.map(async (fn, i) => {
-								if (!invalidated[i]) {
-									return /** @type {import('types').ServerDataSkippedNode} */ ({
-										type: 'skip'
-									});
-								}
-
-								return fn();
-							});
-
-							let length = promises.length;
-							const nodes = await Promise.all(
-								promises.map((p, i) =>
-									p.catch((e) => {
-										const error = normalize_error(e);
-
-										if (error instanceof Redirect) {
-											throw error;
-										}
-
-										// Math.min because array isn't guaranteed to resolve in order
-										length = Math.min(length, i + 1);
-
-										if (error instanceof HttpError) {
-											return /** @type {import('types').ServerErrorNode} */ ({
-												type: 'error',
-												httperror: { ...error }
-											});
-										}
-
-										options.handle_error(error, event);
-
-										return /** @type {import('types').ServerErrorNode} */ ({
-											type: 'error',
-											error: error_to_pojo(error, options.get_stack)
-										});
-									})
-								)
-							);
-
-							/** @type {import('types').ServerData} */
-							const server_data = {
-								type: 'data',
-								nodes: nodes.slice(0, length)
-							};
-
-							response = json(server_data);
-						} catch (e) {
-							const error = normalize_error(e);
-
-							if (error instanceof Redirect) {
-								/** @type {import('types').ServerData} */
-								const server_data = {
-									type: 'redirect',
-									location: error.location
-								};
-
-								response = json(server_data);
-							} else {
-								response = json(error_to_pojo(error, options.get_stack), { status: 500 });
-							}
-						}
+					if (is_data_request) {
+						response = await render_data(event, route, options, state);
 					} else if (route.page) {
 						response = await render_page(event, route, route.page, options, state, resolve_opts);
 					} else if (route.endpoint) {
@@ -371,7 +248,7 @@ export async function respond(request, options, state) {
 					}
 
 					if (!is_data_request) {
-						// we only want to set cookies on __data.json requests, we don't
+						// we only want to set cookies on __data.js requests, we don't
 						// want to cache stuff erroneously etc
 						for (const key in headers) {
 							const value = headers[key];

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

@@ -1,3 +1,4 @@
+import { devalue } from 'devalue';
 import { negotiate } from '../../../utils/http.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
@@ -8,6 +9,7 @@ import { error, json } from '../../../exports/index.js';
 import { compact } from '../../../utils/array.js';
 import { normalize_error } from '../../../utils/error.js';
 import { load_data, load_server_data } from './load_data.js';
+import { DATA_SUFFIX } from '../../../constants.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -102,7 +104,7 @@ export async function render_page(event, route, page, options, state, resolve_op
 		}
 
 		const should_prerender_data = nodes.some((node) => node?.server);
-		const data_pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
+		const data_pathname = event.url.pathname.replace(/\/$/, '') + DATA_SUFFIX;
 
 		// it's crucial that we do this before returning the non-SSR response, otherwise
 		// SvelteKit will erroneously believe that the path has been prerendered,
@@ -166,7 +168,6 @@ export async function render_page(event, route, page, options, state, resolve_op
 					}
 
 					return await load_server_data({
-						dev: options.dev,
 						event,
 						state,
 						node,
@@ -231,12 +232,14 @@ export async function render_page(event, route, page, options, state, resolve_op
 
 					if (error instanceof Redirect) {
 						if (state.prerendering && should_prerender_data) {
+							const body = `window.__sveltekit_data = ${JSON.stringify({
+								type: 'redirect',
+								location: error.location
+							})}`;
+
 							state.prerendering.dependencies.set(data_pathname, {
-								response: new Response(undefined),
-								body: JSON.stringify({
-									type: 'redirect',
-									location: error.location
-								})
+								response: new Response(body),
+								body
 							});
 						}
 
@@ -294,12 +297,14 @@ export async function render_page(event, route, page, options, state, resolve_op
 		}
 
 		if (state.prerendering && should_prerender_data) {
+			const body = `window.__sveltekit_data = ${devalue({
+				type: 'data',
+				nodes: branch.map((branch_node) => branch_node?.server_data)
+			})}`;
+
 			state.prerendering.dependencies.set(data_pathname, {
-				response: new Response(undefined),
-				body: JSON.stringify({
-					type: 'data',
-					nodes: branch.map((branch_node) => branch_node?.server_data)
-				})
+				response: new Response(body),
+				body
 			});
 		}
 

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

@@ -3,7 +3,6 @@ import { disable_search, make_trackable } from '../../../utils/url.js';
 /**
  * Calls the user's `load` function.
  * @param {{
- *   dev: boolean;
  *   event: import('types').RequestEvent;
  *   state: import('types').SSRState;
  *   node: import('types').SSRNode | undefined;
@@ -11,7 +10,7 @@ import { disable_search, make_trackable } from '../../../utils/url.js';
  * }} opts
  * @returns {Promise<import('types').ServerDataNode | null>}
  */
-export async function load_server_data({ dev, event, state, node, parent }) {
+export async function load_server_data({ event, state, node, parent }) {
 	if (!node?.server) return null;
 
 	const uses = {
@@ -53,10 +52,6 @@ export async function load_server_data({ dev, event, state, node, parent }) {
 
 	const data = result ? await unwrap_promises(result) : null;
 
-	if (dev) {
-		check_serializability(data, /** @type {string} */ (node.server_id), 'data');
-	}
-
 	return {
 		type: 'data',
 		data,
@@ -127,42 +122,3 @@ async function unwrap_promises(object) {
 
 	return unwrapped;
 }
-
-/**
- * Check that the data can safely be serialized to JSON
- * @param {any} value
- * @param {string} id
- * @param {string} path
- */
-function check_serializability(value, id, path) {
-	const type = typeof value;
-
-	if (type === 'string' || type === 'boolean' || type === 'number' || type === 'undefined') {
-		// primitives are fine
-		return;
-	}
-
-	if (type === 'object') {
-		// nulls are fine...
-		if (!value) return;
-
-		// ...so are plain arrays...
-		if (Array.isArray(value)) {
-			value.forEach((child, i) => {
-				check_serializability(child, id, `${path}[${i}]`);
-			});
-			return;
-		}
-
-		// ...and objects
-		const tag = Object.prototype.toString.call(value);
-		if (tag === '[object Object]') {
-			for (const key in value) {
-				check_serializability(value[key], id, `${path}.${key}`);
-			}
-			return;
-		}
-	}
-
-	throw new Error(`${path} returned from 'load' in ${id} cannot be serialized as JSON`);
-}

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

@@ -1,4 +1,4 @@
-import devalue from 'devalue';
+import { devalue } from 'devalue';
 import { readable, writable } from 'svelte/store';
 import * as cookie from 'cookie';
 import { hash } from '../../hash.js';
@@ -174,6 +174,31 @@ export async function render_response({
 	/** @param {string} path */
 	const prefixed = (path) => (path.startsWith('/') ? path : `${assets}/${path}`);
 
+	const serialized = { data: '', errors: 'null' };
+
+	try {
+		serialized.data = devalue(branch.map(({ server_data }) => server_data));
+	} catch (e) {
+		// If we're here, the data could not be serialized with devalue
+		// TODO if we wanted to get super fancy we could track down the origin of the `load`
+		// function, but it would mean passing more stuff around than we currently do
+		const error = /** @type {any} */ (e);
+		const match = /\[(\d+)\]\.data\.(.+)/.exec(error.path);
+		if (match) throw new Error(`${error.message} (data.${match[2]})`);
+		throw error;
+	}
+
+	if (validation_errors) {
+		try {
+			serialized.errors = devalue(validation_errors);
+		} catch (e) {
+			// If we're here, the data could not be serialized with devalue
+			const error = /** @type {any} */ (e);
+			if (error.path) throw new Error(`${error.message} (errors.${error.path})`);
+			throw error;
+		}
+	}
+
 	// prettier-ignore
 	const init_app = `
 		import { set_public_env, start } from ${s(prefixed(entry.file))};
@@ -191,7 +216,9 @@ export async function render_response({
 				error: ${error && serialize_error(error, e => e.stack)},
 				node_ids: [${branch.map(({ node }) => node.index).join(', ')}],
 				params: ${devalue(event.params)},
-				routeId: ${s(event.routeId)}
+				routeId: ${s(event.routeId)},
+				data: ${serialized.data},
+				errors: ${serialized.errors}
 			}` : 'null'}
 		});
 	`;

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

@@ -35,7 +35,6 @@ export async function respond_with_error({ event, options, state, status, error,
 			const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
 
 			const server_data_promise = load_server_data({
-				dev: options.dev,
 				event,
 				state,
 				node: default_layout,

package/src/runtime/server/utils.js

@@ -1,3 +1,4 @@
+import { devalue } from 'devalue';
 import { HttpError } from '../control.js';
 
 /** @param {any} body */
@@ -114,3 +115,23 @@ export function allowed_methods(mod) {
 
 	return allowed;
 }
+
+/** @param {any} data */
+export function data_response(data) {
+	try {
+		return new Response(`window.__sveltekit_data = ${devalue(data)}`, {
+			headers: {
+				'content-type': 'application/javascript'
+			}
+		});
+	} catch (e) {
+		const error = /** @type {any} */ (e);
+		const match = /\[(\d+)\]\.data\.(.+)/.exec(error.path);
+		const message = match ? `${error.message} (data.${match[2]})` : error.message;
+		return new Response(`throw new Error(${JSON.stringify(message)})`, {
+			headers: {
+				'content-type': 'application/javascript'
+			}
+		});
+	}
+}