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

package/src/runtime/server/respond.js

@@ -45,6 +45,7 @@ import {
 } from '../pathname.js';
 import { server_data_serializer } from './page/data_serializer.js';
 import { get_remote_id, handle_remote_call } from './remote-functions.js';
+import { hooks, manifest, options } from './internal.js';
 
 /** @type {import('types').RequiredResolveOptions['transformPageChunk']} */
 const default_transform = ({ html }) => html;
@@ -85,12 +86,10 @@ export const respond = propagate_context(internal_respond);
 
 /**
  * @param {Request} request
- * @param {import('types').SSROptions} options
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-export async function internal_respond(request, options, manifest, state) {
+export async function internal_respond(request, state) {
 	/** URL but stripped from the potential `/__data.json` suffix and its search param  */
 	const url = new URL(request.url);
 
@@ -100,7 +99,7 @@ export async function internal_respond(request, options, manifest, state) {
 
 	if (!__SVELTEKIT_DEV__) {
 		const request_origin = request.headers.get('origin');
-		const self_origin = get_self_origin(options.paths_origin, url.origin);
+		const self_origin = get_self_origin(__SVELTEKIT_PATHS_ORIGIN__, url.origin);
 
 		if (remote_id) {
 			if (
@@ -113,7 +112,7 @@ export async function internal_respond(request, options, manifest, state) {
 				const message = 'Cross-site remote requests are forbidden';
 				return Response.json({ message }, { status: 403 });
 			}
-		} else if (options.csrf_check_origin) {
+		} else if (__SVELTEKIT_CSRF_CHECK_ORIGIN__) {
 			const forbidden = is_csrf_forbidden({
 				request,
 				request_origin,
@@ -134,7 +133,7 @@ export async function internal_respond(request, options, manifest, state) {
 		}
 	}
 
-	if (options.hash_routing && url.pathname !== base + '/' && url.pathname !== '/[fallback]') {
+	if (__SVELTEKIT_HASH_ROUTING__ && url.pathname !== base + '/' && url.pathname !== '/[fallback]') {
 		return text('Not found', { status: 404 });
 	}
 
@@ -243,8 +242,6 @@ export async function internal_respond(request, options, manifest, state) {
 	// @ts-expect-error this has to be assigned lazily
 	event.fetch = create_fetch({
 		event,
-		options,
-		manifest,
 		state,
 		get_cookie_header,
 		set_internal
@@ -263,7 +260,16 @@ export async function internal_respond(request, options, manifest, state) {
 
 			// reroute could alter the given URL, so we pass a copy
 			resolved_path =
-				(await options.hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
+				(await hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
+
+			if (!manifest.routes.length && resolved_path !== url.pathname) {
+				state.rerouted_url = denormalise_url({
+					request_url: request.url,
+					resolved_path,
+					is_data_request,
+					is_route_resolution_request
+				}).toString();
+			}
 		} catch {
 			return text('Internal Server Error', {
 				status: 500
@@ -298,14 +304,14 @@ export async function internal_respond(request, options, manifest, state) {
 		// the resolved path has been decoded so it should be compared to the decoded url pathname
 		resolved_path !== decode_pathname(url.pathname) &&
 		!state.prerendering?.fallback &&
-		has_prerendered_path(manifest, resolved_path)
+		has_prerendered_path(resolved_path)
 	) {
-		const url = new URL(request.url);
-		url.pathname = is_data_request
-			? add_data_suffix(resolved_path)
-			: is_route_resolution_request
-				? add_resolution_suffix(resolved_path)
-				: resolved_path;
+		const url = denormalise_url({
+			request_url: request.url,
+			resolved_path,
+			is_data_request,
+			is_route_resolution_request
+		});
 
 		try {
 			// `fetch` automatically decodes the body, so we need to delete the related headers to not break the response
@@ -323,7 +329,7 @@ export async function internal_respond(request, options, manifest, state) {
 				statusText: response.statusText
 			});
 		} catch (error) {
-			return await handle_fatal_error(event, state, options, error);
+			return await handle_fatal_error(event, state, error);
 		}
 	}
 
@@ -339,10 +345,10 @@ export async function internal_respond(request, options, manifest, state) {
 
 	if (is_route_resolution_request) {
 		if (is_route_id_resolution_request) {
-			return resolve_route_by_id(extract_route_id(resolved_path), new URL(request.url), manifest);
+			return resolve_route_by_id(extract_route_id(resolved_path), new URL(request.url));
 		}
 
-		return resolve_route(resolved_path, new URL(request.url), manifest);
+		return resolve_route(resolved_path, new URL(request.url));
 	}
 
 	if (resolved_path === `/${app_dir}/env.js`) {
@@ -358,8 +364,8 @@ export async function internal_respond(request, options, manifest, state) {
 
 	if (!state.prerendering?.fallback && !skip_route_resolution) {
 		try {
-			const matchers = await manifest._.matchers();
-			const result = find_route(resolved_path, manifest._.routes, matchers);
+			const matchers = await manifest.matchers();
+			const result = find_route(resolved_path, manifest.routes, matchers);
 
 			if (result) {
 				route = result.route;
@@ -369,14 +375,12 @@ export async function internal_respond(request, options, manifest, state) {
 				event.params = result.params;
 			}
 		} catch (e) {
-			return await handle_fatal_error(event, state, options, e);
+			return await handle_fatal_error(event, state, e);
 		}
 	}
 
 	try {
-		page_nodes = route?.page
-			? new PageNodes(await load_page_nodes(route.page, manifest))
-			: undefined;
+		page_nodes = route?.page ? new PageNodes(await load_page_nodes(route.page)) : undefined;
 
 		// determine whether we need to redirect to add/remove a trailing slash
 		if (route && !remote_id) {
@@ -452,10 +456,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, state, options, err);
+				return await handle_fatal_error(event, state, err);
 			}
 		}
-		return await handle_fatal_error(event, state, options, e);
+		return await handle_fatal_error(event, state, e);
 	}
 
 	async function handle() {
@@ -485,7 +489,7 @@ export async function internal_respond(request, options, manifest, state) {
 				};
 
 				return await with_request_store({ event: traced_event, state }, () =>
-					options.hooks.handle({
+					hooks.handle({
 						event: traced_event,
 						resolve: (event, opts) => {
 							return record_span({
@@ -592,8 +596,6 @@ export async function internal_respond(request, options, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					options,
-					manifest,
 					error: new SvelteKitError(
 						400,
 						'Malformed URI',
@@ -603,31 +605,29 @@ export async function internal_respond(request, options, manifest, state) {
 				});
 			}
 
-			if (options.hash_routing || state.prerendering?.fallback) {
+			if (__SVELTEKIT_HASH_ROUTING__ || state.prerendering?.fallback) {
 				return await render_response({
 					event,
 					state,
-					options,
-					manifest,
 					page_config: { ssr: false, csr: true },
 					status: 200,
 					error: null,
 					branch: [
 						// include the root layout because it applies to every page
 						{
-							node: /** @type {SSRNode} */ (await manifest._.nodes[0]()),
+							node: /** @type {SSRNode} */ (await manifest.nodes[0]()),
 							data: null,
 							server_data: null
 						}
 					],
 					fetched: [],
 					resolve_opts,
-					data_serializer: server_data_serializer(event, state, options)
+					data_serializer: server_data_serializer(event, state)
 				});
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, state, options, manifest, remote_id);
+				return await handle_remote_call(event, state, remote_id);
 			}
 
 			if (route) {
@@ -637,15 +637,7 @@ export async function internal_respond(request, options, manifest, state) {
 				let response;
 
 				if (is_data_request) {
-					response = await render_data(
-						event,
-						state,
-						route,
-						options,
-						manifest,
-						invalidated_data_nodes,
-						trailing_slash
-					);
+					response = await render_data(event, state, route, invalidated_data_nodes, trailing_slash);
 				} else {
 					let endpoint;
 					if (
@@ -672,18 +664,10 @@ export async function internal_respond(request, options, manifest, state) {
 						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,
-								state,
-								route.page,
-								options,
-								manifest,
-								page_nodes,
-								resolve_opts
-							);
+							response = await render_page(event, state, route.page, page_nodes, resolve_opts);
 						} else {
 							const allowed_methods = new Set(allowed_page_methods);
-							const node = await manifest._.nodes[route.page.leaf]();
+							const node = await manifest.nodes[route.page.leaf]();
 							if (node?.server?.actions) {
 								allowed_methods.add('POST');
 							}
@@ -765,8 +749,6 @@ export async function internal_respond(request, options, manifest, state) {
 						event,
 						state,
 						{ page: { layouts: [], leaf: 0 } },
-						options,
-						manifest,
 						invalidated_data_nodes,
 						// there is no route to take a trailing slash option from, and the
 						// SSR'd error page sees the pathname as-is
@@ -784,8 +766,6 @@ export async function internal_respond(request, options, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					options,
-					manifest,
 					error: new SvelteKitError(404, 'Not Found', `Not found: ${event.url.pathname}`),
 					resolve_opts
 				});
@@ -806,7 +786,7 @@ 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, state, options, e);
+			return await handle_fatal_error(event, state, e);
 		} finally {
 			event.cookies.set = () => {
 				throw new Error('Cannot use `cookies.set(...)` after the response has been generated');
@@ -822,13 +802,12 @@ export async function internal_respond(request, options, manifest, state) {
 
 /**
  * @param {import('types').PageNodeIndexes} page
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  */
-export function load_page_nodes(page, manifest) {
+export function load_page_nodes(page) {
 	return Promise.all([
 		// we use == here rather than === because [undefined] serializes as "[null]"
-		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-		manifest._.nodes[page.leaf]()
+		...page.layouts.map((n) => (n == undefined ? n : manifest.nodes[n]())),
+		manifest.nodes[page.leaf]()
 	]);
 }
 
@@ -853,3 +832,26 @@ function propagate_context(fn) {
 		});
 	};
 }
+
+/**
+ * @param {object} opts
+ * @param {string} opts.request_url - The original request URL
+ * @param {string} opts.resolved_path - The resolved pathname
+ * @param {boolean} opts.is_data_request - Whether the request is a data request
+ * @param {boolean} opts.is_route_resolution_request -
+ * @returns {URL}
+ */
+function denormalise_url({
+	request_url,
+	resolved_path,
+	is_data_request,
+	is_route_resolution_request
+}) {
+	const url = new URL(request_url);
+	url.pathname = is_data_request
+		? add_data_suffix(resolved_path)
+		: is_route_resolution_request
+			? add_resolution_suffix(resolved_path)
+			: resolved_path;
+	return url;
+}

package/src/runtime/server/state.js

@@ -9,6 +9,7 @@ function transient_fields() {
 			implicit: null,
 			forms: null,
 			requested: null,
+			ignored: null,
 			batches: null,
 			live_iterators: null
 		},
@@ -36,6 +37,7 @@ export function create_request_state(options) {
 		prerender_default: undefined,
 		error: false,
 		depth: 0,
+		rerouted_url: null,
 		...transient_fields()
 	};
 }

package/src/runtime/server/utils.js

@@ -1,5 +1,6 @@
 import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
+import { manifest } from './internal.js';
 
 /**
  * @param {Partial<Record<import('types').HttpMethod, any>>} mod
@@ -29,13 +30,6 @@ export function allowed_methods(mod) {
 	return allowed;
 }
 
-/**
- * @param {import('types').SSROptions} options
- */
-export function get_global_name(options) {
-	return __SVELTEKIT_DEV__ ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
-}
-
 /**
  * @param {number} status
  * @param {string} location
@@ -105,13 +99,12 @@ export function serialize_uses(node) {
 
 /**
  * Returns `true` if the given path was prerendered
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {string} pathname Should include the base and be decoded
  */
-export function has_prerendered_path(manifest, pathname) {
+export function has_prerendered_path(pathname) {
 	return (
-		manifest._.prerendered_routes.has(pathname) ||
-		(pathname.at(-1) === '/' && manifest._.prerendered_routes.has(pathname.slice(0, -1)))
+		manifest.prerendered_routes.has(pathname) ||
+		(pathname.at(-1) === '/' && manifest.prerendered_routes.has(pathname.slice(0, -1)))
 	);
 }
 

package/src/runtime/shared.js

@@ -15,6 +15,15 @@ export function validate_depends(route_id, dep) {
 	}
 }
 
+/**
+ * Same-origin urls are keyed by path, so prerendered pages can be served from any origin
+ * @param {URL} url
+ * @param {{ origin: string }} page
+ */
+export function fetch_cache_url(url, page) {
+	return url.origin === page.origin ? url.href.slice(page.origin.length) : url.href;
+}
+
 export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';
 
 export const TRAILING_SLASH_PARAM = 'x-sveltekit-trailing-slash';

package/src/runtime/utils.js

@@ -1,6 +1,47 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
+
+/**
+ * `ReadableStream.from`, for runtimes that don't support it (as of writing, every Bun release)
+ * @template T
+ * @param {AsyncIterable<T>} iterable
+ * @returns {ReadableStream<T>}
+ */
+export function stream_from_iterable(iterable) {
+	// TODO remove the casts once TypeScript's lib includes `ReadableStream.from`
+	if (/** @type {any} */ (ReadableStream).from) {
+		return /** @type {any} */ (ReadableStream).from(iterable);
+	}
+
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			const { value, done } = await iterator.next();
+			if (done) controller.close();
+			else controller.enqueue(value);
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+
+/**
+ * @param {string} head
+ * @param {AsyncIterable<string>} chunks
+ * @returns {ReadableStream<Uint8Array>} `head` followed by each non-empty chunk, encoded
+ */
+export function stream_text(head, chunks) {
+	return stream_from_iterable(
+		(async function* () {
+			yield text_encoder.encode(head);
+			for await (const chunk of chunks) {
+				if (chunk) yield text_encoder.encode(chunk);
+			}
+		})()
+	);
+}
 export const text_decoder = new TextDecoder();
 
 /**

package/src/types/ambient-private.d.ts

@@ -1,7 +1,6 @@
 /** Internal version of $app/server */
 declare module '<sveltekit:generated>/server.js' {
-	import { SSRManifest } from '@sveltejs/kit';
-	import { SSROptions, ServerHooks } from 'types';
+	import { SSROptions, ServerHooks, SSRManifest } from 'types';
 
 	export const options: SSROptions;
 	export const get_hooks: () => Promise<Partial<ServerHooks>>;

package/src/types/global-private.d.ts

@@ -13,7 +13,15 @@ declare global {
 	 * it is influenced by `NODE_ENV` which can still be true during `vite preview`
 	 */
 	const __SVELTEKIT_DEV__: boolean;
+	const __SVELTEKIT_CSRF_CHECK_ORIGIN__: boolean;
 	const __SVELTEKIT_EMBEDDED__: boolean;
+	/** True if `config.output.linkHeaderPreload` is `true` */
+	const __SVELTEKIT_LINK_HEADER_PRELOAD__: boolean;
+	const __SVELTEKIT_PATHS_ORIGIN__: string | undefined;
+	/** True if the app has a service worker and `config.serviceWorker.register` is `true` */
+	const __SVELTEKIT_SERVICE_WORKER__: boolean;
+	/** The `__sveltekit_xxx` name the payload object is attached to, without `globalThis.` */
+	const __SVELTEKIT_GLOBAL_NAME__: string;
 	const __SVELTEKIT_PATHS_ASSETS__: string;
 	const __SVELTEKIT_PATHS_BASE__: string;
 	const __SVELTEKIT_PATHS_RELATIVE__: boolean;

package/src/types/internal.d.ts

@@ -7,12 +7,14 @@ import {
 	ServerInitOptions,
 	Actions,
 	RequestEvent,
-	SSRManifest,
 	Emulator,
-	HttpError
+	HttpError,
+	Adapter,
+	AdapterViteConfig
 } from '@sveltejs/kit';
 import { RemoteFormIssue, RemoteQuery, RemoteLiveQuery } from '$app/server';
 import { Config } from '@sveltejs/kit/vite';
+import { ParamMatcher } from '@sveltejs/kit/params';
 import {
 	ClientInit,
 	Handle,
@@ -48,12 +50,11 @@ export interface ServerInternalModule {
 	set_version(version: string): void;
 	set_fix_stack_trace(fix_stack_trace: (error: Error) => void): void;
 	get_hooks: () => Promise<Record<string, any>>;
-	log_response: (status: number, request: Request) => void;
+	format_response: (status: number, request: Request) => string;
 }
 
 export interface Asset {
 	file: string;
-	size: number;
 	type: string | null;
 }
 
@@ -194,7 +195,8 @@ export interface InternalRequestOptions extends RequestOptions {
 	emulator?: Emulator;
 }
 
-export class InternalServer extends Server {
+export class InternalServer implements Server {
+	constructor(manifest: SSRManifest);
 	init(options: ServerInitOptions): Promise<void>;
 	respond(request: Request, options: InternalRequestOptions): Promise<Response>;
 }
@@ -342,6 +344,8 @@ export type RemoteFunctionData = {
 	f?: Record<string, RemoteFunctionDataNode>;
 	/** Whether there were any refreshes/reconnects during the request */
 	r?: true;
+	/** Client-requested updates that the server intentionally ignored */
+	i?: string[];
 	/** The redirect location, if any */
 	redirect?: string;
 };
@@ -457,6 +461,42 @@ export interface ServerNode {
 	entries?: PrerenderEntryGenerator;
 }
 
+/**
+ * Information required to instantiate a new `Server` instance.
+ */
+export interface SSRManifest {
+	/**
+	 * The directory where SvelteKit keeps its stuff, including static assets
+	 * (such as JS and CSS) and internally-used routes.
+	 */
+	app_dir: string;
+	/**
+	 * The `base` and `appDir` settings combined without a leading slash.
+	 */
+	app_path: string;
+	/**
+	 * Static files from `config.files.assets` and the service worker (if any).
+	 */
+	assets: Set<string>;
+	/**
+	 * Map of file extensions to MIME types
+	 */
+	mime_types: Record<string, string>;
+	client: BuildData['client'];
+	nodes: SSRNodeLoader[];
+	/**
+	 * hashed filename -> import to that file
+	 */
+	remotes: Record<string, () => Promise<{ default: Record<string, any> }>>;
+	routes: SSRRoute[];
+	prerendered_routes: Set<string>;
+	matchers: () => Promise<Record<string, ParamMatcher>>;
+	/**
+	 * A `[file]: size` map of all assets imported by server code.
+	 */
+	server_assets: Record<string, number>;
+}
+
 export interface SSRNode {
 	/** index into the `nodes` array in the generated `client/app.js`. */
 	index: number;
@@ -493,14 +533,7 @@ export type SSRNodeLoader = () => Promise<SSRNode>;
 export interface SSROptions {
 	app_template_contains_nonce: boolean;
 	csp: ValidatedConfig['csp'];
-	csrf_check_origin: boolean;
 	csrf_trusted_origins: string[];
-	embedded: boolean;
-	hash_routing: boolean;
-	hooks: ServerHooks;
-	link_header_preload: ValidatedConfig['output']['linkHeaderPreload'];
-	paths_origin: string | undefined;
-	service_worker: boolean;
 	service_worker_options: RegistrationOptions;
 	templates: {
 		app(values: {
@@ -512,8 +545,6 @@ export interface SSROptions {
 		}): string;
 		error(values: { message: string; status: number }): string;
 	};
-	version: string;
-	version_hash: string;
 }
 
 export interface PageNodeIndexes {
@@ -562,7 +593,8 @@ export interface Uses {
 	search_params: Set<string>;
 }
 
-export type ValidatedConfig = RecursiveRequired<Omit<Config, 'preprocess'>> & {
+export type ValidatedConfig = RecursiveRequired<Omit<Config, 'preprocess' | 'adapter'>> & {
+	adapter: Adapter & { vite?: AdapterViteConfig };
 	preprocess: Config['preprocess'];
 };
 
@@ -606,7 +638,7 @@ export interface RemoteQueryLiveInternals extends BaseRemoteInternals {
 export interface RemoteQueryBatchInternals extends BaseRemoteInternals {
 	type: 'query_batch';
 	validate: (arg?: any) => MaybePromise<any>;
-	run: (args: any[], options: SSROptions) => Promise<any[]>;
+	run: (args: any[]) => Promise<any[]>;
 	/**
 	 * Creates a `RemoteQuery` bound directly to a specific client payload (the
 	 * stringified raw argument) and a pre-validated argument, skipping the query
@@ -691,6 +723,11 @@ export interface RequestState {
 	 * True if we're currently attempting to render an error page.
 	 */
 	error: boolean;
+	/**
+	 * The rerouted URL (only if the new pathname differs from the original).
+	 * Used by platforms that serve a catch-all serverless function.
+	 */
+	rerouted_url: string | null;
 	/**
 	 * Allows us to prevent `event.fetch` from making infinitely looping internal requests.
 	 */
@@ -720,7 +757,9 @@ export interface RequestState {
 		/** Instances created via `myForm.for(...)` */
 		forms: null | Map<string, any>;
 		/** A map of remote function ID to payloads requested for refreshing by the client */
-		requested: null | Map<string, string[]>;
+		requested: null | Map<string, Set<string>>;
+		/** Client-requested updates intentionally ignored by `requested(...).ignoreAll()` or `ignore` */
+		ignored: null | Set<string>;
 		/** A map of query.batch ID to payloads requested for that batch within the same macrotask */
 		batches: null | Map<
 			string,