@sveltejs/kit 3.0.0-next.23 → 3.0.0-next.24

package/src/runtime/client/fetcher.js

@@ -1,12 +1,10 @@
-import { BROWSER, DEV } from 'esm-env';
-import { noop } from '../../utils/functions.js';
+import { DEV } from 'esm-env';
 import { hash_request } from '../../utils/hash.js';
 import { base64_decode } from '../utils.js';
 
 let loading = 0;
 
-/** @type {typeof fetch} */
-const native_fetch = BROWSER ? window.fetch : /** @type {any} */ (noop);
+const native_fetch = window.fetch;
 
 export function lock_fetch() {
 	loading += 1;
@@ -16,7 +14,7 @@ export function unlock_fetch() {
 	loading -= 1;
 }
 
-if (DEV && BROWSER) {
+if (DEV) {
 	let can_inspect_stack_trace = false;
 
 	// detect whether async stack traces work
@@ -61,17 +59,17 @@ if (DEV && BROWSER) {
 		const method = input instanceof Request ? input.method : init?.method || 'GET';
 
 		if (method !== 'GET') {
-			cache.delete(build_selector(input));
+			cache.delete(build_selector(requested_url(input)));
 		}
 
 		return native_fetch(input, init);
 	};
-} else if (BROWSER) {
+} else {
 	window.fetch = (input, init) => {
 		const method = input instanceof Request ? input.method : init?.method || 'GET';
 
 		if (method !== 'GET') {
-			cache.delete(build_selector(input));
+			cache.delete(build_selector(requested_url(input)));
 		}
 
 		return native_fetch(input, init);
@@ -153,6 +151,18 @@ export function dev_fetch(resource, opts) {
 	return window.fetch(resource, patched_opts);
 }
 
+/**
+ * Mirror the url normalization in `resolve_fetch_url`, so that non-GET requests
+ * evict the cache entry regardless of how the url is spelled
+ * @param {RequestInfo | URL} input
+ */
+function requested_url(input) {
+	const resolved = new URL(input instanceof Request ? input.url : input, location.href);
+	return resolved.origin === location.origin
+		? resolved.href.slice(location.origin.length)
+		: resolved.href;
+}
+
 /**
  * Build the cache key for a given request
  * @param {URL | RequestInfo} resource

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

@@ -11,7 +11,7 @@ import {
 	handle_error,
 	refreshAll
 } from '../client.js';
-import { page } from '../state.svelte.js';
+import { page } from '#app/state/client';
 import { tick } from 'svelte';
 import { categorize_updates, remote_request } from './shared.svelte.js';
 import { createAttachmentKey } from 'svelte/attachments';
@@ -133,7 +133,9 @@ export function form(id) {
 			if (await instance.submit()) {
 				await tick();
 				// We call reset from the prototype to avoid DOM clobbering
-				HTMLFormElement.prototype.reset.call(instance.element);
+				if (instance.element.isConnected) {
+					HTMLFormElement.prototype.reset.call(instance.element);
+				}
 			}
 		};
 
@@ -263,7 +265,7 @@ export function form(id) {
 
 							if (response.redirect) {
 								// Use internal version to allow redirects to external URLs
-								void _goto(response.redirect, {
+								await _goto(response.redirect, {
 									refreshAll: should_refresh
 								});
 								return true;
@@ -273,7 +275,7 @@ export function form(id) {
 
 							if (succeeded) {
 								if (should_refresh) {
-									void refreshAll();
+									await refreshAll();
 								}
 							} else {
 								if (DEV) {
@@ -695,13 +697,14 @@ export function form(id) {
 			validate: {
 				/** @type {RemoteForm<any, any>['validate']} */
 				value: async ({ all = false, preflightOnly = false } = {}) => {
-					if (!element) return;
-
 					const id = ++validate_id;
 
 					// wait a tick in case the user is calling validate() right after set() which takes time to propagate
 					await tick();
 
+					// the form may have been removed from the DOM while we were waiting
+					if (!element) return;
+
 					const default_submitter = /** @type {HTMLElement | undefined} */ (
 						element.querySelector('button:not([type]), [type="submit"]')
 					);

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

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

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

@@ -1,7 +1,7 @@
 /** @import { RemoteFunctionResponse } from 'types' */
 import { app_dir, base } from '#app/paths';
 import { app } from '../../client.js';
-import { notify_version } from '../../state.svelte.js';
+import { notify_version } from '#app/state/client';
 import { handle_side_channel_response } from '../shared.svelte.js';
 import * as devalue from 'devalue';
 import { HttpError, HandledHttpError } from '@sveltejs/kit/internal';

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

@@ -6,7 +6,7 @@ import { app, _goto, live_query_map, query_map, query_responses } from '../clien
 import { HttpError, Redirect, HandledHttpError } from '@sveltejs/kit/internal';
 import { untrack } from 'svelte';
 import { create_remote_key, split_remote_key } from '../../shared.js';
-import { navigating, page, notify_version } from '../state.svelte.js';
+import { navigating, page, notify_version } from '#app/state/client';
 
 /** Indicates a query function, as opposed to a query instance */
 export const QUERY_FUNCTION_ID = Symbol('sveltekit.query_function_id');
@@ -97,7 +97,7 @@ export function get_remote_request_headers() {
 	// even in forks because it's state-based - therefore not using window.location.
 	// Use untrack(...) to Avoid accidental reactive dependency on pathname/search
 	return untrack(() => {
-		const url = navigating.current?.to?.url ?? page.url;
+		const url = navigating?.to?.url ?? page.url;
 
 		return {
 			'x-sveltekit-pathname': url.pathname,

package/src/runtime/client/snapshots.js

@@ -1,4 +1,4 @@
-import { BROWSER, DEV } from 'esm-env';
+import { DEV } from 'esm-env';
 import { onMount } from 'svelte';
 import * as storage from './session-storage.js';
 import { NAVIGATION_SNAPSHOT_KEY } from './constants.js';
@@ -105,8 +105,6 @@ function callsite_id(stack) {
  * @returns {void}
  */
 export function snapshot(options) {
-	if (!BROWSER) return;
-
 	let id = options.id;
 	if (id === undefined) {
 		// restore any lowered third-party limit, else every callsite collapses to one id

package/src/runtime/client/stream.js

@@ -8,32 +8,39 @@
  */
 export async function* read_stream(reader, delimiter, options) {
 	let done = false;
-	let buffer = '';
+	/** @type {string[]} */
+	let parts = [];
+	let rest = '';
 	const decoder = new TextDecoder(undefined, options);
+	const carry = delimiter.length - 1;
 
-	while (true) {
-		let split = buffer.indexOf(delimiter);
-		while (split !== -1) {
-			yield buffer.slice(0, split);
-			buffer = buffer.slice(split + delimiter.length);
-			split = buffer.indexOf(delimiter);
-		}
+	while (!done) {
+		const chunk = await reader.read();
+		done = chunk.done;
+		let text = rest;
+		if (chunk.value) text += decoder.decode(chunk.value, { stream: true });
+		if (done) text += decoder.decode();
 
-		if (done) {
-			if (buffer) {
-				yield buffer;
+		let start = 0;
+		let split = text.indexOf(delimiter);
+		while (split !== -1) {
+			if (parts.length > 0) {
+				parts.push(text.slice(start, split));
+				yield parts.join('');
+				parts = [];
+			} else {
+				yield text.slice(start, split);
 			}
-			return;
+			start = split + delimiter.length;
+			split = text.indexOf(delimiter, start);
 		}
 
-		const chunk = await reader.read();
-		done = chunk.done;
-		if (chunk.value) {
-			buffer += decoder.decode(chunk.value, { stream: true });
-		}
+		const keep = Math.max(start, text.length - carry);
+		if (keep > start) parts.push(text.slice(start, keep));
+		rest = text.slice(keep);
+	}
 
-		if (done) {
-			buffer += decoder.decode();
-		}
+	if (parts.length > 0 || rest) {
+		yield parts.join('') + rest;
 	}
 }

package/src/runtime/client/utils.js

@@ -1,7 +1,7 @@
-import { BROWSER, DEV } from 'esm-env';
+import { DEV } from 'esm-env';
 import { PRELOAD_PRIORITIES } from './constants.js';
 
-export const origin = BROWSER ? location.origin : '';
+export const origin = location.origin;
 
 /** @param {string | URL} url */
 export function resolve_url(url) {
@@ -105,7 +105,11 @@ function parent_element(element) {
  */
 export function find_anchor(element, target) {
 	while (element && element !== target) {
-		if (element.nodeName.toUpperCase() === 'A' && element.hasAttribute('href')) {
+		// don't read `nodeName` — a form control named `nodeName` shadows it on its form
+		if (
+			(element instanceof HTMLAnchorElement || element instanceof SVGAElement) &&
+			element.hasAttribute('href')
+		) {
 			return /** @type {HTMLAnchorElement | SVGAElement} */ (element);
 		}
 

package/src/runtime/components/root.svelte

@@ -23,7 +23,11 @@
 	{const Error = $derived(n.error)}
 	{const data = $derived(n.data)}
 
-	<svelte:boundary {onerror}>
+	{#snippet failed(error: unknown)}
+		<Error {error} />
+	{/snippet}
+
+	<svelte:boundary failed={Error ? failed : undefined} onerror={Error ? onerror : undefined}>
 		{#if n.child}
 			<!-- svelte-ignore binding_property_non_reactive -->
 			<Component bind:this={components[depth]} {data} {form} params={page.params}>
@@ -33,10 +37,6 @@
 			<!-- svelte-ignore binding_property_non_reactive -->
 			<Component bind:this={components[depth]} {data} {form} params={page.params} {error} />
 		{/if}
-
-		{#snippet failed(error: unknown)}
-			<Error {error} />
-		{/snippet}
 	</svelte:boundary>
 {/snippet}
 

package/src/runtime/env/dynamic/private.js

@@ -1,5 +1,5 @@
 import { DEV } from 'esm-env';
-import * as env from '../../app/env/private.js';
+import * as env from '../../app/env/private/index.js';
 export { env };
 
 if (DEV) {

package/src/runtime/env/static/private.js

@@ -1,5 +1,5 @@
 import { DEV } from 'esm-env';
-export * from '../../app/env/private.js';
+export * from '../../app/env/private/index.js';
 
 if (DEV) {
 	console.warn('`$env/static/private` is deprecated, use `$app/env/private` instead');

package/src/runtime/error-chain.js

@@ -0,0 +1,54 @@
+/** @import { Component } from 'svelte'; */
+
+/**
+ * Resolves the `+error.svelte` component that guards each node of `branch`, aligned to the
+ * branch with its empty slots removed. A node is guarded by the closest error page declared
+ * at or above it, except the root layout, which wraps the root error component rather than
+ * being wrapped by it.
+ * @template T
+ * @param {Array<unknown>} branch
+ * @param {Array<T | undefined | null>} errors the error page declared at each depth, if any
+ * @param {(error: T) => Promise<Component | undefined> | undefined} load
+ * @returns {Promise<Array<Component | undefined>>}
+ */
+export function build_error_chain(branch, errors, load) {
+	/** @type {Array<Promise<Component | undefined> | undefined>} */
+	const chain = [undefined];
+	let last_idx = -1;
+
+	for (let i = 1; i < branch.length; i += 1) {
+		if (!branch[i]) continue;
+
+		let j = i - 1;
+		while (j > last_idx + 1 && errors[j] == null) j -= 1;
+		last_idx = j;
+
+		const error = errors[j];
+		chain.push(error == null ? undefined : load(error)?.catch(() => undefined));
+	}
+
+	// depths with no error page contribute `undefined` rather than a promise
+	// eslint-disable-next-line @typescript-eslint/await-thenable
+	return Promise.all(chain);
+}
+
+/**
+ * Walks up from the node at index `i` through the `+error.svelte` pages declared strictly
+ * above it, nearest first. Yields each candidate with the branch depth it attaches at,
+ * rewound past empty branch slots, so callers can skip candidates that fail to load.
+ * @template T
+ * @param {number} i
+ * @param {Array<unknown>} branch
+ * @param {Array<T | undefined | null>} errors the error page declared at each depth, if any
+ * @returns {Generator<{ error: T; idx: number }>}
+ */
+export function* nearest_error_pages(i, branch, errors) {
+	while (i--) {
+		const error = errors[i];
+		if (error != null) {
+			let j = i;
+			while (!branch[j]) j -= 1;
+			yield { error, idx: j + 1 };
+		}
+	}
+}

package/src/runtime/form-utils.js

@@ -198,7 +198,9 @@ export async function deserialize_binary_form(request, form_id) {
 
 		let i = chunks.length;
 		while (i <= index) {
-			chunks[i] = reader.read().then((chunk) => chunk.value);
+			// chain reads so only one is ever pending — workerd forbids concurrent reads
+			const previous = chunks[i - 1] ?? Promise.resolve(undefined);
+			chunks[i] = previous.then(() => reader.read()).then((chunk) => chunk.value);
 			i++;
 		}
 		return chunks[index];
@@ -210,47 +212,23 @@ export async function deserialize_binary_form(request, form_id) {
 	 * @returns {Promise<Uint8Array | null>}
 	 */
 	async function get_buffer(offset, length) {
-		/** @type {Uint8Array} */
-		let start_chunk;
-		let chunk_start = 0;
-		/** @type {number} */
-		let chunk_index;
-		for (chunk_index = 0; ; chunk_index++) {
-			const chunk = await get_chunk(chunk_index);
-			if (!chunk) return null;
-
-			const chunk_end = chunk_start + chunk.byteLength;
-			// If this chunk contains the target offset
-			if (offset >= chunk_start && offset < chunk_end) {
-				start_chunk = chunk;
-				break;
-			}
-			chunk_start = chunk_end;
-		}
-		// If the buffer is completely contained in one chunk, do a subarray
-		if (offset + length <= chunk_start + start_chunk.byteLength) {
-			return start_chunk.subarray(offset - chunk_start, offset + length - chunk_start);
-		}
-		// Otherwise, copy the data into a new buffer
-		const chunks = [start_chunk.subarray(offset - chunk_start)];
-		let cursor = start_chunk.byteLength - offset + chunk_start;
-		while (cursor < length) {
-			chunk_index++;
-			let chunk = await get_chunk(chunk_index);
-			if (!chunk) return null;
-			if (chunk.byteLength > length - cursor) {
-				chunk = chunk.subarray(0, length - cursor);
-			}
-			chunks.push(chunk);
-			cursor += chunk.byteLength;
+		/** @type {Uint8Array<ArrayBuffer>[]} */
+		const parts = [];
+		let total = 0;
+		for await (const part of read_range(get_chunk, offset, length)) {
+			parts.push(part);
+			total += part.byteLength;
 		}
+		if (total < length || parts.length === 0) return null;
+		// If the buffer is completely contained in one chunk, return the subarray as-is
+		if (parts.length === 1) return parts[0];
+
 		const buffer = new Uint8Array(length);
-		cursor = 0;
-		for (const chunk of chunks) {
-			buffer.set(chunk, cursor);
-			cursor += chunk.byteLength;
+		let cursor = 0;
+		for (const part of parts) {
+			buffer.set(part, cursor);
+			cursor += part.byteLength;
 		}
-
 		return buffer;
 	}
 
@@ -366,6 +344,32 @@ function deserialize_error(message) {
 	return new SvelteKitError(400, 'Bad Request', `Could not deserialize binary form: ${message}`);
 }
 
+/**
+ * Yields the chunks that make up the byte range `[offset, offset + length)`,
+ * trimmed to its boundaries. Ends early if the underlying data runs out.
+ * @param {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} get_chunk
+ * @param {number} offset
+ * @param {number} length
+ * @returns {AsyncGenerator<Uint8Array<ArrayBuffer>, void, void>}
+ */
+async function* read_range(get_chunk, offset, length) {
+	let chunk_start = 0;
+	for (let index = 0; ; index++) {
+		const chunk = await get_chunk(index);
+		if (!chunk) return;
+
+		const chunk_end = chunk_start + chunk.byteLength;
+		if (chunk_end > offset) {
+			yield chunk.subarray(
+				Math.max(0, offset - chunk_start),
+				Math.min(chunk.byteLength, offset + length - chunk_start)
+			);
+			if (offset + length <= chunk_end) return;
+		}
+		chunk_start = chunk_end;
+	}
+}
+
 /** @implements {File} */
 class LazyFile {
 	/** @type {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} */
@@ -436,49 +440,21 @@ class LazyFile {
 		return file;
 	}
 	stream() {
+		const range = read_range(this.#get_chunk, this.#offset, this.size);
 		let cursor = 0;
-		let chunk_index = 0;
 		return new ReadableStream({
-			start: async (controller) => {
-				let chunk_start = 0;
-				/** @type {Uint8Array} */
-				let start_chunk;
-				for (chunk_index = 0; ; chunk_index++) {
-					const chunk = await this.#get_chunk(chunk_index);
-					if (!chunk) return null;
-
-					const chunk_end = chunk_start + chunk.byteLength;
-					// If this chunk contains the target offset
-					if (this.#offset >= chunk_start && this.#offset < chunk_end) {
-						start_chunk = chunk;
-						break;
-					}
-					chunk_start = chunk_end;
-				}
-				// If the buffer is completely contained in one chunk, do a subarray
-				if (this.#offset + this.size <= chunk_start + start_chunk.byteLength) {
-					controller.enqueue(
-						start_chunk.subarray(this.#offset - chunk_start, this.#offset + this.size - chunk_start)
-					);
-					controller.close();
-				} else {
-					controller.enqueue(start_chunk.subarray(this.#offset - chunk_start));
-					cursor = start_chunk.byteLength - this.#offset + chunk_start;
-				}
-			},
 			pull: async (controller) => {
-				chunk_index++;
-				let chunk = await this.#get_chunk(chunk_index);
-				if (!chunk) {
-					controller.error('incomplete file data');
-					controller.close();
+				const { value, done } = await range.next();
+				if (done) {
+					if (cursor < this.size) {
+						controller.error('incomplete file data');
+					} else {
+						controller.close();
+					}
 					return;
 				}
-				if (chunk.byteLength > this.size - cursor) {
-					chunk = chunk.subarray(0, this.size - cursor);
-				}
-				controller.enqueue(chunk);
-				cursor += chunk.byteLength;
+				cursor += value.byteLength;
+				controller.enqueue(value);
 				if (cursor >= this.size) {
 					controller.close();
 				}

package/src/runtime/invalid-import.js

@@ -0,0 +1 @@
+throw new Error('invalid import');

package/src/runtime/props.svelte.js

@@ -63,7 +63,7 @@ export class RenderNode {
 	/**
 	 *
 	 * @param {Component} component
-	 * @param {Component} error
+	 * @param {Component | undefined} error
 	 */
 	constructor(component, error) {
 		this.component = component;

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

@@ -12,7 +12,7 @@ import { with_version_header } from '../utils.js';
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSRRoute} route
+ * @param {{ page: Pick<import('types').PageNodeIndexes, 'layouts' | 'leaf'> | null }} route
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {boolean[] | undefined} invalidated_data_nodes

package/src/runtime/server/endpoint.js

@@ -1,6 +1,6 @@
 import { Redirect } from '@sveltejs/kit/internal';
 import { with_request_store } from '@sveltejs/kit/internal/server';
-import { ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
+import { BODY_DEPENDENT_METHODS, ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
 import { negotiate } from '../../utils/http.js';
 import { method_not_allowed } from './utils.js';
 
@@ -25,8 +25,13 @@ export async function render_endpoint(event, state, mod) {
 
 	const prerender = mod.prerender ?? state.prerender_default;
 
-	if (prerender && (mod.POST || mod.PATCH || mod.PUT || mod.DELETE)) {
-		throw new Error('Cannot prerender endpoints that have mutative methods');
+	if (
+		prerender &&
+		/** @type {import('types').HttpMethod[]} */ (BODY_DEPENDENT_METHODS).some(
+			(method) => mod[method]
+		)
+	) {
+		throw new Error('Cannot prerender endpoints with body-dependent methods');
 	}
 
 	if (state.prerendering && !state.prerendering.inside_reroute && !prerender) {

package/src/runtime/server/env_module.js

@@ -1,5 +1,5 @@
 import * as devalue from 'devalue';
-import { rendered_env } from '__sveltekit/env';
+import { rendered_env } from '<sveltekit:generated>/env/config.js';
 
 /** @type {string} */
 let payload;

package/src/runtime/server/errors.js

@@ -1,4 +1,4 @@
-import { json, text } from '@sveltejs/kit';
+import { text } from '@sveltejs/kit';
 import {
 	HandledHttpError,
 	HttpError,
@@ -28,7 +28,7 @@ export async function handle_fatal_error(event, state, options, error) {
 	]);
 
 	if (event.isDataRequest || type === 'application/json') {
-		return json(body, {
+		return Response.json(body, {
 			status
 		});
 	}

package/src/runtime/server/index.js

@@ -2,9 +2,9 @@ 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 { options, get_hooks } from '<sveltekit:generated>/server.js';
 import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
-import { set_env } from '__sveltekit/env';
+import { set_env } from '<sveltekit:generated>/env/config.js';
 import { init_tracing } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
 import { init_transport } from '#app/internal/transport';