@sveltejs/kit 3.0.0-next.14 → 3.0.0-next.16

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

@@ -18,13 +18,14 @@ import {
 } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import { count_non_ssi_comments, create_replacer, get_global_name } from '../utils.js';
+import { count_non_ssi_comments, get_global_name } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import * as env from '__sveltekit/env';
 import { collect_remote_data } from '../remote-functions.js';
 import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 import { Props, RenderNode } from '../../props.svelte.js';
+import { has_custom_transporters, uneval } from '#app/internal/transport';
 
 // TODO rename this function/module
 
@@ -35,12 +36,11 @@ import { Props, RenderNode } from '../../props.svelte.js';
  *   fetched: Array<import('./types.js').Fetched>;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
  *   page_config: { ssr: boolean; csr: boolean };
  *   status: number;
  *   error: App.Error | null;
  *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   action_result?: import('@sveltejs/kit').ActionResult;
  *   data_serializer: import('./types.js').ServerDataSerializer;
@@ -52,12 +52,11 @@ export async function render_response({
 	fetched,
 	options,
 	manifest,
-	state,
 	page_config,
 	status,
 	error = null,
 	event,
-	event_state,
+	state,
 	resolve_opts,
 	action_result,
 	data_serializer,
@@ -183,7 +182,7 @@ export async function render_response({
 
 		props.page.data = data;
 
-		const render_state = { ...event_state, is_in_render: true };
+		const render_state = { ...state, is_in_render: true };
 
 		const render_opts = {
 			context: new Map([
@@ -431,7 +430,7 @@ export async function render_response({
 
 			let app_declaration = '';
 
-			if (Object.keys(options.hooks.transport).length > 0) {
+			if (has_custom_transporters) {
 				if (client.inline) {
 					app_declaration = `const app = ${global}.app.app;`;
 				} else if (client.app) {
@@ -482,8 +481,7 @@ export async function render_response({
 			if (form_value) {
 				serialized.form = uneval_action_response(
 					form_value,
-					/** @type {string} */ (event.route.id),
-					options.hooks.transport
+					/** @type {string} */ (event.route.id)
 				);
 			}
 
@@ -518,11 +516,11 @@ export async function render_response({
 			args.push(`{\n${indent}\t${hydrate.join(`,\n${indent}\t`)}\n${indent}}`);
 		}
 
-		const remote_data = await collect_remote_data({}, event, event_state, options);
+		const remote_data = await collect_remote_data({}, event, state, options);
 
 		const serialized_data =
 			Object.keys(remote_data).length > 0
-				? `${global}.data = ${devalue.uneval(remote_data, create_replacer(options.hooks.transport))};\n\n\t\t\t\t\t\t`
+				? `${global}.data = ${uneval(remote_data)};\n\n\t\t\t\t\t\t`
 				: '';
 
 		// `client.app` is a proxy for `bundleStrategy === 'split'`

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

@@ -13,26 +13,17 @@ import { server_data_serializer } from './data_serializer.js';
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   state: import('types').RequestState;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({
-	event,
-	event_state,
-	options,
-	manifest,
-	state,
-	error,
-	resolve_opts
-}) {
+export async function respond_with_error({ event, state, options, manifest, error, resolve_opts }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
-		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
 		return static_error_page(options, transformed.status, transformed.message);
 	}
 
@@ -44,16 +35,15 @@ export async function respond_with_error({
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
-		const data_serializer = server_data_serializer(event, event_state, options);
+		const data_serializer = server_data_serializer(event, state, options);
 		// Do this here first in case the awaits below before rendering themselves error
-		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
 
 		if (ssr) {
 			state.error = true;
 
 			const server_data_promise = load_server_data({
 				event,
-				event_state,
 				state,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
@@ -65,14 +55,13 @@ export async function respond_with_error({
 
 			const data = await load_data({
 				event,
-				event_state,
+				state,
 				fetched,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
 				parent: async () => ({}),
 				resolve_opts,
 				server_data_promise,
-				state,
 				csr
 			});
 
@@ -93,7 +82,6 @@ export async function respond_with_error({
 		return await render_response({
 			options,
 			manifest,
-			state,
 			page_config: {
 				ssr,
 				csr
@@ -104,7 +92,7 @@ export async function respond_with_error({
 			error_components: [],
 			fetched,
 			event,
-			event_state,
+			state,
 			resolve_opts,
 			data_serializer
 		});
@@ -115,7 +103,7 @@ export async function respond_with_error({
 			return redirect_response(e.status, e.location);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, event_state, options, e);
+		const transformed = await handle_error_and_jsonify(event, state, options, e);
 
 		return static_error_page(options, transformed.status, transformed.message);
 	}

package/src/runtime/server/remote-functions.js

@@ -6,7 +6,8 @@ import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
-import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.js';
+import { create_remote_key, parse_remote_arg, split_remote_key } from '../shared.js';
+import { stringify } from '#app/internal/transport';
 import { handle_error_and_jsonify } from './errors.js';
 import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
@@ -59,7 +60,6 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 	/** @type {RemoteInternals} */
 	const internals = fn.__;
-	const transport = options.hooks.transport;
 
 	event.tracing.current.setAttributes({
 		'sveltekit.remote.call.type': internals.type,
@@ -87,7 +87,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					new URL(event.request.url).searchParams.get('payload')
 				);
 
-				const generator = internals.run(event, state, parse_remote_arg(payload, transport));
+				const generator = internals.run(event, state, parse_remote_arg(payload));
 
 				const encoder = new TextEncoder();
 
@@ -156,7 +156,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 									}
 
 									// only send changed data
-									if (result !== (result = stringify(value, transport))) {
+									if (result !== (result = stringify(value))) {
 										send(controller, {
 											type: 'result',
 											result
@@ -214,9 +214,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {{ payloads: string[] }} */
 				const { payloads } = await event.request.json();
 
-				const args = await Promise.all(
-					payloads.map((payload) => parse_remote_arg(payload, transport))
-				);
+				const args = await Promise.all(payloads.map((payload) => parse_remote_arg(payload)));
 
 				data._ = await with_request_store({ event, state }, () => internals.run(args, options));
 
@@ -266,7 +264,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					return json(
 						/** @type {RemoteFunctionResponse} */ ({
 							type: 'result',
-							data: stringify(data, transport)
+							data: stringify(data)
 						}),
 						{ headers }
 					);
@@ -279,7 +277,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {{ payload: string, refreshes?: string[] }} */
 				const { payload, refreshes } = await event.request.json();
 				state.remote.requested = create_requested_map(refreshes);
-				const arg = parse_remote_arg(payload, transport);
+				const arg = parse_remote_arg(payload);
 
 				data._ = await with_request_store(
 					{ event, state: { ...state, is_in_remote_form_or_command: true } },
@@ -291,7 +289,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 			case 'prerender': {
 				data._ = await with_request_store({ event, state }, () =>
-					fn(parse_remote_arg(additional_args, transport))
+					fn(parse_remote_arg(additional_args))
 				);
 
 				break;
@@ -303,9 +301,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					new URL(event.request.url).searchParams.get('payload')
 				);
 
-				data._ = await with_request_store({ event, state }, () =>
-					fn(parse_remote_arg(payload, transport))
-				);
+				data._ = await with_request_store({ event, state }, () => fn(parse_remote_arg(payload)));
 
 				break;
 			}
@@ -316,7 +312,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'result',
-				data: stringify(data, transport)
+				data: stringify(data)
 			}),
 			{ headers }
 		);
@@ -327,7 +323,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
-					data: stringify(data, transport)
+					data: stringify(data)
 				}),
 				{ headers }
 			);

package/src/runtime/server/respond.js

@@ -42,7 +42,6 @@ import { server_data_serializer } from './page/data_serializer.js';
 import { get_remote_id, handle_remote_call } from './remote-functions.js';
 import { record_span } from '../telemetry/record_span.js';
 import { otel } from '../telemetry/otel.js';
-import { create_request_state } from './state.js';
 
 /** @type {import('types').RequiredResolveOptions['transformPageChunk']} */
 const default_transform = ({ html }) => html;
@@ -85,7 +84,7 @@ export const respond = propagate_context(internal_respond);
  * @param {Request} request
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @param {import('types').SSRState} state
+ * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
 export async function internal_respond(request, options, manifest, state) {
@@ -181,8 +180,6 @@ export async function internal_respond(request, options, manifest, state) {
 		url
 	);
 
-	const event_state = create_request_state(state, options.hooks);
-
 	/** @type {import('@sveltejs/kit').RequestEvent} */
 	const event = {
 		cookies,
@@ -197,7 +194,12 @@ export async function internal_respond(request, options, manifest, state) {
 			}),
 		locals: {},
 		params: {},
-		platform: state.platform,
+		platform: state.emulator?.platform
+			? await state.emulator.platform({
+					config: {},
+					prerender: !!state.prerendering?.fallback
+				})
+			: state.platform,
 		request,
 		route: { id: null },
 		setHeaders: (new_headers) => {
@@ -235,6 +237,7 @@ export async function internal_respond(request, options, manifest, state) {
 		isRemoteRequest: !!remote_id
 	};
 
+	// @ts-expect-error this has to be assigned lazily
 	event.fetch = create_fetch({
 		event,
 		options,
@@ -244,13 +247,6 @@ export async function internal_respond(request, options, manifest, state) {
 		set_internal
 	});
 
-	if (state.emulator?.platform) {
-		event.platform = await state.emulator.platform({
-			config: {},
-			prerender: !!state.prerendering?.fallback
-		});
-	}
-
 	/** @type {string | null} */
 	let resolved_path = url.pathname;
 
@@ -324,7 +320,7 @@ export async function internal_respond(request, options, manifest, state) {
 				statusText: response.statusText
 			});
 		} catch (error) {
-			return await handle_fatal_error(event, event_state, options, error);
+			return await handle_fatal_error(event, state, options, error);
 		}
 	}
 
@@ -368,11 +364,13 @@ export async function internal_respond(request, options, manifest, state) {
 
 			if (result) {
 				route = result.route;
+				// @ts-expect-error this has to be assigned lazily
 				event.route = { id: route.id };
+				// @ts-expect-error this has to be assigned lazily
 				event.params = result.params;
 			}
 		} catch (e) {
-			return await handle_fatal_error(event, event_state, options, e);
+			return await handle_fatal_error(event, state, options, e);
 		}
 	}
 
@@ -432,6 +430,7 @@ export async function internal_respond(request, options, manifest, state) {
 				}
 
 				if (state.emulator?.platform) {
+					// @ts-expect-error this has to be assigned lazily
 					event.platform = await state.emulator.platform({ config, prerender });
 				}
 
@@ -454,10 +453,10 @@ export async function internal_respond(request, options, manifest, state) {
 				add_cookies_to_headers(response.headers, new_cookies.values());
 				return response;
 			} catch (err) {
-				return await handle_fatal_error(event, event_state, options, err);
+				return await handle_fatal_error(event, state, options, err);
 			}
 		}
-		return await handle_fatal_error(event, event_state, options, e);
+		return await handle_fatal_error(event, state, options, e);
 	}
 
 	async function handle() {
@@ -486,7 +485,7 @@ export async function internal_respond(request, options, manifest, state) {
 					}
 				};
 
-				return await with_request_store({ event: traced_event, state: event_state }, () =>
+				return await with_request_store({ event: traced_event, state }, () =>
 					options.hooks.handle({
 						event: traced_event,
 						resolve: (event, opts) => {
@@ -593,10 +592,9 @@ export async function internal_respond(request, options, manifest, state) {
 			if (resolved_path === null) {
 				return await respond_with_error({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					error: new SvelteKitError(
 						400,
 						'Malformed URI',
@@ -609,10 +607,9 @@ export async function internal_respond(request, options, manifest, state) {
 			if (options.hash_routing || state.prerendering?.fallback) {
 				return await render_response({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					page_config: { ssr: false, csr: true },
 					status: 200,
 					error: null,
@@ -626,12 +623,12 @@ export async function internal_respond(request, options, manifest, state) {
 					],
 					fetched: [],
 					resolve_opts,
-					data_serializer: server_data_serializer(event, event_state, options)
+					data_serializer: server_data_serializer(event, state, options)
 				});
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, event_state, options, manifest, remote_id);
+				return await handle_remote_call(event, state, options, manifest, remote_id);
 			}
 
 			if (route) {
@@ -643,11 +640,10 @@ export async function internal_respond(request, options, manifest, state) {
 				if (is_data_request) {
 					response = await render_data(
 						event,
-						event_state,
+						state,
 						route,
 						options,
 						manifest,
-						state,
 						invalidated_data_nodes,
 						trailing_slash
 					);
@@ -672,18 +668,17 @@ export async function internal_respond(request, options, manifest, state) {
 					}
 
 					if (endpoint) {
-						response = await render_endpoint(event, event_state, endpoint, state);
+						response = await render_endpoint(event, state, endpoint);
 					} else if (route.page) {
 						if (!page_nodes) {
 							throw new Error('page_nodes not found. This should never happen');
 						} else if (page_methods.has(method)) {
 							response = await render_page(
 								event,
-								event_state,
+								state,
 								route.page,
 								options,
 								manifest,
-								state,
 								page_nodes,
 								resolve_opts
 							);
@@ -769,10 +764,9 @@ export async function internal_respond(request, options, manifest, state) {
 
 				return await respond_with_error({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					error: new SvelteKitError(404, 'Not Found', `Not found: ${event.url.pathname}`),
 					resolve_opts
 				});
@@ -793,12 +787,13 @@ export async function internal_respond(request, options, manifest, state) {
 			// and I don't even know how to describe it. need to investigate at some point
 
 			// HttpError from endpoint can end up here - TODO should it be handled there instead?
-			return await handle_fatal_error(event, event_state, options, e);
+			return await handle_fatal_error(event, state, options, e);
 		} finally {
 			event.cookies.set = () => {
 				throw new Error('Cannot use `cookies.set(...)` after the response has been generated');
 			};
 
+			// @ts-expect-error this has to be assigned lazily
 			event.setHeaders = () => {
 				throw new Error('Cannot use `setHeaders(...)` after the response has been generated');
 			};

package/src/runtime/server/state.js

@@ -1,20 +1,9 @@
-/** @import { RequestState, ServerHooks, SSRState } from 'types' */
+/** @import { InternalRequestOptions, RequestState, ServerHooks } from 'types' */
 import { record_span } from '../telemetry/record_span.js';
 
-/**
- * @param {SSRState} state
- * @param {ServerHooks} hooks
- * @returns {RequestState}
- */
-export function create_request_state(state, hooks) {
-	// Request state is rebuilt fresh, resetting remote caches and context flags.
+/** Per-request caches and context flags — never carried into a fork. */
+function transient_fields() {
 	return {
-		prerendering: state.prerendering,
-		transport: hooks.transport,
-		handleValidationError: hooks.handleValidationError,
-		tracing: {
-			record_span
-		},
 		remote: {
 			data: null,
 			explicit: null,
@@ -29,15 +18,43 @@ export function create_request_state(state, hooks) {
 		is_in_remote_query: false,
 		is_in_remote_prerender: false,
 		is_in_render: false,
-		is_in_universal_load: false
+		original_event: undefined
 	};
 }
 
 /**
- * @param {SSRState} state
- * @returns {SSRState}
+ * @param {InternalRequestOptions} options
+ * @param {ServerHooks} hooks
+ * @returns {RequestState}
+ */
+export function create_request_state(options, hooks) {
+	// every field is initialized up front so the object shape stays stable
+	return {
+		getClientAddress: options.getClientAddress,
+		platform: options.platform,
+		read: options.read,
+		before_handle: options.before_handle,
+		emulator: options.emulator,
+		prerendering: options.prerendering,
+		prerender_default: undefined,
+		error: false,
+		depth: 0,
+		handleValidationError: hooks.handleValidationError,
+		tracing: {
+			record_span
+		},
+		...transient_fields()
+	};
+}
+
+/**
+ * @param {RequestState} state
+ * @returns {RequestState}
  */
 export function fork_state_for_subrequest(state) {
-	// Sub-requests inherit all server state except for the incremented depth.
-	return { ...state, depth: state.depth + 1 };
+	return {
+		...state,
+		...transient_fields(),
+		depth: state.depth + 1
+	};
 }

package/src/runtime/server/utils.js

@@ -1,5 +1,3 @@
-/** @import { ServerHooks } from 'types' */
-import * as devalue from 'devalue';
 import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
 
@@ -139,21 +137,3 @@ export function get_node_type(node_id) {
 export function count_non_ssi_comments(str) {
 	return (str.match(/<!--(?!#)/g) ?? []).length;
 }
-
-/**
- * Creates a serialiser for non-arbitrary POJOs using the app's transport hook
- * @param {ServerHooks['transport']} transport
- * @returns {(thing: unknown) => string | undefined}
- */
-export function create_replacer(transport) {
-	/** @param {unknown} thing */
-	const replacer = (thing) => {
-		for (const key in transport) {
-			const encoded = transport[key].encode(thing);
-			if (encoded) {
-				return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
-			}
-		}
-	};
-	return replacer;
-}