@sveltejs/kit 3.0.0-next.1 → 3.0.0-next.3

package/src/exports/vite/index.js

@@ -1,7 +1,7 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { Adapter, EnvVarConfig, KitConfig } from '@sveltejs/kit' */
 /** @import { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
 /** @import { PreprocessorGroup } from 'svelte/compiler' */
-/** @import { Plugin, ResolvedConfig, UserConfig, ViteDevServer } from 'vite' */
+/** @import { Plugin, Manifest, ResolvedConfig, UserConfig, ViteDevServer, Rolldown, EnvironmentOptions } from 'vite' */
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
@@ -23,16 +23,16 @@ import { create_assets } from '../../core/sync/create_manifest_data/index.js';
 import { runtime_directory, logger } from '../../core/utils.js';
 import { generate_manifest } from '../../core/generate_manifest/index.js';
 import { build_server_nodes } from './build/build_server.js';
-import { assets_base, find_deps, resolve_symlinks } from './build/utils.js';
+import { find_deps, resolve_symlinks } from './build/utils.js';
 import { dev } from './dev/index.js';
 import { preview } from './preview/index.js';
 import {
 	error_for_missing_config,
 	get_config_aliases,
 	normalize_id,
-	stackless,
 	strip_virtual_prefix
 } from './utils.js';
+import { stackless } from '../../utils/error.js';
 import { write_client_manifest } from '../../core/sync/write_client_manifest.js';
 import prerender from '../../core/postbuild/prerender.js';
 import analyse from '../../core/postbuild/analyse.js';
@@ -147,7 +147,7 @@ let vite_plugin_svelte;
 /**
  * Returns the SvelteKit Vite plugins.
  * Since version 2.62.0 you can pass [configuration](configuration) directly, in which case `svelte.config.js` is ignored.
- * @param {import('@sveltejs/kit').KitConfig & Omit<SvelteConfig, 'onwarn'>} [config]
+ * @param {KitConfig & Omit<SvelteConfig, 'onwarn'>} [config]
  * @returns {Promise<Plugin[]>}
  */
 export async function sveltekit(config) {
@@ -190,7 +190,7 @@ export async function sveltekit(config) {
 	];
 }
 
-/** @param {import('vite').UserConfig | import('vite').ResolvedConfig} vite_config */
+/** @param {UserConfig | ResolvedConfig} vite_config */
 function resolve_root(vite_config) {
 	return posixify(vite_config.root ? path.resolve(vite_config.root) : process.cwd());
 }
@@ -199,10 +199,10 @@ function resolve_root(vite_config) {
  * Resolves the Svelte config using the `vite.config.root` setting before any
  * of our other plugins try to access the config objects
  * @param {{
- *   vite_plugin_svelte_options: import('@sveltejs/vite-plugin-svelte').Options;
+ *   vite_plugin_svelte_options: Options;
  * 	 svelte_config: import('types').ValidatedConfig;
  * }} options
- * @return {import('vite').Plugin}
+ * @return {Plugin}
  */
 function plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }) {
 	return {
@@ -214,7 +214,7 @@ function plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }) {
 			handler(config) {
 				root = resolve_root(config);
 
-				/** @type {import('@sveltejs/vite-plugin-svelte').Options['preprocess']} */
+				/** @type {Options['preprocess']} */
 				let preprocess = svelte_config.preprocess;
 				if (Array.isArray(preprocess)) {
 					preprocess = [...preprocess, warning_preprocessor];
@@ -253,8 +253,8 @@ function plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }) {
  *
  * @param {object} opts
  * @param {import('types').ValidatedConfig} opts.svelte_config options are only resolved after the Vite `config` hook runs
- * @param {import('@sveltejs/kit').Adapter | undefined} opts.adapter
- * @return {import('vite').Plugin[]}
+ * @param {Adapter | undefined} opts.adapter
+ * @return {Plugin[]}
  */
 function kit({ svelte_config, adapter }) {
 	/** @type {typeof import('vite')} */
@@ -478,9 +478,7 @@ function kit({ svelte_config, adapter }) {
 
 					// These Kit dependencies are packaged as CommonJS, which means they must always be externalized.
 					// Without this, the tests will still pass but `pnpm dev` will fail in projects that link `@sveltejs/kit`.
-					/** @type {NonNullable<import('vite').UserConfig['ssr']>} */ (new_config.ssr).external = [
-						'cookie'
-					];
+					/** @type {NonNullable<UserConfig['ssr']>} */ (new_config.ssr).external = ['cookie'];
 				}
 
 				warn_overridden_config(config, new_config);
@@ -959,8 +957,10 @@ function kit({ svelte_config, adapter }) {
 		}
 	};
 
-	/** @type {import('vite').Manifest} */
-	let client_manifest;
+	/** @type {Manifest} */
+	let vite_server_manifest;
+	/** @type {Manifest | null} */
+	let vite_client_manifest = null;
 	/** @type {import('types').Prerendered} */
 	let prerendered;
 
@@ -971,7 +971,7 @@ function kit({ svelte_config, adapter }) {
 
 	/**
 	 * Creates the service worker virtual modules
-	 * @type {import('vite').Plugin}
+	 * @type {Plugin}
 	 */
 	const plugin_service_worker = {
 		name: 'vite-plugin-sveltekit-service-worker',
@@ -996,8 +996,9 @@ function kit({ svelte_config, adapter }) {
 		load(id) {
 			if (!build) {
 				build = new Set();
-				for (const key in client_manifest) {
-					const { file, css = [], assets = [] } = client_manifest[key];
+				const manifest = vite_client_manifest ?? vite_server_manifest;
+				for (const key in manifest) {
+					const { file, css = [], assets = [] } = manifest[key];
 					build.add(file);
 					css.forEach((file) => build.add(file));
 					assets.forEach((file) => build.add(file));
@@ -1185,10 +1186,8 @@ function kit({ svelte_config, adapter }) {
 
 					const inline = svelte_config.kit.output.bundleStrategy === 'inline';
 
-					const config_base = assets_base(kit);
-
 					/** @type {string} */
-					const base = kit.paths.assets || kit.paths.base || '/';
+					const base = (kit.paths.assets || kit.paths.base) + '/';
 					const root_to_assets = prefix + '/assets/';
 					const assets_to_root =
 						prefix
@@ -1198,7 +1197,7 @@ function kit({ svelte_config, adapter }) {
 
 					new_config = {
 						appType: 'custom',
-						base: config_base,
+						base: './',
 						build: {
 							cssCodeSplit: !inline,
 							cssMinify:
@@ -1282,43 +1281,36 @@ function kit({ svelte_config, adapter }) {
 							}
 						},
 						experimental: {
-							// we can't change the base path per environment so we're setting the
-							// base prefix for files here ourselves
-							renderBuiltUrl:
-								// if the Vite base is relative, we need to ensure paths used during SSR are absolute
-								config_base === './'
-									? (filename, { ssr }) => {
-											if (ssr) return base + filename;
-										}
-									: // but if the Vite base is absolute, we just need to ensure
-										// client paths are relative rather than absolute
-										(filename, { ssr, hostType }) => {
-											if (ssr) return;
-
-											if (hostType === 'js') {
-												// We could always use a relative asset base path here, but it's better for performance not to.
-												// E.g. Vite generates `new URL('/asset.png', import.meta).href` for a relative path vs just '/asset.png'.
-												// That's larger and takes longer to run and also causes an HTML diff between SSR and client
-												// causing us to do a more expensive hydration check.
-												return {
-													relative: kit.paths.relative !== false || !!kit.paths.assets
-												};
-											}
-
-											// _app/immutable/assets files
-											if (filename.startsWith(root_to_assets)) {
-												return `./${filename.slice(root_to_assets.length)}`;
-											}
-
-											// static dir files
-											return assets_to_root + filename;
-										}
+							// Allows us to use relative paths in as many places as we can
+							renderBuiltUrl(filename, { ssr, hostType }) {
+								if (hostType === 'js') {
+									// SSR builds should use an absolute path in JS modules to
+									// match the default Vite behaviour
+									if (ssr) return base + filename;
+
+									// We could always use a relative asset base path here, but it's better for performance not to.
+									// E.g. Vite generates `new URL('/asset.png', import.meta).href` for a relative path vs just '/asset.png'.
+									// That's larger and takes longer to run and also causes an HTML diff between SSR and client
+									// causing us to do a more expensive hydration check.
+									return {
+										relative: kit.paths.relative !== false || !!kit.paths.assets
+									};
+								}
+
+								// _app/immutable/assets files
+								if (filename.startsWith(root_to_assets)) {
+									return `./${filename.slice(root_to_assets.length)}`;
+								}
+
+								// static dir files
+								return assets_to_root + filename;
+							}
 						},
 						publicDir: kit.files.assets
 					};
 
 					if (service_worker_entry_file) {
-						/** @type {Record<string, import('vite').EnvironmentOptions>} */ (
+						/** @type {Record<string, EnvironmentOptions>} */ (
 							new_config.environments
 						).serviceWorker = {
 							build: {
@@ -1409,15 +1401,15 @@ function kit({ svelte_config, adapter }) {
 			}
 			mkdirp(out);
 
-			const server_bundle = /** @type {import('vite').Rolldown.RolldownOutput} */ (
+			const { output: server_chunks } = /** @type {Rolldown.RolldownOutput} */ (
 				await builder.build(builder.environments.ssr)
 			);
 
 			const verbose = vite_config.logLevel === 'info';
 			const log = logger({ verbose });
 
-			/** @type {import('vite').Manifest} */
-			const server_manifest = JSON.parse(read(`${out}/server/.vite/manifest.json`));
+			/** @type {Manifest} */
+			vite_server_manifest = JSON.parse(read(`${out}/server/.vite/manifest.json`));
 
 			/** @type {import('types').BuildData} */
 			const build_data = {
@@ -1427,7 +1419,7 @@ function kit({ svelte_config, adapter }) {
 				out_dir: out,
 				service_worker: service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 				client: null,
-				server_manifest
+				server_manifest: vite_server_manifest
 			};
 
 			const manifest_path = `${out}/server/manifest-full.js`;
@@ -1443,18 +1435,30 @@ function kit({ svelte_config, adapter }) {
 				})};\n`
 			);
 
+			const assets_path = `${kit.appDir}/immutable/assets`;
+
+			// first, build server nodes without the client manifest so we can analyse it
+			build_server_nodes(
+				out,
+				kit,
+				manifest_data,
+				vite_server_manifest,
+				null,
+				assets_path,
+				server_chunks,
+				root
+			);
+
 			log.info('Analysing routes');
 
 			const { metadata } = await analyse({
 				hash: kit.router.type === 'hash',
 				manifest_path,
 				manifest_data,
-				server_manifest,
+				server_manifest: vite_server_manifest,
 				tracked_features,
 				env,
-				out,
 				remotes,
-				root,
 				vite_config_file: vite_config.configFile
 			});
 
@@ -1470,178 +1474,178 @@ function kit({ svelte_config, adapter }) {
 				metadata.nodes
 			);
 
-			const nodes = Object.values(
-				/** @type {import('types').ServerMetadata} */ (build_metadata).nodes
-			);
-
-			// Through the finished analysis we can now check if any node has server or universal load functions
-			const has_server_load = nodes.some((node) => node.has_server_load);
-			const has_universal_load = nodes.some((node) => node.has_universal_load);
-
-			if (builder.environments.client.config.define) {
-				builder.environments.client.config.define.__SVELTEKIT_HAS_SERVER_LOAD__ =
-					s(has_server_load);
-				builder.environments.client.config.define.__SVELTEKIT_HAS_UNIVERSAL_LOAD__ =
-					s(has_universal_load);
-			}
-
-			const { output: client_chunks } = /** @type {import('vite').Rolldown.RolldownOutput} */ (
-				await builder.build(builder.environments.client)
-			);
-
-			// We use `build.ssrEmitAssets` so that asset URLs created from
-			// imports in server-only modules correspond to files in the build,
-			// but we don't want to copy over CSS imports as these are already
-			// accounted for in the client bundle. In most cases it would be
-			// a no-op, but for SSR builds `url(...)` paths are handled
-			// differently (relative for client, absolute for server)
-			// resulting in different hashes, and thus duplication
-			const ssr_stylesheets = new Set(
-				Object.values(server_manifest)
-					.map((chunk) => chunk.css ?? [])
-					.flat()
-			);
-
-			const assets_path = `${kit.appDir}/immutable/assets`;
 			const server_assets = `${out}/server/${assets_path}`;
 			const client_assets = `${out}/client/${assets_path}`;
 
-			if (fs.existsSync(server_assets)) {
-				for (const file of fs.readdirSync(server_assets)) {
-					const src = `${server_assets}/${file}`;
-					const dest = `${client_assets}/${file}`;
-
-					if (fs.existsSync(dest) || ssr_stylesheets.has(`${assets_path}/${file}`)) {
-						continue;
-					}
+			const skip_client_build = manifest_data.nodes.every(
+				(node) => node.page_options?.csr === false
+			);
 
-					if (file.endsWith('.css')) {
-						// make absolute paths in CSS relative, for portability
-						const content = fs
-							.readFileSync(src, 'utf-8')
-							.replaceAll(`${kit.paths.base}/${assets_path}`, '.');
+			if (!skip_client_build) {
+				const nodes = Object.values(build_metadata.nodes);
 
-						fs.writeFileSync(src, content);
-					}
+				// Through the finished analysis we can now check if any node has server or universal load functions
+				const has_server_load = nodes.some((node) => node.has_server_load);
+				const has_universal_load = nodes.some((node) => node.has_universal_load);
 
-					copy(src, dest);
+				if (builder.environments.client.config.define) {
+					builder.environments.client.config.define.__SVELTEKIT_HAS_SERVER_LOAD__ =
+						s(has_server_load);
+					builder.environments.client.config.define.__SVELTEKIT_HAS_UNIVERSAL_LOAD__ =
+						s(has_universal_load);
 				}
-			}
 
-			/** @type {import('vite').Manifest} */
-			client_manifest = JSON.parse(read(`${out}/client/.vite/manifest.json`));
-
-			/**
-			 * @param {string} entry
-			 * @param {boolean} [add_dynamic_css]
-			 */
-			const deps_of = (entry, add_dynamic_css = false) =>
-				find_deps(client_manifest, posixify(path.relative(root, entry)), add_dynamic_css, root);
-
-			if (svelte_config.kit.output.bundleStrategy === 'split') {
-				const start = deps_of(`${runtime_directory}/client/entry.js`);
-				const app = deps_of(`${out_dir}/generated/client-optimized/app.js`);
-
-				build_data.client = {
-					start: start.file,
-					app: app.file,
-					imports: [...start.imports, ...app.imports],
-					stylesheets: [...start.stylesheets, ...app.stylesheets],
-					fonts: [...start.fonts, ...app.fonts],
-					uses_env_dynamic_public: client_chunks.some(
-						(chunk) => chunk.type === 'chunk' && chunk.modules[sveltekit_env_public_client]
-					)
-				};
+				const { output: client_chunks } = /** @type {Rolldown.RolldownOutput} */ (
+					await builder.build(builder.environments.client)
+				);
 
-				// In case of server-side route resolution, we create a purpose-built route manifest that is
-				// similar to that on the client, with as much information computed upfront so that we
-				// don't need to include any code of the actual routes in the server bundle.
-				if (svelte_config.kit.router.resolution === 'server') {
-					const nodes = manifest_data.nodes.map((node, i) => {
-						if (node.component || node.universal) {
-							const entry = `${out_dir}/generated/client-optimized/nodes/${i}.js`;
-							const deps = deps_of(entry, true);
-							const file = resolve_symlinks(
-								client_manifest,
-								`${out_dir}/generated/client-optimized/nodes/${i}.js`,
-								root
-							).chunk.file;
-
-							return { file, css: deps.stylesheets };
+				// We use `build.ssrEmitAssets` so that asset URLs created from
+				// imports in server-only modules correspond to files in the build,
+				// but we don't want to copy over CSS imports as these are already
+				// accounted for in the client bundle. In most cases it would be
+				// a no-op, but for SSR builds `url(...)` paths are handled
+				// differently (relative for client, absolute for server)
+				// resulting in different hashes, and thus duplication
+				const ssr_stylesheets = new Set(
+					Object.values(vite_server_manifest)
+						.map((chunk) => chunk.css ?? [])
+						.flat()
+				);
+
+				if (fs.existsSync(server_assets)) {
+					for (const file of fs.readdirSync(server_assets)) {
+						const src = `${server_assets}/${file}`;
+						const dest = `${client_assets}/${file}`;
+
+						if (fs.existsSync(dest) || ssr_stylesheets.has(`${assets_path}/${file}`)) {
+							continue;
 						}
-					});
-					build_data.client.nodes = nodes.map((node) => node?.file);
-					build_data.client.css = nodes.map((node) => node?.css);
-
-					build_data.client.routes = compact(
-						manifest_data.routes.map((route) => {
-							if (!route.page) return;
-
-							return {
-								id: route.id,
-								pattern: route.pattern,
-								params: route.params,
-								layouts: route.page.layouts.map((l) =>
-									l !== undefined ? [metadata.nodes[l].has_server_load, l] : undefined
-								),
-								errors: route.page.errors,
-								leaf: [metadata.nodes[route.page.leaf].has_server_load, route.page.leaf]
-							};
-						})
-					);
+
+						copy(src, dest);
+					}
 				}
-			} else {
-				const start = deps_of(`${runtime_directory}/client/bundle.js`);
-
-				build_data.client = {
-					start: start.file,
-					imports: start.imports,
-					stylesheets: start.stylesheets,
-					fonts: start.fonts,
-					uses_env_dynamic_public: client_chunks.some(
-						(chunk) => chunk.type === 'chunk' && chunk.modules[sveltekit_env_public_client]
-					)
-				};
 
-				if (svelte_config.kit.output.bundleStrategy === 'inline') {
-					const style = /** @type {import('vite').Rolldown.OutputAsset} */ (
-						client_chunks.find(
-							(chunk) =>
-								chunk.type === 'asset' && chunk.names.length === 1 && chunk.names[0] === 'style.css'
+				const vite_manifest = (vite_client_manifest = JSON.parse(
+					read(`${out}/client/.vite/manifest.json`)
+				));
+
+				/**
+				 * @param {string} entry
+				 * @param {boolean} [add_dynamic_css]
+				 */
+				const deps_of = (entry, add_dynamic_css = false) =>
+					find_deps(vite_manifest, posixify(path.relative(root, entry)), add_dynamic_css, root);
+
+				if (svelte_config.kit.output.bundleStrategy === 'split') {
+					const start = deps_of(`${runtime_directory}/client/entry.js`);
+					const app = deps_of(`${out_dir}/generated/client-optimized/app.js`);
+
+					build_data.client = {
+						start: start.file,
+						app: app.file,
+						imports: [...start.imports, ...app.imports],
+						stylesheets: [...start.stylesheets, ...app.stylesheets],
+						fonts: [...start.fonts, ...app.fonts],
+						uses_env_dynamic_public: client_chunks.some(
+							(chunk) => chunk.type === 'chunk' && chunk.modules[sveltekit_env_public_client]
 						)
-					);
+					};
 
-					build_data.client.inline = {
-						script: read(`${out}/client/${start.file}`),
-						style: /** @type {string | undefined} */ (style?.source)
+					// In case of server-side route resolution, we create a purpose-built route manifest that is
+					// similar to that on the client, with as much information computed upfront so that we
+					// don't need to include any code of the actual routes in the server bundle.
+					if (svelte_config.kit.router.resolution === 'server') {
+						const nodes = manifest_data.nodes.map((node, i) => {
+							if (node.component || node.universal) {
+								const entry = `${out_dir}/generated/client-optimized/nodes/${i}.js`;
+								const deps = deps_of(entry, true);
+								const file = resolve_symlinks(
+									vite_manifest,
+									`${out_dir}/generated/client-optimized/nodes/${i}.js`,
+									root
+								).chunk.file;
+
+								return { file, css: deps.stylesheets };
+							}
+						});
+						build_data.client.nodes = nodes.map((node) => node?.file);
+						build_data.client.css = nodes.map((node) => node?.css);
+
+						build_data.client.routes = compact(
+							manifest_data.routes.map((route) => {
+								if (!route.page) return;
+
+								return {
+									id: route.id,
+									pattern: route.pattern,
+									params: route.params,
+									layouts: route.page.layouts.map((l) =>
+										l !== undefined ? [metadata.nodes[l].has_server_load, l] : undefined
+									),
+									errors: route.page.errors,
+									leaf: [metadata.nodes[route.page.leaf].has_server_load, route.page.leaf]
+								};
+							})
+						);
+					}
+				} else {
+					const start = deps_of(`${runtime_directory}/client/bundle.js`);
+
+					build_data.client = {
+						start: start.file,
+						imports: start.imports,
+						stylesheets: start.stylesheets,
+						fonts: start.fonts,
+						uses_env_dynamic_public: client_chunks.some(
+							(chunk) => chunk.type === 'chunk' && chunk.modules[sveltekit_env_public_client]
+						)
 					};
+
+					if (svelte_config.kit.output.bundleStrategy === 'inline') {
+						const style = /** @type {Rolldown.OutputAsset} */ (
+							client_chunks.find(
+								(chunk) =>
+									chunk.type === 'asset' &&
+									chunk.names.length === 1 &&
+									chunk.names[0] === 'style.css'
+							)
+						);
+
+						build_data.client.inline = {
+							script: read(`${out}/client/${start.file}`),
+							style: /** @type {string | undefined} */ (style?.source)
+						};
+					}
 				}
-			}
 
-			// regenerate manifest now that we have client entry...
-			fs.writeFileSync(
-				manifest_path,
-				`export const manifest = ${generate_manifest({
-					build_data,
-					prerendered: [],
-					relative_path: '.',
-					routes: manifest_data.routes,
-					remotes,
-					root
-				})};\n`
-			);
+				// regenerate manifest now that we have client entry...
+				fs.writeFileSync(
+					manifest_path,
+					`export const manifest = ${generate_manifest({
+						build_data,
+						prerendered: [],
+						relative_path: '.',
+						routes: manifest_data.routes,
+						remotes,
+						root
+					})};\n`
+				);
 
-			// regenerate nodes with the client manifest...
-			build_server_nodes(
-				out,
-				kit,
-				manifest_data,
-				server_manifest,
-				client_manifest,
-				assets_path,
-				client_chunks,
-				root
-			);
+				// regenerate nodes with the client manifest...
+				build_server_nodes(
+					out,
+					kit,
+					manifest_data,
+					vite_server_manifest,
+					vite_manifest,
+					assets_path,
+					client_chunks,
+					root
+				);
+			} else {
+				copy(server_assets, client_assets);
+				copy(kit.files.assets, `${out}/client`);
+			}
 
 			// ...and prerender
 			const prerender_results = await prerender({
@@ -1661,7 +1665,7 @@ function kit({ svelte_config, adapter }) {
 				remotes,
 				metadata,
 				process.cwd(),
-				server_bundle,
+				server_chunks,
 				vite_config.build.sourcemap
 			);
 

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

@@ -1,9 +1,10 @@
+/** @import { PageOptions } from './types.js' */
 import path from 'node:path';
 import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { Parser } from 'acorn';
 import { read } from '../../../utils/filesystem.js';
 
-const valid_page_options_array = /** @type {const} */ ([
+export const valid_page_options_array = /** @type {const} */ ([
 	'ssr',
 	'prerender',
 	'csr',
@@ -16,9 +17,6 @@ const valid_page_options_array = /** @type {const} */ ([
 /** @type {Set<string>} */
 const valid_page_options = new Set(valid_page_options_array);
 
-/** @typedef {typeof valid_page_options_array[number]} ValidPageOption */
-/** @typedef {Partial<Record<ValidPageOption, any>>} PageOptions */
-
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );

package/src/exports/vite/static_analysis/types.d.ts

@@ -0,0 +1,14 @@
+import type { PrerenderOption, TrailingSlash } from 'types';
+import type { valid_page_options_array } from './index.js';
+
+type ValidPageOption = (typeof valid_page_options_array)[number];
+
+export type PageOptions = Partial<{
+	[K in ValidPageOption]: K extends 'ssr' | 'csr'
+		? boolean
+		: K extends 'prerender'
+			? PrerenderOption
+			: K extends 'trailingSlash'
+				? TrailingSlash
+				: any;
+}>;