@sveltejs/kit 3.0.0-next.14 → 3.0.0-next.16

package/src/exports/public.d.ts

@@ -121,9 +121,15 @@ type UnpackValidationError<T> =
 export interface Builder {
 	/** Print messages to the console. `log.info` and `log.minor` are silent unless Vite's `logLevel` is `info`. */
 	log: Logger;
-	/** Remove `dir` and all its contents. */
+	/**
+	 * Remove `dir` and all its contents.
+	 * @deprecated Use `fs.rmSync(dir, { force: true, recursive: true })` instead
+	 */
 	rimraf: (dir: string) => void;
-	/** Create `dir` and any required parent directories. */
+	/**
+	 * Create `dir` and any required parent directories.
+	 * @deprecated Use `fs.mkdirSync(dir, { recursive: true })` instead
+	 */
 	mkdirp: (dir: string) => void;
 
 	/** The fully resolved SvelteKit config. */
@@ -1614,7 +1620,7 @@ export interface RequestEvent<
 	/**
 	 * Get or set cookies related to the current request
 	 */
-	cookies: Cookies;
+	readonly cookies: Cookies;
 	/**
 	 * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
 	 *
@@ -1626,15 +1632,15 @@ export interface RequestEvent<
 	 *
 	 * You can learn more about making credentialed requests with cookies [here](https://svelte.dev/docs/kit/load#Cookies).
 	 */
-	fetch: typeof fetch;
+	readonly fetch: typeof fetch;
 	/**
 	 * The client's IP address, set by the adapter.
 	 */
-	getClientAddress: () => string;
+	readonly getClientAddress: () => string;
 	/**
 	 * Contains custom data that was added to the request within the [`server handle hook`](https://svelte.dev/docs/kit/hooks#handle).
 	 */
-	locals: App.Locals;
+	readonly locals: App.Locals;
 	/**
 	 * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
 	 *
@@ -1643,19 +1649,19 @@ export interface RequestEvent<
 	 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
 	 * 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;
+	readonly params: Params;
 	/**
 	 * Additional data made available through the adapter.
 	 */
-	platform: Readonly<App.Platform> | undefined;
+	readonly platform: Readonly<App.Platform> | undefined;
 	/**
 	 * The original request object.
 	 */
-	request: Request;
+	readonly request: Request;
 	/**
 	 * Info about the current route.
 	 */
-	route: {
+	readonly 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.
 		 *
@@ -1688,7 +1694,7 @@ export interface RequestEvent<
 	 *
 	 * You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](https://svelte.dev/docs/kit/@sveltejs-kit#Cookies) API instead.
 	 */
-	setHeaders: (headers: Record<string, string>) => void;
+	readonly setHeaders: (headers: Record<string, string>) => void;
 	/**
 	 * The requested URL.
 	 *
@@ -1697,22 +1703,22 @@ export interface RequestEvent<
 	 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
 	 * 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;
+	readonly url: URL;
 	/**
 	 * `true` if the request comes from the client asking for `+page/layout.server.js` data. The `url` property will be stripped of the internal information
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
 	 */
-	isDataRequest: boolean;
+	readonly isDataRequest: boolean;
 	/**
 	 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 	 */
-	isSubRequest: boolean;
+	readonly isSubRequest: boolean;
 
 	/**
 	 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
 	 * @since 2.31.0
 	 */
-	tracing: {
+	readonly tracing: {
 		/** Whether tracing is enabled. */
 		enabled: boolean;
 		/** The root span for the request. This span is named `sveltekit.handle.root`. */
@@ -1725,7 +1731,7 @@ export interface RequestEvent<
 	 * `true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
 	 */
-	isRemoteRequest: boolean;
+	readonly isRemoteRequest: boolean;
 }
 
 /**

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

@@ -1,7 +1,6 @@
 /** @import { AssetDependencies, ManifestData, SSRNode, ValidatedKitConfig } from 'types' */
 /** @import { Manifest, Rolldown } from 'vite' */
 import fs from 'node:fs';
-import { mkdirp } from '../../../utils/filesystem.js';
 import {
 	create_function_as_string,
 	filter_fonts,
@@ -36,8 +35,8 @@ export function build_server_nodes(
 	chunks,
 	root
 ) {
-	mkdirp(`${out}/server/nodes`);
-	mkdirp(`${out}/server/stylesheets`);
+	fs.mkdirSync(`${out}/server/nodes`, { recursive: true });
+	fs.mkdirSync(`${out}/server/stylesheets`, { recursive: true });
 
 	/**
 	 * Stylesheet names and their contents which are below the inline threshold

package/src/exports/vite/dev/index.js

@@ -8,7 +8,6 @@ import { URL } from 'node:url';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { styleText } from 'node:util';
 import sirv from 'sirv';
-import { isCSSRequest, loadEnv, buildErrorMessage } from 'vite';
 import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { coalesce_to_error } from '../../../utils/error.js';
 import { resolve_entry } from '../../../utils/filesystem.js';
@@ -21,12 +20,7 @@ import * as sync from '../../../core/sync/sync.js';
 import { get_mime_lookup, get_runtime_base } from '../../../core/utils.js';
 import '../../../utils/mime.js'; // extend mrmime with additional types (affects sirv too)
 import { compact } from '../../../utils/array.js';
-import {
-	is_chrome_devtools_request,
-	log_response,
-	not_found,
-	remote_module_pattern
-} from '../utils.js';
+import { is_chrome_devtools_request, is_remote_module, log_response, not_found } from '../utils.js';
 import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
@@ -36,7 +30,8 @@ import { get_runner } from '../../../runner.js';
 const vite_css_query_regex = /(?:\?|&)(?:raw|url|inline)(?:&|$)/;
 
 /**
- * @param {ViteDevServer} vite
+ * @param {typeof import('vite')} vite the peer resolved vite module
+ * @param {ViteDevServer} vite_dev_server
  * @param {ResolvedConfig} vite_config
  * @param {ValidatedConfig} svelte_config
  * @param {() => RemoteChunk[]} get_remotes
@@ -44,7 +39,15 @@ const vite_css_query_regex = /(?:\?|&)(?:raw|url|inline)(?:&|$)/;
  * @param {(manifest_data: ManifestData) => void} set_manifest_data
  * @return {Promise<Promise<() => void>>}
  */
-export async function dev(vite, vite_config, svelte_config, get_remotes, root, set_manifest_data) {
+export async function dev(
+	vite,
+	vite_dev_server,
+	vite_config,
+	svelte_config,
+	get_remotes,
+	root,
+	set_manifest_data
+) {
 	/** @type {AsyncLocalStorage<{ event: RequestEvent, config: any, prerender: PrerenderOption }>} */
 	const async_local_storage = new AsyncLocalStorage();
 
@@ -81,7 +84,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 	/** @type {Error | null} */
 	let manifest_error = null;
 
-	const runner = get_runner(vite);
+	const runner = get_runner(vite, vite_dev_server);
 
 	/**
 	 * @param {string} url
@@ -91,19 +94,19 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 		try {
 			return await runner.import(url);
 		} catch (/** @type {any} */ err) {
-			const msg = buildErrorMessage(err, [
+			const msg = vite.buildErrorMessage(err, [
 				styleText('red', `Internal server error: ${err.message}`)
 			]);
 
-			if (!vite.config.logger.hasErrorLogged(err)) {
-				vite.config.logger.error(msg, { error: err });
+			if (!vite_dev_server.config.logger.hasErrorLogged(err)) {
+				vite_dev_server.config.logger.error(msg, { error: err });
 			}
 
 			// TODO this is inadequate — it doesn't reliably show the overlay on every page load,
 			// and when it does appear it may immediately vanish. `vite.hot.send` broadcasts
 			// to all connected clients, even ones that are unaffected by the error.
 			// we need a more considered approach
-			vite.hot.send({
+			vite_dev_server.hot.send({
 				type: 'error',
 				err: /** @type {ErrorPayload['err']} */ ({
 					...err,
@@ -124,7 +127,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 
 		const module = await loud_ssr_load_module(url);
 
-		const module_node = await vite.environments.ssr.moduleGraph.getModuleByUrl(url);
+		const module_node = await vite_dev_server.environments.ssr.moduleGraph.getModuleByUrl(url);
 		if (!module_node) throw new Error(`Could not find node for ${url}`);
 
 		return { module, module_node, url };
@@ -144,13 +147,13 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 
 			if (manifest_error) {
 				manifest_error = null;
-				vite.hot.send({ type: 'full-reload' });
+				vite_dev_server.hot.send({ type: 'full-reload' });
 			}
 		} catch (error) {
 			manifest_error = /** @type {Error} */ (error);
 
 			console.error(styleText(['bold', 'red'], manifest_error.message));
-			vite.hot.send({
+			vite_dev_server.hot.send({
 				type: 'error',
 				err: {
 					message: manifest_error.message ?? 'Invalid routes',
@@ -261,14 +264,14 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 							const deps = new Set();
 
 							for (const module_node of module_nodes) {
-								await find_deps(vite, module_node, deps);
+								await find_deps(vite_dev_server, module_node, deps);
 							}
 
 							/** @type {Record<string, string>} */
 							const styles = {};
 
 							for (const dep of deps) {
-								if (isCSSRequest(dep.url) && !vite_css_query_regex.test(dep.url)) {
+								if (vite.isCSSRequest(dep.url) && !vite_css_query_regex.test(dep.url)) {
 									const inlineCssUrl = dep.url.includes('?')
 										? dep.url.replace('?', '?inline&')
 										: dep.url + '?inline';
@@ -343,14 +346,17 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 			return;
 		}
 
+		let prelude = '';
+		let start = -1;
 		let end = 0;
 
-		error.stack = error.stack
+		const lines = error.stack
 			.replaceAll('\0', '') // remove null bytes from e.g. virtual module IDs, or the response will fail
 			.split('\n')
 			.map((line, i) => {
-				const match = /^ {4}at (?:[^ ]+ \((.+)\)|(.+))$/.exec(line);
+				const match = /^ {4}at (?:[^(]+ \((.+)\)|(.+))$/.exec(line);
 				if (!match) {
+					prelude += line + '\n';
 					end = i + 1;
 					return line;
 				}
@@ -360,6 +366,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 
 				if (fs.existsSync(file)) {
 					if (!file.includes('node_modules') && !file.includes(SRC_ROOT)) {
+						if (start === -1) start = i;
 						end = i + 1;
 					}
 
@@ -368,10 +375,11 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 
 				return line;
 			})
-			.slice(0, end)
-			.join('\n');
+			// if no user-code frame was found, keep only the prelude (message/header)
+			// lines and drop everything else so the message isn't duplicated
+			.slice(start === -1 ? end : start, end);
 
-		return error.stack;
+		return (error.stack = prelude + lines.join('\n'));
 	}
 
 	const params_file = resolve_entry(svelte_config.kit.files.params);
@@ -381,12 +389,12 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 	 * @param {(file: string) => void} cb
 	 */
 	const watch = (event, cb) => {
-		vite.watcher.on(event, (file) => {
+		vite_dev_server.watcher.on(event, (file) => {
 			if (
 				file.startsWith(svelte_config.kit.files.routes + path.sep) ||
 				file.startsWith(svelte_config.kit.files.assets + path.sep) ||
 				(params_file && file === params_file) ||
-				remote_module_pattern.test(file) ||
+				is_remote_module(file) ||
 				// in contrast to server hooks, client hooks are written to the client manifest
 				// and therefore need rebuilding when they are added/removed
 				file.startsWith(svelte_config.kit.files.hooks.client)
@@ -429,14 +437,14 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 	// kit defaults to src/app.html, so unless user changed that to index.html
 	// send the vite client a full-reload event without path being set
 	if (appTemplate !== 'index.html') {
-		vite.watcher.on('change', (file) => {
+		vite_dev_server.watcher.on('change', (file) => {
 			if (file === appTemplate) {
-				vite.hot.send({ type: 'full-reload' });
+				vite_dev_server.hot.send({ type: 'full-reload' });
 			}
 		});
 	}
 
-	vite.watcher.on('all', (_, file) => {
+	vite_dev_server.watcher.on('all', (_, file) => {
 		if (
 			file === appTemplate ||
 			file === errorTemplate ||
@@ -455,8 +463,8 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 		extensions: []
 	});
 
-	vite.middlewares.use((req, res, next) => {
-		const base = `${vite.config.server.https ? 'https' : 'http'}://${
+	vite_dev_server.middlewares.use((req, res, next) => {
+		const base = `${vite_dev_server.config.server.https ? 'https' : 'http'}://${
 			req.headers[':authority'] || req.headers.host
 		}`;
 
@@ -478,23 +486,23 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 		next();
 	});
 
-	const env = loadEnv(vite_config.mode, svelte_config.kit.env.dir, '');
+	const env = vite.loadEnv(vite_config.mode, svelte_config.kit.env.dir, '');
 	const emulator = await svelte_config.kit.adapter?.emulate?.();
 
 	/** @type {Promise<void> | undefined} */
 	let init_manifest;
 
 	return () => {
-		const serve_static_middleware = vite.middlewares.stack.find(
+		const serve_static_middleware = vite_dev_server.middlewares.stack.find(
 			(middleware) =>
 				/** @type {Function} */ (middleware.handle).name === 'viteServeStaticMiddleware'
 		);
 
 		// Vite will give a 403 on URLs like /test, /static, and /package.json preventing us from
 		// serving routes with those names. See https://github.com/vitejs/vite/issues/7363
-		remove_static_middlewares(vite.middlewares);
+		remove_static_middlewares(vite_dev_server.middlewares);
 
-		vite.middlewares.use(async (req, res) => {
+		vite_dev_server.middlewares.use(async (req, res) => {
 			// Vite throws a Cannot read properties of undefined (reading 'wrapDynamicImport')
 			// if you try to run ssr.runner.import before the server has started so
 			// we do it inside here to avoid that
@@ -504,7 +512,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root, s
 			const original_url = req.url;
 			req.url = req.originalUrl;
 			try {
-				const base = `${vite.config.server.https ? 'https' : 'http'}://${
+				const base = `${vite_dev_server.config.server.https ? 'https' : 'http'}://${
 					req.headers[':authority'] || req.headers.host
 				}`;
 

package/src/exports/vite/index.js

@@ -11,7 +11,7 @@ import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
 import { exactRegex, prefixRegex } from 'rolldown/filter';
 
-import { copy, mkdirp, read, resolve_entry, rimraf } from '../../utils/filesystem.js';
+import { copy, read, resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { to_fs } from '../../utils/vite.js';
 import {
@@ -34,6 +34,7 @@ import { preview } from './preview/index.js';
 import {
 	error_for_missing_config,
 	get_config_aliases,
+	is_remote_module,
 	normalize_id,
 	remote_module_pattern,
 	server_only_directory_pattern,
@@ -106,6 +107,21 @@ const enforced_config = {
 
 const options_regex = /(export\s+const\s+(prerender|csr|ssr|trailingSlash))\s*=/s;
 
+const removed_modules = [
+	{
+		name: '$lib',
+		pattern: /^\$lib(?:\/.*|\?.*)?$/,
+		message:
+			"`$lib` has been removed. Use `#lib` instead: https://svelte.dev/docs/kit/$lib. To keep using `$lib`, add `alias: { '$lib': 'src/lib' }` to your SvelteKit config."
+	},
+	{
+		name: '$service-worker',
+		pattern: /^\$service-worker(?:\?.*)?$/,
+		message:
+			'`$service-worker` has been removed. Use `immutable`, `assets` and `prerendered` from `$app/manifest`, `version` from `$app/env`, and `resolve(...)` from `$app/paths` instead: https://svelte.dev/docs/kit/$service-worker'
+	}
+];
+
 /** @type {Set<string>} */
 const warned = new Set();
 
@@ -316,6 +332,26 @@ function kit({ svelte_config }) {
 		api: {
 			options: svelte_config
 		},
+		resolveId: {
+			filter: { id: removed_modules.map(({ pattern }) => pattern) },
+			async handler(id, importer, options) {
+				const resolved = await this.resolve(id, importer, { ...options, skipSelf: true });
+				if (resolved) return resolved;
+
+				const aliases = svelte_config.kit.alias;
+				for (const { name, pattern, message } of removed_modules) {
+					if (!pattern.test(id)) continue;
+
+					// If the user re-added an alias for this module (as the migration message
+					// suggests), a failed resolution means a genuine missing file rather than
+					// use of the removed module. Let Vite report the real "not found" error
+					// instead of the misleading migration message.
+					if (name in aliases || `${name}/*` in aliases) return;
+
+					throw stackless(message);
+				}
+			}
+		},
 
 		/**
 		 * Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.
@@ -472,6 +508,7 @@ function kit({ svelte_config }) {
 								async handler(id, importer) {
 									const resolved = await this.resolve(id, importer, { skipSelf: true });
 									if (!resolved) return { id, external: true };
+									if (!is_remote_module(resolved.id)) return;
 									// a servable /@fs url; 'absolute' stops rolldown relativizing it in the deps bundle
 									return { id: to_fs(resolved.id), external: 'absolute' };
 								}
@@ -582,7 +619,7 @@ function kit({ svelte_config }) {
 
 		async configResolved(config) {
 			explicit_env_entry = resolve_explicit_env_entry(kit);
-			explicit_env_config = await sync.env(kit, explicit_env_entry, config.root, config.mode);
+			explicit_env_config = await sync.env(vite, kit, explicit_env_entry, config.root, config.mode);
 		},
 
 		configureServer(server) {
@@ -596,6 +633,7 @@ function kit({ svelte_config }) {
 				if (file === explicit_env_entry || file === resolved) {
 					explicit_env_entry = resolved;
 					explicit_env_config = await sync.env(
+						vite,
 						kit,
 						explicit_env_entry,
 						vite_config.root,
@@ -894,6 +932,8 @@ function kit({ svelte_config }) {
 				id: remote_module_pattern
 			},
 			async handler(code, id) {
+				if (!is_remote_module(id)) return;
+
 				const file = posixify(path.relative(root, id));
 				const remote = {
 					hash: hash(file),
@@ -956,7 +996,7 @@ function kit({ svelte_config }) {
 				// being called again with `opts.ssr === true` if the module isn't
 				// already loaded) so we can determine what it exports
 				if (dev_server) {
-					const module = await get_runner(dev_server).import(id);
+					const module = await get_runner(vite, dev_server).import(id);
 
 					for (const [name, value] of Object.entries(module)) {
 						const type = value?.__?.type;
@@ -1503,6 +1543,7 @@ function kit({ svelte_config }) {
 		 */
 		async configureServer(server) {
 			return await dev(
+				vite,
 				server,
 				vite_config,
 				svelte_config,
@@ -1555,9 +1596,9 @@ function kit({ svelte_config }) {
 		async buildApp(builder) {
 			// clears the output directories
 			if (!builder.config.build.watch) {
-				rimraf(out);
+				fs.rmSync(out, { force: true, recursive: true });
 			}
-			mkdirp(out);
+			fs.mkdirSync(out, { recursive: true });
 
 			await load_and_validate_params({
 				routes: manifest_data.routes,

package/src/exports/vite/utils.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { posixify } from '../../utils/os.js';
 import { negotiate } from '../../utils/http.js';
@@ -113,6 +114,16 @@ const query_pattern = /\?.*$/s;
 export function normalize_id(id, aliases, cwd) {
 	id = id.replace(query_pattern, '');
 
+	// check before the cwd is removed — in a user's app these modules live
+	// inside `node_modules`, i.e. within the cwd
+	if (id === app_server) {
+		return '$app/server';
+	}
+
+	if (id === app_env_private || id === sveltekit_env_private) {
+		return '$app/env/private';
+	}
+
 	for (const { alias, path } of aliases) {
 		if (id === path || id.startsWith(path + '/')) {
 			id = id.replace(path, alias);
@@ -124,19 +135,61 @@ export function normalize_id(id, aliases, cwd) {
 		id = path.relative(cwd, id);
 	}
 
-	if (id === app_server) {
-		return '$app/server';
-	}
+	return posixify(id);
+}
 
-	if (id === app_env_private || id === sveltekit_env_private) {
-		return '$app/env/private';
+export const remote_module_pattern = /[/.]remote\.[^/]+$/;
+
+/**
+ * A cache of which directories can export remote modules
+ * @type {Map<string, boolean>}
+ */
+const remote_module_cache = new Map();
+
+/**
+ * Whether `id` is a remote module. Files in node_modules only count if the
+ * package they belong to has a peer dependency on `@sveltejs/kit`
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function is_remote_module(id) {
+	id = posixify(id);
+	if (!remote_module_pattern.test(id)) return false;
+	if (!id.includes('node_modules')) return true;
+
+	return can_export_remote_module(path.dirname(id));
+}
+
+/**
+ * @param {string} directory
+ * @returns {boolean}
+ */
+function can_export_remote_module(directory) {
+	let cached = remote_module_cache.get(directory);
+	if (cached !== undefined) return cached;
+
+	let pkg;
+
+	try {
+		pkg = JSON.parse(fs.readFileSync(path.join(directory, 'package.json'), 'utf8'));
+	} catch {}
+
+	if (pkg?.peerDependencies?.['@sveltejs/kit']) {
+		cached = true;
+	} else {
+		const parent = path.dirname(directory);
+
+		cached =
+			path.basename(directory) === 'node_modules' || parent === directory
+				? false // base case
+				: can_export_remote_module(parent); // recurse
 	}
 
-	return posixify(id);
+	remote_module_cache.set(directory, cached);
+	return cached;
 }
 
-export const remote_module_pattern = /[/.]remote(\.[^/]+)+$/;
-export const server_only_module_pattern = /[/.]server(\.[^/]+)+$/;
+export const server_only_module_pattern = /[/.]server\.[^/]+$/;
 export const server_only_directory_pattern = /\/server\//;
 
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');

package/src/runner.js

@@ -1,10 +1,12 @@
 /** @import { ViteDevServer } from 'vite' */
-import * as vite from 'vite';
 
 /**
+ * @param {typeof import('vite')} vite the peer resolved vite module
  * @param {ViteDevServer} server
  */
-export function get_runner(server) {
+export function get_runner(vite, server) {
+	// `isRunnableDevEnvironment` does an `instanceof` check and will fail if
+	// we're using different instances of Vite
 	if (!vite.isRunnableDevEnvironment(server.environments.ssr)) {
 		throw new Error('The configured Vite SSR environment must be a RunnableDevEnvironment');
 	}

package/src/runtime/app/forms.js

@@ -1,10 +1,9 @@
-import * as devalue from 'devalue';
-import { BROWSER, DEV } from 'esm-env';
+import { DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
 import { refreshAll } from './navigation.js';
-import { app as client_app, applyAction, handle_error } from '../client/client.js';
-import { app as server_app } from '../server/app.js';
+import { applyAction, handle_error } from '../client/client.js';
 import { notify_version } from '../client/state.svelte.js';
+import { parse } from '#app/internal/transport';
 
 export { applyAction };
 
@@ -38,9 +37,7 @@ export function deserialize(result) {
 	const parsed = JSON.parse(result);
 
 	if (parsed.data) {
-		// the decoders should never be initialised at the top-level because `app`
-		// will not be initialised yet if `output.bundleStrategy` is 'single' or 'inline'
-		parsed.data = devalue.parse(parsed.data, BROWSER ? client_app.decoders : server_app.decoders);
+		parsed.data = parse(parsed.data);
 	}
 
 	return parsed;