@sveltejs/kit 3.0.0-next.24 → 3.0.0-next.27

package/src/core/postbuild/prerender.js

@@ -48,11 +48,11 @@ async function prerender({
 	vite_config_file,
 	is_tty
 }) {
-	/** @type {import('@sveltejs/kit').SSRManifest} */
+	/** @type {import('types').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */
-	const { set_building, set_prerendering, set_manifest, set_read_implementation, log_response } =
+	const { set_building, set_prerendering, set_manifest, set_read_implementation, format_response } =
 		await import(pathToFileURL(`${out}/server/internal.js`).href);
 
 	// configure `import { building } from `$app/env` —
@@ -424,7 +424,7 @@ async function prerender({
 		}
 
 		if (response.status >= 400) {
-			log_response(response.status, request);
+			console.log(format_response(response.status, request));
 		}
 
 		const body = Buffer.from(await response.arrayBuffer());
@@ -659,7 +659,7 @@ async function prerender({
 	/** @type {Array<import('types').RemotePrerenderInternals>} */
 	const prerender_functions = [];
 
-	for (const loader of Object.values(manifest._.remotes)) {
+	for (const loader of Object.values(manifest.remotes)) {
 		const module = await loader();
 
 		for (const fn of Object.values(module.default)) {

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

@@ -82,7 +82,6 @@ export function create_assets(config) {
 
 	return [...walk(config.files.assets)].map((file) => ({
 		file,
-		size: fs.statSync(path.resolve(config.files.assets, file)).size,
 		type: lookup(file) || null
 	}));
 }

package/src/core/sync/write_app_manifest.js

@@ -1,4 +1,5 @@
 /** @import { Asset, ManifestData, RouteData } from 'types' */
+/** @import { ManifestRoute } from '$app/manifest' */
 
 import { s } from '../../utils/misc.js';
 import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
@@ -60,11 +61,11 @@ function stringify_assets(assets) {
 
 /**
  * @param {RouteData[] | undefined} routes
- * @returns {Array<{ id: string; page: boolean; endpoint: boolean }>}
+ * @returns {ManifestRoute[]}
  */
 export function get_manifest_routes(routes) {
 	return (
-		routes?.filter(is_app_route).map((route) => ({
+		routes?.filter(is_app_route).map((route) => /** @type {ManifestRoute} */ ({
 			id: route.id,
 			page: is_page_route(route),
 			endpoint: is_endpoint_route(route)

package/src/core/sync/write_server.js

@@ -1,5 +1,4 @@
 import path from 'node:path';
-import { hash } from '../../utils/hash.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { s } from '../../utils/misc.js';
@@ -13,7 +12,6 @@ import { runtime_directory } from '../utils.js';
  *   server_hooks: string | null;
  *   universal_hooks: string | null;
  *   config: import('types').ValidatedConfig;
- *   has_service_worker: boolean;
  *   template: string;
  *   runtime_directory: string;
  * }} opts
@@ -22,26 +20,18 @@ const server_template = ({
 	config,
 	server_hooks,
 	universal_hooks,
-	has_service_worker,
 	template,
 	runtime_directory
 }) => `
 import { set_building, set_prerendering } from '$app/env/server';
 import { set_assets } from '$app/paths/internal/server';
-import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '${runtime_directory}/server/internal.js';
+import { set_fix_stack_trace, set_manifest, set_read_implementation, format_response } from '${runtime_directory}/server/internal.js';
 import error from './shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
 	csp: ${s(config.csp)},
-	csrf_check_origin: ${s(!config.csrf.trustedOrigins.includes('*'))},
 	csrf_trusted_origins: ${s(config.csrf.trustedOrigins)},
-	embedded: ${config.embedded},
-	hash_routing: ${s(config.router.type === 'hash')},
-	hooks: null, // added lazily, via \`get_hooks\`
-	link_header_preload: ${s(config.output.linkHeaderPreload)},
-	paths_origin: ${s(config.paths.origin)},
-	service_worker: ${has_service_worker},
 	service_worker_options: ${config.serviceWorker.register ? s(config.serviceWorker.options) : 'null'},
 	templates: {
 		app: ({ head, body, assets, nonce, env }) => ${s(template)
@@ -55,9 +45,7 @@ export const options = {
 				(_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
 			)},
 		error
-	},
-	version: ${s(config.version.name)},
-	version_hash: ${s(hash(config.version.name))}
+	}
 };
 
 export async function get_hooks() {
@@ -81,7 +69,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, log_response };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, format_response };
 `;
 
 /**
@@ -125,8 +113,6 @@ export function write_server(config, output, root) {
 			runtime_directory: relative(runtime_directory),
 			server_hooks: server_hooks_file ? relative(server_hooks_file) : null,
 			universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
-			has_service_worker:
-				config.serviceWorker.register && !!resolve_entry(config.files.serviceWorker),
 			template: load_template(root, config)
 		})
 	);

package/src/core/utils.js

@@ -4,6 +4,7 @@ import { styleText } from 'node:util';
 import { to_fs } from '../utils/vite.js';
 import { noop } from '../utils/functions.js';
 import { posixify } from '../utils/os.js';
+import { hash } from '../utils/hash.js';
 
 /**
  * Resolved path of the `runtime` directory posix-ified
@@ -15,6 +16,15 @@ import { posixify } from '../utils/os.js';
  */
 export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
 
+/**
+ * The name of the `globalThis.__sveltekit_xxx` object the app's payload is attached to
+ * @param {string} version_name
+ * @param {boolean} dev
+ */
+export function get_global_name(version_name, dev) {
+	return dev ? '__sveltekit_dev' : `__sveltekit_${hash(version_name)}`;
+}
+
 /**
  * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
  * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`

package/src/exports/adapter.js

@@ -0,0 +1,22 @@
+import { REROUTED_URL_HEADER } from '../constants.js';
+
+/**
+ * Helps a catch-all request handler pass the request to a different handler if
+ * the `reroute` hook has returned a URL pathname that's different from the
+ * incoming request.
+ *
+ * If your adapter is capable of deploying multiple serverless functions, it's a
+ * good idea to also deploy a "catch-all" one to handle uncaught requests.
+ * Running this in that function allows the app's `reroute` hook to rewrite
+ * the request URL and invoke the next appropriate serverless function, if any.
+ * @param {Response} response The response returned from the SvelteKit `server.respond` function
+ * @param {(url: URL) => Response | Promise<Response>} next Your platform-specific implementation for invoking the next handler with a different request URL
+ * @returns {Response | Promise<Response>}
+ * @since 3.0.0
+ */
+export function applyReroute(response, next) {
+	const rerouted_url = response.headers.get(REROUTED_URL_HEADER);
+	if (!rerouted_url) return response;
+
+	return next(new URL(rerouted_url));
+}

package/src/exports/public.d.ts

@@ -12,11 +12,11 @@ import {
 	RequestOptions,
 	RouteSegment
 } from '../types/private.js';
-import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
+import { ValidatedConfig } from 'types';
 import { Plugin } from 'vite';
 import { RouteId as AppRouteId, LayoutParams as AppLayoutParams } from '$app/types';
-import { ParamMatcher } from '@sveltejs/kit/params';
 import { StandardSchemaV1 } from '@standard-schema/spec';
+import { getRequest, setResponse } from '@sveltejs/kit/node';
 
 export { PrerenderOption } from '../types/private.js';
 
@@ -57,20 +57,47 @@ export interface Adapter {
 	 * during dev, build and prerendering.
 	 */
 	emulate?: () => MaybePromise<Emulator>;
-	vite?: {
-		plugins?: {
-			/**
-			 * Vite plugins placed before any of SvelteKit's own plugins.
-			 * @since 3.0.0
-			 */
-			pre?: Plugin[];
-			/**
-			 * Vite plugins placed after any of SvelteKit's own plugins.
-			 * @since 3.0.0
-			 */
-			post?: Plugin[];
-		};
-	};
+	/**
+	 * Options for configuring and interacting with Vite
+	 * @since 3.0.0
+	 */
+	vite?: AdapterViteConfig | ((ctx: { config: ValidatedConfig }) => AdapterViteConfig);
+}
+
+export interface AdapterViteConfig {
+	/**
+	 * This function overrides the default behavior during Vite's dev and preview modes
+	 * to convert an `http.IncomingMessage` to a `Request` object.
+	 * To call the original `setRequest` function, import it from `@sveltejs/kit/node`.
+	 * @since 3.0.0
+	 */
+	getRequest?: typeof getRequest;
+	/**
+	 * This function overrides the default behavior in Vite's dev and preview modes
+	 * to write a `Response` object to a `http.ServerResponse`.
+	 * To call the original `setResponse` function, import it from `@sveltejs/kit/node`.
+	 * @since 3.0.0
+	 */
+	setResponse?: typeof setResponse;
+	/**
+	 * Vite plugins injected by the adapter. By default,
+	 * they are placed before SvelteKit's plugins.
+	 * @since 3.0.0
+	 */
+	plugins?:
+		| Plugin[]
+		| {
+				/**
+				 * Vite plugins placed before any of SvelteKit's own plugins.
+				 * @since 3.0.0
+				 */
+				pre?: Plugin[];
+				/**
+				 * Vite plugins placed after any of SvelteKit's own plugins.
+				 * @since 3.0.0
+				 */
+				post?: Plugin[];
+		  };
 }
 
 export type LoadProperties<input extends Record<string, any> | void> = input extends void
@@ -139,6 +166,17 @@ export interface Builder {
 	prerendered: Prerendered;
 	/** An array of all routes (including prerendered) */
 	routes: RouteDefinition[];
+	/**
+	 * The value of the `$app/manifest` module.
+	 * The only difference is `manifest.assets` also includes the service worker, if it exists.
+	 * @since 3.0.0
+	 */
+	manifest: typeof import('$app/manifest');
+	/**
+	 * A record of file extensions to MIME types
+	 * @since 3.0.0
+	 */
+	mimeTypes: Record<string, string>;
 
 	/**
 	 * Create separate functions that map to one or more routes of your app.
@@ -165,9 +203,10 @@ export interface Builder {
 	/**
 	 * Generate a server-side manifest to initialise the SvelteKit [server](https://svelte.dev/docs/kit/@sveltejs-kit#Server) with.
 	 * @param opts
-	 * @param opts.relativePath  A relative path to the base directory of the server build output
+	 * @param opts.relativePath A relative path to the base directory of the server build output
+	 * @deprecated removed in 3.0. Use `builder.generateServerInstance` or `builder.manifest` instead
 	 */
-	generateManifest: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string;
+	generateManifest?: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string;
 
 	/**
 	 * Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`.
@@ -181,6 +220,20 @@ export interface Builder {
 	/** Get the application path including any configured `base` path, e.g. `my-base-path/_app`. */
 	getAppPath: () => string;
 
+	/**
+	 * Generates a module exposing a SvelteKit [Server](https://svelte.dev/docs/kit/@sveltejs-kit#Server) instance.
+	 * @param dest
+	 * @param opts.routes A subset of the routes to include in the server's manifest
+	 * @param opts.serverDirectory The directory containing the server code. Defaults to `getServerDirectory()`.
+	 * @since 3.0.0
+	 */
+	generateServerInstance: (
+		dest: string,
+		opts?: {
+			routes?: RouteDefinition[];
+			serverDirectory?: string;
+		}
+	) => void;
 	/**
 	 * Write client assets to `dest`.
 	 * @param dest the destination folder
@@ -199,6 +252,23 @@ export interface Builder {
 	 * @returns an array of files written to `dest`
 	 */
 	writeServer: (dest: string) => string[];
+
+	/**
+	 * Generate an initializer that populates `$env/dynamic/private` before server instrumentation
+	 * runs. Include the returned module in any subsequent bundling or tracing step.
+	 * @param options an object containing the following properties:
+	 * @param options.outputDirectory the directory in which to create the initializer.
+	 * @param options.environment the contents of a module whose default export contains the platform's environment variables. If omitted, `process.env` is used.
+	 * @param options.serverDirectory the directory containing the server build output. Defaults to `getServerDirectory()`.
+	 * @returns the filesystem path to the generated initializer.
+	 * @since 3.0.0
+	 */
+	createInstrumentationInitializer: (options: {
+		outputDirectory: string;
+		environment?: string;
+		serverDirectory?: string;
+	}) => string;
+
 	/**
 	 * Copy a file or directory.
 	 * @param from the source file or directory
@@ -230,6 +300,9 @@ export interface Builder {
 	 * `entrypoint` which imports `instrumentation` and then dynamically imports `start`. This allows
 	 * the module hooks necessary for instrumentation libraries to be loaded prior to any application code.
 	 *
+	 * `initializer` is a module generated by `createInstrumentationInitializer`. It must be included
+	 * in any bundling or tracing step before calling this method.
+	 *
 	 * Caveats:
 	 * - "Live exports" will not work. If your adapter uses live exports, your users will need to manually import the server instrumentation on startup.
 	 * - If `tla` is `false`, OTEL auto-instrumentation may not work properly. Use it if your environment supports it.
@@ -239,21 +312,27 @@ export interface Builder {
 	 * @param options.entrypoint the path to the entrypoint to trace.
 	 * @param options.instrumentation the path to the instrumentation file.
 	 * @param options.start the name of the start file. This is what `entrypoint` will be renamed to.
+	 * @param options.initializer the filesystem path to the bundled or copied instrumentation initializer.
 	 * @param options.module configuration for the resulting entrypoint module.
 	 * @param options.module.exports
-	 * @param options.module.generateText a function that receives the relative paths to the instrumentation and start files, and generates the text of the module to be traced. If not provided, the default implementation will be used, which uses top-level await.
-	 * @since 2.31.0
+	 * @param options.module.generateText a function that receives the relative paths to the initializer, instrumentation and start files, and generates the text of the module to be traced. It must import `initializer` before `instrumentation`, and dynamically import `start` after instrumentation has run. If not provided, the default implementation will be used, which uses top-level await.
+	 * @since 3.0.0
 	 */
 	instrument: (args: {
 		entrypoint: string;
 		instrumentation: string;
 		start?: string;
+		initializer: string;
 		module?:
 			| {
 					exports: string[];
 			  }
 			| {
-					generateText: (args: { instrumentation: string; start: string }) => string;
+					generateText: (args: {
+						instrumentation: string;
+						start: string;
+						initializer: string;
+					}) => string;
 			  };
 	}) => void;
 
@@ -656,8 +735,7 @@ export interface RouteDefinition<Config = any> {
 	config: Config;
 }
 
-export class Server {
-	constructor(manifest: SSRManifest);
+export interface Server {
 	init(options: ServerInitOptions): Promise<void>;
 	respond(request: Request, options: RequestOptions): Promise<Response>;
 }
@@ -669,32 +747,6 @@ export interface ServerInitOptions {
 	read?: (file: string) => MaybePromise<ReadableStream | null>;
 }
 
-/**
- * Information required to instantiate a new `Server` instance.
- */
-export interface SSRManifest {
-	/** The directory where SvelteKit keeps its stuff, including static assets (such as JS and CSS) and internally-used routes. */
-	appDir: string;
-	/** The `base` and `appDir` settings combined without a leading slash. */
-	appPath: string;
-	/** Static files from `config.files.assets` and the service worker (if any). */
-	assets: Set<string>;
-	mimeTypes: Record<string, string>;
-
-	/** @internal private fields */
-	_: {
-		client: BuildData['client'];
-		nodes: SSRNodeLoader[];
-		/** hashed filename -> import to that file */
-		remotes: Record<string, () => Promise<{ default: Record<string, any> }>>;
-		routes: SSRRoute[];
-		prerendered_routes: Set<string>;
-		matchers: () => Promise<Record<string, ParamMatcher>>;
-		/** A `[file]: size` map of all assets imported by server code. */
-		server_assets: Record<string, number>;
-	};
-}
-
 /**
  * The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](https://svelte.dev/docs/kit/types#Generated-types))
  * rather than using `ServerLoad` directly.