@sveltejs/kit 3.0.0-next.24 → 3.0.0-next.25

package/src/runtime/server/index.js

@@ -1,14 +1,24 @@
 import { noop } from '../../utils/functions.js';
-import { IN_WEBCONTAINER } from '../../constants.js';
+import { stream_from_iterable } from '../utils.js';
+import { IN_WEBCONTAINER, REROUTED_URL_HEADER } from '../../constants.js';
 import { respond } from './respond.js';
 import { create_request_state } from './state.js';
 import { options, get_hooks } from '<sveltekit:generated>/server.js';
-import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
+import {
+	set_read_implementation,
+	set_manifest,
+	set_options,
+	set_hooks,
+	fix_stack_trace
+} from './internal.js';
 import { set_env } from '<sveltekit:generated>/env/config.js';
 import { init_tracing } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
 import { init_transport } from '#app/internal/transport';
 
+// set at module scope because prerendering evaluates user modules before constructing a `Server`
+set_options(options);
+
 /** @type {Promise<any>} */
 let init_promise;
 
@@ -48,16 +58,11 @@ if (DEV) {
 }
 
 export class Server {
-	/** @type {import('types').SSROptions} */
-	#options;
-
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	#manifest;
 
 	/** @param {import('@sveltejs/kit').SSRManifest} manifest */
 	constructor(manifest) {
-		/** @type {import('types').SSROptions} */
-		this.#options = options;
 		this.#manifest = manifest;
 
 		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
@@ -105,14 +110,11 @@ export class Server {
 					return result;
 				}
 
-				// TODO remove the cast once TypeScript's lib includes `ReadableStream.from`
-				return /** @type {ReadableStream} */ (
-					/** @type {any} */ (ReadableStream).from(
-						(async function* () {
-							const stream = await result;
-							if (stream) yield* stream;
-						})()
-					)
+				return stream_from_iterable(
+					(async function* () {
+						const stream = await result;
+						if (stream) yield* stream;
+					})()
 				);
 			};
 
@@ -125,7 +127,7 @@ export class Server {
 			try {
 				const module = await get_hooks();
 
-				this.#options.hooks = {
+				set_hooks({
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
 					handleError:
 						module.handleError ||
@@ -154,7 +156,7 @@ export class Server {
 						}),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
 					reroute: module.reroute || noop
-				};
+				});
 
 				init_transport(module.transport ?? {});
 
@@ -163,14 +165,14 @@ export class Server {
 				}
 			} catch (e) {
 				if (__SVELTEKIT_DEV__) {
-					this.#options.hooks = {
+					set_hooks({
 						handle: () => {
 							throw e;
 						},
 						handleError: ({ error }) => console.error(error),
 						handleFetch: ({ request, fetch }) => fetch(request),
 						reroute: noop
-					};
+					});
 				} else {
 					throw e;
 				}
@@ -183,18 +185,19 @@ export class Server {
 	 * @param {import('types').InternalRequestOptions} options
 	 */
 	async respond(request, options) {
-		const response = await respond(
-			request,
-			this.#options,
-			this.#manifest,
-			create_request_state(options)
-		);
+		const request_state = create_request_state(options);
+
+		const response = await respond(request, this.#manifest, request_state);
 
 		if (DEV) {
 			const error = decoded_responses.get(response);
 			if (error) console.error(fix_stack_trace(error));
 		}
 
+		if (request_state.rerouted_url) {
+			response.headers.set(REROUTED_URL_HEADER, request_state.rerouted_url);
+		}
+
 		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -1,4 +1,5 @@
 /** @import { SSRManifest } from '@sveltejs/kit'; */
+/** @import { ServerHooks, SSROptions } from 'types'; */
 import { restore, save } from './dev.js';
 import {
 	has_data_suffix,
@@ -16,6 +17,8 @@ const styleText =
 
 const read_implementation_key = Symbol.for('sveltekit.read_implementation');
 const manifest_key = Symbol.for('sveltekit.manifest');
+const options_key = Symbol.for('sveltekit.options');
+const hooks_key = Symbol.for('sveltekit.hooks');
 
 export let read_implementation = /** @type {((path: string) => ReadableStream<any>) | null} */ (
 	(__SVELTEKIT_DEV__ && restore(read_implementation_key)) ?? null
@@ -25,6 +28,12 @@ export let manifest = /** @type {SSRManifest} */ (
 	(__SVELTEKIT_DEV__ && restore(manifest_key)) ?? null
 );
 
+export let options = /** @type {SSROptions} */ (
+	(__SVELTEKIT_DEV__ && restore(options_key)) ?? null
+);
+
+export let hooks = /** @type {ServerHooks} */ ((__SVELTEKIT_DEV__ && restore(hooks_key)) ?? null);
+
 /**
  * @param {(path: string) => ReadableStream<any>} fn
  */
@@ -42,11 +51,28 @@ export function set_manifest(value) {
 	if (__SVELTEKIT_DEV__) save(manifest_key, value);
 }
 
+/**
+ * @param {SSROptions} value
+ */
+export function set_options(value) {
+	options = value;
+	if (__SVELTEKIT_DEV__) save(options_key, value);
+}
+
+/**
+ * @param {ServerHooks} value
+ */
+export function set_hooks(value) {
+	hooks = value;
+	if (__SVELTEKIT_DEV__) save(hooks_key, value);
+}
+
 /**
  * @param {number} status
  * @param {Request} request
+ * @returns {string}
  */
-export function log_response(status, request) {
+export function format_response(status, request) {
 	const url = new URL(request.url);
 	const requested = url.href.replace(url.origin, '');
 
@@ -59,13 +85,17 @@ export function log_response(status, request) {
 		const pathname = strip_resolution_suffix(url.pathname) || '/';
 		log += pathname + styleText('dim', requested.slice(pathname.length));
 	} else if (has_remote_prefix(url)) {
-		const id = /** @type {string} */ (strip_remote_prefix(url).split('/').pop());
-		log += styleText('dim', url.pathname.slice(0, -id.length)) + id + styleText('dim', url.search);
+		const id = /** @type {string} */ (strip_remote_prefix(url));
+		const [file_hash, name, arg_hash] = id.split('/');
+
+		log += styleText('dim', `${url.pathname.slice(0, -id.length)}${file_hash}/`) + name;
+		if (arg_hash) log += styleText('dim', `/${arg_hash}`);
+		if (url.search) log += styleText('dim', url.search);
 	} else {
 		log += requested;
 	}
 
-	console.log(log);
+	return log;
 }
 
 export { fix_stack_trace, set_fix_stack_trace } from './sourcemaps.js';

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

@@ -1,6 +1,6 @@
 /** @import { RequestEvent, Actions } from '@sveltejs/kit' */
 /** @import { ActionResult } from '$app/forms' */
-/** @import { SSROptions, SSRNode, ServerNode, ServerActionResult } from 'types' */
+/** @import { SSRNode, ServerNode, ServerActionResult } from 'types' */
 import { DEV } from 'esm-env';
 import { HttpError, Redirect, ActionFailure, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing, record_span } from '@sveltejs/kit/internal/server';
@@ -23,28 +23,26 @@ export function is_action_json_request(event) {
 /**
  * @param {RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {SSROptions} options
  * @param {SSRNode['server'] | undefined} server
  */
-export async function handle_action_json_request(event, state, options, server) {
+export async function handle_action_json_request(event, state, server) {
 	const result = await handle_action_request(event, state, server);
-	return action_result_json(event, state, options, result);
+	return action_result_json(event, state, result);
 }
 
 /**
  * @param {RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {SSROptions} options
  * @param {ServerActionResult} result
  * @returns {Promise<Response>}
  */
-async function action_result_json(event, state, options, result) {
+async function action_result_json(event, state, result) {
 	if (result.type === 'redirect') {
 		return action_json(result);
 	}
 
 	if (result.type === 'error') {
-		const error = await handle_error_and_jsonify(event, state, options, result.error);
+		const error = await handle_error_and_jsonify(event, state, result.error);
 		return action_json({ ...result, error }, { status: error.status });
 	}
 
@@ -64,7 +62,7 @@ async function action_result_json(event, state, options, result) {
 			{ status: result.status }
 		);
 	} catch (e) {
-		return action_result_json(event, state, options, action_error_result(e, result.location));
+		return action_result_json(event, state, action_error_result(e, result.location));
 	}
 }
 

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

@@ -1,7 +1,7 @@
 import * as devalue from 'devalue';
 import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
-import { clarify_devalue_error, get_global_name, serialize_uses } from '../utils.js';
+import { clarify_devalue_error, serialize_uses } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import { encoders } from '#app/internal/transport';
 
@@ -10,15 +10,14 @@ import { encoders } from '#app/internal/transport';
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializer}
  */
-export function server_data_serializer(event, state, options) {
+export function server_data_serializer(event, state) {
 	let promise_id = 1;
 	let max_nodes = -1;
 
 	const iterator = create_async_iterator();
-	const global = get_global_name(options);
+	const global = __SVELTEKIT_GLOBAL_NAME__;
 
 	/** @param {number} index */
 	function get_replacer(index) {
@@ -31,7 +30,7 @@ export function server_data_serializer(event, state, options) {
 					.then(/** @param {any} data */ (data) => ({ data }))
 					.catch(
 						/** @param {any} error */ async (error) => ({
-							error: await handle_error_and_jsonify(event, state, options, error)
+							error: await handle_error_and_jsonify(event, state, error)
 						})
 					)
 					.then(
@@ -46,7 +45,6 @@ export function server_data_serializer(event, state, options) {
 								error = await handle_error_and_jsonify(
 									event,
 									state,
-									options,
 									new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
 										cause: e
 									})
@@ -127,10 +125,9 @@ export function server_data_serializer(event, state, options) {
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializerJson}
  */
-export function server_data_serializer_json(event, state, options) {
+export function server_data_serializer_json(event, state) {
 	let promise_id = 1;
 
 	const iterator = create_async_iterator();
@@ -152,7 +149,7 @@ export function server_data_serializer_json(event, state, options) {
 				.catch(
 					/** @param {any} e */ async (e) => {
 						key = 'error';
-						return handle_error_and_jsonify(event, state, options, /** @type {any} */ (e));
+						return handle_error_and_jsonify(event, state, /** @type {any} */ (e));
 					}
 				)
 				.then(
@@ -165,7 +162,6 @@ export function server_data_serializer_json(event, state, options) {
 							const error = await handle_error_and_jsonify(
 								event,
 								state,
-								options,
 								new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
 									cause: e
 								})

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

@@ -1,5 +1,5 @@
 /** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
-/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode, SSROptions } from 'types' */
+/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode } from 'types' */
 import { text } from '@sveltejs/kit';
 import { Redirect } from '@sveltejs/kit/internal';
 import { compact } from '../../../utils/array.js';
@@ -32,13 +32,12 @@ const MAX_DEPTH = 10;
  * @param {RequestEvent} event
  * @param {RequestState} state
  * @param {PageNodeIndexes} page
- * @param {SSROptions} options
  * @param {SSRManifest} manifest
  * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, state, page, options, manifest, nodes, resolve_opts) {
+export async function render_page(event, state, page, manifest, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -48,7 +47,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 
 	if (is_action_json_request(event)) {
 		const node = await manifest._.nodes[page.leaf]();
-		return handle_action_json_request(event, state, options, node?.server);
+		return handle_action_json_request(event, state, node?.server);
 	}
 
 	try {
@@ -150,10 +149,9 @@ export async function render_page(event, state, page, options, manifest, nodes,
 				error: null,
 				event,
 				state,
-				options,
 				manifest,
 				resolve_opts,
-				data_serializer: server_data_serializer(event, state, options)
+				data_serializer: server_data_serializer(event, state)
 			});
 		}
 
@@ -163,10 +161,10 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		/** @type {Error | null} */
 		let load_error = null;
 
-		const data_serializer = server_data_serializer(event, state, options);
+		const data_serializer = server_data_serializer(event, state);
 		const data_serializer_json =
 			(state.prerendering || state.prerender_default === true) && should_prerender_data
-				? server_data_serializer_json(event, state, options)
+				? server_data_serializer_json(event, state)
 				: null;
 
 		/** @type {Array<Promise<ServerDataNode | null>>} */
@@ -274,7 +272,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 						return redirect_response(err.status, err.location);
 					}
 
-					const error = await handle_error_and_jsonify(event, state, options, err);
+					const error = await handle_error_and_jsonify(event, state, err);
 					const status = error.status;
 
 					for (const { error: index, idx } of nearest_error_pages(i, branch, page.errors)) {
@@ -293,7 +291,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 						return await render_response({
 							event,
 							state,
-							options,
 							manifest,
 							resolve_opts,
 							page_config: {
@@ -311,7 +308,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 
 					// if we're still here, it means the error happened in the root layout,
 					// which means we have to fall back to error.html
-					return static_error_page(options, status, error.message);
+					return static_error_page(status, error.message);
 				}
 			} else {
 				// push an empty slot so we can rewind past gaps to the
@@ -339,7 +336,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		return await render_response({
 			event,
 			state,
-			options,
 			manifest,
 			resolve_opts,
 			page_config: {
@@ -351,7 +347,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 			branch: compact(branch),
 			action_result,
 			fetched,
-			data_serializer: !ssr ? server_data_serializer(event, state, options) : data_serializer,
+			data_serializer: !ssr ? server_data_serializer(event, state) : data_serializer,
 			error_components: await load_error_components(ssr, branch, page, manifest)
 		});
 	} catch (e) {
@@ -365,7 +361,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		return await respond_with_error({
 			event,
 			state,
-			options,
 			manifest,
 			error: e,
 			resolve_opts

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

@@ -18,8 +18,8 @@ import {
 	route_id_resolution_pathname
 } 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, get_global_name } from '../utils.js';
+import { stream_text } from '../../utils.js';
+import { count_non_ssi_comments } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import * as env from '<sveltekit:generated>/env/config.js';
 import { collect_remote_data } from '../remote-functions.js';
@@ -27,6 +27,7 @@ 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';
+import { options } from '../internal.js';
 
 // TODO rename this function/module
 
@@ -35,7 +36,6 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
  * @param {{
  *   branch: Array<import('./types.js').Loaded>;
  *   fetched: Array<import('./types.js').Fetched>;
- *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   page_config: { ssr: boolean; csr: boolean };
  *   status: number;
@@ -51,7 +51,6 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
 export async function render_response({
 	branch,
 	fetched,
-	options,
 	manifest,
 	page_config,
 	status,
@@ -134,7 +133,7 @@ export async function render_response({
 			if (!paths.assets || (paths.assets[0] === '/' && paths.assets !== SVELTE_KIT_ASSETS)) {
 				assets = base;
 			}
-		} else if (options.hash_routing) {
+		} else if (__SVELTEKIT_HASH_ROUTING__) {
 			// we have to assume that we're in the right place
 			base_expression = "new URL('.', location).pathname.slice(0, -1)";
 		}
@@ -203,7 +202,7 @@ export async function render_response({
 							throw e;
 						}
 
-						const handled = handle_error_and_jsonify(event, render_state, options, e);
+						const handled = handle_error_and_jsonify(event, render_state, e);
 
 						// TODO 4.0 make this an async function and await `handled`
 						if (handled instanceof Promise) {
@@ -312,7 +311,10 @@ export async function render_response({
 	 * @param {string[]} attributes
 	 */
 	const add_preload = (path, attributes) => {
-		if (options.link_header_preload && !(state.prerendering || state.prerender_default === true)) {
+		if (
+			__SVELTEKIT_LINK_HEADER_PRELOAD__ &&
+			!(state.prerendering || state.prerender_default === true)
+		) {
 			link_headers.add(`<${encodeURI(path)}>; ${attributes.join('; ')}; nopush`);
 		} else {
 			head.add_link_tag(path, attributes);
@@ -329,7 +331,7 @@ export async function render_response({
 			// include them in disabled state so that Vite can detect them and doesn't try to add them
 			attributes.push('disabled', 'media="(max-width: 0)"');
 		} else {
-			if (options.link_header_preload && resolve_opts.preload({ type: 'css', path })) {
+			if (__SVELTEKIT_LINK_HEADER_PRELOAD__ && resolve_opts.preload({ type: 'css', path })) {
 				link_headers.add(`<${encodeURI(path)}>; rel="preload"; as="style"; nopush`);
 			}
 		}
@@ -347,7 +349,7 @@ export async function render_response({
 		}
 	}
 
-	const global = get_global_name(options);
+	const global = __SVELTEKIT_GLOBAL_NAME__;
 	const { data, chunks } = data_serializer.get_data(csp);
 
 	if (page_config.ssr && page_config.csr) {
@@ -509,7 +511,7 @@ export async function render_response({
 					); // make output after it's put together with the rest more readable
 					hydrate.push(`params: ${devalue.uneval(event.params)}`, `server_route: ${stringified}`);
 				}
-			} else if (options.embedded) {
+			} else if (__SVELTEKIT_EMBEDDED__) {
 				hydrate.push(`params: ${devalue.uneval(event.params)}`, `route: ${s(event.route)}`);
 			}
 
@@ -517,7 +519,7 @@ 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, state, options);
+		const remote_data = await collect_remote_data({}, event, state);
 
 		const serialized_data =
 			Object.keys(remote_data).length > 0
@@ -549,7 +551,7 @@ export async function render_response({
 			blocks.push(boot);
 		}
 
-		if (options.service_worker) {
+		if (__SVELTEKIT_SERVICE_WORKER__) {
 			let opts = ", { type: 'module' }";
 			if (options.service_worker_options != null) {
 				const service_worker_options = { ...options.service_worker_options, type: 'module' };
@@ -610,7 +612,7 @@ export async function render_response({
 			headers.set('content-security-policy-report-only', report_only_header);
 		}
 
-		if (options.link_header_preload && link_headers.size) {
+		if (__SVELTEKIT_LINK_HEADER_PRELOAD__ && link_headers.size) {
 			headers.set('link', Array.from(link_headers).join(', '));
 		}
 	}
@@ -657,22 +659,7 @@ export async function render_response({
 				status,
 				headers
 			})
-		: new Response(
-				new ReadableStream({
-					async start(controller) {
-						controller.enqueue(text_encoder.encode(transformed + '\n'));
-						for await (const chunk of chunks) {
-							if (chunk.length) controller.enqueue(text_encoder.encode(chunk));
-						}
-						controller.close();
-					},
-
-					type: 'bytes'
-				}),
-				{
-					headers
-				}
-			);
+		: new Response(stream_text(transformed + '\n', chunks), { headers });
 }
 
 class Head {

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

@@ -14,17 +14,16 @@ import { server_data_serializer } from './data_serializer.js';
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
  *   state: import('types').RequestState;
- *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({ event, state, options, manifest, error, resolve_opts }) {
+export async function respond_with_error({ event, state, 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, state, options, error);
-		return static_error_page(options, transformed.status, transformed.message);
+		const transformed = await handle_error_and_jsonify(event, state, error);
+		return static_error_page(transformed.status, transformed.message);
 	}
 
 	/** @type {import('./types.js').Fetched[]} */
@@ -35,9 +34,9 @@ export async function respond_with_error({ event, state, options, manifest, erro
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
-		const data_serializer = server_data_serializer(event, state, options);
+		const data_serializer = server_data_serializer(event, state);
 		// Do this here first in case the awaits below before rendering themselves error
-		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, error);
 
 		if (ssr) {
 			state.error = true;
@@ -80,7 +79,6 @@ export async function respond_with_error({ event, state, options, manifest, erro
 		}
 
 		return await render_response({
-			options,
 			manifest,
 			page_config: {
 				ssr,
@@ -103,8 +101,8 @@ export async function respond_with_error({ event, state, options, manifest, erro
 			return redirect_response(e.status, e.location);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, state, options, e);
+		const transformed = await handle_error_and_jsonify(event, state, e);
 
-		return static_error_page(options, transformed.status, transformed.message);
+		return static_error_page(transformed.status, transformed.message);
 	}
 }