@sveltejs/kit 3.0.0-next.17 → 3.0.0-next.19

package/types/index.d.ts

@@ -5,11 +5,24 @@ declare module '@sveltejs/kit' {
 	import type { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	import type { Plugin } from 'vite';
-	import type { RouteId as AppRouteId, LayoutParams as AppLayoutParams, ResolvedPathname } from '$app/types';
+	import type { RouteId as AppRouteId, LayoutParams as AppLayoutParams } from '$app/types';
 	// @ts-ignore this is an optional peer dependency so could be missing. Written like this so dts-buddy preserves the ts-ignore
 	type Span = import('@opentelemetry/api').Span;
 
-	type AppErrorWithOptionalStatus = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
+	type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
+		status?: App.Error['status'];
+		message?: App.Error['message'];
+	};
+
+	/**
+	 * `void` is only a valid `handleError` return when `App.Error` adds no required properties
+	 * beyond `status` and `message` — both of which are optional in the return, since they default
+	 * to those of the caught error. If `App.Error` is augmented with required properties, the hook
+	 * must return them, so returning nothing becomes a type error.
+	 */
+	type VoidIfNoRequiredAppErrorProperties = { status: number; message: string } extends App.Error
+		? void
+		: never;
 
 	/**
 	 * [Adapters](https://svelte.dev/docs/kit/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
@@ -46,11 +59,18 @@ declare module '@sveltejs/kit' {
 		 */
 		emulate?: () => MaybePromise<Emulator>;
 		vite?: {
-			/**
-			 * Plugins provided by the adapter are placed before any of SvelteKit's own plugins.
-			 * @since 3.0.0
-			 */
-			plugins?: Plugin[];
+			plugins?: {
+				/**
+				 * Vite plugins placed before any of SvelteKit's own plugins.
+				 * @since 3.0.0
+				 */
+				pre?: Plugin[];
+				/**
+				 * Vite plugins placed after any of SvelteKit's own plugins.
+				 * @since 3.0.0
+				 */
+				post?: Plugin[];
+			};
 		};
 	}
 
@@ -432,7 +452,10 @@ declare module '@sveltejs/kit' {
 			 *
 			 * CSRF checks only apply in production, not in local development.
 			 * @default []
-			 * @example ['https://checkout.stripe.com', 'https://accounts.google.com']
+			 * @example
+			 * ```js
+			 * ['https://checkout.stripe.com', 'https://accounts.google.com']
+			 * ```
 			 */
 			trustedOrigins?: string[];
 		};
@@ -912,45 +935,76 @@ declare module '@sveltejs/kit' {
 		resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
 	}) => MaybePromise<Response>;
 
+	type CaughtErrorMap = {
+		app: App.Error;
+		framework: { status: number; message: string };
+		unknown: unknown;
+	};
+
+	type ValidationCaughtError<Issue extends StandardSchemaV1.Issue> = {
+		kind: 'validation';
+		error: { status: number; message: string };
+		issues: Issue[];
+	};
+
 	/**
-	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while responding to a request.
-	 *
-	 * If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event.
-	 * Make sure that this function _never_ throws an error.
-	 *
-	 * The returned object can include a `status` property to override the HTTP status code used in the response.
-	 * If omitted, the status defaults to 500.
+	 * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
+	 * Use the `kind` discriminant to distinguish errors from your app (thrown with the
+	 * [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper), errors generated by
+	 * SvelteKit itself (such as 404s), validation errors, and unknown errors (thrown by your code,
+	 * or code it calls).
 	 */
-	export type HandleServerError = (input: {
-		error: unknown;
-		event: RequestEvent;
-		status: number;
-		message: string;
-	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+	export type CaughtError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
+		| {
+				[Kind in keyof CaughtErrorMap]: {
+					/** Identifies the category and origin of the error */
+					kind: Kind;
+					/** The caught error. Its type depends on `kind` */
+					error: CaughtErrorMap[Kind];
+					/** Only present for validation errors */
+					issues?: undefined;
+				};
+		  }[keyof CaughtErrorMap]
+		| ValidationCaughtError<Issue>;
+
+	/** The error passed to the client-side `handleError` hook. */
+	export type ClientCaughtError = Exclude<CaughtError, { kind: 'validation' }>;
 
 	/**
-	 * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#handleValidationError) hook runs when the argument to a remote function fails validation.
+	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
+	 *
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+	 * _framework_ errors (generated by SvelteKit itself, such as 404s), _validation_ errors (caused by invalid remote function arguments)
+	 * and _unknown_ errors (thrown by your code, or code it calls).
 	 *
-	 * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
+	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+	 * the status and safe message for framework and validation errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+	 *
+	 * Make sure that this function _never_ throws an error.
 	 */
-	export type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
-		(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
+	export type HandleServerError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (
+		input: CaughtError<Issue> & { event: RequestEvent }
+	) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 	/**
-	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while navigating.
+	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
+	 * Errors that were already transformed by the server-side hook are not passed to it a second time.
 	 *
-	 * If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event.
-	 * Make sure that this function _never_ throws an error.
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+	 * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
+	 *
+	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
 	 *
-	 * The returned object can include a `status` property to override the HTTP status code used in the response.
-	 * If omitted, the status defaults to 500.
+	 * Make sure that this function _never_ throws an error.
 	 */
-	export type HandleClientError = (input: {
-		error: unknown;
-		event: NavigationEvent;
-		status: number;
-		message: string;
-	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+	export type HandleClientError = (
+		input: ClientCaughtError & { event: NavigationEvent }
+	) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 	/**
 	 * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
@@ -1177,810 +1231,401 @@ declare module '@sveltejs/kit' {
 	}
 
 	/**
-	 * Information about the target of a specific navigation.
+	 * A single entry yielded by [`requested`](https://svelte.dev/docs/kit/$app-server#requested)
+	 * when called with a regular `query`. `arg` is the validated argument (the input *after*
+	 * the query's schema validated and transformed it, if applicable); `query` is a
+	 * `RemoteQuery` bound to the client's original cache key, so `refresh()` / `set()` will
+	 * update the correct client entry.
 	 */
-	export interface NavigationTarget<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> {
-		/**
-		 * Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
-		 * Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).
-		 */
-		params: Params | null;
-		/**
-		 * Info about the target route
-		 */
-		route: {
+	export type RequestedEntry<Validated, Output> = {
+		arg: Validated;
+		query: RemoteQuery<Output>;
+	};
+
+	/**
+	 * A single entry yielded by [`requested`](https://svelte.dev/docs/kit/$app-server#requested)
+	 * when called with a `query.live`. `arg` is the validated argument; `query` is a
+	 * `RemoteLiveQuery` bound to the client's original cache key, so `reconnect()` targets
+	 * the correct client subscription.
+	 */
+	export type LiveRequestedEntry<Validated, Output> = {
+		arg: Validated;
+		query: RemoteLiveQuery<Output>;
+	};
+
+	export type QueryRequestedResult<Validated, Output> = Iterable<RequestedEntry<Validated, Output>> &
+		AsyncIterable<RequestedEntry<Validated, Output>> & {
 			/**
-			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+			 * Call `refresh` on all queries selected by this `requested` invocation.
+			 * This is identical to:
+			 * ```ts
+			 * import { requested } from '$app/server';
+			 *
+			 * for await (const { query } of requested(getPost, ...)) {
+			 *   void query.refresh();
+			 * }
+			 * ```
 			 */
-			id: RouteId | null;
+			refreshAll: () => Promise<void>;
+		};
+
+	export type LiveQueryRequestedResult<Validated, Output> = Iterable<
+		LiveRequestedEntry<Validated, Output>
+	> &
+		AsyncIterable<LiveRequestedEntry<Validated, Output>> & {
+			/**
+			 * Call `reconnect` on all live queries selected by this `requested` invocation.
+			 * This is identical to:
+			 * ```ts
+			 * import { requested } from '$app/server';
+			 *
+			 * for await (const { query } of requested(liveQuery, ...)) {
+			 *   void query.reconnect();
+			 * }
+			 * ```
+			 */
+			reconnectAll: () => Promise<void>;
 		};
+
+	export type RequestedResult<Validated, Output> =
+		| QueryRequestedResult<Validated, Output>
+		| LiveQueryRequestedResult<Validated, Output>;
+
+	export interface RequestEvent<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> {
 		/**
-		 * The URL that is navigated to
+		 * Get or set cookies related to the current request
 		 */
-		url: URL;
+		readonly cookies: Cookies;
 		/**
-		 * The scroll position associated with this navigation.
+		 * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
 		 *
-		 * For the `from` target, this is the scroll position at the moment of navigation.
+		 * - It can be used to make credentialed requests on the server, as it inherits the `cookie` and `authorization` headers for the page request.
+		 * - It can make relative requests on the server (ordinarily, `fetch` requires a URL with an origin when used in a server context).
+		 * - Internal requests (e.g. for `+server.js` routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
+		 * - During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into the `text` and `json` methods of the `Response` object. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](https://svelte.dev/docs/kit/hooks#handle)
+		 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
 		 *
-		 * For the `to` target, this represents the scroll position that will be or was restored:
-		 * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
-		 *   and will be `null` for other navigation types, since the final scroll position isn't known
-		 *   ahead of time.
-		 * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
-		 *   completed.
+		 * You can learn more about making credentialed requests with cookies [here](https://svelte.dev/docs/kit/load#Cookies).
 		 */
-		scroll: { x: number; y: number } | null;
-	}
-
-	export interface GotoOptions {
+		readonly fetch: typeof fetch;
 		/**
-		 * If `true`, replaces the current history entry rather than creating a new one.
-		 * @default false
+		 * The client's IP address, set by the adapter.
 		 */
-		replace?: boolean;
-		/** @deprecated Use `replace` instead. */
-		replaceState?: boolean;
+		readonly getClientAddress: () => string;
 		/**
-		 * If `true`, updates the URL and `page.state` without navigating.
-		 * @default false
+		 * Contains custom data that was added to the request within the [`server handle hook`](https://svelte.dev/docs/kit/hooks#handle).
 		 */
-		shallow?: boolean;
+		readonly locals: App.Locals;
 		/**
-		 * If `true`, resets the scroll position (to the top of the page, or to the element
-		 * matching the URL's `#hash` if there is one) and resets focus (to the `<body>`, or the
-		 * `autofocus` element if there is one) once the navigation completes.
+		 * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
 		 *
-		 * If `false`, the current scroll position and focused element are left alone.
-		 * @default true, or false when `shallow` is true
+		 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
+		 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
+		 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
+		 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 		 */
-		reset?: boolean;
+		readonly params: Params;
 		/**
-		 * If `true`, reruns all `load` functions and queries of the page.
-		 * @default false
+		 * Additional data made available through the adapter.
 		 */
-		refreshAll?: boolean;
-		/** Causes any `load` functions to rerun if they depend on one of the URLs. */
-		invalidate?: Array<string | URL | ((url: URL) => boolean)>;
-		/** @deprecated Use `refreshAll` instead. */
-		invalidateAll?: boolean;
-		/** An optional object that will be available as `page.state`. */
-		state?: App.PageState;
+		readonly platform: Readonly<App.Platform> | undefined;
 		/**
-		 * If `true`, `page.state` will be restored after a full page reload.
-		 * @default false
+		 * The original request object.
 		 */
-		persistState?: boolean;
-	}
-
-	/**
-	 * - `enter`: The app has hydrated/started
-	 * - `form`: The user submitted a `<form method="GET">`
-	 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
-	 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
-	 * - `link`: Navigation was triggered by a link click
-	 * - `popstate`: Navigation was triggered by back/forward navigation
-	 */
-	export type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
-
-	export interface NavigationBase {
+		readonly request: Request;
 		/**
-		 * The type of navigation:
-		 * - `enter`: The app has hydrated/started
-		 * - `form`: The user submitted a `<form method="GET">`
-		 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
-		 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
-		 * - `link`: Navigation was triggered by a link click
-		 * - `popstate`: Navigation was triggered by back/forward navigation
+		 * Info about the current route.
 		 */
-		type: NavigationType;
-		/** Whether this is a shallow navigation. */
-		shallow: boolean;
+		readonly route: {
+			/**
+			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+			 *
+			 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
+			 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
+			 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
+			 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
+			 */
+			id: RouteId;
+		};
 		/**
-		 * Where navigation was triggered from
+		 * If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
+		 *
+		 *	```js
+		 *	/// file: src/routes/blog/+page.js
+		 *	export async function load({ fetch, setHeaders }) {
+		 *		const url = `https://cms.example.com/articles.json`;
+		 *		const response = await fetch(url);
+		 *
+		 *		setHeaders({
+		 *			age: response.headers.get('age'),
+		 *			'cache-control': response.headers.get('cache-control')
+		 *		});
+		 *
+		 *		return response.json();
+		 *	}
+		 *	```
+		 *
+		 * Setting the same header multiple times (even in separate `load` functions) is an error — you can only set a given header once.
+		 *
+		 * You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](https://svelte.dev/docs/kit/@sveltejs-kit#Cookies) API instead.
 		 */
-		from: NavigationTarget | null;
+		readonly setHeaders: (headers: Record<string, string>) => void;
 		/**
-		 * Where navigation is going to/has gone to
+		 * The requested URL.
+		 *
+		 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
+		 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
+		 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
+		 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 		 */
-		to: NavigationTarget | null;
+		readonly url: URL;
 		/**
-		 * Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation).
+		 * `true` if the request comes from the client asking for `+page/layout.server.js` data. The `url` property will be stripped of the internal information
+		 * related to the data request in this case. Use this property instead if the distinction is important to you.
 		 */
-		willUnload: boolean;
+		readonly isDataRequest: boolean;
 		/**
-		 * A promise that resolves once the navigation is complete, and rejects if the navigation
-		 * fails or is aborted. In the case of a `willUnload` navigation, the promise will never resolve
+		 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 		 */
-		complete: Promise<void>;
-	}
-
-	/**
-	 * The navigation that occurs when the app starts/hydrates
-	 */
-	export interface NavigationEnter extends NavigationBase {
-		type: 'enter';
+		readonly isSubRequest: boolean;
 
 		/**
-		 * In case of a history back/forward navigation, the number of steps to go back/forward
+		 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
+		 * @since 2.31.0
 		 */
-		delta?: undefined;
+		readonly tracing: {
+			/** Whether tracing is enabled. */
+			enabled: boolean;
+			/** The root span for the request. This span is named `sveltekit.handle.root`. */
+			root: Span;
+			/** The span associated with the current `handle` hook, `load` function, or form action. */
+			current: Span;
+		};
 
 		/**
-		 * Dispatched `Event` object when navigation occurred by `popstate` or `link`.
+		 * `true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
+		 * related to the data request in this case. Use this property instead if the distinction is important to you.
 		 */
-		event?: undefined;
+		readonly isRemoteRequest: boolean;
 	}
 
-	export type NavigationExternal = NavigationGoto | NavigationLeave;
-
 	/**
-	 * A navigation triggered by a `goto(...)` call or a redirect
+	 * A `(event: RequestEvent) => Response` function exported from a `+server.js` file that corresponds to an HTTP verb (`GET`, `PUT`, `PATCH`, etc) and handles requests with that method.
+	 *
+	 * It receives `Params` as the first generic argument, which you can skip by using [generated types](https://svelte.dev/docs/kit/types#Generated-types) instead.
 	 */
-	export interface NavigationGoto extends NavigationBase {
-		type: 'goto';
+	export type RequestHandler<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> = (event: RequestEvent<Params, RouteId>) => MaybePromise<Response>;
+
+	export interface ResolveOptions {
+		/**
+		 * Applies custom transforms to HTML. If `done` is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML
+		 * (they could include an element's opening tag but not its closing tag, for example)
+		 * but they will always be split at sensible boundaries such as `%sveltekit.head%` or layout/page components.
+		 * @param input the html chunk and the info if this is the last chunk
+		 */
+		transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
+		/**
+		 * Determines which headers should be included in serialized responses when a `load` function loads a resource with `fetch`.
+		 * By default, none will be included.
+		 * @param name header name
+		 * @param value header value
+		 */
+		filterSerializedResponseHeaders?: (name: string, value: string) => boolean;
+		/**
+		 * Determines which files should be preloaded. Files are preloaded via `<link>` tags added to the
+		 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
+		 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
+		 * By default, `js` and `css` files will be preloaded.
+		 * @param input the type of the file and its path
+		 */
+		preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
 	}
 
-	/**
-	 * A navigation triggered by the tab being closed, or the user navigating to a different document
-	 */
-	export interface NavigationLeave extends NavigationBase {
-		type: 'leave';
+	export interface RouteDefinition<Config = any> {
+		id: string;
+		api: {
+			methods: Array<HttpMethod | '*'>;
+		};
+		page: {
+			methods: Array<Extract<HttpMethod, 'GET' | 'POST'>>;
+		};
+		pattern: RegExp;
+		prerender: PrerenderOption;
+		segments: RouteSegment[];
+		methods: Array<HttpMethod | '*'>;
+		config: Config;
+	}
+
+	export class Server {
+		constructor(manifest: SSRManifest);
+		init(options: ServerInitOptions): Promise<void>;
+		respond(request: Request, options: RequestOptions): Promise<Response>;
+	}
+
+	export interface ServerInitOptions {
+		/** A map of environment variables. */
+		env: Record<string, string | undefined>;
+		/** A function that turns an asset filename into a `ReadableStream`. Required for the `read` export from `$app/server` to work. */
+		read?: (file: string) => MaybePromise<ReadableStream | null>;
 	}
 
 	/**
-	 * A navigation triggered by a `<form method="GET">`
+	 * Information required to instantiate a new `Server` instance.
 	 */
-	export interface NavigationFormSubmit extends NavigationBase {
-		type: 'form';
-
-		/**
-		 * The `SubmitEvent` that caused the navigation
-		 */
-		event: SubmitEvent;
+	export interface SSRManifest {
+		/** The directory where SvelteKit keeps its stuff, including static assets (such as JS and CSS) and internally-used routes. */
+		appDir: string;
+		/** The `base` and `appDir` settings combined without a leading slash. */
+		appPath: string;
+		/** Static files from `config.files.assets` and the service worker (if any). */
+		assets: Set<string>;
+		mimeTypes: Record<string, string>;
 	}
 
 	/**
-	 * A navigation triggered by back/forward navigation
+	 * The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](https://svelte.dev/docs/kit/types#Generated-types))
+	 * rather than using `ServerLoad` directly.
 	 */
-	export interface NavigationPopState extends NavigationBase {
-		type: 'popstate';
+	export type ServerLoad<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		ParentData extends Record<string, any> = Record<string, any>,
+		OutputData extends Record<string, any> | void = Record<string, any> | void,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> = (event: ServerLoadEvent<Params, ParentData, RouteId>) => MaybePromise<OutputData>;
 
+	export interface ServerLoadEvent<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		ParentData extends Record<string, any> = Record<string, any>,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> extends RequestEvent<Params, RouteId> {
 		/**
-		 * In case of a history back/forward navigation, the number of steps to go back/forward
+		 * `await parent()` returns data from parent `+layout.server.js` `load` functions.
+		 *
+		 * Be careful not to introduce accidental waterfalls when using `await parent()`. If for example you only want to merge parent data into the returned output, call it _after_ fetching your other data.
 		 */
-		delta: number;
-
+		parent: () => Promise<ParentData>;
 		/**
-		 * The `PopStateEvent` that caused the navigation
+		 * This function declares that the `load` function has a _dependency_ on one or more URLs or custom identifiers, which can subsequently be used with [`invalidate()`](https://svelte.dev/docs/kit/$app-navigation#invalidate) to cause `load` to rerun.
+		 *
+		 * Most of the time you won't need this, as `fetch` calls `depends` on your behalf — it's only necessary if you're using a custom API client that bypasses `fetch`.
+		 *
+		 * URLs can be absolute or relative to the page being loaded, and must be [encoded](https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding).
+		 *
+		 * Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the [URI specification](https://www.rfc-editor.org/rfc/rfc3986.html).
+		 *
+		 * The following example shows how to use `depends` to register a dependency on a custom identifier, which is `invalidate`d after a button click, making the `load` function rerun.
+		 *
+		 * ```js
+		 * /// file: src/routes/+page.js
+		 * let count = 0;
+		 * export async function load({ depends }) {
+		 * 	depends('increase:count');
+		 *
+		 * 	return { count: count++ };
+		 * }
+		 * ```
+		 *
+		 * ```html
+		 * /// file: src/routes/+page.svelte
+		 * <script>
+		 * 	import { invalidate } from '$app/navigation';
+		 *
+		 * 	let { data } = $props();
+		 *
+		 * 	const increase = async () => {
+		 * 		await invalidate('increase:count');
+		 * 	}
+		 * </script>
+		 *
+		 * <p>{data.count}<p>
+		 * <button on:click={increase}>Increase Count</button>
+		 * ```
 		 */
-		event: PopStateEvent;
-	}
-
-	/**
-	 * A navigation triggered by a link click
-	 */
-	export interface NavigationLink extends NavigationBase {
-		type: 'link';
+		depends: (...deps: string[]) => void;
+		/**
+		 * Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example:
+		 *
+		 * ```js
+		 * /// file: src/routes/+page.js
+		 * export async function load({ untrack, url }) {
+		 * 	// Untrack url.pathname so that path changes don't trigger a rerun
+		 * 	if (untrack(() => url.pathname === '/')) {
+		 * 		return { message: 'Welcome!' };
+		 * 	}
+		 * }
+		 * ```
+		 */
+		untrack: <T>(fn: () => T) => T;
 
 		/**
-		 * The `PointerEvent` that caused the navigation
+		 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
+		 * @since 2.31.0
 		 */
-		event: PointerEvent;
+		tracing: {
+			/** Whether tracing is enabled. */
+			enabled: boolean;
+			/** The root span for the request. This span is named `sveltekit.handle.root`. */
+			root: Span;
+			/** The span associated with the current server `load` function. */
+			current: Span;
+		};
 	}
 
-	export type Navigation =
-		NavigationExternal | NavigationFormSubmit | NavigationPopState | NavigationLink;
+	/**
+	 * Shape of a form action method that is part of `export const actions = {...}` in `+page.server.js`.
+	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
+	 */
+	export type Action<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		OutputData extends Record<string, any> | void = Record<string, any> | void,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> = (event: RequestEvent<Params, RouteId>) => MaybePromise<OutputData>;
 
 	/**
-	 * The argument passed to [`beforeNavigate`](https://svelte.dev/docs/kit/$app-navigation#beforeNavigate) callbacks.
+	 * Shape of the `export const actions = {...}` object in `+page.server.js`.
+	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
 	 */
-	export type BeforeNavigate = Navigation & {
-		/**
-		 * Call this to prevent the navigation from starting.
-		 */
-		cancel: () => void;
-	};
+	export type Actions<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		OutputData extends Record<string, any> | void = Record<string, any> | void,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> = Record<string, Action<Params, OutputData, RouteId>>;
 
 	/**
-	 * The argument passed to [`onNavigate`](https://svelte.dev/docs/kit/$app-navigation#onNavigate) callbacks.
+	 * The object returned by the [`error`](https://svelte.dev/docs/kit/@sveltejs-kit#error) function.
 	 */
-	export type OnNavigate = Navigation & {
-		type: Exclude<NavigationType, 'enter' | 'leave'>;
-		/**
-		 * Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.
-		 */
-		willUnload: false;
-	};
+	export interface HttpError {
+		/** The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses), in the range 400-599. */
+		status: number;
+		/** The content of the error. */
+		body: App.Error;
+	}
 
 	/**
-	 * The argument passed to [`afterNavigate`](https://svelte.dev/docs/kit/$app-navigation#afterNavigate) callbacks.
+	 * The object returned by the [`redirect`](https://svelte.dev/docs/kit/@sveltejs-kit#redirect) function.
 	 */
-	export type AfterNavigate = (Navigation | NavigationEnter) & {
-		type: Exclude<NavigationType, 'leave'>;
-		/**
-		 * Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page.
-		 */
-		willUnload: false;
-	};
+	export interface Redirect {
+		/** The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages), in the range 300-308. */
+		status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+		/** The location to redirect to. */
+		location: string;
+	}
 
 	/**
-	 * The shape of the [`page`](https://svelte.dev/docs/kit/$app-state#page) reactive object.
-	 */
-	export interface Page<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> {
-		/**
-		 * The URL of the current page.
-		 */
-		url: ReadonlyURL & { readonly pathname: ResolvedPathname | (string & {}) };
-		/**
-		 * The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
-		 */
-		params: Params;
-		/**
-		 * Info about the current route.
-		 */
-		route: {
-			/**
-			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
-			 */
-			id: RouteId;
-		};
-		/**
-		 * HTTP status code of the current page.
-		 */
-		status: number;
-		/**
-		 * The error object of the current page, if any. Filled from the `handleError` hooks.
-		 */
-		error: App.Error | null;
-		/**
-		 * The merged result of all data from all `load` functions on the current page. You can type a common denominator through `App.PageData`.
-		 */
-		data: App.PageData & Record<string, any>;
-		/**
-		 * The page state, which can be manipulated using [`goto`](https://svelte.dev/docs/kit/$app-navigation#goto) from `$app/navigation`.
-		 */
-		state: App.PageState;
-		/**
-		 * Information about the target of the current shallow navigation, or `null` if no shallow navigation has occurred.
-		 */
-		shallow: {
-			/** Parameters of the target route, or `null` if the URL does not resolve to a route. */
-			params: AppLayoutParams<'/'> | null;
-			/** Info about the target route, or `null` if the URL does not resolve to a route. */
-			route: { id: AppRouteId } | null;
-			/** The normalized URL passed to `goto(..., { shallow: true })`. */
-			url: ReadonlyURL;
-		} | null;
-		/**
-		 * Filled only after a form submission. See [form actions](https://svelte.dev/docs/kit/form-actions) for more info.
-		 */
-		form: any;
-	}
-
-	/**
-	 * The shape of a param matcher. See [matching](https://svelte.dev/docs/kit/advanced-routing#Matching) for more info.
-	 */
-	export type ParamMatcher<Output = any> = StandardSchemaV1<string, Output>;
-
-	/**
-	 * A value that can be parsed from a URL param and losslessly encoded with `String(...)`.
-	 */
-	export type ParamValue = string | number | boolean | bigint;
-
-	/**
-	 * A param matcher definition passed to [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
-	 */
-	export type ParamDefinition =
-		((param: string) => ParamValue | undefined) | StandardSchemaV1<string, ParamValue>;
-
-	/**
-	 * The return type of [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
-	 */
-	export type DefinedParams<T extends Record<string, ParamDefinition>> = {
-		readonly [K in keyof T]: ParamEntry<T[K]>;
-	};
-
-	/**
-	 * Normalizes a property of defineParams (schema or function) to standard schema.
-	 */
-	type ParamEntry<M> =
-		M extends StandardSchemaV1<any, any>
-			? StandardSchemaV1.InferOutput<M> extends ParamValue
-				? StandardSchemaV1<any, M>
-				: StandardSchemaV1<any, never>
-			: M extends (param: string) => infer R
-				? Exclude<R, undefined> extends ParamValue
-					? StandardSchemaV1<any, Exclude<R, undefined>>
-					: StandardSchemaV1<any, never>
-				: never;
-
-	/**
-	 * Extracts the param type from a matcher.
-	 */
-	export type MatcherParam<M extends StandardSchemaV1<any, any>> =
-		M extends StandardSchemaV1<any, infer Inner>
-			? Inner extends ParamValue
-				? Inner
-				: Inner extends StandardSchemaV1<any, any>
-					? StandardSchemaV1.InferOutput<Inner> extends ParamValue
-						? StandardSchemaV1.InferOutput<Inner>
-						: never
-					: never
-			: never;
-
-	/**
-	 * Define [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching) for your app.
-	 *
-	 * */
-	export function defineParams<T extends Record<string, ParamDefinition>>(
-		definitions: T
-	): DefinedParams<T>;
-
-	/**
-	 * A single entry yielded by [`requested`](https://svelte.dev/docs/kit/$app-server#requested)
-	 * when called with a regular `query`. `arg` is the validated argument (the input *after*
-	 * the query's schema validated and transformed it, if applicable); `query` is a
-	 * `RemoteQuery` bound to the client's original cache key, so `refresh()` / `set()` will
-	 * update the correct client entry.
-	 */
-	export type RequestedEntry<Validated, Output> = {
-		arg: Validated;
-		query: RemoteQuery<Output>;
-	};
-
-	/**
-	 * A single entry yielded by [`requested`](https://svelte.dev/docs/kit/$app-server#requested)
-	 * when called with a `query.live`. `arg` is the validated argument; `query` is a
-	 * `RemoteLiveQuery` bound to the client's original cache key, so `reconnect()` targets
-	 * the correct client subscription.
-	 */
-	export type LiveRequestedEntry<Validated, Output> = {
-		arg: Validated;
-		query: RemoteLiveQuery<Output>;
-	};
-
-	export type QueryRequestedResult<Validated, Output> = Iterable<RequestedEntry<Validated, Output>> &
-		AsyncIterable<RequestedEntry<Validated, Output>> & {
-			/**
-			 * Call `refresh` on all queries selected by this `requested` invocation.
-			 * This is identical to:
-			 * ```ts
-			 * import { requested } from '$app/server';
-			 *
-			 * for await (const { query } of requested(getPost, ...)) {
-			 *   void query.refresh();
-			 * }
-			 * ```
-			 */
-			refreshAll: () => Promise<void>;
-		};
-
-	export type LiveQueryRequestedResult<Validated, Output> = Iterable<
-		LiveRequestedEntry<Validated, Output>
-	> &
-		AsyncIterable<LiveRequestedEntry<Validated, Output>> & {
-			/**
-			 * Call `reconnect` on all live queries selected by this `requested` invocation.
-			 * This is identical to:
-			 * ```ts
-			 * import { requested } from '$app/server';
-			 *
-			 * for await (const { query } of requested(liveQuery, ...)) {
-			 *   void query.reconnect();
-			 * }
-			 * ```
-			 */
-			reconnectAll: () => Promise<void>;
-		};
-
-	export type RequestedResult<Validated, Output> =
-		QueryRequestedResult<Validated, Output> | LiveQueryRequestedResult<Validated, Output>;
-
-	export interface RequestEvent<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> {
-		/**
-		 * Get or set cookies related to the current request
-		 */
-		readonly cookies: Cookies;
-		/**
-		 * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
-		 *
-		 * - It can be used to make credentialed requests on the server, as it inherits the `cookie` and `authorization` headers for the page request.
-		 * - It can make relative requests on the server (ordinarily, `fetch` requires a URL with an origin when used in a server context).
-		 * - Internal requests (e.g. for `+server.js` routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
-		 * - During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into the `text` and `json` methods of the `Response` object. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](https://svelte.dev/docs/kit/hooks#handle)
-		 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
-		 *
-		 * You can learn more about making credentialed requests with cookies [here](https://svelte.dev/docs/kit/load#Cookies).
-		 */
-		readonly fetch: typeof fetch;
-		/**
-		 * The client's IP address, set by the adapter.
-		 */
-		readonly getClientAddress: () => string;
-		/**
-		 * Contains custom data that was added to the request within the [`server handle hook`](https://svelte.dev/docs/kit/hooks#handle).
-		 */
-		readonly locals: App.Locals;
-		/**
-		 * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
-		 *
-		 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
-		 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
-		 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
-		 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
-		 */
-		readonly params: Params;
-		/**
-		 * Additional data made available through the adapter.
-		 */
-		readonly platform: Readonly<App.Platform> | undefined;
-		/**
-		 * The original request object.
-		 */
-		readonly request: Request;
-		/**
-		 * Info about the current route.
-		 */
-		readonly route: {
-			/**
-			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
-			 *
-			 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
-			 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
-			 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
-			 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
-			 */
-			id: RouteId;
-		};
-		/**
-		 * If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
-		 *
-		 *	```js
-		 *	/// file: src/routes/blog/+page.js
-		 *	export async function load({ fetch, setHeaders }) {
-		 *		const url = `https://cms.example.com/articles.json`;
-		 *		const response = await fetch(url);
-		 *
-		 *		setHeaders({
-		 *			age: response.headers.get('age'),
-		 *			'cache-control': response.headers.get('cache-control')
-		 *		});
-		 *
-		 *		return response.json();
-		 *	}
-		 *	```
-		 *
-		 * Setting the same header multiple times (even in separate `load` functions) is an error — you can only set a given header once.
-		 *
-		 * You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](https://svelte.dev/docs/kit/@sveltejs-kit#Cookies) API instead.
-		 */
-		readonly setHeaders: (headers: Record<string, string>) => void;
-		/**
-		 * The requested URL.
-		 *
-		 * Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error.
-		 * Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page
-		 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
-		 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
-		 */
-		readonly url: URL;
-		/**
-		 * `true` if the request comes from the client asking for `+page/layout.server.js` data. The `url` property will be stripped of the internal information
-		 * related to the data request in this case. Use this property instead if the distinction is important to you.
-		 */
-		readonly isDataRequest: boolean;
-		/**
-		 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
-		 */
-		readonly isSubRequest: boolean;
-
-		/**
-		 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
-		 * @since 2.31.0
-		 */
-		readonly tracing: {
-			/** Whether tracing is enabled. */
-			enabled: boolean;
-			/** The root span for the request. This span is named `sveltekit.handle.root`. */
-			root: Span;
-			/** The span associated with the current `handle` hook, `load` function, or form action. */
-			current: Span;
-		};
-
-		/**
-		 * `true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
-		 * related to the data request in this case. Use this property instead if the distinction is important to you.
-		 */
-		readonly isRemoteRequest: boolean;
-	}
-
-	/**
-	 * A `(event: RequestEvent) => Response` function exported from a `+server.js` file that corresponds to an HTTP verb (`GET`, `PUT`, `PATCH`, etc) and handles requests with that method.
-	 *
-	 * It receives `Params` as the first generic argument, which you can skip by using [generated types](https://svelte.dev/docs/kit/types#Generated-types) instead.
-	 */
-	export type RequestHandler<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> = (event: RequestEvent<Params, RouteId>) => MaybePromise<Response>;
-
-	export interface ResolveOptions {
-		/**
-		 * Applies custom transforms to HTML. If `done` is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML
-		 * (they could include an element's opening tag but not its closing tag, for example)
-		 * but they will always be split at sensible boundaries such as `%sveltekit.head%` or layout/page components.
-		 * @param input the html chunk and the info if this is the last chunk
-		 */
-		transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
-		/**
-		 * Determines which headers should be included in serialized responses when a `load` function loads a resource with `fetch`.
-		 * By default, none will be included.
-		 * @param name header name
-		 * @param value header value
-		 */
-		filterSerializedResponseHeaders?: (name: string, value: string) => boolean;
-		/**
-		 * Determines which files should be preloaded. Files are preloaded via `<link>` tags added to the
-		 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
-		 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
-		 * By default, `js` and `css` files will be preloaded.
-		 * @param input the type of the file and its path
-		 */
-		preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
-	}
-
-	export interface RouteDefinition<Config = any> {
-		id: string;
-		api: {
-			methods: Array<HttpMethod | '*'>;
-		};
-		page: {
-			methods: Array<Extract<HttpMethod, 'GET' | 'POST'>>;
-		};
-		pattern: RegExp;
-		prerender: PrerenderOption;
-		segments: RouteSegment[];
-		methods: Array<HttpMethod | '*'>;
-		config: Config;
-	}
-
-	export class Server {
-		constructor(manifest: SSRManifest);
-		init(options: ServerInitOptions): Promise<void>;
-		respond(request: Request, options: RequestOptions): Promise<Response>;
-	}
-
-	export interface ServerInitOptions {
-		/** A map of environment variables. */
-		env: Record<string, string | undefined>;
-		/** A function that turns an asset filename into a `ReadableStream`. Required for the `read` export from `$app/server` to work. */
-		read?: (file: string) => MaybePromise<ReadableStream | null>;
-	}
-
-	/**
-	 * Information required to instantiate a new `Server` instance.
-	 */
-	export interface SSRManifest {
-		/** The directory where SvelteKit keeps its stuff, including static assets (such as JS and CSS) and internally-used routes. */
-		appDir: string;
-		/** The `base` and `appDir` settings combined without a leading slash. */
-		appPath: string;
-		/** Static files from `config.files.assets` and the service worker (if any). */
-		assets: Set<string>;
-		mimeTypes: Record<string, string>;
-	}
-
-	/**
-	 * The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](https://svelte.dev/docs/kit/types#Generated-types))
-	 * rather than using `ServerLoad` directly.
-	 */
-	export type ServerLoad<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		ParentData extends Record<string, any> = Record<string, any>,
-		OutputData extends Record<string, any> | void = Record<string, any> | void,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> = (event: ServerLoadEvent<Params, ParentData, RouteId>) => MaybePromise<OutputData>;
-
-	export interface ServerLoadEvent<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		ParentData extends Record<string, any> = Record<string, any>,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> extends RequestEvent<Params, RouteId> {
-		/**
-		 * `await parent()` returns data from parent `+layout.server.js` `load` functions.
-		 *
-		 * Be careful not to introduce accidental waterfalls when using `await parent()`. If for example you only want to merge parent data into the returned output, call it _after_ fetching your other data.
-		 */
-		parent: () => Promise<ParentData>;
-		/**
-		 * This function declares that the `load` function has a _dependency_ on one or more URLs or custom identifiers, which can subsequently be used with [`invalidate()`](https://svelte.dev/docs/kit/$app-navigation#invalidate) to cause `load` to rerun.
-		 *
-		 * Most of the time you won't need this, as `fetch` calls `depends` on your behalf — it's only necessary if you're using a custom API client that bypasses `fetch`.
-		 *
-		 * URLs can be absolute or relative to the page being loaded, and must be [encoded](https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding).
-		 *
-		 * Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the [URI specification](https://www.rfc-editor.org/rfc/rfc3986.html).
-		 *
-		 * The following example shows how to use `depends` to register a dependency on a custom identifier, which is `invalidate`d after a button click, making the `load` function rerun.
-		 *
-		 * ```js
-		 * /// file: src/routes/+page.js
-		 * let count = 0;
-		 * export async function load({ depends }) {
-		 * 	depends('increase:count');
-		 *
-		 * 	return { count: count++ };
-		 * }
-		 * ```
-		 *
-		 * ```html
-		 * /// file: src/routes/+page.svelte
-		 * <script>
-		 * 	import { invalidate } from '$app/navigation';
-		 *
-		 * 	let { data } = $props();
-		 *
-		 * 	const increase = async () => {
-		 * 		await invalidate('increase:count');
-		 * 	}
-		 * </script>
-		 *
-		 * <p>{data.count}<p>
-		 * <button on:click={increase}>Increase Count</button>
-		 * ```
-		 */
-		depends: (...deps: string[]) => void;
-		/**
-		 * Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example:
-		 *
-		 * ```js
-		 * /// file: src/routes/+page.js
-		 * export async function load({ untrack, url }) {
-		 * 	// Untrack url.pathname so that path changes don't trigger a rerun
-		 * 	if (untrack(() => url.pathname === '/')) {
-		 * 		return { message: 'Welcome!' };
-		 * 	}
-		 * }
-		 * ```
-		 */
-		untrack: <T>(fn: () => T) => T;
-
-		/**
-		 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
-		 * @since 2.31.0
-		 */
-		tracing: {
-			/** Whether tracing is enabled. */
-			enabled: boolean;
-			/** The root span for the request. This span is named `sveltekit.handle.root`. */
-			root: Span;
-			/** The span associated with the current server `load` function. */
-			current: Span;
-		};
-	}
-
-	/**
-	 * Shape of a form action method that is part of `export const actions = {...}` in `+page.server.js`.
-	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
-	 */
-	export type Action<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		OutputData extends Record<string, any> | void = Record<string, any> | void,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> = (event: RequestEvent<Params, RouteId>) => MaybePromise<OutputData>;
-
-	/**
-	 * Shape of the `export const actions = {...}` object in `+page.server.js`.
-	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
-	 */
-	export type Actions<
-		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
-		OutputData extends Record<string, any> | void = Record<string, any> | void,
-		RouteId extends AppRouteId | null = AppRouteId | null
-	> = Record<string, Action<Params, OutputData, RouteId>>;
-
-	/**
-	 * When calling a form action via fetch, the response will be one of these shapes.
-	 * ```svelte
-	 * <form method="post" use:enhance={() => {
-	 *   return ({ result }) => {
-	 * 		// result is of type ActionResult
-	 *   };
-	 * }}
-	 * ```
-	 *
-	 * Success and failure results carry the root-relative `pathname + search` of the action URL, with
-	 * the `?/actionName` parameter removed. Redirect results carry the redirect target. Server-generated
-	 * error results also carry the action location, while client-generated errors such as network
-	 * failures do not. `update` uses this location to emulate native form navigation.
-	 */
-	export type ActionResult<
-		Success extends Record<string, unknown> | undefined = Record<string, any>,
-		Failure extends Record<string, unknown> | undefined = Record<string, any>
-	> =
-		| { type: 'success'; status: number; data?: Success; location: string }
-		| { type: 'failure'; status: number; data?: Failure; location: string }
-		| { type: 'redirect'; status: number; location: string }
-		| { type: 'error'; status?: number; error: App.Error; location?: string };
-
-	/**
-	 * The object returned by the [`error`](https://svelte.dev/docs/kit/@sveltejs-kit#error) function.
-	 */
-	export interface HttpError {
-		/** The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses), in the range 400-599. */
-		status: number;
-		/** The content of the error. */
-		body: App.Error;
-	}
-
-	/**
-	 * The object returned by the [`redirect`](https://svelte.dev/docs/kit/@sveltejs-kit#redirect) function.
-	 */
-	export interface Redirect {
-		/** The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages), in the range 300-308. */
-		status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
-		/** The location to redirect to. */
-		location: string;
-	}
-
-	export type SubmitFunction<
-		Success extends Record<string, unknown> | undefined = Record<string, any>,
-		Failure extends Record<string, unknown> | undefined = Record<string, any>
-	> = (input: {
-		action: URL;
-		formData: FormData;
-		formElement: HTMLFormElement;
-		controller: AbortController;
-		submitter: HTMLElement | null;
-		cancel: () => void;
-	}) => MaybePromise<
-		| void
-		| ((opts: {
-				formData: FormData;
-				formElement: HTMLFormElement;
-				action: URL;
-				result: ActionResult<Success, Failure>;
-				/**
-				 * Call this to get the default behavior of a form submission response.
-				 * @param options Set `reset: false` if you don't want the `<form>` values to be reset after a successful submission. `refreshAll` defaults to `true` for successful results and `false` for failures. When the submission navigates, setting it to `false` still runs the destination's `load` functions but may reuse shared layout data. Set `navigate: false` to apply non-redirect results to the current page instead of navigating to `result.location`. Redirects are always followed.
-				 */
-				update: (options?: {
-					reset?: boolean;
-					refreshAll?: boolean;
-					navigate?: boolean;
-					/** @deprecated Use `refreshAll` instead. */
-					invalidateAll?: boolean;
-				}) => Promise<void>;
-		  }) => MaybePromise<void>)
-	>;
-
-	/**
-	 * The type of `export const snapshot` exported from a page or layout component.
-	 * @deprecated Use the [`snapshot`](https://svelte.dev/docs/kit/$app-navigation#snapshot) helper from `$app/navigation` instead.
+	 * The type of `export const snapshot` exported from a page or layout component.
+	 * @deprecated Use the [`snapshot`](https://svelte.dev/docs/kit/$app-navigation#snapshot) helper from `$app/navigation` instead.
 	 */
 	export interface Snapshot<T = any> {
 		capture: () => T;
 		restore: (snapshot: T) => void;
 	}
 
-	export type ReadonlyURLSearchParams = Omit<URLSearchParams, 'set' | 'append' | 'delete' | 'sort'>;
-
-	export type ReadonlyURL = Readonly<
-		Omit<URL, 'searchParams'> & {
-			searchParams: ReadonlyURLSearchParams;
-		}
-	>;
-
 	// 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;
 
@@ -2721,11 +2366,20 @@ declare module '@sveltejs/kit' {
 	type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
 	type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
 	type PrerenderUnseenRoutesHandlerValue =
-		'fail' | 'warn' | 'ignore' | PrerenderUnseenRoutesHandler;
+		| 'fail'
+		| 'warn'
+		| 'ignore'
+		| PrerenderUnseenRoutesHandler;
 	type PrerenderEntryGeneratorMismatchHandlerValue =
-		'fail' | 'warn' | 'ignore' | PrerenderEntryGeneratorMismatchHandler;
+		| 'fail'
+		| 'warn'
+		| 'ignore'
+		| PrerenderEntryGeneratorMismatchHandler;
 	type PrerenderInvalidUrlHandlerValue =
-		'fail' | 'warn' | 'ignore' | PrerenderInvalidUrlHandler;
+		| 'fail'
+		| 'warn'
+		| 'ignore'
+		| PrerenderInvalidUrlHandler;
 
 	export type PrerenderOption = boolean | 'auto';
 
@@ -2767,7 +2421,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * When called during request handling, this will cause SvelteKit to
-	 * return an error response without invoking `handleError`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
 	 * @param status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
 	 * @param message The error message.
@@ -2781,7 +2435,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * When called during request handling, this will cause SvelteKit to
-	 * return an error response without invoking `handleError`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
 	 * @param status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
 	 * @param message The error message.
@@ -2789,14 +2443,11 @@ declare module '@sveltejs/kit' {
 	 * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
 	 * @throws {Error} If the provided status is invalid (not between 400 and 599).
 	 */
-	export function error(status: number, message: string, properties: {
-		status: number;
-		message: string;
-	} extends App.Error ? never : Omit<App.Error, "status" | "message">): never;
+	export function error(status: number, message: string, properties: keyof Omit<App.Error, "status" | "message"> extends never ? never : Omit<App.Error, "status" | "message">): never;
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * When called during request handling, this will cause SvelteKit to
-	 * return an error response without invoking `handleError`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
 	 * @deprecated Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third
 	 * @param status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
@@ -2956,203 +2607,556 @@ declare module '@sveltejs/kit/env' {
 	export {};
 }
 
-declare module '@sveltejs/kit/hooks' {
-	import type { Handle } from '@sveltejs/kit';
+declare module '@sveltejs/kit/hooks' {
+	import type { Handle } from '@sveltejs/kit';
+	/**
+	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+	 * The behavior for the `handle` options is as follows:
+	 * - `transformPageChunk` is applied in reverse order and merged
+	 * - `preload` is applied in forward order, the first option "wins" and no `preload` options after it are called
+	 * - `filterSerializedResponseHeaders` behaves the same as `preload`
+	 *
+	 * ```js
+	 * /// file: src/hooks.server.js
+	 * import { sequence } from '@sveltejs/kit/hooks';
+	 *
+	 * /// type: import('@sveltejs/kit').Handle
+	 * async function first({ event, resolve }) {
+	 * 	console.log('first pre-processing');
+	 * 	const result = await resolve(event, {
+	 * 		transformPageChunk: ({ html }) => {
+	 * 			// transforms are applied in reverse order
+	 * 			console.log('first transform');
+	 * 			return html;
+	 * 		},
+	 * 		preload: () => {
+	 * 			// this one wins as it's the first defined in the chain
+	 * 			console.log('first preload');
+	 * 			return true;
+	 * 		}
+	 * 	});
+	 * 	console.log('first post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * /// type: import('@sveltejs/kit').Handle
+	 * async function second({ event, resolve }) {
+	 * 	console.log('second pre-processing');
+	 * 	const result = await resolve(event, {
+	 * 		transformPageChunk: ({ html }) => {
+	 * 			console.log('second transform');
+	 * 			return html;
+	 * 		},
+	 * 		preload: () => {
+	 * 			console.log('second preload');
+	 * 			return true;
+	 * 		},
+	 * 		filterSerializedResponseHeaders: () => {
+	 * 			// this one wins as it's the first defined in the chain
+	 * 			console.log('second filterSerializedResponseHeaders');
+	 * 			return true;
+	 * 		}
+	 * 	});
+	 * 	console.log('second post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * export const handle = sequence(first, second);
+	 * ```
+	 *
+	 * The example above would print:
+	 *
+	 * ```
+	 * first pre-processing
+	 * first preload
+	 * second pre-processing
+	 * second filterSerializedResponseHeaders
+	 * second transform
+	 * first transform
+	 * second post-processing
+	 * first post-processing
+	 * ```
+	 *
+	 * Calling `resolve` invokes the next handler in the sequence (or SvelteKit itself, if it is the last one). To pass data between handlers, use `event.locals`.
+	 *
+	 * @param handlers The chain of `handle` functions
+	 * */
+	export function sequence(...handlers: Handle[]): Handle;
+
+	export {};
+}
+
+declare module '@sveltejs/kit/node' {
+	export function getRequest({ request, base, bodySizeLimit }: {
+		request: import("http").IncomingMessage;
+		base: string;
+		bodySizeLimit?: number;
+	}): Request;
+
+	export function setResponse(res: import("http").ServerResponse, response: Response): void;
+	/**
+	 * Converts a file on disk to a readable stream
+	 * @since 2.4.0
+	 */
+	export function createReadableStream(file: string): ReadableStream;
+
+	export {};
+}
+
+declare module '@sveltejs/kit/params' {
+	import type { StandardSchemaV1 } from '@standard-schema/spec';
+	/**
+	 * The shape of a param matcher. See [matching](https://svelte.dev/docs/kit/advanced-routing#Matching) for more info.
+	 */
+	export type ParamMatcher<Output = any> = StandardSchemaV1<string, Output>;
+
+	/**
+	 * A value that can be parsed from a URL param and losslessly encoded with `String(...)`.
+	 */
+	export type ParamValue = string | number | boolean | bigint;
+
+	/**
+	 * A param matcher definition passed to [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
+	 */
+	export type ParamDefinition =
+		| ((param: string) => ParamValue | undefined)
+		| StandardSchemaV1<string, ParamValue>;
+
+	/**
+	 * The return type of [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
+	 */
+	export type DefinedParams<T extends Record<string, ParamDefinition>> = {
+		readonly [K in keyof T]: ParamEntry<T[K]>;
+	};
+
+	/**
+	 * Normalizes a property of defineParams (schema or function) to standard schema.
+	 */
+	type ParamEntry<M> =
+		M extends StandardSchemaV1<any, any>
+			? StandardSchemaV1.InferOutput<M> extends ParamValue
+				? StandardSchemaV1<any, M>
+				: StandardSchemaV1<any, never>
+			: M extends (param: string) => infer R
+				? Exclude<R, undefined> extends ParamValue
+					? StandardSchemaV1<any, Exclude<R, undefined>>
+					: StandardSchemaV1<any, never>
+				: never;
+
+	/**
+	 * Extracts the param type from a matcher.
+	 */
+	export type MatcherParam<M extends StandardSchemaV1<any, any>> =
+		M extends StandardSchemaV1<any, infer Inner>
+			? Inner extends ParamValue
+				? Inner
+				: Inner extends StandardSchemaV1<any, any>
+					? StandardSchemaV1.InferOutput<Inner> extends ParamValue
+						? StandardSchemaV1.InferOutput<Inner>
+						: never
+					: never
+			: never;
+
+	/**
+	 * Define [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching) for your app.
+	 *
+	 * */
+	export function defineParams<T extends Record<string, ParamDefinition>>(
+		definitions: T
+	): DefinedParams<T>;
+
+	export {};
+}
+
+declare module '@sveltejs/kit/vite' {
+	import type { KitConfig } from '@sveltejs/kit';
+	import type { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte';
+	import type { Plugin } from 'vite';
+	/**
+	 * Returns the SvelteKit Vite plugins.
+	 * Any options that don't belong to SvelteKit are passed through to `vite-plugin-svelte`.
+	 *
+	 * Since version 3.0.0 you must pass [configuration](configuration) directly.
+	 *
+	 * Since version 2.62.0 you can pass configuration directly, in which case `svelte.config.js` is ignored.
+	 *
+	 * */
+	export function sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>;
+
+	export {};
+}
+
+declare module '$app/env' {
+	/**
+	 * `true` if the app is running in the browser.
+	 */
+	export const browser: boolean;
+
+	/**
+	 * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
+	 */
+	export const dev: boolean;
+
+	/**
+	 * SvelteKit analyses your app during the `build` step by running it. During this process, `building` is `true`. This also applies during prerendering.
+	 */
+	export const building: boolean;
+
+	/**
+	 * The value of `config.version.name`.
+	 */
+	export const version: string;
+
+	export {};
+}
+
+declare module '$app/forms' {
 	/**
-	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
-	 * The behavior for the `handle` options is as follows:
-	 * - `transformPageChunk` is applied in reverse order and merged
-	 * - `preload` is applied in forward order, the first option "wins" and no `preload` options after it are called
-	 * - `filterSerializedResponseHeaders` behaves the same as `preload`
+	 * Use this function to deserialize the response from a form submission.
+	 * Usage:
 	 *
 	 * ```js
-	 * /// file: src/hooks.server.js
-	 * import { sequence } from '@sveltejs/kit/hooks';
+	 * import { deserialize } from '$app/forms';
 	 *
-	 * /// type: import('@sveltejs/kit').Handle
-	 * async function first({ event, resolve }) {
-	 * 	console.log('first pre-processing');
-	 * 	const result = await resolve(event, {
-	 * 		transformPageChunk: ({ html }) => {
-	 * 			// transforms are applied in reverse order
-	 * 			console.log('first transform');
-	 * 			return html;
-	 * 		},
-	 * 		preload: () => {
-	 * 			// this one wins as it's the first defined in the chain
-	 * 			console.log('first preload');
-	 * 			return true;
-	 * 		}
-	 * 	});
-	 * 	console.log('first post-processing');
-	 * 	return result;
-	 * }
+	 * async function handleSubmit(event) {
+	 *   const response = await fetch('/form?/action', {
+	 *     method: 'POST',
+	 *     body: new FormData(event.target)
+	 *   });
 	 *
-	 * /// type: import('@sveltejs/kit').Handle
-	 * async function second({ event, resolve }) {
-	 * 	console.log('second pre-processing');
-	 * 	const result = await resolve(event, {
-	 * 		transformPageChunk: ({ html }) => {
-	 * 			console.log('second transform');
-	 * 			return html;
-	 * 		},
-	 * 		preload: () => {
-	 * 			console.log('second preload');
-	 * 			return true;
-	 * 		},
-	 * 		filterSerializedResponseHeaders: () => {
-	 * 			// this one wins as it's the first defined in the chain
-	 * 			console.log('second filterSerializedResponseHeaders');
-	 * 			return true;
-	 * 		}
-	 * 	});
-	 * 	console.log('second post-processing');
-	 * 	return result;
+	 *   const result = deserialize(await response.text());
+	 *   // ...
 	 * }
-	 *
-	 * export const handle = sequence(first, second);
 	 * ```
+	 * */
+	export function deserialize<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: string): ActionResult<Success, Failure>;
+	/**
+	 * This action enhances a `<form>` element that otherwise would work without JavaScript.
 	 *
-	 * The example above would print:
+	 * The `submit` function is called upon submission with the given FormData and the `action` that should be triggered.
+	 * If `cancel` is called, the form will not be submitted.
+	 * You can use the abort `controller` to cancel the submission in case another one starts.
+	 * If a function is returned, that function is called with the response from the server.
+	 * If nothing is returned, the fallback will be used.
 	 *
-	 * ```
-	 * first pre-processing
-	 * first preload
-	 * second pre-processing
-	 * second filterSerializedResponseHeaders
-	 * second transform
-	 * first transform
-	 * second post-processing
-	 * first post-processing
-	 * ```
+	 * If this function or its return value isn't set, it emulates the browser-native behaviour, just without the full-page reload. It
+	 * - resets the `<form>` element and refreshes all data in case of a successful submission with no redirect response
+	 * - updates the `form` prop, `page.form` and `page.status` if the action is on the same page as the form
+	 * - navigates to the page the submission lands on — populating that page's `form` prop and `page.status` — on success and failure if that isn't the current page, just as a native form submission would, but with the `?/actionName` param stripped from the destination URL
+	 * - redirects in case of a redirect response
+	 * - renders the nearest error page in case of an unexpected error — the one nearest the action's route, if the action is on a different page
 	 *
-	 * Calling `resolve` invokes the next handler in the sequence (or SvelteKit itself, if it is the last one). To pass data between handlers, use `event.locals`.
+	 * If you provide a custom function with a callback and want to use the default behavior, invoke `update` in your callback.
+	 * It accepts an options object
+	 * - `reset: false` if you don't want the `<form>` values to be reset after a successful submission
+	 * - `refreshAll` to control whether all data is refreshed after submission; it defaults to `true` for successes and `false` for failures
+	 * - `navigate: false` to apply non-redirect results to the current page rather than navigating to `result.location`; redirects are always followed
+	 * @param form_element The form element
+	 * @param submit Submit callback
+	 */
+	export function enhance<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(form_element: HTMLFormElement, submit?: SubmitFunction<Success, Failure>): {
+		destroy(): void;
+	};
+	/**
+	 * When calling a form action via fetch, the response will be one of these shapes.
+	 * ```svelte
+	 * <form method="post" use:enhance={() => {
+	 *   return ({ result }) => {
+	 * 		// result is of type ActionResult
+	 *   };
+	 * }}
+	 * ```
 	 *
-	 * @param handlers The chain of `handle` functions
+	 * Success and failure results carry the root-relative `pathname + search` of the action URL, with
+	 * the `?/actionName` parameter removed. Redirect results carry the redirect target. Server-generated
+	 * error results also carry the action location, while client-generated errors such as network
+	 * failures do not. `update` uses this location to emulate native form navigation.
+	 */
+	export type ActionResult<
+		Success extends Record<string, unknown> | undefined = Record<string, any>,
+		Failure extends Record<string, unknown> | undefined = Record<string, any>
+	> =
+		| { type: 'success'; status: number; data?: Success; location: string }
+		| { type: 'failure'; status: number; data?: Failure; location: string }
+		| { type: 'redirect'; status: number; location: string }
+		| { type: 'error'; status?: number; error: App.Error; location?: string };
+
+	export type SubmitFunction<
+		Success extends Record<string, unknown> | undefined = Record<string, any>,
+		Failure extends Record<string, unknown> | undefined = Record<string, any>
+	> = (input: {
+		action: URL;
+		formData: FormData;
+		formElement: HTMLFormElement;
+		controller: AbortController;
+		submitter: HTMLElement | null;
+		cancel: () => void;
+	}) => MaybePromise<
+		| void
+		| ((opts: {
+				formData: FormData;
+				formElement: HTMLFormElement;
+				action: URL;
+				result: ActionResult<Success, Failure>;
+				/**
+				 * Call this to get the default behavior of a form submission response.
+				 * @param options Set `reset: false` if you don't want the `<form>` values to be reset after a successful submission. `refreshAll` defaults to `true` for successful results and `false` for failures. When the submission navigates, setting it to `false` still runs the destination's `load` functions but may reuse shared layout data. Set `navigate: false` to apply non-redirect results to the current page instead of navigating to `result.location`. Redirects are always followed.
+				 */
+				update: (options?: {
+					reset?: boolean;
+					refreshAll?: boolean;
+					navigate?: boolean;
+					/** @deprecated Use `refreshAll` instead. */
+					invalidateAll?: boolean;
+				}) => Promise<void>;
+		  }) => MaybePromise<void>)
+	>;
+	/**
+	 * Updates the `form` property of the current page with the given data and updates `page.status`.
+	 * In case of an error, it renders the nearest error page. In case of a redirect, it navigates to
+	 * the redirect location.
 	 * */
-	export function sequence(...handlers: Handle[]): Handle;
+	export function applyAction<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: ActionResult<Success, Failure>): Promise<void>;
+	type MaybePromise<T> = T | Promise<T>;
 
 	export {};
 }
 
-declare module '@sveltejs/kit/node' {
-	export function getRequest({ request, base, bodySizeLimit }: {
-		request: import("http").IncomingMessage;
-		base: string;
-		bodySizeLimit?: number;
-	}): Request;
+declare module '$app/navigation' {
+	import type { LayoutParams as AppLayoutParams, RouteId as AppRouteId } from '$app/types';
+	/**
+	 * Information about the target of a specific navigation.
+	 */
+	export interface NavigationTarget<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> {
+		/**
+		 * Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+		 * Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).
+		 */
+		params: Params | null;
+		/**
+		 * Info about the target route
+		 */
+		route: {
+			/**
+			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+			 */
+			id: RouteId | null;
+		};
+		/**
+		 * The URL that is navigated to
+		 */
+		url: URL;
+		/**
+		 * The scroll position associated with this navigation.
+		 *
+		 * For the `from` target, this is the scroll position at the moment of navigation.
+		 *
+		 * For the `to` target, this represents the scroll position that will be or was restored:
+		 * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
+		 *   and will be `null` for other navigation types, since the final scroll position isn't known
+		 *   ahead of time.
+		 * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
+		 *   completed.
+		 */
+		scroll: { x: number; y: number } | null;
+	}
+
+	export interface GotoOptions {
+		/**
+		 * If `true`, replaces the current history entry rather than creating a new one.
+		 * @default false
+		 */
+		replace?: boolean;
+		/** @deprecated Use `replace` instead. */
+		replaceState?: boolean;
+		/**
+		 * If `true`, updates the URL and `page.state` without navigating.
+		 * @default false
+		 */
+		shallow?: boolean;
+		/**
+		 * If `true`, resets the scroll position (to the top of the page, or to the element
+		 * matching the URL's `#hash` if there is one) and resets focus (to the `<body>`, or the
+		 * `autofocus` element if there is one) once the navigation completes.
+		 *
+		 * If `false`, the current scroll position and focused element are left alone.
+		 * @default true, or false when `shallow` is true
+		 */
+		reset?: boolean;
+		/**
+		 * If `true`, reruns all `load` functions and queries of the page.
+		 * @default false
+		 */
+		refreshAll?: boolean;
+		/** Causes any `load` functions to rerun if they depend on one of the URLs. */
+		invalidate?: Array<string | URL | ((url: URL) => boolean)>;
+		/** @deprecated Use `refreshAll` instead. */
+		invalidateAll?: boolean;
+		/** An optional object that will be available as `page.state`. */
+		state?: App.PageState;
+		/**
+		 * If `true`, `page.state` will be restored after a full page reload.
+		 * @default false
+		 */
+		persistState?: boolean;
+	}
+
+	/**
+	 * - `enter`: The app has hydrated/started
+	 * - `form`: The user submitted a `<form method="GET">`
+	 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+	 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+	 * - `link`: Navigation was triggered by a link click
+	 * - `popstate`: Navigation was triggered by back/forward navigation
+	 */
+	export type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
+
+	export interface NavigationBase {
+		/**
+		 * The type of navigation:
+		 * - `enter`: The app has hydrated/started
+		 * - `form`: The user submitted a `<form method="GET">`
+		 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+		 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+		 * - `link`: Navigation was triggered by a link click
+		 * - `popstate`: Navigation was triggered by back/forward navigation
+		 */
+		type: NavigationType;
+		/** Whether this is a shallow navigation. */
+		shallow: boolean;
+		/**
+		 * Where navigation was triggered from
+		 */
+		from: NavigationTarget | null;
+		/**
+		 * Where navigation is going to/has gone to
+		 */
+		to: NavigationTarget | null;
+		/**
+		 * Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation).
+		 */
+		willUnload: boolean;
+		/**
+		 * A promise that resolves once the navigation is complete, and rejects if the navigation
+		 * fails or is aborted. In the case of a `willUnload` navigation, the promise will never resolve
+		 */
+		complete: Promise<void>;
+	}
 
-	export function setResponse(res: import("http").ServerResponse, response: Response): void;
 	/**
-	 * Converts a file on disk to a readable stream
-	 * @since 2.4.0
+	 * The navigation that occurs when the app starts/hydrates
 	 */
-	export function createReadableStream(file: string): ReadableStream;
+	export interface NavigationEnter extends NavigationBase {
+		type: 'enter';
 
-	export {};
-}
+		/**
+		 * In case of a history back/forward navigation, the number of steps to go back/forward
+		 */
+		delta?: undefined;
 
-declare module '@sveltejs/kit/vite' {
-	import type { KitConfig } from '@sveltejs/kit';
-	import type { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte';
-	import type { Plugin } from 'vite';
-	/**
-	 * Returns the SvelteKit Vite plugins.
-	 * Any options that don't belong to SvelteKit are passed through to `vite-plugin-svelte`.
-	 *
-	 * Since version 3.0.0 you must pass [configuration](configuration) directly.
-	 *
-	 * Since version 2.62.0 you can pass configuration directly, in which case `svelte.config.js` is ignored.
-	 *
-	 * */
-	export function sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>;
+		/**
+		 * Dispatched `Event` object when navigation occurred by `popstate` or `link`.
+		 */
+		event?: undefined;
+	}
 
-	export {};
-}
+	export type NavigationExternal = NavigationGoto | NavigationLeave;
 
-declare module '$app/env' {
 	/**
-	 * `true` if the app is running in the browser.
+	 * A navigation triggered by a `goto(...)` call or a redirect
 	 */
-	export const browser: boolean;
+	export interface NavigationGoto extends NavigationBase {
+		type: 'goto';
+	}
 
 	/**
-	 * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
+	 * A navigation triggered by the tab being closed, or the user navigating to a different document
 	 */
-	export const dev: boolean;
+	export interface NavigationLeave extends NavigationBase {
+		type: 'leave';
+	}
 
 	/**
-	 * SvelteKit analyses your app during the `build` step by running it. During this process, `building` is `true`. This also applies during prerendering.
+	 * A navigation triggered by a `<form method="GET">`
 	 */
-	export const building: boolean;
+	export interface NavigationFormSubmit extends NavigationBase {
+		type: 'form';
+
+		/**
+		 * The `SubmitEvent` that caused the navigation
+		 */
+		event: SubmitEvent;
+	}
 
 	/**
-	 * The value of `config.version.name`.
+	 * A navigation triggered by back/forward navigation
 	 */
-	export const version: string;
+	export interface NavigationPopState extends NavigationBase {
+		type: 'popstate';
 
-	export {};
-}
+		/**
+		 * In case of a history back/forward navigation, the number of steps to go back/forward
+		 */
+		delta: number;
+
+		/**
+		 * The `PopStateEvent` that caused the navigation
+		 */
+		event: PopStateEvent;
+	}
 
-declare module '$app/forms' {
 	/**
-	 * Use this function to deserialize the response from a form submission.
-	 * Usage:
-	 *
-	 * ```js
-	 * import { deserialize } from '$app/forms';
-	 *
-	 * async function handleSubmit(event) {
-	 *   const response = await fetch('/form?/action', {
-	 *     method: 'POST',
-	 *     body: new FormData(event.target)
-	 *   });
-	 *
-	 *   const result = deserialize(await response.text());
-	 *   // ...
-	 * }
-	 * ```
-	 * */
-	export function deserialize<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: string): import("@sveltejs/kit").ActionResult<Success, Failure>;
+	 * A navigation triggered by a link click
+	 */
+	export interface NavigationLink extends NavigationBase {
+		type: 'link';
+
+		/**
+		 * The `PointerEvent` that caused the navigation
+		 */
+		event: PointerEvent;
+	}
+
+	export type Navigation =
+		| NavigationExternal
+		| NavigationFormSubmit
+		| NavigationPopState
+		| NavigationLink;
+
 	/**
-	 * This action enhances a `<form>` element that otherwise would work without JavaScript.
-	 *
-	 * The `submit` function is called upon submission with the given FormData and the `action` that should be triggered.
-	 * If `cancel` is called, the form will not be submitted.
-	 * You can use the abort `controller` to cancel the submission in case another one starts.
-	 * If a function is returned, that function is called with the response from the server.
-	 * If nothing is returned, the fallback will be used.
-	 *
-	 * If this function or its return value isn't set, it emulates the browser-native behaviour, just without the full-page reload. It
-	 * - resets the `<form>` element and refreshes all data in case of a successful submission with no redirect response
-	 * - updates the `form` prop, `page.form` and `page.status` if the action is on the same page as the form
-	 * - navigates to the page the submission lands on — populating that page's `form` prop and `page.status` — on success and failure if that isn't the current page, just as a native form submission would, but with the `?/actionName` param stripped from the destination URL
-	 * - redirects in case of a redirect response
-	 * - renders the nearest error page in case of an unexpected error — the one nearest the action's route, if the action is on a different page
-	 *
-	 * If you provide a custom function with a callback and want to use the default behavior, invoke `update` in your callback.
-	 * It accepts an options object
-	 * - `reset: false` if you don't want the `<form>` values to be reset after a successful submission
-	 * - `refreshAll` to control whether all data is refreshed after submission; it defaults to `true` for successes and `false` for failures
-	 * - `navigate: false` to apply non-redirect results to the current page rather than navigating to `result.location`; redirects are always followed
-	 * @param form_element The form element
-	 * @param submit Submit callback
+	 * The argument passed to [`beforeNavigate`](https://svelte.dev/docs/kit/$app-navigation#beforeNavigate) callbacks.
 	 */
-	export function enhance<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(form_element: HTMLFormElement, submit?: import("@sveltejs/kit").SubmitFunction<Success, Failure>): {
-		destroy(): void;
+	export type BeforeNavigate = Navigation & {
+		/**
+		 * Call this to prevent the navigation from starting.
+		 */
+		cancel: () => void;
 	};
-	/**
-	 * Updates the `form` property of the current page with the given data and updates `page.status`.
-	 * In case of an error, it renders the nearest error page. In case of a redirect, it navigates to
-	 * the redirect location.
-	 * */
-	export function applyAction<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: import("@sveltejs/kit").ActionResult<Success, Failure>): Promise<void>;
 
-	export {};
-}
+	/**
+	 * The argument passed to [`onNavigate`](https://svelte.dev/docs/kit/$app-navigation#onNavigate) callbacks.
+	 */
+	export type OnNavigate = Navigation & {
+		type: Exclude<NavigationType, 'enter' | 'leave'>;
+		/**
+		 * Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.
+		 */
+		willUnload: false;
+	};
 
-declare module '$app/navigation' {
-	import type { RouteId } from '$app/types';
+	/**
+	 * The argument passed to [`afterNavigate`](https://svelte.dev/docs/kit/$app-navigation#afterNavigate) callbacks.
+	 */
+	export type AfterNavigate = (Navigation | NavigationEnter) & {
+		type: Exclude<NavigationType, 'leave'>;
+		/**
+		 * Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page.
+		 */
+		willUnload: false;
+	};
 	/**
 	 * A lifecycle function that captures state before navigating and restores it when traversing history.
 	 *
@@ -3173,7 +3177,7 @@ declare module '$app/navigation' {
 	 *
 	 * `afterNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
 	 * */
-	export function afterNavigate(callback: (navigation: import("@sveltejs/kit").AfterNavigate) => void): void;
+	export function afterNavigate(callback: (navigation: AfterNavigate) => void): void;
 	/**
 	 * A navigation interceptor that triggers before we navigate to a URL, whether by clicking a link, calling `goto(...)`, or using the browser back/forward controls.
 	 *
@@ -3185,7 +3189,7 @@ declare module '$app/navigation' {
 	 *
 	 * `beforeNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
 	 * */
-	export function beforeNavigate(callback: (navigation: import("@sveltejs/kit").BeforeNavigate) => void): void;
+	export function beforeNavigate(callback: (navigation: BeforeNavigate) => void): void;
 	/**
 	 * A lifecycle function that runs the supplied `callback` immediately before we navigate to a new URL except during full-page navigations.
 	 *
@@ -3195,7 +3199,7 @@ declare module '$app/navigation' {
 	 *
 	 * `onNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
 	 * */
-	export function onNavigate(callback: (navigation: import("@sveltejs/kit").OnNavigate) => MaybePromise<(() => void) | void>): void;
+	export function onNavigate(callback: (navigation: OnNavigate) => MaybePromise<(() => void) | void>): void;
 	/**
 	 * If called when the page is being updated following a navigation (in `onMount` or `afterNavigate` or an action, for example), this disables SvelteKit's built-in scroll handling.
 	 * This is generally discouraged, since it breaks user expectations.
@@ -3213,7 +3217,7 @@ declare module '$app/navigation' {
 	 * @param url Where to navigate to. Note that if you've set [`config.paths.base`](https://svelte.dev/docs/kit/configuration#paths) and the URL is root-relative, you need to prepend the base path if you want to navigate within the app.
 	 * @param opts Options related to the navigation
 	 * */
-	export function goto(url: string | URL, opts?: import("@sveltejs/kit").GotoOptions): Promise<void>;
+	export function goto(url: string | URL, opts?: GotoOptions): Promise<void>;
 	/**
 	 * Causes any `load` functions belonging to the currently active page to re-run if they depend on the `url` in question, via `fetch` or `depends`. Returns a `Promise` that resolves when the page is subsequently updated.
 	 *
@@ -3290,7 +3294,7 @@ declare module '$app/navigation' {
 	 * Returns a Promise that resolves when the modules have been imported.
 	 *
 	 * */
-	export function preloadCode(id: RouteId): Promise<void>;
+	export function preloadCode(id: import("$app/types").RouteId): Promise<void>;
 	/**
 	 * Programmatically create a new history entry with the given `page.state`. Used for [shallow routing](https://svelte.dev/docs/kit/shallow-routing).
 	 *
@@ -3660,6 +3664,72 @@ declare module '$app/service-worker' {
 }
 
 declare module '$app/state' {
+	import type { LayoutParams as AppLayoutParams, ResolvedPathname, RouteId as AppRouteId } from '$app/types';
+	import type { Navigation } from '$app/navigation';
+	export type ReadonlyURLSearchParams = Omit<URLSearchParams, 'set' | 'append' | 'delete' | 'sort'>;
+
+	export type ReadonlyURL = Readonly<
+		Omit<URL, 'searchParams'> & {
+			searchParams: ReadonlyURLSearchParams;
+		}
+	>;
+
+	/**
+	 * The shape of the [`page`](https://svelte.dev/docs/kit/$app-state#page) reactive object.
+	 */
+	export interface Page<
+		Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+		RouteId extends AppRouteId | null = AppRouteId | null
+	> {
+		/**
+		 * The URL of the current page.
+		 */
+		url: ReadonlyURL & { readonly pathname: ResolvedPathname | (string & {}) };
+		/**
+		 * The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+		 */
+		params: Params;
+		/**
+		 * Info about the current route.
+		 */
+		route: {
+			/**
+			 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+			 */
+			id: RouteId;
+		};
+		/**
+		 * HTTP status code of the current page.
+		 */
+		status: number;
+		/**
+		 * The error object of the current page, if any. Filled from the `handleError` hooks.
+		 */
+		error: App.Error | null;
+		/**
+		 * The merged result of all data from all `load` functions on the current page. You can type a common denominator through `App.PageData`.
+		 */
+		data: App.PageData & Record<string, any>;
+		/**
+		 * The page state, which can be manipulated using [`goto`](https://svelte.dev/docs/kit/$app-navigation#goto) from `$app/navigation`.
+		 */
+		state: App.PageState;
+		/**
+		 * Information about the target of the current shallow navigation, or `null` if no shallow navigation has occurred.
+		 */
+		shallow: {
+			/** Parameters of the target route, or `null` if the URL does not resolve to a route. */
+			params: AppLayoutParams<'/'> | null;
+			/** Info about the target route, or `null` if the URL does not resolve to a route. */
+			route: { id: AppRouteId } | null;
+			/** The normalized URL passed to `goto(..., { shallow: true })`. */
+			url: ReadonlyURL;
+		} | null;
+		/**
+		 * Filled only after a form submission. See [form actions](https://svelte.dev/docs/kit/form-actions) for more info.
+		 */
+		form: any;
+	}
 	/**
 	 * A read-only reactive object with information about the current page, serving several use cases:
 	 * - retrieving the combined `data` of all pages/layouts anywhere in your component tree (also see [loading data](https://svelte.dev/docs/kit/load))
@@ -3696,12 +3766,12 @@ declare module '$app/state' {
 	 * On the server, values can only be read during rendering (in other words _not_ in e.g. `load` functions). In the browser, the values can be read at any time.
 	 *
 	 * */
-	export const page: import("@sveltejs/kit").Page;
+	export const page: Page;
 	/**
 	 * A read-only object representing an in-progress navigation, with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
 	 * Values are `null` when no navigation is occurring, or during server rendering.
 	 * */
-	export const navigating: import("@sveltejs/kit").Navigation | {
+	export const navigating: Navigation | {
 		from: null;
 		to: null;
 		type: null;
@@ -3744,7 +3814,7 @@ declare module '$app/state' {
  */
 declare namespace App {
 	/**
-	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Unexpected errors are handled by the `handleError` hooks which should return this shape.
+	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Every error passes through the `handleError` hooks, which must return this shape (with `status` and `message` optional, since they default to those of the caught error).
 	 */
 	export interface Error {
 		status: number;