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

package/src/exports/vite/index.js

@@ -34,6 +34,9 @@ import {
 	error_for_missing_config,
 	get_config_aliases,
 	normalize_id,
+	remote_module_pattern,
+	server_only_directory_pattern,
+	server_only_module_pattern,
 	strip_virtual_prefix
 } from './utils.js';
 import { stackless } from '../../utils/error.js';
@@ -51,7 +54,6 @@ import {
 	sveltekit_env,
 	sveltekit_env_private,
 	sveltekit_env_service_worker,
-	sveltekit_server,
 	sveltekit_env_public_client,
 	sveltekit_env_public_server
 } from './module_ids.js';
@@ -402,11 +404,23 @@ function kit({ svelte_config }) {
 				// dev and preview config can be shared
 				/** @type {UserConfig} */
 				const new_config = {
+					environments: {
+						ssr: {
+							build: {
+								sourcemap:
+									config.environments?.ssr?.build?.sourcemap ?? config.build?.sourcemap ?? true
+							}
+						}
+					},
 					resolve: {
 						alias: [
 							{ find: '__SERVER__', replacement: `${generated}/server` },
 							{ find: '$app', replacement: `${runtime_directory}/app` },
 							{ find: '$env', replacement: `${runtime_directory}/env` },
+							{
+								find: '__sveltekit/server',
+								replacement: `${runtime_directory}/server/internal.js`
+							},
 							...get_config_aliases(kit, root)
 						]
 					},
@@ -458,11 +472,8 @@ function kit({ svelte_config }) {
 					}
 				};
 
+				// treat .remote.js files as empty for the purposes of prebundling
 				if (kit.experimental.remoteFunctions) {
-					// treat .remote.js files as empty for the purposes of prebundling
-					const remote_id_filter = new RegExp(
-						`.remote(${kit.moduleExtensions.join('|')})$`.replaceAll('.', '\\.')
-					);
 					// @ts-expect-error optimizeDeps is already set above
 					new_config.optimizeDeps.rolldownOptions ??= {};
 					// @ts-expect-error
@@ -471,7 +482,7 @@ function kit({ svelte_config }) {
 					new_config.optimizeDeps.rolldownOptions.plugins.push({
 						name: 'vite-plugin-sveltekit-setup:optimize-remote-functions',
 						load: {
-							filter: { id: remote_id_filter },
+							filter: { id: remote_module_pattern },
 							handler() {
 								return '';
 							}
@@ -493,7 +504,6 @@ function kit({ svelte_config }) {
 					__SVELTEKIT_SUPPORTS_ASYNC__: s(
 						svelte_config.compilerOptions?.experimental?.async ?? false
 					),
-					__SVELTEKIT_ROOT__: s(root),
 					__SVELTEKIT_DEV__: s(!is_build)
 				};
 
@@ -648,8 +658,7 @@ function kit({ svelte_config }) {
 					exactRegex(sveltekit_env_private),
 					exactRegex(sveltekit_env_public_client),
 					exactRegex(sveltekit_env_public_server),
-					exactRegex(sveltekit_env_service_worker),
-					exactRegex(sveltekit_server)
+					exactRegex(sveltekit_env_service_worker)
 				]
 			},
 			handler(id) {
@@ -687,22 +696,6 @@ function kit({ svelte_config }) {
 									kit.appDir
 								)
 							: create_sveltekit_env_service_worker_dev(explicit_env_config, env, kit_global);
-
-					case sveltekit_server: {
-						return dedent`
-							export let read_implementation = null;
-
-							export let manifest = null;
-
-							export function set_read_implementation(fn) {
-								read_implementation = fn;
-							}
-
-							export function set_manifest(_) {
-								manifest = _;
-							}
-						`;
-					}
 				}
 			}
 		}
@@ -710,10 +703,6 @@ function kit({ svelte_config }) {
 
 	/** @type {Map<string, Set<string>>} */
 	const import_map = new Map();
-	// Matches any ID that has .server. in its filename
-	const server_only_module_pattern = /\.server\.[^/]+$/;
-	// Matches any ID that has /server/ in its path
-	const server_only_directory_pattern = /\/server\//;
 
 	/**
 	 * Ensures that client-side code can't accidentally import server-side code,
@@ -769,24 +758,21 @@ function kit({ svelte_config }) {
 				]
 			},
 			handler(id) {
-				// skip .server.js files outside the cwd or in node_modules, as the filename might not mean 'server-only module' in this context
-				const is_internal =
-					id.startsWith(normalized_cwd) && !id.startsWith(normalized_node_modules);
-
 				const normalized = normalize_id(id, normalized_aliases, normalized_cwd);
 
-				// server-only directories: any file in a `/server/` folder inside the cwd,
-				// except those inside the routes or assets directories
-				const is_in_routes = id.startsWith(normalized_routes + '/');
-				const is_in_assets = id.startsWith(normalized_assets + '/');
-				const is_server_only_directory =
-					is_internal && !is_in_routes && !is_in_assets && server_only_directory_pattern.test(id);
+				let is_server_only = normalized === '$app/env/private' || normalized === '$app/server';
 
-				const is_server_only =
-					normalized === '$app/env/private' ||
-					normalized === '$app/server' ||
-					is_server_only_directory ||
-					(is_internal && server_only_module_pattern.test(id));
+				// skip .server.js files outside the cwd or in node_modules, as the filename might not mean 'server-only module' in this context
+				if (id.startsWith(normalized_cwd) && !id.startsWith(normalized_node_modules)) {
+					// e.g. `server.ts` or `foo.server.ts`
+					is_server_only ||= server_only_module_pattern.test(id);
+
+					// e.g. `server/foo.ts`, unless in `src/routes` or `static`
+					is_server_only ||=
+						server_only_directory_pattern.test(id) &&
+						!id.startsWith(normalized_routes + '/') &&
+						!id.startsWith(normalized_assets + '/');
+				}
 
 				if (!is_server_only) return;
 
@@ -837,6 +823,10 @@ function kit({ svelte_config }) {
 				const chain = find_chain(normalized, [normalized]);
 
 				if (chain) {
+					if (chain.some((id) => remote_module_pattern.test(id))) {
+						error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true');
+					}
+
 					const pyramid = chain
 						.reverse()
 						.map((id, i) => {
@@ -907,31 +897,30 @@ function kit({ svelte_config }) {
 			dev_server = _dev_server;
 		},
 
-		async transform(code, id) {
-			const normalized = normalize_id(id, normalized_aliases, normalized_cwd);
-			if (!svelte_config.kit.moduleExtensions.some((ext) => normalized.endsWith(`.remote${ext}`))) {
-				return;
-			}
-
-			const file = posixify(path.relative(root, id));
-			const remote = {
-				hash: hash(file),
-				file
-			};
+		transform: {
+			filter: {
+				id: remote_module_pattern
+			},
+			async handler(code, id) {
+				const file = posixify(path.relative(root, id));
+				const remote = {
+					hash: hash(file),
+					file
+				};
 
-			remotes.push(remote);
+				remotes.push(remote);
 
-			if (this.environment.config.consumer !== 'client') {
-				// we need to add an `await Promise.resolve()` because if the user imports this function
-				// on the client AND in a load function when loading the client module we will trigger
-				// an ssrLoadModule during dev. During a link preload, the module can be mistakenly
-				// loaded and transformed twice and the first time all its exports would be undefined
-				// triggering a dev server error. By adding a microtask we ensure that the module is fully loaded
+				if (this.environment.config.consumer !== 'client') {
+					// we need to add an `await Promise.resolve()` because if the user imports this function
+					// on the client AND in a load function when loading the client module we will trigger
+					// an ssrLoadModule during dev. During a link preload, the module can be mistakenly
+					// loaded and transformed twice and the first time all its exports would be undefined
+					// triggering a dev server error. By adding a microtask we ensure that the module is fully loaded
 
-				// Extra newlines to prevent syntax errors around missing semicolons or comments
-				code +=
-					'\n\n' +
-					dedent`
+					// Extra newlines to prevent syntax errors around missing semicolons or comments
+					code +=
+						'\n\n' +
+						dedent`
 					import * as $$_self_$$ from './${path.basename(id)}';
 					import { init_remote_functions as $$_init_$$ } from '@sveltejs/kit/internal/server';
 
@@ -945,71 +934,72 @@ function kit({ svelte_config }) {
 					}
 				`;
 
-				// Emit a dedicated entry chunk for this remote in SSR builds (prod only)
-				if (!dev_server) {
-					remote_original_by_hash.set(remote.hash, id);
-					if (!emitted_remote_hashes.has(remote.hash)) {
-						this.emitFile({
-							type: 'chunk',
-							id: `\0sveltekit-remote:${remote.hash}`,
-							name: `remote-${remote.hash}`
-						});
-						emitted_remote_hashes.add(remote.hash);
+					// Emit a dedicated entry chunk for this remote in SSR builds (prod only)
+					if (!dev_server) {
+						remote_original_by_hash.set(remote.hash, id);
+						if (!emitted_remote_hashes.has(remote.hash)) {
+							this.emitFile({
+								type: 'chunk',
+								id: `\0sveltekit-remote:${remote.hash}`,
+								name: `remote-${remote.hash}`
+							});
+							emitted_remote_hashes.add(remote.hash);
+						}
 					}
-				}
 
-				return code;
-			}
+					return code;
+				}
 
-			// For the client, read the exports and create a new module that only contains fetch functions with the correct metadata
+				// For the client, read the exports and create a new module that only contains fetch functions with the correct metadata
 
-			/** @type {Map<string, RemoteInternals['type']>} */
-			const map = new Map();
+				/** @type {Map<string, RemoteInternals['type']>} */
+				const map = new Map();
 
-			// in dev, load the server module here (which will result in this hook
-			// being called again with `opts.ssr === true` if the module isn't
-			// already loaded) so we can determine what it exports
-			if (dev_server) {
-				const module = await dev_server.ssrLoadModule(id);
+				// in dev, load the server module here (which will result in this hook
+				// being called again with `opts.ssr === true` if the module isn't
+				// already loaded) so we can determine what it exports
+				if (dev_server) {
+					const module = await dev_server.ssrLoadModule(id);
 
-				for (const [name, value] of Object.entries(module)) {
-					const type = value?.__?.type;
-					if (type) {
-						map.set(name, type);
+					for (const [name, value] of Object.entries(module)) {
+						const type = value?.__?.type;
+						if (type) {
+							map.set(name, type);
+						}
 					}
 				}
-			}
 
-			// in prod, we already built and analysed the server code before
-			// building the client code, so `remotes` is populated
-			else if (build_metadata?.remotes) {
-				const exports = build_metadata?.remotes.get(remote.hash);
-				if (!exports) throw new Error('Expected to find metadata for remote file ' + id);
+				// in prod, we already built and analysed the server code before
+				// building the client code, so `remotes` is populated
+				else if (build_metadata?.remotes) {
+					const exports = build_metadata?.remotes.get(remote.hash);
+					if (!exports) throw new Error('Expected to find metadata for remote file ' + id);
 
-				for (const [name, value] of exports) {
-					map.set(name, value.type);
+					for (const [name, value] of exports) {
+						map.set(name, value.type);
+					}
 				}
-			}
 
-			const { namespace, declarations, reexports } = create_exported_declarations(
-				map.keys(),
-				(name, ns) => `${ns}.${map.get(name)}('${remote.hash}/${name}')`,
-				'__remote'
-			);
+				const { namespace, declarations, reexports } = create_exported_declarations(
+					map.keys(),
+					(name, ns) => `${ns}.${map.get(name)}('${remote.hash}/${name}')`,
+					'__remote'
+				);
 
-			let result = `import * as ${namespace} from '__sveltekit/remote';\n\n${declarations.join('\n')}`;
-			if (reexports.length > 0) {
-				result += `\nexport { ${reexports.join(', ')} };`;
-			}
-			result += '\n';
+				let result = `import * as ${namespace} from '__sveltekit/remote';\n\n${declarations.join('\n')}`;
+				if (reexports.length > 0) {
+					result += `\nexport { ${reexports.join(', ')} };`;
+				}
+				result += '\n';
 
-			if (dev_server) {
-				result += `\nimport.meta.hot?.accept();\n`;
-			}
+				if (dev_server) {
+					result += `\nimport.meta.hot?.accept();\n`;
+				}
 
-			return {
-				code: result
-			};
+				return {
+					code: result
+				};
+			}
 		}
 	};
 
@@ -1844,15 +1834,30 @@ function kit({ svelte_config }) {
 			}
 
 			// ...and prerender
-			const prerender_results = await prerender({
-				hash: kit.router.type === 'hash',
-				out,
-				manifest_path,
-				metadata,
-				verbose,
-				env,
-				vite_config_file: vite_config.configFile
-			});
+			let prerender_results;
+			try {
+				prerender_results = await prerender({
+					hash: kit.router.type === 'hash',
+					out,
+					manifest_path,
+					metadata,
+					verbose,
+					env,
+					vite_config_file: vite_config.configFile
+				});
+
+				// this silly hack is necessary to ensure that stderr from prerender is flushed before we continue
+				await new Promise((f) => setTimeout(f, 0));
+			} catch (e) {
+				if (e instanceof Error && e.message === '__handled__') {
+					// error details are already logged inside `prerender`, don't duplicate them
+					throw stackless('Prerendering failed');
+				} else {
+					// Unforeseen error, rethrow as-is
+					throw e;
+				}
+			}
+
 			prerendered = prerender_results.prerendered;
 
 			await treeshake_prerendered_remotes(

package/src/exports/vite/module_ids.js

@@ -9,8 +9,6 @@ export const sveltekit_env_service_worker = '\0virtual:__sveltekit/env/service-w
 
 export const service_worker = '\0virtual:service-worker';
 
-export const sveltekit_server = '\0virtual:__sveltekit/server';
-
 export const app_server = posixify(
 	fileURLToPath(new URL('../../runtime/app/server/index.js', import.meta.url))
 );

package/src/exports/vite/preview/index.js

@@ -10,6 +10,7 @@ import { loadEnv, normalizePath } from 'vite';
 import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { is_chrome_devtools_request, not_found } from '../utils.js';
+import { stackless } from '../../../utils/error.js';
 
 /**
  * @param {PreviewServer} vite
@@ -27,8 +28,8 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	const dir = join(svelte_config.kit.outDir, 'output/server');
 
-	if (!fs.existsSync(dir)) {
-		throw new Error(`Server files not found at ${dir}, did you run \`build\` first?`);
+	if (!fs.existsSync(`${dir}/manifest.js`)) {
+		throw stackless(`Server files not found at ${dir}, did you run \`build\` first?`);
 	}
 
 	const instrumentation = join(dir, 'instrumentation.server.js');

package/src/exports/vite/utils.js

@@ -10,6 +10,7 @@ import {
 	service_worker,
 	sveltekit_env_private
 } from './module_ids.js';
+import { styleText } from 'node:util';
 
 /**
  * Transforms alias to a valid vite.resolve.alias array.
@@ -149,6 +150,10 @@ export function normalize_id(id, aliases, cwd) {
 	return posixify(id);
 }
 
+export const remote_module_pattern = /[/.]remote(\.[^/]+)+$/;
+export const server_only_module_pattern = /[/.]server(\.[^/]+)+$/;
+export const server_only_directory_pattern = /\/server\//;
+
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**
@@ -187,3 +192,18 @@ export function error_for_missing_config(feature_name, path, value) {
 		`
 	);
 }
+
+/**
+ * @param {number} status
+ * @param {Request} request
+ */
+export function log_response(status, request) {
+	const url = new URL(request.url);
+	const log = `[${status}] ${request.method} ${url.href.replace(url.origin, '')}`;
+
+	if (status < 400) {
+		console.log(log);
+	} else {
+		console.error(styleText(['bold', 'red'], log));
+	}
+}

package/src/runtime/app/paths/server.js

@@ -3,7 +3,7 @@ import { resolve_route, find_route } from '../../../utils/routing.js';
 import { decode_pathname } from '../../../utils/url.js';
 import { add_data_suffix } from '../../pathname.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
-import { manifest } from '__sveltekit/server';
+import { manifest } from '../../server/internal.js';
 import { get_hooks } from '__SERVER__/internal.js';
 
 /** @type {import('./client.js').asset} */

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

@@ -1,4 +1,4 @@
-import { read_implementation, manifest } from '__sveltekit/server';
+import { read_implementation, manifest } from '../../server/internal.js';
 import { assets } from '$app/paths/internal/server';
 import { base64_decode } from '../../utils.js';
 

package/src/runtime/app/server/remote/query.js

@@ -13,7 +13,7 @@ import {
 } from './shared.js';
 import { noop } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
-import { handle_error_and_jsonify } from '../../../server/utils.js';
+import { handle_error_and_jsonify } from '../../../server/errors.js';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.

package/src/runtime/client/ndjson.js

@@ -6,7 +6,7 @@ import { read_stream } from './stream.js';
  * @param {ReadableStreamDefaultReader<Uint8Array>} reader
  */
 export async function* read_ndjson(reader) {
-	for await (const block of read_stream(reader, '\n')) {
+	for await (const block of read_stream(reader, '\n', { fatal: true })) {
 		const line = block.trim();
 		if (line) {
 			yield JSON.parse(line);

package/src/runtime/client/stream.js

@@ -4,11 +4,12 @@
  * stream closes.
  * @param {ReadableStreamDefaultReader<Uint8Array>} reader
  * @param {string} delimiter
+ * @param {TextDecoderOptions} [options]
  */
-export async function* read_stream(reader, delimiter) {
+export async function* read_stream(reader, delimiter, options) {
 	let done = false;
 	let buffer = '';
-	const decoder = new TextDecoder();
+	const decoder = new TextDecoder(undefined, options);
 
 	while (true) {
 		let split = buffer.indexOf(delimiter);

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

@@ -4,7 +4,7 @@ import { normalize_error } from '../../../utils/error.js';
 import { once } from '../../../utils/functions.js';
 import { server_data_serializer_json } from '../page/data_serializer.js';
 import { load_server_data } from '../page/load_data.js';
-import { handle_error_and_jsonify } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 import { normalize_path } from '../../../utils/url.js';
 import { text_encoder } from '../../utils.js';
 

package/src/runtime/server/errors.js

@@ -0,0 +1,135 @@
+import { json, text } from '@sveltejs/kit';
+import { HttpError, SvelteKitError } 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 './internal.js';
+import { escape_html } from '../../utils/escape.js';
+
+/**
+ * @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 };
+	}
+
+	let e = error;
+	while (e instanceof Error) {
+		fix_stack_trace(e);
+		e = e.cause;
+	}
+
+	const status = get_status(error);
+	const message = get_message(error);
+
+	// TODO 4.0 await this, rather than handling the non-Promise case
+	let result;
+	try {
+		result = with_request_store({ event, state }, () =>
+			options.hooks.handleError({ error, event, status, message })
+		) ?? { status, message };
+	} catch (hook_error) {
+		log_handle_error_hook_failure(error, hook_error);
+		return { status, message: 'Internal Error' };
+	}
+
+	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((hook_error) => log_handle_error_hook_failure(error, hook_error));
+
+			return {
+				status,
+				message: 'Internal Error'
+			};
+		}
+
+		return result.then(
+			(body) => {
+				body ??= { status, message };
+				return { ...body, status: get_status(body, error) };
+			},
+			(hook_error) => {
+				log_handle_error_hook_failure(error, hook_error);
+				return { status, message: 'Internal Error' };
+			}
+		);
+	}
+
+	return { ...result, status: get_status(result, error) };
+}
+
+/**
+ * @param {unknown} error
+ * @param {unknown} hook_error
+ */
+function log_handle_error_hook_failure(error, hook_error) {
+	const failure = new Error('The `handleError` hook failed', {
+		cause: coalesce_to_error(hook_error)
+	});
+	failure.stack = failure.message;
+	console.error(failure);
+	if (error instanceof SvelteKitError) {
+		console.error(`Original error: ${error.status} ${error.text}: ${error.message}`);
+	} else {
+		console.error('Original error:', error);
+	}
+}
+
+/**
+ * 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
+	});
+}

package/src/runtime/server/fetch.js

@@ -2,7 +2,7 @@ import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
 import { respond } from './respond.js';
 import * as paths from '$app/paths/internal/server';
-import { read_implementation } from '__sveltekit/server';
+import { read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
 
 /**