@sveltejs/kit 1.22.2 → 1.22.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.22.2",
+  "version": "1.22.4",
   "description": "The fastest way to build Svelte apps",
   "repository": {
     "type": "git",
@@ -32,14 +32,14 @@
     "@types/node": "^16.18.6",
     "@types/sade": "^1.7.4",
     "@types/set-cookie-parser": "^2.4.2",
-    "dts-buddy": "^0.0.10",
+    "dts-buddy": "^0.1.9",
     "marked": "^4.2.3",
     "rollup": "^3.7.0",
     "svelte": "^4.0.5",
     "svelte-preprocess": "^5.0.4",
     "typescript": "^4.9.4",
     "vite": "^4.4.2",
-    "vitest": "^0.32.2"
+    "vitest": "^0.33.0"
   },
   "peerDependencies": {
     "svelte": "^3.54.0 || ^4.0.0-next.0",
@@ -95,6 +95,7 @@
     "test:cross-platform:build": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:build",
     "test:unit": "vitest --config kit.vitest.config.js run",
     "postinstall": "node postinstall.js",
-    "generate:version": "node scripts/generate-version.js"
+    "generate:version": "node scripts/generate-version.js",
+    "generate:types": "node scripts/generate-dts.js"
   }
 }

package/src/core/adapt/builder.js

@@ -154,7 +154,7 @@ export function create_builder({
 			write(dest, fallback);
 		},
 
-		generateManifest: ({ relativePath, routes: subset }) => {
+		generateManifest({ relativePath, routes: subset }) {
 			return generate_manifest({
 				build_data,
 				relative_path: relativePath,
@@ -189,15 +189,7 @@ export function create_builder({
 			return Array.from(new Set([...server_assets, ...client_assets]));
 		},
 
-		// @ts-expect-error
-		writePrerendered(dest, opts) {
-			// TODO remove for 1.0
-			if (opts?.fallback) {
-				throw new Error(
-					'The fallback option no longer exists — use builder.generateFallback(fallback) instead'
-				);
-			}
-
+		writePrerendered(dest) {
 			const source = `${config.kit.outDir}/output/prerendered`;
 			return [...copy(`${source}/pages`, dest), ...copy(`${source}/dependencies`, dest)];
 		},

package/src/exports/public.d.ts

@@ -697,13 +697,13 @@ export interface LoadEvent<
 	/**
 	 * `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. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](https://kit.svelte.dev/docs/hooks#server-hooks-handle)
-	 * - during hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request
+	 * - 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://kit.svelte.dev/docs/hooks#server-hooks-handle)
+	 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
 	 *
-	 * > Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
+	 * You can learn more about making credentialed requests with cookies [here](https://kit.svelte.dev/docs/load#cookies)
 	 */
 	fetch: typeof fetch;
 	/**
@@ -949,11 +949,13 @@ export interface RequestEvent<
 	/**
 	 * `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
+	 * - 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://kit.svelte.dev/docs/hooks#server-hooks-handle)
+	 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
 	 *
-	 * > Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
+	 * You can learn more about making credentialed requests with cookies [here](https://kit.svelte.dev/docs/load#cookies)
 	 */
 	fetch: typeof fetch;
 	/**

package/src/exports/vite/index.js

@@ -545,7 +545,8 @@ function kit({ svelte_config }) {
 				// E.g. Vite generates `new URL('/asset.png', import.meta).href` for a relative path vs just '/asset.png'.
 				// That's larger and takes longer to run and also causes an HTML diff between SSR and client
 				// causing us to do a more expensive hydration check.
-				const client_base = kit.paths.relative || kit.paths.assets ? './' : kit.paths.base || '/';
+				const client_base =
+					kit.paths.relative !== false || kit.paths.assets ? './' : kit.paths.base || '/';
 
 				new_config = {
 					base: ssr ? assets_base(kit) : client_base,

package/src/runtime/server/fetch.js

@@ -51,7 +51,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 				}
 
 				if (url.origin !== event.url.origin) {
-					// allow cookie passthrough for "same-origin"
+					// Allow cookie passthrough for "credentials: same-origin" and "credentials: include"
 					// if SvelteKit is serving my.domain.com:
 					// -        domain.com WILL NOT receive cookies
 					// -     my.domain.com WILL receive cookies
@@ -59,6 +59,8 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					// - sub.my.domain.com WILL receive cookies
 					// ports do not affect the resolution
 					// leading dot prevents mydomain.com matching domain.com
+					// Do not forward other cookies for "credentials: include" because we don't know
+					// which cookie belongs to which domain (browser does not pass this info)
 					if (`.${url.hostname}`.endsWith(`.${event.url.hostname}`) && credentials !== 'omit') {
 						const cookie = get_cookie_header(url, request.headers.get('cookie'));
 						if (cookie) request.headers.set('cookie', cookie);

package/src/runtime/server/respond.js

@@ -440,6 +440,13 @@ export async function respond(request, options, manifest, state) {
 						?.split(',')
 						?.map((v) => v.trim().toLowerCase());
 					if (!(vary?.includes('accept') || vary?.includes('*'))) {
+						// the returned response might have immutable headers,
+						// so we have to clone them before trying to mutate them
+						response = new Response(response.body, {
+							status: response.status,
+							statusText: response.statusText,
+							headers: new Headers(response.headers)
+						});
 						response.headers.append('Vary', 'Accept');
 					}
 				}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '1.22.2';
+export const VERSION = '1.22.4';

package/types/index.d.ts

@@ -1,11 +1,9 @@
-declare module '@sveltejs/kit' {
-	import 'svelte'; // pick up `declare module "*.svelte"`
-	import 'vite/client';
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
 
-	import { CompileOptions } from 'svelte/types/compiler/interfaces';
+declare module '@sveltejs/kit' {
+	import type { CompileOptions } from 'svelte/types/compiler/interfaces';
 	import type { PluginOptions } from '@sveltejs/vite-plugin-svelte';
-	export { ActionFailure };
-
 	/**
 	 * [Adapters](https://kit.svelte.dev/docs/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
 	 */
@@ -16,7 +14,8 @@ declare module '@sveltejs/kit' {
 		name: string;
 		/**
 		 * This function is called after SvelteKit has built your app.
-		 * */
+		 * @param builder An object provided by SvelteKit that contains methods for adapting the app
+		 */
 		adapt(builder: Builder): MaybePromise<void>;
 	}
 
@@ -75,7 +74,9 @@ declare module '@sveltejs/kit' {
 
 		/**
 		 * Create separate functions that map to one or more routes of your app.
-		 * */
+		 * @param fn A function that groups a set of routes into an entry point
+		 * @deprecated Use `builder.routes` instead
+		 */
 		createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
 
 		/**
@@ -85,12 +86,14 @@ declare module '@sveltejs/kit' {
 
 		/**
 		 * Generate a server-side manifest to initialise the SvelteKit [server](https://kit.svelte.dev/docs/types#public-types-server) with.
-		 * */
+		 * @param opts a relative path to the base directory of the app and optionally in which format (esm or cjs) the manifest should be generated
+		 */
 		generateManifest(opts: { relativePath: string; routes?: RouteDefinition[] }): string;
 
 		/**
 		 * Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`.
-		 * */
+		 * @param name path to the file, relative to the build directory
+		 */
 		getBuildDirectory(name: string): string;
 		/** Get the fully resolved path to the directory containing client-side assets, including the contents of your `static` directory. */
 		getClientDirectory(): string;
@@ -101,19 +104,30 @@ declare module '@sveltejs/kit' {
 
 		/**
 		 * Write client assets to `dest`.
-		 * */
+		 * @param dest the destination folder
+		 * @returns an array of files written to `dest`
+		 */
 		writeClient(dest: string): string[];
 		/**
 		 * Write prerendered files to `dest`.
-		 * */
+		 * @param dest the destination folder
+		 * @returns an array of files written to `dest`
+		 */
 		writePrerendered(dest: string): string[];
 		/**
 		 * Write server-side code to `dest`.
-		 * */
+		 * @param dest the destination folder
+		 * @returns an array of files written to `dest`
+		 */
 		writeServer(dest: string): string[];
 		/**
 		 * Copy a file or directory.
-		 * */
+		 * @param from the source file or directory
+		 * @param to the destination file or directory
+		 * @param opts.filter a function to determine whether a file or directory should be copied
+		 * @param opts.replace a map of strings to replace
+		 * @returns an array of files that were copied
+		 */
 		copy(
 			from: string,
 			to: string,
@@ -125,7 +139,8 @@ declare module '@sveltejs/kit' {
 
 		/**
 		 * Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals.
-		 * */
+		 * @param directory The directory containing the files to be compressed
+		 */
 		compress(directory: string): Promise<void>;
 	}
 
@@ -161,12 +176,15 @@ declare module '@sveltejs/kit' {
 	export interface Cookies {
 		/**
 		 * Gets a cookie that was previously set with `cookies.set`, or from the request headers.
-		 * */
+		 * @param name the name of the cookie
+		 * @param opts the options, passed directly to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)
+		 */
 		get(name: string, opts?: import('cookie').CookieParseOptions): string | undefined;
 
 		/**
 		 * Gets all cookies that were previously set with `cookies.set`, or from the request headers.
-		 * */
+		 * @param opts the options, passed directily to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)
+		 */
 		getAll(opts?: import('cookie').CookieParseOptions): Array<{ name: string; value: string }>;
 
 		/**
@@ -175,14 +193,19 @@ declare module '@sveltejs/kit' {
 		 * The `httpOnly` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`.
 		 *
 		 * By default, the `path` of a cookie is the 'directory' of the current pathname. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app.
-		 * */
+		 * @param name the name of the cookie
+		 * @param value the cookie value
+		 * @param opts the options, passed directory to `cookie.serialize`. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+		 */
 		set(name: string, value: string, opts?: import('cookie').CookieSerializeOptions): void;
 
 		/**
 		 * Deletes a cookie by setting its value to an empty string and setting the expiry date in the past.
 		 *
 		 * By default, the `path` of a cookie is the 'directory' of the current pathname. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app.
-		 * */
+		 * @param name the name of the cookie
+		 * @param opts the options, passed directory to `cookie.serialize`. The `path` must match the path of the cookie you want to delete. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+		 */
 		delete(name: string, opts?: import('cookie').CookieSerializeOptions): void;
 
 		/**
@@ -192,7 +215,10 @@ declare module '@sveltejs/kit' {
 		 *
 		 * By default, the `path` of a cookie is the current pathname. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app.
 		 *
-		 * */
+		 * @param name the name of the cookie
+		 * @param value the cookie value
+		 * @param opts the options, passed directory to `cookie.serialize`. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+		 */
 		serialize(name: string, value: string, opts?: import('cookie').CookieSerializeOptions): string;
 	}
 
@@ -651,13 +677,13 @@ declare module '@sveltejs/kit' {
 		/**
 		 * `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. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](https://kit.svelte.dev/docs/hooks#server-hooks-handle)
-		 * - during hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request
+		 * - 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://kit.svelte.dev/docs/hooks#server-hooks-handle)
+		 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
 		 *
-		 * > Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
+		 * You can learn more about making credentialed requests with cookies [here](https://kit.svelte.dev/docs/load#cookies)
 		 */
 		fetch: typeof fetch;
 		/**
@@ -903,11 +929,13 @@ declare module '@sveltejs/kit' {
 		/**
 		 * `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
+		 * - 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://kit.svelte.dev/docs/hooks#server-hooks-handle)
+		 * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
 		 *
-		 * > Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
+		 * You can learn more about making credentialed requests with cookies [here](https://kit.svelte.dev/docs/load#cookies)
 		 */
 		fetch: typeof fetch;
 		/**
@@ -992,17 +1020,21 @@ declare module '@sveltejs/kit' {
 		 * 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 what should be added to the `<head>` tag to preload it.
 		 * 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;
 	}
 
@@ -1174,12 +1206,14 @@ declare module '@sveltejs/kit' {
 		action: URL;
 		/**
 		 * use `formData` instead of `data`
-		 * */
+		 * @deprecated
+		 */
 		data: FormData;
 		formData: FormData;
 		/**
 		 * use `formElement` instead of `form`
-		 * */
+		 * @deprecated
+		 */
 		form: HTMLFormElement;
 		formElement: HTMLFormElement;
 		controller: AbortController;
@@ -1190,19 +1224,22 @@ declare module '@sveltejs/kit' {
 		| ((opts: {
 				/**
 				 * use `formData` instead of `data`
-				 * */
+				 * @deprecated
+				 */
 				data: FormData;
 				formData: FormData;
 				/**
 				 * use `formElement` instead of `form`
-				 * */
+				 * @deprecated
+				 */
 				form: HTMLFormElement;
 				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.
+				 */
 				update(options?: { reset: boolean }): Promise<void>;
 		  }) => void)
 	>;
@@ -1214,7 +1251,7 @@ declare module '@sveltejs/kit' {
 		capture: () => T;
 		restore: (snapshot: T) => void;
 	}
-	export interface AdapterEntry {
+	interface AdapterEntry {
 		/**
 		 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
 		 * For example, `/foo/a-[b]` and `/foo/[c]` are different routes, but would both
@@ -1264,7 +1301,7 @@ declare module '@sveltejs/kit' {
 	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 	// SOFTWARE.
 
-	export namespace Csp {
+	namespace Csp {
 		type ActionSource = 'strict-dynamic' | 'report-sample';
 		type BaseSource =
 			| 'self'
@@ -1286,7 +1323,7 @@ declare module '@sveltejs/kit' {
 		type UriPath = `${HttpDelineator}${string}`;
 	}
 
-	export interface CspDirectives {
+	interface CspDirectives {
 		'child-src'?: Csp.Sources;
 		'default-src'?: Array<Csp.Source | Csp.ActionSource>;
 		'frame-src'?: Csp.Sources;
@@ -1330,16 +1367,16 @@ declare module '@sveltejs/kit' {
 		'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
 		'upgrade-insecure-requests'?: boolean;
 
-		
+		/** @deprecated */
 		'require-sri-for'?: Array<'script' | 'style' | 'script style'>;
 
-		
+		/** @deprecated */
 		'block-all-mixed-content'?: boolean;
 
-		
+		/** @deprecated */
 		'plugin-types'?: Array<`${string}/${string}` | 'none'>;
 
-		
+		/** @deprecated */
 		referrer?: Array<
 			| 'no-referrer'
 			| 'no-referrer-when-downgrade'
@@ -1353,9 +1390,9 @@ declare module '@sveltejs/kit' {
 		>;
 	}
 
-	export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';
+	type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';
 
-	export interface Logger {
+	interface Logger {
 		(msg: string): void;
 		success(msg: string): void;
 		error(msg: string): void;
@@ -1364,9 +1401,9 @@ declare module '@sveltejs/kit' {
 		info(msg: string): void;
 	}
 
-	export type MaybePromise<T> = T | Promise<T>;
+	type MaybePromise<T> = T | Promise<T>;
 
-	export interface Prerendered {
+	interface Prerendered {
 		/**
 		 * A map of `path` to `{ file }` objects, where a path like `/foo` corresponds to `foo.html` and a path like `/bar/` corresponds to `bar/index.html`.
 		 */
@@ -1401,7 +1438,7 @@ declare module '@sveltejs/kit' {
 		paths: string[];
 	}
 
-	export interface PrerenderHttpErrorHandler {
+	interface PrerenderHttpErrorHandler {
 		(details: {
 			status: number;
 			path: string;
@@ -1411,17 +1448,17 @@ declare module '@sveltejs/kit' {
 		}): void;
 	}
 
-	export interface PrerenderMissingIdHandler {
+	interface PrerenderMissingIdHandler {
 		(details: { path: string; id: string; referrers: string[]; message: string }): void;
 	}
 
-	export interface PrerenderEntryGeneratorMismatchHandler {
+	interface PrerenderEntryGeneratorMismatchHandler {
 		(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;
 	}
 
-	export type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
-	export type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
-	export type PrerenderEntryGeneratorMismatchHandlerValue =
+	type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
+	type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
+	type PrerenderEntryGeneratorMismatchHandlerValue =
 		| 'fail'
 		| 'warn'
 		| 'ignore'
@@ -1429,33 +1466,19 @@ declare module '@sveltejs/kit' {
 
 	export type PrerenderOption = boolean | 'auto';
 
-	export type PrerenderMap = Map<string, PrerenderOption>;
-
-	export interface RequestOptions {
+	interface RequestOptions {
 		getClientAddress(): string;
 		platform?: App.Platform;
 	}
 
-	export interface RouteSegment {
+	interface RouteSegment {
 		content: string;
 		dynamic: boolean;
 		rest: boolean;
 	}
 
-	export type TrailingSlash = 'never' | 'always' | 'ignore';
-	/**
-	 * This is a grotesque hack that, in dev, allows us to replace the implementations
-	 * of these classes that you'd get by importing them from `@sveltejs/kit` with the
-	 * ones that are imported via Vite and loaded internally, so that instanceof
-	 * checks work even though SvelteKit imports this module via Vite and consumers
-	 * import it via Node
-	 * */
-	function replace_implementations(implementations: {
-		ActionFailure: typeof ActionFailure;
-		HttpError: typeof HttpError;
-		Redirect: typeof Redirect;
-	}): void;
-	export class HttpError {
+	type TrailingSlash = 'never' | 'always' | 'ignore';
+	class HttpError_1 {
 		
 		constructor(status: number, body: {
 			message: string;
@@ -1464,47 +1487,25 @@ declare module '@sveltejs/kit' {
 		body: App.Error;
 		toString(): string;
 	}
-	export class Redirect {
+	class Redirect_1 {
 		
 		constructor(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string);
 		status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
 		location: string;
 	}
 
-	class ActionFailure<T extends Record<string, unknown> | undefined = undefined> {
+	export class ActionFailure<T extends Record<string, unknown> | undefined = undefined> {
 		
 		constructor(status: number, data?: T | undefined);
 		status: number;
 		data: T | undefined;
 	}
-	import { SvelteComponent } from 'svelte';
-
-	interface ServerModule {
-		Server: typeof InternalServer;
-	}
-
-	interface ServerInternalModule {
-		set_building(building: boolean): void;
-		set_assets(path: string): void;
-		set_private_env(environment: Record<string, string>): void;
-		set_public_env(environment: Record<string, string>): void;
-		set_version(version: string): void;
-		set_fix_stack_trace(fix_stack_trace: (stack: string) => string): void;
-	}
-
 	interface Asset {
 		file: string;
 		size: number;
 		type: string | null;
 	}
 
-	interface AssetDependencies {
-		file: string;
-		imports: string[];
-		stylesheets: string[];
-		fonts: string[];
-	}
-
 	interface BuildData {
 		app_dir: string;
 		app_path: string;
@@ -1520,61 +1521,6 @@ declare module '@sveltejs/kit' {
 		server_manifest: import('vite').Manifest;
 	}
 
-	interface CSRPageNode {
-		component: typeof SvelteComponent;
-		universal: {
-			load?: Load;
-			trailingSlash?: TrailingSlash;
-		};
-	}
-
-	type CSRPageNodeLoader = () => Promise<CSRPageNode>;
-
-	/**
-	 * Definition of a client side route.
-	 * The boolean in the tuples indicates whether the route has a server load.
-	 */
-	type CSRRoute = {
-		id: string;
-		exec(path: string): undefined | Record<string, string>;
-		errors: Array<CSRPageNodeLoader | undefined>;
-		layouts: Array<[has_server_load: boolean, node_loader: CSRPageNodeLoader] | undefined>;
-		leaf: [has_server_load: boolean, node_loader: CSRPageNodeLoader];
-	};
-
-	interface Deferred {
-		fulfil: (value: any) => void;
-		reject: (error: Error) => void;
-	}
-
-	type GetParams = (match: RegExpExecArray) => Record<string, string>;
-
-	interface ServerHooks {
-		handleFetch: HandleFetch;
-		handle: Handle;
-		handleError: HandleServerError;
-	}
-
-	interface ClientHooks {
-		handleError: HandleClientError;
-	}
-
-	interface Env {
-		private: Record<string, string>;
-		public: Record<string, string>;
-	}
-
-	class InternalServer extends Server {
-		init(options: ServerInitOptions): Promise<void>;
-		respond(
-			request: Request,
-			options: RequestOptions & {
-				prerendering?: PrerenderOptions;
-				read: (file: string) => Buffer;
-			}
-		): Promise<Response>;
-	}
-
 	interface ManifestData {
 		assets: Asset[];
 		nodes: PageNode[];
@@ -1595,17 +1541,6 @@ declare module '@sveltejs/kit' {
 		child_pages?: PageNode[];
 	}
 
-	interface PrerenderDependency {
-		response: Response;
-		body: null | string | Uint8Array;
-	}
-
-	interface PrerenderOptions {
-		cache?: string; // including this here is a bit of a hack, but it makes it easy to add <meta http-equiv>
-		fallback?: boolean;
-		dependencies: Map<string, PrerenderDependency>;
-	}
-
 	type RecursiveRequired<T> = {
 		// Recursive implementation of TypeScript's Required utility type.
 		// Will recursively continue until it reaches a primitive or Function
@@ -1614,8 +1549,6 @@ declare module '@sveltejs/kit' {
 			: T[K]; // Use the exact type for everything else
 	};
 
-	type RequiredResolveOptions = Required<ResolveOptions>;
-
 	interface RouteParam {
 		name: string;
 		matcher: string;
@@ -1652,85 +1585,6 @@ declare module '@sveltejs/kit' {
 		} | null;
 	}
 
-	type ServerRedirectNode = {
-		type: 'redirect';
-		location: string;
-	};
-
-	type ServerNodesResponse = {
-		type: 'data';
-		/**
-		 * If `null`, then there was no load function <- TODO is this outdated now with the recent changes?
-		 */
-		nodes: Array<ServerDataNode | ServerDataSkippedNode | ServerErrorNode | null>;
-	};
-
-	type ServerDataResponse = ServerRedirectNode | ServerNodesResponse;
-
-	/**
-	 * Signals a successful response of the server `load` function.
-	 * The `uses` property tells the client when it's possible to reuse this data
-	 * in a subsequent request.
-	 */
-	interface ServerDataNode {
-		type: 'data';
-		/**
-		 * The serialized version of this contains a serialized representation of any deferred promises,
-		 * which will be resolved later through chunk nodes.
-		 */
-		data: Record<string, any> | null;
-		uses: Uses;
-		slash?: TrailingSlash;
-	}
-
-	/**
-	 * Resolved data/error of a deferred promise.
-	 */
-	interface ServerDataChunkNode {
-		type: 'chunk';
-		id: number;
-		data?: Record<string, any>;
-		error?: any;
-	}
-
-	/**
-	 * Signals that the server `load` function was not run, and the
-	 * client should use what it has in memory
-	 */
-	interface ServerDataSkippedNode {
-		type: 'skip';
-	}
-
-	/**
-	 * Signals that the server `load` function failed
-	 */
-	interface ServerErrorNode {
-		type: 'error';
-		error: App.Error;
-		/**
-		 * Only set for HttpErrors
-		 */
-		status?: number;
-	}
-
-	interface ServerMetadataRoute {
-		config: any;
-		api: {
-			methods: HttpMethod[];
-		};
-		page: {
-			methods: Array<'GET' | 'POST'>;
-		};
-		methods: HttpMethod[];
-		prerender: PrerenderOption | undefined;
-		entries: Array<string> | undefined;
-	}
-
-	interface ServerMetadata {
-		nodes: Array<{ has_server_load: boolean }>;
-		routes: Map<string, ServerMetadataRoute>;
-	}
-
 	interface SSRComponent {
 		default: {
 			render(props: Record<string, any>): {
@@ -1786,31 +1640,6 @@ declare module '@sveltejs/kit' {
 
 	type SSRNodeLoader = () => Promise<SSRNode>;
 
-	interface SSROptions {
-		app_template_contains_nonce: boolean;
-		csp: ValidatedConfig['kit']['csp'];
-		csrf_check_origin: boolean;
-		track_server_fetches: boolean;
-		embedded: boolean;
-		env_public_prefix: string;
-		env_private_prefix: string;
-		hooks: ServerHooks;
-		preload_strategy: ValidatedConfig['kit']['output']['preloadStrategy'];
-		root: SSRComponent['default'];
-		service_worker: boolean;
-		templates: {
-			app(values: {
-				head: string;
-				body: string;
-				assets: string;
-				nonce: string;
-				env: Record<string, string>;
-			}): string;
-			error(values: { message: string; status: number }): string;
-		};
-		version_hash: string;
-	}
-
 	interface PageNodeIndexes {
 		errors: Array<number | undefined>;
 		layouts: Array<number | undefined>;
@@ -1835,59 +1664,34 @@ declare module '@sveltejs/kit' {
 		endpoint_id?: string;
 	}
 
-	interface SSRState {
-		fallback?: string;
-		getClientAddress(): string;
-		/**
-		 * True if we're currently attempting to render an error page
-		 */
-		error: boolean;
-		/**
-		 * Allows us to prevent `event.fetch` from making infinitely looping internal requests
-		 */
-		depth: number;
-		platform?: any;
-		prerendering?: PrerenderOptions;
-		/**
-		 * When fetching data from a +server.js endpoint in `load`, the page's
-		 * prerender option is inherited by the endpoint, unless overridden
-		 */
-		prerender_default?: PrerenderOption;
-		read?: (file: string) => Buffer;
-	}
-
-	type StrictBody = string | ArrayBufferView;
-
-	interface Uses {
-		dependencies: Set<string>;
-		params: Set<string>;
-		parent: boolean;
-		route: boolean;
-		url: boolean;
-	}
-
 	type ValidatedConfig = RecursiveRequired<Config>;
-
-	type ValidatedKitConfig = RecursiveRequired<KitConfig>;
-	export function error(status: number, body: App.Error): HttpError;
+	export function error(status: number, body: App.Error): HttpError_1;
 	export function error(status: number, body?: {
 		message: string;
-	} extends App.Error ? App.Error | string | undefined : never): HttpError;
+	} extends App.Error ? App.Error | string | undefined : never): HttpError_1;
 	/**
 	 * Create a `Redirect` object. If thrown during request handling, SvelteKit will return a redirect response.
 	 * Make sure you're not catching the thrown redirect, which would prevent SvelteKit from handling it.
-	 * */
-	export function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string): Redirect;
+	 * @param status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.
+	 * @param location The location to redirect to.
+	 */
+	export function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string): Redirect_1;
 	/**
 	 * Create a JSON `Response` object from the supplied data.
-	 * */
+	 * @param data The value that will be serialized as JSON.
+	 * @param init Options such as `status` and `headers` that will be added to the response. `Content-Type: application/json` and `Content-Length` headers will be added automatically.
+	 */
 	export function json(data: any, init?: ResponseInit | undefined): Response;
 	/**
 	 * Create a `Response` object from the supplied body.
-	 * */
+	 * @param body The value that will be used as-is.
+	 * @param init Options such as `status` and `headers` that will be added to the response. A `Content-Length` header will be added automatically.
+	 */
 	export function text(body: string, init?: ResponseInit | undefined): Response;
 	/**
 	 * Create an `ActionFailure` object.
+	 * @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 data Data associated with the failure (e.g. validation errors)
 	 * */
 	export function fail<T extends Record<string, unknown> | undefined = undefined>(status: number, data?: T | undefined): ActionFailure<T>;
 	/**
@@ -1973,6 +1777,7 @@ declare module '@sveltejs/kit/hooks' {
 	 * first post-processing
 	 * ```
 	 *
+	 * @param handlers The chain of `handle` functions
 	 * */
 	export function sequence(...handlers: import('@sveltejs/kit').Handle[]): import('@sveltejs/kit').Handle;
 }
@@ -2000,14 +1805,15 @@ declare module '@sveltejs/kit/node/polyfills' {
 }
 
 declare module '@sveltejs/kit/vite' {
+	export { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
 	/**
 	 * Returns the SvelteKit Vite plugins.
 	 * */
 	export function sveltekit(): Promise<import('vite').Plugin[]>;
-	export { vitePreprocess } from "@sveltejs/vite-plugin-svelte";
 }
 
 declare module '$app/environment' {
+	export { building, version } from '__sveltekit/environment';
 	/**
 	 * `true` if the app is running in the browser.
 	 */
@@ -2016,7 +1822,6 @@ declare module '$app/environment' {
 	 * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
 	 */
 	export const dev: boolean;
-	export { building, version } from "__sveltekit/environment";
 }
 
 declare module '$app/forms' {
@@ -2061,7 +1866,9 @@ declare module '$app/forms' {
 	 * - redirects to the nearest error page in case of an unexpected error
 	 *
 	 * If you provide a custom function with a callback and want to use the default behavior, invoke `update` in your callback.
-	 * */
+	 * @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?: import("@sveltejs/kit").SubmitFunction<Success, Failure>): {
 		destroy(): void;
 	};
@@ -2077,6 +1884,10 @@ declare module '$app/navigation' {
 	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified `url`.
 	 * For external URLs, use `window.location = url` instead of calling `goto(url)`.
 	 *
+	 * @param url Where to navigate to. Note that if you've set [`config.kit.paths.base`](https://kit.svelte.dev/docs/configuration#paths) and the URL is root-relative, you need to prepend the base path if you want to navigate within the app.
+	 * @param {Object} opts Options related to the navigation
+	 * @param invalidateAll If `true`, all `load` functions of the page will be rerun. See https://kit.svelte.dev/docs/load#rerunning-load-functions for more info on invalidation.
+	 * @param opts.state The state of the new/updated history entry
 	 * */
 	export const goto: (url: string | URL, opts?: {
 		replaceState?: boolean;
@@ -2100,6 +1911,7 @@ declare module '$app/navigation' {
 	 *
 	 * invalidate((url) => url.pathname === '/path');
 	 * ```
+	 * @param url The invalidated URL
 	 * */
 	export const invalidate: (url: string | URL | ((url: URL) => boolean)) => Promise<void>;
 	/**
@@ -2115,6 +1927,7 @@ declare module '$app/navigation' {
 	 * If the next navigation is to `href`, the values returned from load will be used, making navigation instantaneous.
 	 * Returns a Promise that resolves when the preload is complete.
 	 *
+	 * @param href Page to preload
 	 * */
 	export const preloadData: (href: string) => Promise<void>;
 	/**
@@ -2147,7 +1960,7 @@ declare module '$app/navigation' {
 }
 
 declare module '$app/paths' {
-	export { base, assets } from "__sveltekit/paths";
+	export { base, assets } from '__sveltekit/paths';
 }
 
 declare module '$app/stores' {

package/types/index.d.ts.map

@@ -40,6 +40,7 @@
 		"SubmitFunction",
 		"Snapshot",
 		"AdapterEntry",
+		"Csp",
 		"CspDirectives",
 		"HttpMethod",
 		"Logger",
@@ -52,57 +53,26 @@
 		"PrerenderMissingIdHandlerValue",
 		"PrerenderEntryGeneratorMismatchHandlerValue",
 		"PrerenderOption",
-		"PrerenderMap",
 		"RequestOptions",
 		"RouteSegment",
 		"TrailingSlash",
-		"replace_implementations",
 		"ActionFailure",
-		"ServerModule",
-		"ServerInternalModule",
 		"Asset",
-		"AssetDependencies",
 		"BuildData",
-		"CSRPageNode",
-		"CSRPageNodeLoader",
-		"CSRRoute",
-		"Deferred",
-		"GetParams",
-		"ServerHooks",
-		"ClientHooks",
-		"Env",
-		"InternalServer",
 		"ManifestData",
 		"PageNode",
-		"PrerenderDependency",
-		"PrerenderOptions",
 		"RecursiveRequired",
-		"RequiredResolveOptions",
 		"RouteParam",
 		"RouteData",
-		"ServerRedirectNode",
-		"ServerNodesResponse",
-		"ServerDataResponse",
-		"ServerDataNode",
-		"ServerDataChunkNode",
-		"ServerDataSkippedNode",
-		"ServerErrorNode",
-		"ServerMetadataRoute",
-		"ServerMetadata",
 		"SSRComponent",
 		"SSRComponentLoader",
 		"SSRNode",
 		"SSRNodeLoader",
-		"SSROptions",
 		"PageNodeIndexes",
 		"PrerenderEntryGenerator",
 		"SSREndpoint",
 		"SSRRoute",
-		"SSRState",
-		"StrictBody",
-		"Uses",
 		"ValidatedConfig",
-		"ValidatedKitConfig",
 		"redirect",
 		"json",
 		"text",
@@ -164,5 +134,5 @@
 		null,
 		null
 	],
-	"mappings": "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"
+	"mappings": "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"
 }