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

package/package.json

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

package/src/constants.js

@@ -11,3 +11,5 @@ export const ENDPOINT_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIO
 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

@@ -60,6 +60,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) => {
@@ -247,75 +253,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\``

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;

package/src/core/sync/write_server.js

@@ -26,7 +26,7 @@ const server_template = ({
 }) => `
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
-import { set_manifest, set_read_implementation } from '__sveltekit/server';
+import { set_fix_stack_trace, set_manifest, set_read_implementation } from '__sveltekit/server';
 import error from '../shared/error-template.js';
 
 export const options = {
@@ -80,7 +80,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_manifest, set_prerendering, set_read_implementation };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation };
 `;
 
 // TODO need to re-run this whenever src/app.html or src/error.html are

package/src/core/utils.js

@@ -30,18 +30,43 @@ export function get_runtime_base(root) {
 }
 
 /** @param {{ verbose: boolean }} opts */
-export function logger({ verbose }) {
+export function logger({ verbose } = { verbose: true }) {
 	/** @type {import('types').Logger} */
-	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+	const log = (msg) => console.log(msg);
 
 	/** @param {string} msg */
-	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+	const err = (msg) => console.error(msg);
 
 	log.success = (msg) => log(styleText('green', `✔ ${msg}`));
 	log.error = (msg) => err(styleText(['bold', 'red'], msg));
 	log.warn = (msg) => log(styleText(['bold', 'yellow'], msg));
 	log.minor = verbose ? (msg) => log(styleText('grey', msg)) : noop;
 	log.info = verbose ? log : noop;
+	log.err = err;
+
+	log.prettyError = (error, caller) => {
+		/** @type {unknown} */
+		let e = error;
+
+		while (e instanceof Error) {
+			let stack = e.stack;
+			if (stack) {
+				if (caller) {
+					const i = stack.indexOf(caller);
+					// Cut the stack trace off at the point when our internal one starts
+					stack = stack.slice(0, stack.lastIndexOf('\n', i));
+				}
+
+				err(stack);
+			}
+
+			e = e.cause;
+		}
+
+		if (e) {
+			err(String(e));
+		}
+	};
 
 	return log;
 }

package/src/exports/env/index.js

@@ -1,12 +1,77 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { DefinedEnvVars, EnvVarConfig } from '@sveltejs/kit' */
 
 /**
  * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
  * which are made available via `$app/env/public` and `$app/env/private`.
+ *
+ * @example
+ * ```js
+ * import { defineEnvVars } from '@sveltejs/kit/env';
+ * import * as v from 'valibot';
+ *
+ * export const variables = defineEnvVars({
+ * 	API_URL: {
+ * 		schema: v.pipe(v.string(), v.url())
+ * 	},
+ * 	PORT: {
+ * 		schema: (value) => {
+ * 			if (value === undefined) return 3000;
+ * 			const port = Number(value);
+ * 			if (!Number.isInteger(port)) throw new Error('PORT must be an integer');
+ * 			return port;
+ * 		}
+ * 	}
+ * });
+ * ```
+ *
  * @template {Record<string, EnvVarConfig<any>>} T
  * @param {T} variables
- * @returns {T}
+ * @returns {DefinedEnvVars<T>}
  */
 export function defineEnvVars(variables) {
-	return variables;
+	/** @type {Record<string, EnvVarConfig<any>>} */
+	const normalized = {};
+
+	for (const [name, config] of Object.entries(variables)) {
+		// standard schemas can be callable (e.g. ArkType), so a function is only a validator if it isn't one
+		normalized[name] =
+			typeof config.schema === 'function' && !('~standard' in config.schema)
+				? { ...config, schema: normalize_env_schema(config.schema) }
+				: config;
+	}
+
+	return /** @type {DefinedEnvVars<T>} */ (normalized);
+}
+
+/**
+ * @param {(value: string | undefined) => any} fn
+ * @returns {StandardSchemaV1<string | undefined, any>}
+ */
+function normalize_env_schema(fn) {
+	return /** @type {StandardSchemaV1<string | undefined, any>} */ (
+		/** @type {unknown} */ ({
+			'~standard': {
+				validate(/** @type {unknown} */ value) {
+					let result;
+
+					try {
+						result = fn(/** @type {string | undefined} */ (value));
+					} catch (error) {
+						return {
+							issues: [
+								{
+									message: error instanceof Error ? error.message || 'Invalid value' : String(error)
+								}
+							]
+						};
+					}
+
+					if (result instanceof Promise) return result; // will be rejected upstream
+
+					return { value: result };
+				}
+			}
+		})
+	);
 }

package/src/exports/internal/env.js

@@ -4,7 +4,7 @@
 import { stackless } from '../../utils/error.js';
 
 const MISSING = {
-	message: `Value is missing. If it is optional, add a Standard Schema validator declaring it as such.`
+	message: `Value is missing. If it is optional, add a validator declaring it as such.`
 };
 
 const BAD_VALIDATOR = {
@@ -24,10 +24,13 @@ const ASYNC_VALIDATOR = {
  */
 export function validate(variables, value, name, issues) {
 	const config = variables[name] ?? {};
-	const validator = config.schema;
+	// `defineEnvVars` normalizes function validators to standard schemas
+	const validator = /** @type {StandardSchemaV1<string | undefined, any> | undefined} */ (
+		config.schema
+	);
 
 	if (!validator) {
-		if (!value) issues[name] = [MISSING];
+		if (value === undefined) issues[name] = [MISSING];
 		return value;
 	}
 

package/src/exports/params.js

@@ -35,6 +35,15 @@ export function defineParams(definitions) {
  * @returns {import('@sveltejs/kit').ParamMatcher}
  */
 export function normalize_param_definition(definition) {
+	// standard schemas can be callable (e.g. ArkType), so this must be checked before the function case
+	if (
+		definition &&
+		(typeof definition === 'object' || typeof definition === 'function') &&
+		'~standard' in definition
+	) {
+		return definition;
+	}
+
 	if (typeof definition === 'function') {
 		return /** @type {import('@sveltejs/kit').ParamMatcher} */ (
 			/** @type {unknown} */ ({
@@ -55,9 +64,5 @@ export function normalize_param_definition(definition) {
 		);
 	}
 
-	if (definition && typeof definition === 'object' && '~standard' in definition) {
-		return definition;
-	}
-
 	throw new Error('Invalid param definition');
 }