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

package/src/exports/vite/index.js

@@ -1,7 +1,7 @@
-/** @import { Adapter, EnvVarConfig, KitConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig, KitConfig } from '@sveltejs/kit' */
 /** @import { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
 /** @import { PreprocessorGroup } from 'svelte/compiler' */
-/** @import { Plugin, Manifest, ResolvedConfig, UserConfig, ViteDevServer, Rolldown, EnvironmentOptions } from 'vite' */
+/** @import { Plugin, Manifest, ResolvedConfig, UserConfig, ViteDevServer, Rolldown } from 'vite' */
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
@@ -15,6 +15,7 @@ import {
 	create_sveltekit_env,
 	create_sveltekit_env_public,
 	resolve_explicit_env_entry,
+	create_sveltekit_env_service_worker,
 	create_sveltekit_env_service_worker_dev,
 	create_sveltekit_env_private
 } from '../../core/env.js';
@@ -53,7 +54,7 @@ import {
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
 import { should_ignore, has_children } from './static_analysis/utils.js';
-import { process_config } from '../../core/config/index.js';
+import { process_config, split_config } from '../../core/config/index.js';
 import { treeshake_prerendered_remotes } from './build/remote.js';
 
 /** @type {string} */
@@ -146,46 +147,60 @@ 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 {KitConfig & Omit<SvelteConfig, 'onwarn'>} [config]
+ * Any options that don't belong to SvelteKit are passed through to `vite-plugin-svelte`.
+ *
+ * Since version 3.0.0 you must pass [configuration](configuration) directly.
+ *
+ * Since version 2.62.0 you can pass configuration directly, in which case `svelte.config.js` is ignored.
+ *
+ * @param {KitConfig & Omit<Options, 'onwarn'> & Pick<SvelteConfig, 'vitePlugin'>} [config]
  * @returns {Promise<Plugin[]>}
  */
 export async function sveltekit(config) {
 	const cwd = process.cwd();
 
-	const { extensions, compilerOptions, vitePlugin, preprocess, ...rest } = config ?? {};
-	const svelte_config = process_config(
-		{ extensions, compilerOptions, vitePlugin, preprocess, kit: rest },
-		{ cwd, source: 'SvelteKit options from Vite config' }
-	);
-
-	const config_file = ['svelte.config.js', 'svelte.config.ts'].find((file) => fs.existsSync(file));
-
-	if (config_file) {
-		const message = `${config_file} is no longer used. Please pass configuration via the \`sveltekit(...)\` plugin in your Vite config.`;
-
-		if (!config) {
-			throw new Error(message);
-		}
-
-		console.warn(message);
+	// any options passed to the plugin that SvelteKit doesn't use itself are
+	// forwarded to vite-plugin-svelte, which does its own validation
+	const split = split_config(config ?? {});
+	const svelte_config = process_config(split.svelte_config, { cwd });
+
+	if (Array.isArray(svelte_config.preprocess)) {
+		svelte_config.preprocess.push(warning_preprocessor);
+	} else if (svelte_config.preprocess) {
+		svelte_config.preprocess = [svelte_config.preprocess, warning_preprocessor];
+	} else {
+		svelte_config.preprocess = warning_preprocessor;
 	}
 
-	/** @type {Options} */
-	const vite_plugin_svelte_options = {
-		// we don't want vite-plugin-svelte to load the config file itself because
-		// it will try to validate it without knowing that kit options are valid
+	vite_plugin_svelte = await import_peer('@sveltejs/vite-plugin-svelte', cwd);
+
+	/** @type {Partial<Options>} */
+	const inline_vps_config = {
+		preprocess: svelte_config.preprocess,
+		...(svelte_config.vitePlugin ?? {}),
+		// pass through any options that SvelteKit doesn't use itself, so that
+		// the options SvelteKit manages always take precedence
+		...split.vite_plugin_svelte_config,
+		// we don't want vite-plugin-svelte to load the svelte.config.js file because
+		// we expect options to be passed through the SvelteKit Vite plugin
 		configFile: false
 	};
 
-	vite_plugin_svelte = await import_peer('@sveltejs/vite-plugin-svelte', cwd);
+	// vite-plugin-svelte inline config options need to be added conditionally
+	// because passing undefined causes it to crash
+	if (svelte_config.extensions) {
+		inline_vps_config.extensions = svelte_config.extensions;
+	}
+
+	if (svelte_config.compilerOptions) {
+		inline_vps_config.compilerOptions = svelte_config.compilerOptions;
+	}
 
 	return [
-		plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }),
-		...vite_plugin_svelte.svelte(vite_plugin_svelte_options),
+		plugin_svelte_config(),
+		...vite_plugin_svelte.svelte(inline_vps_config),
 		...kit({
-			svelte_config,
-			adapter: svelte_config.kit.adapter
+			svelte_config
 		})
 	];
 }
@@ -196,15 +211,9 @@ 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: Options;
- * 	 svelte_config: import('types').ValidatedConfig;
- * }} options
  * @return {Plugin}
  */
-function plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }) {
+function plugin_svelte_config() {
 	return {
 		name: 'vite-plugin-sveltekit-resolve-svelte-config',
 		// make sure it runs first
@@ -214,21 +223,15 @@ function plugin_svelte_config({ vite_plugin_svelte_options, svelte_config }) {
 			handler(config) {
 				root = resolve_root(config);
 
-				/** @type {Options['preprocess']} */
-				let preprocess = svelte_config.preprocess;
-				if (Array.isArray(preprocess)) {
-					preprocess = [...preprocess, warning_preprocessor];
-				} else if (preprocess) {
-					preprocess = [preprocess, warning_preprocessor];
-				} else {
-					preprocess = warning_preprocessor;
+				// TODO: mjs mts?
+				const config_file = ['svelte.config.js', 'svelte.config.ts'].find((file) =>
+					fs.existsSync(`${root}/${file}`)
+				);
+				if (config_file) {
+					throw new Error(
+						`${config_file} is no longer used. Please pass configuration via the \`sveltekit(...)\` plugin in your Vite config.`
+					);
 				}
-
-				vite_plugin_svelte_options.extensions = svelte_config.extensions;
-				vite_plugin_svelte_options.preprocess = preprocess;
-				vite_plugin_svelte_options.onwarn = svelte_config.onwarn;
-				vite_plugin_svelte_options.compilerOptions = { ...svelte_config.compilerOptions };
-				Object.assign(vite_plugin_svelte_options, svelte_config.vitePlugin);
 			}
 		},
 		// TODO: do we even need to set `root` based on the final Vite config?
@@ -253,10 +256,9 @@ 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 {Adapter | undefined} opts.adapter
  * @return {Plugin[]}
  */
-function kit({ svelte_config, adapter }) {
+function kit({ svelte_config }) {
 	/** @type {typeof import('vite')} */
 	let vite;
 
@@ -309,6 +311,9 @@ function kit({ svelte_config, adapter }) {
 	const sourcemapIgnoreList = /** @param {string} relative_path */ (relative_path) =>
 		relative_path.includes('node_modules') || relative_path.includes(kit.outDir);
 
+	/** @type {string} name for `globalThis.__sveltekit_xxx` */
+	let kit_global;
+
 	/** @type {Plugin} */
 	const plugin_setup = {
 		name: 'vite-plugin-sveltekit-setup',
@@ -336,10 +341,11 @@ function kit({ svelte_config, adapter }) {
 
 				version_hash = hash(kit.version.name);
 
-				env = loadEnv(config_env.mode, kit.env.dir, '');
+				kit_global = is_build
+					? `globalThis.__sveltekit_${version_hash}`
+					: 'globalThis.__sveltekit_dev';
 
-				service_worker_entry_file = resolve_entry(kit.files.serviceWorker);
-				parsed_service_worker = path.parse(kit.files.serviceWorker);
+				env = loadEnv(config_env.mode, kit.env.dir, '');
 
 				vite = await import_peer('vite', root);
 
@@ -350,10 +356,18 @@ function kit({ svelte_config, adapter }) {
 				const allow = new Set([
 					kit.files.lib,
 					kit.files.routes,
+					kit.files.src,
 					kit.outDir,
 					path.resolve(root, kit.files.src),
 					path.resolve(root, 'node_modules'),
-					path.resolve(process.cwd(), 'node_modules')
+					// ensures that the client entry is served even if it's located outside
+					// the local node_modules, such as the pnpm global virtual store
+					runtime_directory,
+					path.resolve('node_modules'),
+					// include the directory that contains the workspaces declaration
+					// which usually also contains hoisted packages
+					// see https://vite.dev/guide/api-javascript#searchforworkspaceroot
+					path.resolve(vite.searchForWorkspaceRoot(process.cwd()), 'node_modules')
 				]);
 
 				// We can only add directories to the allow list, so we find out
@@ -381,7 +395,7 @@ function kit({ svelte_config, adapter }) {
 						sourcemapIgnoreList,
 						watch: {
 							ignored: [
-								// Ignore all siblings of config.kit.outDir/generated
+								// Ignore all siblings of config.outDir/generated
 								`${out_dir}/!(generated)`
 							]
 						}
@@ -461,7 +475,7 @@ function kit({ svelte_config, adapter }) {
 				if (is_build) {
 					new_config.define = {
 						...define,
-						__SVELTEKIT_ADAPTER_NAME__: s(adapter?.name),
+						__SVELTEKIT_ADAPTER_NAME__: s(kit.adapter?.name),
 						__SVELTEKIT_APP_VERSION_FILE__: s(`${kit.appDir}/version.json`),
 						__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: s(kit.version.pollInterval)
 					};
@@ -471,7 +485,7 @@ function kit({ svelte_config, adapter }) {
 					new_config.define = {
 						...define,
 						__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: '0',
-						__SVELTEKIT_PAYLOAD__: 'globalThis.__sveltekit_dev',
+						__SVELTEKIT_PAYLOAD__: kit_global,
 						__SVELTEKIT_HAS_SERVER_LOAD__: 'true',
 						__SVELTEKIT_HAS_UNIVERSAL_LOAD__: 'true'
 					};
@@ -544,52 +558,28 @@ function kit({ svelte_config, adapter }) {
 			});
 		},
 
-		resolveId(id, importer) {
-			if (id === '__sveltekit/manifest') {
-				return `${out_dir}/generated/client-optimized/app.js`;
-			}
-
-			// If importing from a service-worker, only allow $service-worker & $app/env/public, but none of the other virtual modules.
-			// This check won't catch transitive imports, but it will warn when the import comes from a service-worker directly.
-			// Transitive imports will be caught during the build.
-			// TODO move this logic to plugin_guard. add a filter to this resolveId when doing so
-			// TODO allow $app/env/public
-			if (importer) {
-				const parsed_importer = path.parse(importer);
-
-				const importer_is_service_worker =
-					parsed_importer.dir === parsed_service_worker.dir &&
-					parsed_importer.name === parsed_service_worker.name;
-
-				if (
-					importer_is_service_worker &&
-					id !== '$service-worker' &&
-					id !== 'virtual:$app/env/public' &&
-					id !== '__sveltekit/env/service-worker'
-				) {
-					throw new Error(
-						`Cannot import ${normalize_id(
-							id,
-							normalized_lib,
-							normalized_cwd
-						)} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`
-					);
+		resolveId: {
+			filter: {
+				id: [exactRegex('$service-worker'), prefixRegex('__sveltekit/')]
+			},
+			handler(id) {
+				if (id === '__sveltekit/manifest') {
+					return `${out_dir}/generated/client-optimized/app.js`;
 				}
-			}
 
-			if (id === '$service-worker') {
-				// ids with :$ don't work with reverse proxies like nginx
-				return `\0virtual:${id.substring(1)}`;
-			}
+				if (id === '$service-worker') {
+					// ids with :$ don't work with reverse proxies like nginx
+					return `\0virtual:${id.substring(1)}`;
+				}
 
-			if (id === '__sveltekit/remote') {
-				return `${runtime_directory}/client/remote-functions/index.js`;
-			}
+				if (id === '__sveltekit/remote') {
+					return `${runtime_directory}/client/remote-functions/index.js`;
+				}
 
-			if (id.startsWith('__sveltekit/')) {
 				return `\0virtual:${id}`;
 			}
 		},
+
 		load: {
 			filter: {
 				id: [
@@ -603,10 +593,6 @@ function kit({ svelte_config, adapter }) {
 				]
 			},
 			handler(id) {
-				const global = is_build
-					? `globalThis.__sveltekit_${version_hash}`
-					: 'globalThis.__sveltekit_dev';
-
 				switch (id) {
 					case service_worker:
 						return create_service_worker_module(svelte_config);
@@ -618,7 +604,7 @@ function kit({ svelte_config, adapter }) {
 						return create_sveltekit_env_public(
 							explicit_env_config,
 							env,
-							`const env = ${global}.env;`
+							`const env = ${kit_global}.env;`
 						);
 
 					case sveltekit_env_public_server:
@@ -632,7 +618,15 @@ function kit({ svelte_config, adapter }) {
 						return create_sveltekit_env_private(explicit_env_config, env);
 
 					case sveltekit_env_service_worker:
-						return create_sveltekit_env_service_worker_dev(explicit_env_config, env, global);
+						return is_build
+							? create_sveltekit_env_service_worker(
+									explicit_env_config,
+									env,
+									kit_global,
+									kit.paths.base,
+									kit.appDir
+								)
+							: create_sveltekit_env_service_worker_dev(explicit_env_config, env, kit_global);
 
 					case sveltekit_server: {
 						return dedent`
@@ -656,7 +650,10 @@ function kit({ svelte_config, adapter }) {
 
 	/** @type {Map<string, Set<string>>} */
 	const import_map = new Map();
-	const server_only_pattern = /.*\.server\..+/;
+	// Matches any ID that has .server. in its filename
+	const server_only_module_pattern = /\.server\.[^/]+$/;
+	// Matches any ID that has /server/ in its path
+	const server_only_directory_pattern = /\/server\//;
 
 	/**
 	 * Ensures that client-side code can't accidentally import server-side code,
@@ -706,8 +703,8 @@ function kit({ svelte_config, adapter }) {
 				id: [
 					exactRegex(app_server),
 					exactRegex(app_env_private),
-					/\/server\//,
-					new RegExp(`${server_only_pattern.source}$`)
+					server_only_module_pattern,
+					server_only_directory_pattern
 				]
 			},
 			handler(id) {
@@ -722,8 +719,8 @@ function kit({ svelte_config, adapter }) {
 				const is_server_only =
 					normalized === '$app/env/private' ||
 					normalized === '$app/server' ||
-					normalized.startsWith('$lib/server/') ||
-					(is_internal && server_only_pattern.test(path.basename(id)));
+					(normalized.startsWith('$lib/') && server_only_directory_pattern.test(id)) ||
+					(is_internal && server_only_module_pattern.test(id));
 
 				// skip .server.js files outside the cwd or in node_modules, as the filename might not mean 'server-only module' in this context
 				// TODO: address https://github.com/sveltejs/kit/issues/12529
@@ -965,7 +962,7 @@ function kit({ svelte_config, adapter }) {
 	let prerendered;
 
 	/** @type {Set<string>} */
-	let build;
+	let build_files;
 	/** @type {string} */
 	let service_worker_code;
 
@@ -976,43 +973,132 @@ function kit({ svelte_config, adapter }) {
 	const plugin_service_worker = {
 		name: 'vite-plugin-sveltekit-service-worker',
 
+		config(config) {
+			service_worker_entry_file = resolve_entry(kit.files.serviceWorker);
+			parsed_service_worker = path.parse(kit.files.serviceWorker);
+
+			if (!service_worker_entry_file) return;
+
+			if (kit.paths.assets) {
+				throw new Error('Cannot use service worker alongside config.paths.assets');
+			}
+
+			const user_service_worker_output_config =
+				config.environments?.serviceWorker?.build?.rolldownOptions?.output;
+
+			/** @type {import('vite').UserConfig} */
+			const new_config = {
+				environments: {
+					serviceWorker: {
+						build: {
+							modulePreload: false,
+							rolldownOptions: {
+								external: [`${kit.paths.base}/${kit.appDir}/env.js`],
+								input: {
+									'service-worker': service_worker_entry_file
+								},
+								output: {
+									format: 'es',
+									entryFileNames: 'service-worker.js',
+									assetFileNames: `${kit.appDir}/immutable/assets/[name].[hash][extname]`,
+									codeSplitting:
+										(Array.isArray(user_service_worker_output_config)
+											? user_service_worker_output_config[0].codeSplitting
+											: user_service_worker_output_config?.codeSplitting) ?? false
+								}
+							},
+							outDir: `${out}/client`,
+							minify: initial_config.build?.minify,
+							// avoid overwriting the client build Vite manifest
+							manifest: '.vite/service-worker-manifest.json'
+						},
+						consumer: 'client'
+					}
+				}
+			};
+
+			warn_overridden_config(config, new_config);
+
+			return new_config;
+		},
+
+		// the serviceWorker environment only applies during build because Vite currently
+		// only supports the default client environment during development
 		applyToEnvironment(environment) {
 			return environment.name === 'serviceWorker';
 		},
 
-		resolveId: {
-			handler(id) {
-				if (id.startsWith('$app/') || id === '$service-worker') {
-					// ids with :$ don't work with reverse proxies like nginx
-					return `\0virtual:${id.substring(1)}`;
-				}
+		resolveId(id, importer) {
+			// If importing from a service-worker, only allow $service-worker & $app/env/public, but none of the other virtual modules.
+			// This check won't catch transitive imports, but it will warn when the import comes from a service-worker directly.
+			// Transitive imports will be caught during the build.
+			if (importer) {
+				const parsed_importer = path.parse(importer);
+
+				const importer_is_service_worker =
+					parsed_importer.dir === parsed_service_worker.dir &&
+					parsed_importer.name === parsed_service_worker.name;
 
-				if (id.startsWith('__sveltekit')) {
-					return `\0virtual:${id}`;
+				if (
+					importer_is_service_worker &&
+					id !== '$service-worker' &&
+					id !== 'virtual:$app/env/public' &&
+					id !== '__sveltekit/env/service-worker'
+				) {
+					throw new Error(
+						`Cannot import ${normalize_id(
+							id,
+							normalized_lib,
+							normalized_cwd
+						)} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`
+					);
 				}
 			}
+
+			if (id.startsWith('$app/') || id === '$service-worker') {
+				// ids with :$ don't work with reverse proxies like nginx
+				return `\0virtual:${id.substring(1)}`;
+			}
+
+			if (id.startsWith('__sveltekit')) {
+				return `\0virtual:${id}`;
+			}
 		},
 
-		load(id) {
-			if (!build) {
-				build = new Set();
-				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));
-				}
+		load: {
+			filter: {
+				id: [prefixRegex('\0virtual:')]
+			},
+			handler(id) {
+				if (!build_files) {
+					build_files = new Set();
+					const manifest = vite_client_manifest ?? vite_server_manifest;
+					for (const key in manifest) {
+						const { file, css = [], assets = [] } = manifest[key];
+						build_files.add(file);
+						css.forEach((file) => build_files.add(file));
+						assets.forEach((file) => build_files.add(file));
+					}
+
+					if (kit.output.bundleStrategy === 'inline') {
+						// the bundle and stylesheet are inlined into the page and their files
+						// deleted, so they must not appear in the list of cacheable assets
+						for (const file of build_files) {
+							if (!fs.existsSync(`${out}/client/${file}`)) {
+								build_files.delete(file);
+							}
+						}
+					}
 
-				// in a service worker, `location` is the location of the service worker itself,
-				// which is guaranteed to be `<base>/service-worker.js`
-				const base = "location.pathname.split('/').slice(0, -1).join('/')";
+					// in a service worker, `location` is the location of the service worker itself,
+					// which is guaranteed to be `<base>/service-worker.js`
+					const base = "location.pathname.split('/').slice(0, -1).join('/')";
 
-				service_worker_code = dedent`
+					service_worker_code = dedent`
 					export const base = /*@__PURE__*/ ${base};
 
 					export const build = [
-						${Array.from(build)
+						${Array.from(build_files)
 							.map((file) => `base + ${s(`/${file}`)}`)
 							.join(',\n')}
 					];
@@ -1029,34 +1115,41 @@ function kit({ svelte_config, adapter }) {
 					];
 
 					export const version = ${s(kit.version.name)};
-				`;
-			}
-
-			if (!id.startsWith('\0virtual:')) return;
+					`;
+				}
 
-			const global = is_build
-				? `globalThis.__sveltekit_${version_hash}`
-				: 'globalThis.__sveltekit_dev';
+				if (id === service_worker) {
+					return service_worker_code;
+				}
 
-			if (id === service_worker) {
-				return service_worker_code;
-			}
+				if (id === sveltekit_env_service_worker) {
+					return is_build
+						? create_sveltekit_env_service_worker(
+								explicit_env_config,
+								env,
+								kit_global,
+								kit.paths.base,
+								kit.appDir
+							)
+						: create_sveltekit_env_service_worker_dev(explicit_env_config, env, kit_global);
+				}
 
-			if (id === sveltekit_env_service_worker) {
-				return create_sveltekit_env_service_worker_dev(explicit_env_config, env, global);
-			}
+				if (id === sveltekit_env_public_client) {
+					return create_sveltekit_env_public(
+						explicit_env_config,
+						env,
+						`const env = ${kit_global}.env;`
+					);
+				}
 
-			if (id === sveltekit_env_public_client) {
-				return create_sveltekit_env_public(explicit_env_config, env, `const env = ${global}.env;`);
+				const normalized_cwd = vite.normalizePath(vite_config.root);
+				const normalized_lib = vite.normalizePath(kit.files.lib);
+				const relative = normalize_id(id, normalized_lib, normalized_cwd);
+				const stripped = strip_virtual_prefix(relative);
+				throw new Error(
+					`Cannot import ${stripped} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`
+				);
 			}
-
-			const normalized_cwd = vite.normalizePath(vite_config.root);
-			const normalized_lib = vite.normalizePath(kit.files.lib);
-			const relative = normalize_id(id, normalized_lib, normalized_cwd);
-			const stripped = strip_virtual_prefix(relative);
-			throw new Error(
-				`Cannot import ${stripped} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`
-			);
 		}
 	};
 
@@ -1069,10 +1162,11 @@ function kit({ svelte_config, adapter }) {
 				id: service_worker_entry_file || '<skip>'
 			},
 			handler(code) {
-				// in dev, we prepend the service worker with an import that
-				// configures `env`, in case `$app/env/public` is imported,
-				// in prod, where we currently use non-module service
-				// workers, we have to use `importScripts` instead
+				// prepend the service worker with an import that configures
+				// `env`, in case `$app/env/public` is imported. In production
+				// this is required: dynamic public env vars aren't known at
+				// build time, so `env.js` is loaded at runtime. In dev, the
+				// imported module just inlines the current values instead.
 				return {
 					code: `import '__sveltekit/env/service-worker';\n${code}`
 				};
@@ -1106,6 +1200,7 @@ function kit({ svelte_config, adapter }) {
 					const server_input = {
 						index: `${runtime_directory}/server/index.js`,
 						internal: `${out_dir}/generated/server/internal.js`,
+						env: '__sveltekit/env',
 						['remote-entry']: `${runtime_directory}/app/server/remote/index.js`
 					};
 
@@ -1156,8 +1251,8 @@ function kit({ svelte_config, adapter }) {
 						path.join(kit.files.src, 'instrumentation.server')
 					);
 					if (server_instrumentation) {
-						if (adapter && !adapter.supports?.instrumentation?.()) {
-							throw new Error(`${server_instrumentation} is unsupported in ${adapter.name}.`);
+						if (kit.adapter && !kit.adapter.supports?.instrumentation?.()) {
+							throw new Error(`${server_instrumentation} is unsupported in ${kit.adapter.name}.`);
 						}
 						if (!kit.experimental.instrumentation.server) {
 							error_for_missing_config(
@@ -1195,9 +1290,16 @@ function kit({ svelte_config, adapter }) {
 							.map(() => '..')
 							.join('/') + '/../';
 
+					const relative = kit.paths.relative !== false || !!kit.paths.assets;
+
 					new_config = {
 						appType: 'custom',
-						base: './',
+						// Affects how Vite loads JS assets on the client.
+						// If the initial HTML we render uses an absolute path for assets,
+						// the additional chunks Vite loads must also use an absolute path.
+						// Otherwise, you end up with additional chunks being loaded relative
+						// to the current chunk rather than the root.
+						base: relative ? './' : base,
 						build: {
 							cssCodeSplit: !inline,
 							cssMinify:
@@ -1261,7 +1363,8 @@ function kit({ svelte_config, adapter }) {
 											format: inline ? 'iife' : 'esm',
 											entryFileNames: `${prefix}/[name].[hash].js`,
 											chunkFileNames: `${prefix}/chunks/[hash].js`,
-											codeSplitting: svelte_config.kit.output.bundleStrategy === 'split'
+											codeSplitting:
+												svelte_config.kit.output.bundleStrategy === 'split' ? undefined : false
 										},
 										// This silences Rolldown warnings about not supporting `import.meta`
 										// for the `iife` output format. We don't care because it's
@@ -1276,7 +1379,7 @@ function kit({ svelte_config, adapter }) {
 									}
 								},
 								define: {
-									__SVELTEKIT_PAYLOAD__: `globalThis.__sveltekit_${version_hash}`
+									__SVELTEKIT_PAYLOAD__: kit_global
 								}
 							}
 						},
@@ -1292,9 +1395,7 @@ function kit({ svelte_config, adapter }) {
 									// 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
-									};
+									return { relative };
 								}
 
 								// _app/immutable/assets files
@@ -1308,29 +1409,6 @@ function kit({ svelte_config, adapter }) {
 						},
 						publicDir: kit.files.assets
 					};
-
-					if (service_worker_entry_file) {
-						/** @type {Record<string, EnvironmentOptions>} */ (
-							new_config.environments
-						).serviceWorker = {
-							build: {
-								modulePreload: false,
-								rolldownOptions: {
-									input: {
-										'service-worker': service_worker_entry_file
-									},
-									output: {
-										entryFileNames: 'service-worker.js',
-										assetFileNames: `${kit.appDir}/immutable/assets/[name].[hash][extname]`,
-										codeSplitting: false
-									}
-								},
-								outDir: `${out}/client`,
-								minify: initial_config.build?.minify
-							},
-							consumer: 'client'
-						};
-					}
 				} else {
 					new_config = {
 						appType: 'custom',
@@ -1359,7 +1437,7 @@ function kit({ svelte_config, adapter }) {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
 		 */
 		async configureServer(vite) {
-			return await dev(vite, vite_config, svelte_config, () => remotes, root, adapter);
+			return await dev(vite, vite_config, svelte_config, () => remotes, root);
 		},
 
 		/**
@@ -1367,7 +1445,7 @@ function kit({ svelte_config, adapter }) {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configurepreviewserver
 		 */
 		configurePreviewServer(vite) {
-			return preview(vite, vite_config, svelte_config, adapter);
+			return preview(vite, vite_config, svelte_config);
 		},
 
 		renderChunk(code, chunk) {
@@ -1536,6 +1614,18 @@ function kit({ svelte_config, adapter }) {
 				const deps_of = (entry, add_dynamic_css = false) =>
 					find_deps(vite_manifest, posixify(path.relative(root, entry)), add_dynamic_css, root);
 
+				const has_explicit_dynamic_public_env = Object.values(explicit_env_config ?? {}).some(
+					(variable) => variable.public && !variable.static
+				);
+
+				// the app only depends on runtime public env if it imports `$app/env/public`
+				// *and* at least one public env var is actually dynamic (non-static)
+				const uses_env_dynamic_public =
+					has_explicit_dynamic_public_env &&
+					client_chunks.some(
+						(chunk) => chunk.type === 'chunk' && chunk.modules[sveltekit_env_public_client]
+					);
+
 				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`);
@@ -1546,9 +1636,7 @@ function kit({ svelte_config, adapter }) {
 						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]
-						)
+						uses_env_dynamic_public
 					};
 
 					// In case of server-side route resolution, we create a purpose-built route manifest that is
@@ -1596,9 +1684,7 @@ function kit({ svelte_config, adapter }) {
 						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]
-						)
+						uses_env_dynamic_public
 					};
 
 					if (svelte_config.kit.output.bundleStrategy === 'inline') {
@@ -1615,6 +1701,12 @@ function kit({ svelte_config, adapter }) {
 							script: read(`${out}/client/${start.file}`),
 							style: /** @type {string | undefined} */ (style?.source)
 						};
+
+						// the bundle and stylesheet are inlined into the page, so the
+						// emitted files are never loaded
+						fs.unlinkSync(`${out}/client/${start.file}`);
+						fs.rmSync(`${out}/client/${start.file}.map`, { force: true });
+						if (style) fs.unlinkSync(`${out}/client/${style.fileName}`);
 					}
 				}
 
@@ -1637,7 +1729,7 @@ function kit({ svelte_config, adapter }) {
 					kit,
 					manifest_data,
 					vite_server_manifest,
-					vite_manifest,
+					vite_client_manifest,
 					assets_path,
 					client_chunks,
 					root
@@ -1685,17 +1777,16 @@ function kit({ svelte_config, adapter }) {
 			);
 
 			if (service_worker_entry_file) {
-				if (kit.paths.assets) {
-					throw new Error('Cannot use service worker alongside config.kit.paths.assets');
-				}
-
 				log.info('Building service worker');
 
+				// mirror client settings that we couldn't set per environment in the config hook
 				builder.environments.serviceWorker.config.define =
 					builder.environments.client.config.define;
 				builder.environments.serviceWorker.config.resolve.alias = [
 					...get_config_aliases(kit, vite_config.root)
 				];
+
+				// we have to overwrite this because it can't be configured per environment in the config hook
 				builder.environments.serviceWorker.config.experimental.renderBuiltUrl = (filename) => {
 					return {
 						runtime: `new URL(${JSON.stringify(filename)}, location.href).pathname`
@@ -1709,10 +1800,9 @@ function kit({ svelte_config, adapter }) {
 				`\nRun ${styleText(['bold', 'cyan'], 'npm run preview')} to preview your production build locally.`
 			);
 
-			if (adapter) {
+			if (kit.adapter) {
 				const { adapt } = await import('../../core/adapt/index.js');
 				await adapt(
-					adapter,
 					svelte_config,
 					build_data,
 					metadata,
@@ -1734,17 +1824,6 @@ function kit({ svelte_config, adapter }) {
 		}
 	};
 
-	/** @type {Plugin} */
-	const plugin_adapter = {
-		name: 'vite-plugin-sveltekit-adapter',
-		apply: 'build',
-		// expose the adapter so that forked processes (e.g. prerendering)
-		// can retrieve it by resolving the Vite config
-		api: {
-			adapter
-		}
-	};
-
 	return [
 		plugin_setup,
 		plugin_remote,
@@ -1752,8 +1831,7 @@ function kit({ svelte_config, adapter }) {
 		process.env.TEST !== 'true' ? plugin_guard : undefined,
 		service_worker_entry_file && plugin_service_worker_env,
 		plugin_service_worker,
-		plugin_compile,
-		plugin_adapter
+		plugin_compile
 	].filter((p) => !!p);
 }
 
@@ -1789,13 +1867,18 @@ function find_overridden_config(config, resolved_config, enforced_config, path,
 	for (const key in enforced_config) {
 		if (typeof config === 'object' && key in config && key in resolved_config) {
 			const enforced = enforced_config[key];
+			const resolved = resolved_config[key];
 
 			if (enforced === true) {
-				if (config[key] !== resolved_config[key]) {
+				// Normalize path separators before comparing to avoid false positives on Windows,
+				// where config values like `root` may use backslashes while SvelteKit uses forward slashes.
+				const a = typeof config[key] === 'string' ? posixify(config[key]) : config[key];
+				const b = typeof resolved === 'string' ? posixify(resolved) : resolved;
+				if (a !== b) {
 					out.push(path + key);
 				}
 			} else {
-				find_overridden_config(config[key], resolved_config[key], enforced, path + key + '.', out);
+				find_overridden_config(config[key], resolved, enforced, path + key + '.', out);
 			}
 		}
 	}
@@ -1810,6 +1893,7 @@ const create_service_worker_module = (config) => dedent`
 		throw new Error('This module can only be imported inside a service worker');
 	}
 
+	export const base = location.pathname.split('/').slice(0, -1).join('/');
 	export const build = [];
 	export const files = [
 		${create_assets(config)