fix: make query.refresh lazy, inline results during render

[elliott-with-the-longest-name-on-github]

Supersedes #16428. It had the right approach, but we were actually handling refresh wrong in the first place. I thought we'd implemented this behavior but somehow we haven't.

Anyway, this kills two birds with one stone:

• It makes sure we allow .refresh (and .set) to run during render
• It makes .refresh lazy: Calling .refresh busts the cache and guarantees that the cache will be populated by the end of the request. If you await the query or access its data, it will immediately run and populate the cache; otherwise SvelteKit will do it at the end of the request, in parallel with any other refreshing queries

[pkg-svelte-dev]

Install the latest version of @sveltejs/kit from be95209:

pnpm add https://pkg.svelte.dev/@sveltejs/kit/c/be95209dfe5c3ca197536140637ef645b2264646

Open in pkg.svelte.dev: https://pkg.svelte.dev/repos/kit/pr/16461

[changeset-bot]

🦋 Changeset detected

Latest commit: be95209

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 1 package

Name	Type
@sveltejs/kit	Patch

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

[svelte-docs-bot]

Preview: https://svelte-dev-git-preview-kit-16461-svelte.vercel.app/

[Nic-Polumeyv]

One execution-order regression inline.

[Nic-Polumeyv]

Each fn() now starts only after the previous one settled, the eager version had them all in flight before the loop. Starting them together needs handlers attached at start (the old no-op catch) and must keep picking up entries a lazily-run query adds by refreshing another:

	if (state.remote.explicit) {
		/** @type {Set<string>} */
		const processed = new Set();

		// `state.remote.explicit` can grow while we collect (a lazily-run query can
		// refresh another), so sweep until it stops growing
		while (processed.size < state.remote.explicit.size) {
			/** @type {Promise<void>[]} */
			const batch = [];

			for (const [remote_key, { internals, fn }] of state.remote.explicit) {
				if (processed.has(remote_key)) continue;
				processed.add(remote_key);

				// there were explicit refreshes/reconnects (via `refresh()`/`set()`/`reconnect()`),
				// so the client should apply these single-flight updates instead of calling `invalidateAll()`
				data.r = true;

				const type = /** @type {'p' | 'q' | 'l'} */ (
					internals.type === 'query_live' ? 'l' : internals.type[0]
				);

				batch.push(
					fn().then(
						(v) => {
							((data[type] ??= {})[remote_key] ??= {}).v = v;
						},
						async (e) => {
							if (e instanceof Redirect) {
								// already handled elsewhere
								return;
							}

							((data[type] ??= {})[remote_key] ??= {}).e = await convert_error(e);
						}
					)
				);
			}

			await Promise.all(batch);
		}
	}

[elliott-with-the-longest-name-on-github]

Still not quite happy with this... going to investigate a drain loop so that queries that call refresh on other queries will work correctly, but need to figure out a looping protection.

[Rich-Harris]

small inline suggestion, and there's a lint failure, but otherwise LGTM