@sveltejs/kit 3.0.0-next.25 → 3.0.0-next.27

package/src/exports/vite/plugins/env-vars.js

@@ -27,9 +27,6 @@ export function plugin_env_vars(config, callback) {
 	/** @type {ResolvedConfig} */
 	let resolved_config;
 
-	/** @type {string | null} */
-	let resolved_entry = null;
-
 	/** @type {Set<string>} */
 	let deps = new Set();
 
@@ -39,12 +36,8 @@ export function plugin_env_vars(config, callback) {
 	let generated;
 
 	async function generate() {
-		const synced = await sync.env(
-			config,
-			resolved_entry,
-			resolved_config.root,
-			resolved_config.mode
-		);
+		const entry = resolve_env_entry(config, resolved_config.root);
+		const synced = await sync.env(config, entry, resolved_config.root, resolved_config.mode);
 
 		deps = synced.deps;
 
@@ -56,7 +49,7 @@ export function plugin_env_vars(config, callback) {
 			vars,
 			env,
 			dir,
-			resolved_entry && posixify(path.relative(dir, resolved_entry)),
+			entry && posixify(path.relative(dir, entry)),
 			!is_build
 		);
 
@@ -85,34 +78,18 @@ export function plugin_env_vars(config, callback) {
 			// runs once via the memo — per-process, whichever environment starts first
 			// (environment names vary by adapter), and never in the postbuild forks,
 			// which resolve the config without building
-			await (generated ??= (async () => {
-				resolved_entry = resolve_env_entry(config, resolved_config.root);
-				await generate();
-			})());
+			await (generated ??= generate());
 		},
 
-		configureServer(server) {
-			// `handleHotUpdate` only fires for `change` events on files Vite already knows about,
-			// so it doesn't cover the env entry being created or deleted while the dev server is
-			// running. Watch for those events explicitly, re-resolve the entry, regenerate the
-			// modules and trigger a full reload (mirroring the previous behaviour).
-			const on_entry_add_unlink = async (/** @type {string} */ file) => {
-				const resolved = resolve_env_entry(config, resolved_config.root);
-
-				if (file === resolved_entry || file === resolved) {
-					resolved_entry = resolved;
-					await generate();
-					server.hot.send({ type: 'full-reload' });
-				}
-			};
-
-			server.watcher.on('add', on_entry_add_unlink);
-			server.watcher.on('unlink', on_entry_add_unlink);
-		},
+		async hotUpdate({ type, file }) {
+			// runs for every environment; the generated modules are shared, so do the work once
+			if (this.environment.name !== 'client') return;
+
+			const created = type === 'create' && file === resolve_env_entry(config, resolved_config.root);
+			if (!deps.has(file) && !created) return;
 
-		async handleHotUpdate(update) {
-			if (!deps.has(update.file)) return;
 			await generate();
+			if (type !== 'update') this.environment.hot.send({ type: 'full-reload' });
 		}
 	};
 }

package/src/exports/vite/plugins/guard.js

@@ -78,7 +78,7 @@ export function plugin_guard(kit, get_config, get_manifest_data) {
 				// composable filters only work during build so we still need this guard for dev
 				// see https://github.com/vitejs/rolldown-vite/issues/605
 				if (importer && !importer.endsWith('index.html')) {
-					const resolved = await this.resolve(id, importer, { ...options, skipSelf: true });
+					const resolved = await this.resolve(id, importer, options);
 
 					if (resolved) {
 						const normalized = normalize_id(resolved.id, normalized_aliases, normalized_cwd);
@@ -111,7 +111,7 @@ export function plugin_guard(kit, get_config, get_manifest_data) {
 				let is_server_only = normalized === '$app/env/private' || normalized === '$app/server';
 
 				// skip .server.js files outside the cwd or in node_modules, as the filename might not mean 'server-only module' in this context
-				if (id.startsWith(normalized_cwd) && !id.startsWith(normalized_node_modules)) {
+				if (id.startsWith(normalized_cwd + '/') && !id.startsWith(normalized_node_modules + '/')) {
 					// e.g. `server.ts` or `foo.server.ts`
 					is_server_only ||= server_only_module_pattern.test(id);
 
@@ -128,16 +128,28 @@ export function plugin_guard(kit, get_config, get_manifest_data) {
 
 				/** @type {Set<string>} */
 				const entrypoints = new Set();
+
+				/**
+				 * Entrypoints must be normalized like the import map keys, or files
+				 * outside the project root (e.g. hooks) would never match an importer
+				 * @param {string} file - absolute, or relative to the project root
+				 */
+				const add_entrypoint = (file) => {
+					entrypoints.add(
+						normalize_id(posixify(path.resolve(root, file)), normalized_aliases, normalized_cwd)
+					);
+				};
+
 				for (const node of manifest_data.nodes) {
-					if (node.component) entrypoints.add(node.component);
-					if (node.universal) entrypoints.add(node.universal);
+					if (node.component) add_entrypoint(node.component);
+					if (node.universal) add_entrypoint(node.universal);
 				}
 
-				if (manifest_data.hooks.client) entrypoints.add(manifest_data.hooks.client);
-				if (manifest_data.hooks.universal) entrypoints.add(manifest_data.hooks.universal);
+				if (manifest_data.hooks.client) add_entrypoint(manifest_data.hooks.client);
+				if (manifest_data.hooks.universal) add_entrypoint(manifest_data.hooks.universal);
 
 				if (service_worker_entry_file) {
-					entrypoints.add(posixify(path.relative(root, service_worker_entry_file)));
+					add_entrypoint(service_worker_entry_file);
 				}
 
 				// Walk up the import graph from the server-only module, looking for a chain

package/src/exports/vite/plugins/remote.js

@@ -0,0 +1,237 @@
+/** @import { RemoteChunk, RemoteInternals, ServerMetadata, ValidatedConfig } from 'types' */
+/** @import { Plugin, ViteDevServer } from 'vite' */
+import path from 'node:path';
+import { prefixRegex } from '@rolldown/pluginutils';
+import MagicString from 'magic-string';
+import { error_for_missing_config, is_remote_module, remote_module_pattern } from '../utils.js';
+import { create_exported_declarations } from '../../../core/env.js';
+import { dedent } from '../../../core/sync/utils.js';
+import { runtime_directory } from '../../../core/utils.js';
+import { get_runner } from '../../../runner.js';
+import { hash } from '../../../utils/hash.js';
+import { s } from '../../../utils/misc.js';
+import { posixify } from '../../../utils/os.js';
+
+/**
+ * @param {ValidatedConfig} svelte_config
+ * @param {() => { root: string; vite: typeof import('vite'); }} get_config
+ * @param {() => ServerMetadata | null} get_build_metadata
+ * @param {(remote_metadata: {remotes: RemoteChunk[]; remote_original_by_hash: Map<string, string>}) => void} set_remote_metadata
+ * @returns {Plugin}
+ */
+export function plugin_remote(svelte_config, get_config, get_build_metadata, set_remote_metadata) {
+	/** @type {string} */
+	let root;
+	/** @type {typeof import('vite')} */
+	let vite;
+
+	/** @type {ViteDevServer} */
+	let dev_server;
+
+	/** @type {ServerMetadata | null} */
+	let build_metadata;
+
+	/** @type {RemoteChunk[]} */
+	let remotes = [];
+
+	/** @type {Map<string, string>} Maps remote hash -> original module id */
+	const remote_original_by_hash = new Map();
+	/** @type {Set<string>} Track which remote hashes have already been emitted */
+	const emitted_remote_hashes = new Set();
+
+	return {
+		name: 'vite-plugin-sveltekit-remote',
+
+		configResolved() {
+			({ root, vite } = get_config());
+		},
+
+		configureServer(_dev_server) {
+			dev_server = _dev_server;
+		},
+
+		applyToEnvironment(environment) {
+			return svelte_config.experimental.remoteFunctions && environment.name !== 'serviceWorker';
+		},
+
+		perEnvironmentStartEndDuringDev: true,
+
+		buildStart() {
+			// avoid stale data when building with watch mode
+			if (this.meta.watchMode && this.environment.config.consumer === 'server') {
+				remotes = [];
+				remote_original_by_hash.clear();
+				emitted_remote_hashes.clear();
+			}
+
+			build_metadata = get_build_metadata();
+			set_remote_metadata({ remotes, remote_original_by_hash });
+		},
+
+		// prevent other plugins from resolving our remote virtual module
+		resolveId: {
+			filter: {
+				id: prefixRegex('\0sveltekit-remote:')
+			},
+			handler(id) {
+				return id;
+			}
+		},
+
+		load: {
+			filter: {
+				id: prefixRegex('\0sveltekit-remote:')
+			},
+			handler(id) {
+				// On-the-fly generated entry point for remote file just forwards the original module
+				// We're not using manualChunks because it can cause problems with circular dependencies
+				// (e.g. https://github.com/sveltejs/kit/issues/14679) and module ordering in general
+				// (e.g. https://github.com/sveltejs/kit/issues/14590).
+				const hash_id = id.slice('\0sveltekit-remote:'.length);
+				const original = remote_original_by_hash.get(hash_id);
+				if (!original) throw new Error(`Expected to find metadata for remote file ${id}`);
+				return `import * as m from ${s(original)};\nexport default m;`;
+			}
+		},
+
+		transform: {
+			filter: {
+				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),
+					file
+				};
+
+				if (this.environment.config.consumer === 'server') {
+					remotes.push(remote);
+
+					// we need to add an `await Promise.resolve()` because if the user imports this function
+					// on the client AND in a load function when loading the client module we will trigger
+					// an import during dev. During a link preload, the module can be mistakenly
+					// loaded and transformed twice and the first time all its exports would be undefined
+					// triggering a dev server error. By adding a microtask we ensure that the module is fully loaded
+					const ms = new MagicString(code);
+
+					// Extra newlines to prevent syntax errors around missing semicolons or comments
+					ms.append(
+						'\n\n' +
+							dedent`
+								import * as $$_self_$$ from './${path.basename(id)}';
+								import { init_remote_functions as $$_init_$$ } from '@sveltejs/kit/internal/server';
+
+								${dev_server ? 'await Promise.resolve()' : ''}
+
+								$$_init_$$($$_self_$$, ${s(file)}, ${s(remote.hash)});
+
+								for (const [name, fn] of Object.entries($$_self_$$)) {
+									fn.__.id = ${s(remote.hash)} + '/' + name;
+									fn.__.name = name;
+								}
+							`
+					);
+
+					// Emit a dedicated entry chunk for this remote in SSR builds (prod only)
+					if (!dev_server) {
+						remote_original_by_hash.set(remote.hash, id);
+
+						if (!emitted_remote_hashes.has(remote.hash)) {
+							this.emitFile({
+								type: 'chunk',
+								id: `\0sveltekit-remote:${remote.hash}`,
+								name: `remote-${remote.hash}`
+							});
+							emitted_remote_hashes.add(remote.hash);
+						}
+					}
+
+					return {
+						code: ms.toString(),
+						map: ms.generateMap({ hires: 'boundary' })
+					};
+				}
+
+				// For the client, read the exports and create a new module that only contains fetch functions with the correct metadata
+
+				/** @type {Map<string, RemoteInternals['type']>} */
+				const map = new Map();
+
+				// in dev, load the server module here (which will result in this hook
+				// 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(vite, dev_server).import(id);
+
+					for (const [name, value] of Object.entries(module)) {
+						const type = value?.__?.type;
+						if (type) map.set(name, type);
+					}
+				}
+				// in prod, we already built and analysed the server code before
+				// building the client code, so `remotes` is populated
+				else if (build_metadata?.remotes) {
+					const exports = build_metadata.remotes.get(remote.hash);
+					if (!exports) throw new Error('Expected to find metadata for remote file ' + id);
+
+					for (const [name, value] of exports) {
+						map.set(name, value.type);
+					}
+				}
+
+				const { namespace, declarations, reexports } = create_exported_declarations(
+					map.keys(),
+					(name, ns) => `${ns}.${map.get(name)}('${remote.hash}/${name}')`,
+					'__remote'
+				);
+
+				const relative = posixify(
+					path.relative(path.dirname(id), `${runtime_directory}/client/remote-functions/index.js`)
+				);
+
+				let result = `import * as ${namespace} from '${relative}';\n\n${declarations.join('\n')}`;
+				if (reexports.length > 0) {
+					result += `\nexport { ${reexports.join(', ')} };`;
+				}
+				result += '\n';
+
+				if (dev_server) {
+					result += `\nimport.meta.hot?.accept();\n`;
+				}
+
+				return {
+					code: result,
+					map: null
+				};
+			}
+		}
+	};
+}
+
+/**
+ * @param {ValidatedConfig} svelte_config
+ * @returns {Plugin}
+ */
+export function plugin_remote_guard(svelte_config) {
+	return {
+		name: 'vite-plugin-sveltekit-remote-guard',
+
+		applyToEnvironment() {
+			return !svelte_config.experimental.remoteFunctions;
+		},
+
+		transform: {
+			filter: {
+				id: new RegExp(
+					`.remote(${svelte_config.moduleExtensions.join('|')})$`.replaceAll('.', '\\.')
+				)
+			},
+			handler() {
+				error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true');
+			}
+		}
+	};
+}

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

@@ -1,5 +1,5 @@
 /** @import { NextHandleFunction } from 'connect' */
-/** @import { PreviewServer, ResolvedConfig } from 'vite' */
+/** @import { PreviewServer } from 'vite' */
 /** @import { ValidatedConfig, ServerInternalModule, ServerModule } from 'types' */
 import fs from 'node:fs';
 import { join } from 'node:path';
@@ -15,15 +15,14 @@ import { stackless } from '../../../utils/error.js';
 
 /**
  * @param {PreviewServer} vite
- * @param {ResolvedConfig} vite_config
  * @param {ValidatedConfig} svelte_config
  */
-export async function preview(vite, vite_config, svelte_config) {
+export async function preview(vite, svelte_config) {
 	const { paths } = svelte_config;
 	const base = paths.base;
 	const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
 
-	const protocol = vite_config.preview.https ? 'https' : 'http';
+	const protocol = vite.config.preview.https ? 'https' : 'http';
 
 	const etag = `"${Date.now()}"`;
 
@@ -44,6 +43,7 @@ export async function preview(vite, vite_config, svelte_config) {
 	/** @type {ServerModule} */
 	const { Server } = await import(pathToFileURL(join(dir, 'index.js')).href);
 
+	/** @type {{ manifest: import('types').SSRManifest }} */
 	const { manifest } = await import(pathToFileURL(join(dir, 'manifest.js')).href);
 
 	set_assets(assets);
@@ -52,7 +52,7 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	try {
 		await server.init({
-			env: loadEnv(vite_config.mode, svelte_config.env.dir, ''),
+			env: loadEnv(vite.config.mode, svelte_config.env.dir, ''),
 			read: (file) => createReadableStream(`${dir}/${file}`)
 		});
 	} catch (error) {
@@ -205,13 +205,13 @@ export async function preview(vite, vite_config, svelte_config) {
 		vite.middlewares.use(async (req, res) => {
 			const host = req.headers[':authority'] || req.headers.host;
 
-			const request = getRequest({
+			const request = (svelte_config.adapter?.vite?.getRequest ?? getRequest)({
 				base: `${protocol}://${host}`,
 				request: req,
 				response: res
 			});
 
-			setResponse(
+			(svelte_config.adapter?.vite?.setResponse ?? setResponse)(
 				res,
 				await server.respond(request, {
 					getClientAddress: () => {
@@ -220,7 +220,7 @@ export async function preview(vite, vite_config, svelte_config) {
 						throw new Error('Could not determine clientAddress');
 					},
 					read: (file) => {
-						if (file in manifest._.server_assets) {
+						if (file in manifest.server_assets) {
 							return fs.readFileSync(join(dir, file));
 						}
 

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

@@ -1,7 +1,7 @@
 /** @import { PageOptions } from './types.js' */
+/** @import { ESTree } from 'vite' */
 import path from 'node:path';
-import { tsPlugin } from '@sveltejs/acorn-typescript';
-import { Parser } from 'acorn';
+import { parseSync } from 'vite';
 import { read } from '../../../utils/filesystem.js';
 
 export const valid_page_options_array = /** @type {const} */ ([
@@ -21,8 +21,6 @@ const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );
 
-const parser = Parser.extend(tsPlugin());
-
 /**
  * Collects page options from a +page.js/+layout.js file, ignoring reassignments
  * and using the declared value (except for load functions, for which the value is `true`).
@@ -39,15 +37,13 @@ export function statically_analyse_page_options(filename, input) {
 	}
 
 	try {
-		const source = parser.parse(input, {
-			sourceType: 'module',
-			ecmaVersion: 'latest'
-		});
+		const source = parseSync(filename, input, { sourceType: 'module' });
+		if (source.errors.length) throw new Error(source.errors[0].message);
 
-		/** @type {Map<string, import('acorn').Literal['value']>} */
+		/** @type {Map<string, Extract<ESTree.Expression, { type: 'Literal' }>['value']>} */
 		const page_options = new Map();
 
-		for (const statement of source.body) {
+		for (const statement of source.program.body) {
 			// ignore export all declarations with aliases that are not page options
 			if (
 				statement.type === 'ExportAllDeclaration' &&
@@ -82,7 +78,7 @@ export function statically_analyse_page_options(filename, input) {
 					export_specifiers.set(get_name(specifier.local), exported_name);
 				}
 
-				for (const statement of source.body) {
+				for (const statement of source.program.body) {
 					switch (statement.type) {
 						case 'ImportDeclaration': {
 							for (const import_specifier of statement.specifiers) {
@@ -105,7 +101,10 @@ export function statically_analyse_page_options(filename, input) {
 
 							// class and function declarations
 							if (declaration.type !== 'VariableDeclaration') {
-								if (export_specifiers.has(declaration.id.name)) {
+								if (
+									declaration.id?.type === 'Identifier' &&
+									export_specifiers.has(declaration.id.name)
+								) {
 									return null;
 								}
 								break;
@@ -156,9 +155,10 @@ export function statically_analyse_page_options(filename, input) {
 
 			// class and function declarations
 			if (statement.declaration.type !== 'VariableDeclaration') {
-				if (valid_page_options.has(statement.declaration.id.name)) {
+				const { id } = statement.declaration;
+				if (id?.type === 'Identifier' && valid_page_options.has(id.name)) {
 					// Special case: We only want to know that 'load' is exported (in a way that doesn't cause truthy checks in other places to trigger)
-					if (statement.declaration.id.name === 'load') {
+					if (id.name === 'load') {
 						page_options.set('load', null);
 					} else {
 						return null;
@@ -202,7 +202,7 @@ export function statically_analyse_page_options(filename, input) {
 }
 
 /**
- * @param {import('acorn').Identifier | import('acorn').Literal} node
+ * @param {ESTree.ModuleExportName} node
  * @returns {string}
  */
 function get_name(node) {

package/src/exports/vite/utils.js

@@ -134,7 +134,7 @@ export function normalize_id(id, aliases, cwd) {
 		}
 	}
 
-	if (id.startsWith(cwd)) {
+	if (id.startsWith(cwd + '/')) {
 		id = path.relative(cwd, id);
 	}
 

package/src/runner.js

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

package/src/runtime/app/paths/server.js

@@ -83,8 +83,8 @@ export async function match(url) {
 		resolved_path = resolved_path.slice(base.length) || '/';
 	}
 
-	const matchers = await manifest._.matchers();
-	const result = find_route(resolved_path, manifest._.routes, matchers);
+	const matchers = await manifest.matchers();
+	const result = find_route(resolved_path, manifest.routes, matchers);
 
 	if (result) {
 		return {

package/src/runtime/app/server/index.js

@@ -59,9 +59,9 @@ export function read(asset) {
 			: asset.slice(assets.length + 1)
 	);
 
-	if (file in manifest._.server_assets) {
-		const length = manifest._.server_assets[file];
-		const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+	if (file in manifest.server_assets) {
+		const length = manifest.server_assets[file];
+		const type = manifest.mime_types[file.slice(file.lastIndexOf('.'))];
 
 		return new Response(read_implementation(file), {
 			headers: {