@fragno-dev/example-fragment 0.0.6 → 0.0.7

package/dist/browser/src-Bg_r9_li.js

@@ -0,0 +1,1700 @@
+import { createFragment, defineFragment, defineRoute, defineRoutes } from "@fragno-dev/core";
+import { z } from "zod";
+
+//#region ../../packages/fragno/dist/api-DuzjjCT4.js
+var FragnoApiError = class extends Error {
+	#status;
+	#code;
+	constructor({ message, code }, status) {
+		super(message);
+		this.name = "FragnoApiError";
+		this.#status = status;
+		this.#code = code;
+	}
+	get status() {
+		return this.#status;
+	}
+	get code() {
+		return this.#code;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+var FragnoApiValidationError = class extends FragnoApiError {
+	#issues;
+	constructor(message, issues) {
+		super({
+			message,
+			code: "FRAGNO_VALIDATION_ERROR"
+		}, 400);
+		this.name = "FragnoApiValidationError";
+		this.#issues = issues;
+	}
+	get issues() {
+		return this.#issues;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			issues: this.#issues,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+
+//#endregion
+//#region ../../packages/fragno/dist/route-Dq62lXqB.js
+function getMountRoute(opts) {
+	const mountRoute = opts.mountRoute ?? `/api/${opts.name}`;
+	if (mountRoute.endsWith("/")) return mountRoute.slice(0, -1);
+	return mountRoute;
+}
+var RequestInputContext = class RequestInputContext$1 {
+	#path;
+	#method;
+	#pathParams;
+	#searchParams;
+	#body;
+	#inputSchema;
+	#shouldValidateInput;
+	constructor(config) {
+		this.#path = config.path;
+		this.#method = config.method;
+		this.#pathParams = config.pathParams;
+		this.#searchParams = config.searchParams;
+		this.#body = config.body;
+		this.#inputSchema = config.inputSchema;
+		this.#shouldValidateInput = config.shouldValidateInput ?? true;
+	}
+	/**
+	* Create a RequestContext from a Request object for server-side handling
+	*/
+	static async fromRequest(config) {
+		const url = new URL(config.request.url);
+		const request = config.request.clone();
+		const json = request.body instanceof ReadableStream ? await request.json() : void 0;
+		return new RequestInputContext$1({
+			method: config.method,
+			path: config.path,
+			pathParams: config.pathParams,
+			searchParams: url.searchParams,
+			body: json,
+			inputSchema: config.inputSchema,
+			shouldValidateInput: config.shouldValidateInput
+		});
+	}
+	/**
+	* Create a RequestContext for server-side rendering contexts (no Request object)
+	*/
+	static fromSSRContext(config) {
+		return new RequestInputContext$1({
+			method: config.method,
+			path: config.path,
+			pathParams: config.pathParams,
+			searchParams: config.searchParams ?? new URLSearchParams(),
+			body: "body" in config ? config.body : void 0,
+			inputSchema: "inputSchema" in config ? config.inputSchema : void 0,
+			shouldValidateInput: false
+		});
+	}
+	/**
+	* The HTTP method as string (e.g., `GET`, `POST`)
+	*/
+	get method() {
+		return this.#method;
+	}
+	/**
+	* The matched route path (e.g., `/users/:id`)
+	* @remarks `string`
+	*/
+	get path() {
+		return this.#path;
+	}
+	/**
+	* Extracted path parameters as object (e.g., `{ id: '123' }`)
+	* @remarks `Record<string, string>`
+	*/
+	get pathParams() {
+		return this.#pathParams;
+	}
+	/**
+	* [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+	* @remarks `URLSearchParams`
+	*/
+	get query() {
+		return this.#searchParams;
+	}
+	/**
+	* @internal
+	*/
+	get rawBody() {
+		return this.#body;
+	}
+	/**
+	* Input validation context (only if inputSchema is defined)
+	* @remarks `InputContext`
+	*/
+	get input() {
+		if (!this.#inputSchema) return;
+		return {
+			schema: this.#inputSchema,
+			valid: async () => {
+				if (!this.#shouldValidateInput) return this.#body;
+				return this.#validateInput();
+			}
+		};
+	}
+	async #validateInput() {
+		if (!this.#inputSchema) throw new Error("No input schema defined for this route");
+		if (this.#body instanceof FormData || this.#body instanceof Blob) throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
+		const result = await this.#inputSchema["~standard"].validate(this.#body);
+		if (result.issues) throw new FragnoApiValidationError("Validation failed", result.issues);
+		return result.value;
+	}
+};
+var ResponseStream = class {
+	#writer;
+	#encoder;
+	#abortSubscribers = [];
+	#responseReadable;
+	#aborted = false;
+	#closed = false;
+	/**
+	* Whether the stream has been aborted.
+	*/
+	get aborted() {
+		return this.#aborted;
+	}
+	/**
+	* Whether the stream has been closed normally.
+	*/
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* The readable stream that the response is piped to.
+	*/
+	get responseReadable() {
+		return this.#responseReadable;
+	}
+	constructor(writable, readable) {
+		this.#writer = writable.getWriter();
+		this.#encoder = new TextEncoder();
+		const reader = readable.getReader();
+		this.#abortSubscribers.push(async () => {
+			await reader.cancel();
+		});
+		this.#responseReadable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			},
+			cancel: () => {
+				this.abort();
+			}
+		});
+	}
+	async writeRaw(input) {
+		try {
+			if (typeof input === "string") input = this.#encoder.encode(input);
+			await this.#writer.write(input);
+		} catch {}
+	}
+	write(input) {
+		return this.writeRaw(JSON.stringify(input) + "\n");
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async close() {
+		try {
+			await this.#writer.close();
+		} catch {} finally {
+			this.#closed = true;
+		}
+	}
+	onAbort(listener) {
+		this.#abortSubscribers.push(listener);
+	}
+	/**
+	* Abort the stream.
+	* You can call this method when stream is aborted by external event.
+	*/
+	abort() {
+		if (!this.aborted) {
+			this.#aborted = true;
+			this.#abortSubscribers.forEach((subscriber) => subscriber());
+		}
+	}
+};
+/**
+* Utility function to merge headers from multiple sources.
+* Later headers override earlier ones.
+*/
+function mergeHeaders(...headerSources) {
+	const mergedHeaders = new Headers();
+	for (const headerSource of headerSources) {
+		if (!headerSource) continue;
+		if (headerSource instanceof Headers) for (const [key, value] of headerSource.entries()) mergedHeaders.set(key, value);
+		else if (Array.isArray(headerSource)) for (const [key, value] of headerSource) mergedHeaders.set(key, value);
+		else for (const [key, value] of Object.entries(headerSource)) mergedHeaders.set(key, value);
+	}
+	return mergedHeaders;
+}
+var OutputContext = class {
+	/**
+	* Creates an error response.
+	*
+	* Shortcut for `throw new FragnoApiError(...)`
+	*/
+	error({ message, code }, initOrStatus, headers) {
+		if (typeof initOrStatus === "undefined") return Response.json({
+			message,
+			code
+		}, {
+			status: 500,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders(initOrStatus.headers, headers);
+		return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	}
+	empty(initOrStatus, headers) {
+		const defaultHeaders = {};
+		if (typeof initOrStatus === "undefined") {
+			const mergedHeaders$1 = mergeHeaders(defaultHeaders, headers);
+			return Response.json(null, {
+				status: 201,
+				headers: mergedHeaders$1
+			});
+		}
+		if (typeof initOrStatus === "number") {
+			const mergedHeaders$1 = mergeHeaders(defaultHeaders, headers);
+			return Response.json(null, {
+				status: initOrStatus,
+				headers: mergedHeaders$1
+			});
+		}
+		const mergedHeaders = mergeHeaders(defaultHeaders, initOrStatus.headers, headers);
+		return Response.json(null, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	}
+	json(object, initOrStatus, headers) {
+		if (typeof initOrStatus === "undefined") return Response.json(object, {
+			status: 200,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json(object, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders(initOrStatus.headers, headers);
+		return Response.json(object, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	}
+	jsonStream = (cb, { onError, headers } = {}) => {
+		const defaultHeaders = {
+			"content-type": "application/x-ndjson; charset=utf-8",
+			"transfer-encoding": "chunked",
+			"cache-control": "no-cache"
+		};
+		const { readable, writable } = new TransformStream();
+		const stream = new ResponseStream(writable, readable);
+		(async () => {
+			try {
+				await cb(stream);
+			} catch (e) {
+				if (e === void 0) {} else if (e instanceof Error && onError) await onError(e, stream);
+				else console.error(e);
+			} finally {
+				stream.close();
+			}
+		})();
+		return new Response(stream.responseReadable, {
+			status: 200,
+			headers: mergeHeaders(defaultHeaders, headers)
+		});
+	};
+};
+var RequestOutputContext = class extends OutputContext {
+	#outputSchema;
+	constructor(outputSchema) {
+		super();
+		this.#outputSchema = outputSchema;
+	}
+};
+function resolveRouteFactories(context, routesOrFactories) {
+	const routes = [];
+	for (const item of routesOrFactories) if (typeof item === "function") {
+		const factoryRoutes = item(context);
+		routes.push(...factoryRoutes);
+	} else routes.push(item);
+	return routes;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/task/index.js
+let tasks = 0;
+let resolves = [];
+function startTask() {
+	tasks += 1;
+	return () => {
+		tasks -= 1;
+		if (tasks === 0) {
+			let prevResolves = resolves;
+			resolves = [];
+			for (let i of prevResolves) i();
+		}
+	};
+}
+function task(cb) {
+	let endTask = startTask();
+	let promise = cb().finally(endTask);
+	promise.t = true;
+	return promise;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/clean-stores/index.js
+let clean = Symbol("clean");
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/atom/index.js
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+let epoch = 0;
+let atom = (initialValue) => {
+	let listeners = [];
+	let $atom = {
+		get() {
+			if (!$atom.lc) $atom.listen(() => {})();
+			return $atom.value;
+		},
+		lc: 0,
+		listen(listener) {
+			$atom.lc = listeners.push(listener);
+			return () => {
+				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+				else i += QUEUE_ITEMS_PER_LISTENER;
+				let index = listeners.indexOf(listener);
+				if (~index) {
+					listeners.splice(index, 1);
+					if (!--$atom.lc) $atom.off();
+				}
+			};
+		},
+		notify(oldValue, changedKey) {
+			epoch++;
+			let runListenerQueue = !listenerQueue.length;
+			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
+			if (runListenerQueue) {
+				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
+				listenerQueue.length = 0;
+			}
+		},
+		off() {},
+		set(newValue) {
+			let oldValue = $atom.value;
+			if (oldValue !== newValue) {
+				$atom.value = newValue;
+				$atom.notify(oldValue);
+			}
+		},
+		subscribe(listener) {
+			let unbind = $atom.listen(listener);
+			listener($atom.value);
+			return unbind;
+		},
+		value: initialValue
+	};
+	$atom[clean] = () => {
+		listeners = [];
+		$atom.lc = 0;
+		$atom.off();
+	};
+	return $atom;
+};
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/lifecycle/index.js
+const START = 0;
+const STOP = 1;
+const MOUNT = 5;
+const UNMOUNT = 6;
+const REVERT_MUTATION = 10;
+let on = (object, listener, eventKey, mutateStore) => {
+	object.events = object.events || {};
+	if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
+		object.events[eventKey].reduceRight((event, l) => (l(event), event), {
+			shared: {},
+			...eventProps
+		});
+	});
+	object.events[eventKey] = object.events[eventKey] || [];
+	object.events[eventKey].push(listener);
+	return () => {
+		let currentListeners = object.events[eventKey];
+		let index = currentListeners.indexOf(listener);
+		currentListeners.splice(index, 1);
+		if (!currentListeners.length) {
+			delete object.events[eventKey];
+			object.events[eventKey + REVERT_MUTATION]();
+			delete object.events[eventKey + REVERT_MUTATION];
+		}
+	};
+};
+let onStart = ($store, listener) => on($store, listener, START, (runListeners) => {
+	let originListen = $store.listen;
+	$store.listen = (arg) => {
+		if (!$store.lc && !$store.starting) {
+			$store.starting = true;
+			runListeners();
+			delete $store.starting;
+		}
+		return originListen(arg);
+	};
+	return () => {
+		$store.listen = originListen;
+	};
+});
+let onStop = ($store, listener) => on($store, listener, STOP, (runListeners) => {
+	let originOff = $store.off;
+	$store.off = () => {
+		runListeners();
+		originOff();
+	};
+	return () => {
+		$store.off = originOff;
+	};
+});
+let STORE_UNMOUNT_DELAY = 1e3;
+let onMount = ($store, initialize) => {
+	let listener = (payload) => {
+		let destroy = initialize(payload);
+		if (destroy) $store.events[UNMOUNT].push(destroy);
+	};
+	return on($store, listener, MOUNT, (runListeners) => {
+		let originListen = $store.listen;
+		$store.listen = (...args) => {
+			if (!$store.lc && !$store.active) {
+				$store.active = true;
+				runListeners();
+			}
+			return originListen(...args);
+		};
+		let originOff = $store.off;
+		$store.events[UNMOUNT] = [];
+		$store.off = () => {
+			originOff();
+			setTimeout(() => {
+				if ($store.active && !$store.lc) {
+					$store.active = false;
+					for (let destroy of $store.events[UNMOUNT]) destroy();
+					$store.events[UNMOUNT] = [];
+				}
+			}, STORE_UNMOUNT_DELAY);
+		};
+		{
+			let originClean = $store[clean];
+			$store[clean] = () => {
+				for (let destroy of $store.events[UNMOUNT]) destroy();
+				$store.events[UNMOUNT] = [];
+				$store.active = false;
+				originClean();
+			};
+		}
+		return () => {
+			$store.listen = originListen;
+			$store.off = originOff;
+		};
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/computed/index.js
+let computedStore = (stores$1, cb, batched$1) => {
+	if (!Array.isArray(stores$1)) stores$1 = [stores$1];
+	let previousArgs;
+	let currentEpoch;
+	let set = () => {
+		if (currentEpoch === epoch) return;
+		currentEpoch = epoch;
+		let args = stores$1.map(($store) => $store.get());
+		if (!previousArgs || args.some((arg, i) => arg !== previousArgs[i])) {
+			previousArgs = args;
+			let value = cb(...args);
+			if (value && value.then && value.t) value.then((asyncValue) => {
+				if (previousArgs === args) $computed.set(asyncValue);
+			});
+			else {
+				$computed.set(value);
+				currentEpoch = epoch;
+			}
+		}
+	};
+	let $computed = atom(void 0);
+	let get = $computed.get;
+	$computed.get = () => {
+		set();
+		return get();
+	};
+	let timer;
+	let run = batched$1 ? () => {
+		clearTimeout(timer);
+		timer = setTimeout(set);
+	} : set;
+	onMount($computed, () => {
+		let unbinds = stores$1.map(($store) => $store.listen(run));
+		set();
+		return () => {
+			for (let unbind of unbinds) unbind();
+		};
+	});
+	return $computed;
+};
+let batched = (stores$1, fn) => computedStore(stores$1, fn, true);
+
+//#endregion
+//#region ../../node_modules/.bun/nanostores@1.0.1/node_modules/nanostores/map/index.js
+let map = (initial = {}) => {
+	let $map = atom(initial);
+	$map.setKey = function(key, value) {
+		let oldMap = $map.value;
+		if (typeof value === "undefined" && key in $map.value) {
+			$map.value = { ...$map.value };
+			delete $map.value[key];
+			$map.notify(oldMap, key);
+		} else if ($map.value[key] !== value) {
+			$map.value = {
+				...$map.value,
+				[key]: value
+			};
+			$map.notify(oldMap, key);
+		}
+	};
+	return $map;
+};
+
+//#endregion
+//#region ../../packages/fragno/dist/ssr-BAhbA_3q.js
+let stores = [];
+const SSR_ENABLED = false;
+function addStore(store) {
+	stores.push(store);
+}
+let clientInitialData;
+function getInitialData(key) {
+	if (clientInitialData?.has(key)) {
+		const data = clientInitialData.get(key);
+		clientInitialData.delete(key);
+		return data;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.bun/nanoevents@9.1.0/node_modules/nanoevents/index.js
+let createNanoEvents = () => ({
+	emit(event, ...args) {
+		for (let callbacks = this.events[event] || [], i = 0, length = callbacks.length; i < length; i++) callbacks[i](...args);
+	},
+	events: {},
+	on(event, cb) {
+		(this.events[event] ||= []).push(cb);
+		return () => {
+			this.events[event] = this.events[event]?.filter((i) => cb !== i);
+		};
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@nanostores+query@0.3.4+e0f9796391ddf78a/node_modules/@nanostores/query/dist/nanoquery.js
+function defaultOnErrorRetry({ retryCount }) {
+	return ~~((Math.random() + .5) * (1 << (retryCount < 8 ? retryCount : 8))) * 2e3;
+}
+const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectChangeSubscribe]) => {
+	const nanoquery$1 = ({ cache = /* @__PURE__ */ new Map(), fetcher: globalFetcher,...globalSettings } = {}) => {
+		const events = createNanoEvents();
+		let focus = true;
+		visibilityChangeSubscribe(() => {
+			focus = isAppVisible();
+			focus && events.emit(FOCUS);
+		});
+		reconnectChangeSubscribe(() => events.emit(RECONNECT));
+		const _revalidateOnInterval = /* @__PURE__ */ new Map(), _errorInvalidateTimeouts = /* @__PURE__ */ new Map(), _runningFetches = /* @__PURE__ */ new Map();
+		let rewrittenSettings = {};
+		const getCachedValueByKey = (key) => {
+			const fromCache = cache.get(key);
+			if (!fromCache) return [];
+			return (fromCache.expires || 0) > getNow() ? [fromCache.data, fromCache.error] : [];
+		};
+		const runFetcher = async ([key, keyParts], store, settings) => {
+			if (!focus) return;
+			const set = (v) => {
+				if (store.key === key) {
+					store.set(v);
+					events.emit(SET_CACHE, key, v, true);
+				}
+			};
+			const setAsLoading = (prev) => {
+				set({
+					...prev === void 0 ? {} : { data: prev },
+					...loading,
+					promise: _runningFetches.get(key)
+				});
+			};
+			let { dedupeTime = 4e3, cacheLifetime = Infinity, fetcher, onErrorRetry = defaultOnErrorRetry } = {
+				...settings,
+				...rewrittenSettings
+			};
+			if (cacheLifetime < dedupeTime) cacheLifetime = dedupeTime;
+			const now = getNow();
+			if (_runningFetches.has(key)) {
+				if (!store.value.loading) setAsLoading(getCachedValueByKey(key)[0]);
+				return;
+			}
+			let cachedValue, cachedError;
+			const fromCache = cache.get(key);
+			if (fromCache?.data !== void 0 || fromCache?.error) {
+				[cachedValue, cachedError] = getCachedValueByKey(key);
+				if ((fromCache.created || 0) + dedupeTime > now) {
+					if (store.value.data != cachedValue || store.value.error != cachedError) set({
+						...notLoading,
+						data: cachedValue,
+						error: cachedError
+					});
+					return;
+				}
+			}
+			const finishTask = startTask();
+			try {
+				clearTimeout(_errorInvalidateTimeouts.get(key));
+				const promise = fetcher(...keyParts);
+				_runningFetches.set(key, promise);
+				setAsLoading(cachedValue);
+				const res = await promise;
+				cache.set(key, {
+					data: res,
+					created: getNow(),
+					expires: getNow() + cacheLifetime
+				});
+				set({
+					data: res,
+					...notLoading
+				});
+			} catch (error) {
+				settings.onError?.(error);
+				const retryCount = (cache.get(key)?.retryCount || 0) + 1;
+				cache.set(key, {
+					error,
+					created: getNow(),
+					expires: getNow() + cacheLifetime,
+					retryCount
+				});
+				if (onErrorRetry) {
+					const timer = onErrorRetry({
+						error,
+						key,
+						retryCount
+					});
+					if (timer) _errorInvalidateTimeouts.set(key, setTimeout(() => {
+						invalidateKeys(key);
+						cache.set(key, { retryCount });
+					}, timer));
+				}
+				set({
+					data: store.value.data,
+					error,
+					...notLoading
+				});
+			} finally {
+				finishTask();
+				_runningFetches.delete(key);
+			}
+		};
+		const createFetcherStore = (keyInput, { fetcher = globalFetcher,...fetcherSettings } = {}) => {
+			if (!fetcher) throw new Error("You need to set up either global fetcher of fetcher in createFetcherStore");
+			const fetcherStore = map({ ...notLoading }), settings = {
+				...globalSettings,
+				...fetcherSettings,
+				fetcher
+			};
+			fetcherStore._ = fetcherSymbol;
+			fetcherStore.invalidate = () => {
+				const { key } = fetcherStore;
+				if (key) invalidateKeys(key);
+			};
+			fetcherStore.revalidate = () => {
+				const { key } = fetcherStore;
+				if (key) revalidateKeys(key);
+			};
+			fetcherStore.mutate = (data) => {
+				const { key } = fetcherStore;
+				if (key) mutateCache(key, data);
+			};
+			fetcherStore.fetch = async () => {
+				let resolve;
+				const promise = new Promise((r) => resolve = r);
+				const unsub = fetcherStore.listen(({ error, data }) => {
+					if (error !== void 0) resolve({ error });
+					if (data !== void 0) resolve({ data });
+				});
+				return promise.finally(unsub);
+			};
+			let keysInternalUnsub, prevKey, prevKeyParts, keyUnsub, keyStore;
+			let evtUnsubs = [];
+			onStart(fetcherStore, () => {
+				const firstRun = !keysInternalUnsub;
+				[keyStore, keysInternalUnsub] = getKeyStore(keyInput);
+				keyUnsub = keyStore.subscribe((currentKeys) => {
+					if (currentKeys) {
+						const [newKey, keyParts] = currentKeys;
+						fetcherStore.key = newKey;
+						runFetcher([newKey, keyParts], fetcherStore, settings);
+						prevKey = newKey;
+						prevKeyParts = keyParts;
+					} else {
+						fetcherStore.key = prevKey = prevKeyParts = void 0;
+						fetcherStore.set({ ...notLoading });
+					}
+				});
+				const currentKeyValue = keyStore.get();
+				if (currentKeyValue) {
+					[prevKey, prevKeyParts] = currentKeyValue;
+					if (firstRun) handleNewListener();
+				}
+				const { revalidateInterval = 0, revalidateOnFocus, revalidateOnReconnect } = settings;
+				const runRefetcher = () => {
+					if (prevKey) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+				};
+				if (revalidateInterval > 0) _revalidateOnInterval.set(keyInput, setInterval(runRefetcher, revalidateInterval));
+				if (revalidateOnFocus) evtUnsubs.push(events.on(FOCUS, runRefetcher));
+				if (revalidateOnReconnect) evtUnsubs.push(events.on(RECONNECT, runRefetcher));
+				const cacheKeyChangeHandler = (keySelector) => {
+					if (prevKey && testKeyAgainstSelector(prevKey, keySelector)) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+				};
+				evtUnsubs.push(events.on(INVALIDATE_KEYS, cacheKeyChangeHandler), events.on(REVALIDATE_KEYS, cacheKeyChangeHandler), events.on(SET_CACHE, (keySelector, data, full) => {
+					if (prevKey && testKeyAgainstSelector(prevKey, keySelector) && fetcherStore.value !== data && fetcherStore.value.data !== data) fetcherStore.set(full ? data : {
+						data,
+						...notLoading
+					});
+				}));
+			});
+			const handleNewListener = () => {
+				if (prevKey && prevKeyParts) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+			};
+			const originListen = fetcherStore.listen;
+			fetcherStore.listen = (listener) => {
+				const unsub = originListen(listener);
+				listener(fetcherStore.value);
+				handleNewListener();
+				return unsub;
+			};
+			onStop(fetcherStore, () => {
+				fetcherStore.value = { ...notLoading };
+				keysInternalUnsub?.();
+				evtUnsubs.forEach((fn) => fn());
+				evtUnsubs = [];
+				keyUnsub?.();
+				clearInterval(_revalidateOnInterval.get(keyInput));
+			});
+			return fetcherStore;
+		};
+		const iterOverCache = (keySelector, cb) => {
+			for (const key of cache.keys()) if (testKeyAgainstSelector(key, keySelector)) cb(key);
+		};
+		const invalidateKeys = (keySelector) => {
+			iterOverCache(keySelector, (key) => {
+				cache.delete(key);
+			});
+			events.emit(INVALIDATE_KEYS, keySelector);
+		};
+		const revalidateKeys = (keySelector) => {
+			iterOverCache(keySelector, (key) => {
+				const cached = cache.get(key);
+				if (cached) cache.set(key, {
+					...cached,
+					created: -Infinity
+				});
+			});
+			events.emit(REVALIDATE_KEYS, keySelector);
+		};
+		const mutateCache = (keySelector, data) => {
+			iterOverCache(keySelector, (key) => {
+				if (data === void 0) cache.delete(key);
+				else cache.set(key, {
+					data,
+					created: getNow(),
+					expires: getNow() + (globalSettings.cacheLifetime ?? 8e3)
+				});
+			});
+			events.emit(SET_CACHE, keySelector, data);
+		};
+		function createMutatorStore(mutator, opts) {
+			const { throttleCalls, onError } = opts ?? {
+				throttleCalls: true,
+				onError: globalSettings?.onError
+			};
+			const mutate = async (data) => {
+				if (throttleCalls && store.value?.loading) return;
+				const newMutator = rewrittenSettings.fetcher ?? mutator;
+				const keysToInvalidate = [], keysToRevalidate = [];
+				const safeKeySet = (k, v) => {
+					if (store.lc) store.setKey(k, v);
+				};
+				try {
+					store.set({
+						error: void 0,
+						data: void 0,
+						mutate,
+						...loading
+					});
+					const result = await newMutator({
+						data,
+						invalidate: (key) => {
+							keysToInvalidate.push(key);
+						},
+						revalidate: (key) => {
+							keysToRevalidate.push(key);
+						},
+						getCacheUpdater: (key, shouldRevalidate = true) => [(newVal) => {
+							mutateCache(key, newVal);
+							if (shouldRevalidate) keysToRevalidate.push(key);
+						}, cache.get(key)?.data]
+					});
+					safeKeySet("data", result);
+					return result;
+				} catch (error) {
+					onError?.(error);
+					safeKeySet("error", error);
+					store.setKey("error", error);
+				} finally {
+					safeKeySet("loading", false);
+					keysToInvalidate.forEach(invalidateKeys);
+					keysToRevalidate.forEach(revalidateKeys);
+				}
+			};
+			const store = map({
+				mutate,
+				...notLoading
+			});
+			onStop(store, () => store.set({
+				mutate,
+				...notLoading
+			}));
+			store.mutate = mutate;
+			return store;
+		}
+		const __unsafeOverruleSettings = (data) => {
+			console.warn(`You should only use __unsafeOverruleSettings in test environment`);
+			rewrittenSettings = data;
+		};
+		return [
+			createFetcherStore,
+			createMutatorStore,
+			{
+				__unsafeOverruleSettings,
+				invalidateKeys,
+				revalidateKeys,
+				mutateCache
+			}
+		];
+	};
+	function isSomeKey(key) {
+		return typeof key === "string" || typeof key === "number" || key === true;
+	}
+	const getKeyStore = (keys) => {
+		if (isSomeKey(keys)) return [atom(["" + keys, [keys]]), () => {}];
+		const keyParts = [];
+		const $key = atom(null);
+		const keysAsStoresToIndexes = /* @__PURE__ */ new Map();
+		const setKeyStoreValue = () => {
+			if (keyParts.some((v) => v === null || v === void 0 || v === false)) $key.set(null);
+			else $key.set([keyParts.join(""), keyParts]);
+		};
+		for (let i = 0; i < keys.length; i++) {
+			const keyOrStore = keys[i];
+			if (isSomeKey(keyOrStore)) keyParts.push(keyOrStore);
+			else {
+				keyParts.push(null);
+				keysAsStoresToIndexes.set(keyOrStore, i);
+			}
+		}
+		const storesAsArray = [...keysAsStoresToIndexes.keys()];
+		const $storeKeys = batched(storesAsArray, (...storeValues) => {
+			for (let i = 0; i < storeValues.length; i++) {
+				const store = storesAsArray[i], partIndex = keysAsStoresToIndexes.get(store);
+				keyParts[partIndex] = store._ === fetcherSymbol ? store.value && "data" in store.value ? store.key : null : storeValues[i];
+			}
+			setKeyStoreValue();
+		});
+		setKeyStoreValue();
+		return [$key, $storeKeys.subscribe(noop)];
+	};
+	function noop() {}
+	const FOCUS = 1, RECONNECT = 2, INVALIDATE_KEYS = 3, REVALIDATE_KEYS = 4, SET_CACHE = 5;
+	const testKeyAgainstSelector = (key, selector) => {
+		if (Array.isArray(selector)) return selector.includes(key);
+		else if (typeof selector === "function") return selector(key);
+		else return key === selector;
+	};
+	const getNow = () => (/* @__PURE__ */ new Date()).getTime();
+	const fetcherSymbol = Symbol();
+	const loading = { loading: true }, notLoading = { loading: false };
+	return nanoquery$1;
+};
+const subscribe = (name, fn) => {
+	if (!(typeof window === "undefined")) addEventListener(name, fn);
+};
+const nanoquery = nanoqueryFactory([
+	() => !document.hidden,
+	(cb) => subscribe("visibilitychange", cb),
+	(cb) => subscribe("online", cb)
+]);
+
+//#endregion
+//#region ../../packages/fragno/dist/client-C_Oc8hpD.js
+/**
+* Extract parameter names from a path pattern at runtime.
+* Examples:
+* - "/users/:id" => ["id"]
+* - "/files/**" => ["**"]
+* - "/files/**:rest" => ["rest"]
+*/
+function extractPathParams(pathPattern) {
+	const segments = pathPattern.split("/").filter((s) => s.length > 0);
+	const names = [];
+	for (const segment of segments) {
+		if (segment.startsWith(":")) {
+			names.push(segment.slice(1));
+			continue;
+		}
+		if (segment === "**") {
+			names.push("**");
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			names.push(segment.slice(3));
+			continue;
+		}
+	}
+	return names;
+}
+/**
+* Build a concrete path by replacing placeholders in a path pattern with values.
+*
+* Supports the same placeholder syntax as the matcher:
+* - Named parameter ":name" is URL-encoded as a single segment
+* - Anonymous wildcard "**" inserts the remainder as-is (slashes preserved)
+* - Named wildcard "**:name" inserts the remainder from the named key
+*
+* Examples:
+* - buildPath("/users/:id", { id: "123" }) => "/users/123"
+* - buildPath("/files/**", { "**": "a/b" }) => "/files/a/b"
+* - buildPath("/files/**:rest", { rest: "a/b" }) => "/files/a/b"
+*/
+function buildPath(pathPattern, params) {
+	const patternSegments = pathPattern.split("/");
+	const builtSegments = [];
+	for (const segment of patternSegments) {
+		if (segment.length === 0) {
+			builtSegments.push("");
+			continue;
+		}
+		if (segment.startsWith(":")) {
+			const name = segment.slice(1);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path parameter :${name}`);
+			builtSegments.push(encodeURIComponent(value));
+			continue;
+		}
+		if (segment === "**") {
+			const value = params["**"];
+			if (value === void 0) throw new Error("Missing value for path wildcard **");
+			builtSegments.push(value);
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			const name = segment.slice(3);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path wildcard **:${name}`);
+			builtSegments.push(value);
+			continue;
+		}
+		builtSegments.push(segment);
+	}
+	return builtSegments.join("/");
+}
+/**
+* Base error class for all Fragno client errors.
+*/
+var FragnoClientError = class extends Error {
+	#code;
+	constructor(message, code, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "FragnoClientError";
+		this.#code = code;
+	}
+	get code() {
+		return this.#code;
+	}
+};
+var FragnoClientFetchError = class extends FragnoClientError {
+	constructor(message, code, options = {}) {
+		super(message, code, options);
+		this.name = "FragnoClientFetchError";
+	}
+	static fromUnknownFetchError(error) {
+		if (!(error instanceof Error)) return new FragnoClientFetchNetworkError("Network request failed", { cause: error });
+		if (error.name === "AbortError") return new FragnoClientFetchAbortError("Request was aborted", { cause: error });
+		return new FragnoClientFetchNetworkError("Network request failed", { cause: error });
+	}
+};
+/**
+* Error thrown when a network request fails (e.g., no internet connection, DNS failure).
+*/
+var FragnoClientFetchNetworkError = class extends FragnoClientFetchError {
+	constructor(message = "Network request failed", options = {}) {
+		super(message, "NETWORK_ERROR", options);
+		this.name = "FragnoClientFetchNetworkError";
+	}
+};
+/**
+* Error thrown when a request is aborted (e.g., user cancels request, timeout).
+*/
+var FragnoClientFetchAbortError = class extends FragnoClientFetchError {
+	constructor(message = "Request was aborted", options = {}) {
+		super(message, "ABORT_ERROR", options);
+		this.name = "FragnoClientFetchAbortError";
+	}
+};
+/**
+* Error thrown when the API result is unexpected, e.g. no json is returned.
+*/
+var FragnoClientUnknownApiError = class extends FragnoClientError {
+	#status;
+	constructor(message = "Unknown API error", status, options = {}) {
+		super(message, "UNKNOWN_API_ERROR", options);
+		this.name = "FragnoClientUnknownApiError";
+		this.#status = status;
+	}
+	get status() {
+		return this.#status;
+	}
+};
+var FragnoClientApiError = class FragnoClientApiError$1 extends FragnoClientError {
+	#status;
+	constructor({ message, code }, status, options = {}) {
+		super(message, code, options);
+		this.name = "FragnoClientApiError";
+		this.#status = status;
+	}
+	get status() {
+		return this.#status;
+	}
+	/**
+	* The error code returned by the API.
+	*
+	* The type is `TErrorCode` (the set of known error codes for this route), but may also be a string
+	* for forward compatibility with future error codes.
+	*/
+	get code() {
+		return super.code;
+	}
+	static async fromResponse(response) {
+		const unknown = await response.json();
+		const status = response.status;
+		if (!("message" in unknown || "code" in unknown)) return new FragnoClientUnknownApiError("Unknown API error", status);
+		if (!(typeof unknown.message === "string" && typeof unknown.code === "string")) return new FragnoClientUnknownApiError("Unknown API error", status);
+		return new FragnoClientApiError$1({
+			message: unknown.message,
+			code: unknown.code
+		}, status);
+	}
+};
+/**
+* Parses a content-type header string into its components
+*
+* @param contentType - The content-type header value to parse
+* @returns A ParsedContentType object or null if the input is invalid
+*
+* @example
+* ```ts
+* const { type, subtype, mediaType, parameters }
+*        = parseContentType("application/json; charset=utf-8");
+* console.assert(type === "application");
+* console.assert(subtype === "json");
+* console.assert(mediaType === "application/json");
+* console.assert(parameters["charset"] === "utf-8");
+*/
+function parseContentType(contentType) {
+	if (!contentType || typeof contentType !== "string") return null;
+	const trimmed = contentType.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(";").map((part) => part.trim());
+	const mediaType = parts[0];
+	if (!mediaType) return null;
+	const typeParts = mediaType.split("/");
+	if (typeParts.length !== 2) return null;
+	const [type, subtype] = typeParts.map((part) => part.trim().toLowerCase());
+	if (!type || !subtype) return null;
+	const parameters = {};
+	for (let i = 1; i < parts.length; i++) {
+		const param = parts[i];
+		const equalIndex = param.indexOf("=");
+		if (equalIndex > 0) {
+			const key = param.slice(0, equalIndex).trim().toLowerCase();
+			let value = param.slice(equalIndex + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+			if (key) parameters[key] = value;
+		}
+	}
+	return {
+		type,
+		subtype,
+		mediaType: `${type}/${subtype}`,
+		parameters
+	};
+}
+/**
+* Creates a promise that rejects when the abort signal is triggered
+*/
+function createAbortPromise(abortSignal) {
+	return new Promise((_, reject) => {
+		const abortHandler = () => {
+			reject(new FragnoClientFetchAbortError("Operation was aborted"));
+		};
+		if (abortSignal.aborted) abortHandler();
+		else abortSignal.addEventListener("abort", abortHandler, { once: true });
+	});
+}
+/**
+* Handles NDJSON streaming responses by returning the first item from the fetcher
+* and then continuing to stream updates via the store's mutate method.
+*
+* This makes it so that we can wait until the first chunk before updating the store, if we did
+* not do this, `loading` would briefly be false before the first item would be populated in the
+* result.
+*
+* @param response - The fetch Response object containing the NDJSON stream
+* @param store - The fetcher store to update with streaming data
+* @param abortSignal - Optional AbortSignal to cancel the streaming operation
+* @returns A promise that resolves to an object containing the first item and a streaming promise
+*/
+async function handleNdjsonStreamingFirstItem(response, store, options = {}) {
+	if (!response.body) throw new FragnoClientFetchError("Streaming response has no body", "NO_BODY");
+	const { abortSignal } = options;
+	if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+	const decoder = new TextDecoder();
+	const reader = response.body.getReader();
+	let buffer = "";
+	let firstItem = null;
+	const items = [];
+	try {
+		while (firstItem === null) {
+			if (abortSignal?.aborted) {
+				reader.releaseLock();
+				throw new FragnoClientFetchAbortError("Operation was aborted");
+			}
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const jsonObject = JSON.parse(line);
+					items.push(jsonObject);
+					if (firstItem === null) {
+						firstItem = jsonObject;
+						const streamingPromise = continueStreaming(reader, decoder, buffer, items, store, abortSignal);
+						return {
+							firstItem,
+							streamingPromise
+						};
+					}
+				} catch (parseError) {
+					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 500, { cause: parseError });
+				}
+			}
+		}
+		if (firstItem === null) {
+			reader.releaseLock();
+			throw new FragnoClientUnknownApiError("NDJSON stream contained no valid items", 500);
+		}
+		reader.releaseLock();
+		throw new FragnoClientFetchError("Unexpected end of stream processing", "NO_BODY");
+	} catch (error) {
+		if (error instanceof FragnoClientError) {
+			store?.setError(error);
+			throw error;
+		} else {
+			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 500, { cause: error });
+			store?.setError(clientError);
+			throw clientError;
+		}
+	}
+}
+/**
+* Continues streaming the remaining items in the background
+*/
+async function continueStreaming(reader, decoder, initialBuffer, items, store, abortSignal) {
+	let buffer = initialBuffer;
+	try {
+		while (true) {
+			if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) {
+				if (buffer.trim()) {
+					const lines$1 = buffer.split("\n");
+					for (const line of lines$1) {
+						if (!line.trim()) continue;
+						try {
+							const jsonObject = JSON.parse(line);
+							items.push(jsonObject);
+							store?.setData([...items]);
+						} catch (parseError) {
+							throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+						}
+					}
+				}
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const jsonObject = JSON.parse(line);
+					items.push(jsonObject);
+					store?.setData([...items]);
+				} catch (parseError) {
+					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+				}
+			}
+		}
+	} catch (error) {
+		if (error instanceof FragnoClientError) store?.setError(error);
+		else {
+			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 400, { cause: error });
+			store?.setError(clientError);
+			throw clientError;
+		}
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	return items;
+}
+/**
+* Normalizes a value that could be a plain value, an Atom, or a Vue Ref to a plain value.
+*/
+function unwrapAtom(value) {
+	if (value && typeof value === "object" && "get" in value && typeof value.get === "function") return value.get();
+	return value;
+}
+/**
+* Normalizes an object where values can be plain values, Atoms, or Vue Refs.
+* Returns a new object with all values normalized to plain values.
+*/
+function unwrapObject(params) {
+	if (!params) return;
+	return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, unwrapAtom(value)]));
+}
+function isReadableAtom(value) {
+	if (!value) return false;
+	if (typeof value !== "object" || value === null) return false;
+	if (!("get" in value) || typeof value.get !== "function") return false;
+	if (!("lc" in value) || typeof value.lc !== "number") return false;
+	if (!("notify" in value) || typeof value.notify !== "function") return false;
+	if (!("off" in value) || typeof value.off !== "function") return false;
+	if (!("subscribe" in value) || typeof value.subscribe !== "function") return false;
+	if (!("value" in value)) return false;
+	return true;
+}
+/**
+* Symbols used to identify hook types
+*/
+const GET_HOOK_SYMBOL = Symbol("fragno-get-hook");
+const MUTATOR_HOOK_SYMBOL = Symbol("fragno-mutator-hook");
+const STORE_SYMBOL = Symbol("fragno-store");
+function buildUrl(config, params) {
+	const { baseUrl = "", mountRoute, path } = config;
+	const { pathParams, queryParams } = params ?? {};
+	const normalizedPathParams = unwrapObject(pathParams);
+	const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+	const searchParams = new URLSearchParams(normalizedQueryParams);
+	return `${baseUrl}${mountRoute}${buildPath(path, normalizedPathParams ?? {})}${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+}
+/**
+* This method returns an array, which can be passed directly to nanostores.
+*
+* The returned array is always: path, pathParams (In order they appear in the path), queryParams (In alphabetical order)
+* Missing pathParams are replaced with "<missing>".
+* @param path
+* @param params
+* @returns
+*/
+function getCacheKey(method, path, params) {
+	if (!params) return [method, path];
+	const { pathParams, queryParams } = params;
+	const pathParamValues = extractPathParams(path).map((name) => pathParams?.[name] ?? "<missing>");
+	const queryParamValues = queryParams ? Object.keys(queryParams).sort().map((key) => queryParams[key]) : [];
+	return [
+		method,
+		path,
+		...pathParamValues,
+		...queryParamValues
+	];
+}
+function isStreamingResponse(response) {
+	const contentType = parseContentType(response.headers.get("content-type"));
+	if (!contentType) return false;
+	if (!(response.headers.get("transfer-encoding") === "chunked")) return false;
+	if (contentType.subtype === "octet-stream") return "octet-stream";
+	if (contentType.subtype === "x-ndjson") return "ndjson";
+	return false;
+}
+function isGetHook(hook) {
+	return typeof hook === "object" && hook !== null && GET_HOOK_SYMBOL in hook && hook[GET_HOOK_SYMBOL] === true;
+}
+function isMutatorHook(hook) {
+	return typeof hook === "object" && hook !== null && MUTATOR_HOOK_SYMBOL in hook && hook[MUTATOR_HOOK_SYMBOL] === true;
+}
+function isStore(obj) {
+	return typeof obj === "object" && obj !== null && STORE_SYMBOL in obj && obj[STORE_SYMBOL] === true;
+}
+var ClientBuilder = class {
+	#publicConfig;
+	#fragmentConfig;
+	#cache = /* @__PURE__ */ new Map();
+	#createFetcherStore;
+	#createMutatorStore;
+	#invalidateKeys;
+	constructor(publicConfig, fragmentConfig) {
+		this.#publicConfig = publicConfig;
+		this.#fragmentConfig = fragmentConfig;
+		const [createFetcherStore, createMutatorStore, { invalidateKeys }] = nanoquery({ cache: this.#cache });
+		this.#createFetcherStore = createFetcherStore;
+		this.#createMutatorStore = createMutatorStore;
+		this.#invalidateKeys = invalidateKeys;
+	}
+	get cacheEntries() {
+		return Object.fromEntries(this.#cache.entries());
+	}
+	createStore(obj) {
+		return {
+			obj,
+			[STORE_SYMBOL]: true
+		};
+	}
+	createHook(path, options) {
+		const route = this.#fragmentConfig.routes.find((r) => r.path === path && r.method === "GET" && r.outputSchema !== void 0);
+		if (!route) throw new Error(`Route '${path}' not found or is not a GET route with an output schema.`);
+		return this.#createRouteQueryHook(route, options);
+	}
+	createMutator(method, path, onInvalidate) {
+		const route = this.#fragmentConfig.routes.find((r) => r.method !== "GET" && r.path === path && r.method === method);
+		if (!route) throw new Error(`Route '${path}' not found or is a GET route with an input and output schema.`);
+		return this.#createRouteQueryMutator(route, onInvalidate);
+	}
+	#createRouteQueryHook(route, options = {}) {
+		if (route.method !== "GET") throw new Error(`Only GET routes are supported for hooks. Route '${route.path}' is a ${route.method} route.`);
+		if (!route.outputSchema) throw new Error(`Output schema is required for GET routes. Route '${route.path}' has no output schema.`);
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		async function callServerSideHandler(params) {
+			const { pathParams, queryParams } = params ?? {};
+			const normalizedPathParams = unwrapObject(pathParams);
+			const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+			const searchParams = new URLSearchParams(normalizedQueryParams);
+			return await route.handler(RequestInputContext.fromSSRContext({
+				method: route.method,
+				path: route.path,
+				pathParams: normalizedPathParams,
+				searchParams
+			}), new RequestOutputContext(route.outputSchema));
+		}
+		async function executeQuery(params) {
+			const { pathParams, queryParams } = params ?? {};
+			if (typeof window === "undefined") return task(async () => callServerSideHandler({
+				pathParams,
+				queryParams
+			}));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams,
+				queryParams
+			});
+			let response;
+			try {
+				response = await fetch(url);
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		return {
+			route,
+			store: (args) => {
+				const { path, query } = args ?? {};
+				const key = getCacheKey(route.method, route.path, {
+					pathParams: path,
+					queryParams: query
+				});
+				const store = this.#createFetcherStore(key, {
+					fetcher: async () => {
+						if (SSR_ENABLED) {
+							const initialData = getInitialData(key.map((d) => typeof d === "string" ? d : d.get()).join(""));
+							if (initialData) return initialData;
+						}
+						const response = await executeQuery({
+							pathParams: path,
+							queryParams: query
+						});
+						const isStreaming = isStreamingResponse(response);
+						if (!isStreaming) return response.json();
+						if (typeof window === "undefined") return [];
+						if (isStreaming === "ndjson") {
+							const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+								setData: (value) => {
+									store.set({
+										...store.get(),
+										loading: !(Array.isArray(value) && value.length > 0),
+										data: value
+									});
+								},
+								setError: (value) => {
+									store.set({
+										...store.get(),
+										error: value
+									});
+								}
+							});
+							return [firstItem];
+						}
+						if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+						throw new Error("Unreachable");
+					},
+					onErrorRetry: options?.onErrorRetry,
+					dedupeTime: Infinity
+				});
+				if (typeof window === "undefined") addStore(store);
+				return store;
+			},
+			query: async (args) => {
+				const { path, query } = args ?? {};
+				const response = await executeQuery({
+					pathParams: path,
+					queryParams: query
+				});
+				const isStreaming = isStreamingResponse(response);
+				if (!isStreaming) return await response.json();
+				if (isStreaming === "ndjson") {
+					const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+					return await streamingPromise;
+				}
+				if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+				throw new Error("Unreachable");
+			},
+			[GET_HOOK_SYMBOL]: true
+		};
+	}
+	#createRouteQueryMutator(route, onInvalidate = (invalidate, params) => invalidate("GET", route.path, params)) {
+		const method = route.method;
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		async function executeMutateQuery({ body, path, query }) {
+			if (typeof window === "undefined") return task(async () => route.handler(RequestInputContext.fromSSRContext({
+				inputSchema: route.inputSchema,
+				method,
+				path: route.path,
+				pathParams: path ?? {},
+				searchParams: new URLSearchParams(query),
+				body
+			}), new RequestOutputContext(route.outputSchema)));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams: path,
+				queryParams: query
+			});
+			let response;
+			try {
+				response = await fetch(url, {
+					method,
+					body: body !== void 0 ? JSON.stringify(body) : void 0
+				});
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		const mutatorStore = this.#createMutatorStore(async ({ data }) => {
+			if (typeof window === "undefined") {}
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required.");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			onInvalidate(this.#invalidate.bind(this), {
+				pathParams: path ?? {},
+				queryParams: query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (typeof window === "undefined") return [];
+			if (isStreaming === "ndjson") {
+				const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+					setData: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							loading: !(Array.isArray(value) && value.length > 0),
+							data: value
+						});
+					},
+					setError: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							error: value
+						});
+					}
+				});
+				return [firstItem];
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+			throw new Error("Unreachable");
+		}, { onError: (error) => {
+			console.error("Error in mutatorStore", error);
+		} });
+		const mutateQuery = async (data) => {
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required for mutateQuery");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (isStreaming === "ndjson") {
+				const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+				return await streamingPromise;
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported for mutations");
+			throw new Error("Unreachable");
+		};
+		return {
+			route,
+			mutateQuery,
+			mutatorStore,
+			[MUTATOR_HOOK_SYMBOL]: true
+		};
+	}
+	#invalidate(method, path, params) {
+		const prefix = getCacheKey(method, path, {
+			pathParams: params?.pathParams,
+			queryParams: params?.queryParams
+		}).map((k) => typeof k === "string" ? k : k.get()).join("");
+		this.#invalidateKeys((key) => key.startsWith(prefix));
+	}
+};
+function createClientBuilder(fragmentDefinition, publicConfig, routesOrFactories) {
+	const definition = fragmentDefinition.definition;
+	const routes = resolveRouteFactories({
+		config: {},
+		deps: {},
+		services: {}
+	}, routesOrFactories);
+	const fragmentConfig = {
+		name: definition.name,
+		routes
+	};
+	const mountRoute = publicConfig.mountRoute ?? `/${definition.name}`;
+	return new ClientBuilder({
+		...publicConfig,
+		mountRoute
+	}, fragmentConfig);
+}
+
+//#endregion
+//#region src/index.ts
+const exampleRoutesFactory = defineRoutes().create(({ deps }) => {
+	return [
+		defineRoute({
+			method: "GET",
+			path: "/hash",
+			outputSchema: z.string(),
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/data",
+			outputSchema: z.string(),
+			queryParameters: ["error"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/sample",
+			inputSchema: z.object({ message: z.string() }),
+			outputSchema: z.string(),
+			errorCodes: ["MESSAGE_CANNOT_BE_DIGITS_ONLY"],
+			handler: () => {}
+		})
+	];
+});
+const exampleFragmentDefinition = defineFragment("example-fragment").withDependencies(() => {}).withServices(() => {});
+function createExampleFragment(serverConfig = {}, fragnoConfig = {}) {
+	const config = { initialData: serverConfig.initialData ?? "Hello World! This is a server-side data." };
+	return createFragment(exampleFragmentDefinition, {
+		...serverConfig,
+		...config
+	}, [exampleRoutesFactory], fragnoConfig);
+}
+function createExampleFragmentClients(fragnoConfig) {
+	const b = createClientBuilder(exampleFragmentDefinition, fragnoConfig, [exampleRoutesFactory]);
+	return {
+		useHash: b.createHook("/hash"),
+		useData: b.createHook("/data"),
+		useSampleMutator: b.createMutator("POST", "/sample")
+	};
+}
+
+//#endregion
+export { isReadableAtom as a, isMutatorHook as i, createExampleFragmentClients as n, isStore as o, isGetHook as r, atom as s, createExampleFragment as t };
+//# sourceMappingURL=src-Bg_r9_li.js.map