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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.25",
+  "version": "3.0.0-next.27",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -20,8 +20,6 @@
   "dependencies": {
     "@rolldown/pluginutils": "^1.0.1",
     "@standard-schema/spec": "^1.1.0",
-    "@sveltejs/acorn-typescript": "^1.0.12",
-    "acorn": "^8.18.0",
     "cookie": "^2.0.1",
     "devalue": "^5.9.0",
     "esm-env": "^1.2.2",
@@ -31,14 +29,14 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@playwright/test": "^1.62.0",
+    "@playwright/test": "^1.62.1",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@types/connect": "^3.4.38",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@types/node": "^22.19.19",
     "dts-buddy": "^0.8.3",
     "jsdom": "^30.0.0",
-    "svelte": "^5.56.8",
+    "svelte": "^5.57.0",
     "svelte-preprocess": "^6.0.5",
     "typescript": "~6.0.3",
     "valibot": "^1.4.2",
@@ -66,8 +64,8 @@
   "files": [
     "src",
     "!src/**/*.spec.js",
-    "!src/core/**/fixtures",
-    "!src/core/**/test",
+    "!src/**/fixtures",
+    "!src/**/test",
     "types",
     "svelte-kit.js"
   ],

package/src/core/adapt/builder.js

@@ -13,19 +13,21 @@ import {
 	rmSync,
 	statSync
 } from 'node:fs';
-import { extname, resolve, join, dirname, relative } from 'node:path';
+import path from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
-import { copy, walk } from '../../utils/filesystem.js';
+import { copy, relative_path, walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { generate_manifest } from '../generate_manifest/index.js';
 import { get_route_segments } from '../../utils/routing.js';
 import generate_fallback from '../postbuild/fallback.js';
-import { write } from '../sync/utils.js';
+import { dedent, write } from '../sync/utils.js';
 import { find_server_assets } from '../generate_manifest/find_server_assets.js';
 import { create_exported_declarations } from '../env.js';
 import { handle_issues, validate } from '../../exports/internal/env.js';
+import { get_mime_lookup } from '../utils.js';
+import { lookup as mime_lookup } from '../../utils/mime.js';
 
 const pipe = promisify(pipeline);
 const extensions = [
@@ -51,6 +53,7 @@ const extensions = [
  *   route_data: RouteData[];
  *   prerendered: Prerendered;
  *   prerender_map: PrerenderMap;
+ *   app_manifest: typeof import('$app/manifest');
  *   log: Logger;
  *   vite_config: ResolvedConfig;
  *   remotes: RemoteChunk[];
@@ -65,6 +68,7 @@ export function create_builder({
 	route_data,
 	prerendered,
 	prerender_map,
+	app_manifest,
 	log,
 	vite_config,
 	remotes,
@@ -103,6 +107,12 @@ export function create_builder({
 		return facade;
 	});
 
+	// $app/manifest cannot include the service worker because it's used by the service worker itself,
+	// but the adapter needs to know about it so we add it here.
+	if (build_data.service_worker) {
+		app_manifest.assets.push({ path: build_data.service_worker });
+	}
+
 	return {
 		log,
 		rimraf: (dir) => rmSync(dir, { force: true, recursive: true }),
@@ -112,17 +122,38 @@ export function create_builder({
 		config,
 		prerendered,
 		routes,
+		manifest: app_manifest,
+		get mimeTypes() {
+			// TODO - make the `generate_manifest` function return data instead of a string, and retrieve mime types from there
+			const mime_types = get_mime_lookup(build_data.manifest_data);
+			const server_assets = find_server_assets(
+				build_data,
+				route_data.filter((route) => prerender_map.get(route.id) !== true),
+				vite_config.root
+			);
+			for (const file of server_assets) {
+				const ext = path.extname(file);
+				mime_types[ext] ??= mime_lookup(ext) || '';
+			}
+
+			// record extensions that only exist in prerendered output, e.g. a prerendered favicon.ico
+			for (const pathname of prerendered.paths) {
+				const ext = path.extname(pathname);
+				if (ext) mime_types[ext] ??= mime_lookup(ext) || '';
+			}
+			return mime_types;
+		},
 
 		async compress(directory) {
 			if (!existsSync(directory)) {
 				return [];
 			}
 
-			const files = [...walk(directory)].filter((file) => extensions.includes(extname(file)));
+			const files = [...walk(directory)].filter((file) => extensions.includes(path.extname(file)));
 
 			await Promise.all(
 				files.flatMap((file) => {
-					const abs = resolve(directory, file);
+					const abs = path.resolve(directory, file);
 					return [compress_file(abs, 'gz'), compress_file(abs, 'br')];
 				})
 			);
@@ -184,17 +215,34 @@ export function create_builder({
 			write(`${dest}/env.js`, `export const env=${payload}`);
 		},
 
-		generateManifest({ relativePath, routes: subset }) {
-			return generate_manifest({
-				build_data,
-				prerendered: prerendered.paths,
-				relative_path: relativePath,
-				routes: subset
-					? subset.map((route) => /** @type {import('types').RouteData} */ (lookup.get(route)))
-					: route_data.filter((route) => prerender_map.get(route.id) !== true),
-				remotes,
-				root: vite_config.root
-			});
+		generateManifest() {
+			throw new Error(
+				'The `generateManifest` adapter API has been removed — use `generateServerInstance` or `builder.manifest` instead. You may need to update your adapter'
+			);
+		},
+
+		generateServerInstance(dest, { routes: subset, serverDirectory } = {}) {
+			const relative = relative_path(
+				path.dirname(dest),
+				serverDirectory ?? this.getServerDirectory()
+			);
+			write(
+				dest,
+				dedent`
+					import { Server } from '${relative}/index.js';
+					const manifest = ${generate_manifest({
+						build_data,
+						prerendered: prerendered.paths,
+						relative_path: relative,
+						routes: subset
+							? subset.map((route) => /** @type {import('types').RouteData} */ (lookup.get(route)))
+							: route_data.filter((route) => prerender_map.get(route.id) !== true),
+						remotes,
+						root: vite_config.root
+					})};
+					export const server = new Server(manifest);
+				`
+			);
 		},
 
 		getBuildDirectory(name) {
@@ -234,6 +282,30 @@ export function create_builder({
 			return copy(`${config.outDir}/output/server`, dest);
 		},
 
+		createInstrumentationInitializer({
+			outputDirectory,
+			environment,
+			serverDirectory = `${config.outDir}/output/server`
+		}) {
+			const provider = path.join(outputDirectory, '__sveltekit_env.js');
+			write(provider, environment ?? 'export default process.env;');
+
+			const initializer = path.join(outputDirectory, '__sveltekit_env_init.js');
+			write(
+				initializer,
+				create_env_module({
+					environment: to_import_specifier(
+						posixify(path.relative(path.dirname(initializer), provider))
+					),
+					set_env: to_import_specifier(
+						posixify(path.relative(path.dirname(initializer), `${serverDirectory}/env.js`))
+					)
+				})
+			);
+
+			return initializer;
+		},
+
 		hasServerInstrumentationFile() {
 			return existsSync(`${config.outDir}/output/server/instrumentation.server.js`);
 		},
@@ -241,7 +313,8 @@ export function create_builder({
 		instrument({
 			entrypoint,
 			instrumentation,
-			start = join(dirname(entrypoint), 'start.js'),
+			start = path.join(path.dirname(entrypoint), 'start.js'),
+			initializer,
 			module = {
 				exports: ['default']
 			}
@@ -256,25 +329,35 @@ export function create_builder({
 					`Entrypoint file ${entrypoint} not found. This is probably a bug in your adapter.`
 				);
 			}
+			if (!existsSync(initializer)) {
+				throw new Error(
+					`Instrumentation initializer ${initializer} not found. This is probably a bug in your adapter.`
+				);
+			}
 
 			copy(entrypoint, start);
 			if (existsSync(`${entrypoint}.map`)) {
 				copy(`${entrypoint}.map`, `${start}.map`);
 			}
 
-			const relative_instrumentation = posixify(relative(dirname(entrypoint), instrumentation));
-			const relative_start = posixify(relative(dirname(entrypoint), start));
+			const relative_instrumentation = posixify(
+				path.relative(path.dirname(entrypoint), instrumentation)
+			);
+			const relative_start = posixify(path.relative(path.dirname(entrypoint), start));
+			const relative_initializer = posixify(path.relative(path.dirname(entrypoint), initializer));
 
 			const facade =
 				'generateText' in module
 					? module.generateText({
 							instrumentation: relative_instrumentation,
-							start: relative_start
+							start: relative_start,
+							initializer: relative_initializer
 						})
 					: create_instrumentation_facade({
 							instrumentation: relative_instrumentation,
 							start: relative_start,
-							exports: module.exports
+							exports: module.exports,
+							initializer: relative_initializer
 						});
 
 			rmSync(entrypoint, { force: true, recursive: true });
@@ -307,16 +390,15 @@ async function compress_file(file, format = 'gz') {
 
 /**
  * Given a list of exports, generate a facade that:
+ * - Imports the environment initializer
  * - Imports the instrumentation file
- * - Imports `exports` from the entrypoint (dynamically, if `tla` is true)
+ * - Imports `exports` from the entrypoint (dynamically)
  * - Re-exports `exports` from the entrypoint
  *
- * @param {{ instrumentation: string; start: string; exports: string[] }} opts
+ * @param {{ instrumentation: string; start: string; exports: string[]; initializer: string }} opts
  * @returns {string}
  */
-function create_instrumentation_facade({ instrumentation, start, exports }) {
-	const import_instrumentation = `import './${instrumentation}';`;
-
+function create_instrumentation_facade({ instrumentation, start, exports, initializer }) {
 	const { namespace, declarations, reexports } = create_exported_declarations(
 		exports,
 		(name, ns) => `${ns}.${name}`,
@@ -324,12 +406,26 @@ function create_instrumentation_facade({ instrumentation, start, exports }) {
 	);
 
 	const parts = [
-		`const ${namespace} = await import('./${start}');`,
+		`import ${JSON.stringify(to_import_specifier(initializer))};`,
+		`import ${JSON.stringify(to_import_specifier(instrumentation))};`,
+		`const ${namespace} = await import(${JSON.stringify(to_import_specifier(start))});`,
 		declarations.join('\n'),
 		reexports.length > 0 ? `export { ${reexports.join(', ')} };` : ''
-	]
-		.filter(Boolean)
-		.join('\n');
+	];
 
-	return `${import_instrumentation}\n${parts}`;
+	return parts.filter(Boolean).join('\n');
+}
+
+/**
+ * @param {string} path
+ */
+function to_import_specifier(path) {
+	return path.startsWith('.') ? path : `./${path}`;
+}
+
+/**
+ * @param {{ environment: string; set_env: string }} opts
+ */
+function create_env_module({ environment, set_env }) {
+	return `import env from ${JSON.stringify(environment)};\nimport { set_env } from ${JSON.stringify(set_env)};\nset_env(env);\n`;
 }

package/src/core/adapt/index.js

@@ -7,6 +7,7 @@ import { create_builder } from './builder.js';
  * @param {import('types').ServerMetadata} server_metadata
  * @param {import('types').Prerendered} prerendered
  * @param {import('types').PrerenderMap} prerender_map
+ * @param {typeof import('$app/manifest')} app_manifest
  * @param {import('types').Logger} log
  * @param {import('types').RemoteChunk[]} remotes
  * @param {import('vite').ResolvedConfig} vite_config
@@ -18,6 +19,7 @@ export async function adapt(
 	server_metadata,
 	prerendered,
 	prerender_map,
+	app_manifest,
 	log,
 	remotes,
 	vite_config,
@@ -48,6 +50,7 @@ export async function adapt(
 		route_data: build_data.manifest_data.routes.filter((route) => route.page || route.endpoint),
 		prerendered,
 		prerender_map,
+		app_manifest,
 		log,
 		remotes,
 		vite_config,

package/src/core/config/index.js

@@ -200,13 +200,10 @@ export function validate_config(config) {
 			}
 		}
 
-		if (
-			validated.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
-			!validated.csp?.directives?.['trusted-types']?.includes('svelte-trusted-html')
-		) {
-			throw new Error(
-				"The `csp.directives['trusted-types']` option must include 'svelte-trusted-html'"
-			);
+		if (typeof config.adapter?.vite === 'function') {
+			validated.adapter.vite = config.adapter.vite({
+				config: validated
+			});
 		}
 
 		return validated;

package/src/core/env.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import * as devalue from 'devalue';
 import { dedent } from './sync/utils.js';
 import { get_global_name, runtime_directory } from './utils.js';
+import { stackless } from '../utils/error.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';
@@ -22,7 +23,9 @@ import { posixify } from '../utils/os.js';
  * @returns {string | null}
  */
 export function resolve_env_entry(config, root) {
-	return resolve_entry(path.resolve(root, config.files.src, 'env'));
+	const entry = resolve_entry(path.resolve(root, config.files.src, 'env'));
+	// posix, like the paths Vite hands to `hotUpdate`
+	return entry && posixify(entry);
 }
 
 /**
@@ -35,6 +38,8 @@ export function resolve_env_entry(config, root) {
 export async function load_explicit_env(kit, file, root, mode) {
 	/** @type {Set<string>} */
 	const deps = new Set();
+	/** @type {Map<EnvType, string>} */
+	const env_importers = new Map();
 
 	if (!file) {
 		return { variables: null, deps };
@@ -62,6 +67,16 @@ export async function load_explicit_env(kit, file, root, mode) {
 		plugins: [
 			{
 				name: 'dependency-scanner',
+				enforce: 'pre',
+				resolveId(id, importer) {
+					const prefixes = ['$app/env/', `${runtime_directory}/app/env/`];
+					const prefix = prefixes.find((prefix) => id.startsWith(prefix));
+					const type = prefix && id.slice(prefix.length);
+
+					if (importer && (type === 'private' || type === 'public')) {
+						env_importers.set(type, importer);
+					}
+				},
 				load(id) {
 					deps.add(id);
 				}
@@ -94,14 +109,27 @@ export async function load_explicit_env(kit, file, root, mode) {
 	} catch (e) {
 		const error = /** @type {any} */ (e || {});
 
-		if (
-			error.code === 'ERR_MODULE_NOT_FOUND' &&
-			error.message?.includes(`Cannot find module '$app`)
-		) {
-			throw new Error(
-				`Cannot import \`$app/*\` modules other than \`$app/env\` inside \`src/env\``,
-				{ cause: e }
+		if (error.code === 'ERR_MODULE_NOT_FOUND') {
+			const match = error.message?.match(
+				/<sveltekit:generated>\/env\/(private|public)\/server\.js/
 			);
+
+			if (match) {
+				const type = /** @type {EnvType} */ (match[1]);
+				const importer = env_importers.get(type);
+				const message = importer
+					? `Module \`${posixify(path.relative(root, importer))}\` imports \`$app/env/${type}\`, which creates a circular dependency with \`src/env\``
+					: `Cannot import \`$app/env/${type}\` inside \`src/env\` or its dependencies because it creates a circular dependency`;
+
+				throw stackless(message);
+			}
+
+			if (error.message?.includes(`Cannot find module '$app`)) {
+				throw new Error(
+					`Cannot import \`$app/*\` modules other than \`$app/env\` inside \`src/env\``,
+					{ cause: e }
+				);
+			}
 		}
 
 		throw error;

package/src/core/generate_manifest/index.js

@@ -1,4 +1,4 @@
-/** @import { RemoteChunk } from 'types' */
+/** @import { BuildData, RemoteChunk, RouteData } from 'types' */
 import fs from 'node:fs';
 import path from 'node:path';
 import { lookup as mime_lookup } from '../../utils/mime.js';
@@ -15,10 +15,10 @@ import { uneval } from 'devalue';
  * Generates the data used to write the server-side manifest.js file. This data is used in the Vite
  * build process, to power routing, etc.
  * @param {{
- *   build_data: import('types').BuildData;
+ *   build_data: BuildData;
  *   prerendered: string[];
  *   relative_path: string;
- *   routes: import('types').RouteData[];
+ *   routes: RouteData[];
  *   remotes: RemoteChunk[];
  *   root: string;
  * }} opts
@@ -102,49 +102,48 @@ export function generate_manifest({
 
 	// prettier-ignore
 	// String representation of
-	/** @template {import('@sveltejs/kit').SSRManifest} T */
+	/** @template {import('types').SSRManifest} T */
 	const manifest_expr = dedent`
 		{
-			appDir: ${s(build_data.app_dir)},
-			appPath: ${s(build_data.app_path)},
+			app_dir: ${s(build_data.app_dir)},
+			app_path: ${s(build_data.app_path)},
 			assets: new Set(${s(assets)}),
-			mimeTypes: ${s(mime_types)},
-			_: {
-				client: ${uneval(build_data.client)},
-				nodes: [
-					${(node_paths).map(loader).join(',\n')}
-				],
-				remotes: {
-					${remotes.map((remote) => `'${remote.hash}': ${loader(join_relative(relative_path, `chunks/remote-${remote.hash}.js`))}`).join(',\n')}
-				},
-				routes: [
-					${routes.map(route => {
-						if (!route.page && !route.endpoint) return;
-
-						return dedent`
-							{
-								id: ${s(route.id)},
-								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, root).chunk.file)) : 'null'}
-							}
-						`;
-					}).filter(Boolean).join(',\n')}
-				],
-				prerendered_routes: new Set(${s(prerendered)}),
-				matchers: async () => {
-					${
-						uses_matchers && build_data.manifest_data.params
-							? dedent`
-								const { params } = await import('${join_relative(relative_path, '/entries/params.js')}');
-								return params;
-							`
-							: 'return {};'
-					}
-				},
-				server_assets: ${s(files)}
-			}
+			mime_types: ${s(mime_types)},
+			client: ${uneval(build_data.client)},
+			
+			nodes: [
+				${(node_paths).map(loader).join(',\n')}
+			],
+			remotes: {
+				${remotes.map((remote) => `'${remote.hash}': ${loader(join_relative(relative_path, `chunks/remote-${remote.hash}.js`))}`).join(',\n')}
+			},
+			routes: [
+				${routes.map(route => {
+					if (!route.page && !route.endpoint) return;
+
+					return dedent`
+						{
+							id: ${s(route.id)},
+							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, root).chunk.file)) : 'null'}
+						}
+					`;
+				}).filter(Boolean).join(',\n')}
+			],
+			prerendered_routes: new Set(${s(prerendered)}),
+			matchers: async () => {
+				${
+					uses_matchers && build_data.manifest_data.params
+						? dedent`
+							const { params } = await import('${join_relative(relative_path, '/entries/params.js')}');
+							return params;
+						`
+						: 'return {};'
+				}
+			},
+			server_assets: ${s(files)}
 		}
 	`;
 

package/src/core/postbuild/analyse.js

@@ -34,7 +34,7 @@ async function analyse({
 	remotes,
 	vite_config_file
 }) {
-	/** @type {import('@sveltejs/kit').SSRManifest} */
+	/** @type {import('types').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	const vite_config = await load_vite_config(vite_config_file);
@@ -65,7 +65,7 @@ async function analyse({
 		remotes: new Map()
 	};
 
-	const nodes = await Promise.all(manifest._.nodes.map((loader) => loader()));
+	const nodes = await Promise.all(manifest.nodes.map((loader) => loader()));
 
 	// analyse nodes
 	for (const node of nodes) {
@@ -88,7 +88,7 @@ async function analyse({
 	}
 
 	// analyse routes
-	for (const route of manifest._.routes) {
+	for (const route of manifest.routes) {
 		const page =
 			route.page &&
 			analyse_page(
@@ -147,7 +147,7 @@ async function analyse({
 
 	// analyse remotes
 	for (const remote of remotes) {
-		const loader = manifest._.remotes[remote.hash];
+		const loader = manifest.remotes[remote.hash];
 		const { default: functions } = await loader();
 
 		const exports = new Map();

package/src/core/postbuild/fallback.js

@@ -24,7 +24,7 @@ async function generate_fallback({ manifest_path, env, out_dir, origin, assets }
 	/** @type {import('types').ServerModule} */
 	const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
 
-	/** @type {import('@sveltejs/kit').SSRManifest} */
+	/** @type {import('types').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	set_building();

package/src/core/postbuild/prerender.js

@@ -48,7 +48,7 @@ async function prerender({
 	vite_config_file,
 	is_tty
 }) {
-	/** @type {import('@sveltejs/kit').SSRManifest} */
+	/** @type {import('types').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */
@@ -659,7 +659,7 @@ async function prerender({
 	/** @type {Array<import('types').RemotePrerenderInternals>} */
 	const prerender_functions = [];
 
-	for (const loader of Object.values(manifest._.remotes)) {
+	for (const loader of Object.values(manifest.remotes)) {
 		const module = await loader();
 
 		for (const fn of Object.values(module.default)) {

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

@@ -82,7 +82,6 @@ export function create_assets(config) {
 
 	return [...walk(config.files.assets)].map((file) => ({
 		file,
-		size: fs.statSync(path.resolve(config.files.assets, file)).size,
 		type: lookup(file) || null
 	}));
 }

package/src/core/sync/write_app_manifest.js

@@ -1,4 +1,5 @@
 /** @import { Asset, ManifestData, RouteData } from 'types' */
+/** @import { ManifestRoute } from '$app/manifest' */
 
 import { s } from '../../utils/misc.js';
 import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
@@ -60,11 +61,11 @@ function stringify_assets(assets) {
 
 /**
  * @param {RouteData[] | undefined} routes
- * @returns {Array<{ id: string; page: boolean; endpoint: boolean }>}
+ * @returns {ManifestRoute[]}
  */
 export function get_manifest_routes(routes) {
 	return (
-		routes?.filter(is_app_route).map((route) => ({
+		routes?.filter(is_app_route).map((route) => /** @type {ManifestRoute} */ ({
 			id: route.id,
 			page: is_page_route(route),
 			endpoint: is_endpoint_route(route)