@sveltejs/kit 1.5.2 → 1.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.5.2",
+  "version": "1.5.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/adapt/builder.js

@@ -1,7 +1,5 @@
-import { fork } from 'node:child_process';
 import { existsSync, statSync, createReadStream, createWriteStream } from 'node:fs';
 import { pipeline } from 'node:stream';
-import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
 import glob from 'tiny-glob';
@@ -9,6 +7,8 @@ import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
 import { generate_manifest } from '../generate_manifest/index.js';
 import { get_route_segments } from '../../utils/routing.js';
 import { get_env } from '../../exports/vite/utils.js';
+import generate_fallback from '../postbuild/fallback.js';
+import { write } from '../sync/utils.js';
 
 const pipe = promisify(pipeline);
 
@@ -142,31 +142,16 @@ export function create_builder({
 			}
 		},
 
-		generateFallback(dest) {
-			// do prerendering in a subprocess so any dangling stuff gets killed upon completion
-			const script = fileURLToPath(new URL('../postbuild/fallback.js', import.meta.url));
-
+		async generateFallback(dest) {
 			const manifest_path = `${config.kit.outDir}/output/server/manifest-full.js`;
-
 			const env = get_env(config.kit.env, 'production');
 
-			return new Promise((fulfil, reject) => {
-				const child = fork(
-					script,
-					[dest, manifest_path, JSON.stringify({ ...env.private, ...env.public })],
-					{
-						stdio: 'inherit'
-					}
-				);
-
-				child.on('exit', (code) => {
-					if (code) {
-						reject(new Error(`Could not create a fallback page — failed with code ${code}`));
-					} else {
-						fulfil(undefined);
-					}
-				});
+			const fallback = await generate_fallback({
+				manifest_path,
+				env: { ...env.private, ...env.public }
 			});
+
+			write(dest, fallback);
 		},
 
 		generateManifest: ({ relativePath, routes: subset }) => {

package/src/core/postbuild/fallback.js

@@ -1,43 +1,54 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { mkdirp } from '../../utils/filesystem.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
 import { load_config } from '../config/index.js';
+import { forked } from '../../utils/fork.js';
 
-const [, , dest, manifest_path, env] = process.argv;
+export default forked(import.meta.url, generate_fallback);
 
-/** @type {import('types').ValidatedKitConfig} */
-const config = (await load_config()).kit;
+/**
+ * @param {{
+ *   manifest_path: string;
+ *   env: Record<string, string>
+ * }} opts
+ */
+async function generate_fallback({ manifest_path, env }) {
+	/** @type {import('types').ValidatedKitConfig} */
+	const config = (await load_config()).kit;
 
-installPolyfills();
+	installPolyfills();
 
-const server_root = join(config.outDir, 'output');
+	const server_root = join(config.outDir, 'output');
 
-/** @type {import('types').ServerInternalModule} */
-const { set_building } = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
+	/** @type {import('types').ServerInternalModule} */
+	const { set_building } = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
 
-/** @type {import('types').ServerModule} */
-const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
+	/** @type {import('types').ServerModule} */
+	const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
 
-/** @type {import('types').SSRManifest} */
-const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+	/** @type {import('types').SSRManifest} */
+	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
-set_building(true);
+	set_building(true);
 
-const server = new Server(manifest);
-await server.init({ env: JSON.parse(env) });
+	const server = new Server(manifest);
+	await server.init({ env });
 
-const rendered = await server.respond(new Request(config.prerender.origin + '/[fallback]'), {
-	getClientAddress: () => {
-		throw new Error('Cannot read clientAddress during prerendering');
-	},
-	prerendering: {
-		fallback: true,
-		dependencies: new Map()
-	},
-	read: (file) => readFileSync(join(config.files.assets, file))
-});
+	const response = await server.respond(new Request(config.prerender.origin + '/[fallback]'), {
+		getClientAddress: () => {
+			throw new Error('Cannot read clientAddress during prerendering');
+		},
+		prerendering: {
+			fallback: true,
+			dependencies: new Map()
+		},
+		read: (file) => readFileSync(join(config.files.assets, file))
+	});
 
-mkdirp(dirname(dest));
-writeFileSync(dest, await rendered.text());
+	if (response.ok) {
+		return await response.text();
+	}
+
+	throw new Error(`Could not create a fallback page — failed with status ${response.status}`);
+}

package/src/exports/node/polyfills.js

@@ -1,6 +1,10 @@
 import { ReadableStream, TransformStream, WritableStream } from 'node:stream/web';
+import buffer from 'node:buffer';
 import { webcrypto as crypto } from 'node:crypto';
-import { fetch, Response, Request, Headers, FormData } from 'undici';
+import { fetch, Response, Request, Headers, FormData, File as UndiciFile } from 'undici';
+
+// @ts-expect-error
+const File = buffer.File ?? UndiciFile;
 
 /** @type {Record<string, any>} */
 const globals = {
@@ -12,7 +16,8 @@ const globals = {
 	ReadableStream,
 	TransformStream,
 	WritableStream,
-	FormData
+	FormData,
+	File
 };
 
 // exported for dev/preview and node environments

package/src/exports/vite/index.js

@@ -632,7 +632,15 @@ export function set_assets(path) {
 						// CLI args
 						mode: vite_config_env.mode,
 						logLevel: vite_config.logLevel,
-						clearScreen: vite_config.clearScreen
+						clearScreen: vite_config.clearScreen,
+						build: {
+							minify: vite_config.build.minify,
+							assetsInlineLimit: vite_config.build.assetsInlineLimit,
+							sourcemap: vite_config.build.sourcemap
+						},
+						optimizeDeps: {
+							force: vite_config.optimizeDeps.force
+						}
 					})
 				);
 

package/src/runtime/app/stores.js

@@ -23,7 +23,7 @@ export const getStores = () => {
 export const page = {
 	/** @param {(value: any) => void} fn */
 	subscribe(fn) {
-		const store = getStores().page;
+		const store = __SVELTEKIT_DEV__ ? get_store('page') : getStores().page;
 		return store.subscribe(fn);
 	}
 };
@@ -31,7 +31,7 @@ export const page = {
 /** @type {typeof import('$app/stores').navigating} */
 export const navigating = {
 	subscribe(fn) {
-		const store = getStores().navigating;
+		const store = __SVELTEKIT_DEV__ ? get_store('navigating') : getStores().navigating;
 		return store.subscribe(fn);
 	}
 };
@@ -39,7 +39,7 @@ export const navigating = {
 /** @type {typeof import('$app/stores').updated} */
 export const updated = {
 	subscribe(fn) {
-		const store = getStores().updated;
+		const store = __SVELTEKIT_DEV__ ? get_store('updated') : getStores().updated;
 
 		if (browser) {
 			updated.check = store.check;
@@ -55,3 +55,18 @@ export const updated = {
 		);
 	}
 };
+
+/**
+ * @template {keyof ReturnType<typeof getStores>} Name
+ * @param {Name} name
+ * @returns {ReturnType<typeof getStores>[Name]}
+ */
+function get_store(name) {
+	try {
+		return getStores()[name];
+	} catch (e) {
+		throw new Error(
+			`Cannot subscribe to '${name}' store on the server outside of a Svelte component, as it is bound to the current request via component context. This prevents state from leaking between users.`
+		);
+	}
+}

package/src/runtime/client/client.js

@@ -221,14 +221,8 @@ export function create_client({ target }) {
 		});
 	}
 
-	/** @param {URL} url */
-	async function preload_data(url) {
-		const intent = get_navigation_intent(url, false);
-
-		if (!intent) {
-			throw new Error(`Attempted to preload a URL that does not belong to this app: ${url}`);
-		}
-
+	/** @param {import('./types').NavigationIntent} intent */
+	async function preload_data(intent) {
 		load_cache = {
 			id: intent.id,
 			promise: load_route(intent).then((result) => {
@@ -1261,7 +1255,23 @@ export function create_client({ target }) {
 
 			if (!options.reload) {
 				if (priority <= options.preload_data) {
-					preload_data(/** @type {URL} */ (url));
+					const intent = get_navigation_intent(/** @type {URL} */ (url), false);
+					if (intent) {
+						if (__SVELTEKIT_DEV__) {
+							preload_data(intent).then((result) => {
+								if (result.type === 'loaded' && result.state.error) {
+									console.warn(
+										`Preloading data for ${intent.url.pathname} failed with the following error: ${result.state.error.message}\n` +
+											'If this error is transient, you can ignore it. Otherwise, consider disabling preloading for this route. ' +
+											'This route was preloaded due to a data-sveltekit-preload-data attribute. ' +
+											'See https://kit.svelte.dev/docs/link-options for more info'
+									);
+								}
+							});
+						} else {
+							preload_data(intent);
+						}
+					}
 				} else if (priority <= options.preload_code) {
 					preload_code(get_url_path(/** @type {URL} */ (url)));
 				}
@@ -1347,7 +1357,13 @@ export function create_client({ target }) {
 
 		preload_data: async (href) => {
 			const url = new URL(href, get_base_uri(document));
-			await preload_data(url);
+			const intent = get_navigation_intent(url, false);
+
+			if (!intent) {
+				throw new Error(`Attempted to preload a URL that does not belong to this app: ${url}`);
+			}
+
+			await preload_data(intent);
 		},
 
 		preload_code,

package/src/runtime/server/page/render.js

@@ -113,7 +113,32 @@ export async function render_response({
 			form: form_value
 		};
 
-		rendered = options.root.render(props);
+		if (__SVELTEKIT_DEV__) {
+			const fetch = globalThis.fetch;
+			let warned = false;
+			globalThis.fetch = (info, init) => {
+				if (typeof info === 'string' && !/^\w+:\/\//.test(info)) {
+					throw new Error(
+						`Cannot call \`fetch\` eagerly during server side rendering with relative URL (${info}) — put your \`fetch\` calls inside \`onMount\` or a \`load\` function instead`
+					);
+				} else if (!warned) {
+					console.warn(
+						`Avoid calling \`fetch\` eagerly during server side rendering — put your \`fetch\` calls inside \`onMount\` or a \`load\` function instead`
+					);
+					warned = true;
+				}
+
+				return fetch(info, init);
+			};
+
+			try {
+				rendered = options.root.render(props);
+			} finally {
+				globalThis.fetch = fetch;
+			}
+		} else {
+			rendered = options.root.render(props);
+		}
 
 		for (const { node } of branch) {
 			if (node.imports) {

package/src/runtime/server/utils.js

@@ -41,7 +41,7 @@ export function method_not_allowed(mod, method) {
 export function allowed_methods(mod) {
 	const allowed = [];
 
-	for (const method in ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']) {
+	for (const method of ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']) {
 		if (method in mod) allowed.push(method);
 	}
 

package/types/ambient.d.ts

@@ -292,16 +292,22 @@ declare module '$app/stores' {
 
 	/**
 	 * A readable store whose value contains page data.
+	 *
+	 * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
 	 */
 	export const page: Readable<Page>;
 	/**
 	 * A readable store.
 	 * When navigating starts, its value is a `Navigation` object with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
 	 * When navigating finishes, its value reverts to `null`.
+	 *
+	 * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
 	 */
 	export const navigating: Readable<Navigation | null>;
 	/**
-	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/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.
+	 * A readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/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.
+	 *
+	 * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
 	 */
 	export const updated: Readable<boolean> & { check(): Promise<boolean> };
 

package/types/index.d.ts

@@ -304,6 +304,8 @@ export interface KitConfig {
 	 * > When `mode` is `'auto'`, SvelteKit will use nonces for dynamically rendered pages and hashes for prerendered pages. Using nonces with prerendered pages is insecure and therefore forbidden.
 	 *
 	 * > Note that most [Svelte transitions](https://svelte.dev/tutorial/transition) work by creating an inline `<style>` element. If you use these in your app, you must either leave the `style-src` directive unspecified or add `unsafe-inline`.
+	 *
+	 * If this level of configuration is insufficient and you have more dynamic requirements, you can use the [`handle` hook](https://kit.svelte.dev/docs/hooks#server-hooks-handle) to roll your own CSP.
 	 */
 	csp?: {
 		/**
@@ -542,8 +544,7 @@ export interface KitConfig {
 	 */
 	version?: {
 		/**
-		 * The current app version string.
-		 * @default Date.now().toString()
+		 * The current app version string. If specified, this must be deterministic (e.g. a commit ref rather than `Math.random()` or Date.now().toString()`), otherwise defaults to a timestamp of the build
 		 */
 		name?: string;
 		/**