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

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

@@ -6,28 +6,19 @@ import { server_data_serializer_json } from '../page/data_serializer.js';
 import { load_server_data } from '../page/load_data.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import { normalize_path } from '../../../utils/url.js';
-import { text_encoder } from '../../utils.js';
+import { stream_text } from '../../utils.js';
 import { with_version_header } from '../utils.js';
+import { manifest } from '../internal.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
  * @param {{ page: Pick<import('types').PageNodeIndexes, 'layouts' | 'leaf'> | null }} route
- * @param {import('types').SSROptions} options
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {boolean[] | undefined} invalidated_data_nodes
  * @param {import('types').TrailingSlash} trailing_slash
  * @returns {Promise<Response>}
  */
-export async function render_data(
-	event,
-	state,
-	route,
-	options,
-	manifest,
-	invalidated_data_nodes,
-	trailing_slash
-) {
+export async function render_data(event, state, route, invalidated_data_nodes, trailing_slash) {
 	if (!route.page) {
 		// requesting /__data.json should fail for a +server.js
 		return with_version_header(new Response(undefined, { status: 404 }));
@@ -54,7 +45,7 @@ export async function render_data(
 					}
 
 					// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
-					const node = n == undefined ? n : await manifest._.nodes[n]();
+					const node = n == undefined ? n : await manifest.nodes[n]();
 					// load this. for the child, return as is. for the final result, stream things
 					return load_server_data({
 						event: new_event,
@@ -92,7 +83,7 @@ export async function render_data(
 			return fn();
 		});
 
-		const data_serializer = server_data_serializer_json(event, state, options);
+		const data_serializer = server_data_serializer_json(event, state);
 		await Promise.all(
 			promises.map(async (p, i) => {
 				const node = await p.catch(async (error) => {
@@ -100,7 +91,7 @@ export async function render_data(
 						throw error;
 					}
 
-					const transformed = await handle_error_and_jsonify(event, state, options, error);
+					const transformed = await handle_error_and_jsonify(event, state, error);
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
@@ -120,27 +111,14 @@ export async function render_data(
 		}
 
 		return with_version_header(
-			new Response(
-				new ReadableStream({
-					async start(controller) {
-						controller.enqueue(text_encoder.encode(data));
-						for await (const chunk of chunks) {
-							controller.enqueue(text_encoder.encode(chunk));
-						}
-						controller.close();
-					},
-
-					type: 'bytes'
-				}),
-				{
-					headers: {
-						// we use a proprietary content type to prevent buffering.
-						// the `text` prefix makes it inspectable
-						'content-type': 'text/sveltekit-data',
-						'cache-control': 'private, no-store'
-					}
+			new Response(stream_text(data, chunks), {
+				headers: {
+					// we use a proprietary content type to prevent buffering.
+					// the `text` prefix makes it inspectable
+					'content-type': 'text/sveltekit-data',
+					'cache-control': 'private, no-store'
 				}
-			)
+			})
 		);
 	} catch (e) {
 		const error = normalize_error(e);
@@ -148,7 +126,7 @@ export async function render_data(
 		if (error instanceof Redirect) {
 			return redirect_json_response(error);
 		} else {
-			const transformed = await handle_error_and_jsonify(event, state, options, error);
+			const transformed = await handle_error_and_jsonify(event, state, error);
 			return json_response(transformed, transformed.status);
 		}
 	}

package/src/runtime/server/errors.js

@@ -8,17 +8,16 @@ import {
 import { with_request_store } from '@sveltejs/kit/internal/server';
 import { add_deprecated_handle_error_properties, coalesce_to_error } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
-import { fix_stack_trace } from './internal.js';
+import { fix_stack_trace, hooks, options } from './internal.js';
 import { escape_html } from '../../utils/escape.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @param {unknown} error
  */
-export async function handle_fatal_error(event, state, options, error) {
-	const body = await handle_error_and_jsonify(event, state, options, error);
+export async function handle_fatal_error(event, state, error) {
+	const body = await handle_error_and_jsonify(event, state, error);
 	const status = body.status;
 
 	// sec-fetch-dest would be nicer, but non-browser clients and plain HTTP hosts don't send it
@@ -33,17 +32,16 @@ export async function handle_fatal_error(event, state, options, error) {
 		});
 	}
 
-	return static_error_page(options, status, body.message);
+	return static_error_page(status, body.message);
 }
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @param {any} error
  * @returns {App.Error | Promise<App.Error>}
  */
-export function handle_error_and_jsonify(event, state, options, error) {
+export function handle_error_and_jsonify(event, state, error) {
 	if (error instanceof HandledHttpError) {
 		return error.body;
 	}
@@ -90,7 +88,7 @@ export function handle_error_and_jsonify(event, state, options, error) {
 		const input = { ...caught, event };
 		if (__SVELTEKIT_DEV__) add_deprecated_handle_error_properties(input, fallback);
 
-		result = with_request_store({ event, state }, () => options.hooks.handleError(input));
+		result = with_request_store({ event, state }, () => hooks.handleError(input));
 	} catch (hook_error) {
 		log_handle_error_hook_failure(error, hook_error);
 		return { status: fallback.status, message: 'Internal Error' };
@@ -141,11 +139,10 @@ function log_handle_error_hook_failure(error, hook_error) {
 /**
  * Return as a response that renders the error.html
  *
- * @param {import('types').SSROptions} options
  * @param {number} status
  * @param {string} message
  */
-export function static_error_page(options, status, message) {
+export function static_error_page(status, message) {
 	let page = options.templates.error({ status, message: escape_html(message) });
 
 	if (__SVELTEKIT_DEV__) {

package/src/runtime/server/fetch.js

@@ -2,22 +2,20 @@ import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
 import { respond } from './respond.js';
 import * as paths from '#app/paths';
-import { read_implementation } from './internal.js';
+import { hooks, manifest, read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
 import { fork_state_for_subrequest } from './state.js';
 
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
- *   options: import('types').SSROptions;
- *   manifest: import('@sveltejs/kit').SSRManifest;
  *   state: import('types').RequestState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
  *   set_internal: (name: string, value: string, opts: import('./page/types.js').Cookie['options']) => void;
  * }} opts
  * @returns {typeof fetch}
  */
-export function create_fetch({ event, options, manifest, state, get_cookie_header, set_internal }) {
+export function create_fetch({ event, state, get_cookie_header, set_internal }) {
 	/**
 	 * @type {typeof fetch}
 	 */
@@ -30,7 +28,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 		let credentials =
 			(info instanceof Request ? info.credentials : init?.credentials) ?? 'same-origin';
 
-		return options.hooks.handleFetch({
+		return hooks.handleFetch({
 			event,
 			request: original_request,
 			fetch: async (info, init) => {
@@ -88,24 +86,24 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 				).slice(1);
 				const filename_html = `${filename}/index.html`; // path may also match path/index.html
 
-				const is_asset = manifest.assets.has(filename) || filename in manifest._.server_assets;
+				const is_asset = manifest.assets.has(filename) || filename in manifest.server_assets;
 				const is_asset_html =
-					manifest.assets.has(filename_html) || filename_html in manifest._.server_assets;
+					manifest.assets.has(filename_html) || filename_html in manifest.server_assets;
 
 				if (is_asset || is_asset_html) {
 					const file = is_asset ? filename : filename_html;
 
 					if (state.read) {
 						const type = is_asset
-							? manifest.mimeTypes[filename.slice(filename.lastIndexOf('.'))]
+							? manifest.mime_types[filename.slice(filename.lastIndexOf('.'))]
 							: 'text/html';
 
 						return new Response(state.read(file), {
 							headers: type ? { 'content-type': type } : {}
 						});
-					} else if (read_implementation && file in manifest._.server_assets) {
-						const length = manifest._.server_assets[file];
-						const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+					} else if (read_implementation && file in manifest.server_assets) {
+						const length = manifest.server_assets[file];
+						const type = manifest.mime_types[file.slice(file.lastIndexOf('.'))];
 
 						return new Response(read_implementation(file), {
 							headers: {
@@ -118,7 +116,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					return await fetch(request);
 				}
 
-				if (has_prerendered_path(manifest, decoded)) {
+				if (has_prerendered_path(decoded)) {
 					// The path of something prerendered could match a different route
 					// that is still in the manifest, leading to the wrong route being loaded.
 					// We therefore bail early here. The prerendered logic is different for
@@ -148,18 +146,19 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					request.headers.set('accept-language', accept_language);
 				}
 
-				const response = await internal_fetch(request, options, manifest, state);
+				const response = await internal_fetch(request, state);
 
 				for (const str of response.headers.getSetCookie()) {
-					const { name, value, ...options } = parseSetCookie(str, { decode: (v) => v });
+					const { name, value, ...cookie_options } = parseSetCookie(str, { decode: (v) => v });
 
-					const path = options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
+					const path =
+						cookie_options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
 
-					// options.sameSite is string, something more specific is required - type cast is safe
+					// sameSite is string, something more specific is required - type cast is safe
 					set_internal(name, /** @type {string} */ (value), {
 						path,
 						encode: (value) => value,
-						.../** @type {import('cookie').SerializeOptions} */ (options)
+						.../** @type {import('cookie').SerializeOptions} */ (cookie_options)
 					});
 				}
 
@@ -193,12 +192,10 @@ function normalize_fetch_input(info, init, url) {
 
 /**
  * @param {Request} request
- * @param {import('types').SSROptions} options
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-async function internal_fetch(request, options, manifest, state) {
+async function internal_fetch(request, state) {
 	if (request.signal?.aborted) {
 		throw new DOMException('The operation was aborted.', 'AbortError');
 	}
@@ -206,7 +203,7 @@ async function internal_fetch(request, options, manifest, state) {
 	const subrequest_state = fork_state_for_subrequest(state);
 
 	if (!request.signal) {
-		return await respond(request, options, manifest, subrequest_state);
+		return await respond(request, subrequest_state);
 	}
 
 	let remove_abort_listener = noop;
@@ -219,8 +216,7 @@ async function internal_fetch(request, options, manifest, state) {
 		remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
 	});
 
-	return Promise.race([
-		respond(request, options, manifest, subrequest_state),
-		abort_promise
-	]).finally(remove_abort_listener);
+	return Promise.race([respond(request, subrequest_state), abort_promise]).finally(
+		remove_abort_listener
+	);
 }

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,18 +58,8 @@ if (DEV) {
 }
 
 export class Server {
-	/** @type {import('types').SSROptions} */
-	#options;
-
-	/** @type {import('@sveltejs/kit').SSRManifest} */
-	#manifest;
-
-	/** @param {import('@sveltejs/kit').SSRManifest} manifest */
+	/** @param {import('types').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`
 		// in `src/exports/internal/server/event.js` and handle only one request at a time.
 		if (IN_WEBCONTAINER) {
@@ -105,14 +105,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 +122,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 +151,7 @@ export class Server {
 						}),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
 					reroute: module.reroute || noop
-				};
+				});
 
 				init_transport(module.transport ?? {});
 
@@ -163,14 +160,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 +180,25 @@ 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, 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);
+		}
+
+		// the HTTP layer discards HEAD response bodies, but nothing does when the server is called directly
+		if (request.method === 'HEAD' && response.body !== null) {
+			response.body.cancel().catch(noop);
+			return new Response(null, response);
+		}
+
 		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -1,4 +1,4 @@
-/** @import { SSRManifest } from '@sveltejs/kit'; */
+/** @import { ServerHooks, SSROptions, SSRManifest } from 'types'; */
 import { restore, save } from './dev.js';
 import {
 	has_data_suffix,
@@ -16,6 +16,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 +27,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 +50,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 +84,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
 								})