@sveltejs/kit 1.0.0-next.253 → 1.0.0-next.257

package/assets/app/stores.js

@@ -33,7 +33,8 @@ const getStores = () => {
 				subscribe: stores.navigating.subscribe
 			};
 		},
-		session: stores.session
+		session: stores.session,
+		updated: stores.updated
 	};
 };
 
@@ -79,4 +80,18 @@ const session = {
 	update: () => throw_error('update')
 };
 
-export { getStores, navigating, page, session, stores };
+/** @type {typeof import('$app/stores').updated} */
+const updated = {
+	subscribe(fn) {
+		const store = getStores().updated;
+
+		if (browser) {
+			updated.check = store.check;
+		}
+
+		return store.subscribe(fn);
+	},
+	check: () => throw_error('check')
+};
+
+export { getStores, navigating, page, session, stores, updated };

package/assets/client/start.js

@@ -3,8 +3,8 @@ import { fallback, routes } from '__GENERATED__/manifest.js';
 import { onMount, tick } from 'svelte';
 import { g as get_base_uri } from '../chunks/utils.js';
 import { writable } from 'svelte/store';
+import { base, set_paths } from '../paths.js';
 import { init } from './singletons.js';
-import { set_paths } from '../paths.js';
 
 function scroll_state() {
 	return {
@@ -553,6 +553,56 @@ function notifiable_store(value) {
 	return { notify, set, subscribe };
 }
 
+function create_updated_store() {
+	const { set, subscribe } = writable(false);
+
+	const interval = +(
+		/** @type {string} */ (import.meta.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL)
+	);
+	const initial = import.meta.env.VITE_SVELTEKIT_APP_VERSION;
+
+	/** @type {NodeJS.Timeout} */
+	let timeout;
+
+	async function check() {
+		if (import.meta.env.DEV || import.meta.env.SSR) return false;
+
+		clearTimeout(timeout);
+
+		if (interval) timeout = setTimeout(check, interval);
+
+		const file = import.meta.env.VITE_SVELTEKIT_APP_VERSION_FILE;
+
+		const res = await fetch(`${base}/${file}`, {
+			headers: {
+				pragma: 'no-cache',
+				'cache-control': 'no-cache'
+			}
+		});
+
+		if (res.ok) {
+			const { version } = await res.json();
+			const updated = version !== initial;
+
+			if (updated) {
+				set(true);
+				clearTimeout(timeout);
+			}
+
+			return updated;
+		} else {
+			throw new Error(`Version check failed: ${res.status}`);
+		}
+	}
+
+	if (interval) timeout = setTimeout(check, interval);
+
+	return {
+		subscribe,
+		check
+	};
+}
+
 /**
  * @param {RequestInfo} resource
  * @param {RequestInit} [opts]
@@ -622,7 +672,8 @@ class Renderer {
 			url: notifiable_store({}),
 			page: notifiable_store({}),
 			navigating: writable(/** @type {Navigating | null} */ (null)),
-			session: writable(session)
+			session: writable(session),
+			updated: create_updated_store()
 		};
 
 		this.$session = null;
@@ -788,6 +839,12 @@ class Renderer {
 					location.href = new URL(navigation_result.redirect, location.href).href;
 				}
 
+				return;
+			}
+		} else if (navigation_result.props?.page?.status >= 400) {
+			const updated = await this.stores.updated.check();
+			if (updated) {
+				location.href = info.url.href;
 				return;
 			}
 		}

package/assets/server/index.js

@@ -413,6 +413,16 @@ function safe_not_equal(a, b) {
 Promise.resolve();
 
 const subscriber_queue = [];
+/**
+ * Creates a `Readable` store that allows reading by subscription.
+ * @param value initial value
+ * @param {StartStopNotifier}start start and stop notifications for subscriptions
+ */
+function readable(value, start) {
+    return {
+        subscribe: writable(value, start).subscribe
+    };
+}
 /**
  * Create a `Writable` store that allows both updating and reading by subscription.
  * @param {*=}value initial value
@@ -1015,11 +1025,16 @@ class Csp {
 
 // TODO rename this function/module
 
+const updated = {
+	...readable(false),
+	check: () => false
+};
+
 /**
  * @param {{
  *   branch: Array<import('./types').Loaded>;
- *   options: import('types/internal').SSRRenderOptions;
- *   state: import('types/internal').SSRRenderState;
+ *   options: import('types/internal').SSROptions;
+ *   state: import('types/internal').SSRState;
  *   $session: any;
  *   page_config: { hydrate: boolean, router: boolean };
  *   status: number;
@@ -1091,7 +1106,8 @@ async function render_response({
 			stores: {
 				page: writable(null),
 				navigating: writable(null),
-				session
+				session,
+				updated
 			},
 			page: {
 				url: state.prerender ? create_prerendering_url_proxy(url) : url,
@@ -1152,11 +1168,13 @@ async function render_response({
 		needs_nonce: options.template_contains_nonce
 	});
 
+	const target = hash(body);
+
 	// prettier-ignore
 	const init_app = `
 		import { start } from ${s(options.prefix + options.manifest._.entry.file)};
 		start({
-			target: ${options.target ? `document.querySelector(${s(options.target)})` : 'document.body'},
+			target: document.querySelector('[data-hydrate="${target}"]').parentNode,
 			paths: ${s(options.paths)},
 			session: ${try_serialize($session, (error) => {
 				throw new Error(`Failed to serialize session data: ${error.message}`);
@@ -1234,7 +1252,7 @@ async function render_response({
 				.map((dep) => `\n\t<link rel="modulepreload" href="${options.prefix + dep}">`)
 				.join('');
 
-			const attributes = ['type="module"'];
+			const attributes = ['type="module"', `data-hydrate="${target}"`];
 
 			csp.add_script(init_app);
 
@@ -1242,7 +1260,7 @@ async function render_response({
 				attributes.push(`nonce="${csp.nonce}"`);
 			}
 
-			head += `<script ${attributes.join(' ')}>${init_app}</script>`;
+			body += `\n\t\t<script ${attributes.join(' ')}>${init_app}</script>`;
 
 			// prettier-ignore
 			body += serialized_data
@@ -1252,7 +1270,7 @@ async function render_response({
 
 					return `<script ${attributes}>${json}</script>`;
 				})
-				.join('\n\n\t');
+				.join('\n\t');
 		}
 
 		if (options.service_worker) {
@@ -1449,8 +1467,8 @@ function is_root_relative(path) {
 /**
  * @param {{
  *   event: import('types/hooks').RequestEvent;
- *   options: import('types/internal').SSRRenderOptions;
- *   state: import('types/internal').SSRRenderState;
+ *   options: import('types/internal').SSROptions;
+ *   state: import('types/internal').SSRState;
  *   route: import('types/internal').SSRPage | null;
  *   url: URL;
  *   params: Record<string, string>;
@@ -1747,15 +1765,15 @@ async function load_node({
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
- * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
- * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ * @typedef {import('types/internal').SSROptions} SSROptions
+ * @typedef {import('types/internal').SSRState} SSRState
  */
 
 /**
  * @param {{
  *   event: import('types/hooks').RequestEvent;
- *   options: SSRRenderOptions;
- *   state: SSRRenderState;
+ *   options: SSROptions;
+ *   state: SSRState;
  *   $session: any;
  *   status: number;
  *   error: Error;
@@ -1832,15 +1850,15 @@ async function respond_with_error({ event, options, state, $session, status, err
 /**
  * @typedef {import('./types.js').Loaded} Loaded
  * @typedef {import('types/internal').SSRNode} SSRNode
- * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
- * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ * @typedef {import('types/internal').SSROptions} SSROptions
+ * @typedef {import('types/internal').SSRState} SSRState
  */
 
 /**
  * @param {{
  *   event: import('types/hooks').RequestEvent;
- *   options: SSRRenderOptions;
- *   state: SSRRenderState;
+ *   options: SSROptions;
+ *   state: SSRState;
  *   $session: any;
  *   route: import('types/internal').SSRPage;
  *   params: Record<string, string>;
@@ -2065,7 +2083,7 @@ async function respond$1(opts) {
 
 /**
  * @param {import('types/internal').SSRComponent} leaf
- * @param {SSRRenderOptions} options
+ * @param {SSROptions} options
  */
 function get_page_config(leaf, options) {
 	// TODO remove for 1.0
@@ -2098,8 +2116,8 @@ function with_cookies(response, set_cookie_headers) {
  * @param {import('types/hooks').RequestEvent} event
  * @param {import('types/internal').SSRPage} route
  * @param {RegExpExecArray} match
- * @param {import('types/internal').SSRRenderOptions} options
- * @param {import('types/internal').SSRRenderState} state
+ * @param {import('types/internal').SSROptions} options
+ * @param {import('types/internal').SSRState} state
  * @param {boolean} ssr
  * @returns {Promise<Response | undefined>}
  */
@@ -2196,6 +2214,7 @@ async function respond(request, options, state = {}) {
 		request,
 		url,
 		params: {},
+		// @ts-expect-error this picks up types that belong to the tests
 		locals: {},
 		platform: state.platform
 	};

package/dist/chunks/index.js

@@ -37,6 +37,8 @@ async function create_plugin(config, cwd) {
 		amp = (await import('./amp_hook.js')).handle;
 	}
 
+	process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = '0';
+
 	/** @type {import('types/internal').Respond} */
 	const respond = (await import(`${runtime}/server/index.js`)).respond;
 
@@ -183,6 +185,7 @@ async function create_plugin(config, cwd) {
 
 						/** @type {import('types/internal').Hooks} */
 						const hooks = {
+							// @ts-expect-error this picks up types that belong to the tests
 							getSession: user_hooks.getSession || (() => ({})),
 							handle: amp ? sequence(amp, handle) : handle,
 							handleError:
@@ -269,7 +272,6 @@ async function create_plugin(config, cwd) {
 							read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
 							root,
 							router: config.kit.browser.router,
-							target: config.kit.target,
 							template: ({ head, body, assets, nonce }) => {
 								return (
 									template

package/dist/chunks/index3.js

@@ -151,6 +151,10 @@ async function build_client({
 	output_dir,
 	client_entry_file
 }) {
+	process.env.VITE_SVELTEKIT_APP_VERSION = config.kit.version.name;
+	process.env.VITE_SVELTEKIT_APP_VERSION_FILE = `${config.kit.appDir}/version.json`;
+	process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = `${config.kit.version.pollInterval}`;
+
 	create_app({
 		manifest_data,
 		output: `${SVELTE_KIT}/generated`,
@@ -227,6 +231,11 @@ async function build_client({
 	const entry_css = new Set();
 	find_deps(entry, vite_manifest, entry_js, entry_css);
 
+	fs__default.writeFileSync(
+		`${client_out_dir}/version.json`,
+		JSON.stringify({ version: process.env.VITE_SVELTEKIT_APP_VERSION })
+	);
+
 	return {
 		assets,
 		chunks,
@@ -319,7 +328,6 @@ export class App {
 			root,
 			service_worker: ${has_service_worker ? "base + '/service-worker.js'" : 'null'},
 			router: ${s(config.kit.browser.router)},
-			target: ${s(config.kit.target)},
 			template,
 			template_contains_nonce: ${template.includes('%svelte.nonce%')},
 			trailing_slash: ${s(config.kit.trailingSlash)}
@@ -626,7 +634,7 @@ async function build(config) {
 	const build_data = {
 		app_dir: config.kit.appDir,
 		manifest_data: options.manifest_data,
-		service_worker: options.service_worker_entry_file ? 'service_worker.js' : null, // TODO make file configurable?
+		service_worker: options.service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 		client,
 		server,
 		static: options.manifest_data.assets.map((asset) => posixify(asset.file)),

package/dist/chunks/index5.js

@@ -311,6 +311,8 @@ function crawl(html) {
 									hrefs.push(src);
 								}
 							}
+						} else {
+							i -= 1;
 						}
 					}
 

package/dist/cli.js

@@ -684,10 +684,16 @@ const options = object(
 					`${keypath} has been removed — use the handle hook instead: https://kit.svelte.dev/docs#hooks-handle'`
 			),
 
-			target: string(null),
+			// TODO remove this for 1.0
+			target: error((keypath) => `${keypath} is no longer required, and should be removed`),
 
 			trailingSlash: list(['never', 'always', 'ignore']),
 
+			version: object({
+				name: string(Date.now().toString()),
+				pollInterval: number(0)
+			}),
+
 			vite: validate(
 				() => ({}),
 				(input, keypath) => {
@@ -989,7 +995,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.253');
+const prog = sade('svelte-kit').version('1.0.0-next.257');
 
 prog
 	.command('dev')
@@ -1147,7 +1153,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.253'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.257'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.253",
+  "version": "1.0.0-next.257",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/ambient-modules.d.ts

@@ -1,5 +1,12 @@
 /* eslint-disable import/no-duplicates */
 
+declare namespace App {
+	interface Locals {}
+	interface Platform {}
+	interface Session {}
+	interface Stuff {}
+}
+
 declare module '$app/env' {
 	/**
 	 * Whether or not app is in AMP mode.
@@ -106,10 +113,11 @@ declare module '$app/stores' {
 	 * A convenience function around `getContext` that returns `{ navigating, page, session }`.
 	 * Most of the time, you won't need to use it.
 	 */
-	export function getStores<Session = any>(): {
+	export function getStores(): {
 		navigating: typeof navigating;
 		page: typeof page;
-		session: Writable<Session>;
+		session: Writable<App.Session>;
+		updated: typeof updated;
 	};
 	/**
 	 * A readable store whose value contains page data.
@@ -131,7 +139,12 @@ declare module '$app/stores' {
 	 * A writable store whose initial value is whatever was returned from `getSession`.
 	 * It can be written to, but this will not cause changes to persist on the server — this is something you must implement yourself.
 	 */
-	export const session: Writable<any>;
+	export const session: Writable<App.Session>;
+	/**
+	 * A writable store indicating if the site was updated since the store was created.
+	 * It can be written to when custom logic is required to detect updates.
+	 */
+	export const updated: Readable<boolean> & { check: () => boolean };
 }
 
 declare module '$service-worker' {

package/types/config.d.ts

@@ -1,7 +1,7 @@
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import { UserConfig as ViteConfig } from 'vite';
 import { CspDirectives } from './csp';
-import { RecursiveRequired } from './helper';
+import { MaybePromise, RecursiveRequired } from './helper';
 import { HttpMethod, Logger, RouteSegment, TrailingSlash } from './internal';
 
 export interface RouteDefinition {
@@ -163,9 +163,12 @@ export interface Config {
 			register?: boolean;
 			files?: (filepath: string) => boolean;
 		};
-		target?: string;
 		trailingSlash?: TrailingSlash;
-		vite?: ViteConfig | (() => ViteConfig);
+		version?: {
+			name?: string;
+			pollInterval?: number;
+		};
+		vite?: ViteConfig | (() => MaybePromise<ViteConfig>);
 	};
 	preprocess?: any;
 }

package/types/endpoint.d.ts

@@ -1,7 +1,7 @@
 import { RequestEvent } from './hooks';
-import { Either, JSONString, MaybePromise, ResponseHeaders } from './helper';
+import { Either, JSONValue, MaybePromise, ResponseHeaders } from './helper';
 
-type Body = JSONString | Uint8Array | ReadableStream | import('stream').Readable;
+type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
 
 export interface EndpointOutput<Output extends Body = Body> {
 	status?: number;
@@ -13,12 +13,6 @@ export interface Fallthrough {
 	fallthrough: true;
 }
 
-export interface RequestHandler<
-	Locals = Record<string, any>,
-	Platform = Record<string, any>,
-	Output extends Body = Body
-> {
-	(event: RequestEvent<Locals, Platform>): MaybePromise<
-		Either<Response | EndpointOutput<Output>, Fallthrough>
-	>;
+export interface RequestHandler<Output extends Body = Body> {
+	(event: RequestEvent): MaybePromise<Either<Response | EndpointOutput<Output>, Fallthrough>>;
 }

package/types/helper.d.ts

@@ -1,13 +1,13 @@
-type ToJSON = { toJSON(...args: any[]): JSONValue };
-type JSONValue = Exclude<JSONString, ToJSON>;
-export type JSONString =
+type ToJSON = { toJSON(...args: any[]): Exclude<JSONValue, ToJSON> };
+
+export type JSONValue =
 	| string
 	| number
 	| boolean
 	| null
 	| ToJSON
-	| JSONString[]
-	| { [key: string]: JSONString };
+	| JSONValue[]
+	| { [key: string]: JSONValue };
 
 /** `string[]` is only for set-cookie, everything else must be type of `string` */
 export type ResponseHeaders = Record<string, string | string[]>;
@@ -16,9 +16,6 @@ export type ResponseHeaders = Record<string, string | string[]>;
 type Only<T, U> = { [P in keyof T]: T[P] } & { [P in Exclude<keyof U, keyof T>]?: never };
 
 export type Either<T, U> = Only<T, U> | Only<U, T>;
-export type InferValue<T, Key extends keyof T, Default> = T extends Record<Key, infer Val>
-	? Val
-	: Default;
 export type MaybePromise<T> = T | Promise<T>;
 export type RecursiveRequired<T> = {
 	// Recursive implementation of TypeScript's Required utility type.

package/types/hooks.d.ts

@@ -2,35 +2,31 @@ import { MaybePromise } from './helper';
 
 export type StrictBody = string | Uint8Array;
 
-export interface RequestEvent<Locals = Record<string, any>, Platform = Record<string, any>> {
+export interface RequestEvent {
 	request: Request;
 	url: URL;
 	params: Record<string, string>;
-	locals: Locals;
-	platform: Readonly<Platform>;
+	locals: App.Locals;
+	platform: Readonly<App.Platform>;
 }
 
-export interface GetSession<
-	Locals = Record<string, any>,
-	Platform = Record<string, any>,
-	Session = any
-> {
-	(event: RequestEvent<Locals, Platform>): MaybePromise<Session>;
+export interface GetSession {
+	(event: RequestEvent): MaybePromise<App.Session>;
 }
 
 export interface ResolveOpts {
 	ssr?: boolean;
 }
 
-export interface Handle<Locals = Record<string, any>, Platform = Record<string, any>> {
+export interface Handle {
 	(input: {
-		event: RequestEvent<Locals, Platform>;
-		resolve(event: RequestEvent<Locals, Platform>, opts?: ResolveOpts): MaybePromise<Response>;
+		event: RequestEvent;
+		resolve(event: RequestEvent, opts?: ResolveOpts): MaybePromise<Response>;
 	}): MaybePromise<Response>;
 }
 
-export interface HandleError<Locals = Record<string, any>> {
-	(input: { error: Error & { frame?: string }; event: RequestEvent<Locals> }): void;
+export interface HandleError {
+	(input: { error: Error & { frame?: string }; event: RequestEvent }): void;
 }
 
 export interface ExternalFetch {

package/types/internal.d.ts

@@ -119,7 +119,7 @@ export interface SSRNode {
 	styles?: Record<string, string>;
 }
 
-export interface SSRRenderOptions {
+export interface SSROptions {
 	amp: boolean;
 	csp: ValidatedConfig['kit']['csp'];
 	dev: boolean;
@@ -140,7 +140,6 @@ export interface SSRRenderOptions {
 	root: SSRComponent['default'];
 	router: boolean;
 	service_worker?: string;
-	target: string;
 	template({
 		head,
 		body,
@@ -156,7 +155,7 @@ export interface SSRRenderOptions {
 	trailing_slash: TrailingSlash;
 }
 
-export interface SSRRenderState {
+export interface SSRState {
 	fetched?: string;
 	initiator?: SSRPage | null;
 	platform?: any;
@@ -248,5 +247,5 @@ export interface MethodOverride {
 }
 
 export interface Respond {
-	(request: Request, options: SSRRenderOptions, state?: SSRRenderState): Promise<Response>;
+	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
 }

package/types/page.d.ts

@@ -1,85 +1,32 @@
 import { Fallthrough } from './endpoint';
-import { Either, InferValue, MaybePromise } from './helper';
+import { Either, MaybePromise } from './helper';
 
-export interface LoadInput<
-	PageParams extends Record<string, string> = Record<string, string>,
-	Stuff extends Record<string, any> = Record<string, any>,
-	Session = any
-> {
+export interface LoadInput<Params = Record<string, string>> {
 	url: URL;
-	params: PageParams;
+	params: Params;
 	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
-	session: Session;
-	stuff: Stuff;
+	session: App.Session;
+	stuff: Partial<App.Stuff>;
 }
 
-export interface ErrorLoadInput<
-	PageParams extends Record<string, string> = Record<string, string>,
-	Stuff extends Record<string, any> = Record<string, any>,
-	Session = any
-> extends LoadInput<PageParams, Stuff, Session> {
+export interface ErrorLoadInput<Params = Record<string, string>> extends LoadInput<Params> {
 	status?: number;
 	error?: Error;
 }
 
-export interface LoadOutput<
-	Props extends Record<string, any> = Record<string, any>,
-	Stuff extends Record<string, any> = Record<string, any>
-> {
+export interface LoadOutput<Props = Record<string, any>> {
 	status?: number;
 	error?: string | Error;
 	redirect?: string;
 	props?: Props;
-	stuff?: Stuff;
+	stuff?: Partial<App.Stuff>;
 	maxage?: number;
 }
 
-interface LoadInputExtends {
-	stuff?: Record<string, any>;
-	pageParams?: Record<string, string>;
-	session?: any;
+export interface Load<Params = Record<string, string>, Props = Record<string, any>> {
+	(input: LoadInput<Params>): MaybePromise<Either<Fallthrough, LoadOutput<Props>>>;
 }
 
-interface LoadOutputExtends {
-	stuff?: Record<string, any>;
-	props?: Record<string, any>;
-}
-
-export interface Load<
-	Input extends LoadInputExtends = Required<LoadInputExtends>,
-	Output extends LoadOutputExtends = Required<LoadOutputExtends>
-> {
-	(
-		input: LoadInput<
-			InferValue<Input, 'pageParams', Record<string, string>>,
-			InferValue<Input, 'stuff', Record<string, any>>,
-			InferValue<Input, 'session', any>
-		>
-	): MaybePromise<
-		Either<
-			Fallthrough,
-			LoadOutput<
-				InferValue<Output, 'props', Record<string, any>>,
-				InferValue<Output, 'stuff', Record<string, any>>
-			>
-		>
-	>;
-}
-
-export interface ErrorLoad<
-	Input extends LoadInputExtends = Required<LoadInputExtends>,
-	Output extends LoadOutputExtends = Required<LoadOutputExtends>
-> {
-	(
-		input: ErrorLoadInput<
-			InferValue<Input, 'pageParams', Record<string, string>>,
-			InferValue<Input, 'stuff', Record<string, any>>,
-			InferValue<Input, 'session', any>
-		>
-	): MaybePromise<
-		LoadOutput<
-			InferValue<Output, 'props', Record<string, any>>,
-			InferValue<Output, 'stuff', Record<string, any>>
-		>
-	>;
+export interface ErrorLoad<Params = Record<string, string>, Props = Record<string, any>> {
+	(input: ErrorLoadInput<Params>): MaybePromise<LoadOutput<Props>>;
 }