@sveltejs/kit 2.57.1 → 2.59.0

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

@@ -15,7 +15,7 @@ import { create_server_routing_response, generate_route_object } from './server_
 import { add_resolution_suffix } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import { get_global_name, handle_error_and_jsonify } from '../utils.js';
+import { count_non_ssi_comments, get_global_name, handle_error_and_jsonify } from '../utils.js';
 import { create_remote_key } from '../../shared.js';
 import { get_status } from '../../../utils/error.js';
 
@@ -267,25 +267,25 @@ export async function render_response({
 
 			paths.reset(); // just in case `options.root.render(...)` failed
 		}
+	} else {
+		rendered = { head: '', html: '', css: { code: '', map: null }, hashes: { script: [] } };
+	}
 
-		for (const { node } of branch) {
-			for (const url of node.imports) modulepreloads.add(url);
-			for (const url of node.stylesheets) stylesheets.add(url);
-			for (const url of node.fonts) fonts.add(url);
+	for (const { node } of branch) {
+		for (const url of node.imports) modulepreloads.add(url);
+		for (const url of node.stylesheets) stylesheets.add(url);
+		for (const url of node.fonts) fonts.add(url);
 
-			if (node.inline_styles && !client.inline) {
-				Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
-					if (typeof css === 'string') {
-						inline_styles.set(filename, css);
-						return;
-					}
+		if (node.inline_styles && !client.inline) {
+			Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
+				if (typeof css === 'string') {
+					inline_styles.set(filename, css);
+					return;
+				}
 
-					inline_styles.set(filename, css(`${assets}/${paths.app_dir}/immutable/assets`, assets));
-				});
-			}
+				inline_styles.set(filename, css(`${assets}/${paths.app_dir}/immutable/assets`, assets));
+			});
 		}
-	} else {
-		rendered = { head: '', html: '', css: { code: '', map: null }, hashes: { script: [] } };
 	}
 
 	const head = new Head(rendered.head, !!state.prerendering);
@@ -529,7 +529,10 @@ export async function render_response({
 
 					const store = internals.type === 'prerender' ? prerender : query;
 
-					if (event_state.remote.refreshes?.[remote_key] !== undefined) {
+					if (
+						event_state.remote.refreshes?.has(remote_key) ||
+						event_state.remote.reconnects?.has(remote_key)
+					) {
 						// This entry was refreshed/set by a command or form action.
 						// Always await it so the mutation result is serialized.
 						store[remote_key] = await entry.data;
@@ -691,7 +694,7 @@ export async function render_response({
 
 	if (DEV) {
 		if (page_config.csr) {
-			if (transformed.split('<!--').length < html.split('<!--').length) {
+			if (count_non_ssi_comments(transformed) < count_non_ssi_comments(html)) {
 				// the \u001B stuff is ANSI codes, so that we don't need to add a library to the runtime
 				// https://svelte.dev/playground/1b3f49696f0c44c881c34587f2537aa2?version=4.2.19
 				console.warn(

package/src/runtime/server/remote.js

@@ -121,7 +121,12 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
 					result: stringify(result, transport),
-					refreshes: result.issues ? undefined : await serialize_refreshes()
+					refreshes: result.issues
+						? undefined
+						: await serialize_singleflight(state.remote.refreshes),
+					reconnects: result.issues
+						? undefined
+						: await serialize_singleflight(state.remote.reconnects)
 				})
 			);
 		}
@@ -137,11 +142,115 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
 					result: stringify(data, transport),
-					refreshes: await serialize_refreshes()
+					refreshes: await serialize_singleflight(state.remote.refreshes),
+					reconnects: await serialize_singleflight(state.remote.reconnects)
 				})
 			);
 		}
 
+		if (internals.type === 'query_live') {
+			if (event.request.method !== 'GET') {
+				throw new SvelteKitError(
+					405,
+					'Method Not Allowed',
+					`\`query.live\` functions must be invoked via GET request, not ${event.request.method}`
+				);
+			}
+
+			const payload = /** @type {string} */ (
+				new URL(event.request.url).searchParams.get('payload')
+			);
+
+			const generator = internals.run(event, state, parse_remote_arg(payload, transport));
+
+			const encoder = new TextEncoder();
+
+			/**
+			 * @param {ReadableStreamDefaultController} controller
+			 * @param {any} payload
+			 */
+			function send(controller, payload) {
+				controller.enqueue(encoder.encode(JSON.stringify(payload) + '\n'));
+			}
+
+			let closed = false;
+
+			/** @type {string | undefined} */
+			let result = undefined;
+
+			async function cancel() {
+				if (closed) return;
+				closed = true;
+				await generator.return(undefined);
+			}
+
+			event.request.signal.addEventListener('abort', cancel, { once: true });
+
+			return new Response(
+				new ReadableStream({
+					async pull(controller) {
+						if (event.request.signal.aborted) {
+							await cancel();
+							controller.close();
+							return;
+						}
+
+						try {
+							while (true) {
+								const { value, done } = await generator.next();
+
+								if (done) {
+									await cancel();
+									controller.close();
+									return;
+								}
+
+								// only send changed data
+								if (result !== (result = stringify(value, transport))) {
+									send(controller, {
+										type: 'result',
+										result
+									});
+
+									return;
+								}
+							}
+						} catch (error) {
+							if (!event.request.signal.aborted) {
+								if (error instanceof Redirect) {
+									send(controller, {
+										type: 'redirect',
+										location: error.location
+									});
+								} else {
+									const status =
+										error instanceof HttpError || error instanceof SvelteKitError
+											? error.status
+											: 500;
+
+									send(controller, {
+										type: 'error',
+										error: await handle_error_and_jsonify(event, state, options, error),
+										status
+									});
+								}
+							}
+
+							await cancel();
+							controller.close();
+						}
+					},
+					cancel
+				}),
+				{
+					headers: {
+						'cache-control': 'private, no-store',
+						'content-type': 'application/x-ndjson'
+					}
+				}
+			);
+		}
+
 		const payload =
 			internals.type === 'prerender'
 				? additional_args
@@ -166,7 +275,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'redirect',
 					location: error.location,
-					refreshes: await serialize_refreshes()
+					refreshes: await serialize_singleflight(state.remote.refreshes),
+					reconnects: await serialize_singleflight(state.remote.reconnects)
 				})
 			);
 		}
@@ -191,16 +301,14 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		);
 	}
 
-	async function serialize_refreshes() {
-		const refreshes = state.remote.refreshes ?? {};
-
-		const entries = Object.entries(refreshes);
-		if (entries.length === 0) {
+	/** @param {Map<string, Promise<any>> | null} map */
+	async function serialize_singleflight(map) {
+		if (!map || map.size === 0) {
 			return undefined;
 		}
 
 		const results = await Promise.all(
-			entries.map(async ([key, promise]) => {
+			Array.from(map, async ([key, promise]) => {
 				try {
 					return [key, { type: 'result', data: await promise }];
 				} catch (error) {

package/src/runtime/server/respond.js

@@ -1,4 +1,4 @@
-/** @import { RequestState } from 'types' */
+/** @import { RequestState, SSRNode } from 'types' */
 import { DEV } from 'esm-env';
 import { json, text } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
@@ -152,13 +152,9 @@ export async function internal_respond(request, options, manifest, state) {
 			forms: null,
 			/** A map of remote function key to corresponding single-flight-mutation promise */
 			refreshes: null,
+			reconnects: null,
 			/** A map of remote function ID to payloads requested for refreshing by the client */
-			requested: null,
-			/**
-			 * A map of remote function ID to objects that have passed validation;
-			 * used to prevent revalidating parameters returned from `requested`
-			 */
-			validated: null
+			requested: null
 		},
 		is_in_remote_function: false,
 		is_in_render: false,
@@ -566,7 +562,14 @@ export async function internal_respond(request, options, manifest, state) {
 					page_config: { ssr: false, csr: true },
 					status: 200,
 					error: null,
-					branch: [],
+					branch: [
+						// include the root layout because it applies to every page
+						{
+							node: /** @type {SSRNode} */ (await manifest._.nodes[0]()),
+							data: null,
+							server_data: null
+						}
+					],
 					fetched: [],
 					resolve_opts,
 					data_serializer: server_data_serializer(event, event_state, options)

package/src/runtime/server/utils.js

@@ -251,3 +251,13 @@ export function get_node_type(node_id) {
 	const dot_parts = filename.split('.');
 	return dot_parts.slice(0, -1).join('.');
 }
+
+/**
+ * Counts HTML comments that are not SSI directives (which start with `<!--#`).
+ * Used to detect when `transformPageChunk` removes comments that Svelte needs for hydration.
+ * @param {string} str
+ * @returns {number}
+ */
+export function count_non_ssi_comments(str) {
+	return (str.match(/<!--(?!#)/g) ?? []).length;
+}

package/src/runtime/shared.js

@@ -1,6 +1,6 @@
 /** @import { Transport } from '@sveltejs/kit' */
 import * as devalue from 'devalue';
-import { base64_decode, base64_encode, text_decoder } from './utils.js';
+import { base64_decode, base64_encode, text_encoder } from './utils.js';
 import * as svelte from 'svelte';
 
 /**
@@ -261,7 +261,7 @@ export function stringify_remote_arg(value, transport, sort = true) {
 		create_remote_arg_reducers(transport, sort, new Map())
 	);
 
-	const bytes = new TextEncoder().encode(json_string);
+	const bytes = text_encoder.encode(json_string);
 	return base64_encode(bytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
 }
 
@@ -273,7 +273,7 @@ export function stringify_remote_arg(value, transport, sort = true) {
 export function parse_remote_arg(string, transport) {
 	if (!string) return undefined;
 
-	const json_string = text_decoder.decode(
+	const json_string = new TextDecoder().decode(
 		// no need to add back `=` characters, atob can handle it
 		base64_decode(string.replaceAll('-', '+').replaceAll('_', '/'))
 	);

package/src/runtime/utils.js

@@ -1,7 +1,6 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
-export const text_decoder = new TextDecoder();
 
 /**
  * Like node's path.relative, but without using node

package/src/types/internal.d.ts

@@ -22,7 +22,9 @@ import {
 	ClientInit,
 	Transport,
 	HandleValidationError,
-	RemoteFormIssue
+	RemoteFormIssue,
+	RemoteQuery,
+	RemoteLiveQuery
 } from '@sveltejs/kit';
 import {
 	HttpMethod,
@@ -303,6 +305,8 @@ export type RemoteFunctionResponse =
 	| (ServerRedirectNode & {
 			/** devalue'd Record<string, any> */
 			refreshes?: string;
+			/** devalue'd Record<string, any> */
+			reconnects?: string;
 	  })
 	| ServerErrorNode
 	| {
@@ -310,22 +314,33 @@ export type RemoteFunctionResponse =
 			result: string;
 			/** devalue'd Record<string, any> */
 			refreshes: string | undefined;
+			/** devalue'd Record<string, any> */
+			reconnects: string | undefined;
 	  };
 
-export type RemoteRefreshResult = {
+export type RemoteSingleflightResult = {
 	type: 'result';
 	data: any;
 };
 
-export type RemoteRefreshError = {
+export type RemoteSingleflightError = {
 	type: 'error';
 	status?: number;
 	error: App.Error;
 };
 
-export type RemoteRefreshEntry = RemoteRefreshResult | RemoteRefreshError;
+export type RemoteSingleflightEntry = RemoteSingleflightResult | RemoteSingleflightError;
 
-export type RemoteRefreshMap = Record<string, RemoteRefreshEntry>;
+export type RemoteSingleflightMap = Record<string, RemoteSingleflightEntry>;
+
+export type RemoteLiveQueryUserFunctionReturnType<Output> = MaybePromise<
+	| AsyncGenerator<Output>
+	| AsyncIterator<Output>
+	| AsyncIterable<Output>
+	| Generator<Output>
+	| Iterator<Output>
+	| Iterable<Output>
+>;
 
 /**
  * Signals a successful response of the server `load` function.
@@ -593,19 +608,41 @@ interface BaseRemoteInternals {
 export interface RemoteQueryInternals extends BaseRemoteInternals {
 	type: 'query';
 	validate: (arg?: any) => MaybePromise<any>;
+	/**
+	 * Creates a `RemoteQuery` bound directly to a specific client payload (the
+	 * stringified raw argument) and a pre-validated argument, skipping the query
+	 * wrapper's re-validation step. Used by `requested(query)` to ensure
+	 * `refresh()` / `set()` target the same cache key the client is listening on
+	 * even when the schema transforms the input.
+	 */
+	bind(payload: string, arg: any): RemoteQuery<any>;
 }
 export interface RemoteQueryLiveInternals extends BaseRemoteInternals {
 	type: 'query_live';
-	run(
-		event: RequestEvent,
-		state: RequestState,
-		arg: any
-	): Promise<{ iterator: AsyncIterator<any>; cancel: () => void }>;
+	validate: (arg?: any) => MaybePromise<any>;
+	run(event: RequestEvent, state: RequestState, arg: any): AsyncGenerator<any>;
+	/**
+	 * Creates a `RemoteLiveQuery` bound directly to a specific client payload (the
+	 * stringified raw argument) and a pre-validated argument, skipping the query
+	 * wrapper's re-validation step. Used by `requested(liveQuery)` to ensure
+	 * `reconnect()` targets the same cache key the client is listening on even
+	 * when the schema transforms the input.
+	 */
+	bind(payload: string, arg: any): RemoteLiveQuery<any>;
 }
 
 export interface RemoteQueryBatchInternals extends BaseRemoteInternals {
 	type: 'query_batch';
+	validate: (arg?: any) => MaybePromise<any>;
 	run: (args: any[], options: SSROptions) => Promise<any[]>;
+	/**
+	 * Creates a `RemoteQuery` bound directly to a specific client payload (the
+	 * stringified raw argument) and a pre-validated argument, skipping the query
+	 * wrapper's re-validation step. Used by `requested(batchQuery)` to ensure
+	 * `refresh()` / `set()` target the same cache key the client is listening on
+	 * even when the schema transforms the input.
+	 */
+	bind(payload: string, arg: any): RemoteQuery<any>;
 }
 
 export interface RemoteCommandInternals extends BaseRemoteInternals {
@@ -624,10 +661,13 @@ export interface RemotePrerenderInternals extends BaseRemoteInternals {
 	inputs?: RemotePrerenderInputsGenerator;
 }
 
-export type RemoteInternals =
+export type RemoteAnyQueryInternals =
 	| RemoteQueryInternals
-	| RemoteQueryLiveInternals
 	| RemoteQueryBatchInternals
+	| RemoteQueryLiveInternals;
+
+export type RemoteInternals =
+	| RemoteAnyQueryInternals
 	| RemoteCommandInternals
 	| RemoteFormInternals
 	| RemotePrerenderInternals;
@@ -661,9 +701,9 @@ export interface RequestState {
 			Record<string, { serialize: boolean; data: MaybePromise<any> }>
 		>;
 		forms: null | Map<any, any>;
-		refreshes: null | Record<string, Promise<any>>;
+		refreshes: null | Map<string, Promise<any>>;
+		reconnects: null | Map<string, Promise<any>>;
 		requested: null | Map<string, string[]>;
-		validated: null | Map<string, Set<any>>;
 	};
 	readonly is_in_remote_function: boolean;
 	readonly is_in_render: boolean;

package/src/utils/page_nodes.js

@@ -6,6 +6,7 @@ import {
 } from './exports.js';
 
 export class PageNodes {
+	/** All layout nodes and the page node, if any */
 	data;
 
 	/**

package/src/utils/url.js

@@ -138,12 +138,12 @@ export function make_trackable(url, callback, search_params_callback, allow_hash
 
 	if (!BROWSER) {
 		// @ts-ignore
-		tracked[Symbol.for('nodejs.util.inspect.custom')] = (depth, opts, inspect) => {
+		tracked[Symbol.for('nodejs.util.inspect.custom')] = (_depth, opts, inspect) => {
 			return inspect(url, opts);
 		};
 
 		// @ts-ignore
-		tracked.searchParams[Symbol.for('nodejs.util.inspect.custom')] = (depth, opts, inspect) => {
+		tracked.searchParams[Symbol.for('nodejs.util.inspect.custom')] = (_depth, opts, inspect) => {
 			return inspect(url.searchParams, opts);
 		};
 	}
@@ -194,7 +194,7 @@ export function disable_search(url) {
 function allow_nodejs_console_log(url) {
 	if (!BROWSER) {
 		// @ts-ignore
-		url[Symbol.for('nodejs.util.inspect.custom')] = (depth, opts, inspect) => {
+		url[Symbol.for('nodejs.util.inspect.custom')] = (_depth, opts, inspect) => {
 			return inspect(new URL(url), opts);
 		};
 	}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.57.1';
+export const VERSION = '2.59.0';