@fragno-dev/chatno 0.0.9 → 0.0.11

package/dist/browser/src-DdjU_SuS.js

@@ -1,1525 +0,0 @@
-import { createFragment, defineFragment, defineRoute, defineRoutes } from "@fragno-dev/core";
-import { z } from "zod";
-import { atom, batched, computed, map, onStart, onStop, startTask, task } from "nanostores";
-import OpenAI from "openai";
-
-//#region ../../packages/fragno/dist/api-DngJDcmO.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-B4RbOWjd.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$1 = [];
-	for (const item of routesOrFactories) if (typeof item === "function") {
-		const factoryRoutes = item(context);
-		routes$1.push(...factoryRoutes);
-	} else routes$1.push(item);
-	return routes$1;
-}
-
-//#endregion
-//#region ../../packages/fragno/dist/ssr-CamRrMc0.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-D5ORmjBP.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(fragmentBuilder, publicConfig, routesOrFactories) {
-	const definition = fragmentBuilder.definition;
-	const routes$1 = resolveRouteFactories({
-		config: {},
-		deps: {},
-		services: {}
-	}, routesOrFactories);
-	const fragmentConfig = {
-		name: definition.name,
-		routes: routes$1
-	};
-	const mountRoute = publicConfig.mountRoute ?? `/${definition.name}`;
-	return new ClientBuilder({
-		...publicConfig,
-		mountRoute
-	}, fragmentConfig);
-}
-
-//#endregion
-//#region src/server/chatno-api.ts
-const ChatMessageSchema = z.object({
-	type: z.literal("chat"),
-	id: z.string(),
-	role: z.enum(["user", "assistant"]),
-	content: z.string()
-});
-const FunctionCallMessageSchema = z.object({
-	type: z.literal("functionCall"),
-	id: z.string(),
-	functionCallId: z.string(),
-	name: z.string(),
-	arguments: z.string()
-});
-const FunctionCallOutputMessageSchema = z.object({
-	type: z.literal("functionCallOutput"),
-	id: z.string(),
-	functionCallId: z.string(),
-	output: z.string(),
-	status: z.enum([
-		"inProgress",
-		"completed",
-		"incomplete"
-	])
-});
-const InputMessageSchema = z.discriminatedUnion("type", [
-	ChatMessageSchema,
-	FunctionCallMessageSchema,
-	FunctionCallOutputMessageSchema
-]);
-const ChatStreamRequestSchema = z.object({ messages: z.array(InputMessageSchema) });
-const ResponseTextDeltaEventSchema = z.object({
-	type: z.literal("response.output_text.delta"),
-	content_index: z.number(),
-	delta: z.string(),
-	item_id: z.string(),
-	output_index: z.number(),
-	sequence_number: z.number()
-});
-const ResponseTextDoneEventSchema = z.object({
-	type: z.literal("response.output_text.done"),
-	content_index: z.number(),
-	item_id: z.string(),
-	output_index: z.number(),
-	sequence_number: z.number(),
-	text: z.string()
-});
-const ResponseEventSchema = z.discriminatedUnion("type", [ResponseTextDeltaEventSchema, ResponseTextDoneEventSchema]);
-const chatRouteFactory = defineRoutes().create(({ config, deps }) => {
-	return [defineRoute({
-		method: "POST",
-		path: "/chat/stream",
-		inputSchema: ChatStreamRequestSchema,
-		outputSchema: z.array(ResponseEventSchema),
-		handler: () => {}
-	})];
-});
-
-//#endregion
-//#region src/index.ts
-const healthRoute = defineRoute({
-	method: "GET",
-	path: "/health",
-	outputSchema: z.object({ status: z.literal("ok") }),
-	handler: () => {}
-});
-const simpleStreamRoute = defineRoute({
-	method: "GET",
-	path: "/simple-stream",
-	outputSchema: z.array(z.object({ message: z.string() })),
-	handler: () => {}
-});
-const DEFAULT_SYSTEM_PROMPT = `You are an AI assistant integrated into a dashboard.`;
-const chatnoDefinition = defineFragment("chatno").withDependencies(() => {}).withServices(() => {});
-const routes = [
-	chatRouteFactory,
-	healthRoute,
-	simpleStreamRoute
-];
-function createChatno(chatnoConfig, fragnoConfig = {}) {
-	const config = {
-		model: chatnoConfig.model ?? "gpt-5-nano",
-		systemPrompt: chatnoConfig.systemPrompt ?? DEFAULT_SYSTEM_PROMPT
-	};
-	return createFragment(chatnoDefinition, {
-		...chatnoConfig,
-		...config
-	}, routes, fragnoConfig);
-}
-function createChatnoClients(fragnoConfig) {
-	const cb = createClientBuilder(chatnoDefinition, fragnoConfig, routes);
-	const chatStream = cb.createMutator("POST", "/chat/stream");
-	const aggregatedMessage = computed(chatStream.mutatorStore, ({ data }) => {
-		return (data ?? []).filter((item) => item.type === "response.output_text.delta").map((item) => item.delta).join("");
-	});
-	function sendMessage(message) {
-		chatStream.mutatorStore.mutate({ body: { messages: [{
-			type: "chat",
-			id: crypto.randomUUID(),
-			role: "user",
-			content: message
-		}] } });
-	}
-	return { useSendMessage: cb.createStore({
-		response: aggregatedMessage,
-		responseLoading: computed(chatStream.mutatorStore, ({ loading }) => loading),
-		sendMessage
-	}) };
-}
-
-//#endregion
-export { isReadableAtom as a, isMutatorHook as i, createChatnoClients as n, isStore as o, isGetHook as r, createChatno as t };
-//# sourceMappingURL=src-DdjU_SuS.js.map