@sveltejs/kit 3.0.0-next.1 → 3.0.0-next.3

package/src/exports/vite/utils.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { posixify } from '../../utils/os.js';
 import { negotiate } from '../../utils/http.js';
 import { escape_html } from '../../utils/escape.js';
+import { stackless } from '../../utils/error.js';
 import { dedent } from '../../core/sync/utils.js';
 import {
 	app_server,
@@ -148,18 +149,6 @@ export function normalize_id(id, lib, cwd) {
 	return posixify(id);
 }
 
-/**
- * For times when you need to throw an error, but without
- * displaying a useless stack trace (since the developer
- * can't do anything useful with it)
- * @param {string} message
- */
-export function stackless(message) {
-	const error = new Error(message);
-	error.stack = '';
-	return error;
-}
-
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**

package/src/runtime/app/server/remote/command.js

@@ -77,9 +77,6 @@ export function command(validate_or_fn, maybe_fn) {
 			);
 		}
 
-		state.remote.refreshes ??= new Map();
-		state.remote.reconnects ??= new Map();
-
 		const promise = Promise.resolve(
 			run_remote_function(event, state, true, () => validate(arg), fn)
 		);

package/src/runtime/app/server/remote/form.js

@@ -9,7 +9,7 @@ import {
 	normalize_issue,
 	flatten_issues
 } from '../../../form-utils.js';
-import { get_cache, run_remote_function } from './shared.js';
+import { get_cache, get_implicit_lookup, run_remote_function } from './shared.js';
 import { ValidationError } from '@sveltejs/kit/internal';
 
 /**
@@ -108,9 +108,6 @@ export function form(validate_or_fn, maybe_fn) {
 						data = validated.value;
 					}
 
-					state.remote.refreshes ??= new Map();
-					state.remote.reconnects ??= new Map();
-
 					const issue = create_issues();
 
 					try {
@@ -133,7 +130,12 @@ export function form(validate_or_fn, maybe_fn) {
 				// We don't need to care about args or deduplicating calls, because uneval results are only relevant in full page reloads
 				// where only one form submission is active at the same time
 				if (!event.isRemoteRequest) {
-					get_cache(__, state)[''] ??= { serialize: true, data: output };
+					const cache = get_cache(__, state);
+					cache[''] ??= output;
+
+					// register under the client-side action id so the output is serialized
+					// into the page, allowing the hydrated client to restore `result`/`issues`/`input`
+					get_implicit_lookup(__, state)[__.action_id ?? __.id] = () => cache[''];
 				}
 
 				return output;
@@ -149,28 +151,30 @@ export function form(validate_or_fn, maybe_fn) {
 
 		Object.defineProperty(instance, 'fields', {
 			get() {
+				// the form instance is created once per module and shared across requests,
+				// so the current request's state has to be resolved at access time
 				return create_field_proxy(
 					{},
-					() => get_cache(__)?.['']?.data?.input ?? {},
+					() => get_cache(__, get_request_store().state)?.['']?.input ?? {},
 					(path, value) => {
-						const cache = get_cache(__);
+						const cache = get_cache(__, get_request_store().state);
 						const entry = cache[''];
 
-						if (entry?.data?.submission) {
+						if (entry?.submission) {
 							// don't override a submission
 							return;
 						}
 
 						if (path.length === 0) {
-							(cache[''] ??= { serialize: true, data: {} }).data.input = value;
+							(cache[''] ??= {}).input = value;
 							return;
 						}
 
-						const input = entry?.data?.input ?? {};
+						const input = entry?.input ?? {};
 						deep_set(input, path.map(String), value);
-						(cache[''] ??= { serialize: true, data: {} }).data.input = input;
+						(cache[''] ??= {}).input = input;
 					},
-					() => flatten_issues(get_cache(__)?.['']?.data?.issues ?? [])
+					() => flatten_issues(get_cache(__, get_request_store().state)?.['']?.issues ?? [])
 				);
 			}
 		});
@@ -178,7 +182,7 @@ export function form(validate_or_fn, maybe_fn) {
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
-					return get_cache(__)?.['']?.data?.result;
+					return get_cache(__, get_request_store().state)?.['']?.result;
 				} catch {
 					return undefined;
 				}
@@ -222,6 +226,7 @@ export function form(validate_or_fn, maybe_fn) {
 					if (!instance) {
 						instance = create_instance(key);
 						instance.__.id = `${__.id}/${encodeURIComponent(JSON.stringify(key))}`;
+						instance.__.action_id = `${__.id}/${JSON.stringify(key)}`;
 						instance.__.name = __.name;
 
 						state.remote.forms.set(cache_key, instance);

package/src/runtime/app/server/remote/prerender.js

@@ -1,7 +1,7 @@
 /** @import { RemoteResource, RemotePrerenderFunction } from '@sveltejs/kit' */
 /** @import { RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-import { error, json } from '@sveltejs/kit';
+import { json, error } from '@sveltejs/kit';
 import { DEV } from 'esm-env';
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { stringify, stringify_remote_arg } from '../../../shared.js';
@@ -9,7 +9,6 @@ import { noop } from '../../../../utils/functions.js';
 import { app_dir, base } from '$app/paths/internal/server';
 import {
 	create_validator,
-	get_cache,
 	get_response,
 	parse_remote_response,
 	run_remote_function
@@ -89,51 +88,46 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 
 	/** @type {RemotePrerenderFunction<Input, Output> & { __: RemotePrerenderInternals }} */
 	const wrapper = (arg) => {
+		const { event, state } = get_request_store();
+		const payload = stringify_remote_arg(arg, state.transport);
+
+		// `get_response` (as opposed to bare `get_cache`) also registers the call in the
+		// implicit lookup, so that the result is inlined into the page payload (`data.p`)
+		// and the client doesn't need to fetch it again upon hydration
 		/** @type {Promise<Output> & Partial<RemoteResource<Output>>} */
-		const promise = (async () => {
-			const { event, state } = get_request_store();
-			const payload = stringify_remote_arg(arg, state.transport);
+		const promise = get_response(__, payload, state, async () => {
 			const id = __.id;
 			const url = `${base}/${app_dir}/remote/${id}${payload ? `/${payload}` : ''}`;
 
 			if (!state.prerendering && !DEV && !event.isRemoteRequest) {
 				try {
-					return await get_response(__, payload, state, async () => {
-						const cache = get_cache(__, state);
-
-						// TODO adapters can provide prerendered data more efficiently than
-						// fetching from the public internet
-						const promise = (cache[payload] ??= {
-							serialize: true,
-							data: fetch(new URL(url, event.url.origin).href).then(async (response) => {
-								if (!response.ok) {
-									throw new Error('Prerendered response not found');
-								}
-
-								const prerendered = await response.json();
-
-								if (prerendered.type === 'error') {
-									error(prerendered.status, prerendered.error);
-								}
-
-								return prerendered.result;
-							})
-						}).data;
-
-						return parse_remote_response(await promise, state.transport);
-					});
+					// TODO adapters can provide prerendered data more efficiently than
+					// fetching from the public internet
+					const response = await fetch(new URL(url, event.url.origin).href);
+
+					if (!response.ok) {
+						throw new Error('Prerendered response not found');
+					}
+
+					const prerendered = /** @type {RemoteFunctionResponse} */ await response.json();
+
+					if (prerendered.type === 'error') {
+						error(prerendered.status, prerendered.error);
+					}
+
+					return parse_remote_response(prerendered.data, state.transport)._;
 				} catch {
 					// not available prerendered, fallback to normal function
 				}
 			}
 
+			// during a prerender run, the same function might be invoked while rendering
+			// multiple pages — share the result across the entire run
 			if (state.prerendering?.remote_responses.has(url)) {
 				return /** @type {Promise<any>} */ (state.prerendering.remote_responses.get(url));
 			}
 
-			const promise = get_response(__, payload, state, () =>
-				run_remote_function(event, state, false, () => validate(arg), fn)
-			);
+			const promise = run_remote_function(event, state, false, () => validate(arg), fn);
 
 			if (state.prerendering) {
 				state.prerendering.remote_responses.set(url, promise);
@@ -142,7 +136,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 			const result = await promise;
 
 			if (state.prerendering) {
-				const body = { type: 'result', result: stringify(result, state.transport) };
+				const body = { type: 'result', data: stringify({ _: result }, state.transport) };
 				state.prerendering.dependencies.set(url, {
 					body: JSON.stringify(body),
 					response: json(body)
@@ -151,7 +145,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 
 			// TODO this is missing error/loading/current/status
 			return result;
-		})();
+		});
 
 		promise.catch(noop);
 

package/src/runtime/app/server/remote/query.js

@@ -1,8 +1,8 @@
-/** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction } from '@sveltejs/kit' */
+/** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestEvent } from '@sveltejs/kit' */
 /** @import { RemoteInternals, MaybePromise, RequestState, RemoteQueryLiveInternals, RemoteQueryBatchInternals, RemoteQueryInternals, RemoteLiveQueryUserFunctionReturnType } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, stringify, stringify_remote_arg } from '../../../shared.js';
+import { create_remote_key, stringify_remote_arg } from '../../../shared.js';
 import { prerendering } from '$app/env/internal';
 import {
 	create_validator,
@@ -11,10 +11,10 @@ import {
 	run_remote_function,
 	run_remote_generator
 } from './shared.js';
-import { handle_error_and_jsonify } from '../../../server/utils.js';
-import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 import { noop } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
+import { handle_error_and_jsonify } from '../../../server/utils.js';
+import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -78,8 +78,14 @@ export function query(validate_or_fn, maybe_fn) {
 		bind(payload, validated_arg) {
 			const { event, state } = get_request_store();
 
-			return create_query_resource(__, payload, state, () =>
-				run_remote_function(event, state, false, () => validated_arg, fn)
+			return create_query_resource(__, payload, event, state, () =>
+				run_remote_function(
+					event,
+					{ ...state, is_in_remote_query: true },
+					false,
+					() => validated_arg,
+					fn
+				)
 			);
 		}
 	};
@@ -95,8 +101,14 @@ export function query(validate_or_fn, maybe_fn) {
 		const { event, state } = get_request_store();
 		const payload = stringify_remote_arg(arg, state.transport);
 
-		return create_query_resource(__, payload, state, () =>
-			run_remote_function(event, state, false, () => validate(arg), fn)
+		return create_query_resource(__, payload, event, state, () =>
+			run_remote_function(
+				event,
+				{ ...state, is_in_remote_query: true },
+				false,
+				() => validate(arg),
+				fn
+			)
 		);
 	};
 
@@ -152,7 +164,14 @@ function live(validate_or_fn, maybe_fn) {
 	 * @param {any} get_input
 	 */
 	const run = (event, state, get_input) =>
-		run_remote_generator(event, state, false, get_input, fn, __.name);
+		run_remote_generator(
+			event,
+			{ ...state, is_in_remote_query: true },
+			false,
+			get_input,
+			fn,
+			__.name
+		);
 
 	/** @type {RemoteQueryLiveInternals} */
 	const __ = {
@@ -164,7 +183,7 @@ function live(validate_or_fn, maybe_fn) {
 		bind(payload, validated_arg) {
 			const { event, state } = get_request_store();
 
-			return create_live_query_resource(__, payload, state, event.request.signal, () =>
+			return create_live_query_resource(__, payload, event, state, () =>
 				run(event, state, () => validated_arg)
 			);
 		}
@@ -181,7 +200,7 @@ function live(validate_or_fn, maybe_fn) {
 		const { event, state } = get_request_store();
 		const payload = stringify_remote_arg(arg, state.transport);
 
-		return create_live_query_resource(__, payload, state, event.request.signal, () =>
+		return create_live_query_resource(__, payload, event, state, () =>
 			run(event, state, () => validate(arg))
 		);
 	};
@@ -273,7 +292,7 @@ function batch(validate_or_fn, maybe_fn) {
 				try {
 					return await run_remote_function(
 						event,
-						state,
+						{ ...state, is_in_remote_query: true },
 						false,
 						async () => Promise.all(entries.map((entry) => entry.get_validated())),
 						async (input) => {
@@ -316,7 +335,7 @@ function batch(validate_or_fn, maybe_fn) {
 
 			return run_remote_function(
 				event,
-				state,
+				{ ...state, is_in_remote_query: true },
 				false,
 				async () => Promise.all(args.map(validate)),
 				async (/** @type {any[]} */ input) => {
@@ -326,7 +345,7 @@ function batch(validate_or_fn, maybe_fn) {
 						input.map(async (arg, i) => {
 							try {
 								const data = get_result(arg, i);
-								return { type: 'result', data: stringify(data, state.transport) };
+								return { type: 'result', data };
 							} catch (error) {
 								return {
 									type: 'error',
@@ -343,9 +362,11 @@ function batch(validate_or_fn, maybe_fn) {
 			);
 		},
 		bind(payload, validated_arg) {
-			const { state } = get_request_store();
+			const { event, state } = get_request_store();
 
-			return create_query_resource(__, payload, state, () => enqueue(payload, () => validated_arg));
+			return create_query_resource(__, payload, event, state, () =>
+				enqueue(payload, () => validated_arg)
+			);
 		}
 	};
 
@@ -357,10 +378,10 @@ function batch(validate_or_fn, maybe_fn) {
 			);
 		}
 
-		const { state } = get_request_store();
+		const { event, state } = get_request_store();
 		const payload = stringify_remote_arg(arg, state.transport);
 
-		return create_query_resource(__, payload, state, () =>
+		return create_query_resource(__, payload, event, state, () =>
 			// Collect all the calls to the same query in the same macrotask,
 			// then execute them as one backend request.
 			enqueue(payload, () => validate(arg))
@@ -372,14 +393,53 @@ function batch(validate_or_fn, maybe_fn) {
 	return wrapper;
 }
 
+/**
+ * Include this value in the returned payload...
+ * @param {RequestEvent} event
+ * @param {RequestState} state
+ * @param {RemoteInternals} internals
+ * @param {string} payload
+ * @param {() => Promise<any>} fn
+ */
+export function refresh(event, state, internals, payload, fn) {
+	if (!internals.id) {
+		// unless this is a non-exported (i.e. private) query...
+		return;
+	}
+
+	if (!event.isRemoteRequest) {
+		// or this is a no-JS form submission
+		return;
+	}
+
+	const key = create_remote_key(internals.id, payload);
+
+	// `fn()` is invoked eagerly here, which starts running the query immediately.
+	// The resulting promise is normally awaited (and its rejection handled) in
+	// `collect_remote_data`, but some code paths (e.g. a command throwing a
+	// non-redirect error) never reach that point. Attach a no-op `catch` to the
+	// promise so a rejection is always considered handled and can never become an
+	// unhandled promise rejection (which crashes the process on modern Node).
+	// We still store the original promise so `collect_remote_data` can serialize
+	// either its value or its error as before.
+	const promise = fn();
+	promise.catch(() => {});
+
+	(state.remote.explicit ??= new Map()).set(key, {
+		internals,
+		promise
+	});
+}
+
 /**
  * @param {RemoteInternals} __
  * @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
+ * @param {RequestEvent} event
  * @param {RequestState} state
  * @param {() => Promise<any>} fn
  * @returns {RemoteQuery<any>}
  */
-function create_query_resource(__, payload, state, fn) {
+function create_query_resource(__, payload, event, state, fn) {
 	/** @type {Promise<any> | null} */
 	let promise = null;
 
@@ -391,7 +451,11 @@ function create_query_resource(__, payload, state, fn) {
 		// accessing data properties needs to kick off the work
 		// so that it gets seeded in the hydration cache
 		// and becomes available on the client
-		void (__.id && state.is_in_render && get_promise());
+		if (__.id && state.is_in_render) {
+			// swallow rejections so they don't crash the server — the error is
+			// serialized into the response and surfaced on the client instead
+			get_promise().catch(noop);
+		}
 	};
 
 	return {
@@ -420,20 +484,19 @@ function create_query_resource(__, payload, state, fn) {
 			return false;
 		},
 		refresh() {
-			const { event } = get_request_store();
-			if (!event.isRemoteRequest) {
-				// If the form submission is not a remote request, refreshing the data is
-				// useless, because it can't be returned to the client.
-				return Promise.resolve();
-			}
-			const refresh_context = get_refresh_context(__, 'refresh', payload);
-			const is_immediate_refresh = !refresh_context.cache[refresh_context.payload];
-			const value = is_immediate_refresh ? get_promise() : fn();
-			return update_refresh_value(refresh_context, value, is_immediate_refresh);
+			promise = null;
+			delete get_cache(__, state)[payload];
+
+			refresh(event, state, __, payload, get_promise);
+
+			return Promise.resolve();
 		},
 		/** @param {any} value */
 		set(value) {
-			return update_refresh_value(get_refresh_context(__, 'set', payload), value);
+			const p = (promise = Promise.resolve(value));
+			get_cache(__, state)[payload] = p;
+
+			refresh(event, state, __, payload, () => p);
 		},
 		/** @type {Promise<any>['then']} */
 		then(onfulfilled, onrejected) {
@@ -451,12 +514,12 @@ function create_query_resource(__, payload, state, fn) {
 /**
  * @param {RemoteQueryLiveInternals} __
  * @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
+ * @param {RequestEvent} event
  * @param {RequestState} state
- * @param {AbortSignal} signal — the request signal; aborts in-flight iteration when the client disconnects
  * @param {() => AsyncGenerator<any, void, void>} get_generator
  * @returns {RemoteLiveQuery<any>}
  */
-function create_live_query_resource(__, payload, state, signal, get_generator) {
+function create_live_query_resource(__, payload, event, state, get_generator) {
 	/** @type {Promise<any> | null} */
 	let promise = null;
 
@@ -472,7 +535,11 @@ function create_live_query_resource(__, payload, state, signal, get_generator) {
 	};
 
 	const populate_hydratable = () => {
-		void (__.id && state.is_in_render && get_promise());
+		if (__.id && state.is_in_render) {
+			// swallow rejections so they don't crash the server — the error is
+			// serialized into the response and surfaced on the client instead
+			get_promise().catch(noop);
+		}
 	};
 
 	return {
@@ -509,15 +576,11 @@ function create_live_query_resource(__, payload, state, signal, get_generator) {
 			return false;
 		},
 		reconnect() {
-			const reconnects = state.remote.reconnects;
+			promise = null;
+			delete get_cache(__, state)[payload];
 
-			if (!reconnects) {
-				throw new Error(
-					`Cannot call reconnect on query.live '${__.name}' because it is not executed in the context of a command/form remote function`
-				);
-			}
+			refresh(event, state, __, payload, get_promise);
 
-			reconnects.set(create_remote_key(__.id, payload), get_promise());
 			return Promise.resolve();
 		},
 		/** @ts-expect-error This method no longer exists */
@@ -535,7 +598,7 @@ function create_live_query_resource(__, payload, state, signal, get_generator) {
 			const cache = (state.remote.live_iterators ??= new Map());
 			let cached = cache.get(key);
 			if (!cached) {
-				cached = create_shared_live_iterator(signal, get_generator);
+				cached = create_shared_live_iterator(event.request.signal, get_generator);
 				cache.set(key, cached);
 			}
 			return cached.subscribe();
@@ -613,55 +676,3 @@ function create_shared_live_iterator(signal, get_generator) {
 // Add batch as a property to the query function
 Object.defineProperty(query, 'batch', { value: batch, enumerable: true });
 Object.defineProperty(query, 'live', { value: live, enumerable: true });
-
-/**
- * @param {RemoteInternals} __
- * @param {'set' | 'refresh'} action
- * @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
- * @returns {{ __: RemoteInternals; state: any; refreshes: Map<string, Promise<any>>; cache: Record<string, { serialize: boolean; data: any }>; refreshes_key: string; payload: string }}
- */
-function get_refresh_context(__, action, payload) {
-	const { state } = get_request_store();
-	const { refreshes } = state.remote;
-
-	if (!refreshes) {
-		const name = __.type === 'query_batch' ? `query.batch '${__.name}'` : `query '${__.name}'`;
-		throw new Error(
-			`Cannot call ${action} on ${name} because it is not executed in the context of a command/form remote function`
-		);
-	}
-
-	const cache = get_cache(__, state);
-	const refreshes_key = create_remote_key(__.id, payload);
-
-	return { __, state, refreshes, refreshes_key, cache, payload };
-}
-
-/**
- * @param {{ __: RemoteInternals; refreshes: Map<string, Promise<any>>; cache: Record<string, { serialize: boolean; data: any }>; refreshes_key: string; payload: string }} context
- * @param {any} value
- * @param {boolean} [is_immediate_refresh=false]
- * @returns {Promise<void>}
- */
-function update_refresh_value(
-	{ __, refreshes, refreshes_key, cache, payload },
-	value,
-	is_immediate_refresh = false
-) {
-	const promise = Promise.resolve(value);
-
-	if (!is_immediate_refresh) {
-		cache[payload] = { serialize: true, data: promise };
-	}
-
-	if (__.id) {
-		refreshes.set(refreshes_key, promise);
-	}
-
-	promise.catch(noop);
-
-	// we return an immediately-resolving promise so that the `refresh()` signature is consistent,
-	// but it doesn't delay anything if awaited inside a command. this way, people aren't
-	// penalised if they do `await q1.refresh(); await q2.refresh()`
-	return Promise.resolve();
-}

package/src/runtime/app/server/remote/requested.js

@@ -1,8 +1,11 @@
 /** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestedResult, QueryRequestedResult, LiveQueryRequestedResult } from '@sveltejs/kit' */
 /** @import { MaybePromise, RemoteAnyQueryInternals } from 'types' */
+import { HttpError } from '@sveltejs/kit/internal';
 import { get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, parse_remote_arg } from '../../../shared.js';
+import { parse_remote_arg } from '../../../shared.js';
 import { noop } from '../../../../utils/functions.js';
+import { get_cache } from './shared.js';
+import { refresh } from './query.js';
 
 /**
  * In the context of a remote `command` or `form` request, returns an iterable
@@ -95,7 +98,7 @@ import { noop } from '../../../../utils/functions.js';
  * @returns {RequestedResult<Validated, Output>}
  */
 export function requested(query, limit) {
-	const { state } = get_request_store();
+	const { event, state } = get_request_store();
 	const internals = /** @type {RemoteAnyQueryInternals | undefined} */ (
 		/** @type {any} */ (query).__
 	);
@@ -115,15 +118,12 @@ export function requested(query, limit) {
 
 	const requested = state.remote.requested;
 	const payloads = requested?.get(__.id) ?? [];
+
 	// note: don't initialize these maps here -- they will be initialized by the
 	// command/form wrapper when we enter them, and if we initialize them here
 	// we will enable requested(...) in contexts where it shouldn't be allowed,
 	// such as load functions or other server functions
-	const refreshes = state.remote.refreshes;
-	const reconnects = state.remote.reconnects;
-	const store = __.type === 'query_live' ? reconnects : refreshes;
-
-	if (!store) {
+	if (!state.is_in_remote_form_or_command) {
 		throw new Error(
 			'requested(...) can only be called in the context of a command/form remote function'
 		);
@@ -131,6 +131,9 @@ export function requested(query, limit) {
 	const [selected, skipped] = split_limit(payloads, limit);
 
 	/**
+	 * Registers the failure exactly like `.set()` registers a value: the error record
+	 * is serialized to the client (putting the query there into a failed state), and
+	 * subsequent server-side calls of the query with the same argument reject with it.
 	 * @param {string} payload
 	 * @param {unknown} error
 	 */
@@ -138,14 +141,15 @@ export function requested(query, limit) {
 		const promise = Promise.reject(error);
 		promise.catch(noop);
 
-		const key = create_remote_key(__.id, payload);
-		store.set(key, promise);
+		get_cache(__, state)[payload] = promise;
+		refresh(event, state, __, payload, () => promise);
 	};
 
 	for (const payload of skipped) {
 		record_failure(
 			payload,
-			new Error(
+			new HttpError(
+				400,
 				`Requested refresh was rejected because it exceeded requested(${__.name}, ${limit}) limit`
 			)
 		);