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

package/src/runtime/server/respond.js

@@ -45,7 +45,7 @@ import {
 } from '../pathname.js';
 import { server_data_serializer } from './page/data_serializer.js';
 import { get_remote_id, handle_remote_call } from './remote-functions.js';
-import { hooks, options } from './internal.js';
+import { hooks, manifest, options } from './internal.js';
 
 /** @type {import('types').RequiredResolveOptions['transformPageChunk']} */
 const default_transform = ({ html }) => html;
@@ -86,11 +86,10 @@ export const respond = propagate_context(internal_respond);
 
 /**
  * @param {Request} request
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-export async function internal_respond(request, manifest, state) {
+export async function internal_respond(request, state) {
 	/** URL but stripped from the potential `/__data.json` suffix and its search param  */
 	const url = new URL(request.url);
 
@@ -243,7 +242,6 @@ export async function internal_respond(request, manifest, state) {
 	// @ts-expect-error this has to be assigned lazily
 	event.fetch = create_fetch({
 		event,
-		manifest,
 		state,
 		get_cookie_header,
 		set_internal
@@ -264,7 +262,7 @@ export async function internal_respond(request, manifest, state) {
 			resolved_path =
 				(await hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
 
-			if (!manifest._.routes.length && resolved_path !== url.pathname) {
+			if (!manifest.routes.length && resolved_path !== url.pathname) {
 				state.rerouted_url = denormalise_url({
 					request_url: request.url,
 					resolved_path,
@@ -306,7 +304,7 @@ export async function internal_respond(request, manifest, state) {
 		// the resolved path has been decoded so it should be compared to the decoded url pathname
 		resolved_path !== decode_pathname(url.pathname) &&
 		!state.prerendering?.fallback &&
-		has_prerendered_path(manifest, resolved_path)
+		has_prerendered_path(resolved_path)
 	) {
 		const url = denormalise_url({
 			request_url: request.url,
@@ -347,10 +345,10 @@ export async function internal_respond(request, manifest, state) {
 
 	if (is_route_resolution_request) {
 		if (is_route_id_resolution_request) {
-			return resolve_route_by_id(extract_route_id(resolved_path), new URL(request.url), manifest);
+			return resolve_route_by_id(extract_route_id(resolved_path), new URL(request.url));
 		}
 
-		return resolve_route(resolved_path, new URL(request.url), manifest);
+		return resolve_route(resolved_path, new URL(request.url));
 	}
 
 	if (resolved_path === `/${app_dir}/env.js`) {
@@ -366,8 +364,8 @@ export async function internal_respond(request, manifest, state) {
 
 	if (!state.prerendering?.fallback && !skip_route_resolution) {
 		try {
-			const matchers = await manifest._.matchers();
-			const result = find_route(resolved_path, manifest._.routes, matchers);
+			const matchers = await manifest.matchers();
+			const result = find_route(resolved_path, manifest.routes, matchers);
 
 			if (result) {
 				route = result.route;
@@ -382,9 +380,7 @@ export async function internal_respond(request, manifest, state) {
 	}
 
 	try {
-		page_nodes = route?.page
-			? new PageNodes(await load_page_nodes(route.page, manifest))
-			: undefined;
+		page_nodes = route?.page ? new PageNodes(await load_page_nodes(route.page)) : undefined;
 
 		// determine whether we need to redirect to add/remove a trailing slash
 		if (route && !remote_id) {
@@ -600,7 +596,6 @@ export async function internal_respond(request, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					manifest,
 					error: new SvelteKitError(
 						400,
 						'Malformed URI',
@@ -614,14 +609,13 @@ export async function internal_respond(request, manifest, state) {
 				return await render_response({
 					event,
 					state,
-					manifest,
 					page_config: { ssr: false, csr: true },
 					status: 200,
 					error: null,
 					branch: [
 						// include the root layout because it applies to every page
 						{
-							node: /** @type {SSRNode} */ (await manifest._.nodes[0]()),
+							node: /** @type {SSRNode} */ (await manifest.nodes[0]()),
 							data: null,
 							server_data: null
 						}
@@ -633,7 +627,7 @@ export async function internal_respond(request, manifest, state) {
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, state, manifest, remote_id);
+				return await handle_remote_call(event, state, remote_id);
 			}
 
 			if (route) {
@@ -643,14 +637,7 @@ export async function internal_respond(request, manifest, state) {
 				let response;
 
 				if (is_data_request) {
-					response = await render_data(
-						event,
-						state,
-						route,
-						manifest,
-						invalidated_data_nodes,
-						trailing_slash
-					);
+					response = await render_data(event, state, route, invalidated_data_nodes, trailing_slash);
 				} else {
 					let endpoint;
 					if (
@@ -677,17 +664,10 @@ export async function internal_respond(request, manifest, state) {
 						if (!page_nodes) {
 							throw new Error('page_nodes not found. This should never happen');
 						} else if (page_methods.has(method)) {
-							response = await render_page(
-								event,
-								state,
-								route.page,
-								manifest,
-								page_nodes,
-								resolve_opts
-							);
+							response = await render_page(event, state, route.page, page_nodes, resolve_opts);
 						} else {
 							const allowed_methods = new Set(allowed_page_methods);
-							const node = await manifest._.nodes[route.page.leaf]();
+							const node = await manifest.nodes[route.page.leaf]();
 							if (node?.server?.actions) {
 								allowed_methods.add('POST');
 							}
@@ -769,7 +749,6 @@ export async function internal_respond(request, manifest, state) {
 						event,
 						state,
 						{ page: { layouts: [], leaf: 0 } },
-						manifest,
 						invalidated_data_nodes,
 						// there is no route to take a trailing slash option from, and the
 						// SSR'd error page sees the pathname as-is
@@ -787,7 +766,6 @@ export async function internal_respond(request, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					manifest,
 					error: new SvelteKitError(404, 'Not Found', `Not found: ${event.url.pathname}`),
 					resolve_opts
 				});
@@ -824,13 +802,12 @@ export async function internal_respond(request, manifest, state) {
 
 /**
  * @param {import('types').PageNodeIndexes} page
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  */
-export function load_page_nodes(page, manifest) {
+export function load_page_nodes(page) {
 	return Promise.all([
 		// we use == here rather than === because [undefined] serializes as "[null]"
-		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-		manifest._.nodes[page.leaf]()
+		...page.layouts.map((n) => (n == undefined ? n : manifest.nodes[n]())),
+		manifest.nodes[page.leaf]()
 	]);
 }
 

package/src/runtime/server/state.js

@@ -9,6 +9,7 @@ function transient_fields() {
 			implicit: null,
 			forms: null,
 			requested: null,
+			ignored: null,
 			batches: null,
 			live_iterators: null
 		},

package/src/runtime/server/utils.js

@@ -1,5 +1,6 @@
 import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
+import { manifest } from './internal.js';
 
 /**
  * @param {Partial<Record<import('types').HttpMethod, any>>} mod
@@ -98,13 +99,12 @@ export function serialize_uses(node) {
 
 /**
  * Returns `true` if the given path was prerendered
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {string} pathname Should include the base and be decoded
  */
-export function has_prerendered_path(manifest, pathname) {
+export function has_prerendered_path(pathname) {
 	return (
-		manifest._.prerendered_routes.has(pathname) ||
-		(pathname.at(-1) === '/' && manifest._.prerendered_routes.has(pathname.slice(0, -1)))
+		manifest.prerendered_routes.has(pathname) ||
+		(pathname.at(-1) === '/' && manifest.prerendered_routes.has(pathname.slice(0, -1)))
 	);
 }
 

package/src/runtime/shared.js

@@ -15,6 +15,15 @@ export function validate_depends(route_id, dep) {
 	}
 }
 
+/**
+ * Same-origin urls are keyed by path, so prerendered pages can be served from any origin
+ * @param {URL} url
+ * @param {{ origin: string }} page
+ */
+export function fetch_cache_url(url, page) {
+	return url.origin === page.origin ? url.href.slice(page.origin.length) : url.href;
+}
+
 export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';
 
 export const TRAILING_SLASH_PARAM = 'x-sveltekit-trailing-slash';

package/src/types/ambient-private.d.ts

@@ -1,7 +1,6 @@
 /** Internal version of $app/server */
 declare module '<sveltekit:generated>/server.js' {
-	import { SSRManifest } from '@sveltejs/kit';
-	import { SSROptions, ServerHooks } from 'types';
+	import { SSROptions, ServerHooks, SSRManifest } from 'types';
 
 	export const options: SSROptions;
 	export const get_hooks: () => Promise<Partial<ServerHooks>>;

package/src/types/internal.d.ts

@@ -7,12 +7,14 @@ import {
 	ServerInitOptions,
 	Actions,
 	RequestEvent,
-	SSRManifest,
 	Emulator,
-	HttpError
+	HttpError,
+	Adapter,
+	AdapterViteConfig
 } from '@sveltejs/kit';
 import { RemoteFormIssue, RemoteQuery, RemoteLiveQuery } from '$app/server';
 import { Config } from '@sveltejs/kit/vite';
+import { ParamMatcher } from '@sveltejs/kit/params';
 import {
 	ClientInit,
 	Handle,
@@ -53,7 +55,6 @@ export interface ServerInternalModule {
 
 export interface Asset {
 	file: string;
-	size: number;
 	type: string | null;
 }
 
@@ -194,7 +195,8 @@ export interface InternalRequestOptions extends RequestOptions {
 	emulator?: Emulator;
 }
 
-export class InternalServer extends Server {
+export class InternalServer implements Server {
+	constructor(manifest: SSRManifest);
 	init(options: ServerInitOptions): Promise<void>;
 	respond(request: Request, options: InternalRequestOptions): Promise<Response>;
 }
@@ -342,6 +344,8 @@ export type RemoteFunctionData = {
 	f?: Record<string, RemoteFunctionDataNode>;
 	/** Whether there were any refreshes/reconnects during the request */
 	r?: true;
+	/** Client-requested updates that the server intentionally ignored */
+	i?: string[];
 	/** The redirect location, if any */
 	redirect?: string;
 };
@@ -457,6 +461,42 @@ export interface ServerNode {
 	entries?: PrerenderEntryGenerator;
 }
 
+/**
+ * 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.
+	 */
+	app_dir: string;
+	/**
+	 * The `base` and `appDir` settings combined without a leading slash.
+	 */
+	app_path: string;
+	/**
+	 * Static files from `config.files.assets` and the service worker (if any).
+	 */
+	assets: Set<string>;
+	/**
+	 * Map of file extensions to MIME types
+	 */
+	mime_types: Record<string, string>;
+	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>;
+}
+
 export interface SSRNode {
 	/** index into the `nodes` array in the generated `client/app.js`. */
 	index: number;
@@ -553,7 +593,8 @@ export interface Uses {
 	search_params: Set<string>;
 }
 
-export type ValidatedConfig = RecursiveRequired<Omit<Config, 'preprocess'>> & {
+export type ValidatedConfig = RecursiveRequired<Omit<Config, 'preprocess' | 'adapter'>> & {
+	adapter: Adapter & { vite?: AdapterViteConfig };
 	preprocess: Config['preprocess'];
 };
 
@@ -716,7 +757,9 @@ export interface RequestState {
 		/** Instances created via `myForm.for(...)` */
 		forms: null | Map<string, any>;
 		/** A map of remote function ID to payloads requested for refreshing by the client */
-		requested: null | Map<string, string[]>;
+		requested: null | Map<string, Set<string>>;
+		/** Client-requested updates intentionally ignored by `requested(...).ignoreAll()` or `ignore` */
+		ignored: null | Set<string>;
 		/** A map of query.batch ID to payloads requested for that batch within the same macrotask */
 		batches: null | Map<
 			string,

package/src/utils/filesystem.js

@@ -16,46 +16,58 @@ export function copy(source, target, opts = {}) {
 	/** @type {string[]} */
 	const files = [];
 
-	const prefix = posixify(target) + '/';
-
 	const regex = opts.replace
 		? new RegExp(`\\b(${Object.keys(opts.replace).join('|')})\\b`, 'g')
 		: null;
 
+	/** @type {string | undefined} */
+	let created;
+
 	/**
 	 * @param {string} from
 	 * @param {string} to
+	 * @param {string} file posix path of `to` relative to `target`, empty when copying a single file
+	 * @param {boolean} is_directory
 	 */
-	function go(from, to) {
+	function go(from, to, file, is_directory) {
 		if (opts.filter && !opts.filter(path.basename(from))) return;
 
-		const stats = fs.statSync(from);
-
-		if (stats.isDirectory()) {
-			fs.readdirSync(from).forEach((file) => {
-				go(path.join(from, file), path.join(to, file));
-			});
-		} else {
-			fs.mkdirSync(path.dirname(to), { recursive: true });
-
-			if (opts.replace) {
-				const data = fs.readFileSync(from, 'utf-8');
-				fs.writeFileSync(
-					to,
-					data.replace(
-						/** @type {RegExp} */ (regex),
-						(_match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
-					)
+		if (is_directory) {
+			for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+				const child = path.join(from, entry.name);
+				go(
+					child,
+					path.join(to, entry.name),
+					file ? `${file}/${entry.name}` : entry.name,
+					entry.isSymbolicLink() ? fs.statSync(child).isDirectory() : entry.isDirectory()
 				);
-			} else {
-				fs.copyFileSync(from, to);
 			}
+			return;
+		}
 
-			files.push(to === target ? posixify(path.basename(to)) : posixify(to).replace(prefix, ''));
+		const dir = path.dirname(to);
+		if (dir !== created) {
+			fs.mkdirSync(dir, { recursive: true });
+			created = dir;
 		}
+
+		if (opts.replace) {
+			const data = fs.readFileSync(from, 'utf-8');
+			fs.writeFileSync(
+				to,
+				data.replace(
+					/** @type {RegExp} */ (regex),
+					(_match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
+				)
+			);
+		} else {
+			fs.copyFileSync(from, to);
+		}
+
+		files.push(file || posixify(path.basename(to)));
 	}
 
-	go(source, target);
+	go(source, target, '', fs.statSync(source).isDirectory());
 
 	return files;
 }
@@ -67,9 +79,13 @@ export function copy(source, target, opts = {}) {
  * @returns {Generator<string>} the posix paths of all found files, relative to `cwd`
  */
 export function* walk(cwd, dir = '') {
-	for (const file of fs.readdirSync(path.join(cwd, dir))) {
-		const joined = dir ? `${dir}/${file}` : file;
-		if (fs.statSync(path.join(cwd, joined)).isDirectory()) {
+	for (const entry of fs.readdirSync(path.join(cwd, dir), { withFileTypes: true })) {
+		const joined = dir ? `${dir}/${entry.name}` : entry.name;
+		const is_directory = entry.isSymbolicLink()
+			? fs.statSync(path.join(cwd, joined)).isDirectory()
+			: entry.isDirectory();
+
+		if (is_directory) {
 			yield* walk(cwd, joined);
 		} else {
 			yield joined;

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '3.0.0-next.25';
+export const VERSION = '3.0.0-next.27';