@sveltejs/kit 1.0.0-next.285 → 1.0.0-next.286

package/dist/chunks/index.js

@@ -144,6 +144,24 @@ async function create_plugin(config, cwd) {
 				};
 			}
 
+			/** @param {Error} error */
+			function fix_stack_trace(error) {
+				// TODO https://github.com/vitejs/vite/issues/7045
+
+				// ideally vite would expose ssrRewriteStacktrace, but
+				// in lieu of that, we can implement it ourselves. we
+				// don't want to mutate the error object, because
+				// the stack trace could be 'fixed' multiple times,
+				// and Vite will fix stack traces before we even
+				// see them if they occur during ssrLoadModule
+				const original = error.stack;
+				vite.ssrFixStacktrace(error);
+				const fixed = error.stack;
+				error.stack = original;
+
+				return fixed;
+			}
+
 			update_manifest();
 
 			vite.watcher.on('add', update_manifest);
@@ -248,13 +266,19 @@ async function create_plugin(config, cwd) {
 							dev: true,
 							floc: config.kit.floc,
 							get_stack: (error) => {
-								vite.ssrFixStacktrace(error);
-								return error.stack;
+								return fix_stack_trace(error);
 							},
 							handle_error: (error, event) => {
-								vite.ssrFixStacktrace(error);
 								hooks.handleError({
-									error,
+									error: new Proxy(error, {
+										get: (target, property) => {
+											if (property === 'stack') {
+												return fix_stack_trace(error);
+											}
+
+											return Reflect.get(target, property, target);
+										}
+									}),
 									event,
 
 									// TODO remove for 1.0

package/dist/cli.js

@@ -422,7 +422,7 @@ function get_mime_lookup(manifest_data) {
 	return mime;
 }
 
-/** @param {import('@sveltejs/kit').ValidatedConfig} config */
+/** @param {import('types').ValidatedConfig} config */
 function get_aliases(config) {
 	const alias = {
 		__GENERATED__: path__default.posix.resolve(`${SVELTE_KIT}/generated`),
@@ -998,7 +998,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.285');
+const prog = sade('svelte-kit').version('1.0.0-next.286');
 
 prog
 	.command('dev')
@@ -1156,7 +1156,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.285'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.286'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/dist/node.js

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
 
-/** @type {import('@sveltejs/kit/node').GetRawBody} */
+/** @param {import('http').IncomingMessage} req */
 function get_raw_body(req) {
 	return new Promise((fulfil, reject) => {
 		const h = req.headers;
@@ -50,7 +50,7 @@ function get_raw_body(req) {
 	});
 }
 
-/** @type {import('@sveltejs/kit/node').GetRequest} */
+/** @type {import('@sveltejs/kit/node').getRequest} */
 async function getRequest(base, req) {
 	let headers = /** @type {Record<string, string>} */ (req.headers);
 	if (req.httpVersionMajor === 2) {
@@ -69,9 +69,8 @@ async function getRequest(base, req) {
 	});
 }
 
-/** @type {import('@sveltejs/kit/node').SetResponse} */
+/** @type {import('@sveltejs/kit/node').setResponse} */
 async function setResponse(res, response) {
-	/** @type {import('types').ResponseHeaders} */
 	const headers = Object.fromEntries(response.headers);
 
 	if (response.headers.has('set-cookie')) {

package/package.json

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

package/types/ambient.d.ts

@@ -1,13 +1,52 @@
+/**
+ * It's possible to tell SvelteKit how to type objects inside your app by declaring the `App` namespace. By default, a new project will have a file called `src/app.d.ts` containing the following:
+ *
+ * ```ts
+ * /// <reference types="@sveltejs/kit" />
+ *
+ * declare namespace App {
+ * 	interface Locals {}
+ *
+ * 	interface Platform {}
+ *
+ * 	interface Session {}
+ *
+ * 	interface Stuff {}
+ * }
+ * ```
+ *
+ * By populating these interfaces, you will gain type safety when using `event.locals`, `event.platform`, `session` and `stuff`:
+ */
 declare namespace App {
-	interface Locals {}
-	interface Platform {}
-	interface Session {}
-	interface Stuff {}
+	/**
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](/docs/routing#endpoints).
+	 */
+	export interface Locals {}
+
+	/**
+	 * If your adapter provides [platform-specific context](/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
+	 */
+	export interface Platform {}
+
+	/**
+	 * The interface that defines `session`, both as an argument to [`load`](/docs/loading) functions and the value of the [session store](/docs/modules#$app-stores).
+	 */
+	export interface Session {}
+
+	/**
+	 * The interface that defines `stuff`, as input or output to [`load`](/docs/loading) or as the value of the `stuff` property of the [page store](/docs/modules#$app-stores).
+	 */
+	export interface Stuff {}
 }
 
+/**
+ * ```ts
+ * import { amp, browser, dev, mode, prerendering } from '$app/env';
+ * ```
+ */
 declare module '$app/env' {
 	/**
-	 * Whether or not app is in AMP mode.
+	 * Whether or not the app is running in [AMP mode](/docs/seo#manual-setup-amp).
 	 */
 	export const amp: boolean;
 	/**
@@ -30,14 +69,27 @@ declare module '$app/env' {
 	export const mode: string;
 }
 
+/**
+ * ```ts
+ * import {
+ * 	afterNavigate,
+ * 	beforeNavigate,
+ * 	disableScrollHandling,
+ * 	goto,
+ * 	invalidate,
+ * 	prefetch,
+ * 	prefetchRoutes
+ * } from '$app/navigation';
+ * ```
+ */
 declare module '$app/navigation' {
 	/**
-	 * Disable SvelteKit's built-in scroll handling for the current navigation, in case you need to manually control the scroll position.
+	 * If called when the page is being updated following a navigation (in `onMount` or an action, for example), this disables SvelteKit's built-in scroll handling.
 	 * This is generally discouraged, since it breaks user expectations.
 	 */
 	export function disableScrollHandling(): void;
 	/**
-	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified href.
+	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified `href`.
 	 *
 	 * @param href Where to navigate to
 	 * @param opts.replaceState If `true`, will replace the current `history` entry rather than creating a new one with `pushState`
@@ -48,12 +100,12 @@ declare module '$app/navigation' {
 	export function goto(
 		href: string,
 		opts?: { replaceState?: boolean; noscroll?: boolean; keepfocus?: boolean; state?: any }
-	): Promise<any>;
+	): Promise<void>;
 	/**
-	 * Returns a Promise that resolves when SvelteKit re-runs any current `load` functions that depend on `href`
+	 * Causes any `load` functions belonging to the currently active page to re-run if they `fetch` the resource in question. Returns a `Promise` that resolves when the page is subsequently updated.
 	 * @param href The invalidated resource
 	 */
-	export function invalidate(href: string): Promise<any>;
+	export function invalidate(href: string): Promise<void>;
 	/**
 	 * Programmatically prefetches the given page, which means
 	 *  1. ensuring that the code for the page is loaded, and
@@ -65,7 +117,7 @@ declare module '$app/navigation' {
 	 *
 	 * @param href Page to prefetch
 	 */
-	export function prefetch(href: string): Promise<any>;
+	export function prefetch(href: string): Promise<void>;
 	/**
 	 * Programmatically prefetches the code for routes that haven't yet been fetched.
 	 * Typically, you might call this to speed up subsequent navigation.
@@ -76,92 +128,108 @@ declare module '$app/navigation' {
 	 * Unlike prefetch, this won't call preload for individual pages.
 	 * Returns a Promise that resolves when the routes have been prefetched.
 	 */
-	export function prefetchRoutes(routes?: string[]): Promise<any>;
+	export function prefetchRoutes(routes?: string[]): Promise<void>;
 
 	/**
-	 * A navigation interceptor that triggers before we navigate to a new route.
+	 * A navigation interceptor that triggers before we navigate to a new URL (internal or external) whether by clicking a link, calling `goto`, or using the browser back/forward controls.
 	 * This is helpful if we want to conditionally prevent a navigation from completing or lookup the upcoming url.
 	 */
 	export function beforeNavigate(
-		fn: ({ from, to, cancel }: { from: URL; to: URL | null; cancel: () => void }) => void
-	): any;
+		fn: (navigation: { from: URL; to: URL | null; cancel: () => void }) => void
+	): void;
 
 	/**
 	 * A lifecycle function that runs when the page mounts, and also whenever SvelteKit navigates to a new URL but stays on this component.
 	 */
-	export function afterNavigate(fn: ({ from, to }: { from: URL | null; to: URL }) => void): any;
+	export function afterNavigate(fn: (navigation: { from: URL | null; to: URL }) => void): void;
 }
 
+/**
+ * ```ts
+ * import { base, assets } from '$app/paths';
+ * ```
+ */
 declare module '$app/paths' {
 	/**
-	 * A root-relative (i.e. begins with a `/`) string that matches `config.kit.paths.base` in your project configuration.
+	 * A string that matches [`config.kit.paths.base`](/docs/configuration#paths). It must begin, but not end, with a `/`.
 	 */
-	export const base: string;
+	export const base: `/${string}`;
 	/**
-	 * A root-relative or absolute path that matches `config.kit.paths.assets` (after it has been resolved against base).
+	 * An absolute path that matches [`config.kit.paths.assets`](/docs/configuration#paths).
+	 *
+	 * > If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during [`svelte-kit dev`](/docs/cli#svelte-kit-dev) or [`svelte-kit preview`](/docs/cli#svelte-kit-preview), since the assets don't yet live at their eventual URL.
 	 */
-	export const assets: string;
+	export const assets: `https://${string}` | `http://${string}`;
 }
 
+/**
+ * ```ts
+ * import { getStores, navigating, page, session, updated } from '$app/stores';
+ * ```
+ *
+ * Stores are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `session` and `page` are unique to each request on the server, rather than shared between multiple requests handled by the same server simultaneously, which is what makes it safe to include user-specific data in `session`.
+ *
+ * Because of that, you must subscribe to the stores during component initialization (which happens automatically if you reference the store value, e.g. as `$page`, in a component) before you can use them.
+ */
 declare module '$app/stores' {
 	import { Readable, Writable } from 'svelte/store';
-	type Navigating = { from: URL; to: URL };
+	import { Navigation, Page } from '@sveltejs/kit';
 
 	/**
-	 * A convenience function around `getContext` that returns `{ navigating, page, session }`.
-	 * Most of the time, you won't need to use it.
+	 * A convenience function around `getContext`. Must be called during component initialization.
+	 * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
 	 */
 	export function getStores(): {
 		navigating: typeof navigating;
 		page: typeof page;
-		session: Writable<App.Session>;
+		session: typeof session;
 		updated: typeof updated;
 	};
+
 	/**
 	 * A readable store whose value contains page data.
 	 */
-	export const page: Readable<{
-		url: URL;
-		params: Record<string, string>;
-		stuff: App.Stuff;
-		status: number;
-		error: Error | null;
-	}>;
+	export const page: Readable<Page>;
 	/**
 	 * A readable store.
-	 * When navigating starts, its value is `{ from: URL, to: URL }`
+	 * When navigating starts, its value is `{ from: URL, to: URL }`,
 	 * When navigating finishes, its value reverts to `null`.
 	 */
-	export const navigating: Readable<Navigating | null>;
+	export const navigating: Readable<Navigation | null>;
 	/**
-	 * A writable store whose initial value is whatever was returned from `getSession`.
+	 * A writable store whose initial value is whatever was returned from [`getSession`](/docs/hooks#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<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.
+	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
 	 */
 	export const updated: Readable<boolean> & { check: () => boolean };
 }
 
+/**
+ * This is a simple alias to `src/lib`, or whatever directory is specified as [`config.kit.files.lib`](/docs/configuration#files). It allows you to access common components and utility modules without `../../../../` nonsense.
+ */
+declare module '$lib' {}
+
+/**
+ * ```ts
+ * import { build, files, timestamp } from '$service-worker';
+ * ```
+ *
+ * This module is only available to [service workers](/docs/service-workers).
+ */
 declare module '$service-worker' {
 	/**
 	 * An array of URL strings representing the files generated by Vite, suitable for caching with `cache.addAll(build)`.
-	 * This is only available to service workers.
 	 */
 	export const build: string[];
 	/**
-	 * An array of URL strings representing the files in your static directory,
-	 * or whatever directory is specified by `config.kit.files.assets`.
-	 * This is only available to service workers.
+	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.kit.files.assets`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](/docs/configuration)
 	 */
 	export const files: string[];
 	/**
-	 * The result of calling `Date.now()` at build time.
-	 * It's useful for generating unique cache names inside your service worker,
-	 * so that a later deployment of your app can invalidate old caches.
-	 * This is only available to service workers.
+	 * The result of calling `Date.now()` at build time. It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
 	 */
 	export const timestamp: number;
 }
@@ -170,33 +238,48 @@ declare module '@sveltejs/kit/hooks' {
 	import { Handle } from '@sveltejs/kit';
 
 	/**
-	 * Utility function that allows chaining `handle` functions in a
-	 * middleware-like manner.
+	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+	 *
+	 * ```js
+	 * /// file: src/hooks.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);
+	 * 	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);
+	 * 	console.log('second post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * export const handle = sequence(first, second);
+	 * ```
+	 *
+	 * The example above would print:
+	 *
+	 * ```
+	 * first pre-processing
+	 * second pre-processing
+	 * second post-processing
+	 * first post-processing
+	 * ```
 	 *
 	 * @param handlers The chain of `handle` functions
 	 */
 	export function sequence(...handlers: Handle[]): Handle;
 }
 
-declare module '@sveltejs/kit/node' {
-	import { IncomingMessage, ServerResponse } from 'http';
-
-	export interface GetRawBody {
-		(request: IncomingMessage): Promise<Uint8Array | null>;
-	}
-	export const getRawBody: GetRawBody;
-
-	export interface GetRequest {
-		(base: string, request: IncomingMessage): Promise<Request>;
-	}
-	export const getRequest: GetRequest;
-
-	export interface SetResponse {
-		(res: ServerResponse, response: Response): void;
-	}
-	export const setResponse: SetResponse;
-}
-
+/**
+ * A polyfill for `fetch` and its related interfaces, used by adapters for environments that don't provide a native implementation.
+ */
 declare module '@sveltejs/kit/install-fetch' {
 	import fetch, { Headers, Request, Response } from 'node-fetch';
 
@@ -204,3 +287,14 @@ declare module '@sveltejs/kit/install-fetch' {
 
 	export { fetch, Headers, Request, Response };
 }
+
+/**
+ * Utilities used by adapters for Node-like environments.
+ */
+declare module '@sveltejs/kit/node' {
+	export function getRequest(
+		base: string,
+		request: import('http').IncomingMessage
+	): Promise<Request>;
+	export function setResponse(res: import('http').ServerResponse, response: Response): void;
+}

package/types/index.d.ts

@@ -5,82 +5,27 @@ import './ambient';
 
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
-	AdapterEntry,
 	Body,
+	Builder,
+	CspDirectives,
 	Either,
+	EndpointOutput,
+	ErrorLoadInput,
 	Fallthrough,
-	Logger,
+	LoadInput,
+	LoadOutput,
 	MaybePromise,
 	PrerenderOnErrorValue,
-	RecursiveRequired,
-	RequiredResolveOptions,
-	ResponseHeaders,
-	RouteDefinition,
-	SSRNodeLoader,
-	SSRRoute,
+	RequestEvent,
+	ResolveOptions,
 	TrailingSlash
-} from './internal';
+} from './private';
 
 export interface Adapter {
 	name: string;
 	adapt(builder: Builder): Promise<void>;
 }
 
-export interface Builder {
-	log: Logger;
-	rimraf(dir: string): void;
-	mkdirp(dir: string): void;
-
-	appDir: string;
-	trailingSlash: TrailingSlash;
-
-	/**
-	 * Create entry points that map to individual functions
-	 * @param fn A function that groups a set of routes into an entry point
-	 */
-	createEntries(fn: (route: RouteDefinition) => AdapterEntry): void;
-
-	generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
-
-	getBuildDirectory(name: string): string;
-	getClientDirectory(): string;
-	getServerDirectory(): string;
-	getStaticDirectory(): string;
-
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeClient(dest: string): string[];
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeServer(dest: string): string[];
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeStatic(dest: string): string[];
-	/**
-	 * @param from the source file or folder
-	 * @param to the destination file or folder
-	 * @param opts.filter a function to determine whether a file or folder should be copied
-	 * @param opts.replace a map of strings to replace
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	copy(
-		from: string,
-		to: string,
-		opts?: {
-			filter?: (basename: string) => boolean;
-			replace?: Record<string, string>;
-		}
-	): string[];
-
-	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<Prerendered>;
-}
-
 export interface Config {
 	compilerOptions?: CompileOptions;
 	extensions?: string[];
@@ -142,129 +87,10 @@ export interface Config {
 	preprocess?: any;
 }
 
-// Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
-//
-// MIT License
-//
-// Copyright (c) 2021-present, Joshua Hemphill
-// Copyright (c) 2021, Tecnico Corporation
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-export namespace Csp {
-	type ActionSource = 'strict-dynamic' | 'report-sample';
-	type BaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'none';
-	type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
-	type FrameSource = HostSource | SchemeSource | 'self' | 'none';
-	type HostNameScheme = `${string}.${string}` | 'localhost';
-	type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
-	type HostProtocolSchemes = `${string}://` | '';
-	type HttpDelineator = '/' | '?' | '#' | '\\';
-	type PortScheme = `:${number}` | '' | ':*';
-	type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
-	type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
-	type Sources = Source[];
-	type UriPath = `${HttpDelineator}${string}`;
-}
-
-export type CspDirectives = {
-	'child-src'?: Csp.Sources;
-	'default-src'?: Array<Csp.Source | Csp.ActionSource>;
-	'frame-src'?: Csp.Sources;
-	'worker-src'?: Csp.Sources;
-	'connect-src'?: Csp.Sources;
-	'font-src'?: Csp.Sources;
-	'img-src'?: Csp.Sources;
-	'manifest-src'?: Csp.Sources;
-	'media-src'?: Csp.Sources;
-	'object-src'?: Csp.Sources;
-	'prefetch-src'?: Csp.Sources;
-	'script-src'?: Array<Csp.Source | Csp.ActionSource>;
-	'script-src-elem'?: Csp.Sources;
-	'script-src-attr'?: Csp.Sources;
-	'style-src'?: Array<Csp.Source | Csp.ActionSource>;
-	'style-src-elem'?: Csp.Sources;
-	'style-src-attr'?: Csp.Sources;
-	'base-uri'?: Array<Csp.Source | Csp.ActionSource>;
-	sandbox?: Array<
-		| 'allow-downloads-without-user-activation'
-		| 'allow-forms'
-		| 'allow-modals'
-		| 'allow-orientation-lock'
-		| 'allow-pointer-lock'
-		| 'allow-popups'
-		| 'allow-popups-to-escape-sandbox'
-		| 'allow-presentation'
-		| 'allow-same-origin'
-		| 'allow-scripts'
-		| 'allow-storage-access-by-user-activation'
-		| 'allow-top-navigation'
-		| 'allow-top-navigation-by-user-activation'
-	>;
-	'form-action'?: Array<Csp.Source | Csp.ActionSource>;
-	'frame-ancestors'?: Array<Csp.HostSource | Csp.SchemeSource | Csp.FrameSource>;
-	'navigate-to'?: Array<Csp.Source | Csp.ActionSource>;
-	'report-uri'?: Csp.UriPath[];
-	'report-to'?: string[];
-
-	'require-trusted-types-for'?: Array<'script'>;
-	'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'
-		| 'origin'
-		| 'origin-when-cross-origin'
-		| 'same-origin'
-		| 'strict-origin'
-		| 'strict-origin-when-cross-origin'
-		| 'unsafe-url'
-		| 'none'
-	>;
-};
-
-export interface EndpointOutput<Output extends Body = Body> {
-	status?: number;
-	headers?: Headers | Partial<ResponseHeaders>;
-	body?: Output;
-}
-
 export interface ErrorLoad<Params = Record<string, string>, Props = Record<string, any>> {
 	(input: ErrorLoadInput<Params>): MaybePromise<LoadOutput<Props>>;
 }
 
-export interface ErrorLoadInput<Params = Record<string, string>> extends LoadInput<Params> {
-	status?: number;
-	error?: Error;
-}
-
 export interface ExternalFetch {
 	(req: Request): Promise<Response>;
 }
@@ -288,105 +114,27 @@ export interface Load<Params = Record<string, string>, Props = Record<string, an
 	(input: LoadInput<Params>): MaybePromise<Either<Fallthrough, LoadOutput<Props>>>;
 }
 
-export interface LoadInput<Params = Record<string, string>> {
+export interface Page<Params extends Record<string, string> = Record<string, string>> {
 	url: URL;
 	params: Params;
-	props: Record<string, any>;
-	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
-	session: App.Session;
-	stuff: Partial<App.Stuff>;
-}
-
-export interface LoadOutput<Props = Record<string, any>> {
-	status?: number;
-	error?: string | Error;
-	redirect?: string;
-	props?: Props;
-	stuff?: Partial<App.Stuff>;
-	maxage?: number;
+	stuff: App.Stuff;
+	status: number;
+	error: Error | null;
 }
 
-export interface Prerendered {
-	pages: Map<
-		string,
-		{
-			/** The location of the .html file relative to the output directory */
-			file: string;
-		}
-	>;
-	assets: Map<
-		string,
-		{
-			/** The MIME type of the asset */
-			type: string;
-		}
-	>;
-	redirects: Map<
-		string,
-		{
-			status: number;
-			location: string;
-		}
-	>;
-	/** An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config) */
-	paths: string[];
-}
-
-export interface PrerenderErrorHandler {
-	(details: {
-		status: number;
-		path: string;
-		referrer: string | null;
-		referenceType: 'linked' | 'fetched';
-	}): void;
-}
-
-export interface RequestEvent<Params = Record<string, string>> {
-	request: Request;
-	url: URL;
-	params: Params;
-	locals: App.Locals;
-	platform: Readonly<App.Platform>;
+export interface Navigation {
+	from: URL;
+	to: URL;
 }
 
 /**
  * A function exported from an endpoint that corresponds to an
- * HTTP verb (get, put, patch, etc) and handles requests with
+ * HTTP verb (`get`, `put`, `patch`, etc) and handles requests with
  * that method. Note that since 'delete' is a reserved word in
- * JavaScript, delete handles are called 'del' instead.
+ * JavaScript, delete handles are called `del` instead.
  */
 export interface RequestHandler<Params = Record<string, string>, Output extends Body = Body> {
 	(event: RequestEvent<Params>): MaybePromise<
 		Either<Output extends Response ? Response : EndpointOutput<Output>, Fallthrough>
 	>;
 }
-
-export interface RequestOptions {
-	platform?: App.Platform;
-}
-
-export type ResolveOptions = Partial<RequiredResolveOptions>;
-
-export class Server {
-	constructor(manifest: SSRManifest);
-	respond(request: Request, options?: RequestOptions): Promise<Response>;
-}
-
-export interface SSRManifest {
-	appDir: string;
-	assets: Set<string>;
-	/** private fields */
-	_: {
-		mime: Record<string, string>;
-		entry: {
-			file: string;
-			js: string[];
-			css: string[];
-		};
-		nodes: SSRNodeLoader[];
-		routes: SSRRoute[];
-	};
-}
-
-// TODO should this be public?
-export type ValidatedConfig = RecursiveRequired<Config>;

package/types/internal.d.ts

@@ -1,42 +1,28 @@
 import { OutputAsset, OutputChunk } from 'rollup';
 import {
-	SSRManifest,
-	ValidatedConfig,
 	RequestHandler,
 	Load,
 	ExternalFetch,
 	GetSession,
 	Handle,
 	HandleError,
+	Config
+} from './index';
+import {
+	Either,
+	Fallthrough,
+	HttpMethod,
+	JSONObject,
+	MaybePromise,
 	RequestEvent,
 	RequestOptions,
-	PrerenderErrorHandler,
-	Server
-} from './index';
-
-export 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
-	 * be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID
-	 */
-	id: string;
-
-	/**
-	 * A function that compares the candidate route with the current route to determine
-	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
-	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
-	 */
-	filter: (route: RouteDefinition) => boolean;
-
-	/**
-	 * A function that is invoked once the entry has been created. This is where you
-	 * should write the function to the filesystem and generate redirect manifests.
-	 */
-	complete: (entry: {
-		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
-	}) => void;
-}
+	ResolveOptions,
+	ResponseHeaders,
+	RouteSegment,
+	Server,
+	SSRManifest,
+	TrailingSlash
+} from './private';
 
 export interface ServerModule {
 	Server: typeof InternalServer;
@@ -58,8 +44,6 @@ export interface Asset {
 	type: string | null;
 }
 
-export type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
-
 export interface BuildData {
 	app_dir: string;
 	manifest_data: ManifestData;
@@ -89,8 +73,6 @@ export type CSRComponentLoader = () => Promise<CSRComponent>;
 
 export type CSRRoute = [RegExp, CSRComponentLoader[], CSRComponentLoader[], GetParams?, HasShadow?];
 
-export type Either<T, U> = Only<T, U> | Only<U, T>;
-
 export interface EndpointData {
 	type: 'endpoint';
 	key: string;
@@ -100,10 +82,6 @@ export interface EndpointData {
 	file: string;
 }
 
-export interface Fallthrough {
-	fallthrough: true;
-}
-
 export type GetParams = (match: RegExpExecArray) => Record<string, string>;
 
 type HasShadow = 1;
@@ -115,8 +93,6 @@ export interface Hooks {
 	handleError: HandleError;
 }
 
-export type HttpMethod = 'get' | 'head' | 'post' | 'put' | 'delete' | 'patch';
-
 export class InternalServer extends Server {
 	respond(
 		request: Request,
@@ -126,19 +102,6 @@ export class InternalServer extends Server {
 	): Promise<Response>;
 }
 
-export type JSONObject = { [key: string]: JSONValue };
-
-export type JSONValue = string | number | boolean | null | ToJSON | JSONValue[] | JSONObject;
-
-export interface Logger {
-	(msg: string): void;
-	success(msg: string): void;
-	error(msg: string): void;
-	warn(msg: string): void;
-	minor(msg: string): void;
-	info(msg: string): void;
-}
-
 export interface ManifestData {
 	assets: Asset[];
 	layout: string;
@@ -147,8 +110,6 @@ export interface ManifestData {
 	routes: RouteData[];
 }
 
-export type MaybePromise<T> = T | Promise<T>;
-
 export interface MethodOverride {
 	parameter: string;
 	allowed: string[];
@@ -166,8 +127,6 @@ export type NormalizedLoadOutput = Either<
 	Fallthrough
 >;
 
-type Only<T, U> = { [P in keyof T]: T[P] } & { [P in Exclude<keyof U, keyof T>]?: never };
-
 export interface PageData {
 	type: 'page';
 	key: string;
@@ -185,8 +144,6 @@ export interface PrerenderDependency {
 	body: null | string | Uint8Array;
 }
 
-export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
-
 export interface PrerenderOptions {
 	fallback?: string;
 	all: boolean;
@@ -204,33 +161,14 @@ export type RecursiveRequired<T> = {
 		: T[K]; // Use the exact type for everything else
 };
 
-export interface RequiredResolveOptions {
-	ssr: boolean;
-	transformPage: ({ html }: { html: string }) => MaybePromise<string>;
-}
+export type RequiredResolveOptions = Required<ResolveOptions>;
 
 export interface Respond {
 	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
 }
 
-/** `string[]` is only for set-cookie, everything else must be type of `string` */
-export type ResponseHeaders = Record<string, string | number | string[]>;
-
 export type RouteData = PageData | EndpointData;
 
-export interface RouteDefinition {
-	type: 'page' | 'endpoint';
-	pattern: RegExp;
-	segments: RouteSegment[];
-	methods: HttpMethod[];
-}
-
-export interface RouteSegment {
-	content: string;
-	dynamic: boolean;
-	rest: boolean;
-}
-
 export interface ShadowEndpointOutput<Output extends JSONObject = JSONObject> {
 	status?: number;
 	headers?: Partial<ResponseHeaders>;
@@ -365,8 +303,7 @@ export interface SSRState {
 
 export type StrictBody = string | Uint8Array;
 
-type ToJSON = { toJSON(...args: any[]): Exclude<JSONValue, ToJSON> };
-
-export type TrailingSlash = 'never' | 'always' | 'ignore';
+export type ValidatedConfig = RecursiveRequired<Config>;
 
 export * from './index';
+export * from './private';

package/types/private.d.ts

@@ -0,0 +1,343 @@
+// This module contains types that are visible in the documentation,
+// but which cannot be imported from `@sveltejs/kit`. Care should
+// be taken to avoid breaking changes when editing this file
+
+import { SSRNodeLoader, SSRRoute } from './internal';
+
+export 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
+	 * be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID
+	 */
+	id: string;
+
+	/**
+	 * A function that compares the candidate route with the current route to determine
+	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
+	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
+	 */
+	filter: (route: RouteDefinition) => boolean;
+
+	/**
+	 * A function that is invoked once the entry has been created. This is where you
+	 * should write the function to the filesystem and generate redirect manifests.
+	 */
+	complete: (entry: {
+		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
+	}) => void;
+}
+
+export type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
+
+export interface Builder {
+	log: Logger;
+	rimraf(dir: string): void;
+	mkdirp(dir: string): void;
+
+	appDir: string;
+	trailingSlash: TrailingSlash;
+
+	/**
+	 * Create entry points that map to individual functions
+	 * @param fn A function that groups a set of routes into an entry point
+	 */
+	createEntries(fn: (route: RouteDefinition) => AdapterEntry): void;
+
+	generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
+
+	getBuildDirectory(name: string): string;
+	getClientDirectory(): string;
+	getServerDirectory(): string;
+	getStaticDirectory(): string;
+
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeClient(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeServer(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeStatic(dest: string): string[];
+	/**
+	 * @param from the source file or folder
+	 * @param to the destination file or folder
+	 * @param opts.filter a function to determine whether a file or folder should be copied
+	 * @param opts.replace a map of strings to replace
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy(
+		from: string,
+		to: string,
+		opts?: {
+			filter?: (basename: string) => boolean;
+			replace?: Record<string, string>;
+		}
+	): string[];
+
+	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<Prerendered>;
+}
+
+// Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
+//
+// MIT License
+//
+// Copyright (c) 2021-present, Joshua Hemphill
+// Copyright (c) 2021, Tecnico Corporation
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+export namespace Csp {
+	type ActionSource = 'strict-dynamic' | 'report-sample';
+	type BaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'none';
+	type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+	type FrameSource = HostSource | SchemeSource | 'self' | 'none';
+	type HostNameScheme = `${string}.${string}` | 'localhost';
+	type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
+	type HostProtocolSchemes = `${string}://` | '';
+	type HttpDelineator = '/' | '?' | '#' | '\\';
+	type PortScheme = `:${number}` | '' | ':*';
+	type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+	type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
+	type Sources = Source[];
+	type UriPath = `${HttpDelineator}${string}`;
+}
+
+export type CspDirectives = {
+	'child-src'?: Csp.Sources;
+	'default-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'frame-src'?: Csp.Sources;
+	'worker-src'?: Csp.Sources;
+	'connect-src'?: Csp.Sources;
+	'font-src'?: Csp.Sources;
+	'img-src'?: Csp.Sources;
+	'manifest-src'?: Csp.Sources;
+	'media-src'?: Csp.Sources;
+	'object-src'?: Csp.Sources;
+	'prefetch-src'?: Csp.Sources;
+	'script-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'script-src-elem'?: Csp.Sources;
+	'script-src-attr'?: Csp.Sources;
+	'style-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'style-src-elem'?: Csp.Sources;
+	'style-src-attr'?: Csp.Sources;
+	'base-uri'?: Array<Csp.Source | Csp.ActionSource>;
+	sandbox?: Array<
+		| 'allow-downloads-without-user-activation'
+		| 'allow-forms'
+		| 'allow-modals'
+		| 'allow-orientation-lock'
+		| 'allow-pointer-lock'
+		| 'allow-popups'
+		| 'allow-popups-to-escape-sandbox'
+		| 'allow-presentation'
+		| 'allow-same-origin'
+		| 'allow-scripts'
+		| 'allow-storage-access-by-user-activation'
+		| 'allow-top-navigation'
+		| 'allow-top-navigation-by-user-activation'
+	>;
+	'form-action'?: Array<Csp.Source | Csp.ActionSource>;
+	'frame-ancestors'?: Array<Csp.HostSource | Csp.SchemeSource | Csp.FrameSource>;
+	'navigate-to'?: Array<Csp.Source | Csp.ActionSource>;
+	'report-uri'?: Csp.UriPath[];
+	'report-to'?: string[];
+
+	'require-trusted-types-for'?: Array<'script'>;
+	'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'
+		| 'origin'
+		| 'origin-when-cross-origin'
+		| 'same-origin'
+		| 'strict-origin'
+		| 'strict-origin-when-cross-origin'
+		| 'unsafe-url'
+		| 'none'
+	>;
+};
+
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+
+export interface EndpointOutput<Output extends Body = Body> {
+	status?: number;
+	headers?: Headers | Partial<ResponseHeaders>;
+	body?: Output;
+}
+
+export interface ErrorLoadInput<Params = Record<string, string>> extends LoadInput<Params> {
+	status?: number;
+	error?: Error;
+}
+
+export interface Fallthrough {
+	fallthrough: true;
+}
+
+export type HttpMethod = 'get' | 'head' | 'post' | 'put' | 'delete' | 'patch';
+
+export type JSONObject = { [key: string]: JSONValue };
+
+export type JSONValue = string | number | boolean | null | ToJSON | JSONValue[] | JSONObject;
+
+export interface LoadInput<Params = Record<string, string>> {
+	url: URL;
+	params: Params;
+	props: Record<string, any>;
+	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
+	session: App.Session;
+	stuff: Partial<App.Stuff>;
+}
+
+export interface LoadOutput<Props = Record<string, any>> {
+	status?: number;
+	error?: string | Error;
+	redirect?: string;
+	props?: Props;
+	stuff?: Partial<App.Stuff>;
+	maxage?: number;
+}
+
+export interface Logger {
+	(msg: string): void;
+	success(msg: string): void;
+	error(msg: string): void;
+	warn(msg: string): void;
+	minor(msg: string): void;
+	info(msg: string): void;
+}
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type Only<T, U> = { [P in keyof T]: T[P] } & { [P in Exclude<keyof U, keyof T>]?: never };
+
+export interface Prerendered {
+	pages: Map<
+		string,
+		{
+			/** The location of the .html file relative to the output directory */
+			file: string;
+		}
+	>;
+	assets: Map<
+		string,
+		{
+			/** The MIME type of the asset */
+			type: string;
+		}
+	>;
+	redirects: Map<
+		string,
+		{
+			status: number;
+			location: string;
+		}
+	>;
+	/** An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config) */
+	paths: string[];
+}
+
+export interface PrerenderErrorHandler {
+	(details: {
+		status: number;
+		path: string;
+		referrer: string | null;
+		referenceType: 'linked' | 'fetched';
+	}): void;
+}
+
+export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
+
+export interface RequestEvent<Params = Record<string, string>> {
+	request: Request;
+	url: URL;
+	params: Params;
+	locals: App.Locals;
+	platform: Readonly<App.Platform>;
+}
+
+export interface RequestOptions {
+	platform?: App.Platform;
+}
+
+export type ResolveOptions = {
+	ssr?: boolean;
+	transformPage?: ({ html }: { html: string }) => MaybePromise<string>;
+};
+
+/** `string[]` is only for set-cookie, everything else must be type of `string` */
+export type ResponseHeaders = Record<string, string | number | string[]>;
+
+export interface RouteDefinition {
+	type: 'page' | 'endpoint';
+	pattern: RegExp;
+	segments: RouteSegment[];
+	methods: HttpMethod[];
+}
+
+export interface RouteSegment {
+	content: string;
+	dynamic: boolean;
+	rest: boolean;
+}
+
+export class Server {
+	constructor(manifest: SSRManifest);
+	respond(request: Request, options?: RequestOptions): Promise<Response>;
+}
+
+export interface SSRManifest {
+	appDir: string;
+	assets: Set<string>;
+	/** private fields */
+	_: {
+		mime: Record<string, string>;
+		entry: {
+			file: string;
+			js: string[];
+			css: string[];
+		};
+		nodes: SSRNodeLoader[];
+		routes: SSRRoute[];
+	};
+}
+
+export type ToJSON = { toJSON(...args: any[]): Exclude<JSONValue, ToJSON> };
+
+export type TrailingSlash = 'never' | 'always' | 'ignore';