@sveltejs/kit 2.62.0 → 3.0.0-next.0

package/src/core/sync/write_root.js

@@ -1,4 +1,4 @@
-import { dedent, isSvelte5Plus, write_if_changed } from './utils.js';
+import { dedent, write_if_changed } from './utils.js';
 
 /**
  * @param {import('types').ManifestData} manifest_data
@@ -8,7 +8,7 @@ import { dedent, isSvelte5Plus, write_if_changed } from './utils.js';
 export function write_root(manifest_data, config, output) {
 	// TODO remove default layout altogether
 
-	const use_boundaries = config.kit.experimental.handleRenderingErrors && isSvelte5Plus();
+	const use_boundaries = config.kit.experimental.handleRenderingErrors;
 
 	const max_depth = Math.max(
 		...manifest_data.routes.map((route) =>
@@ -26,7 +26,7 @@ export function write_root(manifest_data, config, output) {
 	/** @type {string} */
 	let pyramid;
 
-	if (isSvelte5Plus() && use_boundaries) {
+	if (use_boundaries) {
 		// with the @const we force the data[depth] access to be derived, which is important to not fire updates needlessly
 		// TODO in Svelte 5 we should rethink the client.js side, we can likely make data a $state and only update indexes that changed there, simplifying this a lot
 		pyramid = dedent`
@@ -55,39 +55,21 @@ export function write_root(manifest_data, config, output) {
 		`;
 	} else {
 		pyramid = dedent`
-	${
-		isSvelte5Plus()
-			? `<!-- svelte-ignore binding_property_non_reactive -->
-		<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />`
-			: `<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />`
-	}`;
+		<!-- svelte-ignore binding_property_non_reactive -->
+		<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />`;
 
 		while (l--) {
 			pyramid = dedent`
 			{#if constructors[${l + 1}]}
-				${
-					isSvelte5Plus()
-						? dedent`{@const Pyramid_${l} = constructors[${l}]}
-						<!-- svelte-ignore binding_property_non_reactive -->
-						<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params}>
-							${pyramid}
-						</Pyramid_${l}>`
-						: dedent`<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} params={page.params}>
+				{@const Pyramid_${l} = constructors[${l}]}
+				<!-- svelte-ignore binding_property_non_reactive -->
+				<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params}>
 					${pyramid}
-				</svelte:component>`
-				}
-
+				</Pyramid_${l}>
 			{:else}
-				${
-					isSvelte5Plus()
-						? dedent`
-					{@const Pyramid_${l} = constructors[${l}]}
-					<!-- svelte-ignore binding_property_non_reactive -->
-					<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />
-					`
-						: dedent`<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />`
-				}
-
+				{@const Pyramid_${l} = constructors[${l}]}
+				<!-- svelte-ignore binding_property_non_reactive -->
+				<Pyramid_${l} bind:this={components[${l}]} data={data_${l}} {form} params={page.params} />
 			{/if}
 		`;
 		}
@@ -97,62 +79,34 @@ export function write_root(manifest_data, config, output) {
 		`${output}/root.svelte`,
 		dedent`
 			<!-- This file is generated by @sveltejs/kit — do not edit it! -->
-			${isSvelte5Plus() ? '<svelte:options runes={true} />' : ''}
+			<svelte:options runes={true} />
 			<script>
-				import { setContext, ${isSvelte5Plus() ? '' : 'afterUpdate, '}onMount, tick } from 'svelte';
-				import { browser } from '$app/environment';
+				import { setContext, onMount, tick } from 'svelte';
+				import { browser } from '$app/env';
 
 				// stores
-				${
-					isSvelte5Plus()
-						? dedent`
-							let { stores, page, constructors, components = [], form, ${use_boundaries ? 'errors = [], error, ' : ''}${levels
-								.map((l) => `data_${l} = null`)
-								.join(', ')} } = $props();
-							${use_boundaries ? `let data = $derived({${levels.map((l) => `'${l}': data_${l}`).join(', ')}})` : ''}
-						`
-						: dedent`
-							export let stores;
-							export let page;
-
-							export let constructors;
-							export let components = [];
-							export let form;
-							${levels.map((l) => `export let data_${l} = null;`).join('\n')}
-						`
-				}
-
-				if (!browser) {
+				let { stores, page, constructors, components = [], form, ${use_boundaries ? 'errors = [], error, ' : ''}${levels
+					.map((l) => `data_${l} = null`)
+					.join(', ')} } = $props();
+				${use_boundaries ? `let data = $derived({${levels.map((l) => `'${l}': data_${l}`).join(', ')}})` : ''}
+
+				if (browser) {
+					$effect.pre(() => stores.page.set(page));
+				} else {
 					// svelte-ignore state_referenced_locally
 					setContext('__svelte__', stores);
+					// svelte-ignore state_referenced_locally
+					stores.page.set(page);
 				}
 
-				${
-					isSvelte5Plus()
-						? dedent`
-							if (browser) {
-								$effect.pre(() => stores.page.set(page));
-							} else {
-								// svelte-ignore state_referenced_locally
-								stores.page.set(page);
-							}
-						`
-						: '$: stores.page.set(page);'
-				}
-				${
-					isSvelte5Plus()
-						? dedent`
-							$effect(() => {
-								stores;page;constructors;components;form;${use_boundaries ? 'errors;error;' : ''}${levels.map((l) => `data_${l}`).join(';')};
-								stores.page.notify();
-							});
-						`
-						: 'afterUpdate(stores.page.notify);'
-				}
+				$effect(() => {
+					stores;page;constructors;components;form;${use_boundaries ? 'errors;error;' : ''}${levels.map((l) => `data_${l}`).join(';')};
+					stores.page.notify();
+				});
 
-				let mounted = ${isSvelte5Plus() ? '$state(false)' : 'false'};
-				let navigated = ${isSvelte5Plus() ? '$state(false)' : 'false'};
-				let title = ${isSvelte5Plus() ? '$state(null)' : 'null'};
+				let mounted = $state(false);
+				let navigated = $state(false);
+				let title = $state(null);
 
 				onMount(() => {
 					const unsubscribe = stores.page.subscribe(() => {
@@ -168,7 +122,7 @@ export function write_root(manifest_data, config, output) {
 					return unsubscribe;
 				});
 
-				${isSvelte5Plus() ? `const Pyramid_${max_depth}=$derived(constructors[${max_depth}])` : ''}
+				const Pyramid_${max_depth} = $derived(constructors[${max_depth}]);
 			</script>
 
 			${pyramid}
@@ -183,14 +137,12 @@ export function write_root(manifest_data, config, output) {
 		`
 	);
 
-	if (isSvelte5Plus()) {
-		write_if_changed(
-			`${output}/root.js`,
-			dedent`
-			import { asClassComponent } from 'svelte/legacy';
-			import Root from './root.svelte';
-			export default asClassComponent(Root);
-		`
-		);
-	}
+	write_if_changed(
+		`${output}/root.js`,
+		dedent`
+		import { asClassComponent } from 'svelte/legacy';
+		import Root from './root.svelte';
+		export default asClassComponent(Root);
+	`
+	);
 }

package/src/core/sync/write_server.js

@@ -1,12 +1,11 @@
 import path from 'node:path';
-import process from 'node:process';
+import { styleText } from 'node:util';
 import { hash } from '../../utils/hash.js';
-import { posixify, resolve_entry } from '../../utils/filesystem.js';
+import { resolve_entry } from '../../utils/filesystem.js';
+import { posixify } from '../../utils/os.js';
 import { s } from '../../utils/misc.js';
 import { load_error_page, load_template } from '../config/index.js';
-import { runtime_directory } from '../utils.js';
-import { isSvelte5Plus, write_if_changed } from './utils.js';
-import colors from 'kleur';
+import { write_if_changed } from './utils.js';
 import { escape_html } from '../../utils/escape.js';
 
 /**
@@ -15,7 +14,6 @@ import { escape_html } from '../../utils/escape.js';
  *   universal_hooks: string | null;
  *   config: import('types').ValidatedConfig;
  *   has_service_worker: boolean;
- *   runtime_directory: string;
  *   template: string;
  *   error_page: string;
  * }} opts
@@ -25,28 +23,25 @@ const server_template = ({
 	server_hooks,
 	universal_hooks,
 	has_service_worker,
-	runtime_directory,
 	template,
 	error_page
 }) => `
-import root from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';
-import { set_building, set_prerendering } from '__sveltekit/environment';
+import root from '../root.js';
+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_private_env, set_public_env } from '${runtime_directory}/shared-server.js';
+import { set_env } from '__sveltekit/env';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
 	async: ${s(!!config.compilerOptions?.experimental?.async)},
 	csp: ${s(config.kit.csp)},
-	csrf_check_origin: ${s(config.kit.csrf.checkOrigin && !config.kit.csrf.trustedOrigins.includes('*'))},
+	csrf_check_origin: ${s(!config.kit.csrf.trustedOrigins.includes('*'))},
 	csrf_trusted_origins: ${s(config.kit.csrf.trustedOrigins)},
 	embedded: ${config.kit.embedded},
-	env_public_prefix: '${config.kit.env.publicPrefix}',
-	env_private_prefix: '${config.kit.env.privatePrefix}',
 	hash_routing: ${s(config.kit.router.type === 'hash')},
 	hooks: null, // added lazily, via \`get_hooks\`
-	preload_strategy: ${s(config.kit.output.preloadStrategy)},
+	link_header_preload: ${s(config.kit.output.linkHeaderPreload)},
 	root,
 	service_worker: ${has_service_worker},
 	service_worker_options: ${config.kit.serviceWorker.register ? s(config.kit.serviceWorker.options) : 'null'},
@@ -92,7 +87,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation };
+export { set_assets, set_building, set_env, set_manifest, set_prerendering, set_read_implementation };
 `;
 
 // TODO need to re-run this whenever src/app.html or src/error.html are
@@ -103,20 +98,20 @@ export { set_assets, set_building, set_manifest, set_prerendering, set_private_e
  * Write server configuration to disk
  * @param {import('types').ValidatedConfig} config
  * @param {string} output
+ * @param {string} root The project root directory
  */
-export function write_server(config, output) {
+export function write_server(config, output, root) {
 	const server_hooks_file = resolve_entry(config.kit.files.hooks.server);
 	const universal_hooks_file = resolve_entry(config.kit.files.hooks.universal);
 
 	const typo = resolve_entry('src/+hooks.server');
 	if (typo) {
 		console.log(
-			colors
-				.bold()
-				.yellow(
-					`Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
-						` at ${path.resolve(typo)}`
-				)
+			styleText(
+				['bold', 'yellow'],
+				`Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
+					` at ${path.resolve(typo)}`
+			)
 		);
 	}
 
@@ -135,8 +130,7 @@ export function write_server(config, output) {
 			universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
 			has_service_worker:
 				config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
-			runtime_directory: relative(runtime_directory),
-			template: load_template(process.cwd(), config),
+			template: load_template(root, config),
 			error_page: load_error_page(config)
 		})
 	);

package/src/core/sync/write_tsconfig.js

@@ -1,8 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process from 'node:process';
-import colors from 'kleur';
-import { posixify } from '../../utils/filesystem.js';
+import { styleText } from 'node:util';
+import { posixify } from '../../utils/os.js';
 import { write_if_changed } from './utils.js';
 
 /**
@@ -17,10 +16,11 @@ function maybe_file(cwd, file) {
 }
 
 /**
+ * @param {string} cwd
  * @param {string} file
  */
-function project_relative(file) {
-	return posixify(path.relative('.', file));
+function project_relative(cwd, file) {
+	return posixify(path.relative(cwd, file));
 }
 
 /**
@@ -37,28 +37,32 @@ function remove_trailing_slashstar(file) {
 /**
  * Generates the tsconfig that the user's tsconfig inherits from.
  * @param {import('types').ValidatedKitConfig} kit
+ * @param {string} cwd
  */
-export function write_tsconfig(kit, cwd = process.cwd()) {
+export function write_tsconfig(kit, cwd) {
 	const out = path.join(kit.outDir, 'tsconfig.json');
 
 	const user_config = load_user_tsconfig(cwd);
 	if (user_config) validate_user_config(cwd, out, user_config);
 
-	write_if_changed(out, JSON.stringify(get_tsconfig(kit), null, '\t'));
+	write_if_changed(out, JSON.stringify(get_tsconfig(kit, cwd), null, '\t'));
 }
 
 /**
  * Generates the tsconfig that the user's tsconfig inherits from.
  * @param {import('types').ValidatedKitConfig} kit
+ * @param {string} cwd
  */
-export function get_tsconfig(kit) {
+export function get_tsconfig(kit, cwd) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path.relative(kit.outDir, file));
 
 	const include = new Set([
 		'ambient.d.ts', // careful: changing this name would be a breaking change, because it's referenced in the service-workers documentation
+		'env.d.ts',
 		'non-ambient.d.ts',
 		'./types/**/$types.d.ts',
+		config_relative('svelte.config.js'),
 		config_relative('vite.config.js'),
 		config_relative('vite.config.ts')
 	]);
@@ -74,11 +78,11 @@ export function get_tsconfig(kit) {
 
 	// Test folder is a special case - we advocate putting tests in a top-level test folder
 	// and it's not configurable (should we make it?)
-	const test_folder = project_relative('test');
+	const test_folder = project_relative(cwd, 'test');
 	include.add(config_relative(`${test_folder}/**/*.js`));
 	include.add(config_relative(`${test_folder}/**/*.ts`));
 	include.add(config_relative(`${test_folder}/**/*.svelte`));
-	const tests_folder = project_relative('tests');
+	const tests_folder = project_relative(cwd, 'tests');
 	include.add(config_relative(`${tests_folder}/**/*.js`));
 	include.add(config_relative(`${tests_folder}/**/*.ts`));
 	include.add(config_relative(`${tests_folder}/**/*.svelte`));
@@ -101,7 +105,7 @@ export function get_tsconfig(kit) {
 		compilerOptions: {
 			// generated options
 			paths: {
-				...get_tsconfig_paths(kit),
+				...get_tsconfig_paths(kit, cwd),
 				'$app/types': ['./types/index.d.ts']
 			},
 			rootDirs: [config_relative('.'), './types'],
@@ -169,22 +173,22 @@ function validate_user_config(cwd, out, config) {
 		// TODO: baseUrl will be removed in TypeScript 7.0
 		if (baseUrl || paths) {
 			console.warn(
-				colors
-					.bold()
-					.yellow(
-						`You have specified a baseUrl and/or paths in your ${config.kind} which interferes with SvelteKit's auto-generated tsconfig.json. ` +
-							'Remove it to avoid problems with intellisense. For path aliases, use `kit.alias` instead: https://svelte.dev/docs/kit/configuration#alias'
-					)
+				styleText(
+					['bold', 'yellow'],
+					`You have specified a baseUrl and/or paths in your ${config.kind} which interferes with SvelteKit's auto-generated tsconfig.json. ` +
+						'Remove it to avoid problems with intellisense. For path aliases, use `kit.alias` instead: https://svelte.dev/docs/kit/configuration#alias'
+				)
 			);
 		}
 	} else {
-		let relative = posixify(path.relative('.', out));
+		let relative = posixify(path.relative(cwd, out));
 		if (!relative.startsWith('./')) relative = './' + relative;
 
 		console.warn(
-			colors
-				.bold()
-				.yellow(`Your ${config.kind} should extend the configuration generated by SvelteKit:`)
+			styleText(
+				['bold', 'yellow'],
+				`Your ${config.kind} should extend the configuration generated by SvelteKit:`
+			)
 		);
 		console.warn(`{\n  "extends": "${relative}"\n}`);
 	}
@@ -200,8 +204,9 @@ const value_regex = /^(.*?)((\/\*)|(\.\w+))?$/;
  * Related to vite alias creation.
  *
  * @param {import('types').ValidatedKitConfig} config
+ * @param {string} cwd
  */
-function get_tsconfig_paths(config) {
+function get_tsconfig_paths(config, cwd) {
 	/** @param {string} file */
 	const config_relative = (file) => {
 		let relative_path = path.relative(config.outDir, file);
@@ -212,8 +217,8 @@ function get_tsconfig_paths(config) {
 	};
 
 	const alias = { ...config.alias };
-	if (fs.existsSync(project_relative(config.files.lib))) {
-		alias['$lib'] = project_relative(config.files.lib);
+	if (fs.existsSync(project_relative(cwd, config.files.lib))) {
+		alias['$lib'] = project_relative(cwd, config.files.lib);
 	}
 
 	/** @type {Record<string, string[]>} */

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

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process from 'node:process';
 import MagicString from 'magic-string';
-import { posixify, rimraf, walk } from '../../../utils/filesystem.js';
+import { rimraf, walk } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
+import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
 const remove_relative_parent_traversals = (/** @type {string} */ path) =>
 	path.replace(/\.\.\//g, '');
@@ -25,21 +25,20 @@ const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
  *  @typedef {Map<import('types').PageNode, {route: import('types').RouteData, proxies: Proxies}>} RoutesMap
  */
 
-const cwd = process.cwd();
-
 /**
  * Creates types for the whole manifest
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
+ * @param {string} root The project root directory
  */
-export function write_all_types(config, manifest_data) {
+export function write_all_types(config, manifest_data, root) {
 	if (!ts) return;
 
 	const types_dir = `${config.kit.outDir}/types`;
 
 	// empty out files that no longer need to exist
 	const routes_dir = remove_relative_parent_traversals(
-		posixify(path.relative('.', config.kit.files.routes))
+		posixify(path.relative(root, config.kit.files.routes))
 	);
 	const expected_directories = new Set(
 		manifest_data.routes.map((route) => path.join(routes_dir, route.id))
@@ -109,7 +108,7 @@ export function write_all_types(config, manifest_data) {
 
 		const source_last_updated = Math.max(
 			// ctimeMs includes move operations whereas mtimeMs does not
-			...input_files.map((file) => fs.statSync(file).ctimeMs)
+			...input_files.map((file) => fs.statSync(path.resolve(root, file)).ctimeMs)
 		);
 		const types_last_updated = Math.max(...output_files.map((file) => file.updated));
 
@@ -124,7 +123,7 @@ export function write_all_types(config, manifest_data) {
 		if (should_generate) {
 			// track which old files end up being surplus to requirements
 			const to_delete = new Set(output_files.map((file) => file.name));
-			update_types(config, routes_map, route, to_delete);
+			update_types(config, routes_map, route, root, to_delete);
 			meta_data[route.id] = input_files;
 		}
 	}
@@ -138,8 +137,9 @@ export function write_all_types(config, manifest_data) {
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
  * @param {string} file
+ * @param {string} root The project root directory
  */
-export function write_types(config, manifest_data, file) {
+export function write_types(config, manifest_data, file, root) {
 	if (!ts) return;
 
 	if (!path.basename(file).startsWith('+')) {
@@ -153,7 +153,7 @@ export function write_types(config, manifest_data, file) {
 	if (!route) return;
 	if (!route.leaf && !route.layout && !route.endpoint) return; // nothing to do
 
-	update_types(config, create_routes_map(manifest_data), route);
+	update_types(config, create_routes_map(manifest_data), route, root);
 }
 
 /**
@@ -176,11 +176,12 @@ function create_routes_map(manifest_data) {
  * @param {import('types').ValidatedConfig} config
  * @param {RoutesMap} routes
  * @param {import('types').RouteData} route
+ * @param {string} root The project root directory
  * @param {Set<string>} [to_delete]
  */
-function update_types(config, routes, route, to_delete = new Set()) {
+function update_types(config, routes, route, root, to_delete = new Set()) {
 	const routes_dir = remove_relative_parent_traversals(
-		posixify(path.relative('.', config.kit.files.routes))
+		posixify(path.relative(root, config.kit.files.routes))
 	);
 	const outdir = path.join(config.kit.outDir, 'types', routes_dir, route.id);
 
@@ -251,7 +252,7 @@ function update_types(config, routes, route, to_delete = new Set()) {
 			declarations: d,
 			exports: e,
 			proxies
-		} = process_node(route.leaf, outdir, true, route_info.proxies);
+		} = process_node(route.leaf, outdir, true, route_info.proxies, root);
 
 		exports.push(...e);
 		declarations.push(...d);
@@ -300,7 +301,7 @@ function update_types(config, routes, route, to_delete = new Set()) {
 					layout_params.push({ ...param, optional: true });
 				}
 
-				ensureProxies(page, leaf.proxies);
+				ensureProxies(page, leaf.proxies, root);
 
 				if (
 					// Be defensive - if a proxy doesn't exist (because it couldn't be created), assume a load function exists.
@@ -336,6 +337,7 @@ function update_types(config, routes, route, to_delete = new Set()) {
 			outdir,
 			false,
 			{ server: null, universal: null },
+			root,
 			all_pages_have_load
 		);
 
@@ -375,9 +377,10 @@ function update_types(config, routes, route, to_delete = new Set()) {
  * @param {string} outdir
  * @param {boolean} is_page
  * @param {Proxies} proxies
+ * @param {string} root The project root directory
  * @param {boolean} [all_pages_have_load]
  */
-function process_node(node, outdir, is_page, proxies, all_pages_have_load = true) {
+function process_node(node, outdir, is_page, proxies, root, all_pages_have_load = true) {
 	const params = `${is_page ? 'Route' : 'Layout'}Params`;
 	const prefix = is_page ? 'Page' : 'Layout';
 
@@ -393,7 +396,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 	/** @type {string} */
 	let data;
 
-	ensureProxies(node, proxies);
+	ensureProxies(node, proxies, root);
 
 	if (node.server) {
 		const basename = path.basename(node.server);
@@ -426,7 +429,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 				// The advantage is that type updates are reflected without saving.
 				const from = proxy.modified
 					? `./proxy${replace_ext_with_js(basename)}`
-					: path_to_original(outdir, node.server);
+					: path_to_original(outdir, node.server, root);
 
 				exports.push(
 					'type ExcludeActionFailure<T> = T extends Kit.ActionFailure<any> ? never : T extends void ? never : T;',
@@ -495,7 +498,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 				// The advantage is that type updates are reflected without saving.
 				const from = proxy.modified
 					? `./proxy${replace_ext_with_js(path.basename(file_path))}`
-					: path_to_original(outdir, file_path);
+					: path_to_original(outdir, file_path, root);
 				const type = `Kit.LoadProperties<Awaited<ReturnType<typeof import('${from}').load>>>`;
 				return expand ? `Expand<OptionalUnion<EnsureDefined<${type}>>>` : type;
 			} else {
@@ -515,24 +518,26 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
  *
  * @param {import('types').PageNode} node
  * @param {Proxies} proxies
+ * @param {string} root The project root directory
  */
-function ensureProxies(node, proxies) {
+function ensureProxies(node, proxies, root) {
 	if (node.server && !proxies.server) {
-		proxies.server = createProxy(node.server, true);
+		proxies.server = createProxy(node.server, true, root);
 	}
 
 	if (node.universal && !proxies.universal) {
-		proxies.universal = createProxy(node.universal, false);
+		proxies.universal = createProxy(node.universal, false, root);
 	}
 }
 
 /**
  * @param {string} file_path
  * @param {boolean} is_server
+ * @param {string} root The project root directory
  * @returns {Proxy}
  */
-function createProxy(file_path, is_server) {
-	const proxy = tweak_types(fs.readFileSync(file_path, 'utf8'), is_server);
+function createProxy(file_path, is_server, root) {
+	const proxy = tweak_types(fs.readFileSync(path.resolve(root, file_path), 'utf8'), is_server);
 	if (proxy) {
 		return {
 			...proxy,
@@ -577,9 +582,10 @@ function get_parent_type(node, type) {
 /**
  * @param {string} outdir
  * @param {string} file_path
+ * @param {string} root The project root directory
  */
-function path_to_original(outdir, file_path) {
-	return posixify(path.relative(outdir, path.join(cwd, replace_ext_with_js(file_path))));
+function path_to_original(outdir, file_path, root) {
+	return posixify(path.relative(outdir, path.join(root, replace_ext_with_js(file_path))));
 }
 
 /**

package/src/core/utils.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process from 'node:process';
 import { fileURLToPath } from 'node:url';
-import colors from 'kleur';
-import { posixify, to_fs } from '../utils/filesystem.js';
+import { styleText } from 'node:util';
+import { to_fs } from '../utils/vite.js';
 import { noop } from '../utils/functions.js';
+import { posixify } from '../utils/os.js';
 
 /**
  * Resolved path of the `runtime` directory
@@ -20,10 +20,14 @@ export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', im
  * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
  * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
  * or in a workspace root
+ * @param {string} root
+ * @returns {string}
  */
-export const runtime_base = runtime_directory.startsWith(process.cwd())
-	? `/${path.relative('.', runtime_directory)}`
-	: to_fs(runtime_directory);
+export function get_runtime_base(root) {
+	return runtime_directory.startsWith(root)
+		? `/${path.relative(root, runtime_directory)}`
+		: to_fs(runtime_directory);
+}
 
 /** @param {{ verbose: boolean }} opts */
 export function logger({ verbose }) {
@@ -33,11 +37,10 @@ export function logger({ verbose }) {
 	/** @param {string} msg */
 	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
 
-	log.success = (msg) => log(colors.green(`✔ ${msg}`));
-	log.error = (msg) => err(colors.bold().red(msg));
-	log.warn = (msg) => log(colors.bold().yellow(msg));
-
-	log.minor = verbose ? (msg) => log(colors.grey(msg)) : noop;
+	log.success = (msg) => log(styleText('green', `✔ ${msg}`));
+	log.error = (msg) => err(styleText(['bold', 'red'], msg));
+	log.warn = (msg) => log(styleText(['bold', 'yellow'], msg));
+	log.minor = verbose ? (msg) => log(styleText('grey', msg)) : noop;
 	log.info = verbose ? log : noop;
 
 	return log;