@sveltejs/kit 3.0.0-next.10 → 3.0.0-next.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.10",
+  "version": "3.0.0-next.12",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",

package/src/cli.js

@@ -75,19 +75,19 @@ if (!command) {
 }
 
 if (command === 'sync') {
-	// create placeholder .svelte-kit/tsconfig.json if necessary, to squelch warnings.
+	// create placeholder node_modules/$app/tsconfig/tsconfig.json if necessary, to squelch warnings.
 	// this isn't bulletproof — if someone has some esoteric config, it will continue
 	// to harmlessly warn — but we handle the 90% case and clean up after ourselves
-	const sveltekit_dir = '.svelte-kit';
-	const base_tsconfig = `${sveltekit_dir}/tsconfig.json`;
+	const dir = 'node_modules/$app/tsconfig';
+	const base_tsconfig = `${dir}/tsconfig.json`;
 	const base_tsconfig_json = '{}';
 
-	const sveltekit_dir_exists = fs.existsSync(sveltekit_dir);
+	const sveltekit_dir_exists = fs.existsSync(dir);
 	const base_tsconfig_exists = fs.existsSync(base_tsconfig);
 
 	if (!base_tsconfig_exists) {
 		try {
-			fs.mkdirSync('.svelte-kit');
+			fs.mkdirSync(dir, { recursive: true });
 		} catch {
 			// ignore
 		}
@@ -100,7 +100,7 @@ if (command === 'sync') {
 		const sveltekit_config = extract_svelte_config(vite_config);
 
 		const sync = await import('./core/sync/sync.js');
-		sync.all_types(sveltekit_config);
+		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);
@@ -113,8 +113,8 @@ if (command === 'sync') {
 			fs.unlinkSync(base_tsconfig);
 		}
 
-		if (!sveltekit_dir_exists && fs.readdirSync(sveltekit_dir).length === 0) {
-			fs.rmSync(sveltekit_dir, { recursive: true });
+		if (!sveltekit_dir_exists && fs.readdirSync(dir).length === 0) {
+			fs.rmSync(dir, { recursive: true });
 		}
 	}
 } else {

package/src/constants.js

@@ -4,10 +4,12 @@
  */
 export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
 
-export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';
+export const GENERATED_COMMENT = '// this file is generated — do not edit it';
 
 export const ENDPOINT_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'];
 
 export const MUTATIVE_METHODS = ['POST', 'PUT', 'PATCH', 'DELETE'];
 
 export const PAGE_METHODS = ['GET', 'POST', 'HEAD'];
+
+export const SRC_ROOT = import.meta.dirname;

package/src/core/adapt/builder.js

@@ -8,7 +8,7 @@ import * as devalue from 'devalue';
 import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
 import { extname, resolve, join, dirname, relative } from 'node:path';
 import { pipeline } from 'node:stream';
-import { promisify, styleText } from 'node:util';
+import { promisify } from 'node:util';
 import zlib from 'node:zlib';
 import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
@@ -142,11 +142,8 @@ export function create_builder({
 			});
 
 			if (existsSync(dest)) {
-				console.log(
-					styleText(
-						['bold', 'yellow'],
-						`Overwriting ${dest} with fallback page. Consider using a different name for the fallback.`
-					)
+				log.warn(
+					`\nOverwriting ${dest} with fallback page. Consider using a different name for the fallback.\n`
 				);
 			}
 

package/src/core/config/index.js

@@ -6,6 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import * as url from 'node:url';
+import { styleText } from 'node:util';
 import {
 	validate_kit_options,
 	kit_options,
@@ -223,6 +224,10 @@ export function validate_config(config) {
 		return validated;
 	} catch (e) {
 		const error = /** @type {Error} */ (e);
-		throw stackless(`Error loading SvelteKit options from Vite config: ${error.message}`);
+
+		// Print a nicer version of the error to the console
+		console.log(styleText(['bold', 'red'], `\n${error.message}\n`));
+
+		throw stackless('Failed to load SvelteKit options from Vite config');
 	}
 }

package/src/core/config/options.js

@@ -1,6 +1,7 @@
 /** @import { SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
 /** @import { ValidatedKitConfig } from 'types' */
 /** @import { Validator } from './types.js' */
+import { styleText } from 'node:util';
 
 const directives = object({
 	'child-src': string_array(),
@@ -60,6 +61,12 @@ export const validate_svelte_options = object(
 	true
 );
 
+const prerender_handler = validate(undefined, (input, keypath) => {
+	if (typeof input === 'function') return input;
+	if (['fail', 'warn', 'ignore'].includes(input)) return input;
+	throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
+});
+
 /** @type {Validator<ValidatedKitConfig>} */
 export const validate_kit_options = object({
 	adapter: validate(undefined, (input, keypath) => {
@@ -71,17 +78,21 @@ export const validate_kit_options = object({
 		return input;
 	}),
 
-	alias: validate({}, (input, keypath) => {
-		if (typeof input !== 'object') {
-			throw new Error(`${keypath} should be an object`);
-		}
+	alias: deprecate(
+		validate({}, (input, keypath) => {
+			if (typeof input !== 'object') {
+				throw new Error(`${keypath} should be an object`);
+			}
 
-		for (const key in input) {
-			assert_string(input[key], `${keypath}.${key}`);
-		}
+			for (const key in input) {
+				assert_string(input[key], `${keypath}.${key}`);
+			}
 
-		return input;
-	}),
+			return input;
+		}),
+		(keypath) =>
+			`The \`${keypath}\` option is deprecated, and will be removed in a future version of SvelteKit. Use subpath imports instead: https://svelte.dev/docs/kit/$lib`
+	),
 
 	appDir: validate('_app', (input, keypath) => {
 		assert_string(input, keypath);
@@ -247,75 +258,11 @@ export const validate_kit_options = object({
 			return input;
 		}),
 
-		handleHttpError: validate(
-			(/** @type {any} */ { message }) => {
-				throw new Error(
-					message +
-						'\nTo suppress or handle this error, implement `handleHttpError` in https://svelte.dev/docs/kit/configuration#prerender'
-				);
-			},
-			(input, keypath) => {
-				if (typeof input === 'function') return input;
-				if (['fail', 'warn', 'ignore'].includes(input)) return input;
-				throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
-			}
-		),
-
-		handleMissingId: validate(
-			(/** @type {any} */ { message }) => {
-				throw new Error(
-					message +
-						'\nTo suppress or handle this error, implement `handleMissingId` in https://svelte.dev/docs/kit/configuration#prerender'
-				);
-			},
-			(input, keypath) => {
-				if (typeof input === 'function') return input;
-				if (['fail', 'warn', 'ignore'].includes(input)) return input;
-				throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
-			}
-		),
-
-		handleEntryGeneratorMismatch: validate(
-			(/** @type {any} */ { message }) => {
-				throw new Error(
-					message +
-						'\nTo suppress or handle this error, implement `handleEntryGeneratorMismatch` in https://svelte.dev/docs/kit/configuration#prerender'
-				);
-			},
-			(input, keypath) => {
-				if (typeof input === 'function') return input;
-				if (['fail', 'warn', 'ignore'].includes(input)) return input;
-				throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
-			}
-		),
-
-		handleUnseenRoutes: validate(
-			(/** @type {any} */ { message }) => {
-				throw new Error(
-					message +
-						'\nTo suppress or handle this error, implement `handleUnseenRoutes` in https://svelte.dev/docs/kit/configuration#prerender'
-				);
-			},
-			(input, keypath) => {
-				if (typeof input === 'function') return input;
-				if (['fail', 'warn', 'ignore'].includes(input)) return input;
-				throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
-			}
-		),
-
-		handleInvalidUrl: validate(
-			(/** @type {any} */ { message }) => {
-				throw new Error(
-					message +
-						'\nTo suppress or handle this error, implement `handleInvalidUrl` in https://svelte.dev/docs/kit/configuration#prerender'
-				);
-			},
-			(input, keypath) => {
-				if (typeof input === 'function') return input;
-				if (['fail', 'warn', 'ignore'].includes(input)) return input;
-				throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
-			}
-		),
+		handleHttpError: prerender_handler,
+		handleMissingId: prerender_handler,
+		handleEntryGeneratorMismatch: prerender_handler,
+		handleUnseenRoutes: prerender_handler,
+		handleInvalidUrl: prerender_handler,
 
 		origin: removed(
 			(keypath) => `\`${keypath}\` has been removed in favour of \`config.paths.origin\``
@@ -328,47 +275,50 @@ export const validate_kit_options = object({
 	}),
 
 	serviceWorker: object({
+		files: removed(),
 		register: boolean(true),
 		// options could be undefined but if it is defined we only validate that
 		// it's an object since the type comes from the browser itself
-		options: validate(undefined, object({}, true)),
-		files: fun((filename) => !/\.DS_Store/.test(filename))
+		options: validate(undefined, object({}, true))
 	}),
 
 	tracing: object({
 		server: boolean(false)
 	}),
 
-	typescript: object({
-		config: fun((config) => config)
-	}),
+	typescript: deprecate(
+		object({
+			config: fun((config) => config)
+		}),
+		(keypath) => {
+			return `The \`${keypath}\` option is deprecated, and will be removed in a future version. Add configuration to tsconfig.json directly`;
+		}
+	),
 
 	version: object({
 		name: string(Date.now().toString()),
-		pollInterval: number(0)
+		pollInterval: number(3_600_000)
 	})
 });
 
-// /**
-//  * @param {Validator} fn
-//  * @param {(keypath: string) => string} get_message
-//  * @returns {Validator}
-//  */
-// function deprecate(
-// 	fn,
-// 	get_message = (keypath) =>
-// 		`The \`${keypath}\` option is deprecated, and will be removed in a future version`
-// ) {
-// 	return (input, keypath) => {
-//		keypath = remove_kit_prefix(keypath);
-//
-// 		if (input !== undefined) {
-// 			console.warn(styleText(['bold', 'yellow'], get_message(keypath)));
-// 		}
-
-// 		return fn(input, keypath);
-// 	};
-// }
+/**
+ * @param {Validator} fn
+ * @param {(keypath: string) => string} get_message
+ * @returns {Validator}
+ */
+function deprecate(
+	fn,
+	get_message = (keypath) =>
+		`The \`${keypath}\` option is deprecated, and will be removed in a future version`
+) {
+	return (input, keypath) => {
+		if (input !== undefined) {
+			console.warn(styleText(['bold', 'yellow'], get_message(keypath)));
+		}
+
+		return fn(input, keypath);
+	};
+}
 
 // Derive the names of SvelteKit's own config options from the schema, so they
 // stay in sync automatically. These are used to separate Kit's options from

package/src/core/env.js

@@ -10,6 +10,7 @@ import { runtime_directory } from './utils.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';
+import { get_runner } from '../runner.js';
 
 /**
  * @typedef {'public' | 'private'} EnvType
@@ -52,12 +53,14 @@ export async function load_explicit_env(kit, file, root, mode) {
 	/** @type {Record<string, EnvVarConfig<any>>} */
 	let variables;
 
+	const runner = get_runner(server);
+
 	/** @type {import('../runtime/app/env/internal.js')} */ (
-		await server.ssrLoadModule(`${runtime_directory}/app/env/internal.js`)
+		await runner.import(`${runtime_directory}/app/env/internal.js`)
 	).set_building();
 
 	try {
-		({ variables } = await server.ssrLoadModule(file));
+		({ variables } = await runner.import(file));
 
 		if (!variables || typeof variables !== 'object') {
 			throw new Error(`${file} must export a variables object`);
@@ -238,25 +241,35 @@ export function create_sveltekit_env_public(variables, env, prelude) {
  * `env.js`. If there are none, values are inlined.
  * @param {Record<string, EnvVarConfig<any>> | null} variables
  * @param {Record<string, string>} env
+ * @param {string} version
  * @param {string} global
  * @param {string} base
  * @param {string} app_dir
  */
-export function create_sveltekit_env_service_worker(variables, env, global, base, app_dir) {
+export function create_sveltekit_env_service_worker(
+	variables,
+	env,
+	version,
+	global,
+	base,
+	app_dir
+) {
 	const has_dynamic_public_env = Object.values(variables ?? {}).some(
 		(config) => config.public && !config.static
 	);
 
 	if (!has_dynamic_public_env) {
-		return create_sveltekit_env_service_worker_dev(variables, env, global);
+		return create_sveltekit_env_service_worker_dev(variables, env, version, global);
 	}
 
 	return dedent`
 		import { env } from '${base}/${app_dir}/env.js';
 
-		globalThis.__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ = true;
-
-		${global} = { env };
+		${global} = {
+			base: location.pathname.split('/').slice(0, -1).join('/'),
+			env,
+			version: ${JSON.stringify(version)}
+		};
 	`;
 }
 
@@ -264,9 +277,10 @@ export function create_sveltekit_env_service_worker(variables, env, global, base
  * Creates the `__sveltekit/env/service-worker` module used in development
  * @param {Record<string, EnvVarConfig<any>> | null} variables
  * @param {Record<string, string>} env
+ * @param {string} version
  * @param {string} global
  */
-export function create_sveltekit_env_service_worker_dev(variables, env, global) {
+export function create_sveltekit_env_service_worker_dev(variables, env, version, global) {
 	/** @type {string[]} */
 	const properties = [];
 
@@ -283,12 +297,12 @@ export function create_sveltekit_env_service_worker_dev(variables, env, global)
 	handle_issues(issues);
 
 	return dedent`
-		globalThis.__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ = true;
-
 		${global} = {
+			base: location.pathname.split('/').slice(0, -1).join('/'),
 			env: {
 				${properties.join(',\n\t\t') || '// empty'}
-			}
+			},
+			version: ${JSON.stringify(version)}
 		};
 	`;
 }

package/src/core/postbuild/fallback.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { forked } from '../../utils/fork.js';
+import { stackless } from '../../utils/error.js';
 
 export default forked(import.meta.url, generate_fallback);
 
@@ -47,5 +48,5 @@ async function generate_fallback({ manifest_path, env, out_dir, origin, assets }
 		return await response.text();
 	}
 
-	throw new Error(`Could not create a fallback page — failed with status ${response.status}`);
+	throw stackless('Could not create a fallback page');
 }

package/src/core/postbuild/prerender.js

@@ -16,6 +16,7 @@ import * as devalue from 'devalue';
 import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
+import { log_response } from '../../exports/vite/utils.js';
 
 export default forked(import.meta.url, prerender);
 
@@ -57,29 +58,60 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	/** @type {import('types').ServerModule} */
 	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
 
+	const throw_handled = () => {
+		throw new Error('__handled__');
+	};
+
 	/**
 	 * @template {{message: string}} T
 	 * @template {Omit<T, 'message'>} K
-	 * @param {import('types').Logger} log
-	 * @param {'fail' | 'warn' | 'ignore' | ((details: T) => void)} input
+	 * @param {string} name
+	 * @param {'fail' | 'warn' | 'ignore' | undefined | ((details: T) => void)} input
 	 * @param {(details: K) => string} format
-	 * @returns {(details: K) => void}
+	 * @returns {(details: K & { error?: unknown }) => void}
 	 */
-	function normalise_error_handler(log, input, format) {
+	function normalise_error_handler(name, input, format) {
+		/**
+		 * @param {any} details
+		 */
+		function log_failure(details) {
+			const message = format(details);
+			log.error(`\n${message}\n`);
+		}
+
 		switch (input) {
 			case 'fail':
 				return (details) => {
-					throw new Error(format(details));
+					log_failure(details);
+					throw_handled();
 				};
 			case 'warn':
-				return (details) => {
-					log.error(format(details));
-				};
+				return log_failure;
 			case 'ignore':
 				return noop;
+			case undefined: {
+				return (details) => {
+					log_failure(details);
+
+					log.err(
+						`To suppress or handle this error, implement \`${name}\` in https://svelte.dev/docs/kit/configuration#prerender\n`
+					);
+
+					throw_handled();
+				};
+			}
 			default:
-				// @ts-expect-error TS thinks T might be of a different kind, but it's not
-				return (details) => input({ ...details, message: format(details) });
+				return (details) => {
+					const message = format(details);
+
+					try {
+						// @ts-expect-error TS thinks T might be of a different kind, but it's not
+						input({ ...details, message });
+					} catch (error) {
+						log.prettyError(error, import.meta.dirname);
+						throw_handled();
+					}
+				};
 		}
 	}
 
@@ -141,48 +173,55 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	const saved = new Map();
 
 	const handle_http_error = normalise_error_handler(
-		log,
+		'handleHttpError',
 		config.prerender.handleHttpError,
 		({ status, path, referrer, referenceType }) => {
-			const message =
-				status === 404 && !path.startsWith(config.paths.base)
-					? `${path} does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\` - see https://svelte.dev/docs/kit/configuration#paths for more info`
-					: path;
+			let message = `Failed to prerender ${path}`;
+
+			if (status === 404) {
+				if (!path.startsWith(config.paths.base)) {
+					message = referrer ? `${path} (${referenceType} from ${referrer})` : path;
+
+					message += ` does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\``;
+				} else if (referrer) {
+					message = `${path} was ${referenceType} from ${referrer}`;
+				}
+			}
 
-			return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+			return message;
 		}
 	);
 
 	const handle_missing_id = normalise_error_handler(
-		log,
+		'handleMissingId',
 		config.prerender.handleMissingId,
 		({ path, id, referrers }) => {
 			return (
-				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path} - see the \`handleMissingId\` option in https://svelte.dev/docs/kit/configuration#prerender for more info:` +
+				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path}:` +
 				referrers.map((l) => `\n  - ${l}`).join('')
 			);
 		}
 	);
 
 	const handle_entry_generator_mismatch = normalise_error_handler(
-		log,
+		'handleEntryGeneratorMismatch',
 		config.prerender.handleEntryGeneratorMismatch,
 		({ generatedFromId, entry, matchedId }) => {
-			return `The entries export from ${generatedFromId} generated entry ${entry}, which was matched by ${matchedId} - see the \`handleEntryGeneratorMismatch\` option in https://svelte.dev/docs/kit/configuration#prerender for more info.`;
+			return `The entries export from ${generatedFromId} generated entry ${entry}, which was matched by ${matchedId === entry ? 'a static route' : matchedId}`;
 		}
 	);
 
 	const handle_not_prerendered_route = normalise_error_handler(
-		log,
+		'handleUnseenRoutes',
 		config.prerender.handleUnseenRoutes,
 		({ routes }) => {
 			const list = routes.map((id) => `  - ${id}`).join('\n');
-			return `The following routes were marked as prerenderable, but were not prerendered because they were not found while crawling your app:\n${list}\n\nSee the \`handleUnseenRoutes\` option in https://svelte.dev/docs/kit/configuration#prerender for more info.`;
+			return `The following routes were marked as prerenderable, but were not prerendered because they were not found while crawling your app:\n${list}`;
 		}
 	);
 
 	const handle_invalid_url = normalise_error_handler(
-		log,
+		'handleInvalidUrl',
 		config.prerender.handleInvalidUrl,
 		({ href, referrer }) => {
 			return `Invalid URL ${href}${referrer ? ` (linked from ${referrer})` : ''}`;
@@ -260,7 +299,9 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		/** @type {Map<string, import('types').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		const response = await server.respond(new Request(prerender_origin + encoded), {
+		const request = new Request(prerender_origin + encoded);
+
+		const response = await server.respond(request, {
 			getClientAddress() {
 				throw new Error('Cannot read clientAddress during prerendering');
 			},
@@ -298,6 +339,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 			});
 		}
 
+		if (response.status !== 204) {
+			log_response(response.status, request);
+		}
+
 		const body = Buffer.from(await response.arrayBuffer());
 
 		const category = decoded.startsWith(remote_prefix) ? 'data' : 'pages';
@@ -428,8 +473,6 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				if (!headers['x-sveltekit-normalize']) {
 					mkdirp(dirname(dest));
 
-					log.warn(`${response.status} ${decoded} -> ${location}`);
-
 					writeFileSync(
 						dest,
 						`<script>location.href=${devalue.uneval(
@@ -476,7 +519,6 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 			mkdirp(dir);
 
-			log.info(`${response.status} ${decoded}`);
 			writeFileSync(dest, body);
 			written.add(file);
 
@@ -492,7 +534,12 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 			prerendered.paths.push(decoded);
 		} else if (response_type !== OK) {
-			handle_http_error({ status: response.status, path: decoded, referrer, referenceType });
+			handle_http_error({
+				status: response.status,
+				path: decoded,
+				referrer,
+				referenceType
+			});
 		}
 
 		manifest.assets.add(file);

package/src/core/postbuild/queue.js

@@ -28,7 +28,7 @@ export function queue(concurrency) {
 
 			if (task) {
 				current += 1;
-				const promise = Promise.resolve(task.fn());
+				const promise = (async () => task.fn())(); // could throw synchronously
 
 				void promise
 					.then(task.fulfil, (err) => {
@@ -54,6 +54,7 @@ export function queue(concurrency) {
 			const promise = new Promise((fulfil, reject) => {
 				tasks.push({ fn, fulfil, reject });
 			});
+			promise.catch(() => {});
 
 			dequeue();
 			return promise;