@sveltejs/kit 1.0.0-next.416 → 1.0.0-next.419

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.416",
+  "version": "1.0.0-next.419",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -11,7 +11,6 @@
   "type": "module",
   "dependencies": {
     "@sveltejs/vite-plugin-svelte": "^1.0.1",
-    "chokidar": "^3.5.3",
     "cookie": "^0.5.0",
     "devalue": "^2.0.1",
     "kleur": "^4.1.4",
@@ -37,14 +36,14 @@
     "rollup": "^2.75.7",
     "svelte": "^3.48.0",
     "svelte-preprocess": "^4.10.6",
-    "svelte2tsx": "~0.5.10",
+    "tiny-glob": "^0.2.9",
     "typescript": "^4.7.4",
     "uvu": "^0.5.3",
-    "vite": "^3.0.0"
+    "vite": "3.0.2"
   },
   "peerDependencies": {
     "svelte": "^3.44.0",
-    "vite": "^3.0.0"
+    "vite": "3.0.2"
   },
   "bin": {
     "svelte-kit": "svelte-kit.js"
@@ -88,10 +87,9 @@
     "check": "tsc",
     "check:all": "tsc && pnpm -r --filter=\"./**\" check",
     "format": "npm run lint -- --write",
-    "test": "npm run test:unit && npm run test:packaging && npm run test:integration",
+    "test": "npm run test:unit && npm run test:integration",
     "test:integration": "pnpm run -r --workspace-concurrency 1 --filter=\"./test/**\" test",
     "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
-    "test:packaging": "uvu src/packaging \"(spec\\.js|test[\\\\/]index\\.js)\"",
     "types": "node scripts/extract-types.js",
     "postinstall": "node svelte-kit.js sync"
   }

package/src/cli.js

@@ -22,21 +22,6 @@ function handle_error(e) {
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 const prog = sade('svelte-kit').version(pkg.version);
 
-prog
-	.command('package')
-	.describe('Create a package')
-	.option('-w, --watch', 'Rerun when files change', false)
-	.action(async ({ watch }) => {
-		try {
-			const config = await load_config();
-			const packaging = await import('./packaging/index.js');
-
-			await (watch ? packaging.watch(config) : packaging.build(config));
-		} catch (error) {
-			handle_error(error);
-		}
-	});
-
 prog
 	.command('sync')
 	.describe('Synchronise generated files')
@@ -78,6 +63,14 @@ prog
 replace('dev');
 replace('build');
 replace('preview');
+prog
+	.command('package')
+	.describe('No longer available - use @sveltejs/package instead')
+	.action(() => {
+		console.error(
+			'svelte-kit package has been removed. It now lives in its own npm package. See the PR on how to migrate: https://github.com/sveltejs/kit/pull/5730'
+		);
+	});
 
 prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
 

package/src/core/config/options.js

@@ -173,13 +173,7 @@ const options = object(
 
 			outDir: string('.svelte-kit'),
 
-			package: object({
-				dir: string('package'),
-				// excludes all .d.ts and filename starting with _
-				exports: fun((filepath) => !/^_|\/_|\.d\.ts$/.test(filepath)),
-				files: fun(() => true),
-				emitTypes: boolean(true)
-			}),
+			package: error((keypath) => `${keypath} has been removed — use @sveltejs/package instead`),
 
 			paths: object({
 				base: validate('', (input, keypath) => {

package/src/core/sync/create_manifest_data/index.js

@@ -172,12 +172,22 @@ export default function create_manifest_data({
 			if (item.is_page) {
 				const route = /** @type {import('types').PageData} */ (route_map.get(id));
 
-				if (item.kind === 'component') {
-					route.leaf.component = project_relative;
-
-					const { layouts, errors } = trace(tree, id, item.uses_layout, project_relative);
+				// This ensures that layouts and errors are set for pages that have no Svelte file
+				// and only redirect or throw an error, but are set to the Svelte file definition if it exists.
+				// This ensures the proper error page is used and rendered in the proper layout.
+				if (item.kind === 'component' || route.layouts.length === 0) {
+					const { layouts, errors } = trace(
+						tree,
+						id,
+						item.kind === 'component' ? item.uses_layout : undefined,
+						project_relative
+					);
 					route.layouts = layouts;
 					route.errors = errors;
+				}
+
+				if (item.kind === 'component') {
+					route.leaf.component = project_relative;
 				} else if (item.kind === 'server') {
 					route.leaf.server = project_relative;
 				} else {

package/src/core/sync/write_types.js

@@ -246,12 +246,18 @@ function write_types_for_dir(config, manifest_data, routes_dir, dir, groups, ts)
 
 		exports.push(`export type PageData = ${data};`);
 		if (load) {
-			exports.push(`export type PageLoad = ${load};`);
+			exports.push(
+				`export type PageLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
+			);
+			exports.push('export type PageLoadEvent = Parameters<PageLoad>[0];');
 		}
 
 		exports.push(`export type PageServerData = ${server_data};`);
 		if (server_load) {
-			exports.push(`export type PageServerLoad = ${server_load};`);
+			exports.push(
+				`export type PageServerLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${server_load};`
+			);
+			exports.push('export type PageServerLoadEvent = Parameters<PageServerLoad>[0];');
 		}
 
 		if (group.leaf.server) {
@@ -292,12 +298,18 @@ function write_types_for_dir(config, manifest_data, routes_dir, dir, groups, ts)
 
 			exports.push(`export type LayoutData = ${data};`);
 			if (load) {
-				exports.push(`export type LayoutLoad = ${load};`);
+				exports.push(
+					`export type LayoutLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
+				);
+				exports.push('export type LayoutLoadEvent = Parameters<LayoutLoad>[0];');
 			}
 
 			exports.push(`export type LayoutServerData = ${server_data};`);
 			if (server_load) {
-				exports.push(`export type LayoutServerLoad = ${server_load};`);
+				exports.push(
+					`export type LayoutServerLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${server_load};`
+				);
+				exports.push('export type LayoutServerLoadEvent = Parameters<LayoutServerLoad>[0];');
 			}
 		}
 
@@ -311,9 +323,15 @@ function write_types_for_dir(config, manifest_data, routes_dir, dir, groups, ts)
 			/** @type {string[]} */
 			const load_exports = [];
 
+			/** @type {string[]} */
+			const load_event_exports = [];
+
 			/** @type {string[]} */
 			const server_load_exports = [];
 
+			/** @type {string[]} */
+			const server_load_event_exports = [];
+
 			for (const [name, node] of group.named_layouts) {
 				const { data, server_data, load, server_load, written_proxies } = process_node(
 					ts,
@@ -326,26 +344,39 @@ function write_types_for_dir(config, manifest_data, routes_dir, dir, groups, ts)
 				data_exports.push(`export type ${name} = ${data};`);
 				server_data_exports.push(`export type ${name} = ${server_data};`);
 				if (load) {
-					load_exports.push(`export type ${name} = ${load};`);
+					load_exports.push(
+						`export type ${name}<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
+					);
+					load_event_exports.push(`export type ${name} = Parameters<LayoutLoad.${name}>[0];`);
 				}
 				if (server_load) {
-					server_load_exports.push(`export type ${name} = ${load};`);
+					server_load_exports.push(
+						`export type ${name}<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
+					);
+					server_load_event_exports.push(
+						`export type ${name} = Parameters<LayoutServerLoad.${name}>[0];`
+					);
 				}
 			}
 
 			exports.push(`\nexport namespace LayoutData {\n\t${data_exports.join('\n\t')}\n}`);
 			exports.push(`\nexport namespace LayoutLoad {\n\t${load_exports.join('\n\t')}\n}`);
+			exports.push(`\nexport namespace LayoutLoadEvent {\n\t${load_event_exports.join('\n\t')}\n}`);
 			exports.push(
 				`\nexport namespace LayoutServerData {\n\t${server_data_exports.join('\n\t')}\n}`
 			);
 			exports.push(
 				`\nexport namespace LayoutServerLoad {\n\t${server_load_exports.join('\n\t')}\n}`
 			);
+			exports.push(
+				`\nexport namespace LayoutServerLoadEvent {\n\t${server_load_event_exports.join('\n\t')}\n}`
+			);
 		}
 	}
 
 	if (group.endpoint) {
 		exports.push(`export type RequestHandler = Kit.RequestHandler<RouteParams>;`);
+		exports.push(`export type RequestEvent = Kit.RequestEvent<RouteParams>;`);
 	}
 
 	const output = [imports.join('\n'), declarations.join('\n'), exports.join('\n')]
@@ -384,7 +415,7 @@ function process_node(ts, node, outdir, params, groups) {
 		}
 
 		server_data = get_data_type(node.server, 'load', 'null', proxy);
-		server_load = `Kit.ServerLoad<${params}, ${get_parent_type('LayoutServerData')}>`;
+		server_load = `Kit.ServerLoad<${params}, ${get_parent_type('LayoutServerData')}, OutputData>`;
 
 		if (proxy) {
 			const types = [];
@@ -415,7 +446,7 @@ function process_node(ts, node, outdir, params, groups) {
 		}
 
 		data = get_data_type(node.shared, 'load', server_data, proxy);
-		load = `Kit.Load<${params}, ${server_data}, ${get_parent_type('LayoutData')}>`;
+		load = `Kit.Load<${params}, ${server_data}, ${get_parent_type('LayoutData')}, OutputData>`;
 	} else {
 		data = server_data;
 	}
@@ -468,7 +499,7 @@ function process_node(ts, node, outdir, params, groups) {
 			parent = parent_layout.parent;
 		}
 
-		let parent_str = parent_imports[0] || 'null';
+		let parent_str = parent_imports[0] || 'Record<never, never>';
 		for (let i = 1; i < parent_imports.length; i++) {
 			// Omit is necessary because a parent could have a property with the same key which would
 			// cause a type conflict. At runtime the child overwrites the parent property in this case,

package/src/runtime/client/client.js

@@ -448,7 +448,7 @@ export function create_client({ target, base, trailing_slash }) {
 	 *   url: URL;
 	 *   params: Record<string, string>;
 	 *   routeId: string | null;
-	 * 	 server_data: import('types').JSONObject | null;
+	 * 	 server_data: Record<string, any> | null;
 	 * }} options
 	 * @returns {Promise<import('./types').BranchNode>}
 	 */

package/src/runtime/client/types.d.ts

@@ -6,7 +6,7 @@ import {
 	prefetch,
 	prefetchRoutes
 } from '$app/navigation';
-import { CSRPageNode, CSRRoute, JSONObject } from 'types';
+import { CSRPageNode, CSRRoute } from 'types';
 import { HttpError } from '../../index/private.js';
 import { SerializedHttpError } from '../server/page/types.js';
 
@@ -92,7 +92,7 @@ export interface ServerDataRedirected {
 export interface ServerDataLoaded {
 	type: 'data';
 	nodes: Array<{
-		data?: JSONObject | null; // TODO or `-1` to indicate 'reuse cached data'?
+		data?: Record<string, any> | null; // TODO or `-1` to indicate 'reuse cached data'?
 		status?: number;
 		message?: string;
 		error?: {

package/src/runtime/server/endpoint.js

@@ -29,7 +29,9 @@ export async function render_endpoint(event, route) {
 		return method_not_allowed(mod, method);
 	}
 
-	const response = await handler(event);
+	const response = await handler(
+		/** @type {import('types').RequestEvent<Record<string, any>>} */ (event)
+	);
 
 	if (!(response instanceof Response)) {
 		return new Response(

package/src/runtime/server/index.js

@@ -257,7 +257,7 @@ export async function respond(request, options, state) {
 											event,
 											node,
 											parent: async () => {
-												/** @type {import('types').JSONObject} */
+												/** @type {Record<string, any>} */
 												const data = {};
 												for (let j = 0; j < i; j += 1) {
 													const parent = await promises[j];

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

@@ -77,7 +77,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 					}
 
 					if (event.request.method === 'POST' && result?.location) {
-						return redirect_response(status, result.location);
+						return redirect_response(303, result.location);
 					}
 				} else {
 					event.setHeaders({
@@ -95,6 +95,9 @@ export async function render_page(event, route, options, state, resolve_opts) {
 			}
 		}
 
+		const should_prerender_data = nodes.some((node) => node?.server);
+		const data_pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
+
 		if (!resolve_opts.ssr) {
 			return await render_response({
 				branch: [],
@@ -137,7 +140,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 		/** @type {Error | null} */
 		let load_error = null;
 
-		/** @type {Array<Promise<import('types').JSONObject | null>>} */
+		/** @type {Array<Promise<Record<string, any> | null>>} */
 		const server_promises = nodes.map((node, i) => {
 			if (load_error) {
 				// if an error happens immediately, don't bother with the rest of the nodes
@@ -156,7 +159,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 						event,
 						node,
 						parent: async () => {
-							/** @type {import('types').JSONObject} */
+							/** @type {Record<string, any>} */
 							const data = {};
 							for (let j = 0; j < i; j += 1) {
 								Object.assign(data, await server_promises[j]);
@@ -214,6 +217,16 @@ export async function render_page(event, route, options, state, resolve_opts) {
 					const error = normalize_error(e);
 
 					if (error instanceof Redirect) {
+						if (state.prerendering && should_prerender_data) {
+							state.prerendering.dependencies.set(data_pathname, {
+								response: new Response(undefined),
+								body: JSON.stringify({
+									type: 'redirect',
+									location: error.location
+								})
+							});
+						}
+
 						return redirect_response(error.status, error.location);
 					}
 
@@ -267,19 +280,14 @@ export async function render_page(event, route, options, state, resolve_opts) {
 			}
 		}
 
-		// generate __data.json files when prerendering
-		if (state.prerendering && nodes.some((node) => node?.server)) {
-			const pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
-
-			const dependency = {
+		if (state.prerendering && should_prerender_data) {
+			state.prerendering.dependencies.set(data_pathname, {
 				response: new Response(undefined),
 				body: JSON.stringify({
 					type: 'data',
 					nodes: branch.map((branch_node) => ({ data: branch_node?.server_data }))
 				})
-			};
-
-			state.prerendering.dependencies.set(pathname, dependency);
+			});
 		}
 
 		// TODO use validation_errors

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

@@ -5,7 +5,7 @@ import { LoadURL, PrerenderingURL } from '../../../utils/url.js';
  * @param {{
  *   event: import('types').RequestEvent;
  *   node: import('types').SSRNode | undefined;
- *   parent: () => Promise<import('types').JSONObject | null>;
+ *   parent: () => Promise<Record<string, any>>;
  * }} opts
  */
 export async function load_server_data({ event, node, parent }) {
@@ -37,7 +37,7 @@ export async function load_server_data({ event, node, parent }) {
  *   fetcher: typeof fetch;
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
- *   server_data_promise: Promise<import('types').JSONObject | null>;
+ *   server_data_promise: Promise<Record<string, any> | null>;
  *   state: import('types').SSRState;
  * }} opts
  */
@@ -70,7 +70,7 @@ export async function load_data({ event, fetcher, node, parent, server_data_prom
 
 /** @param {Record<string, any>} object */
 async function unwrap_promises(object) {
-	/** @type {import('types').JSONObject} */
+	/** @type {Record<string, any>} */
 	const unwrapped = {};
 
 	for (const key in object) {

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

@@ -86,7 +86,7 @@ export async function render_response({
 			/** @type {import('types').Page} */
 			page: {
 				error,
-				params: event.params,
+				params: /** @type {Record<string, any>} */ (event.params),
 				routeId: event.routeId,
 				status,
 				url: state.prerendering ? new PrerenderingURL(event.url) : event.url,
@@ -150,9 +150,31 @@ export async function render_response({
 
 	const target = hash(body);
 
+	/**
+	 * The prefix to use for static assets. Replaces `%sveltekit.assets%` in the template
+	 * @type {string}
+	 */
+	let assets;
+
+	if (options.paths.assets) {
+		// if an asset path is specified, use it
+		assets = options.paths.assets;
+	} else if (state.prerendering?.fallback) {
+		// if we're creating a fallback page, asset paths need to be root-relative
+		assets = options.paths.base;
+	} else {
+		// otherwise we want asset paths to be relative to the page, so that they
+		// will work in odd contexts like IPFS, the internet archive, and so on
+		const segments = event.url.pathname.slice(options.paths.base.length).split('/').slice(2);
+		assets = segments.length > 0 ? segments.map(() => '..').join('/') : '.';
+	}
+
+	/** @param {string} path */
+	const prefixed = (path) => (path.startsWith('/') ? path : `${assets}/${path}`);
+
 	// prettier-ignore
 	const init_app = `
-		import { set_public_env, start } from ${s(options.prefix + entry.file)};
+		import { set_public_env, start } from ${s(prefixed(entry.file))};
 
 		set_public_env(${s(options.public_env)});
 
@@ -195,7 +217,7 @@ export async function render_response({
 	}
 
 	for (const dep of stylesheets) {
-		const path = options.prefix + dep;
+		const path = prefixed(dep);
 		const attributes = [];
 
 		if (csp.style_needs_nonce) {
@@ -217,7 +239,7 @@ export async function render_response({
 
 	if (page_config.router || page_config.hydrate) {
 		for (const dep of modulepreloads) {
-			const path = options.prefix + dep;
+			const path = prefixed(dep);
 			link_header_preloads.add(`<${encodeURI(path)}>; rel="modulepreload"; nopush`);
 			if (state.prerendering) {
 				head += `\n\t<link rel="modulepreload" href="${path}">`;
@@ -292,10 +314,6 @@ export async function render_response({
 		}
 	}
 
-	const segments = event.url.pathname.slice(options.paths.base.length).split('/').slice(2);
-	const assets =
-		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
-
 	// TODO flush chunks as early as we can
 	const html =
 		(await resolve_opts.transformPageChunk({

package/src/runtime/server/page/types.d.ts

@@ -1,4 +1,4 @@
-import { JSONValue, ResponseHeaders, SSRNode, CspDirectives } from 'types';
+import { ResponseHeaders, SSRNode, CspDirectives } from 'types';
 import { HttpError } from '../../../index/private';
 
 export interface Fetched {
@@ -21,7 +21,7 @@ export interface FetchState {
 export type Loaded = {
 	node: SSRNode;
 	data: Record<string, any> | null;
-	server_data: JSONValue;
+	server_data: any;
 };
 
 type CspMode = 'hash' | 'nonce' | 'auto';

package/src/utils/escape.js

@@ -37,7 +37,7 @@ const render_json_payload_script_regex = new RegExp(
  * Attribute names must be type-checked so we don't need to escape them.
  *
  * @param {import('types').PayloadScriptAttributes} attrs A list of attributes to be added to the element.
- * @param {import('types').JSONValue} payload The data to be carried by the element. Must be serializable to JSON.
+ * @param {any} payload The data to be carried by the element. Must be serializable to JSON.
  * @returns {string} The raw HTML of a script element carrying the JSON payload.
  * @example const html = render_json_payload_script({ type: 'data', url: '/data.json' }, { foo: 'bar' });
  */

package/src/vite/build/build_server.js

@@ -69,7 +69,6 @@ export class Server {
 			manifest,
 			method_override: ${s(config.kit.methodOverride)},
 			paths: { base, assets },
-			prefix: assets + '/',
 			prerender: {
 				default: ${config.kit.prerender.default},
 				enabled: ${config.kit.prerender.enabled}

package/src/vite/build/utils.js

@@ -88,9 +88,11 @@ export function find_deps(manifest, entry, add_dynamic_css) {
  * @return {import('vite').UserConfig}
  */
 export const get_default_config = function ({ config, input, ssr, outDir }) {
+	const prefix = `${config.kit.appDir}/immutable`;
+
 	return {
 		appType: 'custom',
-		base: assets_base(config.kit),
+		base: ssr ? assets_base(config.kit) : './',
 		build: {
 			cssCodeSplit: true,
 			// don't use the default name to avoid collisions with 'static/manifest.json'
@@ -101,11 +103,9 @@ export const get_default_config = function ({ config, input, ssr, outDir }) {
 				input,
 				output: {
 					format: 'esm',
-					entryFileNames: ssr ? '[name].js' : `${config.kit.appDir}/immutable/[name]-[hash].js`,
-					chunkFileNames: ssr
-						? 'chunks/[name].js'
-						: `${config.kit.appDir}/immutable/chunks/[name]-[hash].js`,
-					assetFileNames: `${config.kit.appDir}/immutable/assets/[name]-[hash][extname]`
+					entryFileNames: ssr ? '[name].js' : `${prefix}/[name]-[hash].js`,
+					chunkFileNames: ssr ? 'chunks/[name].js' : `${prefix}/chunks/[name]-[hash].js`,
+					assetFileNames: `${prefix}/assets/[name]-[hash][extname]`
 				},
 				preserveEntrySignatures: 'strict'
 			},
@@ -125,6 +125,14 @@ export const get_default_config = function ({ config, input, ssr, outDir }) {
 		},
 		ssr: {
 			noExternal: ['@sveltejs/kit']
+		},
+		worker: {
+			rollupOptions: {
+				output: {
+					entryFileNames: `${prefix}/workers/[name]-[hash].js`,
+					chunkFileNames: `${prefix}/workers/chunks/[name]-[hash].js`
+				}
+			}
 		}
 	};
 };
@@ -134,11 +142,7 @@ export const get_default_config = function ({ config, input, ssr, outDir }) {
  * @returns {string}
  */
 export function assets_base(config) {
-	// TODO this is so that Vite's preloading works. Unfortunately, it fails
-	// during `svelte-kit preview`, because we use a local asset path. This
-	// may be fixed in Vite 3: https://github.com/vitejs/vite/issues/2009
-	const { base, assets } = config.paths;
-	return `${assets || base}/`;
+	return config.paths.assets || config.paths.base || './';
 }
 
 const method_names = new Set(['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']);

package/src/vite/dev/index.js

@@ -286,6 +286,20 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 		}
 	});
 
+	const runtime_base = runtime_directory.startsWith(process.cwd())
+		? `/${path.relative('.', runtime_directory)}`
+		: `/@fs${
+				// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
+				runtime_directory.startsWith('/') ? '' : '/'
+		  }${runtime_directory}`;
+
+	const { set_private_env } = await vite.ssrLoadModule(`${runtime_base}/env-private.js`);
+	const { set_public_env } = await vite.ssrLoadModule(`${runtime_base}/env-public.js`);
+
+	const env = get_env(vite_config.mode, svelte_config.kit.env.publicPrefix);
+	set_private_env(env.private);
+	set_public_env(env.public);
+
 	return () => {
 		const serve_static_middleware = vite.middlewares.stack.find(
 			(middleware) =>
@@ -320,20 +334,6 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 					);
 				}
 
-				// For some reason using runtime_prefix here is buggy, since Vite will later load the modules
-				// again with a slightly different url (with the drive letter) on windows
-				const runtime_base = `/@fs${
-					// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
-					runtime_directory.startsWith('/') ? '' : '/'
-				}${runtime_directory}`;
-
-				const { set_private_env } = await vite.ssrLoadModule(`${runtime_base}/env-private.js`);
-				const { set_public_env } = await vite.ssrLoadModule(`${runtime_base}/env-public.js`);
-
-				const env = get_env(vite_config.mode, svelte_config.kit.env.publicPrefix);
-				set_private_env(env.private);
-				set_public_env(env.public);
-
 				/** @type {Partial<import('types').Hooks>} */
 				const user_hooks = resolve_entry(svelte_config.kit.files.hooks)
 					? await vite.ssrLoadModule(`/${svelte_config.kit.files.hooks}`)
@@ -432,7 +432,6 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 							base: svelte_config.kit.paths.base,
 							assets
 						},
-						prefix: '',
 						prerender: {
 							default: svelte_config.kit.prerender.default,
 							enabled: svelte_config.kit.prerender.enabled

package/src/vite/index.js

@@ -207,7 +207,7 @@ function kit() {
 			paths = {
 				build_dir: `${svelte_config.kit.outDir}/build`,
 				output_dir: `${svelte_config.kit.outDir}/output`,
-				client_out_dir: `${svelte_config.kit.outDir}/output/client/`
+				client_out_dir: `${svelte_config.kit.outDir}/output/client`
 			};
 
 			illegal_imports = new Set([
@@ -230,7 +230,7 @@ function kit() {
 			/** @type {import('vite').UserConfig} */
 			const result = {
 				appType: 'custom',
-				base: '/',
+				base: './',
 				build: {
 					rollupOptions: {
 						// Vite dependency crawler needs an explicit JS entry point

package/types/index.d.ts

@@ -7,8 +7,6 @@ import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
 	CspDirectives,
-	JSONObject,
-	JSONValue,
 	Logger,
 	MaybePromise,
 	Prerendered,
@@ -109,6 +107,13 @@ export interface Config {
 	extensions?: string[];
 	kit?: KitConfig;
 	preprocess?: any;
+	package?: {
+		source?: string;
+		dir?: string;
+		emitTypes?: boolean;
+		exports?: (filepath: string) => boolean;
+		files?: (filepath: string) => boolean;
+	};
 	[key: string]: any;
 }
 
@@ -144,12 +149,6 @@ export interface KitConfig {
 		allowed?: string[];
 	};
 	outDir?: string;
-	package?: {
-		dir?: string;
-		emitTypes?: boolean;
-		exports?(filepath: string): boolean;
-		files?(filepath: string): boolean;
-	};
 	paths?: {
 		assets?: string;
 		base?: string;
@@ -194,18 +193,18 @@ export interface HandleError {
  * rather than using `Load` directly.
  */
 export interface Load<
-	Params extends Record<string, string> = Record<string, string>,
-	InputData extends JSONObject | null = JSONObject | null,
-	ParentData extends Record<string, any> | null = Record<string, any> | null,
-	OutputData extends Record<string, any> = Record<string, any>
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	InputData extends Record<string, any> | null = Record<string, any> | null,
+	ParentData extends Record<string, any> = Record<string, any>,
+	OutputData extends Record<string, any> | void = Record<string, any> | void
 > {
-	(event: LoadEvent<Params, InputData, ParentData>): MaybePromise<OutputData | void>;
+	(event: LoadEvent<Params, InputData, ParentData>): MaybePromise<OutputData>;
 }
 
 export interface LoadEvent<
-	Params extends Record<string, string> = Record<string, string>,
-	Data extends JSONObject | null = JSONObject | null,
-	ParentData extends Record<string, any> | null = Record<string, any> | null
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	Data extends Record<string, any> | null = Record<string, any> | null,
+	ParentData extends Record<string, any> = Record<string, any>
 > {
 	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
 	params: Params;
@@ -235,7 +234,9 @@ export interface ParamMatcher {
 	(param: string): boolean;
 }
 
-export interface RequestEvent<Params extends Record<string, string> = Record<string, string>> {
+export interface RequestEvent<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
 	clientAddress: string;
 	locals: App.Locals;
 	params: Params;
@@ -260,8 +261,6 @@ export interface ResolveOptions {
 	transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
 }
 
-export type ResponseBody = JSONValue | Uint8Array | ReadableStream | Error;
-
 export class Server {
 	constructor(manifest: SSRManifest);
 	init(options: ServerInitOptions): void;
@@ -295,21 +294,23 @@ export interface SSRManifest {
  * rather than using `ServerLoad` directly.
  */
 export interface ServerLoad<
-	Params extends Record<string, string> = Record<string, string>,
-	ParentData extends JSONObject | null = JSONObject | null,
-	OutputData extends JSONObject | void = JSONObject | void
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	ParentData extends Record<string, any> = Record<string, any>,
+	OutputData extends Record<string, any> | void = Record<string, any> | void
 > {
-	(event: ServerLoadEvent<Params, ParentData>): MaybePromise<OutputData | void>;
+	(event: ServerLoadEvent<Params, ParentData>): MaybePromise<OutputData>;
 }
 
 export interface ServerLoadEvent<
-	Params extends Record<string, string> = Record<string, string>,
-	ParentData extends JSONObject | null = JSONObject | null
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	ParentData extends Record<string, any> = Record<string, any>
 > extends RequestEvent<Params> {
 	parent: () => Promise<ParentData>;
 }
 
-export interface Action<Params extends Record<string, string> = Record<string, string>> {
+export interface Action<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
 	(event: RequestEvent<Params>): MaybePromise<
 		| { status?: number; errors: Record<string, string>; location?: never }
 		| { status?: never; errors?: never; location: string }

package/types/internal.d.ts

@@ -239,7 +239,6 @@ export interface SSROptions {
 		base: string;
 		assets: string;
 	};
-	prefix: string;
 	prerender: {
 		default: boolean;
 		enabled: boolean;

package/types/private.d.ts

@@ -26,15 +26,6 @@ export interface AdapterEntry {
 	}) => MaybePromise<void>;
 }
 
-// TODO is this still used?
-export type BodyValidator<T> = {
-	[P in keyof T]: T[P] extends { [k: string]: unknown }
-		? BodyValidator<T[P]> // recurse when T[P] is an object
-		: T[P] extends BigInt | Function | Symbol
-		? never
-		: T[P];
-};
-
 // Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
 //
 // MIT License
@@ -145,20 +136,6 @@ export interface CspDirectives {
 
 export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 
-export interface JSONObject {
-	[key: string]: JSONValue;
-}
-
-export type JSONValue =
-	| string
-	| number
-	| boolean
-	| null
-	| undefined
-	| ToJSON
-	| JSONValue[]
-	| JSONObject;
-
 export interface Logger {
 	(msg: string): void;
 	success(msg: string): void;
@@ -229,8 +206,4 @@ export interface RouteSegment {
 	rest: boolean;
 }
 
-export interface ToJSON {
-	toJSON(...args: any[]): Exclude<JSONValue, ToJSON>;
-}
-
 export type TrailingSlash = 'never' | 'always' | 'ignore';

package/src/packaging/index.js

@@ -1,218 +0,0 @@
-import * as fs from 'fs';
-import { dirname, join, relative } from 'path';
-import colors from 'kleur';
-import chokidar from 'chokidar';
-import { preprocess } from 'svelte/compiler';
-import { copy, mkdirp, rimraf } from '../utils/filesystem.js';
-import { analyze, generate_pkg, resolve_lib_alias, scan, strip_lang_tags, write } from './utils.js';
-import { emit_dts, transpile_ts } from './typescript.js';
-import { write_tsconfig } from '../core/sync/write_tsconfig.js';
-
-const essential_files = ['README', 'LICENSE', 'CHANGELOG', '.gitignore', '.npmignore'];
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {string} cwd
- */
-export async function build(config, cwd = process.cwd()) {
-	const { lib } = config.kit.files;
-	const { dir } = config.kit.package;
-
-	if (!fs.existsSync(lib)) {
-		throw new Error(`${lib} does not exist`);
-	}
-
-	rimraf(dir);
-	mkdirp(dir);
-
-	// Make sure generated tsconfig is up-to-date
-	write_tsconfig(config.kit, cwd);
-
-	const files = scan(config);
-
-	if (config.kit.package.emitTypes) {
-		await emit_dts(config, cwd, files);
-	}
-
-	const pkg = generate_pkg(cwd, files);
-
-	if (!pkg.svelte && files.some((file) => file.is_svelte)) {
-		// Several heuristics in Kit/vite-plugin-svelte to tell Vite to mark Svelte packages
-		// rely on the "svelte" property. Vite/Rollup/Webpack plugin can all deal with it.
-		// See https://github.com/sveltejs/kit/issues/1959 for more info and related threads.
-		if (pkg.exports['.']) {
-			const svelte_export =
-				typeof pkg.exports['.'] === 'string'
-					? pkg.exports['.']
-					: pkg.exports['.'].import || pkg.exports['.'].default;
-			if (svelte_export) {
-				pkg.svelte = svelte_export;
-			} else {
-				console.warn(
-					'Cannot generate a "svelte" entry point because the "." entry in "exports" is not a string. If you set it by hand, please also set one of the options as a "svelte" entry point\n'
-				);
-			}
-		} else {
-			console.warn(
-				'Cannot generate a "svelte" entry point because the "." entry in "exports" is missing. Please specify one or set a "svelte" entry point yourself\n'
-			);
-		}
-	}
-
-	write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
-
-	for (const file of files) {
-		await process_file(config, file);
-	}
-
-	const whitelist = fs.readdirSync(cwd).filter((file) => {
-		const lowercased = file.toLowerCase();
-		return essential_files.some((name) => lowercased.startsWith(name.toLowerCase()));
-	});
-
-	for (const pathname of whitelist) {
-		const full_path = join(cwd, pathname);
-		if (fs.lstatSync(full_path).isDirectory()) continue; // just to be sure
-
-		const package_path = join(dir, pathname);
-		if (!fs.existsSync(package_path)) fs.copyFileSync(full_path, package_path);
-	}
-
-	const from = relative(cwd, lib);
-	const to = relative(cwd, dir);
-	console.log(colors.bold().green(`${from} -> ${to}`));
-	console.log(`Successfully built '${pkg.name}' package. To publish it to npm:`);
-	console.log(colors.bold().cyan(`  cd ${to}`));
-	console.log(colors.bold().cyan('  npm publish\n'));
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- */
-export async function watch(config, cwd = process.cwd()) {
-	await build(config, cwd);
-
-	const message = `\nWatching ${relative(cwd, config.kit.files.lib)} for changes...\n`;
-
-	console.log(message);
-
-	const { lib } = config.kit.files;
-	const { dir } = config.kit.package;
-
-	/** @type {Array<{ file: import('./types').File, type: string }>} */
-	const pending = [];
-
-	/** @type {Array<(value?: any) => void>} */
-	const fulfillers = [];
-
-	/** @type {NodeJS.Timeout} */
-	let timeout;
-
-	const watcher = chokidar.watch(lib, { ignoreInitial: true });
-	const ready = new Promise((resolve) => watcher.on('ready', resolve));
-
-	watcher.on('all', async (type, path) => {
-		const file = analyze(config, relative(lib, path));
-		if (!file.is_included) return;
-
-		pending.push({ file, type });
-
-		clearTimeout(timeout);
-		timeout = setTimeout(async () => {
-			const files = scan(config);
-
-			let should_update_pkg = false;
-
-			const events = pending.slice();
-			pending.length = 0;
-
-			for (const { file, type } of events) {
-				if ((type === 'unlink' || type === 'add') && file.is_exported) {
-					should_update_pkg = true;
-				}
-
-				if (type === 'unlink') {
-					for (const candidate of [
-						file.name,
-						`${file.base}.d.ts`,
-						`${file.base}.d.mts`,
-						`${file.base}.d.cts`
-					]) {
-						const resolved = join(dir, candidate);
-
-						if (fs.existsSync(resolved)) {
-							fs.unlinkSync(resolved);
-
-							const parent = dirname(resolved);
-							if (parent !== dir && fs.readdirSync(parent).length === 0) {
-								fs.rmdirSync(parent);
-							}
-						}
-					}
-					console.log(`Removed ${file.dest}`);
-				}
-
-				if (type === 'add' || type === 'change') {
-					await process_file(config, file);
-					console.log(`Processing ${file.name}`);
-				}
-			}
-
-			if (should_update_pkg) {
-				const pkg = generate_pkg(cwd, files);
-				write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
-				console.log('Updated package.json');
-			}
-
-			if (config.kit.package.emitTypes) {
-				await emit_dts(config, cwd, scan(config));
-				console.log('Updated .d.ts files');
-			}
-
-			console.log(message);
-
-			fulfillers.forEach((fn) => fn());
-		}, 100);
-	});
-
-	return {
-		watcher,
-		ready,
-		settled: () =>
-			new Promise((fulfil, reject) => {
-				fulfillers.push(fulfil);
-				setTimeout(() => reject(new Error('Timed out')), 1000);
-			})
-	};
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {import('./types').File} file
- */
-async function process_file(config, file) {
-	if (!file.is_included) return;
-
-	const filename = join(config.kit.files.lib, file.name);
-	const dest = join(config.kit.package.dir, file.dest);
-
-	if (file.is_svelte || file.name.endsWith('.ts')) {
-		let contents = fs.readFileSync(filename, 'utf-8');
-
-		if (file.is_svelte) {
-			if (config.preprocess) {
-				const preprocessed = (await preprocess(contents, config.preprocess, { filename })).code;
-				contents = strip_lang_tags(preprocessed);
-			}
-		}
-
-		if (file.name.endsWith('.ts') && !file.name.endsWith('.d.ts')) {
-			contents = await transpile_ts(filename, contents);
-		}
-
-		contents = resolve_lib_alias(file.name, contents, config);
-		write(dest, contents);
-	} else {
-		copy(filename, dest);
-	}
-}

package/src/packaging/types.d.ts

@@ -1,8 +0,0 @@
-export type File = {
-	name: string;
-	dest: string;
-	base: string;
-	is_included: boolean;
-	is_exported: boolean;
-	is_svelte: boolean;
-};

package/src/packaging/typescript.js

@@ -1,150 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createRequire } from 'module';
-import { posixify, mkdirp, rimraf, walk } from '../utils/filesystem.js';
-import { resolve_lib_alias, write } from './utils.js';
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {string} cwd
- * @param {import('./types').File[]} files
- */
-export async function emit_dts(config, cwd, files) {
-	const tmp = `${config.kit.outDir}/package/types`;
-	rimraf(tmp);
-	mkdirp(tmp);
-
-	const require = createRequire(import.meta.url);
-	const emit = await try_load_svelte2tsx();
-	await emit({
-		libRoot: config.kit.files.lib,
-		svelteShimsPath: require.resolve('svelte2tsx/svelte-shims.d.ts'),
-		declarationDir: path.relative(cwd, tmp)
-	});
-
-	const handwritten = new Set();
-	const excluded = new Set();
-
-	// remove excluded files, and files that conflict with hand-written .d.ts
-	for (const file of files) {
-		if (file.name.endsWith('.d.ts')) {
-			handwritten.add(file.name);
-		}
-
-		if (!file.is_included) {
-			excluded.add(file.base + '.d.ts');
-			excluded.add(file.base + '.d.mts');
-			excluded.add(file.base + '.d.cts');
-		}
-	}
-
-	// resolve $lib alias (TODO others), copy into package dir
-	for (const file of walk(tmp)) {
-		const normalized = posixify(file);
-
-		if (handwritten.has(normalized)) {
-			console.warn(`Using $lib/${normalized} instead of generated .d.ts file`);
-		}
-
-		// don't overwrite hand-written .d.ts files
-		if (excluded.has(normalized)) continue;
-
-		const source = fs.readFileSync(path.join(tmp, normalized), 'utf8');
-		write(
-			path.join(config.kit.package.dir, normalized),
-			resolve_lib_alias(normalized, source, config)
-		);
-	}
-}
-
-async function try_load_svelte2tsx() {
-	const svelte2tsx = await load();
-	const emit_dts = svelte2tsx.emitDts;
-	if (!emit_dts) {
-		throw new Error(
-			'You need to install svelte2tsx >=0.4.1 if you want to generate type definitions'
-		);
-	}
-	return emit_dts;
-
-	async function load() {
-		try {
-			return await import('svelte2tsx');
-		} catch (e) {
-			throw new Error(
-				'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'
-			);
-		}
-	}
-}
-
-/**
- * @param {string} filename
- * @param {string} source
- */
-export async function transpile_ts(filename, source) {
-	const ts = await try_load_ts();
-	return ts.transpileModule(source, {
-		compilerOptions: load_tsconfig(filename, ts),
-		fileName: filename
-	}).outputText;
-}
-
-async function try_load_ts() {
-	try {
-		return (await import('typescript')).default;
-	} catch (e) {
-		throw new Error(
-			'You need to install TypeScript if you want to transpile TypeScript files and/or generate type definitions'
-		);
-	}
-}
-
-/**
- * @param {string} filename
- * @param {import('typescript')} ts
- */
-function load_tsconfig(filename, ts) {
-	let config_filename;
-
-	// ts.findConfigFile is broken (it will favour a distant tsconfig
-	// over a near jsconfig, and then only when you call it twice)
-	// so we implement it ourselves
-	let dir = filename;
-	while (dir !== (dir = path.dirname(dir))) {
-		const tsconfig = path.join(dir, 'tsconfig.json');
-		const jsconfig = path.join(dir, 'jsconfig.json');
-
-		if (fs.existsSync(tsconfig)) {
-			config_filename = tsconfig;
-			break;
-		}
-
-		if (fs.existsSync(jsconfig)) {
-			config_filename = jsconfig;
-			break;
-		}
-	}
-
-	if (!config_filename) {
-		throw new Error('Failed to locate tsconfig or jsconfig');
-	}
-
-	const { error, config } = ts.readConfigFile(config_filename, ts.sys.readFile);
-
-	if (error) {
-		throw new Error('Malformed tsconfig\n' + JSON.stringify(error, null, 2));
-	}
-
-	// Do this so TS will not search for initial files which might take a while
-	config.include = [];
-	config.files = [];
-	const { options } = ts.parseJsonConfigFileContent(
-		config,
-		ts.sys,
-		path.dirname(config_filename),
-		{ sourceMap: false },
-		config_filename
-	);
-	return options;
-}

package/src/packaging/utils.js

@@ -1,143 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { posixify, mkdirp, walk } from '../utils/filesystem.js';
-
-/**
- * Resolves the `$lib` alias.
- *
- * TODO: make this more generic to also handle other aliases the user could have defined via
- * `kit.alias`. Also investigate how to do this in a more robust way (right now regex string
- * replacement is used).
- * For more discussion see https://github.com/sveltejs/kit/pull/2453
- *
- * @param {string} file Relative to the lib root
- * @param {string} content
- * @param {import('types').ValidatedConfig} config
- * @returns {string}
- */
-export function resolve_lib_alias(file, content, config) {
-	/**
-	 * @param {string} match
-	 * @param {string} _
-	 * @param {string} import_path
-	 */
-	const replace_import_path = (match, _, import_path) => {
-		if (!import_path.startsWith('$lib/')) {
-			return match;
-		}
-
-		const full_path = path.join(config.kit.files.lib, file);
-		const full_import_path = path.join(config.kit.files.lib, import_path.slice('$lib/'.length));
-		let resolved = posixify(path.relative(path.dirname(full_path), full_import_path));
-		resolved = resolved.startsWith('.') ? resolved : './' + resolved;
-		return match.replace(import_path, resolved);
-	};
-	content = content.replace(/from\s+('|")([^"';,]+?)\1/g, replace_import_path);
-	content = content.replace(/import\s*\(\s*('|")([^"';,]+?)\1\s*\)/g, replace_import_path);
-	return content;
-}
-
-/**
- * Strip out lang="X" or type="text/X" tags. Doing it here is only a temporary solution.
- * See https://github.com/sveltejs/kit/issues/2450 for ideas for places where it's handled better.
- *
- * @param {string} content
- */
-export function strip_lang_tags(content) {
-	return content
-		.replace(/(<!--[^]*?-->)|(<script[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2')
-		.replace(/(<!--[^]*?-->)|(<style[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2');
-}
-
-/**
- * @param {string} file
- * @param {Parameters<typeof fs.writeFileSync>[1]} contents
- */
-export function write(file, contents) {
-	mkdirp(path.dirname(file));
-	fs.writeFileSync(file, contents);
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @returns {import('./types').File[]}
- */
-export function scan(config) {
-	return walk(config.kit.files.lib).map((file) => analyze(config, file));
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {string} file
- * @returns {import('./types').File}
- */
-export function analyze(config, file) {
-	const name = posixify(file);
-
-	const svelte_extension = config.extensions.find((ext) => name.endsWith(ext));
-
-	const base = svelte_extension ? name : name.slice(0, -path.extname(name).length);
-
-	const dest = svelte_extension
-		? name.slice(0, -svelte_extension.length) + '.svelte'
-		: name.endsWith('.d.ts')
-		? name
-		: name.endsWith('.ts')
-		? name.slice(0, -3) + '.js'
-		: name;
-
-	return {
-		name,
-		dest,
-		base,
-		is_included: config.kit.package.files(name),
-		is_exported: config.kit.package.exports(name),
-		is_svelte: !!svelte_extension
-	};
-}
-
-/**
- * @param {string} cwd
- * @param {import('./types').File[]} files
- */
-export function generate_pkg(cwd, files) {
-	const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-
-	// Remove fields that are specific to the original package.json
-	// See: https://pnpm.io/package_json#publishconfigdirectory
-	delete pkg.publishConfig?.directory;
-	delete pkg.linkDirectory?.directory;
-	delete pkg.scripts;
-
-	pkg.type = 'module';
-
-	pkg.exports = {
-		'./package.json': './package.json',
-		...pkg.exports
-	};
-
-	/** @type {Record<string, string>} */
-	const clashes = {};
-
-	for (const file of files) {
-		if (file.is_included && file.is_exported) {
-			const original = `$lib/${file.name}`;
-			const entry = `./${file.dest}`;
-			const key = entry.replace(/\/index\.js$|(\/[^/]+)\.js$/, '$1');
-
-			if (clashes[key]) {
-				throw new Error(
-					`Duplicate "${key}" export. Please remove or rename either ${clashes[key]} or ${original}`
-				);
-			}
-
-			if (!pkg.exports[key]) {
-				pkg.exports[key] = entry;
-			}
-
-			clashes[key] = original;
-		}
-	}
-
-	return pkg;
-}