feat: add Vite 7 Environment API support

- Upgrade to Vite 7.0.3 and add pnpm override to ensure consistent versions
- Add sveltekit_vite_environment virtual module for dev-time manifest access
- Add DevEnvironment type for sharing state between plugin and dev server
- Add environment.js utilities for module resolution in Vite environments
- Update dev server to populate and invalidate environment module
- Support environments config for future isolated builds

This is a minimal port of the Environment API changes from PR sveltejs#14008,
enabling Vite 7 support while maintaining compatibility with existing
adapters.

Author: hynj

package.json

@@ -48,6 +48,9 @@
 			"svelte-preprocess",
 			"unix-dgram",
 			"workerd"
-		]
+		],
+		"overrides": {
+			"vite": "^7.0.3"
+		}
 	}
 }

packages/kit/src/exports/vite/dev/environment.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+
+// `posixify` and `to_fs` are duplicated from utils/filesystem.js to avoid
+// the import from `node:fs` which isn't available in Cloudflare's workerd runtime
+
+/** @param {string} str */
+export function posixify(str) {
+	return str.replace(/\\/g, '/');
+}
+
+/**
+ * Prepend given path with `/@fs` prefix
+ * @param {string} str
+ */
+export function to_fs(str) {
+	str = posixify(str);
+	return `/@fs${
+		// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
+		str.startsWith('/') ? '' : '/'
+	}${str}`;
+}
+
+/** @param {string} id */
+export async function resolve(id) {
+	// TODO: doesn't work for files symlinked to kit package workspace
+	const url = id.startsWith('..') ? to_fs(path.posix.resolve(id)) : `/${id}`;
+
+	const module = await loud_ssr_load_module(url);
+
+	// TODO: module_node
+	// const module_node = await vite.moduleGraph.getModuleByUrl(url);
+	// if (!module_node) throw new Error(`Could not find node for ${url}`);
+
+	// return { module, module_node, url };
+	return { module, module_node: '', url };
+}
+
+/**
+ * @param {string} url
+ * @returns {Promise<Record<string, any>>}
+ */
+export async function loud_ssr_load_module(url) {
+	try {
+		return await import(/* @vite-ignore */ url);
+	} catch (/** @type {any} */ err) {
+		// TODO: implement error logging
+		// const msg = buildErrorMessage(err, [colors.red(`Internal server error: ${err.message}`)]);
+
+		// if (!vite.config.logger.hasErrorLogged(err)) {
+		// 	vite.config.logger.error(msg, { error: err });
+		// }
+
+		// vite.ws.send({
+		// 	type: 'error',
+		// 	err: {
+		// 		...err,
+		// 		// these properties are non-enumerable and will
+		// 		// not be serialized unless we explicitly include them
+		// 		message: err.message,
+		// 		stack: err.stack
+		// 	}
+		// });
+
+		throw err;
+	}
+}

packages/kit/src/exports/vite/dev/index.js

@@ -20,6 +20,7 @@ import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
 import { create_node_analyser } from '../static_analysis/index.js';
+import { sveltekit_vite_environment } from '../module_ids.js';
 
 const cwd = process.cwd();
 // vite-specifc queries that we should skip handling for css urls
@@ -29,10 +30,11 @@ const vite_css_query_regex = /(?:\?|&)(?:raw|url|inline)(?:&|$)/;
  * @param {import('vite').ViteDevServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
+ * @param {import('types').DevEnvironment} dev_environment
  * @param {() => Array<{ hash: string, file: string }>} get_remotes
  * @return {Promise<Promise<() => void>>}
  */
-export async function dev(vite, vite_config, svelte_config, get_remotes) {
+export async function dev(vite, vite_config, svelte_config, dev_environment, get_remotes) {
 	installPolyfills();
 
 	const async_local_storage = new AsyncLocalStorage();
@@ -65,6 +67,20 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 	/** @type {Error | null} */
 	let manifest_error = null;
 
+	function invalidate_vite_environment_module() {
+		if (vite.environments) {
+			for (const environment in vite.environments) {
+				const module = vite.environments[environment].moduleGraph.getModuleById(
+					sveltekit_vite_environment
+				);
+
+				if (module) {
+					vite.environments[environment].moduleGraph.invalidateModule(module);
+				}
+			}
+		}
+	}
+
 	/** @param {string} url */
 	async function loud_ssr_load_module(url) {
 		try {
@@ -110,6 +126,10 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 		try {
 			({ manifest_data } = sync.create(svelte_config));
 
+			// Populate dev_environment for the virtual module
+			dev_environment.manifest_data = manifest_data;
+			invalidate_vite_environment_module();
+
 			if (manifest_error) {
 				manifest_error = null;
 				vite.ws.send({ type: 'full-reload' });
@@ -449,6 +469,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 	});
 
 	const env = loadEnv(vite_config.mode, svelte_config.kit.env.dir, '');
+	dev_environment.env = env;
 	const emulator = await svelte_config.kit.adapter?.emulate?.();
 
 	return () => {
@@ -461,6 +482,16 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 		// serving routes with those names. See https://github.com/vitejs/vite/issues/7363
 		remove_static_middlewares(vite.middlewares);
 
+		// Capture remote address for the virtual module
+		vite.middlewares.stack.unshift({
+			route: '',
+			/** @type {import('vite').Connect.NextHandleFunction} */
+			handle: (req, _, next) => {
+				dev_environment.remote_address = req.socket.remoteAddress;
+				next();
+			}
+		});
+
 		vite.middlewares.use(async (req, res) => {
 			// Vite's base middleware strips out the base path. Restore it
 			const original_url = req.url;

packages/kit/src/exports/vite/index.js

@@ -8,7 +8,8 @@ import { copy, mkdirp, posixify, read, resolve_entry, rimraf } from '../../utils
 import { create_static_module, create_dynamic_module } from '../../core/env.js';
 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 { runtime_directory, logger, get_mime_lookup, runtime_base } from '../../core/utils.js';
+import { to_fs } from '../../utils/filesystem.js';
 import { load_config } from '../../core/config/index.js';
 import { generate_manifest } from '../../core/generate_manifest/index.js';
 import { build_server_nodes } from './build/build_server.js';
@@ -36,7 +37,8 @@ import {
 	env_static_public,
 	service_worker,
 	sveltekit_environment,
-	sveltekit_server
+	sveltekit_server,
+	sveltekit_vite_environment
 } from './module_ids.js';
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
@@ -175,6 +177,8 @@ let manifest_data;
 /** @type {import('types').ServerMetadata | undefined} only set at build time once analysis is finished */
 let build_metadata = undefined;
 
+const dev_environment = /** @type {import('types').DevEnvironment} */ ({});
+
 /**
  * Returns the SvelteKit Vite plugin. Vite executes Rollup hooks as well as some of its own.
  * Background reading is available at:
@@ -531,6 +535,97 @@ async function kit({ svelte_config }) {
 						}
 					`;
 				}
+
+				case sveltekit_vite_environment: {
+					const { manifest_data: md, env: dev_env, remote_address } = dev_environment;
+
+					if (!md) {
+						return 'export const manifest = null; export const env = {}; export const remote_address = undefined; export const base_path = ""; export const prerendered = new Set();';
+					}
+
+					const nodes_code = md.nodes.map((node, index) => {
+						const component = s(node.component);
+						return `async () => {
+							const result = {
+								index: ${s(index)},
+								universal_id: ${s(node.universal)},
+								server_id: ${s(node.server)},
+								imports: [],
+								stylesheets: [],
+								fonts: []
+							};
+							if (${component}) {
+								result.component = async () => {
+									const { module } = await resolve(${component});
+									return module.default;
+								};
+							}
+							if (result.universal_id) {
+								const { module } = await resolve(result.universal_id);
+								result.universal = module;
+							}
+							if (result.server_id) {
+								const { module } = await resolve(result.server_id);
+								result.server = module;
+							}
+							result.inline_styles = async () => ({});
+							return result;
+						}`;
+					}).join(',\n');
+
+					const routes_code = compact(md.routes.map((route) => {
+						if (!route.page && !route.endpoint) return null;
+						const endpoint = route.endpoint;
+						return `{
+							id: ${s(route.id)},
+							pattern: /${route.pattern.source}/,
+							params: ${s(route.params)},
+							page: ${s(route.page)},
+							endpoint: ${endpoint ? `async () => { const url = path.resolve(cwd, ${s(endpoint.file)}); return await loud_ssr_load_module(url); }` : 'null'},
+							endpoint_id: ${s(endpoint?.file)}
+						}`;
+					})).join(',\n');
+
+					return `
+						import path from "node:path";
+						import { resolve, loud_ssr_load_module } from "${runtime_base}/../exports/vite/dev/environment.js";
+						const cwd = ${s(cwd)};
+						export const manifest = {
+							appDir: ${s(svelte_config.kit.appDir)},
+							appPath: ${s(svelte_config.kit.appDir)},
+							assets: new Set(${s(md.assets.map((asset) => asset.file))}),
+							mimeTypes: ${s(get_mime_lookup(md))},
+							_: {
+								client: {
+									start: "${runtime_base}/client/entry.js",
+									app: "${to_fs(svelte_config.kit.outDir)}/generated/client/app.js",
+									imports: [],
+									stylesheets: [],
+									fonts: [],
+									uses_env_dynamic_public: true
+								},
+								server_assets: new Proxy({}, { has: () => true, get: () => 1 }),
+								nodes: [${nodes_code}],
+								prerendered_routes: new Set(),
+								routes: [${routes_code}],
+								matchers: async () => {
+									const matchers = {};
+									for (const [key, file] of ${s(Object.entries(md.matchers))}) {
+										const url = path.resolve(cwd, file);
+										const module = await import(url);
+										if (module.match) matchers[key] = module.match;
+										else throw new Error(file + ' does not export a match function');
+									}
+									return matchers;
+								}
+							}
+						};
+						export const env = ${s(dev_env)};
+						export const remote_address = ${s(remote_address)};
+						export const base_path = ${s(svelte_config.kit.paths.base)};
+						export const prerendered = manifest._.prerendered_routes;
+					`;
+				}
 			}
 		}
 	};
@@ -964,7 +1059,7 @@ async function kit({ svelte_config }) {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
 		 */
 		async configureServer(vite) {
-			return await dev(vite, vite_config, svelte_config, () => remotes);
+			return await dev(vite, vite_config, svelte_config, dev_environment, () => remotes);
 		},
 
 		/**

packages/kit/src/exports/vite/module_ids.js

@@ -9,7 +9,9 @@ export const env_dynamic_public = '\0virtual:env/dynamic/public';
 export const service_worker = '\0virtual:service-worker';
 
 export const sveltekit_environment = '\0virtual:__sveltekit/environment';
+export const sveltekit_paths = '\0virtual:__sveltekit/paths';
 export const sveltekit_server = '\0virtual:__sveltekit/server';
+export const sveltekit_vite_environment = '\0virtual:__sveltekit/vite-environment';
 
 export const app_server = posixify(
 	fileURLToPath(new URL('../../runtime/app/server/index.js', import.meta.url))

packages/kit/src/types/internal.d.ts

@@ -627,5 +627,11 @@ export interface RequestStore {
 	state: RequestState;
 }
 
+export interface DevEnvironment {
+	manifest_data: ManifestData;
+	env: Record<string, string>;
+	remote_address: string | undefined;
+}
+
 export * from '../exports/index.js';
 export * from './private.js';