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

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/form-utils.js

@@ -10,21 +10,58 @@ import { SvelteKitError } from '@sveltejs/kit/internal';
 const decoder = new TextDecoder();
 
 /**
- * Sets a value in a nested object using a path string, mutating the original object
+ * Sets a parsed form field value in a nested object, mutating the original object.
  * @param {Record<string, any>} object
- * @param {string} path_string
+ * @param {{ name: string; type: 'number' | 'boolean' | null }} field
  * @param {any} value
  */
-export function set_nested_value(object, path_string, value) {
-	if (path_string.startsWith('n:')) {
-		path_string = path_string.slice(2);
-		value = value === '' ? undefined : parseFloat(value);
-	} else if (path_string.startsWith('b:')) {
-		path_string = path_string.slice(2);
-		value = value === 'on';
+export function set_nested_value(object, field, value) {
+	deep_set(object, split_path(field.name), value);
+}
+
+/**
+ * Separates a form field's path from the metadata encoded in its name.
+ * @param {string} form_id
+ * @param {string} key
+ * @returns {{ name: string; type: 'number' | 'boolean' | null; is_array: boolean }}
+ */
+export function parse_form_key(form_id, key) {
+	const suffix = '/' + form_id;
+	let name = key;
+
+	if (!name.endsWith(suffix)) {
+		throw new Error(`Form contained a field that wasn't created with form.fields.as(...): ${name}`);
 	}
 
-	deep_set(object, split_path(path_string), value);
+	name = name.slice(0, -suffix.length);
+
+	/** @type {'number' | 'boolean' | null} */
+	let type = null;
+
+	if (name.startsWith('n:')) {
+		name = name.slice(2);
+		type = 'number';
+	} else if (name.startsWith('b:')) {
+		name = name.slice(2);
+		type = 'boolean';
+	}
+
+	const is_array = name.endsWith('[]');
+	if (is_array) name = name.slice(0, -2);
+
+	return { name, type, is_array };
+}
+
+/**
+ * @param {'number' | 'boolean' | null} type
+ * @param {any} value
+ * @returns {any}
+ */
+export function coerce_form_value(type, value) {
+	if (Array.isArray(value)) return value.map((value) => coerce_form_value(type, value));
+	if (type === 'number') return value === '' ? undefined : parseFloat(value);
+	if (type === 'boolean') return value === 'on';
+	return value;
 }
 
 /** Pass this to set_nested_value to delete the last part of the given path */
@@ -32,38 +69,36 @@ export const DELETE_KEY = {};
 
 /**
  * Convert `FormData` into a POJO
+ * @param {string} form_id
  * @param {FormData} data
  */
-export function convert_formdata(data) {
+export function convert_formdata(form_id, data) {
 	/** @type {Record<string, any>} */
 	const result = {};
 
-	for (let key of data.keys()) {
-		const is_array = key.endsWith('[]');
+	for (const field_name of data.keys()) {
 		/** @type {any[]} */
-		let values = data.getAll(key);
+		const values = data.getAll(field_name);
 
-		if (is_array) key = key.slice(0, -2);
+		const field = parse_form_key(form_id, field_name);
 
 		// an empty `<input type="file">` will submit a non-existent file, bizarrely
-		values = values.filter(
+		const entries = values.filter(
 			(entry) => typeof entry === 'string' || entry.name !== '' || entry.size > 0
 		);
-		if (values.length === 0 && !is_array) continue;
-
-		if (key.startsWith('n:')) {
-			key = key.slice(2);
-			values = values.map((v) => (v === '' ? undefined : parseFloat(/** @type {string} */ (v))));
-		} else if (key.startsWith('b:')) {
-			key = key.slice(2);
-			values = values.map((v) => v === 'on');
-		}
+		if (entries.length === 0 && !field.is_array) continue;
 
-		if (values.length > 1 && !is_array) {
-			throw new Error(`Form cannot contain duplicated keys — "${key}" has ${values.length} values`);
+		if (entries.length > 1 && !field.is_array) {
+			throw new Error(
+				`Form cannot contain duplicated keys — "${field.name}" has ${entries.length} values`
+			);
 		}
 
-		set_nested_value(result, key, is_array ? values : values[0]);
+		set_nested_value(
+			result,
+			field,
+			coerce_form_value(field.type, field.is_array ? entries : entries[0])
+		);
 	}
 
 	return result;
@@ -139,12 +174,13 @@ export function serialize_binary_form(data, meta) {
 
 /**
  * @param {Request} request
+ * @param {string} form_id
  * @returns {Promise<{ data: Record<string, any>; meta: BinaryFormMeta; form_data: FormData | null }>}
  */
-export async function deserialize_binary_form(request) {
+export async function deserialize_binary_form(request, form_id) {
 	if (request.headers.get('content-type') !== BINARY_FORM_CONTENT_TYPE) {
 		const form_data = await request.formData();
-		return { data: convert_formdata(form_data), meta: {}, form_data };
+		return { data: convert_formdata(form_id, form_data), meta: {}, form_data };
 	}
 	if (!request.body) {
 		throw deserialize_error('no body');
@@ -653,18 +689,21 @@ function deep_clone(value) {
 
 /**
  * Creates a proxy-based field accessor for form data
+ * @param {{
+ * 	form_id: string,
+ * 	get: () => Record<string, any>,
+ * 	set: (path: (string | number)[], value: any) => void,
+ * 	get_issues: (path?: (string | number)[], all?: boolean) => Record<string, InternalRemoteFormIssue[]>,
+ * 	get_touched: () => Record<string, boolean>,
+ * 	get_dirty: () => Record<string, boolean>
+ * }} context - Form context, including value accessors and form metadata
  * @param {any} target - Function or empty POJO
- * @param {() => Record<string, any>} get - Function to get current input data
- * @param {(path: (string | number)[], value: any) => void} set - Function to set input data
- * @param {(path?: (string | number)[], all?: boolean) => Record<string, InternalRemoteFormIssue[]>} get_issues - Function to get current issues
- * @param {() => Record<string, boolean>} get_touched - Function to get touched fields
- * @param {() => Record<string, boolean>} get_dirty - Function to get dirty fields
  * @param {(string | number)[]} path - Current access path
  * @returns {any} Proxy object with name(), value(), and issues() methods
  */
-export function create_field_proxy(target, get, set, get_issues, get_touched, get_dirty, path) {
+export function create_field_proxy(context, target = {}, path = []) {
 	const get_value = () => {
-		const value = deep_get(get(), path);
+		const value = deep_get(context.get(), path);
 		return deep_clone(value);
 	};
 
@@ -674,10 +713,7 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 
 			// Handle array access like jobs[0]
 			if (/^\d+$/.test(prop)) {
-				return create_field_proxy({}, get, set, get_issues, get_touched, get_dirty, [
-					...path,
-					parseInt(prop, 10)
-				]);
+				return create_field_proxy(context, {}, [...path, parseInt(prop, 10)]);
 			}
 
 			const key = build_path_string(path);
@@ -685,20 +721,19 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 
 			if (prop === 'set') {
 				const set_func = function (/** @type {any} */ newValue) {
-					set(path, newValue);
+					context.set(path, newValue);
 					return newValue;
 				};
-
-				return create_field_proxy(set_func, get, set, get_issues, get_touched, get_dirty, next);
+				return create_field_proxy(context, set_func, next);
 			}
 
 			if (prop === 'value') {
-				return create_field_proxy(get_value, get, set, get_issues, get_touched, get_dirty, next);
+				return create_field_proxy(context, get_value, next);
 			}
 
 			if (prop === 'issues' || prop === 'allIssues') {
 				const issues_func = () => {
-					const all_issues = get_issues(path, prop === 'allIssues')[key === '' ? '$' : key];
+					const all_issues = context.get_issues(path, prop === 'allIssues')[key === '' ? '$' : key];
 
 					if (prop === 'allIssues') {
 						return all_issues?.map((issue) => ({
@@ -717,12 +752,12 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 					return issues?.length ? issues : undefined;
 				};
 
-				return create_field_proxy(issues_func, get, set, get_issues, get_touched, get_dirty, next);
+				return create_field_proxy(context, issues_func, next);
 			}
 
 			if (prop === 'touched' || prop === 'dirty') {
 				const fn = () => {
-					const object = prop === 'dirty' ? get_dirty() : get_touched();
+					const object = prop === 'dirty' ? context.get_dirty() : context.get_touched();
 
 					if (key === '') {
 						return Object.keys(object).length > 0;
@@ -745,7 +780,7 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 					return false;
 				};
 
-				return create_field_proxy(fn, get, set, get_issues, get_touched, get_dirty, next);
+				return create_field_proxy(context, fn, next);
 			}
 
 			if (prop === 'as') {
@@ -759,14 +794,14 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 						type === 'select multiple' ||
 						(type === 'checkbox' && typeof input_value === 'string');
 
-					const prefix = get_type_prefix(type, is_array, input_value);
+					const type_prefix = get_type_prefix(type, is_array, input_value);
 
 					// Base properties for all input types
 					/** @type {Record<string, any>} */
 					const base_props = {
-						name: prefix + key + (is_array ? '[]' : ''),
+						name: type_prefix + key + (is_array ? '[]' : '') + '/' + context.form_id,
 						get 'aria-invalid'() {
-							const issues = get_issues();
+							const issues = context.get_issues();
 							return key in issues ? 'true' : undefined;
 						}
 					};
@@ -911,11 +946,11 @@ export function create_field_proxy(target, get, set, get_issues, get_touched, ge
 					});
 				};
 
-				return create_field_proxy(as_func, get, set, get_issues, get_touched, get_dirty, next);
+				return create_field_proxy(context, as_func, next);
 			}
 
 			// Handle property access (nested fields)
-			return create_field_proxy({}, get, set, get_issues, get_touched, get_dirty, next);
+			return create_field_proxy(context, {}, next);
 		}
 	});
 }

package/src/runtime/server/cookie.js

@@ -73,7 +73,7 @@ export function get_cookies(request, url) {
 		httpOnly: true,
 		path: '/',
 		sameSite: 'lax',
-		secure: url.hostname === 'localhost' && url.protocol === 'http:' ? false : true
+		secure: !__SVELTEKIT_DEV__ && !(url.hostname === 'localhost' && url.protocol === 'http:')
 	};
 
 	/** @type {import('@sveltejs/kit').Cookies} */

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

@@ -4,9 +4,10 @@ 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';
+import { with_version_header } from '../utils.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
@@ -31,9 +32,7 @@ export async function render_data(
 ) {
 	if (!route.page) {
 		// requesting /__data.json should fail for a +server.js
-		return new Response(undefined, {
-			status: 404
-		});
+		return with_version_header(new Response(undefined, { status: 404 }));
 	}
 
 	try {
@@ -123,26 +122,28 @@ export async function render_data(
 			return json_response(data);
 		}
 
-		return new Response(
-			new ReadableStream({
-				async start(controller) {
-					controller.enqueue(text_encoder.encode(data));
-					for await (const chunk of chunks) {
-						controller.enqueue(text_encoder.encode(chunk));
+		return with_version_header(
+			new Response(
+				new ReadableStream({
+					async start(controller) {
+						controller.enqueue(text_encoder.encode(data));
+						for await (const chunk of chunks) {
+							controller.enqueue(text_encoder.encode(chunk));
+						}
+						controller.close();
+					},
+
+					type: 'bytes'
+				}),
+				{
+					headers: {
+						// we use a proprietary content type to prevent buffering.
+						// the `text` prefix makes it inspectable
+						'content-type': 'text/sveltekit-data',
+						'cache-control': 'private, no-store'
 					}
-					controller.close();
-				},
-
-				type: 'bytes'
-			}),
-			{
-				headers: {
-					// we use a proprietary content type to prevent buffering.
-					// the `text` prefix makes it inspectable
-					'content-type': 'text/sveltekit-data',
-					'cache-control': 'private, no-store'
 				}
-			}
+			)
 		);
 	} catch (e) {
 		const error = normalize_error(e);
@@ -161,13 +162,15 @@ export async function render_data(
  * @param {number} [status]
  */
 function json_response(json, status = 200) {
-	return text(typeof json === 'string' ? json : JSON.stringify(json), {
-		status,
-		headers: {
-			'content-type': 'application/json',
-			'cache-control': 'private, no-store'
-		}
-	});
+	return with_version_header(
+		text(typeof json === 'string' ? json : JSON.stringify(json), {
+			status,
+			headers: {
+				'content-type': 'application/json',
+				'cache-control': 'private, no-store'
+			}
+		})
+	);
 }
 
 /**

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;
+
+	// sec-fetch-dest would be nicer, but non-browser clients and plain HTTP hosts don't send 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';
 
 /**

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, with_version_header } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 import { record_span } from '../../telemetry/record_span.js';
 
 /** @param {RequestEvent} event */
@@ -94,7 +95,7 @@ export async function handle_action_json_request(event, event_state, options, se
 			});
 		} else {
 			// no data returned — use 204 No Content (without a body, per the spec)
-			return new Response(null, { status: 204 });
+			return with_version_header(new Response(null, { status: 204 }));
 		}
 	} catch (e) {
 		const err = normalize_error(e);
@@ -147,7 +148,7 @@ export function action_json_redirect(redirect) {
  * @param {ResponseInit} [init]
  */
 function action_json(data, init) {
-	return json(data, init);
+	return with_version_header(json(data, init));
 }
 
 /**

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';