diff --git a/.changeset/refresh-page-state.md b/.changeset/refresh-page-state.md
new file mode 100644
index 000000000000..f69d1876700a
--- /dev/null
+++ b/.changeset/refresh-page-state.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': major
+---
+
+breaking: add `refreshAll` and deprecate `invalidateAll`
diff --git a/documentation/docs/20-core-concepts/20-load.md b/documentation/docs/20-core-concepts/20-load.md
index 2c895dc6af72..2146de9a56bc 100644
--- a/documentation/docs/20-core-concepts/20-load.md
+++ b/documentation/docs/20-core-concepts/20-load.md
@@ -638,7 +638,9 @@ export async function load({ untrack, url }) {
 
 ### Manual invalidation
 
-You can also rerun `load` functions that apply to the current page using [`invalidate(url)`]($app-navigation#invalidate), which reruns all `load` functions that depend on `url`, and [`invalidateAll()`]($app-navigation#invalidateAll), which reruns every `load` function. Server load functions will never automatically depend on a fetched `url` to avoid leaking secrets to the client.
+You can also rerun `load` functions that apply to the current page using [`invalidate(url)`]($app-navigation#invalidate), which reruns all `load` functions that depend on `url`, and [`refreshAll()`]($app-navigation#refreshAll), which reruns every `load` function and all active queries. Server load functions will never automatically depend on a fetched `url` to avoid leaking secrets to the client.
+
+> [!NOTE] `refreshAll` does _not_ reset `page.state`, unlike its deprecated predecessor `invalidateAll`.
 
 A `load` function depends on `url` if it calls `fetch(url)` or `depends(url)`. Note that `url` can be a custom identifier that starts with `[a-z]:`:
 
@@ -661,7 +663,7 @@ export async function load({ fetch, depends }) {
 ```svelte
 <!--- file: src/routes/random-number/+page.svelte --->
 <script>
-	import { invalidate, invalidateAll } from '$app/navigation';
+	import { invalidate, refreshAll } from '$app/navigation';
 
 	/** @type {import('./$types').PageProps} */
 	let { data } = $props();
@@ -671,7 +673,7 @@ export async function load({ fetch, depends }) {
 		invalidate('app:random');
 		invalidate('https://api.example.com/random-number');
 		invalidate(url => url.href.includes('random-number'));
-		invalidateAll();
+		refreshAll();
 	}
 </script>
 
@@ -689,7 +691,7 @@ To summarize, a `load` function will rerun in the following situations:
 - It calls `await parent()` and a parent `load` function reran
 - A child `load` function calls `await parent()` and is rerunning, and the parent is a server load function
 - It declared a dependency on a specific URL via [`fetch`](#Making-fetch-requests) (universal load only) or [`depends`](@sveltejs-kit#LoadEvent), and that URL was marked invalid with [`invalidate(url)`]($app-navigation#invalidate)
-- All active `load` functions were forcibly rerun with [`invalidateAll()`]($app-navigation#invalidateAll)
+- All active `load` functions were forcibly rerun with [`refreshAll()`]($app-navigation#refreshAll)
 
 `params` and `url` can change in response to a `<a href="..">` link click, a [`<form>` interaction](form-actions#GET-vs-POST), a [`goto`]($app-navigation#goto) invocation, or a [`redirect`](@sveltejs-kit#redirect).
 
diff --git a/documentation/docs/20-core-concepts/30-form-actions.md b/documentation/docs/20-core-concepts/30-form-actions.md
index c8e69846efa5..6642f17ba4ad 100644
--- a/documentation/docs/20-core-concepts/30-form-actions.md
+++ b/documentation/docs/20-core-concepts/30-form-actions.md
@@ -433,7 +433,7 @@ We can also implement progressive enhancement ourselves, without `use:enhance`,
 ```svelte
 <!--- file: src/routes/login/+page.svelte --->
 <script>
-	import { invalidateAll, goto } from '$app/navigation';
+	import { refreshAll, goto } from '$app/navigation';
 	import { applyAction, deserialize } from '$app/forms';
 
 	/** @type {import('./$types').PageProps} */
@@ -453,8 +453,8 @@ We can also implement progressive enhancement ourselves, without `use:enhance`,
 		const result = deserialize(await response.text());
 
 		if (result.type === 'success') {
-			// rerun all `load` functions, following the successful update
-			await invalidateAll();
+			// rerun all `load` functions and queries, following the successful update
+			await refreshAll();
 		}
 
 		applyAction(result);
diff --git a/packages/kit/src/runtime/app/forms.js b/packages/kit/src/runtime/app/forms.js
index 4d9b5238d7a2..adb55c8247a3 100644
--- a/packages/kit/src/runtime/app/forms.js
+++ b/packages/kit/src/runtime/app/forms.js
@@ -1,7 +1,7 @@
 import * as devalue from 'devalue';
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
-import { invalidateAll } from './navigation.js';
+import { refreshAll } from './navigation.js';
 import { app as client_app, applyAction, handle_error } from '../client/client.js';
 import { app as server_app } from '../server/app.js';
 
@@ -106,7 +106,7 @@ export function enhance(form_element, submit = noop) {
 				HTMLFormElement.prototype.reset.call(form_element);
 			}
 			if (shouldInvalidateAll) {
-				await invalidateAll();
+				await refreshAll();
 			}
 		}
 
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 3cb7b4a53f45..34b6750a9bc9 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -403,7 +403,7 @@ export async function start(_app, _target, hydrate) {
 	_start_router();
 }
 
-async function _invalidate(include_load_functions = true, reset_page_state = true) {
+async function _invalidate(reset_page_state = true) {
 	// Accept all invalidations as they come, don't swallow any while another invalidation
 	// is running because subsequent invalidations may make earlier ones outdated,
 	// but batch multiple synchronous invalidations.
@@ -442,39 +442,35 @@ async function _invalidate(include_load_functions = true, reset_page_state = tru
 		}
 	}
 
-	if (include_load_functions) {
-		const prev_state = page.state;
-		const navigation_result = intent && (await load_route(intent));
-		if (!navigation_result || token !== invalidation_token || nav_token !== navigation_token) {
-			return;
-		}
+	const prev_state = page.state;
+	const navigation_result = intent && (await load_route(intent));
+	if (!navigation_result || token !== invalidation_token || nav_token !== navigation_token) {
+		return;
+	}
 
-		if (navigation_result.type === 'redirect') {
-			return _goto(
-				new URL(navigation_result.location, current.url).href,
-				{ replaceState: true },
-				1,
-				token
-			);
-		}
+	if (navigation_result.type === 'redirect') {
+		return _goto(
+			new URL(navigation_result.location, current.url).href,
+			{ replaceState: true },
+			1,
+			token
+		);
+	}
 
-		// A navigation started before the invalidation and ended before it finished. The invalidation did not redirect,
-		// hence it likely contains outdated data now, so we ignore it.
-		if (navigating && !is_navigating) {
-			return;
-		}
+	// A navigation started before the invalidation and ended before it finished. The invalidation did not redirect,
+	// hence it likely contains outdated data now, so we ignore it.
+	if (navigating && !is_navigating) {
+		return;
+	}
 
-		// This is a bit hacky but allows us not having to pass that boolean around, making things harder to reason about
-		if (!reset_page_state) {
-			navigation_result.props.page.state = prev_state;
-		}
-		update(navigation_result.props.page);
-		current = { ...navigation_result.state, nav: current.nav };
-		reset_invalidation();
-		root.$set(navigation_result.props);
-	} else {
-		reset_invalidation();
+	// Preserve `page.state` when invalidating without resetting it (e.g. `refresh`/`refreshAll`)
+	if (!reset_page_state) {
+		navigation_result.props.page.state = prev_state;
 	}
+	update(navigation_result.props.page);
+	current = { ...navigation_result.state, nav: current.nav };
+	reset_invalidation();
+	root.$set(navigation_result.props);
 
 	// only wait for promises that are connected to queries that still exist
 	/** @type {Promise<any>[]} */
@@ -527,7 +523,7 @@ function persist_state() {
 
 /**
  * @param {string | URL} url
- * @param {{ replaceState?: boolean; noScroll?: boolean; keepFocus?: boolean; invalidateAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any> }} options
+ * @param {{ replaceState?: boolean; noScroll?: boolean; keepFocus?: boolean; refreshAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any> }} options
  * @param {number} redirect_count
  * @param {{}} [nav_token]
  * @param {NavigationIntent | undefined} [intent] navigation intent, when already known by the caller (avoids recomputing it)
@@ -539,9 +535,9 @@ export async function _goto(url, options, redirect_count, nav_token, intent) {
 	/** @type {Set<string>} */
 	let live_query_keys;
 
-	// Clear preload cache when invalidateAll is true to ensure fresh data
+	// Clear preload cache when refreshAll is true to ensure fresh data
 	// after form submissions or explicit invalidations
-	if (options.invalidateAll) {
+	if (options.refreshAll) {
 		discard_load_cache();
 	}
 
@@ -556,7 +552,7 @@ export async function _goto(url, options, redirect_count, nav_token, intent) {
 		nav_token,
 		intent,
 		accept: () => {
-			if (options.invalidateAll) {
+			if (options.refreshAll) {
 				force_invalidation = true;
 				query_keys = new Set();
 				for (const [id, entries] of query_map) {
@@ -582,7 +578,7 @@ export async function _goto(url, options, redirect_count, nav_token, intent) {
 		}
 	});
 
-	if (options.invalidateAll) {
+	if (options.refreshAll) {
 		// TODO the ticks shouldn't be necessary, something inside Svelte itself is buggy
 		// when a query in a layout that still exists after page change is refreshed earlier than this
 		void svelte
@@ -2297,6 +2293,8 @@ export function disableScrollHandling() {
 	}
 }
 
+let warned_on_invalidate_all = false;
+
 /**
  * Allows you to navigate programmatically to a given route, with options such as keeping the current element focused.
  * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified `url`.
@@ -2310,8 +2308,9 @@ export function disableScrollHandling() {
  * @param {boolean} [opts.replaceState] If `true`, will replace the current `history` entry rather than creating a new one with `pushState`
  * @param {boolean} [opts.noScroll] If `true`, the browser will maintain its scroll position rather than scrolling to the top of the page after navigation
  * @param {boolean} [opts.keepFocus] If `true`, the currently focused element will retain focus after navigation. Otherwise, focus will be reset to the body
- * @param {boolean} [opts.invalidateAll] If `true`, all `load` functions of the page will be rerun. See https://svelte.dev/docs/kit/load#rerunning-load-functions for more info on invalidation.
+ * @param {boolean} [opts.refreshAll] If `true`, all `load` functions and queries of the page will be rerun. See https://svelte.dev/docs/kit/load#rerunning-load-functions for more info on invalidation.
  * @param {Array<string | URL | ((url: URL) => boolean)>} [opts.invalidate] Causes any load functions to re-run if they depend on one of the urls
+ * @param {boolean} [opts.invalidateAll] Deprecated in favour of opts.refreshAll.
  * @param {App.PageState} [opts.state] An optional object that will be available as `page.state`
  * @returns {Promise<void>}
  */
@@ -2340,6 +2339,14 @@ export async function goto(url, opts = {}) {
 		);
 	}
 
+	if (DEV && 'invalidateAll' in opts && !warned_on_invalidate_all) {
+		warned_on_invalidate_all = true;
+		console.warn(
+			`The \`goto(..., { invalidateAll: ${opts.invalidateAll} })\` option has been deprecated in favour of \`refreshAll\``
+		);
+	}
+
+	opts.refreshAll = opts.refreshAll ?? opts.invalidateAll;
 	return _goto(url, opts, 0, {}, intent);
 }
 
@@ -2359,16 +2366,17 @@ export async function goto(url, opts = {}) {
  * invalidate((url) => url.pathname === '/path');
  * ```
  * @param {string | URL | ((url: URL) => boolean)} resource The invalidated URL
+ * @param {boolean} [keepState] If `true`, the current `page.state` will be preserved. Otherwise, it will be reset to an empty object. `false` by default.
  * @returns {Promise<void>}
  */
-export function invalidate(resource) {
+export function invalidate(resource, keepState = false) {
 	if (!BROWSER) {
 		throw new Error('Cannot call invalidate(...) on the server');
 	}
 
 	push_invalidated(resource);
 
-	return _invalidate();
+	return _invalidate(!keepState);
 }
 
 /**
@@ -2385,6 +2393,10 @@ function push_invalidated(resource) {
 
 /**
  * Causes all `load` and `query` functions belonging to the currently active page to re-run. Returns a `Promise` that resolves when the page is subsequently updated.
+ *
+ * Note that this resets `page.state` to an empty object. If you want to preserve `page.state` (for example when using [shallow routing](https://svelte.dev/docs/kit/shallow-routing)), use `refreshAll` instead.
+ *
+ * @deprecated Use [`refreshAll`](https://svelte.dev/docs/kit/$app-navigation#refreshAll) instead. Unlike `invalidateAll`, `refreshAll` does not reset `page.state`.
  * @returns {Promise<void>}
  */
 export function invalidateAll() {
@@ -2397,18 +2409,17 @@ export function invalidateAll() {
 }
 
 /**
- * Causes all currently active remote functions to refresh, and all `load` functions belonging to the currently active page to re-run (unless disabled via the option argument).
+ * Causes all currently active remote functions to refresh, and all `load` functions belonging to the currently active page to re-run.
  * Returns a `Promise` that resolves when the page is subsequently updated.
- * @param {{ includeLoadFunctions?: boolean }} [options]
  * @returns {Promise<void>}
  */
-export function refreshAll({ includeLoadFunctions = true } = {}) {
+export function refreshAll() {
 	if (!BROWSER) {
 		throw new Error('Cannot call refreshAll() on the server');
 	}
 
 	force_invalidation = true;
-	return _invalidate(includeLoadFunctions, false);
+	return _invalidate(false);
 }
 
 /**
@@ -2599,7 +2610,7 @@ export async function applyAction(result) {
 	if (result.type === 'error') {
 		await set_nearest_error_page(result.error);
 	} else if (result.type === 'redirect') {
-		await _goto(result.location, { invalidateAll: true }, 0);
+		await _goto(result.location, { refreshAll: true }, 0);
 	} else {
 		page.form = result.data;
 		page.status = result.status;
diff --git a/packages/kit/src/runtime/client/remote-functions/form.svelte.js b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
index 38089eaead61..a83a1e0d1b08 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -8,8 +8,8 @@ import {
 	query_responses,
 	_goto,
 	set_nearest_error_page,
-	invalidateAll,
-	handle_error
+	handle_error,
+	refreshAll
 } from '../client.js';
 import { tick } from 'svelte';
 import { categorize_updates, remote_request } from './shared.svelte.js';
@@ -227,14 +227,14 @@ export function form(id) {
 
 					// if the developer took control of updates via `.updates(...)` (even with
 					// no arguments), or the server performed explicit refreshes, don't invalidateAll
-					const should_invalidate = refreshes === null && !response.r;
+					const should_refresh = refreshes === null && !response.r;
 
 					if (response.redirect) {
 						// Use internal version to allow redirects to external URLs
 						void _goto(
 							response.redirect,
 							{
-								invalidateAll: should_invalidate
+								refreshAll: should_refresh
 							},
 							0
 						);
@@ -244,8 +244,8 @@ export function form(id) {
 					const succeeded = raw_issues.length === 0;
 
 					if (succeeded) {
-						if (should_invalidate) {
-							void invalidateAll();
+						if (should_refresh) {
+							void refreshAll();
 						}
 					} else {
 						if (DEV) {
diff --git a/packages/kit/test/apps/async/src/routes/remote/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/+page.svelte
index 62f18a5c4238..8860c5059dd9 100644
--- a/packages/kit/test/apps/async/src/routes/remote/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/+page.svelte
@@ -172,9 +172,6 @@
 </button>
 
 <button id="refresh-all" onclick={() => refreshAll()}>refreshAll</button>
-<button id="refresh-remote-only" onclick={() => refreshAll({ includeLoadFunctions: false })}>
-	refreshAll (remote functions only)
-</button>
 <button id="resolve-deferreds" onclick={() => resolve_deferreds()}>Resolve Deferreds</button>
 
 <a href="/remote/event">/remote/event</a>
diff --git a/packages/kit/test/apps/async/src/routes/remote/live/+page.svelte b/packages/kit/test/apps/async/src/routes/remote/live/+page.svelte
index 4251d6a37d56..6c4798558ced 100644
--- a/packages/kit/test/apps/async/src/routes/remote/live/+page.svelte
+++ b/packages/kit/test/apps/async/src/routes/remote/live/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { invalidateAll } from '$app/navigation';
+	import { refreshAll } from '$app/navigation';
 	import LiveView from './LiveView.svelte';
 	import {
 		increment,
@@ -67,15 +67,15 @@
 		}
 	}
 
-	let invalidate_state = $state('idle');
+	let refresh_state = $state('idle');
 
-	async function run_invalidate_all() {
-		invalidate_state = 'pending';
+	async function run_refresh_all() {
+		refresh_state = 'pending';
 		try {
-			await invalidateAll();
-			invalidate_state = 'resolved';
+			await refreshAll();
+			refresh_state = 'resolved';
 		} catch {
-			invalidate_state = 'rejected';
+			refresh_state = 'rejected';
 		}
 	}
 </script>
@@ -111,5 +111,5 @@
 
 <button id="start-stream-log" onclick={start_stream_log}>start stream log</button>
 <p id="stream-log">{stream_log}</p>
-<button id="run-invalidate-all" onclick={run_invalidate_all}>invalidate all</button>
-<p id="invalidate-state">{invalidate_state}</p>
+<button id="run-refresh-all" onclick={run_refresh_all}>refresh all</button>
+<p id="refresh-state">{refresh_state}</p>
diff --git a/packages/kit/test/apps/async/test/client.test.js b/packages/kit/test/apps/async/test/client.test.js
index 208876495c8a..5b47b97a6e62 100644
--- a/packages/kit/test/apps/async/test/client.test.js
+++ b/packages/kit/test/apps/async/test/client.test.js
@@ -372,20 +372,6 @@ test.describe('remote function mutations', () => {
 		expect(request_count).toBe(5);
 	});
 
-	test('refreshAll({ includeLoadFunctions: false }) reloads remote functions only', async ({
-		page
-	}) => {
-		await page.goto('/remote');
-		await expect(page.locator('#count-result')).toHaveText('0 / 0 (false)');
-
-		let request_count = 0;
-		page.on('request', (r) => (request_count += r.url().includes('/_app/remote') ? 1 : 0));
-
-		await page.click('#refresh-remote-only');
-		await page.waitForTimeout(100); // allow things to rerun
-		expect(request_count).toBe(4);
-	});
-
 	test('command tracks pending state', async ({ page }) => {
 		await page.goto('/remote');
 
@@ -806,7 +792,7 @@ test.describe('remote function mutations', () => {
 		await page.click('#reset');
 	});
 
-	test('for await consumers continue receiving values across invalidateAll-triggered reconnects', async ({
+	test('for await consumers continue receiving values across refreshAll-triggered reconnects', async ({
 		page
 	}) => {
 		await page.goto('/remote/live');
@@ -817,11 +803,11 @@ test.describe('remote function mutations', () => {
 		// the first value should be the current value (0)
 		await expect(page.locator('#stream-log')).toHaveText(/0/);
 
-		// invalidateAll() calls reconnect(), which keeps the existing fan-out
+		// refreshAll() calls reconnect(), which keeps the existing fan-out
 		// open so active `for await` consumers continue receiving values from
 		// the new connection without interruption.
-		await page.click('#run-invalidate-all');
-		await expect(page.locator('#invalidate-state')).toHaveText('resolved');
+		await page.click('#run-refresh-all');
+		await expect(page.locator('#refresh-state')).toHaveText('resolved');
 
 		// Trigger a new value — the still-attached consumer must see it.
 		// Before the fix the fan-out was replaced, orphaning the subscriber so
@@ -832,7 +818,7 @@ test.describe('remote function mutations', () => {
 		await page.click('#reset');
 	});
 
-	test('invalidateAll resolves while a live query is offline', async ({ page, context }) => {
+	test('refreshAll resolves while a live query is offline', async ({ page, context }) => {
 		await page.goto('/remote/live');
 		await page.click('#reset');
 		await expect(page.locator('#connected')).toHaveText('true');
@@ -840,9 +826,9 @@ test.describe('remote function mutations', () => {
 		await context.setOffline(true);
 
 		// reconnect()'s handshake must settle on every #main exit path (here:
-		// offline) so that awaiting invalidateAll() doesn't deadlock.
-		await page.click('#run-invalidate-all');
-		await expect(page.locator('#invalidate-state')).toHaveText(/resolved|rejected/);
+		// offline) so that awaiting refreshAll() doesn't deadlock.
+		await page.click('#run-refresh-all');
+		await expect(page.locator('#refresh-state')).toHaveText(/resolved|rejected/);
 
 		await context.setOffline(false);
 	});
diff --git a/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte b/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
index e42c285b54c8..3cee4d352d6f 100644
--- a/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
@@ -1,6 +1,6 @@
 <script>
 	import { applyAction } from '$app/forms';
-	import { invalidateAll } from '$app/navigation';
+	import { refreshAll } from '$app/navigation';
 
 	export let form;
 	let count = 0;
@@ -20,7 +20,7 @@
 <pre>{JSON.stringify(form)}</pre>
 <button class="increment-success" onclick={() => update('success')}>Increment (success)</button>
 <button class="increment-invalid" onclick={() => update('failure')}>Increment (invalid)</button>
-<button class="invalidateAll" onclick={invalidateAll}>Invalidate</button>
+<button class="refreshAll" onclick={refreshAll}>Refresh</button>
 <button class="redirect" onclick={redirect}>Redirect</button>
 <button class="error" onclick={error}>Error</button>
 <a href="/actions/enhance">To enhance</a>
diff --git a/packages/kit/test/apps/basics/src/routes/load/change-detection/one/[x]/+page.svelte b/packages/kit/test/apps/basics/src/routes/load/change-detection/one/[x]/+page.svelte
index 108bab003f7f..ff473717c549 100644
--- a/packages/kit/test/apps/basics/src/routes/load/change-detection/one/[x]/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/change-detection/one/[x]/+page.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidate, invalidateAll } from '$app/navigation';
+	import { invalidate, refreshAll } from '$app/navigation';
 
 	/** @type {import('./$types').PageData} */
 	export let data;
@@ -18,7 +18,7 @@
 <button
 	onclick={async () => {
 		window.invalidated = false;
-		await invalidateAll();
+		await refreshAll();
 		window.invalidated = true;
-	}}>invalidate all</button
+	}}>refresh all</button
 >
diff --git a/packages/kit/test/apps/basics/src/routes/load/invalidation/during-navigation/[slug]/+layout.svelte b/packages/kit/test/apps/basics/src/routes/load/invalidation/during-navigation/[slug]/+layout.svelte
index 606e4f59034d..e0beca43276e 100644
--- a/packages/kit/test/apps/basics/src/routes/load/invalidation/during-navigation/[slug]/+layout.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/invalidation/during-navigation/[slug]/+layout.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidateAll } from '$app/navigation';
+	import { refreshAll } from '$app/navigation';
 	let { children } = $props();
 </script>
 
@@ -8,17 +8,17 @@
 	<a href="/load/invalidation/during-navigation/b" data-testid="nav-b">b</a>
 	<a
 		href="/load/invalidation/during-navigation/b"
-		data-testid="nav-b-invalidate"
-		onclick={() => setTimeout(() => invalidateAll(), 50)}
+		data-testid="nav-b-refresh"
+		onclick={() => setTimeout(() => refreshAll(), 50)}
 	>
-		b+invalidate
+		b+refresh
 	</a>
 	<a
 		href="/load/invalidation/during-navigation/a"
-		data-testid="nav-a-invalidate"
-		onclick={() => setTimeout(() => invalidateAll(), 50)}
+		data-testid="nav-a-refresh"
+		onclick={() => setTimeout(() => refreshAll(), 50)}
 	>
-		a+invalidate
+		a+refresh
 	</a>
 </nav>
 
diff --git a/packages/kit/test/apps/basics/src/routes/load/invalidation/forced-goto/+page.svelte b/packages/kit/test/apps/basics/src/routes/load/invalidation/forced-goto/+page.svelte
index 76d828cac677..129a6078e95f 100644
--- a/packages/kit/test/apps/basics/src/routes/load/invalidation/forced-goto/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/invalidation/forced-goto/+page.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidateAll, goto } from '$app/navigation';
+	import { refreshAll, goto } from '$app/navigation';
 
 	/** @type {import('./$types').PageData} */
 	export let data;
@@ -8,10 +8,10 @@
 <h1>a: {data.a}, b: {data.b}</h1>
 
 <button
-	class="invalidateall"
+	class="refreshall"
 	onclick={() => {
-		window.promise = invalidateAll();
-	}}>invalidate</button
+		window.promise = refreshAll();
+	}}>refresh</button
 >
 
 <button
diff --git a/packages/kit/test/apps/basics/src/routes/load/invalidation/forced/+page.svelte b/packages/kit/test/apps/basics/src/routes/load/invalidation/forced/+page.svelte
index 0150fabb1b35..a68171f775d6 100644
--- a/packages/kit/test/apps/basics/src/routes/load/invalidation/forced/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/invalidation/forced/+page.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidateAll, goto } from '$app/navigation';
+	import { refreshAll, goto } from '$app/navigation';
 
 	/** @type {import('./$types').PageData} */
 	export let data;
@@ -8,10 +8,10 @@
 <h1>a: {data.a}, b: {data.b}</h1>
 
 <button
-	class="invalidateall"
+	class="refreshall"
 	onclick={() => {
-		window.promise = invalidateAll();
-	}}>invalidate</button
+		window.promise = refreshAll();
+	}}>refresh</button
 >
 
 <button
diff --git a/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/+layout.svelte b/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/+layout.svelte
index 0405e1d6b9ad..42b36837895a 100644
--- a/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/+layout.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/+layout.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidate, invalidateAll } from '$app/navigation';
+	import { invalidate, refreshAll } from '$app/navigation';
 	import { page } from '$app/state';
 	import { increment_layout, increment_page } from './state';
 
@@ -13,16 +13,16 @@
 		}
 
 		if (str === 'all') {
-			invalidateAll();
+			refreshAll();
 		} else {
 			invalidate(`invalid:${str}`);
 		}
 	}
 </script>
 
-<button class="layout" onclick={() => update('layout')}>Invalidate layout</button>
-<button class="page" onclick={() => update('page')}>Invalidate page</button>
-<button class="all" onclick={() => update('all')}>Invalidate all</button>
+<button class="layout" onclick={() => update('layout')}>Refresh layout</button>
+<button class="page" onclick={() => update('page')}>Refresh page</button>
+<button class="all" onclick={() => update('all')}>Refresh all</button>
 
 <p>layout: {page.data.count_layout}, page: {page.data.count_page}</p>
 
diff --git a/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/redirect/+page.svelte b/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/redirect/+page.svelte
index 141db8bcff59..21d1cc0321d9 100644
--- a/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/redirect/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/load/invalidation/multiple/redirect/+page.svelte
@@ -1,10 +1,10 @@
 <script>
-	import { invalidateAll } from '$app/navigation';
+	import { refreshAll } from '$app/navigation';
 	import { redirect_state } from '../state';
 
 	function redirect() {
 		redirect_state.set('start');
-		invalidateAll();
+		refreshAll();
 	}
 </script>
 
diff --git a/packages/kit/test/apps/basics/src/routes/reroute/invalidate/+page.svelte b/packages/kit/test/apps/basics/src/routes/reroute/invalidate/+page.svelte
index 77c4945350a1..16cb78956569 100644
--- a/packages/kit/test/apps/basics/src/routes/reroute/invalidate/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/reroute/invalidate/+page.svelte
@@ -1,10 +1,10 @@
 <script>
-	import { invalidateAll } from '$app/navigation';
+	import { refreshAll } from '$app/navigation';
 
 	export let data;
 </script>
 
-<button onclick={async () => await invalidateAll()}>Invalidate</button>
+<button onclick={async () => await refreshAll()}>Refresh</button>
 
 {#if data.request}
 	<p>data request: {data.request}</p>
diff --git a/packages/kit/test/apps/basics/src/routes/shallow-routing/push-state/+page.svelte b/packages/kit/test/apps/basics/src/routes/shallow-routing/push-state/+page.svelte
index 318d0c91cbd9..07c88d358be5 100644
--- a/packages/kit/test/apps/basics/src/routes/shallow-routing/push-state/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/shallow-routing/push-state/+page.svelte
@@ -1,5 +1,5 @@
 <script>
-	import { invalidateAll, pushState } from '$app/navigation';
+	import { refreshAll, pushState } from '$app/navigation';
 	import { page } from '$app/state';
 
 	let { data } = $props();
@@ -17,7 +17,7 @@
 
 <button data-id="one" onclick={one}>push state on current page</button>
 <button data-id="two" onclick={two}>push state on child page</button>
-<button data-id="invalidate" onclick={invalidateAll}>invalidate all</button>
+<button data-id="refresh" onclick={refreshAll}>refresh all</button>
 
 <p>active: {page.state.active ?? false}</p>
 <span>{data.now}</span>
diff --git a/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.js b/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.js
new file mode 100644
index 000000000000..0b7f1326641a
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.js
@@ -0,0 +1,7 @@
+/** @type {import('./$types').PageLoad} */
+export function load({ depends }) {
+	depends('refresh:now');
+	return {
+		now: Date.now()
+	};
+}
diff --git a/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.svelte b/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.svelte
new file mode 100644
index 000000000000..ea3961aba72e
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/shallow-routing/refresh/+page.svelte
@@ -0,0 +1,24 @@
+<script>
+	import { invalidate, invalidateAll, refreshAll, pushState } from '$app/navigation';
+	import { page } from '$app/state';
+
+	let { data } = $props();
+
+	function activate() {
+		pushState('', { active: true });
+	}
+</script>
+
+<h1>refresh</h1>
+
+<button data-id="activate" onclick={activate}>push state</button>
+<button data-id="refreshAll" onclick={() => (window.promise = refreshAll())}>refreshAll</button>
+<button data-id="invalidate" onclick={() => (window.promise = invalidate('refresh:now'))}
+	>invalidate</button
+>
+<button data-id="invalidateAll" onclick={() => (window.promise = invalidateAll())}
+	>invalidateAll</button
+>
+
+<p>active: {page.state.active ?? false}</p>
+<span>{data.now}</span>
diff --git a/packages/kit/test/apps/basics/test/client.test.js b/packages/kit/test/apps/basics/test/client.test.js
index 1e5b36b519f5..c9a069649f35 100644
--- a/packages/kit/test/apps/basics/test/client.test.js
+++ b/packages/kit/test/apps/basics/test/client.test.js
@@ -76,7 +76,7 @@ test.describe('Load', () => {
 		expect(await page.textContent('h1')).toBe('layout loads: 5');
 		expect(await page.textContent('h2')).toBe('x: b: 3');
 
-		await page.click('button:has-text("invalidate all")');
+		await page.click('button:has-text("refresh all")');
 		await page.waitForFunction('window.invalidated');
 		expect(await page.textContent('h1')).toBe('layout loads: 6');
 		expect(await page.textContent('h2')).toBe('x: b: 4');
@@ -536,13 +536,13 @@ test.describe('Invalidation', () => {
 		await page.goto('/load/invalidation/forced');
 		expect(await page.textContent('h1')).toBe('a: 0, b: 0');
 
-		await page.click('button.invalidateall');
+		await page.click('button.refreshall');
 		await page.evaluate(
 			() => /** @type {Window & typeof globalThis & { promise: Promise<void> }} */ (window).promise
 		);
 		expect(await page.textContent('h1')).toBe('a: 1, b: 1');
 
-		await page.click('button.invalidateall');
+		await page.click('button.refreshall');
 		await page.evaluate(
 			() => /** @type {Window & typeof globalThis & { promise: Promise<void> }} */ (window).promise
 		);
@@ -590,7 +590,7 @@ test.describe('Invalidation', () => {
 		await expect(btn).toHaveText('2');
 	});
 
-	test('invalidateAll persists through redirects', async ({ page }) => {
+	test('refreshAll persists through redirects', async ({ page }) => {
 		await page.goto('/load/invalidation/multiple/redirect');
 		await page.locator('button.redirect').click();
 		await expect(page.locator('p.redirect-state')).toHaveText('Redirect state: done');
@@ -795,7 +795,7 @@ test.describe('Invalidation', () => {
 		await expect(page.getByText('updated')).toBeVisible();
 	});
 
-	test('goto after invalidation does not reset state', async ({ page }) => {
+	test('goto after invalidate does not reset state', async ({ page }) => {
 		await page.goto('/load/invalidation/invalidate-then-goto');
 		const layout = await page.textContent('p.layout');
 		const _page = await page.textContent('p.page');
@@ -821,28 +821,28 @@ test.describe('Invalidation', () => {
 		expect(next_page_2).not.toBe(next_page_1);
 	});
 
-	test('invalidateAll finishing after navigation does not apply stale data', async ({
+	test('refreshAll finishing after navigation does not apply stale data', async ({
 		page,
 		clicknav
 	}) => {
 		await page.goto('/load/invalidation/during-navigation/a');
 		await expect(page.locator('[data-testid="scores"]')).toHaveText('1 - 1');
 
-		await clicknav('[data-testid="nav-b-invalidate"]');
+		await clicknav('[data-testid="nav-b-refresh"]');
 		await expect(page.locator('[data-testid="scores"]')).toHaveText('2 - 2');
 
 		await page.waitForTimeout(400);
 		await expect(page.locator('[data-testid="scores"]')).toHaveText('2 - 2');
 	});
 
-	test('invalidateAll finishing before navigation ends does not prevent navigation', async ({
+	test('refreshAll finishing before navigation ends does not prevent navigation', async ({
 		page,
 		clicknav
 	}) => {
 		await page.goto('/load/invalidation/during-navigation/b');
 		await expect(page.locator('[data-testid="scores"]')).toHaveText('2 - 2');
 
-		await clicknav('[data-testid="nav-a-invalidate"]');
+		await clicknav('[data-testid="nav-a-refresh"]');
 		await expect(page.locator('[data-testid="scores"]')).toHaveText('1 - 1');
 	});
 });
@@ -1679,7 +1679,7 @@ test.describe('Shallow routing', () => {
 		await page.locator('[data-id="two"]').click();
 		expect(page.url()).toBe(`${baseURL}/shallow-routing/push-state/a`);
 
-		await page.locator('[data-id="invalidate"]').click();
+		await page.locator('[data-id="refresh"]').click();
 		await expect(page.locator('h1')).toHaveText('parent');
 		await expect(page.locator('span')).not.toHaveText(now);
 	});
@@ -1742,6 +1742,51 @@ test.describe('Shallow routing', () => {
 		await page.locator('button').click();
 		await expect(page.locator('p')).toHaveText('count: 1');
 	});
+
+	test('refreshAll reruns load functions without resetting page.state', async ({ page }) => {
+		await page.goto('/shallow-routing/refresh');
+		await expect(page.locator('p')).toHaveText('active: false');
+
+		const now = /** @type {string} */ (await page.locator('span').textContent());
+
+		await page.locator('[data-id="activate"]').click();
+		await expect(page.locator('p')).toHaveText('active: true');
+
+		await page.locator('[data-id="refreshAll"]').click();
+		await page.evaluate(() => window.promise);
+		await expect(page.locator('p')).toHaveText('active: true');
+		await expect(page.locator('span')).not.toHaveText(now);
+	});
+
+	test('invalidate resets page.state', async ({ page }) => {
+		await page.goto('/shallow-routing/refresh');
+		await expect(page.locator('p')).toHaveText('active: false');
+
+		const now = /** @type {string} */ (await page.locator('span').textContent());
+
+		await page.locator('[data-id="activate"]').click();
+		await expect(page.locator('p')).toHaveText('active: true');
+
+		await page.locator('[data-id="invalidate"]').click();
+		await page.evaluate(() => window.promise);
+		await expect(page.locator('p')).toHaveText('active: false');
+		await expect(page.locator('span')).not.toHaveText(now);
+	});
+
+	test('invalidateAll resets page.state', async ({ page }) => {
+		await page.goto('/shallow-routing/refresh');
+		await expect(page.locator('p')).toHaveText('active: false');
+
+		const now = /** @type {string} */ (await page.locator('span').textContent());
+
+		await page.locator('[data-id="activate"]').click();
+		await expect(page.locator('p')).toHaveText('active: true');
+
+		await page.locator('[data-id="invalidateAll"]').click();
+		await page.evaluate(() => window.promise);
+		await expect(page.locator('p')).toHaveText('active: false');
+		await expect(page.locator('span')).not.toHaveText(now);
+	});
 });
 
 test.describe('reroute', () => {
diff --git a/packages/kit/test/apps/basics/test/test.js b/packages/kit/test/apps/basics/test/test.js
index 25ffbe4ced36..b6dac3ac1f07 100644
--- a/packages/kit/test/apps/basics/test/test.js
+++ b/packages/kit/test/apps/basics/test/test.js
@@ -1078,7 +1078,7 @@ test.describe('Actions', () => {
 		}
 	});
 
-	test('form prop stays after invalidation and is reset on navigation', async ({
+	test('form prop stays after refresh and is reset on navigation', async ({
 		page,
 		app,
 		javaScriptEnabled
@@ -1090,7 +1090,7 @@ test.describe('Actions', () => {
 			await page.locator('button.increment-success').click();
 			await expect(page.locator('pre')).toHaveText(JSON.stringify({ count: 0 }));
 
-			await page.locator('button.invalidateAll').click();
+			await page.locator('button.refreshAll').click();
 			await page.waitForTimeout(500);
 			await expect(page.locator('pre')).toHaveText(JSON.stringify({ count: 0 }));
 			await app.goto('/actions/enhance');
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 318380ee4e5a..1ac57eb7a3af 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -3361,8 +3361,9 @@ declare module '$app/navigation' {
 		replaceState?: boolean | undefined;
 		noScroll?: boolean | undefined;
 		keepFocus?: boolean | undefined;
-		invalidateAll?: boolean | undefined;
+		refreshAll?: boolean | undefined;
 		invalidate?: (string | URL | ((url: URL) => boolean))[] | undefined;
+		invalidateAll?: boolean | undefined;
 		state?: App.PageState | undefined;
 	}): Promise<void>;
 	/**
@@ -3381,19 +3382,22 @@ declare module '$app/navigation' {
 	 * invalidate((url) => url.pathname === '/path');
 	 * ```
 	 * @param resource The invalidated URL
+	 * @param keepState If `true`, the current `page.state` will be preserved. Otherwise, it will be reset to an empty object. `false` by default.
 	 * */
-	export function invalidate(resource: string | URL | ((url: URL) => boolean)): Promise<void>;
+	export function invalidate(resource: string | URL | ((url: URL) => boolean), keepState?: boolean): Promise<void>;
 	/**
 	 * Causes all `load` and `query` functions belonging to the currently active page to re-run. Returns a `Promise` that resolves when the page is subsequently updated.
+	 *
+	 * Note that this resets `page.state` to an empty object. If you want to preserve `page.state` (for example when using [shallow routing](https://svelte.dev/docs/kit/shallow-routing)), use `refreshAll` instead.
+	 *
+	 * @deprecated Use [`refreshAll`](https://svelte.dev/docs/kit/$app-navigation#refreshAll) instead. Unlike `invalidateAll`, `refreshAll` does not reset `page.state`.
 	 * */
 	export function invalidateAll(): Promise<void>;
 	/**
-	 * Causes all currently active remote functions to refresh, and all `load` functions belonging to the currently active page to re-run (unless disabled via the option argument).
+	 * Causes all currently active remote functions to refresh, and all `load` functions belonging to the currently active page to re-run.
 	 * Returns a `Promise` that resolves when the page is subsequently updated.
 	 * */
-	export function refreshAll({ includeLoadFunctions }?: {
-		includeLoadFunctions?: boolean;
-	}): Promise<void>;
+	export function refreshAll(): Promise<void>;
 	/**
 	 * Programmatically preloads the given page, which means
 	 *  1. ensuring that the code for the page is loaded, and