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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.14",
+  "version": "3.0.0-next.16",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -30,12 +30,12 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@playwright/test": "~1.61.0",
+    "@playwright/test": "^1.62.0",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@types/connect": "^3.4.38",
     "@types/node": "^22.19.19",
     "dts-buddy": "^0.8.3",
-    "jsdom": "^29.1.1",
+    "jsdom": "^30.0.0",
     "rolldown": "^1.2.0",
     "svelte": "^5.56.3",
     "svelte-preprocess": "^6.0.5",
@@ -71,6 +71,9 @@
     "svelte-kit.js"
   ],
   "imports": {
+    "#app/internal/transport": {
+      "default": "./src/runtime/app/internal/transport.js"
+    },
     "#app/paths": {
       "workerd": "./src/runtime/app/paths/server.js",
       "browser": "./src/runtime/app/paths/client.js",

package/src/cli.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { parseArgs, styleText } from 'node:util';
 import { extract_svelte_config, load_vite_config } from './core/config/index.js';
-import { coalesce_to_error } from './utils/error.js';
 import { resolve_explicit_env_entry } from './core/env.js';
+import { coalesce_to_error } from './utils/error.js';
+import { import_peer } from './utils/import.js';
 
 /** @param {unknown} e */
 function handle_error(e) {
@@ -96,14 +97,16 @@ if (command === 'sync') {
 	}
 
 	try {
-		const vite_config = await load_vite_config(values.config);
+		const vite = /** @type {import('vite')} */ (await import_peer('vite', process.cwd()));
+
+		const vite_config = await load_vite_config(values.config, vite);
 		const sveltekit_config = extract_svelte_config(vite_config);
 
 		const sync = await import('./core/sync/sync.js');
 		sync.all_types(sveltekit_config, vite_config.root);
 
 		const explicit_env_entry = resolve_explicit_env_entry(sveltekit_config.kit);
-		await sync.env(sveltekit_config.kit, explicit_env_entry, vite_config.root, values.mode);
+		await sync.env(vite, sveltekit_config.kit, explicit_env_entry, vite_config.root, values.mode);
 	} catch (error) {
 		handle_error(error);
 	} finally {

package/src/core/adapt/builder.js

@@ -5,12 +5,19 @@
 /** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger, RemoteChunk } from 'types' */
 import { loadEnv } from 'vite';
 import * as devalue from 'devalue';
-import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
+import {
+	createReadStream,
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	rmSync,
+	statSync
+} from 'node:fs';
 import { extname, resolve, join, dirname, relative } from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
-import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
+import { copy } 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';
@@ -99,8 +106,8 @@ export function create_builder({
 
 	return {
 		log,
-		rimraf,
-		mkdirp,
+		rimraf: (dir) => rmSync(dir, { force: true, recursive: true }),
+		mkdirp: (dir) => mkdirSync(dir, { recursive: true }),
 		copy,
 
 		config,
@@ -271,7 +278,7 @@ export function create_builder({
 							exports: module.exports
 						});
 
-			rimraf(entrypoint);
+			rmSync(entrypoint, { force: true, recursive: true });
 			write(entrypoint, facade);
 		}
 	};

package/src/core/config/index.js

@@ -120,13 +120,12 @@ export function load_error_page(config) {
 
 /**
  * @param {string} [config]
+ * @param {typeof import('vite')} [vite]
  */
-export async function load_vite_config(config) {
-	const { resolveConfig } = /** @type {import('vite')} */ (
-		await import_peer('vite', process.cwd())
-	);
+export async function load_vite_config(config, vite) {
+	vite ??= /** @type {import('vite')} */ (await import_peer('vite', process.cwd()));
 
-	return resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
+	return vite.resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
 }
 
 /**

package/src/core/env.js

@@ -2,7 +2,6 @@
 /** @import { EnvVarConfig } from '@sveltejs/kit' */
 /** @import { ValidatedKitConfig } from 'types' */
 import path from 'node:path';
-import * as vite from 'vite';
 import * as devalue from 'devalue';
 import { GENERATED_COMMENT } from '../constants.js';
 import { dedent } from './sync/utils.js';
@@ -25,13 +24,14 @@ export function resolve_explicit_env_entry(config) {
 }
 
 /**
+ * @param {typeof import('vite')} vite
  * @param {ValidatedKitConfig} kit
  * @param {string | null} file
  * @param {string} root
  * @param {string} mode
  * @returns {Promise<Record<string, EnvVarConfig<any>> | null>}
  */
-export async function load_explicit_env(kit, file, root, mode) {
+export async function load_explicit_env(vite, kit, file, root, mode) {
 	if (!file) return null;
 
 	const server = await vite.createServer({
@@ -53,7 +53,7 @@ export async function load_explicit_env(kit, file, root, mode) {
 	/** @type {Record<string, EnvVarConfig<any>>} */
 	let variables;
 
-	const runner = get_runner(server);
+	const runner = get_runner(vite, server);
 
 	/** @type {import('../runtime/app/env/internal.js')} */ (
 		await runner.import(`${runtime_directory}/app/env/internal.js`)

package/src/core/postbuild/prerender.js

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { mkdirp, walk } from '../../utils/filesystem.js';
+import { walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { noop } from '../../utils/functions.js';
 import { decode_uri, is_root_relative, resolve } from '../../utils/url.js';
@@ -157,7 +157,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const file = output_filename('/', true);
 		const dest = `${config.outDir}/output/prerendered/pages/${file}`;
 
-		mkdirp(dirname(dest));
+		mkdirSync(dirname(dest), { recursive: true });
 		writeFileSync(dest, fallback);
 
 		prerendered.pages.set('/', { file });
@@ -480,7 +480,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				}
 
 				if (!headers['x-sveltekit-normalize']) {
-					mkdirp(dirname(dest));
+					mkdirSync(dirname(dest), { recursive: true });
 
 					writeFileSync(
 						dest,
@@ -526,7 +526,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				);
 			}
 
-			mkdirp(dir);
+			mkdirSync(dir, { recursive: true });
 
 			writeFileSync(dest, body);
 			written.add(file);
@@ -629,14 +629,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	}
 
-	const transport = (await internal.get_hooks()).transport ?? {};
 	for (const internals of prerender_functions) {
 		if (internals.has_arg) {
 			for (const arg of (await internals.inputs?.()) ?? []) {
-				void enqueue(
-					null,
-					remote_prefix + internals.id + '/' + stringify_remote_arg(arg, transport)
-				);
+				void enqueue(null, remote_prefix + internals.id + '/' + stringify_remote_arg(arg));
 			}
 		} else {
 			void enqueue(null, remote_prefix + internals.id);

package/src/core/sync/sync.js

@@ -89,13 +89,14 @@ export function all_types(config, root) {
 
 /**
  * Generate modules and types for explicit env vars
+ * @param {typeof import('vite')} vite
  * @param {import('types').ValidatedKitConfig} kit
  * @param {string | null} entry
  * @param {string} root The Vite root
  * @param {string} mode The Vite mode
  */
-export async function env(kit, entry, root, mode) {
-	const env_config = await load_explicit_env(kit, entry, root, mode);
+export async function env(vite, kit, entry, root, mode) {
+	const env_config = await load_explicit_env(vite, kit, entry, root, mode);
 
 	write_env(entry, env_config, root);
 

package/src/core/sync/utils.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
-import { mkdirp, resolve_entry } from '../../utils/filesystem.js';
+import { resolve_entry } from '../../utils/filesystem.js';
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();
@@ -22,7 +22,7 @@ export function write_if_changed(file, code) {
  */
 export function write(file, code) {
 	previous_contents.set(file, code);
-	mkdirp(path.dirname(file));
+	fs.mkdirSync(path.dirname(file), { recursive: true });
 	fs.writeFileSync(file, code);
 }
 

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

@@ -6,13 +6,12 @@ import { styleText } from 'node:util';
 import { write_if_changed } from '../utils.js';
 import {
 	ESSENTIAL_OPTIONS,
-	extends_id,
 	get_subpath_imports,
 	normalize_config,
 	RECOMMENDED_OPTIONS,
-	remove_trailing_slashstar,
-	validate_resolved_config
+	remove_trailing_slashstar
 } from './utils.js';
+import { extends_id, validate_resolved_config } from './validate.js';
 
 /** @type {import('typescript')} */
 let ts;
@@ -29,16 +28,16 @@ try {
  */
 export function write_tsconfig(kit, root) {
 	const paths = get_paths(kit, root);
+	const types = ['$app/types'];
 
 	write_parent_tsconfig(
-		root,
 		root,
 		'$app/tsconfig',
 		{
 			compilerOptions: {
 				paths,
 				rootDirs: ['.', `${kit.outDir}/types`],
-				types: ['$app/types'],
+				types,
 
 				// This is required for svelte-package to work as expected
 				// Can be overwritten
@@ -46,45 +45,48 @@ export function write_tsconfig(kit, root) {
 
 				...ESSENTIAL_OPTIONS,
 				...RECOMMENDED_OPTIONS
-			},
-			exclude: [kit.files.serviceWorker]
-		},
-		{
-			extends: '$app/tsconfig',
-			include: ['src']
+			}
 		},
 		kit.typescript.config
 	);
 
-	write_parent_tsconfig(
-		root,
-		kit.files.serviceWorker,
-		'$app/tsconfig/service-worker',
-		{
-			compilerOptions: {
-				paths,
-				types: ['$app/types'],
-				lib: ['ESNext', 'WebWorker'],
-				...ESSENTIAL_OPTIONS
-			}
-		},
-		{
+	validate_config(root, {
+		paths,
+		types,
+		exclusions: [kit.files.serviceWorker],
+		example: {
+			extends: '$app/tsconfig'
+		}
+	});
+
+	write_parent_tsconfig(root, '$app/tsconfig/service-worker', {
+		compilerOptions: {
+			paths,
+			types,
+			lib: ['ESNext', 'WebWorker'],
+			...ESSENTIAL_OPTIONS,
+			...RECOMMENDED_OPTIONS
+		}
+	});
+
+	validate_config(kit.files.serviceWorker, {
+		paths,
+		types,
+		example: {
 			extends: '$app/tsconfig/service-worker'
 		}
-	);
+	});
 }
 
 /**
  * Write a generated `tsconfig.json` inside `node_modules`, for the
  * user config to extend
  * @param {string} root The project root
- * @param {string} dir The directory to resolve a user config from
  * @param {string} id The id of the generated config
  * @param {any} config The contents of the generated tsconfig, with paths relative to `root`
- * @param {any} example What to print if the user config does _not_ extend the generated config
  * @param {ValidatedKitConfig['typescript']['config']} [transform] TODO get rid of this
  */
-function write_parent_tsconfig(root, dir, id, config, example, transform) {
+function write_parent_tsconfig(root, id, config, transform) {
 	// simplified tsconfig resolvers (e.g. Playwright's) only find `${id}.json`, not `${id}/tsconfig.json`
 	const out_file = path.join(root, `node_modules/${id}.json`);
 
@@ -92,44 +94,60 @@ function write_parent_tsconfig(root, dir, id, config, example, transform) {
 	normalized = transform?.(normalized) ?? normalized;
 
 	write_if_changed(out_file, JSON.stringify(normalized, null, '\t'));
+}
 
+/**
+ * @param {string} dir The directory to resolve a user config from
+ * @param {Object} options
+ * @param {Record<string, string[]>} options.paths The expected paths
+ * @param {string[]} options.types The expected types
+ * @param {string[]} [options.exclusions] Files that should be excluded
+ * @param {any} options.example What to print if the user config does _not_ extend the generated config
+ */
+function validate_config(dir, options) {
 	if (!ts) {
 		// The user has not installed TypeScript. Skip validation of config.
 		return;
 	}
 
 	const user_config = load_user_tsconfig(dir);
+	if (!user_config || !modified_since_last_check(user_config.file)) return;
 
-	if (user_config && modified_since_last_check(user_config.file)) {
-		// now that we've written the parent config, we can resolve the
-		// user config and validate that nothing important was overwritten
-		if (!extends_id(user_config.options, id)) {
-			console.warn(
-				styleText(
-					['bold', 'yellow'],
-					`${path.relative(process.cwd(), user_config.file)} should extend SvelteKit's built-in configuration:`
-				)
-			);
+	// now that we've written the parent config, we can resolve the
+	// user config and validate that nothing important was overwritten
+	if (!extends_id(user_config.options, options.example.extends)) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`${path.relative(process.cwd(), user_config.file)} should extend SvelteKit's built-in configuration:`
+			)
+		);
 
-			console.warn(JSON.stringify(example, null, '  '));
+		console.warn(JSON.stringify(options.example, null, '  '));
 
-			return;
-		}
+		return;
+	}
 
-		const resolved = ts.parseJsonConfigFileContent(user_config.options, ts.sys, dir).options;
-		const warnings = validate_resolved_config(resolved, config.compilerOptions);
+	const resolved = ts.parseJsonConfigFileContent(user_config.options, ts.sys, dir);
 
-		if (warnings.length > 0) {
-			console.warn(
-				styleText(
-					['bold', 'yellow'],
-					`Found issues while validating ${path.relative(process.cwd(), user_config.file)}`
-				)
-			);
+	const warnings = validate_resolved_config(
+		dir,
+		resolved,
+		options.paths,
+		options.types,
+		options.exclusions
+	);
 
-			for (const warning of warnings) {
-				console.warn(`  - ${warning}`);
-			}
+	if (warnings.length > 0) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`Found issues while validating ${path.relative(process.cwd(), user_config.file)}`
+			)
+		);
+
+		for (const warning of warnings) {
+			console.warn(`  - ${warning}`);
 		}
 	}
 }

package/src/core/sync/write_tsconfig/utils.js

@@ -36,16 +36,6 @@ export const RECOMMENDED_OPTIONS = {
 	noEmit: true // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
 };
 
-/**
- * Validates that a tsconfig contains `"extends": "<id>"`
- * @param {any} options
- * @param {string} id
- */
-export function extends_id(options, id) {
-	const o = options.extends;
-	return Array.isArray(o) ? o.includes(id) : o === id;
-}
-
 /**
  * Makes paths relative to the output file
  * @param {string} out
@@ -76,57 +66,6 @@ export function normalize_config(out, config, transform) {
 	return transform?.(normalized) ?? normalized;
 }
 
-/**
- * @param {any} resolved
- * @param {any} options
- */
-export function validate_resolved_config(resolved, options) {
-	const warnings = [];
-
-	const join = (/** @type {string[]} */ array) =>
-		array
-			.map((v) => JSON.stringify(v))
-			.join(', ')
-			.replace(/, ([^,]*)$/, ' and $1');
-
-	const missing_types = options.types?.filter(
-		(/** @type {string} */ type) => !resolved.types?.includes(type)
-	);
-
-	if (missing_types.length > 0) {
-		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
-	}
-
-	if (options.paths) {
-		/** @type {Set<string>} */
-		const mismatch = new Set();
-
-		for (const [k, expected] of Object.entries(options.paths)) {
-			const actual = resolved.paths?.[k]?.map((/** @type {string} */ x) =>
-				path.resolve(/** @type {string} */ (resolved.pathsBasePath), x)
-			);
-
-			if (JSON.stringify(expected) !== JSON.stringify(actual)) {
-				mismatch.add(remove_trailing_slashstar(k));
-			}
-		}
-
-		if (mismatch.size > 0) {
-			const joined = join([...mismatch]);
-
-			warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
-		}
-	}
-
-	for (const key in ESSENTIAL_OPTIONS) {
-		if (resolved[key] !== options[key]) {
-			warnings.push(`"${key}" was overwritten. It should be ${JSON.stringify(options[key])}`);
-		}
-	}
-
-	return warnings;
-}
-
 /**
  * @param {string} file
  */

package/src/core/sync/write_tsconfig/validate.js

@@ -0,0 +1,128 @@
+/** @import ts from 'typescript' */
+import path from 'node:path';
+import { ESSENTIAL_OPTIONS, remove_trailing_slashstar } from './utils.js';
+import { posixify } from '../../../utils/os.js';
+
+const formatter = new Intl.ListFormat('en-gb', { type: 'conjunction' });
+
+/**
+ * @param {string[]} things
+ */
+function join(things) {
+	return formatter.format(things.map((thing) => JSON.stringify(thing)));
+}
+
+/**
+ * @param {string} dir
+ * @param {ts.ParsedCommandLine} resolved
+ * @param {Record<string, string[]>} paths
+ * @param {string[]} types
+ * @param {string[]} [exclusions]
+ */
+export function validate_resolved_config(dir, resolved, paths, types, exclusions) {
+	/** @type {string[]} */
+	const warnings = [];
+
+	if (resolved.options.types) {
+		validate_types(warnings, types, resolved.options.types);
+	}
+
+	if (resolved.options.paths) {
+		validate_paths(
+			warnings,
+			/** @type {string} */ (resolved.options.pathsBasePath),
+			paths,
+			resolved.options.paths
+		);
+	}
+
+	if (exclusions) {
+		validate_exclusions(warnings, dir, exclusions, resolved.fileNames);
+	}
+
+	for (const key in ESSENTIAL_OPTIONS) {
+		if (resolved.options[key] !== ESSENTIAL_OPTIONS[key]) {
+			warnings.push(
+				`"${key}" was overwritten. It should be ${JSON.stringify(ESSENTIAL_OPTIONS[key])}`
+			);
+		}
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string[]} expected
+ * @param {string[]} actual
+ */
+export function validate_types(warnings, expected, actual) {
+	const missing_types = expected.filter((/** @type {string} */ type) => !actual.includes(type));
+
+	if (missing_types.length > 0) {
+		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} base
+ * @param {Record<string, string[]>} expected
+ * @param {ts.MapLike<string[]>} actual
+ */
+export function validate_paths(warnings, base, expected, actual) {
+	/** @type {Set<string>} */
+	const mismatch = new Set();
+
+	for (const [k, e] of Object.entries(expected)) {
+		const a = actual[k]?.map((/** @type {string} */ x) =>
+			path.resolve(/** @type {string} */ (base), x)
+		);
+
+		if (JSON.stringify(e) !== JSON.stringify(a)) {
+			mismatch.add(remove_trailing_slashstar(k));
+		}
+	}
+
+	if (mismatch.size > 0) {
+		const joined = join([...mismatch]);
+
+		warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} dir
+ * @param {string[]} exclusions
+ * @param {string[]} files
+ */
+export function validate_exclusions(warnings, dir, exclusions, files) {
+	const missing_exclusions = exclusions.map(posixify).filter((exclusion) => {
+		return files.some(
+			(f) => f === exclusion || f.startsWith(exclusion + '/') || f.startsWith(exclusion + '.')
+		);
+	});
+
+	if (missing_exclusions.length > 0) {
+		warnings.push(
+			`${join(missing_exclusions.map((file) => posixify(path.relative(dir, file))))} should be added to the "exclude" array`
+		);
+	}
+
+	return warnings;
+}
+
+/**
+ * Validates that a tsconfig contains `"extends": "<id>"`
+ * @param {any} options
+ * @param {string} id
+ */
+export function extends_id(options, id) {
+	const o = options.extends;
+	return Array.isArray(o) ? o.includes(id) : o === id;
+}

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';
-import { rimraf, walk, resolve_entry } from '../../../utils/filesystem.js';
+import { walk, resolve_entry } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
@@ -49,7 +49,7 @@ export function write_all_types(config, manifest_data, root) {
 		for (const file of walk(types_dir)) {
 			const dir = path.dirname(file);
 			if (!expected_directories.has(dir)) {
-				rimraf(path.join(types_dir, file));
+				fs.rmSync(path.join(types_dir, file), { force: true, recursive: true });
 			}
 		}
 	}