@sveltejs/kit 1.0.0-next.552 → 1.0.0-next.554

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.552",
+  "version": "1.0.0-next.554",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/config/options.js

@@ -232,7 +232,7 @@ const options = object(
 				crawl: boolean(true),
 				createIndexFiles: error(
 					(keypath) =>
-						`${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/configuration#trailingslash`
+						`${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/page-options#trailingslash`
 				),
 				default: error(
 					(keypath) =>
@@ -320,7 +320,7 @@ const options = object(
 			// TODO remove for 1.0
 			router: error(
 				(keypath) =>
-					`${keypath} has been removed. You can set \`export const csr = false\` inside the top level +layout.js instead. See the PR for more information: https://github.com/sveltejs/kit/pull/6197`
+					`${keypath} has been removed. You can set \`export const csr = false\` inside the top level +layout.js (or +layout.server.js) instead. See the PR for more information: https://github.com/sveltejs/kit/pull/6197`
 			),
 
 			// TODO remove for 1.0
@@ -343,7 +343,10 @@ const options = object(
 			// TODO remove this for 1.0
 			target: error((keypath) => `${keypath} is no longer required, and should be removed`),
 
-			trailingSlash: list(['never', 'always', 'ignore']),
+			trailingSlash: error(
+				(keypath, input) =>
+					`${keypath} has been removed. You can set \`export const trailingSlash = '${input}'\` inside a top level +layout.js (or +layout.server.js) instead. See the PR for more information: https://github.com/sveltejs/kit/pull/7719`
+			),
 
 			version: object({
 				name: string(Date.now().toString()),
@@ -506,10 +509,10 @@ function assert_string(input, keypath) {
 	}
 }
 
-/** @param {(keypath?: string) => string} fn */
+/** @param {(keypath?: string, input?: any) => string} fn */
 function error(fn) {
-	return validate(undefined, (_, keypath) => {
-		throw new Error(fn(keypath));
+	return validate(undefined, (input, keypath) => {
+		throw new Error(fn(keypath, input));
 	});
 }
 

package/src/core/env.js

@@ -1,6 +1,15 @@
 import { GENERATED_COMMENT } from '../constants.js';
 import { runtime_base } from './utils.js';
 
+/**
+ * @typedef {'public' | 'private'} EnvType
+ * @typedef {{
+ * 	public: Record<string, string>;
+ * 	private: Record<string, string>;
+ * 	prefix: string;
+ * }} EnvData
+ */
+
 /**
  * @param {string} id
  * @param {Record<string, string>} env
@@ -25,46 +34,54 @@ export function create_static_module(id, env) {
 }
 
 /**
- * @param {'public' | 'private'} type
+ * @param {EnvType} type
  * @param {Record<string, string> | undefined} dev_values If in a development mode, values to pre-populate the module with.
  */
 export function create_dynamic_module(type, dev_values) {
 	if (dev_values) {
-		const objectKeys = Object.entries(dev_values).map(
+		const keys = Object.entries(dev_values).map(
 			([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`
 		);
-		return `const env = {\n${objectKeys.join(',\n')}\n}\n\nexport { env }`;
+		return `export const env = {\n${keys.join(',\n')}\n}`;
 	}
 	return `export { env } from '${runtime_base}/env-${type}.js';`;
 }
 
 /**
- * @param {string} id
- * @param {Record<string, string>} env
+ * @param {EnvType} id
+ * @param {EnvData} env
  * @returns {string}
  */
 export function create_static_types(id, env) {
-	const declarations = Object.keys(env)
+	const declarations = Object.keys(env[id])
 		.filter((k) => valid_identifier.test(k))
 		.map((k) => `\texport const ${k}: string;`)
 		.join('\n');
 
-	return `declare module '${id}' {\n${declarations}\n}`;
+	return `declare module '$env/static/${id}' {\n${declarations}\n}`;
 }
 
 /**
- * @param {string} id
- * @param {Record<string, string>} env
+ * @param {EnvType} id
+ * @param {EnvData} env
  * @returns {string}
  */
 export function create_dynamic_types(id, env) {
-	const properties = Object.keys(env)
+	const properties = Object.keys(env[id])
 		.filter((k) => valid_identifier.test(k))
 		.map((k) => `\t\t${k}: string;`);
 
-	properties.push(`\t\t[key: string]: string | undefined;`);
+	const prefixed = `[key: \`${env.prefix}\${string}\`]`;
+
+	if (id === 'private') {
+		properties.push(`\t\t${prefixed}: undefined;`);
+		properties.push(`\t\t[key: string]: string | undefined;`);
+	} else {
+		properties.push(`\t\t${prefixed}: string | undefined;`);
+	}
 
-	return `declare module '${id}' {\n\texport const env: {\n${properties.join('\n')}\n\t}\n}`;
+	const declaration = `export const env: {\n${properties.join('\n')}\n\t}`;
+	return `declare module '$env/dynamic/${id}' {\n\t${declaration}\n}`;
 }
 
 export const reserved = new Set([

package/src/core/prerender/prerender.js

@@ -137,7 +137,7 @@ export async function prerender() {
 		config.prerender.handleMissingId,
 		({ path, id, referrers }) => {
 			return (
-				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path}:` +
+				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path} - see the \`handleMissingId\` option in https://kit.svelte.dev/docs/configuration#prerender for more info:` +
 				referrers.map((l) => `\n  - ${l}`).join('')
 			);
 		}
@@ -262,11 +262,13 @@ export async function prerender() {
 				}
 
 				if (hash) {
-					if (!expected_hashlinks.has(pathname + hash)) {
-						expected_hashlinks.set(pathname + hash, new Set());
+					const key = decodeURI(pathname + hash);
+
+					if (!expected_hashlinks.has(key)) {
+						expected_hashlinks.set(key, new Set());
 					}
 
-					/** @type {Set<string>} */ (expected_hashlinks.get(pathname + hash)).add(decoded);
+					/** @type {Set<string>} */ (expected_hashlinks.get(key)).add(decoded);
 				}
 
 				enqueue(decoded, decodeURI(pathname), pathname);

package/src/core/sync/write_ambient.js

@@ -19,7 +19,7 @@ function read_description(filename) {
 }
 
 /**
- * @param {{ public: Record<string, string>, private: Record<string, string> }} env
+ * @param {import('../env.js').EnvData} env
  */
 const template = (env) => `
 ${GENERATED_COMMENT}
@@ -27,16 +27,16 @@ ${GENERATED_COMMENT}
 /// <reference types="@sveltejs/kit" />
 
 ${read_description('$env+static+private.md')}
-${create_static_types('$env/static/private', env.private)}
+${create_static_types('private', env)}
 
 ${read_description('$env+static+public.md')}
-${create_static_types('$env/static/public', env.public)}
+${create_static_types('public', env)}
 
 ${read_description('$env+dynamic+private.md')}
-${create_dynamic_types('$env/dynamic/private', env.private)}
+${create_dynamic_types('private', env)}
 
 ${read_description('$env+dynamic+public.md')}
-${create_dynamic_types('$env/dynamic/public', env.public)}
+${create_dynamic_types('public', env)}
 `;
 
 /**
@@ -49,5 +49,8 @@ ${create_dynamic_types('$env/dynamic/public', env.public)}
 export function write_ambient(config, mode) {
 	const env = get_env(config.env, mode);
 
-	write_if_changed(path.join(config.outDir, 'ambient.d.ts'), template(env));
+	write_if_changed(
+		path.join(config.outDir, 'ambient.d.ts'),
+		template({ ...env, prefix: config.env.publicPrefix })
+	);
 }

package/src/exports/vite/build/build_server.js

@@ -87,7 +87,6 @@ export class Server {
 			app_template,
 			app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
 			error_template,
-			trailing_slash: ${s(config.kit.trailingSlash)},
 			version: ${s(config.kit.version.name)}
 		};
 	}

package/src/exports/vite/dev/index.js

@@ -480,7 +480,6 @@ export async function dev(vite, vite_config, svelte_config) {
 						service_worker:
 							svelte_config.kit.serviceWorker.register &&
 							!!resolve_entry(svelte_config.kit.files.serviceWorker),
-						trailing_slash: svelte_config.kit.trailingSlash,
 						version: svelte_config.kit.version.name
 					},
 					{

package/src/exports/vite/index.js

@@ -107,9 +107,6 @@ function kit() {
 	/** @type {import('types').BuildData} */
 	let build_data;
 
-	/** @type {string | undefined} */
-	let deferred_warning;
-
 	/** @type {{ public: Record<string, string>; private: Record<string, string> }} */
 	let env;
 
@@ -284,7 +281,9 @@ function kit() {
 				}
 			};
 
-			deferred_warning = warn_overridden_config(config, result);
+			const warning = warn_overridden_config(config, result);
+			if (warning) console.error(warning);
+
 			return result;
 		},
 
@@ -334,6 +333,10 @@ function kit() {
 		 */
 		configResolved(config) {
 			vite_config = config;
+
+			// This is a hack to prevent Vite from nuking useful logs,
+			// pending https://github.com/vitejs/vite/issues/9378
+			config.logger.warn('');
 		},
 
 		/**
@@ -540,14 +543,6 @@ function kit() {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
 		 */
 		async configureServer(vite) {
-			// This method is called by Vite after clearing the screen.
-			// This patch ensures we can log any important messages afterwards for the user to see.
-			const print_urls = vite.printUrls;
-			vite.printUrls = function () {
-				print_urls.apply(this);
-				if (deferred_warning) console.error('\n' + deferred_warning);
-			};
-
 			return await dev(vite, vite_config, svelte_config);
 		},
 

package/src/runtime/client/client.js

@@ -77,11 +77,10 @@ function check_for_removed_attributes() {
  * @param {{
  *   target: Element;
  *   base: string;
- *   trailing_slash: import('types').TrailingSlash;
  * }} opts
  * @returns {import('./types').Client}
  */
-export function create_client({ target, base, trailing_slash }) {
+export function create_client({ target, base }) {
 	/** @type {Array<((url: URL) => boolean)>} */
 	const invalidated = [];
 
@@ -416,6 +415,14 @@ export function create_client({ target, base, trailing_slash }) {
 	}) {
 		const filtered = /** @type {import('./types').BranchNode[] } */ (branch.filter(Boolean));
 
+		/** @type {import('types').TrailingSlash} */
+		let slash = 'never';
+		for (const node of branch) {
+			if (node?.slash !== undefined) slash = node.slash;
+		}
+		url.pathname = normalize_path(url.pathname, slash);
+		url.search = url.search; // turn `/?` into `/`
+
 		/** @type {import('./types').NavigationFinished} */
 		const result = {
 			type: 'loaded',
@@ -657,7 +664,8 @@ export function create_client({ target, base, trailing_slash }) {
 			loader,
 			server: server_data_node,
 			shared: node.shared?.load ? { type: 'data', data, uses } : null,
-			data: data ?? server_data_node?.data ?? null
+			data: data ?? server_data_node?.data ?? null,
+			slash: node.shared?.trailingSlash ?? server_data_node?.slash
 		};
 	}
 
@@ -704,7 +712,8 @@ export function create_client({ target, base, trailing_slash }) {
 					parent: !!node.uses.parent,
 					route: !!node.uses.route,
 					url: !!node.uses.url
-				}
+				},
+				slash: node.slash
 			};
 		} else if (node?.type === 'skip') {
 			return previous ?? null;
@@ -999,12 +1008,9 @@ export function create_client({ target, base, trailing_slash }) {
 			const params = route.exec(path);
 
 			if (params) {
-				const normalized = new URL(
-					url.origin + normalize_path(url.pathname, trailing_slash) + url.search + url.hash
-				);
-				const id = normalized.pathname + normalized.search;
+				const id = url.pathname + url.search;
 				/** @type {import('./types').NavigationIntent} */
-				const intent = { id, invalidating, route, params: decode_params(params), url: normalized };
+				const intent = { id, invalidating, route, params: decode_params(params), url };
 				return intent;
 			}
 		}
@@ -1458,7 +1464,7 @@ export function create_client({ target, base, trailing_slash }) {
 			});
 
 			addEventListener('popstate', (event) => {
-				if (event.state) {
+				if (event.state?.[INDEX_KEY]) {
 					// if a popstate-driven navigation is cancelled, we need to counteract it
 					// with history.go, which means we end up back here, hence this check
 					if (event.state[INDEX_KEY] === current_history_index) return;

package/src/runtime/client/start.js

@@ -13,11 +13,10 @@ import { set_version } from '../env.js';
  *     base: string;
  *   },
  *   target: Element;
- *   trailing_slash: import('types').TrailingSlash;
  *   version: string;
  * }} opts
  */
-export async function start({ env, hydrate, paths, target, trailing_slash, version }) {
+export async function start({ env, hydrate, paths, target, version }) {
 	set_public_env(env);
 	set_paths(paths);
 	set_version(version);
@@ -30,8 +29,7 @@ export async function start({ env, hydrate, paths, target, trailing_slash, versi
 
 	const client = create_client({
 		target,
-		base: paths.base,
-		trailing_slash
+		base: paths.base
 	});
 
 	init({ client });

package/src/runtime/client/types.d.ts

@@ -8,7 +8,7 @@ import {
 	prefetch,
 	prefetchRoutes
 } from '$app/navigation';
-import { CSRPageNode, CSRPageNodeLoader, CSRRoute, Uses } from 'types';
+import { CSRPageNode, CSRPageNodeLoader, CSRRoute, TrailingSlash, Uses } from 'types';
 
 export interface Client {
 	// public API, exposed via $app/navigation
@@ -67,12 +67,14 @@ export type BranchNode = {
 	server: DataNode | null;
 	shared: DataNode | null;
 	data: Record<string, any> | null;
+	slash?: TrailingSlash;
 };
 
 export interface DataNode {
 	type: 'data';
 	data: Record<string, any> | null;
 	uses: Uses;
+	slash?: TrailingSlash;
 }
 
 export interface NavigationState {

package/src/runtime/server/cookie.js

@@ -11,9 +11,10 @@ const cookie_paths = {};
 /**
  * @param {Request} request
  * @param {URL} url
- * @param {Pick<import('types').SSROptions, 'dev' | 'trailing_slash'>} options
+ * @param {boolean} dev
+ * @param {import('types').TrailingSlash} trailing_slash
  */
-export function get_cookies(request, url, options) {
+export function get_cookies(request, url, dev, trailing_slash) {
 	const header = request.headers.get('cookie') ?? '';
 	const initial_cookies = parse(header);
 
@@ -21,12 +22,12 @@ export function get_cookies(request, url, options) {
 		// Remove suffix: 'foo/__data.json' would mean the cookie path is '/foo',
 		// whereas a direct hit of /foo would mean the cookie path is '/'
 		has_data_suffix(url.pathname) ? strip_data_suffix(url.pathname) : url.pathname,
-		options.trailing_slash
+		trailing_slash
 	);
 	// Emulate browser-behavior: if the cookie is set at '/foo/bar', its path is '/foo'
 	const default_path = normalized_url.split('/').slice(0, -1).join('/') || '/';
 
-	if (options.dev) {
+	if (dev) {
 		// Remove all cookies that no longer exist according to the request
 		for (const name of Object.keys(cookie_paths)) {
 			cookie_paths[name] = new Set(
@@ -79,7 +80,7 @@ export function get_cookies(request, url, options) {
 			const req_cookies = parse(header, { decode });
 			const cookie = req_cookies[name]; // the decoded string or undefined
 
-			if (!options.dev || cookie) {
+			if (!dev || cookie) {
 				return cookie;
 			}
 
@@ -113,7 +114,7 @@ export function get_cookies(request, url, options) {
 				}
 			};
 
-			if (options.dev) {
+			if (dev) {
 				cookie_paths[name] = cookie_paths[name] ?? new Set();
 				if (!value) {
 					if (!cookie_paths[name].has(path) && cookie_paths[name].size > 0) {

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

@@ -12,9 +12,10 @@ export const INVALIDATED_HEADER = 'x-sveltekit-invalidated';
  * @param {import('types').SSRRoute} route
  * @param {import('types').SSROptions} options
  * @param {import('types').SSRState} state
+ * @param {import('types').TrailingSlash} trailing_slash
  * @returns {Promise<Response>}
  */
-export async function render_data(event, route, options, state) {
+export async function render_data(event, route, options, state, trailing_slash) {
 	if (!route.page) {
 		// requesting /__data.json should fail for a +server.js
 		return new Response(undefined, {
@@ -32,7 +33,7 @@ export async function render_data(event, route, options, state) {
 		let aborted = false;
 
 		const url = new URL(event.url);
-		url.pathname = normalize_path(strip_data_suffix(url.pathname), options.trailing_slash);
+		url.pathname = normalize_path(strip_data_suffix(url.pathname), trailing_slash);
 
 		const new_event = { ...event, url };
 

package/src/runtime/server/index.js

@@ -3,7 +3,7 @@ import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
 import { is_form_content_type } from '../../utils/http.js';
-import { GENERIC_ERROR, handle_fatal_error, redirect_response } from './utils.js';
+import { GENERIC_ERROR, get_option, handle_fatal_error, redirect_response } from './utils.js';
 import {
 	decode_pathname,
 	decode_params,
@@ -70,6 +70,7 @@ export async function respond(request, options, state) {
 	if (is_data_request) decoded = strip_data_suffix(decoded) || '/';
 
 	if (!state.prerendering?.fallback) {
+		// TODO this could theoretically break — should probably be inside a try-catch
 		const matchers = await options.manifest._.matchers();
 
 		for (const candidate of options.manifest._.routes) {
@@ -85,34 +86,17 @@ export async function respond(request, options, state) {
 		}
 	}
 
-	if (route?.page && !is_data_request) {
-		const normalized = normalize_path(url.pathname, options.trailing_slash);
-
-		if (normalized !== url.pathname && !state.prerendering?.fallback) {
-			return new Response(undefined, {
-				status: 301,
-				headers: {
-					'x-sveltekit-normalize': '1',
-					location:
-						// ensure paths starting with '//' are not treated as protocol-relative
-						(normalized.startsWith('//') ? url.origin + normalized : normalized) +
-						(url.search === '?' ? '' : url.search)
-				}
-			});
-		}
-	}
+	/** @type {import('types').TrailingSlash | void} */
+	let trailing_slash = undefined;
 
 	/** @type {Record<string, string>} */
 	const headers = {};
 
-	const { cookies, new_cookies, get_cookie_header } = get_cookies(request, url, options);
-
-	if (state.prerendering && !state.prerendering.fallback) disable_search(url);
-
 	/** @type {import('types').RequestEvent} */
 	const event = {
-		cookies,
-		// @ts-expect-error this is added in the next step, because `create_fetch` needs a reference to `event`
+		// @ts-expect-error `cookies` and `fetch` need to be created after the `event` itself
+		cookies: null,
+		// @ts-expect-error
 		fetch: null,
 		getClientAddress:
 			state.getClientAddress ||
@@ -149,8 +133,6 @@ export async function respond(request, options, state) {
 		url
 	};
 
-	event.fetch = create_fetch({ event, options, state, get_cookie_header });
-
 	// TODO remove this for 1.0
 	/**
 	 * @param {string} property
@@ -193,6 +175,128 @@ export async function respond(request, options, state) {
 		preload: default_preload
 	};
 
+	try {
+		// determine whether we need to redirect to add/remove a trailing slash
+		if (route && !is_data_request) {
+			if (route.page) {
+				const nodes = await Promise.all([
+					// we use == here rather than === because [undefined] serializes as "[null]"
+					...route.page.layouts.map((n) => (n == undefined ? n : options.manifest._.nodes[n]())),
+					options.manifest._.nodes[route.page.leaf]()
+				]);
+
+				trailing_slash = get_option(nodes, 'trailingSlash');
+			} else if (route.endpoint) {
+				const node = await route.endpoint();
+				trailing_slash = node.trailingSlash;
+			}
+
+			const normalized = normalize_path(url.pathname, trailing_slash ?? 'never');
+
+			if (normalized !== url.pathname && !state.prerendering?.fallback) {
+				return new Response(undefined, {
+					status: 301,
+					headers: {
+						'x-sveltekit-normalize': '1',
+						location:
+							// ensure paths starting with '//' are not treated as protocol-relative
+							(normalized.startsWith('//') ? url.origin + normalized : normalized) +
+							(url.search === '?' ? '' : url.search)
+					}
+				});
+			}
+		}
+
+		const { cookies, new_cookies, get_cookie_header } = get_cookies(
+			request,
+			url,
+			options.dev,
+			trailing_slash ?? 'never'
+		);
+
+		event.cookies = cookies;
+		event.fetch = create_fetch({ event, options, state, get_cookie_header });
+
+		if (state.prerendering && !state.prerendering.fallback) disable_search(url);
+
+		const response = await options.hooks.handle({
+			event,
+			resolve: (event, opts) =>
+				resolve(event, opts).then((response) => {
+					// add headers/cookies here, rather than inside `resolve`, so that we
+					// can do it once for all responses instead of once per `return`
+					for (const key in headers) {
+						const value = headers[key];
+						response.headers.set(key, /** @type {string} */ (value));
+					}
+
+					if (is_data_request) {
+						// set the Vary header on __data.json requests to ensure we don't cache
+						// incomplete responses with skipped data loads
+						// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary
+						const vary = response.headers.get('Vary');
+						if (vary !== '*') {
+							response.headers.append('Vary', INVALIDATED_HEADER);
+						}
+					}
+
+					add_cookies_to_headers(response.headers, Object.values(new_cookies));
+
+					if (state.prerendering && event.route.id !== null) {
+						response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
+					}
+
+					return response;
+				}),
+			// TODO remove for 1.0
+			// @ts-expect-error
+			get request() {
+				throw new Error('request in handle has been replaced with event' + details);
+			}
+		});
+
+		// respond with 304 if etag matches
+		if (response.status === 200 && response.headers.has('etag')) {
+			let if_none_match_value = request.headers.get('if-none-match');
+
+			// ignore W/ prefix https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match#directives
+			if (if_none_match_value?.startsWith('W/"')) {
+				if_none_match_value = if_none_match_value.substring(2);
+			}
+
+			const etag = /** @type {string} */ (response.headers.get('etag'));
+
+			if (if_none_match_value === etag) {
+				const headers = new Headers({ etag });
+
+				// https://datatracker.ietf.org/doc/html/rfc7232#section-4.1 + set-cookie
+				for (const key of [
+					'cache-control',
+					'content-location',
+					'date',
+					'expires',
+					'vary',
+					'set-cookie'
+				]) {
+					const value = response.headers.get(key);
+					if (value) headers.set(key, value);
+				}
+
+				return new Response(undefined, {
+					status: 304,
+					headers
+				});
+			}
+		}
+
+		return response;
+	} catch (error) {
+		if (error instanceof Redirect) {
+			return redirect_response(error.status, error.location);
+		}
+		return handle_fatal_error(event, options, error);
+	}
+
 	/**
 	 *
 	 * @param {import('types').RequestEvent} event
@@ -240,7 +344,7 @@ export async function respond(request, options, state) {
 				let response;
 
 				if (is_data_request) {
-					response = await render_data(event, route, options, state);
+					response = await render_data(event, route, options, state, trailing_slash ?? 'never');
 				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
 					response = await render_endpoint(event, await route.endpoint(), state);
 				} else if (route.page) {
@@ -293,83 +397,4 @@ export async function respond(request, options, state) {
 			};
 		}
 	}
-
-	try {
-		const response = await options.hooks.handle({
-			event,
-			resolve: (event, opts) =>
-				resolve(event, opts).then((response) => {
-					// add headers/cookies here, rather than inside `resolve`, so that we
-					// can do it once for all responses instead of once per `return`
-					for (const key in headers) {
-						const value = headers[key];
-						response.headers.set(key, /** @type {string} */ (value));
-					}
-
-					if (is_data_request) {
-						// set the Vary header on __data.json requests to ensure we don't cache
-						// incomplete responses with skipped data loads
-						// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary
-						const vary = response.headers.get('Vary');
-						if (vary !== '*') {
-							response.headers.append('Vary', INVALIDATED_HEADER);
-						}
-					}
-
-					add_cookies_to_headers(response.headers, Object.values(new_cookies));
-
-					if (state.prerendering && event.route.id !== null) {
-						response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
-					}
-
-					return response;
-				}),
-			// TODO remove for 1.0
-			// @ts-expect-error
-			get request() {
-				throw new Error('request in handle has been replaced with event' + details);
-			}
-		});
-
-		// respond with 304 if etag matches
-		if (response.status === 200 && response.headers.has('etag')) {
-			let if_none_match_value = request.headers.get('if-none-match');
-
-			// ignore W/ prefix https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match#directives
-			if (if_none_match_value?.startsWith('W/"')) {
-				if_none_match_value = if_none_match_value.substring(2);
-			}
-
-			const etag = /** @type {string} */ (response.headers.get('etag'));
-
-			if (if_none_match_value === etag) {
-				const headers = new Headers({ etag });
-
-				// https://datatracker.ietf.org/doc/html/rfc7232#section-4.1 + set-cookie
-				for (const key of [
-					'cache-control',
-					'content-location',
-					'date',
-					'expires',
-					'vary',
-					'set-cookie'
-				]) {
-					const value = response.headers.get(key);
-					if (value) headers.set(key, value);
-				}
-
-				return new Response(undefined, {
-					status: 304,
-					headers
-				});
-			}
-		}
-
-		return response;
-	} catch (error) {
-		if (error instanceof Redirect) {
-			return redirect_response(error.status, error.location);
-		}
-		return handle_fatal_error(event, options, error);
-	}
 }

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

@@ -63,7 +63,8 @@ export async function load_server_data({ event, state, node, parent }) {
 	return {
 		type: 'data',
 		data,
-		uses
+		uses,
+		slash: node.server.trailingSlash
 	};
 }
 

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

@@ -195,7 +195,9 @@ export async function render_response({
 					if (server_data.uses.route) uses.push(`route:1`);
 					if (server_data.uses.url) uses.push(`url:1`);
 
-					return `{type:"data",data:${data},uses:{${uses.join(',')}}}`;
+					return `{type:"data",data:${data},uses:{${uses.join(',')}}${
+						server_data.slash ? `,slash:${s(server_data.slash)}` : ''
+					}}`;
 				}
 
 				return s(server_data);
@@ -281,7 +283,6 @@ export async function render_response({
 				}` : 'null'},
 				paths: ${s(options.paths)},
 				target: document.querySelector('[data-sveltekit-hydrate="${target}"]').parentNode,
-				trailing_slash: ${s(options.trailing_slash)},
 				version: ${s(options.version)}
 			});
 		`;

package/src/runtime/server/utils.js

@@ -69,8 +69,8 @@ export function allowed_methods(mod) {
 }
 
 /**
- * @template {'prerender' | 'ssr' | 'csr'} Option
- * @template {Option extends 'prerender' ? import('types').PrerenderOption : boolean} Value
+ * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash'} Option
+ * @template {Option extends 'prerender' ? import('types').PrerenderOption : Option extends 'trailingSlash' ? import('types').TrailingSlash : boolean} Value
  *
  * @param {Array<import('types').SSRNode | undefined>} nodes
  * @param {Option} option
@@ -201,5 +201,7 @@ export function serialize_data_node(node) {
 	if (node.uses.route) uses.push(`"route":1`);
 	if (node.uses.url) uses.push(`"url":1`);
 
-	return `{"type":"data","data":${stringified},"uses":{${uses.join(',')}}}`;
+	return `{"type":"data","data":${stringified},"uses":{${uses.join(',')}}${
+		node.slash ? `,"slash":${JSON.stringify(node.slash)}` : ''
+	}}`;
 }

package/types/internal.d.ts

@@ -72,6 +72,7 @@ export interface CSRPageNode {
 	component: typeof SvelteComponent;
 	shared: {
 		load?: Load;
+		trailingSlash?: TrailingSlash;
 	};
 	server: boolean;
 }
@@ -209,6 +210,7 @@ export interface ServerDataNode {
 	type: 'data';
 	data: Record<string, any> | null;
 	uses: Uses;
+	slash?: TrailingSlash;
 }
 
 /**
@@ -266,6 +268,7 @@ export interface SSRNode {
 		prerender?: PrerenderOption;
 		ssr?: boolean;
 		csr?: boolean;
+		trailingSlash?: TrailingSlash;
 	};
 
 	server: {
@@ -273,6 +276,7 @@ export interface SSRNode {
 		prerender?: PrerenderOption;
 		ssr?: boolean;
 		csr?: boolean;
+		trailingSlash?: TrailingSlash;
 		actions?: Actions;
 	};
 
@@ -312,7 +316,6 @@ export interface SSROptions {
 	}): string;
 	app_template_contains_nonce: boolean;
 	error_template({ message, status }: { message: string; status: number }): string;
-	trailing_slash: TrailingSlash;
 	version: string;
 }
 
@@ -328,6 +331,7 @@ export interface PageNodeIndexes {
 
 export type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>> & {
 	prerender?: PrerenderOption;
+	trailingSlash?: TrailingSlash;
 };
 
 export interface SSRRoute {