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

package/src/runtime/server/fetch.js

@@ -2,21 +2,20 @@ import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
 import { respond } from './respond.js';
 import * as paths from '#app/paths';
-import { hooks, read_implementation } from './internal.js';
+import { hooks, manifest, read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
 import { fork_state_for_subrequest } from './state.js';
 
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
- *   manifest: import('@sveltejs/kit').SSRManifest;
  *   state: import('types').RequestState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
  *   set_internal: (name: string, value: string, opts: import('./page/types.js').Cookie['options']) => void;
  * }} opts
  * @returns {typeof fetch}
  */
-export function create_fetch({ event, manifest, state, get_cookie_header, set_internal }) {
+export function create_fetch({ event, state, get_cookie_header, set_internal }) {
 	/**
 	 * @type {typeof fetch}
 	 */
@@ -87,24 +86,24 @@ export function create_fetch({ event, manifest, state, get_cookie_header, set_in
 				).slice(1);
 				const filename_html = `${filename}/index.html`; // path may also match path/index.html
 
-				const is_asset = manifest.assets.has(filename) || filename in manifest._.server_assets;
+				const is_asset = manifest.assets.has(filename) || filename in manifest.server_assets;
 				const is_asset_html =
-					manifest.assets.has(filename_html) || filename_html in manifest._.server_assets;
+					manifest.assets.has(filename_html) || filename_html in manifest.server_assets;
 
 				if (is_asset || is_asset_html) {
 					const file = is_asset ? filename : filename_html;
 
 					if (state.read) {
 						const type = is_asset
-							? manifest.mimeTypes[filename.slice(filename.lastIndexOf('.'))]
+							? manifest.mime_types[filename.slice(filename.lastIndexOf('.'))]
 							: 'text/html';
 
 						return new Response(state.read(file), {
 							headers: type ? { 'content-type': type } : {}
 						});
-					} else if (read_implementation && file in manifest._.server_assets) {
-						const length = manifest._.server_assets[file];
-						const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+					} else if (read_implementation && file in manifest.server_assets) {
+						const length = manifest.server_assets[file];
+						const type = manifest.mime_types[file.slice(file.lastIndexOf('.'))];
 
 						return new Response(read_implementation(file), {
 							headers: {
@@ -117,7 +116,7 @@ export function create_fetch({ event, manifest, state, get_cookie_header, set_in
 					return await fetch(request);
 				}
 
-				if (has_prerendered_path(manifest, decoded)) {
+				if (has_prerendered_path(decoded)) {
 					// The path of something prerendered could match a different route
 					// that is still in the manifest, leading to the wrong route being loaded.
 					// We therefore bail early here. The prerendered logic is different for
@@ -147,7 +146,7 @@ export function create_fetch({ event, manifest, state, get_cookie_header, set_in
 					request.headers.set('accept-language', accept_language);
 				}
 
-				const response = await internal_fetch(request, manifest, state);
+				const response = await internal_fetch(request, state);
 
 				for (const str of response.headers.getSetCookie()) {
 					const { name, value, ...cookie_options } = parseSetCookie(str, { decode: (v) => v });
@@ -193,11 +192,10 @@ function normalize_fetch_input(info, init, url) {
 
 /**
  * @param {Request} request
- * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-async function internal_fetch(request, manifest, state) {
+async function internal_fetch(request, state) {
 	if (request.signal?.aborted) {
 		throw new DOMException('The operation was aborted.', 'AbortError');
 	}
@@ -205,7 +203,7 @@ async function internal_fetch(request, manifest, state) {
 	const subrequest_state = fork_state_for_subrequest(state);
 
 	if (!request.signal) {
-		return await respond(request, manifest, subrequest_state);
+		return await respond(request, subrequest_state);
 	}
 
 	let remove_abort_listener = noop;
@@ -218,7 +216,7 @@ async function internal_fetch(request, manifest, state) {
 		remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
 	});
 
-	return Promise.race([respond(request, manifest, subrequest_state), abort_promise]).finally(
+	return Promise.race([respond(request, subrequest_state), abort_promise]).finally(
 		remove_abort_listener
 	);
 }

package/src/runtime/server/index.js

@@ -58,13 +58,8 @@ if (DEV) {
 }
 
 export class Server {
-	/** @type {import('@sveltejs/kit').SSRManifest} */
-	#manifest;
-
-	/** @param {import('@sveltejs/kit').SSRManifest} manifest */
+	/** @param {import('types').SSRManifest} manifest */
 	constructor(manifest) {
-		this.#manifest = manifest;
-
 		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
 		// in `src/exports/internal/server/event.js` and handle only one request at a time.
 		if (IN_WEBCONTAINER) {
@@ -187,7 +182,7 @@ export class Server {
 	async respond(request, options) {
 		const request_state = create_request_state(options);
 
-		const response = await respond(request, this.#manifest, request_state);
+		const response = await respond(request, request_state);
 
 		if (DEV) {
 			const error = decoded_responses.get(response);
@@ -198,6 +193,12 @@ export class Server {
 			response.headers.set(REROUTED_URL_HEADER, request_state.rerouted_url);
 		}
 
+		// the HTTP layer discards HEAD response bodies, but nothing does when the server is called directly
+		if (request.method === 'HEAD' && response.body !== null) {
+			response.body.cancel().catch(noop);
+			return new Response(null, response);
+		}
+
 		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -1,5 +1,4 @@
-/** @import { SSRManifest } from '@sveltejs/kit'; */
-/** @import { ServerHooks, SSROptions } from 'types'; */
+/** @import { ServerHooks, SSROptions, SSRManifest } from 'types'; */
 import { restore, save } from './dev.js';
 import {
 	has_data_suffix,

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

@@ -1,4 +1,4 @@
-/** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
+/** @import { RequestEvent } from '@sveltejs/kit' */
 /** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode } from 'types' */
 import { text } from '@sveltejs/kit';
 import { Redirect } from '@sveltejs/kit/internal';
@@ -8,6 +8,7 @@ import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
 import { build_error_chain, nearest_error_pages } from '../../error-chain.js';
 import { redirect_response } from '../utils.js';
+import { manifest } from '../internal.js';
 import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
 	handle_action_json_request,
@@ -32,12 +33,11 @@ const MAX_DEPTH = 10;
  * @param {RequestEvent} event
  * @param {RequestState} state
  * @param {PageNodeIndexes} page
- * @param {SSRManifest} manifest
  * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, state, page, manifest, nodes, resolve_opts) {
+export async function render_page(event, state, page, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -46,7 +46,7 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 	}
 
 	if (is_action_json_request(event)) {
-		const node = await manifest._.nodes[page.leaf]();
+		const node = await manifest.nodes[page.leaf]();
 		return handle_action_json_request(event, state, node?.server);
 	}
 
@@ -61,7 +61,7 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 		if (is_action_request(event)) {
 			const remote_id = get_remote_action(event.url);
 			if (remote_id) {
-				action_result = await handle_remote_form_post(event, state, manifest, remote_id);
+				action_result = await handle_remote_form_post(event, state, remote_id);
 			} else {
 				// for action requests, first call handler in +page.server.js
 				// (this also determines status code)
@@ -149,7 +149,6 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 				error: null,
 				event,
 				state,
-				manifest,
 				resolve_opts,
 				data_serializer: server_data_serializer(event, state)
 			});
@@ -276,7 +275,7 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 					const status = error.status;
 
 					for (const { error: index, idx } of nearest_error_pages(i, branch, page.errors)) {
-						const node = await manifest._.nodes[index]();
+						const node = await manifest.nodes[index]();
 
 						data_serializer.set_max_nodes(idx);
 
@@ -291,7 +290,6 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 						return await render_response({
 							event,
 							state,
-							manifest,
 							resolve_opts,
 							page_config: {
 								ssr: nodes.ssr(),
@@ -299,7 +297,7 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 							},
 							status,
 							error,
-							error_components: await load_error_components(ssr, error_branch, page, manifest),
+							error_components: await load_error_components(ssr, error_branch, page),
 							branch: error_branch,
 							fetched,
 							data_serializer
@@ -336,7 +334,6 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 		return await render_response({
 			event,
 			state,
-			manifest,
 			resolve_opts,
 			page_config: {
 				csr,
@@ -348,7 +345,7 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 			action_result,
 			fetched,
 			data_serializer: !ssr ? server_data_serializer(event, state) : data_serializer,
-			error_components: await load_error_components(ssr, branch, page, manifest)
+			error_components: await load_error_components(ssr, branch, page)
 		});
 	} catch (e) {
 		// a remote function could have thrown a redirect during render
@@ -361,7 +358,6 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
 		return await respond_with_error({
 			event,
 			state,
-			manifest,
 			error: e,
 			resolve_opts
 		});
@@ -372,12 +368,11 @@ export async function render_page(event, state, page, manifest, nodes, resolve_o
  * @param {boolean} ssr
  * @param {Array<import('./types.js').Loaded | null>} branch
  * @param {PageNodeIndexes} page
- * @param {SSRManifest} manifest
  */
-function load_error_components(ssr, branch, page, manifest) {
+function load_error_components(ssr, branch, page) {
 	if (!ssr) return undefined;
 
 	return build_error_chain(branch, page.errors, (idx) =>
-		manifest._.nodes[idx]?.().then((e) => e.component?.())
+		manifest.nodes[idx]?.().then((e) => e.component?.())
 	);
 }

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

@@ -1,7 +1,7 @@
 import { DEV } from 'esm-env';
 import { noop } from '../../../utils/functions.js';
 import { disable_search, make_trackable } from '../../../utils/url.js';
-import { validate_depends, validate_load_response } from '../../shared.js';
+import { fetch_cache_url, validate_depends, validate_load_response } from '../../shared.js';
 import { with_request_store, merge_tracing, record_span } from '@sveltejs/kit/internal/server';
 import { base64_encode } from '../../utils.js';
 import { NULL_BODY_STATUS } from '../constants.js';
@@ -344,7 +344,7 @@ export function create_universal_fetch(event, prerendering, fetched, csr, resolv
 					}
 
 					fetched.push({
-						url: same_origin ? url.href.slice(event.url.origin.length) : url.href,
+						url: fetch_cache_url(url, event.url),
 						method: event.request.method,
 						request_body: /** @type {string | ArrayBufferView | null | undefined} */ (request_body),
 						request_headers: cloned_headers,

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

@@ -1,4 +1,5 @@
 /** @import { Component } from 'svelte'; */
+/** @import { SyncRenderOutput } from 'svelte/server' */
 import * as devalue from 'devalue';
 import { DEV } from 'esm-env';
 import { isRedirect, text } from '@sveltejs/kit';
@@ -27,7 +28,7 @@ import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 import { Props, RenderNode } from '../../props.svelte.js';
 import { has_custom_transporters, uneval } from '#app/internal/transport';
-import { options } from '../internal.js';
+import { manifest, options } from '../internal.js';
 
 // TODO rename this function/module
 
@@ -36,7 +37,6 @@ import { options } from '../internal.js';
  * @param {{
  *   branch: Array<import('./types.js').Loaded>;
  *   fetched: Array<import('./types.js').Fetched>;
- *   manifest: import('@sveltejs/kit').SSRManifest;
  *   page_config: { ssr: boolean; csr: boolean };
  *   status: number;
  *   error: App.Error | null;
@@ -51,7 +51,6 @@ import { options } from '../internal.js';
 export async function render_response({
 	branch,
 	fetched,
-	manifest,
 	page_config,
 	status,
 	error = null,
@@ -72,7 +71,7 @@ export async function render_response({
 		}
 	}
 
-	const { client } = manifest._;
+	const client = manifest.client;
 
 	const modulepreloads = new Set(client?.imports);
 	const stylesheets = new Set(client?.stylesheets);
@@ -90,8 +89,7 @@ export async function render_response({
 	// TODO if we add a client entry point one day, we will need to include inline_styles with the entry, otherwise stylesheets will be linked even if they are below inlineStyleThreshold
 	const inline_styles = new Map();
 
-	// TODO `svelte/server` should expose `RenderOutput`
-	/** @type {Omit<Awaited<ReturnType<typeof render>>, 'html'>} */
+	/** @type {Omit<SyncRenderOutput, 'html'>} */
 	let rendered;
 
 	const form_value =
@@ -286,7 +284,7 @@ export async function render_response({
 			// Vite makes the start script available through the base path and without it.
 			// We load it via the base path in order to support remote IDE environments which proxy
 			// all URLs under the base path during development.
-			return paths.base + path;
+			return relative ? `${base}/${path.slice(1)}` : paths.base + path;
 		}
 		return `${assets}/${path}`;
 	};
@@ -654,12 +652,9 @@ export async function render_response({
 		}
 	}
 
-	return !chunks
-		? text(transformed, {
-				status,
-				headers
-			})
-		: new Response(stream_text(transformed + '\n', chunks), { headers });
+	return chunks
+		? new Response(stream_text(transformed + '\n', chunks), { status, headers })
+		: text(transformed, { status, headers });
 }
 
 class Head {

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

@@ -5,6 +5,7 @@ import { redirect_response } from '../utils.js';
 import { handle_error_and_jsonify, static_error_page } from '../errors.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
+import { manifest } from '../internal.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -14,12 +15,11 @@ import { server_data_serializer } from './data_serializer.js';
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
  *   state: import('types').RequestState;
- *   manifest: import('@sveltejs/kit').SSRManifest;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({ event, state, manifest, error, resolve_opts }) {
+export async function respond_with_error({ event, state, error, resolve_opts }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
 		const transformed = await handle_error_and_jsonify(event, state, error);
@@ -30,7 +30,7 @@ export async function respond_with_error({ event, state, manifest, error, resolv
 	const fetched = [];
 	try {
 		const branch = [];
-		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
+		const default_layout = await manifest.nodes[0](); // 0 is always the root layout
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
@@ -71,7 +71,7 @@ export async function respond_with_error({ event, state, manifest, error, resolv
 					data
 				},
 				{
-					node: await manifest._.nodes[1](), // 1 is always the root error
+					node: await manifest.nodes[1](), // 1 is always the root error
 					data: null,
 					server_data: null
 				}
@@ -79,7 +79,6 @@ export async function respond_with_error({ event, state, manifest, error, resolv
 		}
 
 		return await render_response({
-			manifest,
 			page_config: {
 				ssr,
 				csr

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

@@ -1,15 +1,16 @@
-/** @import { SSRManifest } from '@sveltejs/kit' */
+/** @import { SSRManifest } from 'types' */
 import { base, assets } from '#app/paths';
 import { relative } from '$app/paths/internal/server';
 import { text } from '@sveltejs/kit';
 import { s } from '../../../utils/misc.js';
 import { find_route } from '../../../utils/routing.js';
 import { get_relative_path } from '../../utils.js';
+import { manifest } from '../internal.js';
 
 /**
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {string}
  */
 export function generate_route_object(route, url, client) {
@@ -38,23 +39,18 @@ export function generate_route_object(route, url, client) {
 function create_client_import(import_path, url) {
 	if (!import_path) return 'Promise.resolve({})';
 
-	// During DEV, Vite will make the paths absolute (e.g. /@fs/...)
-	if (import_path[0] === '/') {
-		return `import('${import_path}')`;
-	}
-
 	// During PROD, they're root-relative
-	if (assets !== '') {
+	if (assets !== '' && import_path[0] !== '/') {
 		return `import('${assets}/${import_path}')`;
 	}
 
-	if (!relative) {
-		return `import('${base}/${import_path}')`;
-	}
+	// During DEV, Vite will make the paths absolute (e.g. /@fs/...)
+	const absolute = import_path[0] === '/' ? import_path : `${base}/${import_path}`;
+	if (!relative) return `import('${absolute}')`;
 
 	// Else we make them relative to the server-side route resolution request
 	// to support IPFS, the internet archive, etc.
-	let path = get_relative_path(url.pathname, `${base}/${import_path}`);
+	let path = get_relative_path(url.pathname, absolute);
 	if (path[0] !== '.') path = `./${path}`;
 	return `import('${path}')`;
 }
@@ -62,23 +58,22 @@ function create_client_import(import_path, url) {
 /**
  * @param {string} resolved_path
  * @param {URL} url
- * @param {SSRManifest} manifest
  * @returns {Promise<Response>}
  */
-export async function resolve_route(resolved_path, url, manifest) {
-	if (!manifest._.client?.routes) {
+export async function resolve_route(resolved_path, url) {
+	if (!manifest.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
 	try {
-		const matchers = await manifest._.matchers();
-		const result = find_route(resolved_path, manifest._.client.routes, matchers);
+		const matchers = await manifest.matchers();
+		const result = find_route(resolved_path, manifest.client.routes, matchers);
 
 		return create_server_routing_response(
 			result?.route ?? null,
 			result?.params ?? {},
 			url,
-			manifest._.client
+			manifest.client
 		).response;
 	} catch {
 		return text('Error resolving route', { status: 500 });
@@ -99,29 +94,28 @@ export async function resolve_route(resolved_path, url, manifest) {
  *
  * @param {string} route_id
  * @param {URL} url
- * @param {SSRManifest} manifest
  * @returns {Response}
  */
-export function resolve_route_by_id(route_id, url, manifest) {
-	if (!manifest._.client?.routes) {
+export function resolve_route_by_id(route_id, url) {
+	if (!manifest.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
 	try {
-		const route = manifest._.client.routes.find((r) => r.id === route_id);
+		const route = manifest.client.routes.find((r) => r.id === route_id);
 
 		if (route) {
-			return create_server_routing_response(route, null, url, manifest._.client).response;
+			return create_server_routing_response(route, null, url, manifest.client).response;
 		}
 
 		// `client.routes` only contains routes with a `+page`, so a miss above doesn't mean the
 		// route doesn't exist — it might be a `+server.js`-only route. `_.routes` includes those
 		// (with `page: null`), so we can distinguish "exists but has no code" from "unknown".
-		if (manifest._.routes.some((r) => r.id === route_id && !r.page)) {
+		if (manifest.routes.some((r) => r.id === route_id && !r.page)) {
 			return text('export const endpoint_only = true;', { headers: js_headers() });
 		}
 
-		return create_server_routing_response(null, null, url, manifest._.client).response;
+		return create_server_routing_response(null, null, url, manifest.client).response;
 	} catch {
 		return text('Error resolving route', { status: 500 });
 	}
@@ -137,7 +131,7 @@ function js_headers() {
  * @param {import('types').SSRClientRoute | null} route
  * @param {Partial<Record<string, string>> | null} params
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {{response: Response, body: string}}
  */
 export function create_server_routing_response(route, params, url, client) {
@@ -164,7 +158,7 @@ export function create_server_routing_response(route, params, url, client) {
  *
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {NonNullable<SSRManifest['_']['client']>} client
+ * @param {NonNullable<SSRManifest['client']>} client
  * @returns {string}
  */
 function create_css_import(route, url, client) {

package/src/runtime/server/remote-functions.js

@@ -1,4 +1,4 @@
-/** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
+/** @import { RequestEvent } from '@sveltejs/kit' */
 /** @import { RemoteForm } from '$app/server' */
 /** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, ServerActionResult } from 'types' */
 
@@ -18,6 +18,7 @@ import {
 import { deserialize_binary_form } from '../form-utils.js';
 import { text_encoder } from '../utils.js';
 import { with_version_header } from './utils.js';
+import { manifest } from './internal.js';
 
 /**
  * How long (in milliseconds) to wait after the last message was sent before
@@ -140,7 +141,7 @@ export function create_live_query_response(event, state, internals, arg) {
 }
 
 /** @type {typeof handle_remote_call_internal} */
-export async function handle_remote_call(event, state, manifest, id) {
+export async function handle_remote_call(event, state, id) {
 	return record_span({
 		name: 'sveltekit.remote.call',
 		attributes: {
@@ -149,7 +150,7 @@ export async function handle_remote_call(event, state, manifest, id) {
 		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
 			const response = await with_request_store({ event: traced_event, state }, () =>
-				handle_remote_call_internal(traced_event, state, manifest, id)
+				handle_remote_call_internal(traced_event, state, id)
 			);
 			return with_version_header(response);
 		}
@@ -159,12 +160,11 @@ export async function handle_remote_call(event, state, manifest, id) {
 /**
  * @param {RequestEvent} event
  * @param {RequestState} state
- * @param {SSRManifest} manifest
  * @param {string} id
  */
-async function handle_remote_call_internal(event, state, manifest, id) {
+async function handle_remote_call_internal(event, state, id) {
 	const [hash, name, additional_args] = id.split('/');
-	const remotes = manifest._.remotes;
+	const remotes = manifest.remotes;
 
 	if (!Object.hasOwn(remotes, hash)) error(404);
 
@@ -311,6 +311,7 @@ async function handle_remote_call_internal(event, state, manifest, id) {
 		}
 
 		await collect_remote_data(data, event, state);
+		if (state.remote.ignored?.size) data.i = Array.from(state.remote.ignored);
 
 		return Response.json(
 			/** @type {RemoteFunctionResponse} */ ({
@@ -493,7 +494,7 @@ export async function collect_remote_data(data, event, state) {
  * @param {string[] | undefined} refreshes
  */
 function create_requested_map(refreshes) {
-	/** @type {Map<string, string[]>} */
+	/** @type {Map<string, Set<string>>} */
 	const requested = new Map();
 
 	for (const key of refreshes ?? []) {
@@ -502,9 +503,9 @@ function create_requested_map(refreshes) {
 		const existing = requested.get(parts.id);
 
 		if (existing) {
-			existing.push(parts.payload);
+			existing.add(parts.payload);
 		} else {
-			requested.set(parts.id, [parts.payload]);
+			requested.set(parts.id, new Set([parts.payload]));
 		}
 	}
 
@@ -512,7 +513,7 @@ function create_requested_map(refreshes) {
 }
 
 /** @type {typeof handle_remote_form_post_internal} */
-export async function handle_remote_form_post(event, state, manifest, id) {
+export async function handle_remote_form_post(event, state, id) {
 	return record_span({
 		name: 'sveltekit.remote.form.post',
 		attributes: {
@@ -521,7 +522,7 @@ export async function handle_remote_form_post(event, state, manifest, id) {
 		fn: (current) => {
 			const traced_event = merge_tracing(event, current);
 			return with_request_store({ event: traced_event, state }, () =>
-				handle_remote_form_post_internal(traced_event, state, manifest, id)
+				handle_remote_form_post_internal(traced_event, state, id)
 			);
 		}
 	});
@@ -530,17 +531,16 @@ export async function handle_remote_form_post(event, state, manifest, id) {
 /**
  * @param {RequestEvent} event
  * @param {RequestState} state
- * @param {SSRManifest} manifest
  * @param {string} id
  * @returns {Promise<ServerActionResult>}
  */
-async function handle_remote_form_post_internal(event, state, manifest, id) {
+async function handle_remote_form_post_internal(event, state, id) {
 	const location = get_action_location(event.url);
 	// `hash` and `name` can never contain a `/`, but the JSON-stringified key of a
 	// keyed (`form.for(key)`) instance can — rejoin the remaining segments
 	const [hash, name, ...rest] = id.split('/');
 	const action_id = rest.join('/');
-	const remotes = manifest._.remotes;
+	const remotes = manifest.remotes;
 	const module = Object.hasOwn(remotes, hash) ? await remotes[hash]() : undefined;
 
 	let form = /** @type {RemoteForm<any, any>} */ (