@sveltejs/kit 3.0.0-next.13 → 3.0.0-next.16

package/src/runtime/client/fetcher.js

@@ -1,6 +1,6 @@
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
-import { hash } from '../../utils/hash.js';
+import { hash_request } from '../../utils/hash.js';
 import { base64_decode } from '../utils.js';
 
 let loading = 0;
@@ -172,18 +172,7 @@ function build_selector(resource, opts) {
 			return null;
 		}
 
-		/** @type {import('types').StrictBody[]} */
-		const values = [];
-
-		if (opts.headers) {
-			values.push([...new Headers(opts.headers)].join(','));
-		}
-
-		if (body) {
-			values.push(/** @type {import('types').StrictBody} */ (body));
-		}
-
-		selector += `[data-hash="${hash(...values)}"]`;
+		selector += `[data-hash="${hash_request(opts.headers, body)}"]`;
 	}
 
 	return selector;

package/src/runtime/client/parse.js

@@ -4,7 +4,7 @@ import { exec, parse_route_id } from '../../utils/routing.js';
  * @param {import('./types.js').SvelteKitApp} app
  * @returns {import('types').CSRRoute[]}
  */
-export function parse({ nodes, server_loads, dictionary, matchers }) {
+export function parse_routes({ nodes, server_loads, dictionary, matchers }) {
 	const layouts_with_server_load = new Set(server_loads);
 
 	return Object.entries(dictionary).map(([id, [leaf, layouts, errors]]) => {

package/src/runtime/client/remote-functions/command.svelte.js

@@ -1,6 +1,5 @@
 /** @import { RemoteCommand, RemoteQueryUpdate } from '@sveltejs/kit' */
 import { app_dir, base } from '$app/paths/internal/client';
-import { app } from '../client.js';
 import { stringify_command_arg } from '../../shared.js';
 import { get_remote_request_headers, categorize_updates, remote_request } from './shared.svelte.js';
 
@@ -48,7 +47,7 @@ export function command(id) {
 				const response = await remote_request(`${base}/${app_dir}/remote/${id}`, {
 					method: 'POST',
 					body: JSON.stringify({
-						payload: await stringify_command_arg(arg, app.hooks.transport),
+						payload: await stringify_command_arg(arg),
 						refreshes: Array.from(refreshes ?? [])
 					}),
 					headers

package/src/runtime/client/remote-functions/form.svelte.js

@@ -262,13 +262,9 @@ export function form(id) {
 
 					if (response.redirect) {
 						// Use internal version to allow redirects to external URLs
-						void _goto(
-							response.redirect,
-							{
-								refreshAll: should_refresh
-							},
-							0
-						);
+						void _goto(response.redirect, {
+							refreshAll: should_refresh
+						});
 						return true;
 					}
 

package/src/runtime/client/remote-functions/prerender.svelte.js

@@ -57,7 +57,7 @@ function put(url, encoded) {
  */
 export function prerender(id) {
 	return (arg) => {
-		const payload = stringify_remote_arg(arg, app.hooks.transport);
+		const payload = stringify_remote_arg(arg);
 		const cache_key = create_remote_key(id, payload);
 
 		let resource = prerender_resources.get(cache_key)?.deref();
@@ -100,7 +100,7 @@ export function prerender(id) {
 
 				if (result.redirect) {
 					// Use internal version to allow redirects to external URLs
-					void _goto(result.redirect, {}, 0);
+					void _goto(result.redirect);
 					return;
 				}
 

package/src/runtime/client/remote-functions/query/index.js

@@ -30,7 +30,7 @@ export function query(id) {
 
 			if (result.redirect) {
 				// Use internal version to allow redirects to external URLs
-				await _goto(result.redirect, {}, 0);
+				await _goto(result.redirect);
 			}
 		});
 	};

package/src/runtime/client/remote-functions/query/proxy.js

@@ -1,4 +1,4 @@
-import { app, query_map } from '../../client.js';
+import { query_map } from '../../client.js';
 import {
 	pin_in_effect,
 	pin_while_resolving,
@@ -29,7 +29,7 @@ export class QueryProxy {
 	 */
 	constructor(id, arg, fn) {
 		this.#id = id;
-		this.#payload = stringify_remote_arg(arg, app.hooks.transport);
+		this.#payload = stringify_remote_arg(arg);
 		this.#key = create_remote_key(id, this.#payload);
 		Object.defineProperty(this, QUERY_RESOURCE_KEY, { value: this.#key });
 		this.#fn = fn;

package/src/runtime/client/remote-functions/query-batch.svelte.js

@@ -50,7 +50,7 @@ export function query_batch(id) {
 
 						if (response.redirect) {
 							// Use internal version to allow redirects to external URLs
-							await _goto(response.redirect, {}, 0);
+							await _goto(response.redirect);
 
 							// settle all batched promises (with `undefined`, like a redirect
 							// from a non-batched query) so that callers don't hang forever

package/src/runtime/client/remote-functions/query-live/proxy.js

@@ -1,4 +1,4 @@
-import { app, live_query_map } from '../../client.js';
+import { live_query_map } from '../../client.js';
 import { pin_in_effect, pin_while_resolving, QUERY_RESOURCE_KEY } from '../shared.svelte.js';
 import { create_remote_key, stringify_remote_arg } from '../../../shared.js';
 import { LiveQuery } from './instance.svelte.js';
@@ -20,7 +20,7 @@ export class LiveQueryProxy {
 	 */
 	constructor(id, arg) {
 		this.#id = id;
-		this.#payload = stringify_remote_arg(arg, app.hooks.transport);
+		this.#payload = stringify_remote_arg(arg);
 		this.#key = create_remote_key(id, this.#payload);
 		Object.defineProperty(this, QUERY_RESOURCE_KEY, { value: this.#key });
 
@@ -74,16 +74,6 @@ export class LiveQueryProxy {
 		return this.#get_cached_query().done;
 	}
 
-	/**
-	 * @deprecated Use `for await (const value of liveQuery())` instead.
-	 * @returns {AsyncGenerator<T>}
-	 */
-	run() {
-		throw new Error(
-			'`.run()` has been removed from live queries. Use `for await (const value of liveQuery())` instead.'
-		);
-	}
-
 	reconnect() {
 		return this.#get_cached_query().reconnect();
 	}

package/src/runtime/client/remote-functions/shared.svelte.js

@@ -197,7 +197,7 @@ export async function remote_request(url, init) {
 export async function handle_side_channel_response(response) {
 	if (response.type === 'redirect') {
 		// Use internal version to allow redirects to external URLs
-		await _goto(response.location, {}, 0);
+		await _goto(response.location);
 		throw new Redirect(307, response.location);
 	}
 

package/src/runtime/client/utils.js

@@ -122,6 +122,7 @@ export function get_link_info(a, base, uses_hash_router) {
 	/** @type {URL | undefined} */
 	let url;
 
+	// TODO replace the try/catch with `URL.parse` when browser support allows (Chrome 126, Firefox 126, Safari 18)
 	try {
 		url = new URL(a instanceof SVGAElement ? a.href.baseVal : a.href, document.baseURI);
 

package/src/runtime/form-utils.js

@@ -3,12 +3,10 @@
 
 import { DEV } from 'esm-env';
 import * as devalue from 'devalue';
-import { text_encoder } from './utils.js';
+import { text_decoder, text_encoder } from './utils.js';
 import { noop } from '../utils/functions.js';
 import { SvelteKitError } from '@sveltejs/kit/internal';
 
-const decoder = new TextDecoder();
-
 /**
  * Sets a parsed form field value in a nested object, mutating the original object.
  * @param {Record<string, any>} object
@@ -283,7 +281,7 @@ export async function deserialize_binary_form(request, form_id) {
 		const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
 		if (!file_offsets_buffer) throw deserialize_error('file offset table too short');
 
-		const parsed_offsets = JSON.parse(decoder.decode(file_offsets_buffer));
+		const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
 
 		if (
 			!Array.isArray(parsed_offsets) ||
@@ -298,7 +296,7 @@ export async function deserialize_binary_form(request, form_id) {
 
 	/** @type {Array<{ offset: number, size: number }>} */
 	const file_spans = [];
-	const [data, meta] = devalue.parse(decoder.decode(data_buffer), {
+	const [data, meta] = devalue.parse(text_decoder.decode(data_buffer), {
 		File: ([name, type, size, last_modified, index]) => {
 			if (
 				typeof name !== 'string' ||
@@ -488,7 +486,7 @@ class LazyFile {
 		});
 	}
 	async text() {
-		return decoder.decode(await this.arrayBuffer());
+		return text_decoder.decode(await this.arrayBuffer());
 	}
 }
 

package/src/runtime/pathname.js

@@ -22,13 +22,14 @@ export function strip_data_suffix(pathname) {
 }
 
 const ROUTE_SUFFIX = '/__route.js';
+const HTML_ROUTE_SUFFIX = '.html__route.js';
 
 /**
  * @param {string} pathname
  * @returns {boolean}
  */
 export function has_resolution_suffix(pathname) {
-	return pathname.endsWith(ROUTE_SUFFIX);
+	return pathname.endsWith(ROUTE_SUFFIX) || pathname.endsWith(HTML_ROUTE_SUFFIX);
 }
 
 /**
@@ -37,6 +38,7 @@ export function has_resolution_suffix(pathname) {
  * @returns {string}
  */
 export function add_resolution_suffix(pathname) {
+	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_ROUTE_SUFFIX);
 	return pathname.replace(/\/$/, '') + ROUTE_SUFFIX;
 }
 
@@ -45,5 +47,46 @@ export function add_resolution_suffix(pathname) {
  * @returns {string}
  */
 export function strip_resolution_suffix(pathname) {
+	if (pathname.endsWith(HTML_ROUTE_SUFFIX)) {
+		return pathname.slice(0, -HTML_ROUTE_SUFFIX.length) + '.html';
+	}
+
 	return pathname.slice(0, -ROUTE_SUFFIX.length);
 }
+
+const ROUTES_PREFIX = '/routes';
+
+/**
+ * The pathname of the route-ID-keyed resolution module for a given route ID,
+ * e.g. `/_app/routes/blog/[slug]/__route.js` (before prefixing with `base`).
+ * @param {string} app_dir
+ * @param {string} route_id
+ * @returns {string}
+ */
+export function route_id_resolution_pathname(app_dir, route_id) {
+	return add_resolution_suffix(`/${app_dir}${ROUTES_PREFIX}${route_id === '/' ? '' : route_id}`);
+}
+
+/**
+ * Whether a pathname (with the `/__route.js` suffix already stripped, and `base` NOT yet stripped)
+ * is a route-ID resolution request rather than a pathname resolution request.
+ * @param {string} pathname
+ * @param {string} base
+ * @param {string} app_dir
+ * @returns {boolean}
+ */
+export function is_route_id_resolution_path(pathname, base, app_dir) {
+	const prefix = `${base}/${app_dir}${ROUTES_PREFIX}`;
+	return pathname === prefix || pathname.startsWith(prefix + '/');
+}
+
+/**
+ * Extract the route ID from a decoded, base-stripped, suffix-stripped pathname,
+ * e.g. `/_app/routes/blog/[slug]` -> `/blog/[slug]`, `/_app/routes` -> `/`.
+ * @param {string} pathname
+ * @param {string} app_dir
+ * @returns {string}
+ */
+export function extract_route_id(pathname, app_dir) {
+	return pathname.slice(`/${app_dir}${ROUTES_PREFIX}`.length) || '/';
+}

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

@@ -11,22 +11,20 @@ import { with_version_header } from '../utils.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('types').RequestState} state
  * @param {import('types').SSRRoute} route
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @param {import('types').SSRState} state
  * @param {boolean[] | undefined} invalidated_data_nodes
  * @param {import('types').TrailingSlash} trailing_slash
  * @returns {Promise<Response>}
  */
 export async function render_data(
 	event,
-	event_state,
+	state,
 	route,
 	options,
 	manifest,
-	state,
 	invalidated_data_nodes,
 	trailing_slash
 ) {
@@ -60,7 +58,6 @@ export async function render_data(
 					// load this. for the child, return as is. for the final result, stream things
 					return load_server_data({
 						event: new_event,
-						event_state,
 						state,
 						node,
 						parent: async () => {
@@ -95,7 +92,7 @@ export async function render_data(
 			return fn();
 		});
 
-		const data_serializer = server_data_serializer_json(event, event_state, options);
+		const data_serializer = server_data_serializer_json(event, state, options);
 		await Promise.all(
 			promises.map(async (p, i) => {
 				const node = await p.catch(async (error) => {
@@ -103,7 +100,7 @@ export async function render_data(
 						throw error;
 					}
 
-					const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+					const transformed = await handle_error_and_jsonify(event, state, options, error);
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
@@ -151,7 +148,7 @@ export async function render_data(
 		if (error instanceof Redirect) {
 			return redirect_json_response(error);
 		} else {
-			const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+			const transformed = await handle_error_and_jsonify(event, state, options, error);
 			return json_response(transformed, transformed.status);
 		}
 	}

package/src/runtime/server/dev.js

@@ -0,0 +1,22 @@
+const symbol = Symbol.for('sveltekit.global_state');
+const state = /** @type {Record<symbol, any>} */ (
+	/** @type {Record<symbol, unknown>} */ (/** @type {unknown} */ (globalThis))[symbol] ??= {}
+);
+
+/**
+ * Persist a value across dev server reloads, in case a freshly-invalidated module
+ * reads global state that is not set until a request is handled
+ * @param {symbol} key
+ * @param {any} value
+ */
+export function save(key, value) {
+	state[key] = value;
+}
+
+/**
+ * Restore a value after a dev server reload
+ * @param {symbol} key
+ */
+export function restore(key) {
+	return state[key];
+}

package/src/runtime/server/endpoint.js

@@ -6,12 +6,11 @@ import { method_not_allowed } from './utils.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('types').RequestState} state
  * @param {import('types').SSREndpoint} mod
- * @param {import('types').SSRState} state
  * @returns {Promise<Response>}
  */
-export async function render_endpoint(event, event_state, mod, state) {
+export async function render_endpoint(event, state, mod) {
 	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
 
 	let handler = mod[method] || mod.fallback;
@@ -42,7 +41,7 @@ export async function render_endpoint(event, event_state, mod, state) {
 	}
 
 	try {
-		const response = await with_request_store({ event, state: event_state }, () =>
+		const response = await with_request_store({ event, state }, () =>
 			handler(/** @type {import('@sveltejs/kit').RequestEvent<Record<string, any>>} */ (event))
 		);
 

package/src/runtime/server/fetch.js

@@ -4,13 +4,14 @@ import { respond } from './respond.js';
 import * as paths from '$app/paths/internal/server';
 import { read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
+import { fork_state_for_subrequest } from './state.js';
 
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
+ *   state: import('types').RequestState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
  *   set_internal: (name: string, value: string, opts: import('./page/types.js').Cookie['options']) => void;
  * }} opts
@@ -194,38 +195,32 @@ function normalize_fetch_input(info, init, url) {
  * @param {Request} request
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @param {import('types').SSRState} state
+ * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
 async function internal_fetch(request, options, manifest, state) {
-	if (request.signal) {
-		if (request.signal.aborted) {
-			throw new DOMException('The operation was aborted.', 'AbortError');
-		}
-
-		let remove_abort_listener = noop;
-		/** @type {Promise<never>} */
-		const abort_promise = new Promise((_, reject) => {
-			const on_abort = () => {
-				reject(new DOMException('The operation was aborted.', 'AbortError'));
-			};
-			request.signal.addEventListener('abort', on_abort, { once: true });
-			remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
-		});
+	if (request.signal?.aborted) {
+		throw new DOMException('The operation was aborted.', 'AbortError');
+	}
 
-		const result = await Promise.race([
-			respond(request, options, manifest, {
-				...state,
-				depth: state.depth + 1
-			}),
-			abort_promise
-		]);
-		remove_abort_listener();
-		return result;
-	} else {
-		return await respond(request, options, manifest, {
-			...state,
-			depth: state.depth + 1
-		});
+	const subrequest_state = fork_state_for_subrequest(state);
+
+	if (!request.signal) {
+		return await respond(request, options, manifest, subrequest_state);
 	}
+
+	let remove_abort_listener = noop;
+	/** @type {Promise<never>} */
+	const abort_promise = new Promise((_, reject) => {
+		const on_abort = () => {
+			reject(new DOMException('The operation was aborted.', 'AbortError'));
+		};
+		request.signal.addEventListener('abort', on_abort, { once: true });
+		remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
+	});
+
+	return Promise.race([
+		respond(request, options, manifest, subrequest_state),
+		abort_promise
+	]).finally(remove_abort_listener);
 }

package/src/runtime/server/index.js

@@ -1,11 +1,13 @@
 import { noop } from '../../utils/functions.js';
 import { IN_WEBCONTAINER } from './constants.js';
 import { respond } from './respond.js';
+import { create_request_state } from './state.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
-import { set_read_implementation, set_manifest } from './internal.js';
+import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
 import { set_env } from '__sveltekit/env';
-import { set_app } from './app.js';
 import { SvelteKitError } from '@sveltejs/kit/internal';
+import { DEV } from 'esm-env';
+import { init_transport } from '#app/internal/transport';
 
 /** @type {Promise<any>} */
 let init_promise;
@@ -13,6 +15,38 @@ let init_promise;
 /** @type {Promise<void> | null} */
 let current = null;
 
+/**
+ * Responses that were created with our monkey-patched `fetch`, which may need
+ * to have their `content-encoding` and `content-length` headers removed
+ * if returned directly (i.e. `fetch` is being used to proxy a request)
+ * @type {WeakMap<Response, Error>}
+ */
+const decoded_responses = new WeakMap();
+
+if (DEV) {
+	const fetch = globalThis.fetch;
+
+	/**
+	 * @param {RequestInfo | URL} info
+	 * @param {RequestInit} [init]
+	 */
+	globalThis.fetch = async (info, init) => {
+		const response = await fetch(info, init);
+		const encoding = response.headers.get('content-encoding');
+
+		if (encoding) {
+			decoded_responses.set(
+				response,
+				new Error(
+					`Cannot return \`fetch(...)\` directly from a handler if the response has a \`Content-Encoding: ${encoding}\` header. The body has already been decoded`
+				)
+			);
+		}
+
+		return response;
+	};
+}
+
 export class Server {
 	/** @type {import('types').SSROptions} */
 	#options;
@@ -67,31 +101,17 @@ export class Server {
 				const result = read(file);
 				if (result instanceof ReadableStream) {
 					return result;
-				} else {
-					return new ReadableStream({
-						async start(controller) {
-							try {
-								const stream = await Promise.resolve(result);
-								if (!stream) {
-									controller.close();
-									return;
-								}
-
-								const reader = stream.getReader();
-
-								while (true) {
-									const { done, value } = await reader.read();
-									if (done) break;
-									controller.enqueue(value);
-								}
-
-								controller.close();
-							} catch (error) {
-								controller.error(error);
-							}
-						}
-					});
 				}
+
+				// TODO remove the cast once TypeScript's lib includes `ReadableStream.from`
+				return /** @type {ReadableStream} */ (
+					/** @type {any} */ (ReadableStream).from(
+						(async function* () {
+							const stream = await result;
+							if (stream) yield* stream;
+						})()
+					)
+				);
 			};
 
 			set_read_implementation(wrapped_read);
@@ -132,15 +152,10 @@ export class Server {
 							console.error('Remote function schema validation failed:', issues);
 							return { message: 'Bad Request', status: 400 };
 						}),
-					reroute: module.reroute || noop,
-					transport: module.transport || {}
+					reroute: module.reroute || noop
 				};
 
-				set_app({
-					decoders: module.transport
-						? Object.fromEntries(Object.entries(module.transport).map(([k, v]) => [k, v.decode]))
-						: {}
-				});
+				init_transport(module.transport ?? {});
 
 				if (module.init) {
 					await module.init();
@@ -156,13 +171,8 @@ export class Server {
 						handleValidationError: () => {
 							return { message: 'Bad Request' };
 						},
-						reroute: noop,
-						transport: {}
+						reroute: noop
 					};
-
-					set_app({
-						decoders: {}
-					});
 				} else {
 					throw e;
 				}
@@ -172,13 +182,21 @@ export class Server {
 
 	/**
 	 * @param {Request} request
-	 * @param {import('types').RequestOptions} options
+	 * @param {import('types').InternalRequestOptions} options
 	 */
-	respond(request, options) {
-		return respond(request, this.#options, this.#manifest, {
-			...options,
-			error: false,
-			depth: 0
-		});
+	async respond(request, options) {
+		const response = await respond(
+			request,
+			this.#options,
+			this.#manifest,
+			create_request_state(options, this.#options.hooks)
+		);
+
+		if (DEV) {
+			const error = decoded_responses.get(response);
+			if (error) console.error(fix_stack_trace(error));
+		}
+
+		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -1,17 +1,23 @@
 /** @import { SSRManifest } from '@sveltejs/kit'; */
+import { restore, save } from './dev.js';
 
-/**
- * @type {((path: string) => ReadableStream<any>) | null}
- */
-export let read_implementation = null;
+const read_implementation_key = Symbol.for('sveltekit.read_implementation');
+const manifest_key = Symbol.for('sveltekit.manifest');
+
+export let read_implementation = /** @type {((path: string) => ReadableStream<any>) | null} */ (
+	(__SVELTEKIT_DEV__ && restore(read_implementation_key)) ?? null
+);
 
-export let manifest = /** @type {SSRManifest} */ (/** @type {unknown} */ (null));
+export let manifest = /** @type {SSRManifest} */ (
+	(__SVELTEKIT_DEV__ && restore(manifest_key)) ?? null
+);
 
 /**
  * @param {(path: string) => ReadableStream<any>} fn
  */
 export function set_read_implementation(fn) {
 	read_implementation = fn;
+	if (__SVELTEKIT_DEV__) save(read_implementation_key, fn);
 }
 
 /**
@@ -20,6 +26,7 @@ export function set_read_implementation(fn) {
  */
 export function set_manifest(value) {
 	manifest = value;
+	if (__SVELTEKIT_DEV__) save(manifest_key, value);
 }
 
 export { fix_stack_trace, set_fix_stack_trace } from './sourcemaps.js';