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

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

@@ -1,7 +1,7 @@
 /** @import { PageOptions } from './types.js' */
+/** @import { ESTree } from 'vite' */
 import path from 'node:path';
-import { tsPlugin } from '@sveltejs/acorn-typescript';
-import { Parser } from 'acorn';
+import { parseSync } from 'vite';
 import { read } from '../../../utils/filesystem.js';
 
 export const valid_page_options_array = /** @type {const} */ ([
@@ -21,8 +21,6 @@ const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );
 
-const parser = Parser.extend(tsPlugin());
-
 /**
  * Collects page options from a +page.js/+layout.js file, ignoring reassignments
  * and using the declared value (except for load functions, for which the value is `true`).
@@ -39,15 +37,13 @@ export function statically_analyse_page_options(filename, input) {
 	}
 
 	try {
-		const source = parser.parse(input, {
-			sourceType: 'module',
-			ecmaVersion: 'latest'
-		});
+		const source = parseSync(filename, input, { sourceType: 'module' });
+		if (source.errors.length) throw new Error(source.errors[0].message);
 
-		/** @type {Map<string, import('acorn').Literal['value']>} */
+		/** @type {Map<string, Extract<ESTree.Expression, { type: 'Literal' }>['value']>} */
 		const page_options = new Map();
 
-		for (const statement of source.body) {
+		for (const statement of source.program.body) {
 			// ignore export all declarations with aliases that are not page options
 			if (
 				statement.type === 'ExportAllDeclaration' &&
@@ -82,7 +78,7 @@ export function statically_analyse_page_options(filename, input) {
 					export_specifiers.set(get_name(specifier.local), exported_name);
 				}
 
-				for (const statement of source.body) {
+				for (const statement of source.program.body) {
 					switch (statement.type) {
 						case 'ImportDeclaration': {
 							for (const import_specifier of statement.specifiers) {
@@ -105,7 +101,10 @@ export function statically_analyse_page_options(filename, input) {
 
 							// class and function declarations
 							if (declaration.type !== 'VariableDeclaration') {
-								if (export_specifiers.has(declaration.id.name)) {
+								if (
+									declaration.id?.type === 'Identifier' &&
+									export_specifiers.has(declaration.id.name)
+								) {
 									return null;
 								}
 								break;
@@ -156,9 +155,10 @@ export function statically_analyse_page_options(filename, input) {
 
 			// class and function declarations
 			if (statement.declaration.type !== 'VariableDeclaration') {
-				if (valid_page_options.has(statement.declaration.id.name)) {
+				const { id } = statement.declaration;
+				if (id?.type === 'Identifier' && valid_page_options.has(id.name)) {
 					// Special case: We only want to know that 'load' is exported (in a way that doesn't cause truthy checks in other places to trigger)
-					if (statement.declaration.id.name === 'load') {
+					if (id.name === 'load') {
 						page_options.set('load', null);
 					} else {
 						return null;
@@ -202,7 +202,7 @@ export function statically_analyse_page_options(filename, input) {
 }
 
 /**
- * @param {import('acorn').Identifier | import('acorn').Literal} node
+ * @param {ESTree.ModuleExportName} node
  * @returns {string}
  */
 function get_name(node) {

package/src/exports/vite/utils.js

@@ -1,5 +1,9 @@
+/** @import { UserConfig } from 'vite' */
+/** @import { EnforcedConfig } from './types.js' */
 import fs from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
+import { styleText } from 'node:util';
 import { posixify } from '../../utils/os.js';
 import { negotiate } from '../../utils/http.js';
 import { escape_html } from '../../utils/escape.js';
@@ -130,7 +134,7 @@ export function normalize_id(id, aliases, cwd) {
 		}
 	}
 
-	if (id.startsWith(cwd)) {
+	if (id.startsWith(cwd + '/')) {
 		id = path.relative(cwd, id);
 	}
 
@@ -227,3 +231,96 @@ export function error_for_missing_config(feature_name, path, value) {
 		`
 	);
 }
+
+/** @type {EnforcedConfig} */
+export const enforced_config = {
+	appType: true,
+	base: true,
+	build: {
+		cssCodeSplit: true,
+		emptyOutDir: true,
+		lib: {
+			entry: true,
+			name: true,
+			formats: true
+		},
+		manifest: true,
+		outDir: true,
+		rolldownOptions: {
+			input: true,
+			output: {
+				format: true,
+				entryFileNames: true,
+				chunkFileNames: true,
+				assetFileNames: true
+			},
+			preserveEntrySignatures: true
+		},
+		ssr: true
+	},
+	publicDir: true,
+	resolve: {
+		alias: {
+			$app: true,
+			$env: true,
+			'<sveltekit:generated>': true
+		}
+	}
+};
+
+/**
+ * @param {UserConfig} config
+ * @param {UserConfig} resolved_config
+ */
+export function warn_overridden_config(config, resolved_config) {
+	const overridden = find_overridden_config(config, resolved_config, enforced_config, '', []);
+
+	if (overridden.length > 0) {
+		console.error(
+			styleText(
+				['bold', 'red'],
+				'The following Vite config options will be overridden by SvelteKit:'
+			) + overridden.map((key) => `\n  - ${key}`).join('')
+		);
+	}
+}
+
+/**
+ * @param {Record<string, any>} config
+ * @param {Record<string, any>} resolved_config
+ * @param {EnforcedConfig} enforced_config
+ * @param {string} path
+ * @param {string[]} out used locally to compute the return value
+ */
+export function find_overridden_config(config, resolved_config, enforced_config, path, out) {
+	if (config == null || resolved_config == null) {
+		return out;
+	}
+
+	for (const key in enforced_config) {
+		if (typeof config === 'object' && key in config && key in resolved_config) {
+			const enforced = enforced_config[key];
+			const resolved = resolved_config[key];
+
+			if (enforced === true) {
+				if (comparable(config[key]) !== comparable(resolved)) {
+					out.push(path + key);
+				}
+			} else {
+				find_overridden_config(config[key], resolved, enforced, path + key + '.', out);
+			}
+		}
+	}
+	return out;
+}
+
+/**
+ * Normalizes a config value for comparison, since Windows paths may use backslashes
+ * and differ in casing (e.g. the drive letter) depending on where they came from.
+ * @param {any} value
+ */
+export function comparable(value) {
+	if (typeof value !== 'string') return value;
+	const normalized = posixify(value);
+	return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}

package/src/runner.js

@@ -1,13 +1,14 @@
+/** @import * as vite from 'vite' */
 /** @import { ViteDevServer } from 'vite' */
 
 /**
- * @param {typeof import('vite')} vite the peer resolved vite module
+ * @param {typeof vite} vite the vite module that created the server
  * @param {ViteDevServer} server
  */
-export function get_runner(vite, server) {
+export function get_runner({ isRunnableDevEnvironment }, server) {
 	// `isRunnableDevEnvironment` does an `instanceof` check and will fail if
 	// we're using different instances of Vite
-	if (!vite.isRunnableDevEnvironment(server.environments.ssr)) {
+	if (!isRunnableDevEnvironment(server.environments.ssr)) {
 		throw new Error('The configured Vite SSR environment must be a RunnableDevEnvironment');
 	}
 

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

@@ -83,8 +83,8 @@ export async function match(url) {
 		resolved_path = resolved_path.slice(base.length) || '/';
 	}
 
-	const matchers = await manifest._.matchers();
-	const result = find_route(resolved_path, manifest._.routes, matchers);
+	const matchers = await manifest.matchers();
+	const result = find_route(resolved_path, manifest.routes, matchers);
 
 	if (result) {
 		return {

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

@@ -59,9 +59,9 @@ export function read(asset) {
 			: asset.slice(assets.length + 1)
 	);
 
-	if (file in manifest._.server_assets) {
-		const length = manifest._.server_assets[file];
-		const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+	if (file in manifest.server_assets) {
+		const length = manifest.server_assets[file];
+		const type = manifest.mime_types[file.slice(file.lastIndexOf('.'))];
 
 		return new Response(read_implementation(file), {
 			headers: {

package/src/runtime/app/server/public.d.ts

@@ -3,6 +3,14 @@ import { DeepPartial, IsAny, MaybePromise } from 'types';
 
 export * from './index.js';
 
+type ImageInputValue = { x: number; y: number };
+
+type IsImageInputValue<T> = T extends ImageInputValue
+	? Exclude<keyof T, keyof ImageInputValue> extends never
+		? true
+		: false
+	: false;
+
 // If T is unknown or has an index signature, the types below will recurse indefinitely and create giant unions that TS can't handle
 type WillRecurseIndefinitely<T> = unknown extends T ? true : string extends keyof T ? true : false;
 
@@ -29,7 +37,7 @@ type InputTypeMap = {
 	submit: string | number | boolean;
 	button: string;
 	reset: string;
-	image: string;
+	image: ImageInputValue;
 	select: string;
 	'select multiple': string[];
 	'file multiple': File[];
@@ -41,7 +49,7 @@ export type RemoteFormFieldType<T> = {
 }[keyof InputTypeMap];
 
 // Input element properties based on type
-type InputElementProps<T extends keyof InputTypeMap> = T extends 'checkbox' | 'radio'
+type InputElementProps<T extends keyof InputTypeMap, Value> = T extends 'checkbox' | 'radio'
 	? {
 			name: string;
 			type: T;
@@ -51,45 +59,51 @@ type InputElementProps<T extends keyof InputTypeMap> = T extends 'checkbox' | 'r
 			set checked(value: boolean);
 			readonly defaultChecked?: boolean;
 		}
-	: T extends 'file'
+	: T extends 'image'
 		? {
 				name: string;
-				type: 'file';
+				type: 'image';
 				'aria-invalid': boolean | 'false' | 'true' | undefined;
-				get files(): FileList | null;
-				set files(v: FileList | null);
 			}
-		: T extends 'select'
+		: T extends 'file'
 			? {
 					name: string;
+					type: 'file';
 					'aria-invalid': boolean | 'false' | 'true' | undefined;
-					get value(): string;
-					set value(v: string);
+					get files(): FileList | null;
+					set files(v: FileList | null);
 				}
-			: T extends 'select multiple'
+			: T extends 'select'
 				? {
 						name: string;
-						multiple: true;
 						'aria-invalid': boolean | 'false' | 'true' | undefined;
-						get value(): string[];
-						set value(v: string[]);
+						get value(): string;
+						set value(v: string);
 					}
-				: T extends 'text'
+				: T extends 'select multiple'
 					? {
 							name: string;
+							multiple: true;
 							'aria-invalid': boolean | 'false' | 'true' | undefined;
-							get value(): string | number;
-							set value(v: string | number);
-							readonly defaultValue?: string | number;
+							get value(): string[];
+							set value(v: string[]);
 						}
-					: {
-							name: string;
-							type: T;
-							'aria-invalid': boolean | 'false' | 'true' | undefined;
-							get value(): string | number;
-							set value(v: string | number);
-							readonly defaultValue?: string | number;
-						};
+					: T extends 'text'
+						? {
+								name: string;
+								'aria-invalid': boolean | 'false' | 'true' | undefined;
+								get value(): Value extends string ? string : string | number;
+								set value(v: Value extends string ? string : string | number);
+								readonly defaultValue?: Value extends string ? string : string | number;
+							}
+						: {
+								name: string;
+								type: T;
+								'aria-invalid': boolean | 'false' | 'true' | undefined;
+								get value(): string | number;
+								set value(v: string | number);
+								readonly defaultValue?: string | number;
+							};
 
 type RemoteFormFieldMethods<T> = {
 	/** The values that will be submitted */
@@ -113,23 +127,34 @@ type ValueOfUnionKey<T, K extends PropertyKey> = T extends unknown
 		: never
 	: never;
 
-export type RemoteFormFieldValue = string | string[] | number | boolean | File | File[];
+export type RemoteFormFieldValue =
+	| string
+	| string[]
+	| number
+	| boolean
+	| File
+	| File[]
+	| ImageInputValue;
 
 type AsArgs<Type extends keyof InputTypeMap, Value> = Type extends 'checkbox'
 	? Value extends string[]
-		? [type: Type, value: Value[number] | (string & {})]
+		? [type: Type, value: Value[number] | (string & {}), checked?: boolean]
 		: Value extends boolean
-			? [type: Type] | [type: Type, value: boolean]
-			: [type: Type] | [type: Type, value: Value | (string & {})]
-	: Type extends 'submit' | 'hidden'
-		? Value extends string
-			? [type: Type, value: Value | (string & {})]
-			: [type: Type, value: Value]
-		: Type extends 'radio'
-			? [type: Type, value: Value | (string & {})]
-			: Type extends 'file' | 'file multiple'
-				? [type: Type]
-				: [type: Type] | [type: Type, value: Value | undefined];
+			? [type: Type, value?: boolean]
+			: [type: Type, value?: Value]
+	: Type extends 'image'
+		? [type: Type]
+		: Type extends 'submit' | 'hidden'
+			? Value extends string
+				? [type: Type, value: Value | (string & {})]
+				: [type: Type, value: Value]
+			: Type extends 'radio'
+				? [type: Type, value: Value | (string & {}), checked?: boolean]
+				: Type extends 'file' | 'file multiple'
+					? [type: Type]
+					: [type: Type, value?: Value];
+
+type WidenLiteralString<T> = T extends string ? (string extends T ? T : string) : T;
 
 /**
  * Form field accessor type that provides name(), value(), and issues() methods
@@ -145,7 +170,9 @@ export type RemoteFormField<Value extends RemoteFormFieldValue> = RemoteFormFiel
 	 * <input {...myForm.fields.myBoolean.as('checkbox')} />
 	 * ```
 	 */
-	as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+	as<T extends RemoteFormFieldType<Value>>(
+		...args: AsArgs<T, Value>
+	): InputElementProps<T, WidenLiteralString<Value>>;
 };
 
 type RemoteFormFieldContainer<Value> = RemoteFormFieldMethods<Value> & {
@@ -166,12 +193,15 @@ type UnknownField<Value> = RemoteFormFieldMethods<Value> & {
 	 * <input {...myForm.fields.myBoolean.as('checkbox')} />
 	 * ```
 	 */
-	as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T>;
+	as<T extends RemoteFormFieldType<Value>>(...args: AsArgs<T, Value>): InputElementProps<T, Value>;
 } & {
 	[key: string | number]: UnknownField<any>;
 };
 
-type RemoteFormFieldsRoot<Input extends RemoteFormInput | void> =
+type RemoteFormFieldsRoot<
+	Input extends RemoteFormInput | void,
+	Original extends [RemoteFormInput | void] = [Input]
+> =
 	IsAny<Input> extends true
 		? RecursiveFormFields
 		: Input extends void
@@ -181,7 +211,11 @@ type RemoteFormFieldsRoot<Input extends RemoteFormInput | void> =
 					/** Validation issues belonging to this or any of the fields that belong to it, if any */
 					allIssues(): RemoteFormIssue[] | undefined;
 				}
-			: RemoteFormFields<Input>;
+			: WillRecurseIndefinitely<Input> extends true
+				? RecursiveFormFields
+				: RemoteFormFieldContainer<Original[0]> & {
+						[K in KeysOfUnion<Original[0]>]-?: RemoteFormFields<ValueOfUnionKey<Original[0], K>>;
+					};
 
 /**
  * Recursive type to build form fields structure with proxy access
@@ -191,20 +225,25 @@ export type RemoteFormFields<T> =
 		? RecursiveFormFields
 		: NonNullable<T> extends string | number | boolean | File
 			? RemoteFormField<NonNullable<T>>
-			: // [NonNullable<T>] is used to prevent distributing over union while still allowing
-				// nullable wrappers (e.g. `string[] | undefined` from a schema with `.default([])`)
-				// to be treated as arrays; only the last condition should distribute over unions
-				[NonNullable<T>] extends [string[] | File[]]
-				? RemoteFormField<NonNullable<T>> & {
-						[K in number]: RemoteFormField<NonNullable<T>[number]>;
-					}
-				: [NonNullable<T>] extends [Array<infer U>]
-					? RemoteFormFieldContainer<NonNullable<T>> & {
-							[K in number]: RemoteFormFields<U>;
-						}
-					: RemoteFormFieldContainer<T> & {
+			: IsImageInputValue<NonNullable<T>> extends true
+				? RemoteFormField<NonNullable<T> & ImageInputValue> &
+						Pick<RemoteFormFieldContainer<T>, 'allIssues'> & {
 							[K in KeysOfUnion<T>]-?: RemoteFormFields<ValueOfUnionKey<T, K>>;
-						};
+						}
+				: // [NonNullable<T>] is used to prevent distributing over union while still allowing
+					// nullable wrappers (e.g. `string[] | undefined` from a schema with `.default([])`)
+					// to be treated as arrays; only the last condition should distribute over unions
+					[NonNullable<T>] extends [string[] | File[]]
+					? RemoteFormField<NonNullable<T>> & {
+							[K in number]: RemoteFormField<NonNullable<T>[number]>;
+						}
+					: [NonNullable<T>] extends [Array<infer U>]
+						? RemoteFormFieldContainer<NonNullable<T>> & {
+								[K in number]: RemoteFormFields<U>;
+							}
+						: RemoteFormFieldContainer<T> & {
+								[K in KeysOfUnion<T>]-?: RemoteFormFields<ValueOfUnionKey<T, K>>;
+							};
 
 // By breaking this out into its own type, we avoid the TS recursion depth limit
 type RecursiveFormFields = RemoteFormFieldContainer<any> & {
@@ -273,7 +312,17 @@ export type RemoteFormEnhanceCallback<
 /**
  * The type of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  */
-export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+export type RemoteForm<Input extends RemoteFormInput | void, Output> = RemoteForm_<
+	Input,
+	Output,
+	[Input]
+>;
+
+type RemoteForm_<
+	Input extends RemoteFormInput | void,
+	Output,
+	Original extends [RemoteFormInput | void]
+> = {
 	/** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */
 	[attachment: symbol]: (node: HTMLFormElement) => void;
 	method: 'POST';
@@ -327,7 +376,7 @@ export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
 	/** True if the form has been submitted at least once, and hasn't been reset since */
 	get submitted(): boolean;
 	/** Access form fields using object notation */
-	fields: RemoteFormFieldsRoot<Input>;
+	fields: RemoteFormFieldsRoot<Input, Original>;
 };
 
 /**
@@ -459,6 +508,8 @@ export type RemoteLiveQueryFunction<Input, Output, _Validated = Input> = (
 export type RequestedEntry<Validated, Output> = {
 	arg: Validated;
 	query: RemoteQuery<Output>;
+	/** Explicitly ignore this requested update. */
+	ignore: () => void;
 };
 
 /**
@@ -470,6 +521,8 @@ export type RequestedEntry<Validated, Output> = {
 export type RemoteLiveQueryRequestedEntry<Validated, Output> = {
 	arg: Validated;
 	query: RemoteLiveQuery<Output>;
+	/** Explicitly ignore this requested update. */
+	ignore: () => void;
 };
 
 export type RemoteQueryRequestedResult<Validated, Output> = Iterable<
@@ -488,6 +541,8 @@ export type RemoteQueryRequestedResult<Validated, Output> = Iterable<
 		 * ```
 		 */
 		refreshAll: () => Promise<void>;
+		/** Explicitly ignore all updates selected by this `requested` invocation. */
+		ignoreAll: () => Promise<void>;
 	};
 
 export type RemoteLiveQueryRequestedResult<Validated, Output> = Iterable<
@@ -506,6 +561,8 @@ export type RemoteLiveQueryRequestedResult<Validated, Output> = Iterable<
 		 * ```
 		 */
 		reconnectAll: () => Promise<void>;
+		/** Explicitly ignore all updates selected by this `requested` invocation. */
+		ignoreAll: () => Promise<void>;
 	};
 
 export type RequestedResult<Validated, Output> =

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

@@ -330,7 +330,7 @@ function batch(validate_or_fn, maybe_fn) {
 		id: '',
 		name: '',
 		validate,
-		run: async (args, options) => {
+		run: async (args) => {
 			const { event, state } = get_request_store();
 
 			return run_remote_function(
@@ -347,7 +347,7 @@ function batch(validate_or_fn, maybe_fn) {
 								const data = get_result(arg, i);
 								return { type: 'result', data };
 							} catch (error) {
-								const transformed = await handle_error_and_jsonify(event, state, options, error);
+								const transformed = await handle_error_and_jsonify(event, state, error);
 
 								return {
 									type: 'error',

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

@@ -1,8 +1,7 @@
 /** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestedResult, RemoteQueryRequestedResult, RemoteLiveQueryRequestedResult } from '$app/server' */
 /** @import { MaybePromise, RemoteAnyQueryInternals } from 'types' */
-import { HttpError } from '@sveltejs/kit/internal';
 import { get_request_store } from '@sveltejs/kit/internal/server';
-import { parse_remote_arg } from '../../../shared.js';
+import { create_remote_key, parse_remote_arg } from '../../../shared.js';
 import { noop } from '../../../../utils/functions.js';
 import { get_cache } from './shared.js';
 import { refresh } from './query.js';
@@ -121,7 +120,19 @@ export function requested(query, limit) {
 	const __ = internals;
 
 	const requested = state.remote.requested;
-	const payloads = requested?.get(__.id) ?? [];
+	const payloads = requested?.get(__.id) ?? new Set();
+	const ignored = (state.remote.ignored ??= new Set());
+
+	/** @param {string} payload */
+	const consume = (payload) => {
+		payloads.delete(payload);
+		if (payloads.size === 0) requested?.delete(__.id);
+	};
+
+	/** @param {string} payload */
+	const create_ignore = (payload) => () => {
+		ignored.add(create_remote_key(__.id, payload));
+	};
 
 	// note: don't initialize these maps here -- they will be initialized by the
 	// command/form wrapper when we enter them, and if we initialize them here
@@ -132,7 +143,7 @@ export function requested(query, limit) {
 			'requested(...) can only be called in the context of a command/form remote function'
 		);
 	}
-	const [selected, skipped] = split_limit(payloads, limit);
+	const [selected, skipped] = split_limit([...payloads], limit);
 
 	/**
 	 * Registers the failure exactly like `.set()` registers a value: the error record
@@ -149,19 +160,12 @@ export function requested(query, limit) {
 		refresh(event, state, __, payload, () => promise);
 	};
 
-	for (const payload of skipped) {
-		record_failure(
-			payload,
-			new HttpError({
-				status: 400,
-				message: `Requested refresh was rejected because it exceeded requested(${__.name}, ${limit}) limit`
-			})
-		);
-	}
+	for (const payload of skipped) consume(payload);
 
 	const result = {
 		*[Symbol.iterator]() {
 			for (const payload of selected) {
+				consume(payload);
 				try {
 					const parsed = parse_remote_arg(payload);
 					const validated = __.validate(parsed);
@@ -173,7 +177,11 @@ export function requested(query, limit) {
 						);
 					}
 
-					yield { arg: validated, query: __.bind(payload, validated) };
+					yield {
+						arg: validated,
+						query: __.bind(payload, validated),
+						ignore: create_ignore(payload)
+					};
 				} catch (error) {
 					record_failure(payload, error);
 					continue;
@@ -182,10 +190,15 @@ export function requested(query, limit) {
 		},
 		async *[Symbol.asyncIterator]() {
 			yield* race_all(selected, async (payload) => {
+				consume(payload);
 				try {
 					const parsed = parse_remote_arg(payload);
 					const validated = await __.validate(parsed);
-					return { arg: validated, query: __.bind(payload, validated) };
+					return {
+						arg: validated,
+						query: __.bind(payload, validated),
+						ignore: create_ignore(payload)
+					};
 				} catch (error) {
 					record_failure(payload, error);
 					throw new Error(`Skipping ${__.name}(${payload})`, { cause: error });
@@ -209,6 +222,9 @@ export function requested(query, limit) {
 			for await (const { query } of result) {
 				void (/** @type {RemoteLiveQuery<Output>} */ (query).reconnect());
 			}
+		},
+		async ignoreAll() {
+			for await (const { ignore } of result) ignore();
 		}
 	};
 

package/src/runtime/app/state/client.svelte.js

@@ -1,6 +1,7 @@
 /** @import { Navigation } from '$app/navigation' */
 /** @import { Page } from '$app/state' */
 import { DEV } from 'esm-env';
+import { untrack } from 'svelte';
 import { assets } from '#app/paths';
 import { version } from '$app/env';
 
@@ -195,7 +196,8 @@ if (!DEV && interval) {
  */
 export function notify_version(new_version) {
 	if (__SVELTEKIT_APP_VERSION_CHECKS_ENABLED__ && new_version) {
-		_updated ||= new_version !== version;
+		// a tracked write inside a restored reaction context throws `state_unsafe_mutation`
+		untrack(() => (_updated ||= new_version !== version));
 	}
 }