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

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 { RequestEvent } from '@sveltejs/kit' */
+/** @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';
@@ -8,6 +8,7 @@ import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
 import { build_error_chain, nearest_error_pages } from '../../error-chain.js';
 import { redirect_response } from '../utils.js';
+import { manifest } from '../internal.js';
 import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
 	handle_action_json_request,
@@ -32,13 +33,11 @@ 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, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -47,8 +46,8 @@ 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);
+		const node = await manifest.nodes[page.leaf]();
+		return handle_action_json_request(event, state, node?.server);
 	}
 
 	try {
@@ -62,7 +61,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		if (is_action_request(event)) {
 			const remote_id = get_remote_action(event.url);
 			if (remote_id) {
-				action_result = await handle_remote_form_post(event, state, manifest, remote_id);
+				action_result = await handle_remote_form_post(event, state, remote_id);
 			} else {
 				// for action requests, first call handler in +page.server.js
 				// (this also determines status code)
@@ -150,10 +149,8 @@ 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 +160,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,11 +271,11 @@ 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)) {
-						const node = await manifest._.nodes[index]();
+						const node = await manifest.nodes[index]();
 
 						data_serializer.set_max_nodes(idx);
 
@@ -293,8 +290,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 						return await render_response({
 							event,
 							state,
-							options,
-							manifest,
 							resolve_opts,
 							page_config: {
 								ssr: nodes.ssr(),
@@ -302,7 +297,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 							},
 							status,
 							error,
-							error_components: await load_error_components(ssr, error_branch, page, manifest),
+							error_components: await load_error_components(ssr, error_branch, page),
 							branch: error_branch,
 							fetched,
 							data_serializer
@@ -311,7 +306,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,8 +334,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		return await render_response({
 			event,
 			state,
-			options,
-			manifest,
 			resolve_opts,
 			page_config: {
 				csr,
@@ -351,8 +344,8 @@ 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,
-			error_components: await load_error_components(ssr, branch, page, manifest)
+			data_serializer: !ssr ? server_data_serializer(event, state) : data_serializer,
+			error_components: await load_error_components(ssr, branch, page)
 		});
 	} catch (e) {
 		// a remote function could have thrown a redirect during render
@@ -365,8 +358,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
 		});
@@ -377,12 +368,11 @@ export async function render_page(event, state, page, options, manifest, nodes,
  * @param {boolean} ssr
  * @param {Array<import('./types.js').Loaded | null>} branch
  * @param {PageNodeIndexes} page
- * @param {SSRManifest} manifest
  */
-function load_error_components(ssr, branch, page, manifest) {
+function load_error_components(ssr, branch, page) {
 	if (!ssr) return undefined;
 
 	return build_error_chain(branch, page.errors, (idx) =>
-		manifest._.nodes[idx]?.().then((e) => e.component?.())
+		manifest.nodes[idx]?.().then((e) => e.component?.())
 	);
 }

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

@@ -1,7 +1,7 @@
 import { DEV } from 'esm-env';
 import { noop } from '../../../utils/functions.js';
 import { disable_search, make_trackable } from '../../../utils/url.js';
-import { validate_depends, validate_load_response } from '../../shared.js';
+import { fetch_cache_url, validate_depends, validate_load_response } from '../../shared.js';
 import { with_request_store, merge_tracing, record_span } from '@sveltejs/kit/internal/server';
 import { base64_encode } from '../../utils.js';
 import { NULL_BODY_STATUS } from '../constants.js';
@@ -344,7 +344,7 @@ export function create_universal_fetch(event, prerendering, fetched, csr, resolv
 					}
 
 					fetched.push({
-						url: same_origin ? url.href.slice(event.url.origin.length) : url.href,
+						url: fetch_cache_url(url, event.url),
 						method: event.request.method,
 						request_body: /** @type {string | ArrayBufferView | null | undefined} */ (request_body),
 						request_headers: cloned_headers,

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

@@ -1,4 +1,5 @@
 /** @import { Component } from 'svelte'; */
+/** @import { SyncRenderOutput } from 'svelte/server' */
 import * as devalue from 'devalue';
 import { DEV } from 'esm-env';
 import { isRedirect, text } from '@sveltejs/kit';
@@ -18,8 +19,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 +28,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 { manifest, options } from '../internal.js';
 
 // TODO rename this function/module
 
@@ -35,8 +37,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;
  *   error: App.Error | null;
@@ -51,8 +51,6 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
 export async function render_response({
 	branch,
 	fetched,
-	options,
-	manifest,
 	page_config,
 	status,
 	error = null,
@@ -73,7 +71,7 @@ export async function render_response({
 		}
 	}
 
-	const { client } = manifest._;
+	const client = manifest.client;
 
 	const modulepreloads = new Set(client?.imports);
 	const stylesheets = new Set(client?.stylesheets);
@@ -91,8 +89,7 @@ export async function render_response({
 	// TODO if we add a client entry point one day, we will need to include inline_styles with the entry, otherwise stylesheets will be linked even if they are below inlineStyleThreshold
 	const inline_styles = new Map();
 
-	// TODO `svelte/server` should expose `RenderOutput`
-	/** @type {Omit<Awaited<ReturnType<typeof render>>, 'html'>} */
+	/** @type {Omit<SyncRenderOutput, 'html'>} */
 	let rendered;
 
 	const form_value =
@@ -134,7 +131,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 +200,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) {
@@ -287,7 +284,7 @@ export async function render_response({
 			// Vite makes the start script available through the base path and without it.
 			// We load it via the base path in order to support remote IDE environments which proxy
 			// all URLs under the base path during development.
-			return paths.base + path;
+			return relative ? `${base}/${path.slice(1)}` : paths.base + path;
 		}
 		return `${assets}/${path}`;
 	};
@@ -312,7 +309,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 +329,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 +347,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 +509,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 +517,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 +549,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 +610,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(', '));
 		}
 	}
@@ -652,27 +652,9 @@ export async function render_response({
 		}
 	}
 
-	return !chunks
-		? text(transformed, {
-				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
-				}
-			);
+	return chunks
+		? new Response(stream_text(transformed + '\n', chunks), { status, headers })
+		: text(transformed, { status, headers });
 }
 
 class Head {

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

@@ -5,6 +5,7 @@ import { redirect_response } from '../utils.js';
 import { handle_error_and_jsonify, static_error_page } from '../errors.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
+import { manifest } from '../internal.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -14,30 +15,28 @@ 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, 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[]} */
 	const fetched = [];
 	try {
 		const branch = [];
-		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
+		const default_layout = await manifest.nodes[0](); // 0 is always the root layout
 		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;
@@ -72,7 +71,7 @@ export async function respond_with_error({ event, state, options, manifest, erro
 					data
 				},
 				{
-					node: await manifest._.nodes[1](), // 1 is always the root error
+					node: await manifest.nodes[1](), // 1 is always the root error
 					data: null,
 					server_data: null
 				}
@@ -80,8 +79,6 @@ export async function respond_with_error({ event, state, options, manifest, erro
 		}
 
 		return await render_response({
-			options,
-			manifest,
 			page_config: {
 				ssr,
 				csr
@@ -103,8 +100,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);
 	}
 }

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

@@ -1,15 +1,16 @@
-/** @import { SSRManifest } from '@sveltejs/kit' */
+/** @import { SSRManifest } from 'types' */
 import { base, assets } from '#app/paths';
 import { relative } from '$app/paths/internal/server';
 import { text } from '@sveltejs/kit';
 import { s } from '../../../utils/misc.js';
 import { find_route } from '../../../utils/routing.js';
 import { get_relative_path } from '../../utils.js';
+import { manifest } from '../internal.js';
 
 /**
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {string}
  */
 export function generate_route_object(route, url, client) {
@@ -38,23 +39,18 @@ export function generate_route_object(route, url, client) {
 function create_client_import(import_path, url) {
 	if (!import_path) return 'Promise.resolve({})';
 
-	// During DEV, Vite will make the paths absolute (e.g. /@fs/...)
-	if (import_path[0] === '/') {
-		return `import('${import_path}')`;
-	}
-
 	// During PROD, they're root-relative
-	if (assets !== '') {
+	if (assets !== '' && import_path[0] !== '/') {
 		return `import('${assets}/${import_path}')`;
 	}
 
-	if (!relative) {
-		return `import('${base}/${import_path}')`;
-	}
+	// During DEV, Vite will make the paths absolute (e.g. /@fs/...)
+	const absolute = import_path[0] === '/' ? import_path : `${base}/${import_path}`;
+	if (!relative) return `import('${absolute}')`;
 
 	// Else we make them relative to the server-side route resolution request
 	// to support IPFS, the internet archive, etc.
-	let path = get_relative_path(url.pathname, `${base}/${import_path}`);
+	let path = get_relative_path(url.pathname, absolute);
 	if (path[0] !== '.') path = `./${path}`;
 	return `import('${path}')`;
 }
@@ -62,23 +58,22 @@ function create_client_import(import_path, url) {
 /**
  * @param {string} resolved_path
  * @param {URL} url
- * @param {SSRManifest} manifest
  * @returns {Promise<Response>}
  */
-export async function resolve_route(resolved_path, url, manifest) {
-	if (!manifest._.client?.routes) {
+export async function resolve_route(resolved_path, url) {
+	if (!manifest.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
 	try {
-		const matchers = await manifest._.matchers();
-		const result = find_route(resolved_path, manifest._.client.routes, matchers);
+		const matchers = await manifest.matchers();
+		const result = find_route(resolved_path, manifest.client.routes, matchers);
 
 		return create_server_routing_response(
 			result?.route ?? null,
 			result?.params ?? {},
 			url,
-			manifest._.client
+			manifest.client
 		).response;
 	} catch {
 		return text('Error resolving route', { status: 500 });
@@ -99,29 +94,28 @@ export async function resolve_route(resolved_path, url, manifest) {
  *
  * @param {string} route_id
  * @param {URL} url
- * @param {SSRManifest} manifest
  * @returns {Response}
  */
-export function resolve_route_by_id(route_id, url, manifest) {
-	if (!manifest._.client?.routes) {
+export function resolve_route_by_id(route_id, url) {
+	if (!manifest.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
 	try {
-		const route = manifest._.client.routes.find((r) => r.id === route_id);
+		const route = manifest.client.routes.find((r) => r.id === route_id);
 
 		if (route) {
-			return create_server_routing_response(route, null, url, manifest._.client).response;
+			return create_server_routing_response(route, null, url, manifest.client).response;
 		}
 
 		// `client.routes` only contains routes with a `+page`, so a miss above doesn't mean the
 		// route doesn't exist — it might be a `+server.js`-only route. `_.routes` includes those
 		// (with `page: null`), so we can distinguish "exists but has no code" from "unknown".
-		if (manifest._.routes.some((r) => r.id === route_id && !r.page)) {
+		if (manifest.routes.some((r) => r.id === route_id && !r.page)) {
 			return text('export const endpoint_only = true;', { headers: js_headers() });
 		}
 
-		return create_server_routing_response(null, null, url, manifest._.client).response;
+		return create_server_routing_response(null, null, url, manifest.client).response;
 	} catch {
 		return text('Error resolving route', { status: 500 });
 	}
@@ -137,7 +131,7 @@ function js_headers() {
  * @param {import('types').SSRClientRoute | null} route
  * @param {Partial<Record<string, string>> | null} params
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {{response: Response, body: string}}
  */
 export function create_server_routing_response(route, params, url, client) {
@@ -164,7 +158,7 @@ export function create_server_routing_response(route, params, url, client) {
  *
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {string}
  */
 function create_css_import(route, url, client) {