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

package/src/runtime/server/index.js

@@ -2,10 +2,10 @@ import { noop } from '../../utils/functions.js';
 import { IN_WEBCONTAINER } from './constants.js';
 import { respond } from './respond.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
-import { format_server_error } from './utils.js';
-import { set_read_implementation, set_manifest } from '__sveltekit/server';
+import { set_read_implementation, set_manifest } from './internal.js';
 import { set_env } from '__sveltekit/env';
 import { set_app } from './app.js';
+import { SvelteKitError } from '@sveltejs/kit/internal';
 
 /** @type {Promise<any>} */
 let init_promise;
@@ -107,13 +107,23 @@ export class Server {
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
 					handleError:
 						module.handleError ||
-						(({ status, error, event }) => {
-							const error_message = format_server_error(
-								status,
-								/** @type {Error} */ (error),
-								event
-							);
-							console.error(error_message);
+						(({ error }) => {
+							if (error instanceof SvelteKitError) {
+								// don't log stack traces for 404s etc, it's all internal gubbins
+								return;
+							}
+
+							let e = error;
+							while (e instanceof Error) {
+								if (e.stack) {
+									console.error(e.stack);
+								}
+								e = e.cause;
+							}
+
+							if (e) {
+								console.error(String(e));
+							}
 						}),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
 					handleValidationError:
@@ -164,7 +174,7 @@ export class Server {
 	 * @param {Request} request
 	 * @param {import('types').RequestOptions} options
 	 */
-	async respond(request, options) {
+	respond(request, options) {
 		return respond(request, this.#options, this.#manifest, {
 			...options,
 			error: false,

package/src/runtime/server/internal.js

@@ -0,0 +1,25 @@
+/** @import { SSRManifest } from '@sveltejs/kit'; */
+
+/**
+ * @type {((path: string) => ReadableStream<any>) | null}
+ */
+export let read_implementation = null;
+
+export let manifest = /** @type {SSRManifest} */ (/** @type {unknown} */ (null));
+
+/**
+ * @param {(path: string) => ReadableStream<any>} fn
+ */
+export function set_read_implementation(fn) {
+	read_implementation = fn;
+}
+
+/**
+ *
+ * @param {SSRManifest} value
+ */
+export function set_manifest(value) {
+	manifest = value;
+}
+
+export { fix_stack_trace, set_fix_stack_trace } from './sourcemaps.js';

package/src/runtime/server/page/actions.js

@@ -7,7 +7,8 @@ import { HttpError, Redirect, ActionFailure, SvelteKitError } from '@sveltejs/ki
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { normalize_error } from '../../../utils/error.js';
 import { is_form_content_type, negotiate } from '../../../utils/http.js';
-import { create_replacer, handle_error_and_jsonify } from '../utils.js';
+import { create_replacer } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 import { record_span } from '../../telemetry/record_span.js';
 
 /** @param {RequestEvent} event */

package/src/runtime/server/page/data_serializer.js

@@ -1,12 +1,8 @@
 import * as devalue from 'devalue';
 import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
-import {
-	clarify_devalue_error,
-	get_global_name,
-	handle_error_and_jsonify,
-	serialize_uses
-} from '../utils.js';
+import { clarify_devalue_error, get_global_name, serialize_uses } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 
 /**
  * If the serialized data contains promises, `chunks` will be an
@@ -45,12 +41,14 @@ export function server_data_serializer(event, event_state, options) {
 							let str;
 							try {
 								str = devalue.uneval(error ? [, error] : [data], replacer);
-							} catch {
+							} catch (e) {
 								error = await handle_error_and_jsonify(
 									event,
 									event_state,
 									options,
-									new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+									new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
+										cause: e
+									})
 								);
 								str = devalue.uneval([, error], replacer);
 							}
@@ -164,12 +162,14 @@ export function server_data_serializer_json(event, event_state, options) {
 						let str;
 						try {
 							str = devalue.stringify(value, reducers);
-						} catch {
+						} catch (e) {
 							const error = await handle_error_and_jsonify(
 								event,
 								event_state,
 								options,
-								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+								new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
+									cause: e
+								})
 							);
 
 							key = 'error';

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

@@ -7,7 +7,8 @@ import { compact } from '../../../utils/array.js';
 import { get_status, normalize_error } from '../../../utils/error.js';
 import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
-import { redirect_response, static_error_page, handle_error_and_jsonify } from '../utils.js';
+import { redirect_response } from '../utils.js';
+import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
 	handle_action_json_request,
 	handle_action_request,
@@ -19,7 +20,7 @@ import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { DEV } from 'esm-env';
-import { get_remote_action, handle_remote_form_post } from '../remote.js';
+import { get_remote_action, handle_remote_form_post } from '../remote-functions.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**

package/src/runtime/server/page/load_data.js

@@ -465,7 +465,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 					const included = resolve_opts.filterSerializedResponseHeaders(lower, value);
 					if (!included) {
 						throw new Error(
-							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#Server-hooks-handle (at ${event.route.id})`
+							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#handle (at ${event.route.id})`
 						);
 					}
 				}

package/src/runtime/server/page/render.js

@@ -14,14 +14,10 @@ import { create_server_routing_response, generate_route_object } from './server_
 import { add_data_suffix, add_resolution_suffix } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import {
-	count_non_ssi_comments,
-	create_replacer,
-	get_global_name,
-	handle_error_and_jsonify
-} from '../utils.js';
+import { count_non_ssi_comments, create_replacer, get_global_name } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 import * as env from '__sveltekit/env';
-import { collect_remote_data } from '../remote.js';
+import { collect_remote_data } from '../remote-functions.js';
 import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 

package/src/runtime/server/page/respond_with_error.js

@@ -1,7 +1,8 @@
 import { Redirect } from '@sveltejs/kit/internal';
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
-import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
+import { redirect_response } from '../utils.js';
+import { handle_error_and_jsonify, static_error_page } from '../errors.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
 
@@ -33,12 +34,12 @@ export async function respond_with_error({
 }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
-		return static_error_page(options, status, /** @type {Error} */ (error).message);
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+		return static_error_page(options, status, transformed.message);
 	}
 
 	/** @type {import('./types.js').Fetched[]} */
 	const fetched = [];
-
 	try {
 		const branch = [];
 		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
@@ -46,6 +47,8 @@ export async function respond_with_error({
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
 		const data_serializer = server_data_serializer(event, event_state, options);
+		// Do this here first in case the awaits below before rendering themselves error
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
 
 		if (ssr) {
 			state.error = true;
@@ -89,8 +92,6 @@ export async function respond_with_error({
 			);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
-
 		return await render_response({
 			options,
 			manifest,

package/src/runtime/server/{remote.js → remote-functions.js}

@@ -7,7 +7,7 @@ import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
 import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.js';
-import { handle_error_and_jsonify } from './utils.js';
+import { handle_error_and_jsonify } from './errors.js';
 import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';

package/src/runtime/server/respond.js

@@ -9,12 +9,8 @@ import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
 import { get_self_origin, is_csrf_forbidden, is_remote_forbidden } from './csrf.js';
-import {
-	handle_fatal_error,
-	has_prerendered_path,
-	method_not_allowed,
-	redirect_response
-} from './utils.js';
+import { has_prerendered_path, method_not_allowed, redirect_response } from './utils.js';
+import { handle_fatal_error } from './errors.js';
 import { decode_pathname, disable_search, normalize_path } from '../../utils/url.js';
 import { find_route } from '../../utils/routing.js';
 import { redirect_json_response, render_data } from './data/index.js';
@@ -36,7 +32,7 @@ import {
 	strip_resolution_suffix
 } from '../pathname.js';
 import { server_data_serializer } from './page/data_serializer.js';
-import { get_remote_id, handle_remote_call } from './remote.js';
+import { get_remote_id, handle_remote_call } from './remote-functions.js';
 import { record_span } from '../telemetry/record_span.js';
 import { otel } from '../telemetry/otel.js';
 

package/src/runtime/server/sourcemaps.js

@@ -0,0 +1,183 @@
+/* eslint-disable n/prefer-global/process */
+
+// using `getBuiltinModule` rather than `import` makes this safe to run in non-Node-compatible environments
+const fs = globalThis.process?.getBuiltinModule?.('node:fs');
+const url = globalThis.process?.getBuiltinModule?.('node:url');
+const path = globalThis.process?.getBuiltinModule?.('node:path');
+const module = globalThis.process?.getBuiltinModule?.('node:module');
+
+const cwd = globalThis.process?.cwd?.();
+
+/** @type {(file: string) => string} */
+const relative = cwd ? (file) => path.relative(cwd, file) : (file) => file;
+
+/**
+ * Applies sourcemaps, makes paths relative to the cwd, and truncates
+ * non-user code from the bottom of the stack
+ * @param {Error} error
+ * @returns void
+ */
+export let fix_stack_trace = (error) => {
+	if (!error.stack || !fs) return;
+
+	let end = 0;
+
+	error.stack = error.stack
+		.split('\n')
+		.map((line, i) => {
+			const match = line.match(/^ {4}at.+(file:\/\/\/.*):(\d+):(\d+)(\)?)$/);
+
+			if (!match) {
+				if (!line.includes('node:internal/')) {
+					end = i + 1;
+				}
+
+				return line;
+			}
+
+			const file = url.fileURLToPath(match[1]);
+			const traced = trace(file, Number(match[2]) - 1, Number(match[3]) - 1);
+
+			// truncate non-user code from the bottom of the stack (but leave it in otherwise)
+			if (!/[\\/]node_modules[\\/]/.test(traced?.file ?? file)) {
+				end = i + 1;
+			}
+
+			if (traced?.line) {
+				const location = `${match[1]}:${match[2]}:${match[3]}`;
+				const original = `${relative(traced.file)}:${traced.line}:${traced.column}`;
+
+				return line.replace(location, original);
+			}
+
+			if (traced) {
+				return `${line.replace(match[1], relative(file))} [${traced.file}]`;
+			}
+
+			return line;
+		})
+		.slice(0, end)
+		.join('\n');
+};
+
+/**
+ * Override the implementation of fix_stack_trace (for using during dev)
+ * @param {(error: Error) => void} fn
+ */
+export function set_fix_stack_trace(fn) {
+	fix_stack_trace = fn;
+}
+
+/** @type {Map<string, { map: import('node:module').SourceMap; directory: string } | null>} */
+const source_maps = new Map();
+
+/** @type {Map<string, Array<string | undefined>>} */
+const source_regions = new Map();
+
+/** @param {string} file */
+function get_source_map(file) {
+	if (source_maps.has(file)) {
+		return source_maps.get(file);
+	}
+
+	try {
+		let source;
+		let directory = path.dirname(file);
+
+		const code = fs.readFileSync(file, 'utf8');
+		const matches = Array.from(code.matchAll(/\/\/[#@]\s*sourceMappingURL=(\S+)/g));
+		const url = matches.at(-1)?.[1];
+
+		if (url?.startsWith('data:')) {
+			const comma = url.indexOf(',');
+			const metadata = url.slice(5, comma);
+			const data = url.slice(comma + 1);
+			source = metadata.endsWith(';base64')
+				? Buffer.from(data, 'base64').toString()
+				: decodeURIComponent(data);
+		} else {
+			const map_file = url
+				? path.resolve(path.dirname(file), decodeURIComponent(url))
+				: `${file}.map`;
+			if (fs.existsSync(map_file)) {
+				directory = path.dirname(map_file);
+				source = fs.readFileSync(map_file, 'utf8');
+			}
+		}
+
+		if (source) {
+			const source_map = { map: new module.SourceMap(JSON.parse(source)), directory };
+			source_maps.set(file, source_map);
+
+			return source_map;
+		}
+	} catch {
+		// failure could be for any reason and this is best-effort, ignore
+	}
+
+	source_maps.set(file, null);
+	return null;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {number} line
+ * @param {number} column
+ * @returns {null | { file: string, line?: number, column?: number }}
+ */
+function trace(file, line, column) {
+	const source_map = get_source_map(file);
+	if (!source_map) return null;
+
+	const entry = source_map.map.findEntry(line, column);
+
+	if (
+		entry &&
+		'originalSource' in entry &&
+		entry.originalSource &&
+		typeof entry.originalLine === 'number' &&
+		typeof entry.originalColumn === 'number'
+	) {
+		const source = entry.originalSource.startsWith('file:')
+			? url.fileURLToPath(entry.originalSource)
+			: path.resolve(source_map.directory, entry.originalSource);
+
+		const traced = {
+			file: source,
+			line: entry.originalLine + 1,
+			column: entry.originalColumn + 1
+		};
+
+		// keep going, in case we are running code that was bundled a second time by an adapter
+		return trace(traced.file, traced.line - 1, traced.column - 1) ?? traced;
+	}
+
+	let regions = source_regions.get(file);
+	if (!regions) {
+		/** @type {string | undefined} */
+		let source;
+		regions = fs
+			.readFileSync(file, 'utf8')
+			.split('\n')
+			.map((line) => {
+				// Vite will merge multiple files into one but add region markers
+				// with the original file names, which we try to extract here.
+				const start = line.match(/^\/\/#region (.+)$/);
+				if (start) source = start[1];
+				if (line === '//#endregion') source = undefined;
+				return source;
+			});
+		source_regions.set(file, regions);
+	}
+
+	const source = regions[line];
+
+	if (source) {
+		return {
+			file: source
+		};
+	}
+
+	return null;
+}

package/src/runtime/server/utils.js

@@ -1,15 +1,7 @@
 /** @import { ServerHooks } from 'types' */
 import * as devalue from 'devalue';
-import { DEV } from 'esm-env';
-import { json, text } from '@sveltejs/kit';
-import { HttpError } from '@sveltejs/kit/internal';
-import { with_request_store } from '@sveltejs/kit/internal/server';
-import { coalesce_to_error, get_message, get_status } from '../../utils/error.js';
-import { negotiate } from '../../utils/http.js';
-import { fix_stack_trace } from '../shared-server.js';
+import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
-import { escape_html } from '../../utils/escape.js';
-import * as path from '../../utils/path.js';
 
 /**
  * @param {Partial<Record<import('types').HttpMethod, any>>} mod
@@ -46,103 +38,6 @@ export function get_global_name(options) {
 	return __SVELTEKIT_DEV__ ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
 }
 
-/**
- * Return as a response that renders the error.html
- *
- * @param {import('types').SSROptions} options
- * @param {number} status
- * @param {string} message
- */
-export function static_error_page(options, status, message) {
-	let page = options.templates.error({ status, message: escape_html(message) });
-
-	if (__SVELTEKIT_DEV__) {
-		// inject Vite HMR client, for easier debugging
-		page = page.replace('</head>', '<script type="module" src="/@vite/client"></script></head>');
-	}
-
-	return text(page, {
-		headers: { 'content-type': 'text/html; charset=utf-8' },
-		status
-	});
-}
-
-/**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
- * @param {unknown} error
- */
-export async function handle_fatal_error(event, state, options, error) {
-	error = error instanceof HttpError ? error : coalesce_to_error(error);
-	const body = await handle_error_and_jsonify(event, state, options, error);
-	const status = body.status;
-
-	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
-	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
-		'application/json',
-		'text/html'
-	]);
-
-	if (event.isDataRequest || type === 'application/json') {
-		return json(body, {
-			status
-		});
-	}
-
-	return static_error_page(options, status, body.message);
-}
-
-/**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
- * @param {any} error
- * @returns {App.Error | Promise<App.Error>}
- */
-export function handle_error_and_jsonify(event, state, options, error) {
-	if (error instanceof HttpError) {
-		// @ts-expect-error custom user errors may not have a message field if App.Error is overwritten
-		return { message: 'Unknown Error', ...error.body };
-	}
-
-	if (__SVELTEKIT_DEV__ && typeof error == 'object') {
-		fix_stack_trace(error);
-	}
-
-	const status = get_status(error);
-	const message = get_message(error);
-
-	// TODO 4.0 await this, rather than handling the non-Promise case
-	const result = with_request_store({ event, state }, () =>
-		options.hooks.handleError({ error, event, status, message })
-	) ?? { status, message };
-
-	if (result instanceof Promise) {
-		if (!__SVELTEKIT_SUPPORTS_ASYNC__ && state.is_in_render) {
-			console.warn(
-				`To use an async \`handleError\` hook to handle errors that occur during rendering, you must enable \`compilerOptions.experimental.async\` in the SvelteKit plugin of your Vite config. The returned error has been replaced with a generic object`
-			);
-
-			// we're discarding the result, but we still need to prevent an unhandled
-			// rejection if the user's async `handleError` hook rejects
-			result.catch(() => {});
-
-			return {
-				status,
-				message: 'Internal Error'
-			};
-		}
-
-		return result.then((body) => {
-			body ??= { status, message };
-			return { ...body, status: get_status(body, error) };
-		});
-	}
-
-	return { ...result, status: get_status(result, error) };
-}
-
 /**
  * @param {number} status
  * @param {string} location
@@ -163,7 +58,7 @@ export function clarify_devalue_error(event, error) {
 	if (error.path) {
 		return (
 			`Data returned from \`load\` while rendering ${event.route.id} is not serializable: ${error.message} (${error.path}). ` +
-			`If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#Universal-hooks-transport.`
+			`If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#transport.`
 		);
 	}
 
@@ -212,56 +107,6 @@ export function has_prerendered_path(manifest, pathname) {
 	);
 }
 
-/**
- * Formats the error into a nice message with sanitized stack trace
- * @param {number} status
- * @param {Error} error
- * @param {import('@sveltejs/kit').RequestEvent} event
- */
-export function format_server_error(status, error, event) {
-	const formatted_text = `\n\x1b[1;31m[${status}] ${event.request.method} ${event.url.pathname}\x1b[0m`;
-
-	if (status === 404) {
-		return formatted_text;
-	}
-
-	return `${formatted_text}\n${DEV ? clean_up_stack_trace(error) : error.stack}`;
-}
-
-/**
- * In dev, tidy up stack traces by making paths relative to the current project directory
- * @param {string} file
- */
-let relative = (file) => file;
-
-if (DEV) {
-	try {
-		relative = (file) => path.relative(__SVELTEKIT_ROOT__, file);
-	} catch {
-		// do nothing
-	}
-}
-
-/**
- * Provides a refined stack trace by excluding lines following the last occurrence of a line containing +page. +layout. or +server.
- * @param {Error} error
- */
-export function clean_up_stack_trace(error) {
-	const stack_trace = (error.stack?.split('\n') ?? []).map((line) => {
-		return line.replace(/\((.+)(:\d+:\d+)\)$/, (_, file, loc) => `(${relative(file)}${loc})`);
-	});
-
-	// progressive enhancement for people who haven't configured files.src to something else
-	const last_line_from_src_code = stack_trace.findLastIndex((line) => /\(src[\\/]/.test(line));
-
-	if (last_line_from_src_code === -1) {
-		// default to the whole stack trace
-		return error.stack;
-	}
-
-	return stack_trace.slice(0, last_line_from_src_code + 1).join('\n');
-}
-
 /**
  * Returns the filename without the extension. e.g., `+page.server`, `+page`, etc.
  * @param {string | undefined} node_id

package/src/types/ambient-private.d.ts

@@ -13,8 +13,10 @@ declare module '__sveltekit/paths' {
 declare module '__sveltekit/server' {
 	import { SSRManifest } from '@sveltejs/kit';
 
+	export let fix_stack_trace: (error: Error) => string;
 	export let manifest: SSRManifest;
 	export function read_implementation(path: string): ReadableStream;
+	export function set_fix_stack_trace(fn: (error: Error) => string): void;
 	export function set_manifest(manifest: SSRManifest): void;
 	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
 }

package/src/types/global-private.d.ts

@@ -38,11 +38,6 @@ declare global {
 	 * Should only be used when bundleStrategy !== 'inline' to avoid SvelteKit runtime changing on every build, preventing cacheability.
 	 */
 	const __SVELTEKIT_PAYLOAD__: SvelteKitPayload;
-	/**
-	 * The Vite `root` setting used to construct paths to nodes and components
-	 * for the SSR manifest during development
-	 */
-	const __SVELTEKIT_ROOT__: string;
 	/**
 	 * Whether the `experimental.async` flag is applied
 	 */