@sveltejs/kit 1.0.0-next.242 → 1.0.0-next.246

package/dist/chunks/index3.js

@@ -1,6 +1,6 @@
 import fs__default from 'fs';
 import path__default from 'path';
-import { p as print_config_conflicts, a as SVELTE_KIT, d as copy_assets, f as posixify, e as get_aliases, r as resolve_entry, b as runtime, l as load_template, m as mkdirp, h as rimraf } from '../cli.js';
+import { p as print_config_conflicts, a as SVELTE_KIT, d as copy_assets, f as posixify, e as get_aliases, r as resolve_entry, l as load_template, b as runtime, m as mkdirp, h as rimraf } from '../cli.js';
 import { d as deep_merge, a as create_app, c as create_manifest_data } from './index2.js';
 import { g as generate_manifest } from './index4.js';
 import vite from 'vite';
@@ -241,24 +241,25 @@ async function build_client({
 
 /**
  * @param {{
- *   cwd: string;
  *   hooks: string;
  *   config: import('types/config').ValidatedConfig;
  *   has_service_worker: boolean;
+ *   template: string;
  * }} opts
  * @returns
  */
-const template = ({ cwd, config, hooks, has_service_worker }) => `
+const app_template = ({ config, hooks, has_service_worker, template }) => `
 import root from '__GENERATED__/root.svelte';
 import { respond } from '${runtime}/server/index.js';
 import { set_paths, assets, base } from '${runtime}/paths.js';
 import { set_prerendering } from '${runtime}/env.js';
 import * as user_hooks from ${s(hooks)};
 
-const template = ({ head, body, assets }) => ${s(load_template(cwd, config))
+const template = ({ head, body, assets, nonce }) => ${s(template)
 	.replace('%svelte.head%', '" + head + "')
 	.replace('%svelte.body%', '" + body + "')
-	.replace(/%svelte\.assets%/g, '" + assets + "')};
+	.replace(/%svelte\.assets%/g, '" + assets + "')
+	.replace(/%svelte\.nonce%/g, '" + nonce + "')};
 
 let read = null;
 
@@ -290,6 +291,7 @@ export class App {
 
 		this.options = {
 			amp: ${config.kit.amp},
+			csp: ${s(config.kit.csp)},
 			dev: false,
 			floc: ${config.kit.floc},
 			get_stack: error => String(error), // for security
@@ -319,18 +321,17 @@ export class App {
 			router: ${s(config.kit.router)},
 			target: ${s(config.kit.target)},
 			template,
+			template_contains_nonce: ${template.includes('%svelte.nonce%')},
 			trailing_slash: ${s(config.kit.trailingSlash)}
 		};
 	}
 
-	render(request, {
-		prerender
-	} = {}) {
+	render(request, options = {}) {
 		if (!(request instanceof Request)) {
 			throw new Error('The first argument to app.render must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
 		}
 
-		return respond(request, this.options, { prerender });
+		return respond(request, this.options, options);
 	}
 }
 `;
@@ -399,14 +400,13 @@ async function build_server(
 		return relative_file[0] === '.' ? relative_file : `./${relative_file}`;
 	};
 
-	// prettier-ignore
 	fs__default.writeFileSync(
 		input.app,
-		template({
-			cwd,
+		app_template({
 			config,
 			hooks: app_relative(hooks_file),
-			has_service_worker: service_worker_register && !!service_worker_entry_file
+			has_service_worker: service_worker_register && !!service_worker_entry_file,
+			template: load_template(cwd, config)
 		})
 	);
 

package/dist/chunks/index5.js

@@ -412,8 +412,9 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 	 * @param {string?} referrer
 	 */
 	async function visit(path, decoded_path, referrer) {
-		/** @type {Map<string, Response>} */
+		/** @type {Map<string, import('types/internal').PrerenderDependency>} */
 		const dependencies = new Map();
+
 		const render_path = config.kit.paths?.base
 			? `http://sveltekit-prerender${config.kit.paths.base}${path === '/' ? '' : path}`
 			: `http://sveltekit-prerender${path}`;
@@ -474,9 +475,11 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 			}
 
 			for (const [dependency_path, result] of dependencies) {
-				const response_type = Math.floor(result.status / 100);
+				const { status, headers } = result.response;
+
+				const response_type = Math.floor(status / 100);
 
-				const is_html = result.headers.get('content-type') === 'text/html';
+				const is_html = headers.get('content-type') === 'text/html';
 
 				const parts = dependency_path.split('/');
 				if (is_html && parts[parts.length - 1] !== 'index.html') {
@@ -486,16 +489,17 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 				const file = `${out}${parts.join('/')}`;
 				mkdirp(dirname(file));
 
-				if (result.body) {
-					writeFileSync(file, await result.text());
-					paths.push(dependency_path);
-				}
+				writeFileSync(
+					file,
+					result.body === null ? new Uint8Array(await result.response.arrayBuffer()) : result.body
+				);
+				paths.push(dependency_path);
 
 				if (response_type === OK) {
-					log.info(`${result.status} ${dependency_path}`);
+					log.info(`${status} ${dependency_path}`);
 				} else {
 					error({
-						status: result.status,
+						status,
 						path: dependency_path,
 						referrer: path,
 						referenceType: 'fetched'

package/dist/chunks/index7.js

@@ -15254,18 +15254,23 @@ const essential_files = ['README', 'LICENSE', 'CHANGELOG', '.gitignore', '.npmig
  * @param {string} cwd
  */
 async function make_package(config, cwd = process.cwd()) {
-	const package_dir = config.kit.package.dir;
-	const abs_package_dir = path.isAbsolute(package_dir) ? package_dir : path.join(cwd, package_dir);
-	rimraf(abs_package_dir);
-	mkdirp(abs_package_dir); // TODO https://github.com/sveltejs/kit/issues/2333
+	if (!fs.existsSync(config.kit.files.lib)) {
+		throw new Error(`${config.kit.files.lib} does not exist`);
+	}
+
+	const package_dir = path.isAbsolute(config.kit.package.dir)
+		? config.kit.package.dir
+		: path.join(cwd, config.kit.package.dir);
+	rimraf(package_dir);
+	mkdirp(package_dir); // TODO https://github.com/sveltejs/kit/issues/2333
 
 	if (config.kit.package.emitTypes) {
 		// Generate type definitions first so hand-written types can overwrite generated ones
 		await emit_dts(config);
 		// Resolve aliases, TS leaves them as-is
-		const files = walk$1(abs_package_dir);
+		const files = walk$1(package_dir);
 		for (const file of files) {
-			const filename = path.join(abs_package_dir, file);
+			const filename = path.join(package_dir, file);
 			const source = fs.readFileSync(filename, 'utf8');
 			fs.writeFileSync(filename, resolve_$lib_alias(file, source, config));
 		}
@@ -15292,7 +15297,7 @@ async function make_package(config, cwd = process.cwd()) {
 
 		if (!config.kit.package.files(normalized)) {
 			const dts_file = (svelte_ext ? file : file.slice(0, -ext.length)) + '.d.ts';
-			const dts_path = path.join(abs_package_dir, dts_file);
+			const dts_path = path.join(package_dir, dts_file);
 			if (fs.existsSync(dts_path)) {
 				fs.unlinkSync(dts_path);
 
@@ -15327,7 +15332,7 @@ async function make_package(config, cwd = process.cwd()) {
 			out_file = file;
 			out_contents = source.toString('utf-8');
 			out_contents = resolve_$lib_alias(out_file, out_contents, config);
-			if (fs.existsSync(path.join(abs_package_dir, out_file))) {
+			if (fs.existsSync(path.join(package_dir, out_file))) {
 				console.warn(
 					'Found already existing file from d.ts generation for ' +
 						out_file +
@@ -15343,7 +15348,7 @@ async function make_package(config, cwd = process.cwd()) {
 			out_contents = source;
 		}
 
-		write(path.join(abs_package_dir, out_file), out_contents);
+		write(path.join(package_dir, out_file), out_contents);
 
 		if (config.kit.package.exports(normalized)) {
 			const original = `$lib/${normalized}`;
@@ -15390,7 +15395,7 @@ async function make_package(config, cwd = process.cwd()) {
 		}
 	}
 
-	write(path.join(abs_package_dir, 'package.json'), JSON.stringify(pkg, null, '  '));
+	write(path.join(package_dir, 'package.json'), JSON.stringify(pkg, null, 2));
 
 	const whitelist = fs.readdirSync(cwd).filter((file) => {
 		const lowercased = file.toLowerCase();
@@ -15400,7 +15405,7 @@ async function make_package(config, cwd = process.cwd()) {
 		const full_path = path.join(cwd, pathname);
 		if (fs.lstatSync(full_path).isDirectory()) continue; // just to be sure
 
-		const package_path = path.join(abs_package_dir, pathname);
+		const package_path = path.join(package_dir, pathname);
 		if (!fs.existsSync(package_path)) fs.copyFileSync(full_path, package_path);
 	}
 
@@ -15568,8 +15573,7 @@ async function try_load_svelte2tsx() {
 			return await import('svelte2tsx');
 		} catch (e) {
 			throw new Error(
-				'You need to install svelte2tsx and typescript if you want to generate type definitions\n' +
-					e
+				'You need svelte2tsx and typescript if you want to generate type definitions. Install it through your package manager, or disable generation which is highly discouraged. See https://kit.svelte.dev/docs#packaging'
 			);
 		}
 	}

package/dist/cli.js

@@ -1,5 +1,5 @@
 import sade from 'sade';
-import path__default, { relative } from 'path';
+import path__default, { join, relative } from 'path';
 import { exec as exec$1 } from 'child_process';
 import { createConnection, createServer } from 'net';
 import fs__default from 'fs';
@@ -490,13 +490,50 @@ const options = object(
 				return input;
 			}),
 
+			csp: object({
+				mode: list(['auto', 'hash', 'nonce']),
+				directives: object({
+					'child-src': string_array(),
+					'default-src': string_array(),
+					'frame-src': string_array(),
+					'worker-src': string_array(),
+					'connect-src': string_array(),
+					'font-src': string_array(),
+					'img-src': string_array(),
+					'manifest-src': string_array(),
+					'media-src': string_array(),
+					'object-src': string_array(),
+					'prefetch-src': string_array(),
+					'script-src': string_array(),
+					'script-src-elem': string_array(),
+					'script-src-attr': string_array(),
+					'style-src': string_array(),
+					'style-src-elem': string_array(),
+					'style-src-attr': string_array(),
+					'base-uri': string_array(),
+					sandbox: string_array(),
+					'form-action': string_array(),
+					'frame-ancestors': string_array(),
+					'navigate-to': string_array(),
+					'report-uri': string_array(),
+					'report-to': string_array(),
+					'require-trusted-types-for': string_array(),
+					'trusted-types': string_array(),
+					'upgrade-insecure-requests': boolean(false),
+					'require-sri-for': string_array(),
+					'block-all-mixed-content': boolean(false),
+					'plugin-types': string_array(),
+					referrer: string_array()
+				})
+			}),
+
 			files: object({
 				assets: string('static'),
-				hooks: string('src/hooks'),
-				lib: string('src/lib'),
-				routes: string('src/routes'),
-				serviceWorker: string('src/service-worker'),
-				template: string('src/app.html')
+				hooks: string(join('src', 'hooks')),
+				lib: string(join('src', 'lib')),
+				routes: string(join('src', 'routes')),
+				serviceWorker: string(join('src', 'service-worker')),
+				template: string(join('src', 'app.html'))
 			}),
 
 			floc: boolean(false),
@@ -747,6 +784,22 @@ function string(fallback, allow_empty = true) {
 	});
 }
 
+/**
+ * @param {string[] | undefined} [fallback]
+ * @returns {Validator}
+ */
+function string_array(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (input === undefined) return input;
+
+		if (!Array.isArray(input) || input.some((value) => typeof value !== 'string')) {
+			throw new Error(`${keypath} must be an array of strings, if specified`);
+		}
+
+		return input;
+	});
+}
+
 /**
  * @param {number} fallback
  * @returns {Validator}
@@ -933,7 +986,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.242');
+const prog = sade('svelte-kit').version('1.0.0-next.246');
 
 prog
 	.command('dev')
@@ -1085,7 +1138,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.242'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.246'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/dist/install-fetch.js

@@ -6489,7 +6489,7 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
 	});
 }
 
-// exported for dev, prerender, and preview
+// exported for dev/preview and node environments
 function __fetch_polyfill() {
 	Object.defineProperties(globalThis, {
 		fetch: {

package/package.json

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

package/types/app.d.ts

@@ -1,15 +1,19 @@
 import { PrerenderOptions, SSRNodeLoader, SSRRoute } from './internal';
 
+export interface RequestOptions<Platform = Record<string, any>> {
+	platform?: Platform;
+}
+
 export class App {
 	constructor(manifest: SSRManifest);
-	render(request: Request): Promise<Response>;
+	render(request: Request, options?: RequestOptions): Promise<Response>;
 }
 
 export class InternalApp extends App {
 	render(
 		request: Request,
-		options?: {
-			prerender: PrerenderOptions;
+		options?: RequestOptions & {
+			prerender?: PrerenderOptions;
 		}
 	): Promise<Response>;
 }

package/types/config.d.ts

@@ -1,5 +1,6 @@
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import { UserConfig as ViteConfig } from 'vite';
+import { CspDirectives } from './csp';
 import { RecursiveRequired } from './helper';
 import { HttpMethod, Logger, RouteSegment, TrailingSlash } from './internal';
 
@@ -117,6 +118,10 @@ export interface Config {
 		adapter?: Adapter;
 		amp?: boolean;
 		appDir?: string;
+		csp?: {
+			mode?: 'hash' | 'nonce' | 'auto';
+			directives?: CspDirectives;
+		};
 		files?: {
 			assets?: string;
 			hooks?: string;

package/types/csp.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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.
+ */
+type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+
+type HostProtocolSchemes = `${string}://` | '';
+type PortScheme = `:${number}` | '' | ':*';
+/** Can actually be any string, but typed more explicitly to
+ *  restrict the combined optional types of Source from collapsing to just bing `string` */
+type HostNameScheme = `${string}.${string}` | `localhost`;
+type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
+
+type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+
+type BaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'none';
+
+export type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
+type Sources = Source[];
+
+type ActionSource = 'strict-dynamic' | 'report-sample';
+
+type FrameSource = HostSource | SchemeSource | 'self' | 'none';
+
+type HttpDelineator = '/' | '?' | '#' | '\\';
+type UriPath = `${HttpDelineator}${string}`;
+
+export type CspDirectives = {
+	'child-src'?: Sources;
+	'default-src'?: Array<Source | ActionSource>;
+	'frame-src'?: Sources;
+	'worker-src'?: Sources;
+	'connect-src'?: Sources;
+	'font-src'?: Sources;
+	'img-src'?: Sources;
+	'manifest-src'?: Sources;
+	'media-src'?: Sources;
+	'object-src'?: Sources;
+	'prefetch-src'?: Sources;
+	'script-src'?: Array<Source | ActionSource>;
+	'script-src-elem'?: Sources;
+	'script-src-attr'?: Sources;
+	'style-src'?: Array<Source | ActionSource>;
+	'style-src-elem'?: Sources;
+	'style-src-attr'?: Sources;
+	'base-uri'?: Array<Source | 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<Source | ActionSource>;
+	'frame-ancestors'?: Array<HostSource | SchemeSource | FrameSource>;
+	'navigate-to'?: Array<Source | ActionSource>;
+	'report-uri'?: 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'
+	>;
+};

package/types/endpoint.d.ts

@@ -13,8 +13,12 @@ export interface Fallthrough {
 	fallthrough: true;
 }
 
-export interface RequestHandler<Locals = Record<string, any>, Output extends Body = Body> {
-	(event: RequestEvent<Locals>): MaybePromise<
+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>
 	>;
 }

package/types/helper.d.ts

@@ -13,7 +13,7 @@ export type JSONString =
 export type ResponseHeaders = Record<string, string | string[]>;
 
 // <-- Utility Types -->
-type Only<T, U> = { [P in keyof T]: T[P] } & { [P in keyof U]?: never };
+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>

package/types/hooks.d.ts

@@ -2,37 +2,33 @@ import { MaybePromise } from './helper';
 
 export type StrictBody = string | Uint8Array;
 
-export interface RequestEvent<Locals = Record<string, any>> {
+export interface RequestEvent<Locals = Record<string, any>, Platform = Record<string, any>> {
 	request: Request;
 	url: URL;
 	params: Record<string, string>;
 	locals: Locals;
+	platform: Readonly<Platform>;
 }
 
-export interface GetSession<Locals = Record<string, any>, Session = any> {
-	(event: RequestEvent<Locals>): MaybePromise<Session>;
+export interface GetSession<
+	Locals = Record<string, any>,
+	Platform = Record<string, any>,
+	Session = any
+> {
+	(event: RequestEvent<Locals, Platform>): MaybePromise<Session>;
 }
 
 export interface ResolveOpts {
 	ssr?: boolean;
 }
 
-export interface Handle<Locals = Record<string, any>> {
+export interface Handle<Locals = Record<string, any>, Platform = Record<string, any>> {
 	(input: {
-		event: RequestEvent<Locals>;
-		resolve(event: RequestEvent<Locals>, opts?: ResolveOpts): MaybePromise<Response>;
+		event: RequestEvent<Locals, Platform>;
+		resolve(event: RequestEvent<Locals, Platform>, opts?: ResolveOpts): MaybePromise<Response>;
 	}): MaybePromise<Response>;
 }
 
-// internally, `resolve` could return `undefined`, so we differentiate InternalHandle
-// from the public Handle type
-export interface InternalHandle<Locals = Record<string, any>> {
-	(input: {
-		event: RequestEvent<Locals>;
-		resolve(event: RequestEvent<Locals>, opts?: ResolveOpts): MaybePromise<Response | undefined>;
-	}): MaybePromise<Response | undefined>;
-}
-
 export interface HandleError<Locals = Record<string, any>> {
 	(input: { error: Error & { frame?: string }; event: RequestEvent<Locals> }): void;
 }

package/types/internal.d.ts

@@ -1,14 +1,20 @@
 import { OutputAsset, OutputChunk } from 'rollup';
+import { ValidatedConfig } from './config';
 import { InternalApp, SSRManifest } from './app';
 import { Fallthrough, RequestHandler } from './endpoint';
 import { Either } from './helper';
-import { ExternalFetch, GetSession, HandleError, InternalHandle, RequestEvent } from './hooks';
+import { ExternalFetch, GetSession, Handle, HandleError, RequestEvent } from './hooks';
 import { Load } from './page';
 
+export interface PrerenderDependency {
+	response: Response;
+	body: null | string | Uint8Array;
+}
+
 export interface PrerenderOptions {
 	fallback?: string;
 	all: boolean;
-	dependencies: Map<string, Response>;
+	dependencies: Map<string, PrerenderDependency>;
 }
 
 export interface AppModule {
@@ -97,7 +103,7 @@ export type SSRNodeLoader = () => Promise<SSRNode>;
 export interface Hooks {
 	externalFetch: ExternalFetch;
 	getSession: GetSession;
-	handle: InternalHandle;
+	handle: Handle;
 	handleError: HandleError;
 }
 
@@ -115,6 +121,7 @@ export interface SSRNode {
 
 export interface SSRRenderOptions {
 	amp: boolean;
+	csp: ValidatedConfig['kit']['csp'];
 	dev: boolean;
 	floc: boolean;
 	get_stack: (error: Error) => string | undefined;
@@ -134,13 +141,25 @@ export interface SSRRenderOptions {
 	router: boolean;
 	service_worker?: string;
 	target: string;
-	template({ head, body, assets }: { head: string; body: string; assets: string }): string;
+	template({
+		head,
+		body,
+		assets,
+		nonce
+	}: {
+		head: string;
+		body: string;
+		assets: string;
+		nonce: string;
+	}): string;
+	template_contains_nonce: boolean;
 	trailing_slash: TrailingSlash;
 }
 
 export interface SSRRenderState {
 	fetched?: string;
 	initiator?: SSRPage | null;
+	platform?: any;
 	prerender?: PrerenderOptions;
 	fallback?: string;
 }
@@ -228,7 +247,5 @@ export interface MethodOverride {
 }
 
 export interface Respond {
-	(request: Request, options: SSRRenderOptions, state?: SSRRenderState): Promise<
-		Response | undefined
-	>;
+	(request: Request, options: SSRRenderOptions, state?: SSRRenderState): Promise<Response>;
 }