@sveltejs/kit 2.65.1 → 2.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.65.1",
+  "version": "2.66.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -38,12 +38,12 @@
     "@types/connect": "^3.4.38",
     "@types/node": "^18.19.130",
     "@types/set-cookie-parser": "^2.4.7",
-    "dts-buddy": "^0.8.0",
+    "dts-buddy": "^0.8.1",
     "jsdom": "^26.1.0",
     "rollup": "^4.59.0",
     "svelte": "^5.56.3",
     "typescript": "^5.3.3",
-    "vite": "^6.4.2",
+    "vite": "^6.4.3",
     "vitest": "^4.1.7"
   },
   "peerDependencies": {

package/src/core/adapt/builder.js

@@ -22,7 +22,19 @@ import { reserved } from '../env.js';
 import { handle_issues, validate } from '../../exports/internal/env.js';
 
 const pipe = promisify(pipeline);
-const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.wasm', '.txt'];
+const extensions = [
+	'.html',
+	'.js',
+	'.mjs',
+	'.json',
+	'.css',
+	'.svg',
+	'.xml',
+	'.wasm',
+	'.txt',
+	'.md',
+	'.mdx'
+];
 
 /**
  * Creates the Builder which is passed to adapters for building the application.
@@ -193,12 +205,12 @@ export function create_builder({
 		},
 
 		generateEnvModule() {
-			if (!build_data.client?.uses_env_dynamic_public) return;
-
-			const dest = `${config.kit.outDir}/output/prerendered/dependencies/${config.kit.appDir}/env.js`;
 			const env = get_env(config.kit.env, vite_config.mode);
 
-			const values = config.kit.experimental.explicitEnvironmentVariables ? {} : env.public;
+			const dest = `${config.kit.outDir}/output/prerendered/dependencies/${config.kit.appDir}`;
+
+			/** @type {string} */
+			let payload;
 
 			if (config.kit.experimental.explicitEnvironmentVariables) {
 				const variables = explicit_env_config ?? {};
@@ -206,15 +218,30 @@ export function create_builder({
 				/** @type {Record<string, StandardSchemaV1.Issue[]>} */
 				const issues = {};
 
+				/** @type {Record<string, any>} */
+				const values = {};
+
 				for (const [name, config] of Object.entries(variables)) {
 					if (config.static || !config.public) continue;
 					values[name] = validate(variables, env.all[name], name, issues);
 				}
 
 				handle_issues(issues);
+
+				if (Object.keys(values).length === 0) return;
+
+				payload = devalue.uneval(values);
+
+				if (build_data.service_worker) {
+					write(`${dest}/env.script.js`, `globalThis.__sveltekit_sw={env:${payload}}`);
+				}
+			} else {
+				payload = devalue.uneval(env.public);
 			}
 
-			write(dest, `export const env=${devalue.uneval(values)}`);
+			if (build_data.client?.uses_env_dynamic_public) {
+				write(`${dest}/env.js`, `export const env=${payload}`);
+			}
 		},
 
 		generateManifest({ relativePath, routes: subset }) {

package/src/core/config/index.js

@@ -1,14 +1,72 @@
-/** @import { Config } from '@sveltejs/kit' */
+/** @import { Config, KitConfig } from '@sveltejs/kit' */
+/** @import { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
 /** @import { ValidatedConfig } from 'types' */
 /** @import { ResolvedConfig } from 'vite' */
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import * as url from 'node:url';
-import options from './options.js';
+import { options, kit_options, kit_experimental_options } from './options.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { import_peer } from '../../utils/import.js';
 
+/**
+ * Splits the config passed to the `sveltekit` Vite plugin into the options that
+ * SvelteKit processes itself and the options that are forwarded to
+ * `vite-plugin-svelte`. SvelteKit makes no assumptions about which options
+ * `vite-plugin-svelte` accepts — it plucks out its own options and passes
+ * everything else along (`vite-plugin-svelte` does its own validation).
+ * @param {KitConfig & Omit<Options, 'onwarn'> & Pick<SvelteConfig, 'vitePlugin'>} config
+ * @returns {{ svelte_config: Config, vite_plugin_svelte_config: Record<string, any> }}
+ */
+export function split_config(config) {
+	const { extensions, compilerOptions, vitePlugin, preprocess, ...rest } = config;
+
+	/** @type {KitConfig} */
+	const kit = {};
+
+	/** @type {Record<string, any>} */
+	const vite_plugin_svelte_config = {};
+
+	for (const key in rest) {
+		if (key === 'experimental') {
+			// `experimental` is a namespace that both SvelteKit and vite-plugin-svelte
+			// use, so pluck out the flags SvelteKit recognises and pass the rest along
+			const experimental = /** @type {Record<string, any>} */ (rest[key]) ?? {};
+
+			/** @type {Record<string, any>} */
+			const kit_experimental = {};
+			/** @type {Record<string, any>} */
+			const vps_experimental = {};
+
+			for (const flag in experimental) {
+				if (kit_experimental_options.includes(flag)) {
+					kit_experimental[flag] = experimental[flag];
+				} else {
+					vps_experimental[flag] = experimental[flag];
+				}
+			}
+
+			if (Object.keys(kit_experimental).length > 0) {
+				kit.experimental = kit_experimental;
+			}
+			if (Object.keys(vps_experimental).length > 0) {
+				vite_plugin_svelte_config.experimental = vps_experimental;
+			}
+		} else if (kit_options.includes(key)) {
+			// @ts-expect-error - we've verified this is one of SvelteKit's own options
+			kit[key] = rest[key];
+		} else {
+			vite_plugin_svelte_config[key] = /** @type {Record<string, any>} */ (rest)[key];
+		}
+	}
+
+	return {
+		svelte_config: { extensions, compilerOptions, vitePlugin, preprocess, kit },
+		vite_plugin_svelte_config
+	};
+}
+
 /**
  * Loads the template (src/app.html by default) and validates that it has the
  * required content.

package/src/core/config/options.js

@@ -45,7 +45,7 @@ const directives = object({
 });
 
 /** @type {Validator} */
-const options = object(
+export const options = object(
 	{
 		extensions: validate(['.svelte'], (input, keypath) => {
 			if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
@@ -326,6 +326,17 @@ const options = object(
 	true
 );
 
+// Derive the names of SvelteKit's own config options from the schema, so they
+// stay in sync automatically. These are used to separate Kit's options from
+// `vite-plugin-svelte`'s options when config is passed via the Vite plugin.
+const defaults = /** @type {Record<string, any>} */ (options({}, 'config'));
+
+/** The names of the options that live under the `kit` namespace */
+export const kit_options = Object.keys(defaults.kit);
+
+/** The names of the options that live under the `kit.experimental` namespace */
+export const kit_experimental_options = Object.keys(defaults.kit.experimental);
+
 /**
  * @param {Validator} fn
  * @param {(keypath: string) => string} get_message
@@ -502,5 +513,3 @@ function assert_trusted_types_supported(keypath) {
 		);
 	}
 }
-
-export default options;

package/src/core/env.js

@@ -72,6 +72,10 @@ export async function load_explicit_env(kit, file, mode) {
 	/** @type {Record<string, EnvVarConfig<any>>} */
 	let variables;
 
+	/** @type {import('../runtime/app/env/internal.js')} */ (
+		await server.ssrLoadModule(`${runtime_directory}/app/env/internal.js`)
+	).set_building();
+
 	try {
 		({ variables } = await server.ssrLoadModule(file));
 
@@ -157,7 +161,7 @@ export function create_dynamic_module(type, dev_values, disabled) {
 
 /**
  * Creates the `__sveltekit/env` module
- * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, EnvVarConfig<any> | undefined> | null} variables
  * @param {Record<string, string>} env
  * @param {string | null} entry
  */
@@ -176,7 +180,7 @@ export function create_sveltekit_env(variables, env, entry) {
 	const issues = {};
 
 	for (const [name, config] of Object.entries(variables ?? {})) {
-		if (config.static) {
+		if (config?.static) {
 			if (config.public) {
 				const value = validate(variables ?? {}, env[name], name, issues);
 				declarations.push(`explicit_public_env.${name} = ${devalue.uneval(value)};`);
@@ -186,7 +190,7 @@ export function create_sveltekit_env(variables, env, entry) {
 				`const ${name} = validate(variables, env.${name}, ${JSON.stringify(name)}, issues);`
 			);
 
-			if (config.public) {
+			if (config?.public) {
 				setters.push(`explicit_public_env.${name} = ${name};`);
 				setters.push(`rendered_env.${name} = ${name};`);
 			} else {

package/src/core/postbuild/analyse.js

@@ -58,10 +58,13 @@ async function analyse({
 	const public_env = filter_env(env, public_prefix, private_prefix);
 	internal.set_private_env(private_env);
 	internal.set_public_env(public_env);
-	internal.set_env(env);
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
+	/** @type {import('__sveltekit/env')} */
+	const { set_env } = await import(pathToFileURL(`${server_root}/server/env.js`).href);
+	set_env(env);
+
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
 		nodes: [],

package/src/core/postbuild/prerender.js

@@ -43,14 +43,18 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	/** @type {import('types').ServerInternalModule} */
 	const internal = await import(pathToFileURL(`${out}/server/internal.js`).href);
 
-	/** @type {import('types').ServerModule} */
-	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
-
 	// configure `import { building } from '$app/environment'` and `$app/env` —
 	// essential we do this before analysing the code
 	internal.set_building();
 	internal.set_prerendering();
 
+	/** @type {import('__sveltekit/env')} */
+	const { set_env } = await import(pathToFileURL(`${out}/server/env.js`).href);
+	set_env(env);
+
+	/** @type {import('types').ServerModule} */
+	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
+
 	/**
 	 * @template {{message: string}} T
 	 * @template {Omit<T, 'message'>} K
@@ -382,6 +386,12 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 		const type = headers['content-type'];
 		const is_html = response_type === REDIRECT || type === 'text/html';
 
+		if (!is_html && response.status === 200 && decoded.slice(config.paths.base.length + 1) === '') {
+			throw new Error(
+				`Cannot prerender a root +server.js that returns a non-HTML response - static hosts always serve an HTML file for \`${config.paths.base || '/'}\``
+			);
+		}
+
 		const file = output_filename(decoded, is_html);
 		const dest = `${config.outDir}/output/prerendered/${category}/${file}`;
 
@@ -499,7 +509,6 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	const public_env = filter_env(env, public_prefix, private_prefix);
 	internal.set_private_env(private_env);
 	internal.set_public_env(public_env);
-	internal.set_env(env);
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
 

package/src/core/sync/create_manifest_data/index.js

@@ -426,7 +426,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 	const indexes = new Map(nodes.map((node, i) => [node, i]));
 
-	const node_analyser = create_node_analyser();
+	const node_analyser = create_node_analyser(cwd);
 
 	// add the related layout, page, and error nodes for a route
 	for (const route of routes) {
@@ -495,7 +495,18 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 	for (const route of routes) {
 		if (route.endpoint) {
-			route.endpoint.page_options = get_page_options(route.endpoint.file);
+			route.endpoint.page_options = get_page_options(path.join(cwd, route.endpoint.file));
+		}
+
+		if (route.page && route.endpoint) {
+			const page = nodes[route.page.leaf];
+			if (page.page_options?.prerender || route.endpoint.page_options?.prerender) {
+				const endpoint_file = route.endpoint.file.split('/').pop();
+
+				throw new Error(
+					`Cannot prerender a route (${route.id}) with both a \`+page.svelte\` and a \`${endpoint_file}\``
+				);
+			}
 		}
 	}
 

package/src/core/sync/write_client_manifest.js

@@ -183,6 +183,8 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			export const decode = (type, value) => decoders[type](value);
 
 			export { default as root } from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';
+
+			export const get_error_template = () => import('../shared/error-template.js').then(m => m.default);
 		`
 	);
 

package/src/core/sync/write_server.js

@@ -17,7 +17,6 @@ import { escape_html } from '../../utils/escape.js';
  *   has_service_worker: boolean;
  *   runtime_directory: string;
  *   template: string;
- *   error_page: string;
  * }} opts
  */
 const server_template = ({
@@ -26,15 +25,14 @@ const server_template = ({
 	universal_hooks,
 	has_service_worker,
 	runtime_directory,
-	template,
-	error_page
+	template
 }) => `
 import root from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
 import { set_manifest, set_read_implementation } from '__sveltekit/server';
-import { set_env } from '__sveltekit/env';
 import { set_private_env, set_public_env } from '${runtime_directory}/shared-server.js';
+import error from '../shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
@@ -63,9 +61,7 @@ export const options = {
 				/%sveltekit\.env\.([^%]+)%/g,
 				(_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
 			)},
-		error: ({ status, message }) => ${s(error_page)
-			.replace(/%sveltekit\.status%/g, '" + status + "')
-			.replace(/%sveltekit\.error\.message%/g, '" + message + "')}
+		error
 	},
 	version_hash: ${s(hash(config.kit.version.name))}
 };
@@ -93,7 +89,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_env, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation };
+export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation };
 `;
 
 // TODO need to re-run this whenever src/app.html or src/error.html are
@@ -126,6 +122,13 @@ export function write_server(config, output) {
 		return posixify(path.relative(`${output}/server`, file));
 	}
 
+	write_if_changed(
+		`${output}/shared/error-template.js`,
+		`export default ({ status, message }) => ${s(load_error_page(config))
+			.replace(/%sveltekit\.status%/g, '" + status + "')
+			.replace(/%sveltekit\.error\.message%/g, '" + message + "')};`
+	);
+
 	// Contains the stringified version of
 	/** @type {import('types').SSROptions} */
 	write_if_changed(
@@ -137,8 +140,7 @@ export function write_server(config, output) {
 			has_service_worker:
 				config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
 			runtime_directory: relative(runtime_directory),
-			template: load_template(process.cwd(), config),
-			error_page: load_error_page(config)
+			template: load_template(process.cwd(), config)
 		})
 	);
 }

package/src/core/sync/write_tsconfig.js

@@ -122,8 +122,7 @@ export function get_tsconfig(kit) {
 			moduleResolution: 'bundler',
 			module: 'esnext',
 			noEmit: true, // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
-			target: 'esnext',
-			types: ['node']
+			target: 'esnext'
 		},
 		include: [...include],
 		exclude

package/src/exports/internal/env.js

@@ -16,7 +16,7 @@ const ASYNC_VALIDATOR = {
 };
 
 /**
- * @param {Record<string, EnvVarConfig<any>>} variables
+ * @param {Record<string, EnvVarConfig<any> | undefined>} variables
  * @param {string | undefined} value
  * @param {string} name
  * @param {Record<string, StandardSchemaV1.Issue[]>} issues

package/src/exports/public.d.ts

@@ -141,7 +141,7 @@ export interface Builder {
 	generateFallback: (dest: string) => Promise<void>;
 
 	/**
-	 * Generate a module exposing build-time environment variables as `$env/dynamic/public` if the app uses it.
+	 * Generate a module exposing build-time environment variables as `$env/dynamic/public` or `$app/env/public` if the app uses it.
 	 */
 	generateEnvModule: () => void;
 
@@ -1550,6 +1550,10 @@ export interface RequestEvent<
 	locals: App.Locals;
 	/**
 	 * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+	 *
+	 * In the context of a remote function request initiated by the client, this relates to the page the remote function
+	 * was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
+	 * whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 	 */
 	params: Params;
 	/**
@@ -1566,6 +1570,10 @@ export interface RequestEvent<
 	route: {
 		/**
 		 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+		 *
+		 * In the context of a remote function request initiated by the client, this relates to the page the remote function
+		 * was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
+		 * whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 		 */
 		id: RouteId;
 	};
@@ -1594,6 +1602,10 @@ export interface RequestEvent<
 	setHeaders: (headers: Record<string, string>) => void;
 	/**
 	 * The requested URL.
+	 *
+	 * In the context of a remote function request initiated by the client, this relates to the page the remote function
+	 * was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
+	 * whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 	 */
 	url: URL;
 	/**

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

@@ -147,7 +147,12 @@ export function build_server_nodes(
 		}
 
 		if (node.universal) {
-			if (!!node.page_options && node.page_options.ssr === false) {
+			if (
+				(kit.router.type === 'hash' &&
+					node.page_options !== null &&
+					node.page_options?.ssr === undefined) ||
+				(node.page_options && node.page_options.ssr === false)
+			) {
 				exports.push(`export const universal = ${s(node.page_options, null, 2)};`);
 			} else {
 				imports.push(

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

@@ -106,11 +106,17 @@ export async function build_service_worker(
 			}
 
 			if (id === '\0virtual:app/env/public') {
-				// TODO ideally we would only add the `importScripts` if there are dynamic vars that are known to be used
+				const has_dynamic_public_env = Object.values(env_config ?? {}).some(
+					(variable) => variable.public && !variable.static
+				);
+
 				return create_sveltekit_env_public(
 					env_config,
 					env.all,
-					`importScripts('${kit.paths.base}/${kit.appDir}/env.script.js'); const env = globalThis.__sveltekit_sw.env;`
+					has_dynamic_public_env
+						? // the service worker isn't registered as ESM yet, so we need to use `importScripts`
+							`importScripts('${kit.paths.base}/${kit.appDir}/env.script.js'); const env = globalThis.__sveltekit_sw.env;`
+						: ''
 				);
 			}
 

package/src/exports/vite/index.js

@@ -22,7 +22,7 @@ import {
 import * as sync from '../../core/sync/sync.js';
 import { create_assets } from '../../core/sync/create_manifest_data/index.js';
 import { runtime_directory, logger } from '../../core/utils.js';
-import { load_svelte_config, process_config } from '../../core/config/index.js';
+import { load_svelte_config, process_config, split_config } from '../../core/config/index.js';
 import { generate_manifest } from '../../core/generate_manifest/index.js';
 import { build_server_nodes } from './build/build_server.js';
 import { build_service_worker } from './build/build_service_worker.js';
@@ -143,19 +143,27 @@ const warning_preprocessor = {
 /**
  * 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`.
+ * @param {KitConfig & Omit<Options, 'onwarn'> & Pick<SvelteConfig, 'vitePlugin'>} [config]
  * @returns {Promise<Plugin[]>}
  */
 export async function sveltekit(config) {
 	/** @type {ValidatedConfig} */
 	let svelte_config;
 
+	// any options passed to the plugin that SvelteKit doesn't use itself are
+	// forwarded to vite-plugin-svelte, which does its own validation
+	/** @type {Record<string, any>} */
+	let vite_plugin_svelte_config = {};
+
 	if (config !== undefined) {
-		const { extensions, compilerOptions, vitePlugin, preprocess, ...kit } = config;
-		svelte_config = process_config(
-			{ extensions, compilerOptions, vitePlugin, preprocess, kit },
-			{ cwd, source: 'SvelteKit options from Vite config' }
-		);
+		const split = split_config(config);
+		vite_plugin_svelte_config = split.vite_plugin_svelte_config;
+
+		svelte_config = process_config(split.svelte_config, {
+			cwd,
+			source: 'SvelteKit options from Vite config'
+		});
 
 		const config_file = ['svelte.config.js', 'svelte.config.ts'].find((file) =>
 			fs.existsSync(file)
@@ -180,6 +188,9 @@ export async function sveltekit(config) {
 
 	/** @type {Options} */
 	const vite_plugin_svelte_options = {
+		// pass through any options that SvelteKit doesn't use itself first, so
+		// that the options SvelteKit manages below always take precedence
+		...vite_plugin_svelte_config,
 		configFile: false,
 		extensions: svelte_config.extensions,
 		preprocess,
@@ -293,8 +304,11 @@ async function kit({ svelte_config }) {
 				const allow = new Set([
 					kit.files.lib,
 					kit.files.routes,
+					kit.files.src,
 					kit.outDir,
-					path.resolve('src'), // TODO this isn't correct if user changed all his files to sth else than src (like in test/options)
+					// 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'),
 					path.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
 				]);
@@ -958,6 +972,7 @@ async function kit({ svelte_config }) {
 					if (ssr) {
 						input.index = `${runtime_directory}/server/index.js`;
 						input.internal = `${out_dir}/generated/server/internal.js`;
+						input.env = `__sveltekit/env`;
 						input['remote-entry'] = `${runtime_directory}/app/server/remote/index.js`;
 
 						// add entry points for every endpoint...
@@ -1375,6 +1390,17 @@ async function kit({ svelte_config }) {
 					const deps_of = (entry, add_dynamic_css = false) =>
 						find_deps(manifest, posixify(path.relative('.', entry)), add_dynamic_css);
 
+					const has_explicit_dynamic_public_env = Object.values(explicit_env_config ?? {}).some(
+						(variable) => variable.public && !variable.static
+					);
+
+					const uses_env_dynamic_public = client_chunks.some(
+						(chunk) =>
+							chunk.type === 'chunk' &&
+							(chunk.modules[env_dynamic_public] ||
+								(has_explicit_dynamic_public_env && 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`);
@@ -1385,9 +1411,7 @@ async function kit({ svelte_config }) {
 							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[env_dynamic_public]
-							)
+							uses_env_dynamic_public
 						};
 
 						// In case of server-side route resolution, we create a purpose-built route manifest that is
@@ -1434,9 +1458,7 @@ async function kit({ svelte_config }) {
 							imports: start.imports,
 							stylesheets: start.stylesheets,
 							fonts: start.fonts,
-							uses_env_dynamic_public: client_chunks.some(
-								(chunk) => chunk.type === 'chunk' && chunk.modules[env_dynamic_public]
-							)
+							uses_env_dynamic_public
 						};
 
 						if (svelte_config.kit.output.bundleStrategy === 'inline') {
@@ -1633,13 +1655,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);
 			}
 		}
 	}
@@ -1654,6 +1681,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)