@sveltejs/kit 1.20.5 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.20.5",
+  "version": "1.22.0",
   "description": "The fastest way to build Svelte apps",
   "repository": {
     "type": "git",
@@ -35,11 +35,11 @@
     "dts-buddy": "^0.0.10",
     "marked": "^4.2.3",
     "rollup": "^3.7.0",
-    "svelte": "^3.56.0",
-    "svelte-preprocess": "^5.0.3",
+    "svelte": "^4.0.3",
+    "svelte-preprocess": "^5.0.4",
     "typescript": "^4.9.4",
     "vite": "^4.3.6",
-    "vitest": "^0.31.0"
+    "vitest": "^0.32.2"
   },
   "peerDependencies": {
     "svelte": "^3.54.0 || ^4.0.0-next.0",
@@ -94,6 +94,7 @@
     "test:cross-platform:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:dev",
     "test:cross-platform:build": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:build",
     "test:unit": "vitest --config kit.vitest.config.js run",
-    "postinstall": "node postinstall.js"
+    "postinstall": "node postinstall.js",
+    "generate:version": "node scripts/generate-version.js"
   }
 }

package/src/constants.js

@@ -5,3 +5,15 @@
 export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
 
 export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';
+
+export const ENDPOINT_METHODS = new Set([
+	'GET',
+	'POST',
+	'PUT',
+	'PATCH',
+	'DELETE',
+	'OPTIONS',
+	'HEAD'
+]);
+
+export const PAGE_METHODS = new Set(['GET', 'POST', 'HEAD']);

package/src/core/config/options.js

@@ -120,7 +120,8 @@ const options = object(
 
 			env: object({
 				dir: string(process.cwd()),
-				publicPrefix: string('PUBLIC_')
+				publicPrefix: string('PUBLIC_'),
+				privatePrefix: string('')
 			}),
 
 			files: object({

package/src/core/env.js

@@ -63,21 +63,30 @@ export function create_static_types(id, env) {
 /**
  * @param {EnvType} id
  * @param {import('types').Env} env
- * @param {string} prefix
+ * @param {{
+ * 	public_prefix: string;
+ * 	private_prefix: string;
+ * }} prefixes
  * @returns {string}
  */
-export function create_dynamic_types(id, env, prefix) {
+export function create_dynamic_types(id, env, { public_prefix, private_prefix }) {
 	const properties = Object.keys(env[id])
 		.filter((k) => valid_identifier.test(k))
 		.map((k) => `${k}: string;`);
 
-	const prefixed = `[key: \`${prefix}\${string}\`]`;
+	const public_prefixed = `[key: \`${public_prefix}\${string}\`]`;
+	const private_prefixed = `[key: \`${private_prefix}\${string}\`]`;
 
 	if (id === 'private') {
-		properties.push(`${prefixed}: undefined;`);
-		properties.push('[key: string]: string | undefined;');
+		if (public_prefix) {
+			properties.push(`${public_prefixed}: undefined;`);
+		}
+		properties.push(`${private_prefixed}: string | undefined;`);
 	} else {
-		properties.push(`${prefixed}: string | undefined;`);
+		if (private_prefix) {
+			properties.push(`${private_prefixed}: undefined;`);
+		}
+		properties.push(`${public_prefixed}: string | undefined;`);
 	}
 
 	return dedent`

package/src/core/generate_manifest/index.js

@@ -44,7 +44,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 	);
 
 	/** @type {(path: string) => string} */
-	const loader = (path) => `() => import('${path}')`;
+	const loader = (path) => `__memo(() => import('${path}'))`;
 
 	const assets = build_data.manifest_data.assets.map((asset) => asset.file);
 	if (build_data.service_worker) {
@@ -65,8 +65,8 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 
 	// prettier-ignore
 	// String representation of
-	/** @type {import('@sveltejs/kit').SSRManifest} */
-	return dedent`
+	/** @template {import('@sveltejs/kit').SSRManifest} T */
+	const manifest_expr = dedent`
 		{
 			appDir: ${s(build_data.app_dir)},
 			appPath: ${s(build_data.app_path)},
@@ -97,10 +97,26 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 					}).filter(Boolean).join(',\n')}
 				],
 				matchers: async () => {
-					${Array.from(matchers).map(type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`).join('\n')}
+					${Array.from(
+						matchers, 
+						type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`
+					).join('\n')}
 					return { ${Array.from(matchers).join(', ')} };
 				}
 			}
 		}
 	`;
+
+	// Memoize the loaders to prevent Node from doing unnecessary work
+	// on every dynamic import call
+	return dedent`
+		(() => {
+		function __memo(fn) {
+			let value;
+			return () => value ??= (value = fn());
+		}
+
+		return ${manifest_expr}
+		})()
+	`;
 }

package/src/core/postbuild/analyse.js

@@ -13,6 +13,8 @@ import { forked } from '../../utils/fork.js';
 import { should_polyfill } from '../../utils/platform.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
 import { resolvePath } from '../../exports/index.js';
+import { ENDPOINT_METHODS } from '../../constants.js';
+import { filter_private_env, filter_public_env } from '../../utils/env.js';
 
 export default forked(import.meta.url, analyse);
 
@@ -43,10 +45,9 @@ async function analyse({ manifest_path, env }) {
 	internal.set_building(true);
 
 	// set env, in case it's used in initialisation
-	const entries = Object.entries(env);
-	const prefix = config.env.publicPrefix;
-	internal.set_private_env(Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix))));
-	internal.set_public_env(Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))));
+	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = config.env;
+	internal.set_private_env(filter_private_env(env, { public_prefix, private_prefix }));
+	internal.set_public_env(filter_public_env(env, { public_prefix, private_prefix }));
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -92,12 +93,11 @@ async function analyse({ manifest_path, env }) {
 				prerender = mod.prerender;
 			}
 
-			if (mod.GET) api_methods.push('GET');
-			if (mod.POST) api_methods.push('POST');
-			if (mod.PUT) api_methods.push('PUT');
-			if (mod.PATCH) api_methods.push('PATCH');
-			if (mod.DELETE) api_methods.push('DELETE');
-			if (mod.OPTIONS) api_methods.push('OPTIONS');
+			Object.values(mod).forEach((/** @type {import('types').HttpMethod} */ method) => {
+				if (mod[method] && ENDPOINT_METHODS.has(method)) {
+					api_methods.push(method);
+				}
+			});
 
 			config = mod.config;
 			entries = mod.entries;

package/src/core/sync/write_ambient.js

@@ -22,9 +22,12 @@ function read_description(filename) {
 
 /**
  * @param {import('types').Env} env
- * @param {string} prefix
+ * @param {{
+ * 	public_prefix: string;
+ * 	private_prefix: string;
+ * }} prefixes
  */
-const template = (env, prefix) => `
+const template = (env, prefixes) => `
 ${GENERATED_COMMENT}
 
 /// <reference types="@sveltejs/kit" />
@@ -36,10 +39,10 @@ ${read_description('$env+static+public.md')}
 ${create_static_types('public', env)}
 
 ${read_description('$env+dynamic+private.md')}
-${create_dynamic_types('private', env, prefix)}
+${create_dynamic_types('private', env, prefixes)}
 
 ${read_description('$env+dynamic+public.md')}
-${create_dynamic_types('public', env, prefix)}
+${create_dynamic_types('public', env, prefixes)}
 `;
 
 /**
@@ -51,9 +54,10 @@ ${create_dynamic_types('public', env, prefix)}
  */
 export function write_ambient(config, mode) {
 	const env = get_env(config.env, mode);
+	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = config.env;
 
 	write_if_changed(
 		path.join(config.outDir, 'ambient.d.ts'),
-		template(env, config.env.publicPrefix)
+		template(env, { public_prefix, private_prefix })
 	);
 }

package/src/core/sync/write_server.js

@@ -37,6 +37,7 @@ export const options = {
 	track_server_fetches: ${s(config.kit.dangerZone.trackServerFetches)},
 	embedded: ${config.kit.embedded},
 	env_public_prefix: '${config.kit.env.publicPrefix}',
+	env_private_prefix: '${config.kit.env.privatePrefix}',
 	hooks: null, // added lazily, via \`get_hooks\`
 	preload_strategy: ${s(config.kit.output.preloadStrategy)},
 	root,

package/src/exports/index.js

@@ -2,6 +2,8 @@ import { HttpError, Redirect, ActionFailure } from '../runtime/control.js';
 import { BROWSER, DEV } from 'esm-env';
 import { get_route_segments } from '../utils/routing.js';
 
+export { VERSION } from '../version.js';
+
 /**
  * @overload
  * @param {number} status
@@ -84,7 +86,12 @@ const encoder = new TextEncoder();
 export function text(body, init) {
 	const headers = new Headers(init?.headers);
 	if (!headers.has('content-length')) {
-		headers.set('content-length', encoder.encode(body).byteLength.toString());
+		const encoded = encoder.encode(body);
+		headers.set('content-length', encoded.byteLength.toString());
+		return new Response(encoded, {
+			...init,
+			headers
+		});
 	}
 
 	return new Response(body, {

package/src/exports/public.d.ts

@@ -372,6 +372,11 @@ export interface KitConfig {
 		 * @default "PUBLIC_"
 		 */
 		publicPrefix?: string;
+		/**
+		 * A prefix that signals that an environment variable is unsafe to expose to client-side code. Environment variables matching neither the public nor the private prefix will be discarded completely. See [`$env/static/private`](/docs/modules#$env-static-private) and [`$env/dynamic/private`](/docs/modules#$env-dynamic-private).
+		 * @default ""
+		 */
+		privatePrefix?: string;
 	};
 	/**
 	 * Where to find various files within your project.
@@ -449,7 +454,7 @@ export interface KitConfig {
 		/**
 		 * SvelteKit will preload the JavaScript modules needed for the initial page to avoid import 'waterfalls', resulting in faster application startup. There
 		 * are three strategies with different trade-offs:
-		 * - `modulepreload` - uses `<link rel="modulepreload">`. This delivers the best results in Chromium-based browsers, but is currently ignored by Firefox and Safari (though support is coming to Safari soon).
+		 * - `modulepreload` - uses `<link rel="modulepreload">`. This delivers the best results in Chromium-based browsers, in Firefox 115+, and Safari 17+. It is ignored in older browsers.
 		 * - `preload-js` - uses `<link rel="preload">`. Prevents waterfalls in Chromium and Safari, but Chromium will parse each module twice (once as a script, once as a module). Causes modules to be requested twice in Firefox. This is a good setting if you want to maximise performance for users on iOS devices at the cost of a very slight degradation for Chromium users.
 		 * - `preload-mjs` - uses `<link rel="preload">` but with the `.mjs` extension which prevents double-parsing in Chromium. Some static webservers will fail to serve .mjs files with a `Content-Type: application/javascript` header, which will cause your application to break. If that doesn't apply to you, this is the option that will deliver the best performance for the largest number of users, until `modulepreload` is more widely supported.
 		 * @default "modulepreload"
@@ -821,7 +826,7 @@ export interface NavigationTarget {
 
 /**
  * - `enter`: The app has hydrated
- * - `form`: The user submitted a `<form>`
+ * - `form`: The user submitted a `<form>` with a GET method
  * - `leave`: The user is leaving the app by closing the tab or using the back/forward buttons to go to a different document
  * - `link`: Navigation was triggered by a link click
  * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
@@ -1012,6 +1017,10 @@ export interface RequestEvent<
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
 	 */
 	isDataRequest: boolean;
+	/**
+	 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
+	 */
+	isSubRequest: boolean;
 }
 
 /**

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

@@ -50,7 +50,8 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 
 		if (node.component && client_manifest) {
 			exports.push(
-				`export const component = async () => (await import('../${
+				'let component_cache;',
+				`export const component = async () => component_cache ??= (await import('../${
 					resolve_symlinks(server_manifest, node.component).chunk.file
 				}')).default;`
 			);

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

@@ -90,14 +90,3 @@ export function resolve_symlinks(manifest, file) {
 export function assets_base(config) {
 	return (config.paths.assets || config.paths.base || '.') + '/';
 }
-
-const method_names = new Set(['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH', 'OPTIONS']);
-
-// If we'd written this in TypeScript, it could be easy...
-/**
- * @param {string} str
- * @returns {str is import('types').HttpMethod}
- */
-export function is_http_method(str) {
-	return method_names.has(str);
-}

package/src/exports/vite/utils.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { loadEnv } from 'vite';
 import { posixify } from '../../utils/filesystem.js';
 import { negotiate } from '../../utils/http.js';
+import { filter_private_env, filter_public_env } from '../../utils/env.js';
 
 /**
  * Transforms kit.alias to a valid vite.resolve.alias array.
@@ -56,11 +57,12 @@ function escape_for_regexp(str) {
  * @param {string} mode
  */
 export function get_env(env_config, mode) {
-	const entries = Object.entries(loadEnv(mode, env_config.dir, ''));
+	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = env_config;
+	const env = loadEnv(mode, env_config.dir, '');
 
 	return {
-		public: Object.fromEntries(entries.filter(([k]) => k.startsWith(env_config.publicPrefix))),
-		private: Object.fromEntries(entries.filter(([k]) => !k.startsWith(env_config.publicPrefix)))
+		public: filter_public_env(env, { public_prefix, private_prefix }),
+		private: filter_private_env(env, { public_prefix, private_prefix })
 	};
 }
 

package/src/runtime/client/client.js

@@ -1,12 +1,21 @@
 import { DEV } from 'esm-env';
 import { onMount, tick } from 'svelte';
 import {
-	make_trackable,
-	decode_pathname,
+	add_data_suffix,
 	decode_params,
-	normalize_path,
-	add_data_suffix
+	decode_pathname,
+	make_trackable,
+	normalize_path
 } from '../../utils/url.js';
+import {
+	initial_fetch,
+	lock_fetch,
+	native_fetch,
+	subsequent_fetch,
+	unlock_fetch
+} from './fetcher.js';
+import { parse } from './parse.js';
+import * as storage from './session-storage.js';
 import {
 	find_anchor,
 	get_base_uri,
@@ -15,25 +24,16 @@ import {
 	is_external_url,
 	scroll_state
 } from './utils.js';
-import * as storage from './session-storage.js';
-import {
-	lock_fetch,
-	unlock_fetch,
-	initial_fetch,
-	subsequent_fetch,
-	native_fetch
-} from './fetcher.js';
-import { parse } from './parse.js';
 
 import { base } from '__sveltekit/paths';
-import { HttpError, Redirect } from '../control.js';
-import { stores } from './singletons.js';
-import { unwrap_promises } from '../../utils/promises.js';
 import * as devalue from 'devalue';
-import { INDEX_KEY, PRELOAD_PRIORITIES, SCROLL_KEY, SNAPSHOT_KEY } from './constants.js';
-import { validate_page_exports } from '../../utils/exports.js';
 import { compact } from '../../utils/array.js';
+import { validate_page_exports } from '../../utils/exports.js';
+import { unwrap_promises } from '../../utils/promises.js';
+import { HttpError, Redirect } from '../control.js';
 import { INVALIDATED_PARAM, validate_depends } from '../shared.js';
+import { INDEX_KEY, PRELOAD_PRIORITIES, SCROLL_KEY, SNAPSHOT_KEY } from './constants.js';
+import { stores } from './singletons.js';
 
 let errored = false;
 
@@ -1555,9 +1555,7 @@ export function create_client(app, target) {
 
 					update_scroll_positions(current_history_index);
 
-					current.url = url;
-					stores.page.set({ ...page, url });
-					stores.page.notify();
+					update_url(url);
 
 					if (!options.replace_state) return;
 
@@ -1670,6 +1668,14 @@ export function create_client(app, target) {
 						type: 'popstate',
 						delta
 					});
+				} else {
+					// since popstate event is also emitted when an anchor referencing the same
+					// document is clicked, we have to check that the router isn't already handling
+					// the navigation. otherwise we would be updating the page store twice.
+					if (!hash_navigating) {
+						const url = new URL(location.href);
+						update_url(url);
+					}
 				}
 			});
 
@@ -1702,6 +1708,15 @@ export function create_client(app, target) {
 					stores.navigating.set(null);
 				}
 			});
+
+			/**
+			 * @param {URL} url
+			 */
+			function update_url(url) {
+				current.url = url;
+				stores.page.set({ ...page, url });
+				stores.page.notify();
+			}
 		},
 
 		_hydrate: async ({

package/src/runtime/server/endpoint.js

@@ -1,3 +1,4 @@
+import { ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
 import { negotiate } from '../../utils/http.js';
 import { Redirect } from '../control.js';
 import { method_not_allowed } from './utils.js';
@@ -79,8 +80,8 @@ export async function render_endpoint(event, mod, state) {
 export function is_endpoint_request(event) {
 	const { method, headers } = event.request;
 
-	if (method === 'PUT' || method === 'PATCH' || method === 'DELETE' || method === 'OPTIONS') {
-		// These methods exist exclusively for endpoints
+	// These methods exist exclusively for endpoints
+	if (ENDPOINT_METHODS.has(method) && !PAGE_METHODS.has(method)) {
 		return true;
 	}
 

package/src/runtime/server/index.js

@@ -2,6 +2,7 @@ import { respond } from './respond.js';
 import { set_private_env, set_public_env } from '../shared-server.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
 import { DEV } from 'esm-env';
+import { filter_private_env, filter_public_env } from '../../utils/env.js';
 
 export class Server {
 	/** @type {import('types').SSROptions} */
@@ -26,14 +27,19 @@ export class Server {
 		// Take care: Some adapters may have to call `Server.init` per-request to set env vars,
 		// so anything that shouldn't be rerun should be wrapped in an `if` block to make sure it hasn't
 		// been done already.
-		const entries = Object.entries(env);
-
-		const prefix = this.#options.env_public_prefix;
-		const prv = Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix)));
-		const pub = Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix)));
-
-		set_private_env(prv);
-		set_public_env(pub);
+		// set env, in case it's used in initialisation
+		set_private_env(
+			filter_private_env(env, {
+				public_prefix: this.#options.env_public_prefix,
+				private_prefix: this.#options.env_private_prefix
+			})
+		);
+		set_public_env(
+			filter_public_env(env, {
+				public_prefix: this.#options.env_public_prefix,
+				private_prefix: this.#options.env_private_prefix
+			})
+		);
 
 		if (!this.#options.hooks) {
 			try {

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

@@ -46,7 +46,7 @@ export function serialize_data(fetched, filter, prerendering = false) {
 
 	let cache_control = null;
 	let age = null;
-	let vary = false;
+	let varyAny = false;
 
 	for (const [key, value] of fetched.response.headers) {
 		if (filter(key, value)) {
@@ -54,8 +54,8 @@ export function serialize_data(fetched, filter, prerendering = false) {
 		}
 
 		if (key === 'cache-control') cache_control = value;
-		if (key === 'age') age = value;
-		if (key === 'vary') vary = true;
+		else if (key === 'age') age = value;
+		else if (key === 'vary' && value.trim() === '*') varyAny = true;
 	}
 
 	const payload = {
@@ -89,10 +89,9 @@ export function serialize_data(fetched, filter, prerendering = false) {
 	}
 
 	// Compute the time the response should be cached, taking into account max-age and age.
-	// Do not cache at all if a vary header is present, as this indicates that the cache is
-	// likely to get busted. It would also mean we'd have to add more logic to computing the
-	// selector on the client which results in more code for 99% of people for the 1% who use vary.
-	if (!prerendering && fetched.method === 'GET' && cache_control && !vary) {
+	// Do not cache at all if a `Vary: *` header is present, as this indicates that the
+	// cache is likely to get busted.
+	if (!prerendering && fetched.method === 'GET' && cache_control && !varyAny) {
 		const match = /s-maxage=(\d+)/g.exec(cache_control) ?? /max-age=(\d+)/g.exec(cache_control);
 		if (match) {
 			const ttl = +match[1] - +(age ?? '0');

package/src/runtime/server/respond.js

@@ -5,7 +5,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 { handle_fatal_error, redirect_response } from './utils.js';
+import { handle_fatal_error, method_not_allowed, redirect_response } from './utils.js';
 import {
 	decode_pathname,
 	decode_params,
@@ -42,6 +42,10 @@ const default_filter = () => false;
 /** @type {import('types').RequiredResolveOptions['preload']} */
 const default_preload = ({ type }) => type === 'js' || type === 'css';
 
+const page_methods = new Set(['GET', 'HEAD', 'POST']);
+
+const allowed_page_methods = new Set(['GET', 'HEAD', 'OPTIONS']);
+
 /**
  * @param {Request} request
  * @param {import('types').SSROptions} options
@@ -169,7 +173,8 @@ export async function respond(request, options, manifest, state) {
 			}
 		},
 		url,
-		isDataRequest: is_data_request
+		isDataRequest: is_data_request,
+		isSubRequest: state.depth > 0
 	};
 
 	/** @type {import('types').RequiredResolveOptions} */
@@ -342,7 +347,6 @@ export async function respond(request, options, manifest, state) {
 	}
 
 	/**
-	 *
 	 * @param {import('@sveltejs/kit').RequestEvent} event
 	 * @param {import('@sveltejs/kit').ResolveOptions} [opts]
 	 */
@@ -378,6 +382,8 @@ export async function respond(request, options, manifest, state) {
 			}
 
 			if (route) {
+				const method = /** @type {import('types').HttpMethod} */ (event.request.method);
+
 				/** @type {Response} */
 				let response;
 
@@ -394,13 +400,50 @@ export async function respond(request, options, manifest, state) {
 				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
 					response = await render_endpoint(event, await route.endpoint(), state);
 				} else if (route.page) {
-					response = await render_page(event, route.page, options, manifest, state, resolve_opts);
+					if (page_methods.has(method)) {
+						response = await render_page(event, route.page, options, manifest, state, resolve_opts);
+					} else {
+						const allowed_methods = new Set(allowed_page_methods);
+						const node = await manifest._.nodes[route.page.leaf]();
+						if (node?.server?.actions) {
+							allowed_methods.add('POST');
+						}
+
+						if (method === 'OPTIONS') {
+							// This will deny CORS preflight requests implicitly because we don't
+							// add the required CORS headers to the response.
+							response = new Response(null, {
+								status: 204,
+								headers: {
+									allow: Array.from(allowed_methods.values()).join(', ')
+								}
+							});
+						} else {
+							const mod = [...allowed_methods].reduce((acc, curr) => {
+								acc[curr] = true;
+								return acc;
+							}, /** @type {Record<string, any>} */ ({}));
+							response = method_not_allowed(mod, method);
+						}
+					}
 				} else {
 					// a route will always have a page or an endpoint, but TypeScript
 					// doesn't know that
 					throw new Error('This should never happen');
 				}
 
+				// If the route contains a page and an endpoint, we need to add a
+				// `Vary: Accept` header to the response because of browser caching
+				if (request.method === 'GET' && route.page && route.endpoint) {
+					const vary = response.headers
+						.get('vary')
+						?.split(',')
+						?.map((v) => v.trim().toLowerCase());
+					if (!(vary?.includes('accept') || vary?.includes('*'))) {
+						response.headers.append('Vary', 'Accept');
+					}
+				}
+
 				return response;
 			}
 

package/src/runtime/server/utils.js

@@ -4,6 +4,7 @@ import { coalesce_to_error } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
 import { HttpError } from '../control.js';
 import { fix_stack_trace } from '../shared-server.js';
+import { ENDPOINT_METHODS } from '../../constants.js';
 
 /** @param {any} body */
 export function is_pojo(body) {
@@ -34,9 +35,7 @@ export function method_not_allowed(mod, method) {
 
 /** @param {Partial<Record<import('types').HttpMethod, any>>} mod */
 export function allowed_methods(mod) {
-	const allowed = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].filter(
-		(method) => method in mod
-	);
+	const allowed = Array.from(ENDPOINT_METHODS).filter((method) => method in mod);
 
 	if ('GET' in mod || 'HEAD' in mod) allowed.push('HEAD');
 

package/src/types/internal.d.ts

@@ -336,6 +336,7 @@ export interface SSROptions {
 	track_server_fetches: boolean;
 	embedded: boolean;
 	env_public_prefix: string;
+	env_private_prefix: string;
 	hooks: ServerHooks;
 	preload_strategy: ValidatedConfig['kit']['output']['preloadStrategy'];
 	root: SSRComponent['default'];

package/src/types/synthetic/$env+dynamic+private.md

@@ -1,4 +1,4 @@
-This module provides access to runtime environment variables, as defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/master/packages/adapter-node) (or running [`vite preview`](https://kit.svelte.dev/docs/cli)), this is equivalent to `process.env`. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).
+This module provides access to runtime environment variables, as defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/master/packages/adapter-node) (or running [`vite preview`](https://kit.svelte.dev/docs/cli)), this is equivalent to `process.env`. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://kit.svelte.dev/docs/configuration#env) (if configured).
 
 This module cannot be imported into client-side code.
 

package/src/types/synthetic/$env+static+private.md

@@ -1,4 +1,4 @@
-Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), this module cannot be imported into client-side code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).
+Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), this module cannot be imported into client-side code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://kit.svelte.dev/docs/configuration#env) (if configured).
 
 _Unlike_ [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), the values exported from this module are statically injected into your bundle at build time, enabling optimisations like dead code elimination.
 

package/src/utils/env.js

@@ -0,0 +1,33 @@
+/**
+ * @param {Record<string, string>} env
+ * @param {{
+ * 		public_prefix: string;
+ * 		private_prefix: string;
+ * }} prefixes
+ * @returns {Record<string, string>}
+ */
+export function filter_private_env(env, { public_prefix, private_prefix }) {
+	return Object.fromEntries(
+		Object.entries(env).filter(
+			([k]) =>
+				k.startsWith(private_prefix) && (public_prefix === '' || !k.startsWith(public_prefix))
+		)
+	);
+}
+
+/**
+ * @param {Record<string, string>} env
+ * @param {{
+ * 		public_prefix: string;
+ *    private_prefix: string;
+ * }} prefixes
+ * @returns {Record<string, string>}
+ */
+export function filter_public_env(env, { public_prefix, private_prefix }) {
+	return Object.fromEntries(
+		Object.entries(env).filter(
+			([k]) =>
+				k.startsWith(public_prefix) && (private_prefix === '' || !k.startsWith(private_prefix))
+		)
+	);
+}

package/src/utils/exports.js

@@ -78,6 +78,7 @@ const valid_server_exports = new Set([
 	'PUT',
 	'DELETE',
 	'OPTIONS',
+	'HEAD',
 	'prerender',
 	'trailingSlash',
 	'config',

package/src/version.js

@@ -0,0 +1,4 @@
+// generated during release, do not modify
+
+/** @type {string} */
+export const VERSION = '1.22.0';

package/types/index.d.ts

@@ -326,6 +326,11 @@ declare module '@sveltejs/kit' {
 			 * @default "PUBLIC_"
 			 */
 			publicPrefix?: string;
+			/**
+			 * A prefix that signals that an environment variable is unsafe to expose to client-side code. Environment variables matching neither the public nor the private prefix will be discarded completely. See [`$env/static/private`](/docs/modules#$env-static-private) and [`$env/dynamic/private`](/docs/modules#$env-dynamic-private).
+			 * @default ""
+			 */
+			privatePrefix?: string;
 		};
 		/**
 		 * Where to find various files within your project.
@@ -403,7 +408,7 @@ declare module '@sveltejs/kit' {
 			/**
 			 * SvelteKit will preload the JavaScript modules needed for the initial page to avoid import 'waterfalls', resulting in faster application startup. There
 			 * are three strategies with different trade-offs:
-			 * - `modulepreload` - uses `<link rel="modulepreload">`. This delivers the best results in Chromium-based browsers, but is currently ignored by Firefox and Safari (though support is coming to Safari soon).
+			 * - `modulepreload` - uses `<link rel="modulepreload">`. This delivers the best results in Chromium-based browsers, in Firefox 115+, and Safari 17+. It is ignored in older browsers.
 			 * - `preload-js` - uses `<link rel="preload">`. Prevents waterfalls in Chromium and Safari, but Chromium will parse each module twice (once as a script, once as a module). Causes modules to be requested twice in Firefox. This is a good setting if you want to maximise performance for users on iOS devices at the cost of a very slight degradation for Chromium users.
 			 * - `preload-mjs` - uses `<link rel="preload">` but with the `.mjs` extension which prevents double-parsing in Chromium. Some static webservers will fail to serve .mjs files with a `Content-Type: application/javascript` header, which will cause your application to break. If that doesn't apply to you, this is the option that will deliver the best performance for the largest number of users, until `modulepreload` is more widely supported.
 			 * @default "modulepreload"
@@ -775,7 +780,7 @@ declare module '@sveltejs/kit' {
 
 	/**
 	 * - `enter`: The app has hydrated
-	 * - `form`: The user submitted a `<form>`
+	 * - `form`: The user submitted a `<form>` with a GET method
 	 * - `leave`: The user is leaving the app by closing the tab or using the back/forward buttons to go to a different document
 	 * - `link`: Navigation was triggered by a link click
 	 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
@@ -966,6 +971,10 @@ declare module '@sveltejs/kit' {
 		 * related to the data request in this case. Use this property instead if the distinction is important to you.
 		 */
 		isDataRequest: boolean;
+		/**
+		 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
+		 */
+		isSubRequest: boolean;
 	}
 
 	/**
@@ -1784,6 +1793,7 @@ declare module '@sveltejs/kit' {
 		track_server_fetches: boolean;
 		embedded: boolean;
 		env_public_prefix: string;
+		env_private_prefix: string;
 		hooks: ServerHooks;
 		preload_strategy: ValidatedConfig['kit']['output']['preloadStrategy'];
 		root: SSRComponent['default'];
@@ -1894,6 +1904,7 @@ declare module '@sveltejs/kit' {
 	 * ```
 	 * */
 	export function resolvePath(id: string, params: Record<string, string | undefined>): string;
+	export const VERSION: string;
 }
 
 declare module '@sveltejs/kit/hooks' {

package/types/index.d.ts.map

@@ -108,6 +108,7 @@
 		"text",
 		"fail",
 		"resolvePath",
+		"VERSION",
 		"sequence",
 		"getRequest",
 		"setResponse",
@@ -137,6 +138,7 @@
 		"../src/types/private.d.ts",
 		"../src/types/internal.d.ts",
 		"../src/exports/index.js",
+		"../src/version.js",
 		"../src/exports/hooks/sequence.js",
 		"../src/exports/node/index.js",
 		"../src/exports/node/polyfills.js",
@@ -159,7 +161,8 @@
 		null,
 		null,
 		null,
+		null,
 		null
 	],
-	"mappings": "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"
+	"mappings": "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"
 }