@sveltejs/kit 2.63.0 → 3.0.0-next.0

package/src/core/env.js

@@ -2,12 +2,11 @@
 /** @import { EnvVarConfig } from '@sveltejs/kit' */
 /** @import { ValidatedKitConfig } from 'types' */
 import path from 'node:path';
-import process from 'node:process';
 import * as vite from 'vite';
 import * as devalue from 'devalue';
 import { GENERATED_COMMENT } from '../constants.js';
 import { dedent } from './sync/utils.js';
-import { runtime_base, runtime_directory } from './utils.js';
+import { runtime_directory } from './utils.js';
 import { resolve_entry } from '../utils/filesystem.js';
 import { handle_issues, validate } from '../exports/internal/env.js';
 import { get_config_aliases } from '../exports/vite/utils.js';
@@ -16,42 +15,22 @@ import { get_config_aliases } from '../exports/vite/utils.js';
  * @typedef {'public' | 'private'} EnvType
  */
 
-let warned = false;
-
 /**
  * @param {import('types').ValidatedKitConfig} config
  * @returns {string | null}
  */
 export function resolve_explicit_env_entry(config) {
-	const resolved = resolve_entry(path.join(config.files.src, 'env'));
-
-	if (resolved) {
-		if (config.experimental.explicitEnvironmentVariables) {
-			return resolved;
-		}
-
-		if (!warned) {
-			console.warn(
-				`${path.relative(process.cwd(), resolved)} requires the \`experimental.explicitEnvironmentVariables\` flag to be set`
-			);
-			warned = true;
-		}
-	} else if (config.experimental.explicitEnvironmentVariables) {
-		console.warn(
-			'experimental.explicitEnvironmentVariables was set, but no src/env.ts or src/env.js file could be found'
-		);
-	}
-
-	return null;
+	return resolve_entry(path.join(config.files.src, 'env')) ?? null;
 }
 
 /**
  * @param {ValidatedKitConfig} kit
  * @param {string | null} file
+ * @param {string} root
  * @param {string} mode
  * @returns {Promise<Record<string, EnvVarConfig<any>> | null>}
  */
-export async function load_explicit_env(kit, file, mode) {
+export async function load_explicit_env(kit, file, root, mode) {
 	if (!file) return null;
 
 	const server = await vite.createServer({
@@ -64,7 +43,7 @@ export async function load_explicit_env(kit, file, mode) {
 		resolve: {
 			alias: [
 				{ find: '$app/env', replacement: `${runtime_directory}/app/env` },
-				...get_config_aliases(kit)
+				...get_config_aliases(kit, root)
 			]
 		}
 	});
@@ -106,55 +85,6 @@ export async function load_explicit_env(kit, file, mode) {
 	return variables;
 }
 
-/**
- * @param {string} id
- * @param {Record<string, string>} env
- * @param {boolean} disabled
- * @returns {string}
- */
-export function create_static_module(id, env, disabled) {
-	/** @type {string[]} */
-	const statements = [];
-
-	if (disabled) {
-		statements.push(
-			`throw new Error('Cannot import \`${id}\` when \`experimental.explicitEnvironmentVariables\` is enabled. Use \`${id.replace('$env/static', '$app/env')}\` instead.');`
-		);
-	}
-
-	for (const key in env) {
-		if (!valid_identifier.test(key) || reserved.has(key)) {
-			continue;
-		}
-
-		const comment = `/** @type {import('${id}').${key}} */`;
-		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
-
-		statements.push(`${comment}\n${declaration}`);
-	}
-
-	return GENERATED_COMMENT + statements.join('\n\n');
-}
-
-/**
- * @param {EnvType} type
- * @param {Record<string, string> | undefined} dev_values If in a development mode, values to pre-populate the module with.
- * @param {boolean} disabled
- */
-export function create_dynamic_module(type, dev_values, disabled) {
-	const prelude = disabled
-		? `throw new Error('Cannot import \`$env/dynamic/${type}\` when \`experimental.explicitEnvironmentVariables\` is enabled. Use \`$app/env/${type}\` instead.');\n\n`
-		: '';
-
-	if (dev_values) {
-		const keys = Object.entries(dev_values).map(
-			([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`
-		);
-		return `${prelude}export const env = {\n${keys.join(',\n')}\n}`;
-	}
-	return `${prelude}export { ${type}_env as env } from '${runtime_base}/shared-server.js';`;
-}
-
 /**
  * Creates the `__sveltekit/env` module
  * @param {Record<string, EnvVarConfig<any>> | null} variables
@@ -325,61 +255,6 @@ function create_jsdoc(description) {
 		.join('\n')}\n */`;
 }
 
-/**
- * @param {EnvType} id
- * @param {import('types').Env} env
- * @returns {string}
- */
-export function create_static_types(id, env) {
-	const declarations = Object.keys(env[id])
-		.filter((k) => valid_identifier.test(k))
-		.map((k) => `export const ${k}: string;`);
-
-	return dedent`
-		declare module '$env/static/${id}' {
-			${declarations.join('\n')}
-		}
-	`;
-}
-
-/**
- * @param {EnvType} id
- * @param {import('types').Env} env
- * @param {{
- * 	public_prefix: string;
- * 	private_prefix: string;
- * }} prefixes
- * @returns {string}
- */
-export function create_dynamic_types(id, env, { public_prefix, private_prefix }) {
-	const properties = Object.keys(env[id])
-		.filter((k) => valid_identifier.test(k))
-		.map((k) => `${k}: string;`);
-
-	const public_prefixed = `[key: \`${public_prefix}\${string}\`]`;
-	const private_prefixed = `[key: \`${private_prefix}\${string}\`]`;
-
-	if (id === 'private') {
-		if (public_prefix) {
-			properties.push(`${public_prefixed}: undefined;`);
-		}
-		properties.push(`${private_prefixed}: string | undefined;`);
-	} else {
-		if (private_prefix) {
-			properties.push(`${private_prefixed}: undefined;`);
-		}
-		properties.push(`${public_prefixed}: string | undefined;`);
-	}
-
-	return dedent`
-		declare module '$env/dynamic/${id}' {
-			export const env: {
-				${properties.join('\n')}
-			}
-		}
-	`;
-}
-
 /**
  * @param {Record<string, EnvVarConfig<any>>} variables
  * @param {string} relative

package/src/core/generate_manifest/find_server_assets.js

@@ -4,8 +4,9 @@ import { find_deps } from '../../exports/vite/build/utils.js';
  * Finds all the assets that are imported by server files associated with `routes`
  * @param {import('types').BuildData} build_data
  * @param {import('types').RouteData[]} routes
+ * @param {string} root
  */
-export function find_server_assets(build_data, routes) {
+export function find_server_assets(build_data, routes, root) {
 	/**
 	 * All nodes actually used in the routes definition (prerendered routes are omitted).
 	 * Root layout/error is always included as they are needed for 404 and root errors.
@@ -19,7 +20,7 @@ export function find_server_assets(build_data, routes) {
 	/** @param {string} id */
 	function add_assets(id) {
 		if (id in build_data.server_manifest) {
-			const deps = find_deps(build_data.server_manifest, id, false);
+			const deps = find_deps(build_data.server_manifest, id, false, root);
 			for (const asset of deps.assets) {
 				server_assets.add(asset);
 			}

package/src/core/generate_manifest/index.js

@@ -20,9 +20,17 @@ import { uneval } from 'devalue';
  *   relative_path: string;
  *   routes: import('types').RouteData[];
  *   remotes: RemoteChunk[];
+ *   root: string;
  * }} opts
  */
-export function generate_manifest({ build_data, prerendered, relative_path, routes, remotes }) {
+export function generate_manifest({
+	build_data,
+	prerendered,
+	relative_path,
+	routes,
+	remotes,
+	root
+}) {
 	/**
 	 * @type {Map<any, number>} The new index of each node in the filtered nodes array
 	 */
@@ -34,7 +42,7 @@ export function generate_manifest({ build_data, prerendered, relative_path, rout
 	 */
 	const used_nodes = new Set([0, 1]);
 
-	const server_assets = find_server_assets(build_data, routes);
+	const server_assets = find_server_assets(build_data, routes, root);
 
 	for (const route of routes) {
 		if (route.page) {
@@ -119,7 +127,7 @@ export function generate_manifest({ build_data, prerendered, relative_path, rout
 								pattern: ${route.pattern},
 								params: ${s(route.params)},
 								page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
-								endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
+								endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file, root).chunk.file)) : 'null'}
 							}
 						`;
 					}).filter(Boolean).join(',\n')}

package/src/core/postbuild/analyse.js

@@ -1,12 +1,11 @@
+/** @import { Adapter } from '@sveltejs/kit' */
 /** @import { RemoteChunk } from 'types' */
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { validate_server_exports } from '../../utils/exports.js';
-import { load_config } from '../config/index.js';
+import { extract_svelte_config, load_vite_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
-import { installPolyfills } from '../../exports/node/polyfills.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
-import { filter_env } from '../../utils/env.js';
 import { has_server_load, resolve_route } from '../../utils/routing.js';
 import { check_feature } from '../../utils/features.js';
 import { createReadableStream } from '@sveltejs/kit/node';
@@ -25,6 +24,8 @@ export default forked(import.meta.url, analyse);
  *   env: Record<string, string>;
  *   out: string;
  *   remotes: RemoteChunk[];
+ *   root: string;
+ *   vite_config_file: string | undefined;
  * }} opts
  */
 async function analyse({
@@ -35,37 +36,39 @@ async function analyse({
 	tracked_features,
 	env,
 	out,
-	remotes
+	remotes,
+	root,
+	vite_config_file
 }) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
-	/** @type {import('types').ValidatedKitConfig} */
-	const config = (await load_config()).kit;
+	const vite_config = await load_vite_config(vite_config_file);
+
+	const config = extract_svelte_config(vite_config).kit;
+
+	// TODO i think this can just be config.adapter?
+	/** @type {Adapter | undefined} */
+	const adapter = vite_config.plugins.find(
+		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
+	)?.api?.adapter;
 
 	const server_root = join(config.outDir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */
 	const internal = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
 
-	installPolyfills();
-
-	// configure `import { building } from '$app/environment'` and `$app/env` —
+	// configure `import { building } from '$app/env'` —
 	// essential we do this before analysing the code
 	internal.set_building();
 
 	// set env, `read`, and `manifest`, in case they're used in initialisation
-	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = config.env;
-	const private_env = filter_env(env, private_prefix, public_prefix);
-	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}`));
 
 	// first, build server nodes without the client manifest so we can analyse it
-	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null);
+	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null, root);
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -131,7 +134,7 @@ async function analyse({
 				server_manifest,
 				tracked_features
 			)) {
-				check_feature(route.id, route_config, feature, config.adapter);
+				check_feature(route.id, route_config, feature, adapter);
 			}
 		}
 

package/src/core/postbuild/fallback.js

@@ -1,7 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { installPolyfills } from '../../exports/node/polyfills.js';
 import { forked } from '../../utils/fork.js';
 
 export default forked(import.meta.url, generate_fallback);
@@ -16,8 +15,6 @@ export default forked(import.meta.url, generate_fallback);
  * }} opts
  */
 async function generate_fallback({ manifest_path, env, out_dir, origin, assets }) {
-	installPolyfills();
-
 	const server_root = join(out_dir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */

package/src/core/postbuild/prerender.js

@@ -1,13 +1,14 @@
+/** @import { Adapter } from '@sveltejs/kit' */
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { installPolyfills } from '../../exports/node/polyfills.js';
-import { mkdirp, posixify, walk } from '../../utils/filesystem.js';
+import { mkdirp, walk } from '../../utils/filesystem.js';
+import { posixify } from '../../utils/os.js';
 import { noop } from '../../utils/functions.js';
 import { decode_uri, is_root_relative, resolve } from '../../utils/url.js';
 import { escape_html } from '../../utils/escape.js';
 import { logger } from '../utils.js';
-import { load_config } from '../config/index.js';
+import { extract_svelte_config, load_vite_config } from '../config/index.js';
 import { get_route_segments } from '../../utils/routing.js';
 import { queue } from './queue.js';
 import { crawl } from './crawl.js';
@@ -16,7 +17,6 @@ import * as devalue from 'devalue';
 import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
-import { filter_env } from '../../utils/env.js';
 
 export default forked(import.meta.url, prerender);
 
@@ -33,10 +33,11 @@ const SPECIAL_HASHLINKS = new Set(['', 'top']);
  *   manifest_path: string;
  *   metadata: import('types').ServerMetadata;
  *   verbose: boolean;
- *   env: Record<string, string>
+ *   env: Record<string, string>;
+ *   vite_config_file: string | undefined;
  * }} opts
  */
-async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
+async function prerender({ hash, out, manifest_path, metadata, verbose, env, vite_config_file }) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
@@ -46,7 +47,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	/** @type {import('types').ServerModule} */
 	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
 
-	// configure `import { building } from '$app/environment'` and `$app/env` —
+	// configure `import { building } from `$app/env` —
 	// essential we do this before analysing the code
 	internal.set_building();
 	internal.set_prerendering();
@@ -100,8 +101,9 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	/** @type {Set<string>} */
 	const prerendered_routes = new Set();
 
-	/** @type {import('types').ValidatedKitConfig} */
-	const config = (await load_config()).kit;
+	const vite_config = await load_vite_config(vite_config_file);
+
+	const config = extract_svelte_config(vite_config).kit;
 
 	if (hash) {
 		const fallback = await generate_fallback({
@@ -123,13 +125,17 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 		return { prerendered, prerender_map };
 	}
 
-	const emulator = await config.adapter?.emulate?.();
+	// TODO this can just be config.adapter?
+	/** @type {Adapter | undefined} */
+	const adapter = vite_config.plugins.find(
+		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
+	)?.api?.adapter;
+
+	const emulator = await adapter?.emulate?.();
 
 	/** @type {import('types').Logger} */
 	const log = logger({ verbose });
 
-	installPolyfills();
-
 	/** @type {Map<string, string>} */
 	const saved = new Map();
 
@@ -492,11 +498,6 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env }) {
 	// the user's remote function modules may reference environment variables,
 	// `read` or the `manifest` at the top-level so we need to set them before
 	// evaluating those modules to avoid potential runtime errors
-	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = config.env;
-	const private_env = filter_env(env, private_prefix, public_prefix);
-	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/postbuild/queue.js

@@ -1,6 +1,3 @@
-/** @import { PromiseWithResolvers } from '../../utils/promise.js' */
-import { with_resolvers } from '../../utils/promise.js';
-
 /**
  * @typedef {{
  *   fn: () => Promise<any>,
@@ -13,7 +10,9 @@ import { with_resolvers } from '../../utils/promise.js';
 export function queue(concurrency) {
 	/** @type {Task[]} */
 	const tasks = [];
-	const { promise, resolve, reject } = /** @type {PromiseWithResolvers<void>} */ (with_resolvers());
+	const { promise, resolve, reject } = /** @type {PromiseWithResolvers<void>} */ (
+		Promise.withResolvers()
+	);
 
 	let current = 0;
 	let closed = false;

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

@@ -1,14 +1,13 @@
+import { lookup } from 'mrmime';
 import fs from 'node:fs';
 import path from 'node:path';
-import process from 'node:process';
-import colors from 'kleur';
-import { lookup } from 'mrmime';
-import { list_files, runtime_directory } from '../../utils.js';
-import { posixify, resolve_entry } from '../../../utils/filesystem.js';
+import { styleText } from 'node:util';
+import { resolve_entry } from '../../../utils/filesystem.js';
+import { posixify } from '../../../utils/os.js';
 import { parse_route_id } from '../../../utils/routing.js';
+import { list_files, runtime_directory } from '../../utils.js';
 import { prevent_conflicts } from './conflict.js';
 import { sort_routes } from './sort.js';
-import { isSvelte5Plus } from '../utils.js';
 import {
 	create_node_analyser,
 	get_page_options
@@ -19,14 +18,14 @@ import {
  * @param {{
  *   config: import('types').ValidatedConfig;
  *   fallback?: string;
- *   cwd?: string;
+ *   cwd: string;
  * }} opts
  * @returns {import('types').ManifestData}
  */
 export default function create_manifest_data({
 	config,
-	fallback = `${runtime_directory}/components/${isSvelte5Plus() ? 'svelte-5' : 'svelte-4'}`,
-	cwd = process.cwd()
+	fallback = `${runtime_directory}/components`,
+	cwd
 }) {
 	const assets = create_assets(config);
 	const hooks = create_hooks(config, cwd);
@@ -116,8 +115,8 @@ function create_matchers(config, cwd) {
 }
 
 /**
- * @param {import('types').ValidatedConfig} config
  * @param {string} cwd
+ * @param {import('types').ValidatedConfig} config
  * @param {string} fallback
  */
 function create_routes_and_nodes(cwd, config, fallback) {
@@ -241,12 +240,11 @@ function create_routes_and_nodes(cwd, config, fallback) {
 						);
 					if (typo) {
 						console.log(
-							colors
-								.bold()
-								.yellow(
-									`Missing route file prefix. Did you mean +${file.name}?` +
-										` at ${path.join(dir, file.name)}`
-								)
+							styleText(
+								['bold', 'yellow'],
+								`Missing route file prefix. Did you mean +${file.name}?` +
+									` at ${path.join(dir, file.name)}`
+							)
 						);
 					}
 
@@ -421,7 +419,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);
 
 	for (const route of routes) {
 		if (!route.leaf) continue;
@@ -473,7 +471,7 @@ 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(route.endpoint.file, cwd);
 		}
 	}
 

package/src/core/sync/sync.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import process from 'node:process';
 import create_manifest_data from './create_manifest_data/index.js';
 import { write_client_manifest } from './write_client_manifest.js';
 import { write_root } from './write_root.js';
@@ -17,26 +18,27 @@ import { write_env } from './write_env.js';
 /**
  * Initialize SvelteKit's generated files that only depend on the config and mode.
  * @param {import('types').ValidatedConfig} config
- * @param {string} mode
+ * @param {string} root The project root directory
  */
-export function init(config, mode) {
-	write_tsconfig(config.kit);
-	write_ambient(config.kit, mode);
+export function init(config, root) {
+	write_tsconfig(config.kit, root);
+	write_ambient(config.kit);
 }
 
 /**
  * Update SvelteKit's generated files
  * @param {import('types').ValidatedConfig} config
+ * @param {string} root The project root directory
  */
-export function create(config) {
-	const manifest_data = create_manifest_data({ config });
+export function create(config, root) {
+	const manifest_data = create_manifest_data({ config, cwd: root });
 
 	const output = path.join(config.kit.outDir, 'generated');
 
 	write_client_manifest(config.kit, manifest_data, `${output}/client`);
-	write_server(config, output);
+	write_server(config, output, root);
 	write_root(manifest_data, config, output);
-	write_all_types(config, manifest_data);
+	write_all_types(config, manifest_data, root);
 	write_non_ambient(config.kit, manifest_data);
 
 	return { manifest_data };
@@ -49,9 +51,10 @@ export function create(config) {
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
  * @param {string} file
+ * @param {string} root The project root directory
  */
-export function update(config, manifest_data, file) {
-	const node_analyser = create_node_analyser();
+export function update(config, manifest_data, file, root) {
+	const node_analyser = create_node_analyser(root);
 
 	for (const node of manifest_data.nodes) {
 		node.page_options = node_analyser.get_page_options(node);
@@ -59,33 +62,33 @@ export function update(config, manifest_data, file) {
 
 	for (const route of manifest_data.routes) {
 		if (route.endpoint) {
-			route.endpoint.page_options = get_page_options(route.endpoint.file);
+			route.endpoint.page_options = get_page_options(route.endpoint.file, root);
 		}
 	}
 
-	write_types(config, manifest_data, file);
+	write_types(config, manifest_data, file, root);
 	write_non_ambient(config.kit, manifest_data);
 }
 
 /**
  * Run sync.init and sync.create in series, returning the result from sync.create.
  * @param {import('types').ValidatedConfig} config
- * @param {string} mode The Vite mode
+ * @param {string} root The project root directory
  */
-export function all(config, mode) {
-	init(config, mode);
-	return create(config);
+export function all(config, root) {
+	init(config, root);
+	return create(config, root);
 }
 
 /**
  * Run sync.init and then generate all type files.
  * @param {import('types').ValidatedConfig} config
- * @param {string} mode The Vite mode
  */
-export function all_types(config, mode) {
-	init(config, mode);
-	const manifest_data = create_manifest_data({ config });
-	write_all_types(config, manifest_data);
+export function all_types(config) {
+	const cwd = process.cwd();
+	init(config, cwd);
+	const manifest_data = create_manifest_data({ config, cwd });
+	write_all_types(config, manifest_data, cwd);
 	write_non_ambient(config.kit, manifest_data);
 }
 
@@ -93,10 +96,11 @@ export function all_types(config, mode) {
  * Generate modules and types for explicit env vars
  * @param {import('types').ValidatedKitConfig} kit
  * @param {string | null} entry
+ * @param {string} root The Vite root
  * @param {string} mode The Vite mode
  */
-export async function env(kit, entry, mode) {
-	const env_config = await load_explicit_env(kit, entry, mode);
+export async function env(kit, entry, root, mode) {
+	const env_config = await load_explicit_env(kit, entry, root, mode);
 
 	write_env(kit, entry, env_config);
 
@@ -106,7 +110,8 @@ export async function env(kit, entry, mode) {
 /**
  * Regenerate __SERVER__/internal.js in response to src/{app.html,error.html,service-worker.js} changing
  * @param {import('types').ValidatedConfig} config
+ * @param {string} root The project root directory
  */
-export function server(config) {
-	write_server(config, path.join(config.kit.outDir, 'generated'));
+export function server(config, root) {
+	write_server(config, path.join(config.kit.outDir, 'generated'), root);
 }