import { i as parse_remote_arg, o as stringify, r as create_remote_key, s as stringify_remote_arg, v as parse, y as noop } from "./chunks/shared.js";
import { a as app_dir, s as base, t as prerendering } from "./chunks/internal2.js";
import { C as set_nested_value, S as normalize_issue, T as MUTATIVE_METHODS, s as handle_error_and_jsonify, v as create_field_proxy, x as flatten_issues, y as deep_set } from "./chunks/utils.js";
import { error, json } from "@sveltejs/kit";
import { HttpError, SvelteKitError, ValidationError } from "@sveltejs/kit/internal";
import { get_request_store, with_request_store } from "@sveltejs/kit/internal/server";
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/shared.js
/** @import { RequestEvent } from '@sveltejs/kit' */
/** @import { ServerHooks, MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
/**
* @param {any} validate_or_fn
* @param {((arg?: any) => any) | undefined} [maybe_fn]
* @returns {(arg?: any) => MaybePromise<any>}
*/
function create_validator(validate_or_fn, maybe_fn) {
	if (!maybe_fn) return (arg) => {
		if (arg !== void 0) error(400, "Bad Request");
	};
	if (validate_or_fn === "unchecked") return (arg) => arg;
	if ("~standard" in validate_or_fn) return async (arg) => {
		const { event, state } = get_request_store();
		const result = await validate_or_fn["~standard"].validate(arg);
		if (result.issues) error(400, await state.handleValidationError({
			issues: result.issues,
			event
		}));
		return result.value;
	};
	throw new Error("Invalid validator passed to remote function. Expected \"unchecked\" or a Standard Schema (https://standardschema.dev)");
}
/**
* In case of a single remote function call, just returns the result.
*
* In case of a full page reload, returns the response for a remote function call,
* either from the cache or by invoking the function.
* Also saves an uneval'ed version of the result for later HTML inlining for hydration.
*
* @template {MaybePromise<any>} T
* @param {RemoteInternals} internals
* @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
* @param {RequestState} state
* @param {() => Promise<T>} get_result
* @returns {Promise<T>}
*/
async function get_response(internals, payload, state, get_result) {
	await 0;
	const cache = get_cache(internals, state);
	if (!state.is_in_remote_query) get_implicit_lookup(internals, state)[payload] = get_result;
	return cache[payload] ??= get_result();
}
/**
* @param {any} data
* @param {ServerHooks['transport']} transport
*/
function parse_remote_response(data, transport) {
	/** @type {Record<string, any>} */
	const revivers = {};
	for (const key in transport) revivers[key] = transport[key].decode;
	return parse(data, revivers);
}
/**
* @param {RequestEvent} event
* @param {RequestState} state
* @param {boolean} allow_cookies
* @returns {RequestStore}
*/
function derive_remote_function_event(event, state, allow_cookies) {
	return {
		event: {
			...event,
			setHeaders: () => {
				throw new Error("setHeaders is not allowed in remote functions");
			},
			cookies: {
				...event.cookies,
				set: (name, value, opts) => {
					if (!allow_cookies) throw new Error("Cannot set cookies in `query` or `prerender` functions");
					if (opts.path && !opts.path.startsWith("/")) throw new Error("Cookies set in remote functions must have an absolute path");
					return event.cookies.set(name, value, opts);
				},
				delete: (name, opts) => {
					if (!allow_cookies) throw new Error("Cannot delete cookies in `query` or `prerender` functions");
					if (opts.path && !opts.path.startsWith("/")) throw new Error("Cookies deleted in remote functions must have an absolute path");
					return event.cookies.delete(name, opts);
				}
			}
		},
		state: {
			...state,
			is_in_remote_function: true
		}
	};
}
/**
* Like `with_event` but removes things from `event` you cannot see/call in remote functions, such as `setHeaders`.
* @template T
* @param {RequestEvent} event
* @param {RequestState} state
* @param {boolean} allow_cookies
* @param {() => any} get_input
* @param {(arg?: any) => T} fn
*/
async function run_remote_function(event, state, allow_cookies, get_input, fn) {
	const store = derive_remote_function_event(event, state, allow_cookies);
	const input = await with_request_store(store, get_input);
	return with_request_store(store, () => fn(input));
}
/**
* Like `with_event` but removes things from `event` you cannot see/call in remote functions, such as `setHeaders`.
* @template T
* @param {RequestEvent} event
* @param {RequestState} state
* @param {boolean} allow_cookies
* @param {() => any} get_input
* @param {(arg?: any) => RemoteLiveQueryUserFunctionReturnType<T>} fn
* @param {string} name
*/
async function* run_remote_generator(event, state, allow_cookies, get_input, fn, name) {
	const store = derive_remote_function_event(event, state, allow_cookies);
	const input = await with_request_store(store, get_input);
	const iterator = to_iterator(await with_request_store(store, () => fn(input)), name);
	let done = false;
	try {
		while (true) {
			const result = await with_request_store(store, () => iterator.next());
			if (result.done) {
				done = true;
				return result.value;
			}
			yield result.value;
		}
	} finally {
		if (!done && typeof iterator.return === "function") await with_request_store(store, () => iterator.return?.(void 0));
	}
}
/**
* @template T
* @param {Awaited<RemoteLiveQueryUserFunctionReturnType<T>>} source
* @param {string} name
* @returns {Iterator<T> | AsyncIterator<T>}
*/
function to_iterator(source, name) {
	if ("next" in source && typeof source.next === "function") return source;
	if (Symbol.asyncIterator in source && typeof source[Symbol.asyncIterator] === "function") return source[Symbol.asyncIterator]();
	if (Symbol.iterator in source && typeof source[Symbol.iterator] === "function") return source[Symbol.iterator]();
	throw new Error(`query.live '${name}' must return an Iterator, Iterable, AsyncIterator or AsyncIterable`);
}
/**
* Note that `state` is deliberately not optional: resources that capture the request
* state at creation must pass it explicitly, because reading it from the request store
* at call time is only equivalent on runtimes with `AsyncLocalStorage` support.
* Callers without a captured state (such as the module-level `form` instance getters)
* should pass `get_request_store().state` themselves.
* @param {RemoteInternals} internals
* @param {RequestState} state
*/
function get_cache(internals, state) {
	let cache = state.remote.data?.get(internals);
	if (cache === void 0) {
		cache = {};
		(state.remote.data ??= /* @__PURE__ */ new Map()).set(internals, cache);
	}
	return cache;
}
/**
* @param {RemoteInternals} internals
* @param {RequestState} state
*/
function get_implicit_lookup(internals, state) {
	let cache = state.remote.implicit?.get(internals);
	if (cache === void 0) {
		cache = {};
		(state.remote.implicit ??= /* @__PURE__ */ new Map()).set(internals, cache);
	}
	return cache;
}
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/command.js
/** @import { RemoteCommand } from '@sveltejs/kit' */
/** @import { MaybePromise, RemoteCommandInternals } from 'types' */
/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
/**
* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
*
* @template Output
* @overload
* @param {() => MaybePromise<Output>} fn
* @returns {RemoteCommand<void, Output>}
* @since 2.27
*/
/**
* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
*
* @template Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(arg: Input) => MaybePromise<Output>} fn
* @returns {RemoteCommand<Input, Output>}
* @since 2.27
*/
/**
* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
*
* @template {StandardSchemaV1} Schema
* @template Output
* @overload
* @param {Schema} validate
* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
* @returns {RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>}
* @since 2.27
*/
/**
* @template Input
* @template Output
* @param {any} validate_or_fn
* @param {(arg?: Input) => MaybePromise<Output>} [maybe_fn]
* @returns {RemoteCommand<Input, Output>}
* @since 2.27
*/
/*@__NO_SIDE_EFFECTS__*/
function command(validate_or_fn, maybe_fn) {
	/** @type {(arg?: Input) => MaybePromise<Output>} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {(arg?: any) => MaybePromise<Input>} */
	const validate = create_validator(validate_or_fn, maybe_fn);
	/** @type {RemoteCommandInternals} */
	const __ = {
		type: "command",
		id: "",
		name: ""
	};
	/** @type {RemoteCommand<Input, Output> & { __: RemoteCommandInternals }} */
	const wrapper = (arg) => {
		const { event, state } = get_request_store();
		if (!MUTATIVE_METHODS.includes(event.request.method)) throw new Error(`Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) from a ${event.request.method} handler`);
		if (state.is_in_render) throw new Error(`Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) during server-side rendering`);
		const promise = Promise.resolve(run_remote_function(event, state, true, () => validate(arg), fn));
		promise.updates = () => {
			throw new Error(`Cannot call '${__.name}(...).updates(...)' on the server`);
		};
		return promise;
	};
	Object.defineProperty(wrapper, "__", { value: __ });
	Object.defineProperty(wrapper, "pending", { get: () => 0 });
	return wrapper;
}
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/form.js
/** @import { RemoteFormInput, RemoteForm, InvalidField } from '@sveltejs/kit' */
/** @import { InternalRemoteFormIssue, MaybePromise, RemoteFormInternals } from 'types' */
/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
/**
* Creates a form object that can be spread onto a `<form>` element.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
*
* @template Output
* @overload
* @param {() => MaybePromise<Output>} fn
* @returns {RemoteForm<void, Output>}
* @since 2.27
*/
/**
* Creates a form object that can be spread onto a `<form>` element.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
*
* @template {RemoteFormInput} Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(data: Input, issue: InvalidField<Input>) => MaybePromise<Output>} fn
* @returns {RemoteForm<Input, Output>}
* @since 2.27
*/
/**
* Creates a form object that can be spread onto a `<form>` element.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
*
* @template {StandardSchemaV1<RemoteFormInput, Record<string, any>>} Schema
* @template Output
* @overload
* @param {Schema} validate
* @param {(data: StandardSchemaV1.InferOutput<Schema>, issue: InvalidField<StandardSchemaV1.InferInput<Schema>>) => MaybePromise<Output>} fn
* @returns {RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>}
* @since 2.27
*/
/**
* @template {RemoteFormInput} Input
* @template Output
* @param {any} validate_or_fn
* @param {(data_or_issue: any, issue?: any) => MaybePromise<Output>} [maybe_fn]
* @returns {RemoteForm<Input, Output>}
* @since 2.27
*/
/*@__NO_SIDE_EFFECTS__*/
function form(validate_or_fn, maybe_fn) {
	/** @type {any} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {StandardSchemaV1 | null} */
	const schema = !maybe_fn || validate_or_fn === "unchecked" ? null : validate_or_fn;
	/**
	* @param {string | number | boolean} [key]
	*/
	function create_instance(key) {
		/** @type {RemoteForm<Input, Output>} */
		const instance = {};
		instance.method = "POST";
		Object.defineProperty(instance, "enhance", { value: () => {
			return {
				action: instance.action,
				method: instance.method
			};
		} });
		/** @type {RemoteFormInternals} */
		const __ = {
			type: "form",
			name: "",
			id: "",
			fn: async (data, meta, form_data) => {
				/** @type {{ submission: true, input?: Record<string, any>, issues?: InternalRemoteFormIssue[], result: Output }} */
				const output = {};
				output.submission = true;
				const { event, state } = get_request_store();
				const validated = await schema?.["~standard"].validate(data);
				if (meta.validate_only) return validated?.issues?.map((issue) => normalize_issue(issue, true)) ?? [];
				if (validated?.issues !== void 0) handle_issues(output, validated.issues, form_data);
				else {
					if (validated !== void 0) data = validated.value;
					const issue = create_issues();
					try {
						output.result = await run_remote_function(event, state, true, () => data, (data) => !maybe_fn ? fn() : fn(data, issue));
					} catch (e) {
						if (e instanceof ValidationError) handle_issues(output, e.issues, form_data);
						else throw e;
					}
				}
				if (!event.isRemoteRequest) {
					const cache = get_cache(__, state);
					cache[""] ??= output;
					get_implicit_lookup(__, state)[__.action_id ?? __.id] = () => cache[""];
				}
				return output;
			}
		};
		Object.defineProperty(instance, "__", { value: __ });
		Object.defineProperty(instance, "action", {
			get: () => `?/remote=${__.id}`,
			enumerable: true
		});
		Object.defineProperty(instance, "fields", { get() {
			return create_field_proxy({}, () => get_cache(__, get_request_store().state)?.[""]?.input ?? {}, (path, value) => {
				const cache = get_cache(__, get_request_store().state);
				const entry = cache[""];
				if (entry?.submission) return;
				if (path.length === 0) {
					(cache[""] ??= {}).input = value;
					return;
				}
				const input = entry?.input ?? {};
				deep_set(input, path.map(String), value);
				(cache[""] ??= {}).input = input;
			}, () => flatten_issues(get_cache(__, get_request_store().state)?.[""]?.issues ?? []));
		} });
		Object.defineProperty(instance, "result", { get() {
			try {
				return get_cache(__, get_request_store().state)?.[""]?.result;
			} catch {
				return;
			}
		} });
		Object.defineProperty(instance, "pending", { get: () => 0 });
		Object.defineProperty(instance, "preflight", { value: () => instance });
		Object.defineProperty(instance, "validate", { value: () => {
			throw new Error("Cannot call validate() on the server");
		} });
		Object.defineProperty(instance, "submit", { value: () => {
			throw new Error("Cannot call submit() on the server");
		} });
		Object.defineProperty(instance, "element", { get: () => null });
		if (key == void 0) Object.defineProperty(instance, "for", { 
		/** @type {RemoteForm<any, any>['for']} */
value: (key) => {
			const { state } = get_request_store();
			const cache_key = __.id + "|" + JSON.stringify(key);
			let instance = (state.remote.forms ??= /* @__PURE__ */ new Map()).get(cache_key);
			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);
			}
			return instance;
		} });
		return instance;
	}
	return create_instance();
}
/**
* @param {{ issues?: InternalRemoteFormIssue[], input?: Record<string, any>, result: any }} output
* @param {readonly StandardSchemaV1.Issue[]} issues
* @param {FormData | null} form_data - null if the form is progressively enhanced
*/
function handle_issues(output, issues, form_data) {
	output.issues = issues.map((issue) => normalize_issue(issue, true));
	if (form_data) {
		output.input = {};
		for (let key of form_data.keys()) {
			if (/^[.\]]?_/.test(key)) continue;
			const is_array = key.endsWith("[]");
			const values = form_data.getAll(key).filter((value) => typeof value === "string");
			if (is_array) key = key.slice(0, -2);
			set_nested_value(output.input, key, is_array ? values : values[0]);
		}
	}
}
/**
* Creates an invalid function that can be used to imperatively mark form fields as invalid
* @returns {InvalidField<any>}
*/
function create_issues() {
	return new Proxy(
		/** @param {string} message */
		(message) => {
			return create_issue(message);
		},
		{ get(target, prop) {
			if (typeof prop === "symbol") return target[prop];
			return create_issue_proxy(prop, []);
		} }
	);
	/**
	* @param {string} message
	* @param {(string | number)[]} path
	* @returns {StandardSchemaV1.Issue}
	*/
	function create_issue(message, path = []) {
		return {
			message,
			path
		};
	}
	/**
	* Creates a proxy that builds up a path and returns a function to create an issue
	* @param {string | number} key
	* @param {(string | number)[]} path
	*/
	function create_issue_proxy(key, path) {
		const new_path = [...path, key];
		/**
		* @param {string} message
		* @returns {StandardSchemaV1.Issue}
		*/
		const issue_func = (message) => create_issue(message, new_path);
		return new Proxy(issue_func, { get(target, prop) {
			if (typeof prop === "symbol") return target[prop];
			if (/^\d+$/.test(prop)) return create_issue_proxy(parseInt(prop, 10), new_path);
			return create_issue_proxy(prop, new_path);
		} });
	}
}
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/prerender.js
/** @import { RemoteResource, RemotePrerenderFunction } from '@sveltejs/kit' */
/** @import { RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
/**
* Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#prerender) for full documentation.
*
* @template Output
* @overload
* @param {() => MaybePromise<Output>} fn
* @param {{ inputs?: RemotePrerenderInputsGenerator<void>, dynamic?: boolean }} [options]
* @returns {RemotePrerenderFunction<void, Output>}
* @since 2.27
*/
/**
* Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#prerender) for full documentation.
*
* @template Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(arg: Input) => MaybePromise<Output>} fn
* @param {{ inputs?: RemotePrerenderInputsGenerator<Input>, dynamic?: boolean }} [options]
* @returns {RemotePrerenderFunction<Input, Output>}
* @since 2.27
*/
/**
* Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#prerender) for full documentation.
*
* @template {StandardSchemaV1} Schema
* @template Output
* @overload
* @param {Schema} schema
* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
* @param {{ inputs?: RemotePrerenderInputsGenerator<StandardSchemaV1.InferInput<Schema>>, dynamic?: boolean }} [options]
* @returns {RemotePrerenderFunction<StandardSchemaV1.InferInput<Schema>, Output>}
* @since 2.27
*/
/**
* @template Input
* @template Output
* @param {any} validate_or_fn
* @param {any} [fn_or_options]
* @param {{ inputs?: RemotePrerenderInputsGenerator<Input>, dynamic?: boolean }} [maybe_options]
* @returns {RemotePrerenderFunction<Input, Output>}
* @since 2.27
*/
/*@__NO_SIDE_EFFECTS__*/
function prerender(validate_or_fn, fn_or_options, maybe_options) {
	const maybe_fn = typeof fn_or_options === "function" ? fn_or_options : void 0;
	/** @type {typeof maybe_options} */
	const options = maybe_options ?? (maybe_fn ? void 0 : fn_or_options);
	/** @type {(arg?: Input) => MaybePromise<Output>} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {(arg?: any) => MaybePromise<Input>} */
	const validate = create_validator(validate_or_fn, maybe_fn);
	/** @type {RemotePrerenderInternals} */
	const __ = {
		type: "prerender",
		id: "",
		name: "",
		has_arg: !!maybe_fn,
		inputs: options?.inputs,
		dynamic: options?.dynamic
	};
	/** @type {RemotePrerenderFunction<Input, Output> & { __: RemotePrerenderInternals }} */
	const wrapper = (arg) => {
		const { event, state } = get_request_store();
		const payload = stringify_remote_arg(arg, state.transport);
		/** @type {Promise<Output> & Partial<RemoteResource<Output>>} */
		const promise = get_response(__, payload, state, async () => {
			const url = `${base}/${app_dir}/remote/${__.id}${payload ? `/${payload}` : ""}`;
			if (!state.prerendering && !event.isRemoteRequest) try {
				const response = await fetch(new URL(url, event.url.origin).href);
				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 parse_remote_response(prerendered.data, state.transport)._;
			} catch {}
			if (state.prerendering?.remote_responses.has(url)) return state.prerendering.remote_responses.get(url);
			const promise = run_remote_function(event, state, false, () => validate(arg), fn);
			if (state.prerendering) state.prerendering.remote_responses.set(url, promise);
			const result = await promise;
			if (state.prerendering) {
				const body = {
					type: "result",
					data: stringify({ _: result }, state.transport)
				};
				state.prerendering.dependencies.set(url, {
					body: JSON.stringify(body),
					response: json(body)
				});
			}
			return result;
		});
		promise.catch(noop);
		return promise;
	};
	Object.defineProperty(wrapper, "__", { value: __ });
	return wrapper;
}
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/utils/shared-iterator.js
/**
* A pull-style async iterator that fans out a single stream of values to
* multiple `for await (...)` consumers. Each subscriber gets its own
* `AsyncGenerator` whose `.next()` resolves whenever a value is pushed via
* `push(value)`. Multiple consumers see the same values without each one
* driving an independent underlying source.
*
* Backpressure is **latest-wins**: if values arrive faster than a particular
* consumer drains its iterator, only the most-recently-pushed value is kept
* pending for that subscriber. Earlier undrained values are dropped. This is
* appropriate for live data streams (reactive state replication), not for
* event logs where every value must be delivered.
*
* Lifecycle hooks are exposed via the constructor:
*
*   - `start()` is called when the subscriber count transitions
*     from 0 to 1 (e.g. to start a pump pulling from a real source).
*   - `stop()` is called when the subscriber count transitions
*     from non-zero back to 0 (e.g. to tear down that pump).
*
* Either hook may be omitted.
*
* The owner is responsible for calling `push(value)` to broadcast values,
* `done()` to signal natural completion to all subscribers, and `fail(error)`
* to broadcast a terminal error. After `done()` or `fail()`, the iterator
* rejects further `subscribe()` calls with the terminal state appropriately.
*
* @template T
*/
var SharedIterator = class {
	/**
	* @typedef {object} Subscriber
	* @property {{ value: any } | null} pending
	* @property {{ error: unknown } | null} pending_error
	* @property {boolean} finished
	* @property {((result: IteratorResult<any, void>) => void) | null} waiting_resolve
	* @property {((reason: unknown) => void) | null} waiting_reject
	*/
	/** @type {Set<Subscriber>} */
	#subscribers = /* @__PURE__ */ new Set();
	/** @type {((instance: SharedIterator<T>) => (() => void)) | undefined} */
	#start = void 0;
	/** @type {(() => void) | undefined} */
	#stop = void 0;
	/** Once `done()` or `fail()` has been broadcast, no new values are accepted. */
	#closed = false;
	/** @type {unknown} */
	#terminal_error = void 0;
	/**
	* @param {(instance: SharedIterator<T>) => (() => void)} [start]
	*/
	constructor(start) {
		this.#start = start;
	}
	/** @param {T} value */
	push(value) {
		if (this.#closed) return;
		for (const subscriber of this.#subscribers) if (subscriber.waiting_resolve) {
			const resolve = subscriber.waiting_resolve;
			subscriber.waiting_resolve = null;
			subscriber.waiting_reject = null;
			resolve({
				value,
				done: false
			});
		} else subscriber.pending = { value };
	}
	/**
	* Signal natural completion to all current subscribers, and to any future
	* subscriber (which will receive an immediately-done iterator).
	*/
	done() {
		if (this.#closed) return;
		this.#closed = true;
		for (const subscriber of this.#subscribers) {
			subscriber.finished = true;
			if (subscriber.waiting_resolve) {
				const resolve = subscriber.waiting_resolve;
				subscriber.waiting_resolve = null;
				subscriber.waiting_reject = null;
				resolve({
					value: void 0,
					done: true
				});
			}
		}
		this.#subscribers.clear();
	}
	/**
	* Broadcast a terminal error. All current subscribers will reject their
	* next `.next()` call with `error`. Future subscribers will also reject
	* their first `.next()`.
	*
	* @param {unknown} error
	*/
	fail(error) {
		if (this.#closed) return;
		this.#closed = true;
		this.#terminal_error = error;
		for (const subscriber of this.#subscribers) {
			subscriber.finished = true;
			if (subscriber.waiting_reject) {
				const reject = subscriber.waiting_reject;
				subscriber.waiting_resolve = null;
				subscriber.waiting_reject = null;
				reject(error);
			} else subscriber.pending_error = { error };
		}
		this.#subscribers.clear();
	}
	/**
	* Subscribe to the shared stream. Returns an `AsyncGenerator<T>` that
	* yields every value pushed after this call (and, if `initial_value` is
	* provided, that value as the first yield).
	*
	* @param {{ initial_value?: { value: T } }} [options]
	*   `initial_value` lets the caller seed the iterator with a synchronously-
	*   available current value before any new pushes arrive (e.g. the
	*   "last-seen value" of a reactive resource). Pass it wrapped in an
	*   object so `undefined` can be distinguished from "no initial value".
	* @returns {AsyncGenerator<T, void, void>}
	*/
	subscribe(options) {
		/** @type {Subscriber} */
		const subscriber = {
			pending: options?.initial_value ? { value: options.initial_value.value } : null,
			pending_error: this.#closed && this.#terminal_error !== void 0 ? { error: this.#terminal_error } : null,
			finished: this.#closed && this.#terminal_error === void 0,
			waiting_resolve: null,
			waiting_reject: null
		};
		if (!subscriber.finished && subscriber.pending_error === null) this.#subscribers.add(subscriber);
		if (!this.#closed) this.#stop ??= this.#start?.(this);
		const unsubscribe = () => {
			subscriber.finished = true;
			if (this.#subscribers.delete(subscriber) && this.#subscribers.size === 0) this.#stop?.();
		};
		/** @type {AsyncGenerator<T, void, void>} */
		const iterator = {
			next() {
				if (subscriber.pending_error) {
					const { error } = subscriber.pending_error;
					subscriber.pending_error = null;
					unsubscribe();
					return Promise.reject(error);
				}
				if (subscriber.pending) {
					const { value } = subscriber.pending;
					subscriber.pending = null;
					return Promise.resolve({
						value,
						done: false
					});
				}
				if (subscriber.finished) return Promise.resolve({
					value: void 0,
					done: true
				});
				return new Promise((resolve, reject) => {
					subscriber.waiting_resolve = resolve;
					subscriber.waiting_reject = reject;
				});
			},
			return(value) {
				unsubscribe();
				if (subscriber.waiting_resolve) {
					const resolve = subscriber.waiting_resolve;
					subscriber.waiting_resolve = null;
					subscriber.waiting_reject = null;
					resolve({
						value: void 0,
						done: true
					});
				}
				return Promise.resolve({
					value,
					done: true
				});
			},
			throw(error) {
				unsubscribe();
				if (subscriber.waiting_reject) {
					const reject = subscriber.waiting_reject;
					subscriber.waiting_resolve = null;
					subscriber.waiting_reject = null;
					reject(error);
				}
				return Promise.reject(error);
			},
			[Symbol.asyncIterator]() {
				return iterator;
			},
			async [Symbol.asyncDispose]() {}
		};
		return iterator;
	}
};
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/query.js
/** @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' */
/**
* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
*
* @template Output
* @overload
* @param {() => MaybePromise<Output>} fn
* @returns {RemoteQueryFunction<void, Output>}
* @since 2.27
*/
/**
* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
*
* @template Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(arg: Input) => MaybePromise<Output>} fn
* @returns {RemoteQueryFunction<Input, Output>}
* @since 2.27
*/
/**
* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
*
* @template {StandardSchemaV1} Schema
* @template Output
* @overload
* @param {Schema} schema
* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
* @returns {RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
* @since 2.27
*/
/**
* @template Input
* @template Output
* @param {any} validate_or_fn
* @param {(args?: Input) => MaybePromise<Output>} [maybe_fn]
* @returns {RemoteQueryFunction<Input, Output>}
* @since 2.27
*/
/*@__NO_SIDE_EFFECTS__*/
function query(validate_or_fn, maybe_fn) {
	/** @type {(arg?: Input) => Output} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {(arg?: any) => MaybePromise<Input>} */
	const validate = create_validator(validate_or_fn, maybe_fn);
	/** @type {RemoteQueryInternals} */
	const __ = {
		type: "query",
		id: "",
		name: "",
		validate,
		bind(payload, validated_arg) {
			const { event, state } = get_request_store();
			return create_query_resource(__, payload, event, state, () => run_remote_function(event, {
				...state,
				is_in_remote_query: true
			}, false, () => validated_arg, fn));
		}
	};
	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryInternals }} */
	const wrapper = (arg) => {
		if (prerendering) throw new Error(`Cannot call query '${__.name}' while prerendering, as prerendered pages need static data. Use 'prerender' from $app/server instead`);
		const { event, state } = get_request_store();
		return create_query_resource(__, stringify_remote_arg(arg, state.transport), event, state, () => run_remote_function(event, {
			...state,
			is_in_remote_query: true
		}, false, () => validate(arg), fn));
	};
	Object.defineProperty(wrapper, "__", { value: __ });
	return wrapper;
}
/**
* Creates a live remote query. When called from the browser, the function will be invoked on the server via a streaming `fetch` call.
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.live) for full documentation.
*
* @template Output
* @overload
* @param {(arg: void) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
* @returns {RemoteLiveQueryFunction<void, Output>}
*/
/**
* @template Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(arg: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
* @returns {RemoteLiveQueryFunction<Input, Output>}
*/
/**
* @template {StandardSchemaV1} Schema
* @template Output
* @overload
* @param {Schema} schema
* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
* @returns {RemoteLiveQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
*/
/**
* @template Input
* @template Output
* @param {any} validate_or_fn
* @param {(args: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} [maybe_fn]
* @returns {RemoteLiveQueryFunction<Input, Output>}
*/
/*@__NO_SIDE_EFFECTS__*/
function live(validate_or_fn, maybe_fn) {
	/** @type {(arg: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {(arg?: any) => MaybePromise<Input>} */
	const validate = create_validator(validate_or_fn, maybe_fn);
	/**
	* @param {any} event
	* @param {any} state
	* @param {any} get_input
	*/
	const run = (event, state, get_input) => run_remote_generator(event, {
		...state,
		is_in_remote_query: true
	}, false, get_input, fn, __.name);
	/** @type {RemoteQueryLiveInternals} */
	const __ = {
		type: "query_live",
		id: "",
		name: "",
		run: (event, state, arg) => run(event, state, () => validate(arg)),
		validate,
		bind(payload, validated_arg) {
			const { event, state } = get_request_store();
			return create_live_query_resource(__, payload, event, state, () => run(event, state, () => validated_arg));
		}
	};
	/** @type {RemoteLiveQueryFunction<Input, Output> & { __: RemoteQueryLiveInternals }} */
	const wrapper = (arg) => {
		if (prerendering) throw new Error(`Cannot call query.live '${__.name}' while prerendering, as prerendered pages need static data. Use 'prerender' from $app/server instead`);
		const { event, state } = get_request_store();
		return create_live_query_resource(__, stringify_remote_arg(arg, state.transport), event, state, () => run(event, state, () => validate(arg)));
	};
	Object.defineProperty(wrapper, "__", { value: __ });
	return wrapper;
}
/**
* Creates a batch query function that collects multiple calls and executes them in a single request
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
*
* @template Input
* @template Output
* @overload
* @param {'unchecked'} validate
* @param {(args: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} fn
* @returns {RemoteQueryFunction<Input, Output>}
* @since 2.35
*/
/**
* Creates a batch query function that collects multiple calls and executes them in a single request
*
* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
*
* @template {StandardSchemaV1} Schema
* @template Output
* @overload
* @param {Schema} schema
* @param {(args: StandardSchemaV1.InferOutput<Schema>[]) => MaybePromise<(arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output>} fn
* @returns {RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
* @since 2.35
*/
/**
* @template Input
* @template Output
* @param {any} validate_or_fn
* @param {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} [maybe_fn]
* @returns {RemoteQueryFunction<Input, Output>}
* @since 2.35
*/
/*@__NO_SIDE_EFFECTS__*/
function batch(validate_or_fn, maybe_fn) {
	/** @type {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} */
	const fn = maybe_fn ?? validate_or_fn;
	/** @type {(arg?: any) => MaybePromise<Input>} */
	const validate = create_validator(validate_or_fn, maybe_fn);
	/**
	* Enqueues a single call into the current batch (creating one if necessary)
	* and returns a promise that resolves with the result for this entry.
	*
	* @param {string} payload — the stringified raw argument (cache key)
	* @param {() => MaybePromise<any>} get_validated — produces the validated argument for this entry
	* @returns {Promise<any>}
	*/
	const enqueue = (payload, get_validated) => {
		const { event, state } = get_request_store();
		return new Promise((resolve, reject) => {
			const batches = state.remote.batches ??= /* @__PURE__ */ new Map();
			let batched = batches.get(__.id);
			if (!batched) {
				batched = /* @__PURE__ */ new Map();
				batches.set(__.id, batched);
			}
			const entry = batched.get(payload);
			if (entry) {
				entry.resolvers.push({
					resolve,
					reject
				});
				return;
			}
			batched.set(payload, {
				get_validated,
				resolvers: [{
					resolve,
					reject
				}]
			});
			if (batched.size > 1) return;
			setTimeout(async () => {
				batches.delete(__.id);
				const entries = Array.from(batched.values());
				try {
					return await run_remote_function(event, {
						...state,
						is_in_remote_query: true
					}, false, async () => Promise.all(entries.map((entry) => entry.get_validated())), async (input) => {
						const get_result = await fn(input);
						for (let i = 0; i < entries.length; i++) try {
							const result = get_result(input[i], i);
							for (const resolver of entries[i].resolvers) resolver.resolve(result);
						} catch (error) {
							for (const resolver of entries[i].resolvers) resolver.reject(error);
						}
					});
				} catch (error) {
					for (const entry of batched.values()) for (const resolver of entry.resolvers) resolver.reject(error);
				}
			}, 0);
		});
	};
	/** @type {RemoteQueryBatchInternals} */
	const __ = {
		type: "query_batch",
		id: "",
		name: "",
		validate,
		run: async (args, options) => {
			const { event, state } = get_request_store();
			return run_remote_function(event, {
				...state,
				is_in_remote_query: true
			}, false, async () => Promise.all(args.map(validate)), async (input) => {
				const get_result = await fn(input);
				return Promise.all(input.map(async (arg, i) => {
					try {
						return {
							type: "result",
							data: get_result(arg, i)
						};
					} catch (error) {
						return {
							type: "error",
							error: await handle_error_and_jsonify(event, state, options, error),
							status: error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
						};
					}
				}));
			});
		},
		bind(payload, validated_arg) {
			const { event, state } = get_request_store();
			return create_query_resource(__, payload, event, state, () => enqueue(payload, () => validated_arg));
		}
	};
	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryBatchInternals }} */
	const wrapper = (arg) => {
		if (prerendering) throw new Error(`Cannot call query.batch '${__.name}' while prerendering, as prerendered pages need static data. Use 'prerender' from $app/server instead`);
		const { event, state } = get_request_store();
		const payload = stringify_remote_arg(arg, state.transport);
		return create_query_resource(__, payload, event, state, () => enqueue(payload, () => validate(arg)));
	};
	Object.defineProperty(wrapper, "__", { value: __ });
	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
*/
function refresh(event, state, internals, payload, fn) {
	if (!internals.id) return;
	if (!event.isRemoteRequest) return;
	const key = create_remote_key(internals.id, payload);
	const promise = fn();
	promise.catch(() => {});
	(state.remote.explicit ??= /* @__PURE__ */ 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, event, state, fn) {
	/** @type {Promise<any> | null} */
	let promise = null;
	const get_promise = () => {
		return promise ??= get_response(__, payload, state, fn);
	};
	const populate_hydratable = () => {
		if (__.id && state.is_in_render) get_promise().catch(noop);
	};
	return {
		/** @type {Promise<any>['catch']} */
		catch(onrejected) {
			return get_promise().catch(onrejected);
		},
		get current() {
			populate_hydratable();
		},
		get error() {
			populate_hydratable();
		},
		/** @type {Promise<any>['finally']} */
		finally(onfinally) {
			return get_promise().finally(onfinally);
		},
		get loading() {
			populate_hydratable();
			return true;
		},
		get ready() {
			populate_hydratable();
			return false;
		},
		refresh() {
			promise = null;
			delete get_cache(__, state)[payload];
			refresh(event, state, __, payload, get_promise);
			return Promise.resolve();
		},
		/** @param {any} value */
		set(value) {
			const p = promise = Promise.resolve(value);
			get_cache(__, state)[payload] = p;
			refresh(event, state, __, payload, () => p);
		},
		/** @type {Promise<any>['then']} */
		then(onfulfilled, onrejected) {
			return get_promise().then(onfulfilled, onrejected);
		},
		withOverride() {
			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
		},
		get [Symbol.toStringTag]() {
			return "QueryResource";
		}
	};
}
/**
* @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 {() => AsyncGenerator<any, void, void>} get_generator
* @returns {RemoteLiveQuery<any>}
*/
function create_live_query_resource(__, payload, event, state, get_generator) {
	/** @type {Promise<any> | null} */
	let promise = null;
	const get_first_value = async () => {
		for await (const value of get_generator()) return value;
		throw new Error(`query.live '${__.name}' did not yield a value`);
	};
	const get_promise = () => {
		return promise ??= get_response(__, payload, state, get_first_value);
	};
	const populate_hydratable = () => {
		if (__.id && state.is_in_render) get_promise().catch(noop);
	};
	return {
		/** @type {Promise<any>['catch']} */
		catch(onrejected) {
			return get_promise().catch(onrejected);
		},
		get current() {
			populate_hydratable();
		},
		get error() {
			populate_hydratable();
		},
		/** @type {Promise<any>['finally']} */
		finally(onfinally) {
			return get_promise().finally(onfinally);
		},
		get done() {
			populate_hydratable();
			return false;
		},
		get loading() {
			populate_hydratable();
			return true;
		},
		get ready() {
			populate_hydratable();
			return false;
		},
		get connected() {
			populate_hydratable();
			return false;
		},
		reconnect() {
			promise = null;
			delete get_cache(__, state)[payload];
			refresh(event, state, __, payload, get_promise);
			return Promise.resolve();
		},
		/** @ts-expect-error This method no longer exists */
		run() {
			throw new Error("`.run()` has been removed from live queries. Use `for await (const value of liveQuery())` instead.");
		},
		/** @type {Promise<any>['then']} */
		then(onfulfilled, onrejected) {
			return get_promise().then(onfulfilled, onrejected);
		},
		[Symbol.asyncIterator]() {
			const key = create_remote_key(__.id, payload);
			const cache = state.remote.live_iterators ??= /* @__PURE__ */ new Map();
			let cached = cache.get(key);
			if (!cached) {
				cached = create_shared_live_iterator(event.request.signal, get_generator);
				cache.set(key, cached);
			}
			return cached.subscribe();
		},
		get [Symbol.toStringTag]() {
			return "LiveQueryResource";
		}
	};
}
/**
* Wraps a lazily-created live-query generator so that multiple `for await`
* consumers within the same request share one underlying iteration. The first
* subscriber starts the generator; values are broadcast to all subscribers
* via a `SharedIterator`. When the last subscriber unsubscribes, the generator
* is closed via `generator.return(undefined)`.
*
* If `signal` aborts (typically because the client has disconnected), the
* pump is torn down and any in-flight `next()` calls on consumer iterators
* resolve with `{ done: true }`, so suspended `for await` loops unwind
* cleanly rather than leaking.
*
* @param {AbortSignal} signal
* @param {() => AsyncGenerator<any, void, void>} get_generator
*/
function create_shared_live_iterator(signal, get_generator) {
	return new SharedIterator((instance) => {
		if (signal.aborted) {
			instance.done();
			return noop;
		}
		const generator = get_generator();
		let aborted = false;
		const close = () => {
			aborted = true;
			generator.return().catch(noop);
		};
		signal.addEventListener("abort", () => (close(), instance.done()), { once: true });
		(async () => {
			try {
				while (true) {
					const result = await generator.next();
					if (result.done) {
						instance.done();
						return;
					}
					instance.push(result.value);
				}
			} catch (error) {
				if (!aborted) instance.fail(error);
			} finally {
				close();
			}
		})();
		return close;
	});
}
Object.defineProperty(query, "batch", {
	value: batch,
	enumerable: true
});
Object.defineProperty(query, "live", {
	value: live,
	enumerable: true
});
//#endregion
//#region ../node_modules/.pnpm/@sveltejs+kit@3.0.0-next.4_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.3_vite@8.0.16_831df308509456bf75377b19fdb5b8d4/node_modules/@sveltejs/kit/src/runtime/app/server/remote/requested.js
/** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestedResult, QueryRequestedResult, LiveQueryRequestedResult } from '@sveltejs/kit' */
/** @import { MaybePromise, RemoteAnyQueryInternals } from 'types' */
/**
* In the context of a remote `command` or `form` request, returns an iterable
* of `{ arg, query }` entries for the refreshes requested by the client, up to
* the supplied `limit`. Each `query` is a `RemoteQuery` bound to the original
* client-side cache key, so `refresh()` / `set()` propagate correctly even when
* the query's schema transforms the input. `arg` is the *validated* argument,
* i.e. the value after the schema has run (so `InferOutput<Schema>` for queries
* declared with a Standard Schema).
*
* Arguments that fail validation or exceed `limit` are recorded as failures in
* the response to the client.
*
* @example
* ```ts
* import { requested } from '$app/server';
*
* for (const { arg, query } of requested(getPost, 5)) {
* 	// `arg` is the validated argument; `query` is bound to the client's
* 	// cache key. It's safe to throw away this promise -- SvelteKit will
* 	// await it and forward any errors to the client.
* 	void query.refresh();
* }
* ```
*
* As a shorthand for the above, you can also call `refreshAll` on the result:
*
* @example
* ```ts
* import { requested } from '$app/server';
*
* await requested(getPost, 5).refreshAll();
* ```
*
* Works with `query.batch` as well — refreshes for individual entries are
* collected into a single batched call.
*
* For live queries, the same applies, but with `reconnect` and `reconnectAll`.
*
* @template Input
* @template Output
* @template [Validated=Input]
* @overload
* @param {RemoteQueryFunction<Input, Output, Validated>} query
* @param {number} limit
* @returns {QueryRequestedResult<Validated, Output>}
*/
/**
* In the context of a remote `command` or `form` request, returns an iterable
* of `{ arg, query }` entries for the reconnects requested by the client, up to
* the supplied `limit`. Each `query` is a `RemoteLiveQuery` bound to the original
* client-side cache key, so `reconnect()` propagates correctly even when
* the query's schema transforms the input. `arg` is the *validated* argument.
*
* Arguments that fail validation or exceed `limit` are recorded as failures in
* the response to the client.
*
* @example
* ```ts
* import { requested } from '$app/server';
*
* for (const { query } of requested(getPost, 5)) {
* 	void query.reconnect();
* }
* ```
*
* As a shorthand, you can also call `reconnectAll` on the result:
*
* @example
* ```ts
* import { requested } from '$app/server';
*
* await requested(getPost, 5).reconnectAll();
* ```
*
* @template Input
* @template Output
* @template [Validated=Input]
* @overload
* @param {RemoteLiveQueryFunction<Input, Output, Validated>} query
* @param {number} limit
* @returns {LiveQueryRequestedResult<Validated, Output>}
*/
/**
* @template Input
* @template Output
* @template [Validated=Input]
* @param {RemoteQueryFunction<Input, Output, Validated> | RemoteLiveQueryFunction<Input, Output, Validated>} query
* @param {number} limit
* @returns {RequestedResult<Validated, Output>}
*/
function requested(query, limit) {
	const { event, state } = get_request_store();
	const internals = query.__;
	if (internals?.type !== "query" && internals?.type !== "query_batch" && internals?.type !== "query_live") throw new Error("requested(...) expects a query function created with query(...), query.batch(...), or query.live(...)");
	const __ = internals;
	const payloads = state.remote.requested?.get(__.id) ?? [];
	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");
	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
	*/
	const record_failure = (payload, error) => {
		const promise = Promise.reject(error);
		promise.catch(noop);
		get_cache(__, state)[payload] = promise;
		refresh(event, state, __, payload, () => promise);
	};
	for (const payload of skipped) record_failure(payload, new HttpError(400, `Requested refresh was rejected because it exceeded requested(${__.name}, ${limit}) limit`));
	const result = {
		*[Symbol.iterator]() {
			for (const payload of selected) try {
				const parsed = parse_remote_arg(payload, state.transport);
				const validated = __.validate(parsed);
				if (is_thenable(validated)) throw new Error(`requested(${__.name}, ${limit}) cannot be used with synchronous iteration because the query validator is async. Use \`for await ... of\` instead`);
				yield {
					arg: validated,
					query: __.bind(payload, validated)
				};
			} catch (error) {
				record_failure(payload, error);
				continue;
			}
		},
		async *[Symbol.asyncIterator]() {
			yield* race_all(selected, async (payload) => {
				try {
					const parsed = parse_remote_arg(payload, state.transport);
					const validated = await __.validate(parsed);
					return {
						arg: validated,
						query: __.bind(payload, validated)
					};
				} catch (error) {
					record_failure(payload, error);
					throw new Error(`Skipping ${__.name}(${payload})`, { cause: error });
				}
			});
		},
		async refreshAll() {
			if (__.type === "query_live") throw new Error("refreshAll() is invalid for live queries. Use reconnectAll() instead.");
			for await (const { query } of result) query.refresh();
		},
		async reconnectAll() {
			if (__.type !== "query_live") throw new Error("reconnectAll() is invalid for regular queries. Use refreshAll() instead.");
			for await (const { query } of result) query.reconnect();
		}
	};
	return result;
}
/**
* @template T
* @param {Array<T>} array
* @param {number} limit
* @returns {[Array<T>, Array<T>]}
*/
function split_limit(array, limit) {
	if (limit === Infinity) return [array, []];
	if (!Number.isInteger(limit) || limit < 0) throw new Error("Limit must be a non-negative integer or Infinity");
	return [array.slice(0, limit), array.slice(limit)];
}
/**
* @param {any} value
* @returns {value is PromiseLike<any>}
*/
function is_thenable(value) {
	return !!value && (typeof value === "object" || typeof value === "function") && "then" in value;
}
/**
* Runs all callbacks immediately and yields resolved values in completion order.
* If the promise rejects, it is skipped.
*
* @template T
* @template R
* @param {Array<T>} array
* @param {(value: T) => MaybePromise<R>} fn
* @returns {AsyncIterable<R>}
*/
async function* race_all(array, fn) {
	/** @type {Set<Promise<{ promise: Promise<any>, value: Awaited<R> }>>} */
	const pending = /* @__PURE__ */ new Set();
	for (const value of array) {
		/** @type {Promise<{ promise: Promise<any>, value: Awaited<R> }>} */
		const promise = Promise.resolve(fn(value)).then((result) => ({
			promise,
			value: result
		}));
		promise.catch(() => pending.delete(promise));
		pending.add(promise);
	}
	while (pending.size > 0) try {
		const { promise, value } = await Promise.race(pending);
		pending.delete(promise);
		yield value;
	} catch {}
}
//#endregion
export { command, form, prerender, query, requested };